LLVM API Documentation
00001 //===- TableGen'erated file -------------------------------------*- C++ -*-===// 00002 // 00003 // DAG Instruction Selector for the X86 target 00004 // 00005 // Automatically generated file, do not edit! 00006 // 00007 //===----------------------------------------------------------------------===// 00008 00009 // *** NOTE: This file is #included into the middle of the target 00010 // *** instruction selector class. These functions are really methods. 00011 00012 // Include standard, target-independent definitions and methods used 00013 // by the instruction selector. 00014 #include "llvm/CodeGen/DAGISelHeader.h" 00015 00016 00017 // Node transformations. 00018 inline SDValue Transform_MMX_SHUFFLE_get_shuf_imm(SDNode *N) { 00019 00020 return getI8Imm(X86::getShuffleSHUFImmediate(N)); 00021 00022 } 00023 inline SDValue Transform_PSxLDQ_imm(SDNode *inN) { 00024 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00025 00026 // Transformation function: imm >> 3 00027 return getI32Imm(N->getZExtValue() >> 3); 00028 00029 } 00030 inline SDValue Transform_SHUFFLE_get_pshufhw_imm(SDNode *N) { 00031 00032 return getI8Imm(X86::getShufflePSHUFHWImmediate(N)); 00033 00034 } 00035 inline SDValue Transform_SHUFFLE_get_pshuflw_imm(SDNode *N) { 00036 00037 return getI8Imm(X86::getShufflePSHUFLWImmediate(N)); 00038 00039 } 00040 inline SDValue Transform_SHUFFLE_get_shuf_imm(SDNode *N) { 00041 00042 return getI8Imm(X86::getShuffleSHUFImmediate(N)); 00043 00044 } 00045 00046 // Predicate functions. 00047 inline bool Predicate_alignedload(SDNode *N) { 00048 00049 return cast<LoadSDNode>(N)->getAlignment() >= 16; 00050 00051 } 00052 inline bool Predicate_alignedstore(SDNode *N) { 00053 00054 return cast<StoreSDNode>(N)->getAlignment() >= 16; 00055 00056 } 00057 inline bool Predicate_and_su(SDNode *N) { 00058 00059 return N->hasOneUse(); 00060 00061 } 00062 inline bool Predicate_atomic_cmp_swap_16(SDNode *N) { 00063 00064 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16; 00065 00066 } 00067 inline bool Predicate_atomic_cmp_swap_32(SDNode *N) { 00068 00069 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32; 00070 00071 } 00072 inline bool Predicate_atomic_cmp_swap_64(SDNode *N) { 00073 00074 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64; 00075 00076 } 00077 inline bool Predicate_atomic_cmp_swap_8(SDNode *N) { 00078 00079 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8; 00080 00081 } 00082 inline bool Predicate_atomic_load_add_16(SDNode *N) { 00083 00084 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16; 00085 00086 } 00087 inline bool Predicate_atomic_load_add_32(SDNode *N) { 00088 00089 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32; 00090 00091 } 00092 inline bool Predicate_atomic_load_add_64(SDNode *N) { 00093 00094 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64; 00095 00096 } 00097 inline bool Predicate_atomic_load_add_8(SDNode *N) { 00098 00099 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8; 00100 00101 } 00102 inline bool Predicate_atomic_load_and_16(SDNode *N) { 00103 00104 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16; 00105 00106 } 00107 inline bool Predicate_atomic_load_and_32(SDNode *N) { 00108 00109 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32; 00110 00111 } 00112 inline bool Predicate_atomic_load_and_64(SDNode *N) { 00113 00114 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64; 00115 00116 } 00117 inline bool Predicate_atomic_load_and_8(SDNode *N) { 00118 00119 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8; 00120 00121 } 00122 inline bool Predicate_atomic_load_max_16(SDNode *N) { 00123 00124 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16; 00125 00126 } 00127 inline bool Predicate_atomic_load_max_32(SDNode *N) { 00128 00129 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32; 00130 00131 } 00132 inline bool Predicate_atomic_load_max_64(SDNode *N) { 00133 00134 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64; 00135 00136 } 00137 inline bool Predicate_atomic_load_max_8(SDNode *N) { 00138 00139 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8; 00140 00141 } 00142 inline bool Predicate_atomic_load_min_16(SDNode *N) { 00143 00144 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16; 00145 00146 } 00147 inline bool Predicate_atomic_load_min_32(SDNode *N) { 00148 00149 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32; 00150 00151 } 00152 inline bool Predicate_atomic_load_min_64(SDNode *N) { 00153 00154 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64; 00155 00156 } 00157 inline bool Predicate_atomic_load_min_8(SDNode *N) { 00158 00159 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8; 00160 00161 } 00162 inline bool Predicate_atomic_load_nand_16(SDNode *N) { 00163 00164 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16; 00165 00166 } 00167 inline bool Predicate_atomic_load_nand_32(SDNode *N) { 00168 00169 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32; 00170 00171 } 00172 inline bool Predicate_atomic_load_nand_64(SDNode *N) { 00173 00174 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64; 00175 00176 } 00177 inline bool Predicate_atomic_load_nand_8(SDNode *N) { 00178 00179 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8; 00180 00181 } 00182 inline bool Predicate_atomic_load_or_16(SDNode *N) { 00183 00184 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16; 00185 00186 } 00187 inline bool Predicate_atomic_load_or_32(SDNode *N) { 00188 00189 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32; 00190 00191 } 00192 inline bool Predicate_atomic_load_or_64(SDNode *N) { 00193 00194 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64; 00195 00196 } 00197 inline bool Predicate_atomic_load_or_8(SDNode *N) { 00198 00199 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8; 00200 00201 } 00202 inline bool Predicate_atomic_load_sub_16(SDNode *N) { 00203 00204 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16; 00205 00206 } 00207 inline bool Predicate_atomic_load_sub_32(SDNode *N) { 00208 00209 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32; 00210 00211 } 00212 inline bool Predicate_atomic_load_sub_64(SDNode *N) { 00213 00214 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64; 00215 00216 } 00217 inline bool Predicate_atomic_load_sub_8(SDNode *N) { 00218 00219 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8; 00220 00221 } 00222 inline bool Predicate_atomic_load_umax_16(SDNode *N) { 00223 00224 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16; 00225 00226 } 00227 inline bool Predicate_atomic_load_umax_32(SDNode *N) { 00228 00229 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32; 00230 00231 } 00232 inline bool Predicate_atomic_load_umax_64(SDNode *N) { 00233 00234 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64; 00235 00236 } 00237 inline bool Predicate_atomic_load_umax_8(SDNode *N) { 00238 00239 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8; 00240 00241 } 00242 inline bool Predicate_atomic_load_umin_16(SDNode *N) { 00243 00244 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16; 00245 00246 } 00247 inline bool Predicate_atomic_load_umin_32(SDNode *N) { 00248 00249 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32; 00250 00251 } 00252 inline bool Predicate_atomic_load_umin_64(SDNode *N) { 00253 00254 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64; 00255 00256 } 00257 inline bool Predicate_atomic_load_umin_8(SDNode *N) { 00258 00259 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8; 00260 00261 } 00262 inline bool Predicate_atomic_load_xor_16(SDNode *N) { 00263 00264 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16; 00265 00266 } 00267 inline bool Predicate_atomic_load_xor_32(SDNode *N) { 00268 00269 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32; 00270 00271 } 00272 inline bool Predicate_atomic_load_xor_64(SDNode *N) { 00273 00274 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64; 00275 00276 } 00277 inline bool Predicate_atomic_load_xor_8(SDNode *N) { 00278 00279 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8; 00280 00281 } 00282 inline bool Predicate_atomic_swap_16(SDNode *N) { 00283 00284 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16; 00285 00286 } 00287 inline bool Predicate_atomic_swap_32(SDNode *N) { 00288 00289 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32; 00290 00291 } 00292 inline bool Predicate_atomic_swap_64(SDNode *N) { 00293 00294 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64; 00295 00296 } 00297 inline bool Predicate_atomic_swap_8(SDNode *N) { 00298 00299 return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8; 00300 00301 } 00302 inline bool Predicate_cvtff(SDNode *N) { 00303 00304 return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_FF; 00305 00306 } 00307 inline bool Predicate_cvtfs(SDNode *N) { 00308 00309 return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_FS; 00310 00311 } 00312 inline bool Predicate_cvtfu(SDNode *N) { 00313 00314 return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_FU; 00315 00316 } 00317 inline bool Predicate_cvtsf(SDNode *N) { 00318 00319 return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_SF; 00320 00321 } 00322 inline bool Predicate_cvtss(SDNode *N) { 00323 00324 return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_SS; 00325 00326 } 00327 inline bool Predicate_cvtsu(SDNode *N) { 00328 00329 return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_SU; 00330 00331 } 00332 inline bool Predicate_cvtuf(SDNode *N) { 00333 00334 return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_UF; 00335 00336 } 00337 inline bool Predicate_cvtus(SDNode *N) { 00338 00339 return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_US; 00340 00341 } 00342 inline bool Predicate_cvtuu(SDNode *N) { 00343 00344 return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_UU; 00345 00346 } 00347 inline bool Predicate_def32(SDNode *N) { 00348 00349 return N->getOpcode() != ISD::TRUNCATE && 00350 N->getOpcode() != TargetInstrInfo::EXTRACT_SUBREG && 00351 N->getOpcode() != ISD::CopyFromReg && 00352 N->getOpcode() != X86ISD::CMOV; 00353 00354 } 00355 inline bool Predicate_extload(SDNode *N) { 00356 00357 return cast<LoadSDNode>(N)->getExtensionType() == ISD::EXTLOAD; 00358 00359 } 00360 inline bool Predicate_extloadf32(SDNode *N) { 00361 00362 return cast<LoadSDNode>(N)->getMemoryVT() == MVT::f32; 00363 00364 } 00365 inline bool Predicate_extloadf64(SDNode *N) { 00366 00367 return cast<LoadSDNode>(N)->getMemoryVT() == MVT::f64; 00368 00369 } 00370 inline bool Predicate_extloadi1(SDNode *N) { 00371 00372 return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i1; 00373 00374 } 00375 inline bool Predicate_extloadi16(SDNode *N) { 00376 00377 return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i16; 00378 00379 } 00380 inline bool Predicate_extloadi32(SDNode *N) { 00381 00382 return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i32; 00383 00384 } 00385 inline bool Predicate_extloadi8(SDNode *N) { 00386 00387 return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i8; 00388 00389 } 00390 inline bool Predicate_fp32imm0(SDNode *inN) { 00391 ConstantFPSDNode *N = cast<ConstantFPSDNode>(inN); 00392 00393 return N->isExactlyValue(+0.0); 00394 00395 } 00396 inline bool Predicate_fpimm0(SDNode *inN) { 00397 ConstantFPSDNode *N = cast<ConstantFPSDNode>(inN); 00398 00399 return N->isExactlyValue(+0.0); 00400 00401 } 00402 inline bool Predicate_fpimm1(SDNode *inN) { 00403 ConstantFPSDNode *N = cast<ConstantFPSDNode>(inN); 00404 00405 return N->isExactlyValue(+1.0); 00406 00407 } 00408 inline bool Predicate_fpimmneg0(SDNode *inN) { 00409 ConstantFPSDNode *N = cast<ConstantFPSDNode>(inN); 00410 00411 return N->isExactlyValue(-0.0); 00412 00413 } 00414 inline bool Predicate_fpimmneg1(SDNode *inN) { 00415 ConstantFPSDNode *N = cast<ConstantFPSDNode>(inN); 00416 00417 return N->isExactlyValue(-1.0); 00418 00419 } 00420 inline bool Predicate_fsload(SDNode *N) { 00421 00422 if (const Value *Src = cast<LoadSDNode>(N)->getSrcValue()) 00423 if (const PointerType *PT = dyn_cast<PointerType>(Src->getType())) 00424 return PT->getAddressSpace() == 257; 00425 return false; 00426 00427 } 00428 inline bool Predicate_gsload(SDNode *N) { 00429 00430 if (const Value *Src = cast<LoadSDNode>(N)->getSrcValue()) 00431 if (const PointerType *PT = dyn_cast<PointerType>(Src->getType())) 00432 return PT->getAddressSpace() == 256; 00433 return false; 00434 00435 } 00436 inline bool Predicate_i16immSExt8(SDNode *inN) { 00437 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00438 00439 // i16immSExt8 predicate - True if the 16-bit immediate fits in a 8-bit 00440 // sign extended field. 00441 return (int16_t)N->getZExtValue() == (int8_t)N->getZExtValue(); 00442 00443 } 00444 inline bool Predicate_i32immSExt8(SDNode *inN) { 00445 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00446 00447 // i32immSExt8 predicate - True if the 32-bit immediate fits in a 8-bit 00448 // sign extended field. 00449 return (int32_t)N->getZExtValue() == (int8_t)N->getZExtValue(); 00450 00451 } 00452 inline bool Predicate_i64immSExt32(SDNode *inN) { 00453 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00454 00455 // i64immSExt32 predicate - True if the 64-bit immediate fits in a 32-bit 00456 // sign extended field. 00457 return (int64_t)N->getZExtValue() == (int32_t)N->getZExtValue(); 00458 00459 } 00460 inline bool Predicate_i64immSExt8(SDNode *inN) { 00461 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00462 00463 // i64immSExt8 predicate - True if the 64-bit immediate fits in a 8-bit 00464 // sign extended field. 00465 return (int64_t)N->getZExtValue() == (int8_t)N->getZExtValue(); 00466 00467 } 00468 inline bool Predicate_i64immZExt32(SDNode *inN) { 00469 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00470 00471 // i64immZExt32 predicate - True if the 64-bit immediate fits in a 32-bit 00472 // unsignedsign extended field. 00473 return (uint64_t)N->getZExtValue() == (uint32_t)N->getZExtValue(); 00474 00475 } 00476 inline bool Predicate_immAllOnes(SDNode *inN) { 00477 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00478 return N->isAllOnesValue(); 00479 } 00480 inline bool Predicate_immAllOnesV(SDNode *N) { 00481 00482 return ISD::isBuildVectorAllOnes(N); 00483 00484 } 00485 inline bool Predicate_immAllOnesV_bc(SDNode *N) { 00486 00487 return ISD::isBuildVectorAllOnes(N); 00488 00489 } 00490 inline bool Predicate_immAllZerosV(SDNode *N) { 00491 00492 return ISD::isBuildVectorAllZeros(N); 00493 00494 } 00495 inline bool Predicate_immAllZerosV_bc(SDNode *N) { 00496 00497 return ISD::isBuildVectorAllZeros(N); 00498 00499 } 00500 inline bool Predicate_istore(SDNode *N) { 00501 00502 return !cast<StoreSDNode>(N)->isTruncatingStore(); 00503 00504 } 00505 inline bool Predicate_itruncstore(SDNode *N) { 00506 00507 return cast<StoreSDNode>(N)->isTruncatingStore(); 00508 00509 } 00510 inline bool Predicate_load(SDNode *N) { 00511 00512 return cast<LoadSDNode>(N)->getExtensionType() == ISD::NON_EXTLOAD; 00513 00514 } 00515 inline bool Predicate_loadf32(SDNode *N) { 00516 00517 if (const Value *Src = cast<LoadSDNode>(N)->getSrcValue()) 00518 if (const PointerType *PT = dyn_cast<PointerType>(Src->getType())) 00519 if (PT->getAddressSpace() > 255) 00520 return false; 00521 return true; 00522 00523 } 00524 inline bool Predicate_loadf64(SDNode *N) { 00525 00526 if (const Value *Src = cast<LoadSDNode>(N)->getSrcValue()) 00527 if (const PointerType *PT = dyn_cast<PointerType>(Src->getType())) 00528 if (PT->getAddressSpace() > 255) 00529 return false; 00530 return true; 00531 00532 } 00533 inline bool Predicate_loadf80(SDNode *N) { 00534 00535 if (const Value *Src = cast<LoadSDNode>(N)->getSrcValue()) 00536 if (const PointerType *PT = dyn_cast<PointerType>(Src->getType())) 00537 if (PT->getAddressSpace() > 255) 00538 return false; 00539 return true; 00540 00541 } 00542 inline bool Predicate_loadi16(SDNode *N) { 00543 00544 LoadSDNode *LD = cast<LoadSDNode>(N); 00545 if (const Value *Src = LD->getSrcValue()) 00546 if (const PointerType *PT = dyn_cast<PointerType>(Src->getType())) 00547 if (PT->getAddressSpace() > 255) 00548 return false; 00549 ISD::LoadExtType ExtType = LD->getExtensionType(); 00550 if (ExtType == ISD::NON_EXTLOAD) 00551 return true; 00552 if (ExtType == ISD::EXTLOAD) 00553 return LD->getAlignment() >= 2 && !LD->isVolatile(); 00554 return false; 00555 00556 } 00557 inline bool Predicate_loadi16_anyext(SDNode *N) { 00558 00559 LoadSDNode *LD = cast<LoadSDNode>(N); 00560 if (const Value *Src = LD->getSrcValue()) 00561 if (const PointerType *PT = dyn_cast<PointerType>(Src->getType())) 00562 if (PT->getAddressSpace() > 255) 00563 return false; 00564 ISD::LoadExtType ExtType = LD->getExtensionType(); 00565 if (ExtType == ISD::EXTLOAD) 00566 return LD->getAlignment() >= 2 && !LD->isVolatile(); 00567 return false; 00568 00569 } 00570 inline bool Predicate_loadi32(SDNode *N) { 00571 00572 LoadSDNode *LD = cast<LoadSDNode>(N); 00573 if (const Value *Src = LD->getSrcValue()) 00574 if (const PointerType *PT = dyn_cast<PointerType>(Src->getType())) 00575 if (PT->getAddressSpace() > 255) 00576 return false; 00577 ISD::LoadExtType ExtType = LD->getExtensionType(); 00578 if (ExtType == ISD::NON_EXTLOAD) 00579 return true; 00580 if (ExtType == ISD::EXTLOAD) 00581 return LD->getAlignment() >= 4 && !LD->isVolatile(); 00582 return false; 00583 00584 } 00585 inline bool Predicate_loadi64(SDNode *N) { 00586 00587 if (const Value *Src = cast<LoadSDNode>(N)->getSrcValue()) 00588 if (const PointerType *PT = dyn_cast<PointerType>(Src->getType())) 00589 if (PT->getAddressSpace() > 255) 00590 return false; 00591 return true; 00592 00593 } 00594 inline bool Predicate_loadi8(SDNode *N) { 00595 00596 if (const Value *Src = cast<LoadSDNode>(N)->getSrcValue()) 00597 if (const PointerType *PT = dyn_cast<PointerType>(Src->getType())) 00598 if (PT->getAddressSpace() > 255) 00599 return false; 00600 return true; 00601 00602 } 00603 inline bool Predicate_memop(SDNode *N) { 00604 00605 return cast<LoadSDNode>(N)->getAlignment() >= 16; 00606 00607 } 00608 inline bool Predicate_memop64(SDNode *N) { 00609 00610 return cast<LoadSDNode>(N)->getAlignment() >= 8; 00611 00612 } 00613 inline bool Predicate_mmx_pshufw(SDNode *N) { 00614 00615 return X86::isPSHUFDMask(cast<ShuffleVectorSDNode>(N)); 00616 00617 } 00618 inline bool Predicate_mmx_unpckh(SDNode *N) { 00619 00620 return X86::isUNPCKHMask(cast<ShuffleVectorSDNode>(N)); 00621 00622 } 00623 inline bool Predicate_mmx_unpckh_undef(SDNode *N) { 00624 00625 return X86::isUNPCKH_v_undef_Mask(cast<ShuffleVectorSDNode>(N)); 00626 00627 } 00628 inline bool Predicate_mmx_unpckl(SDNode *N) { 00629 00630 return X86::isUNPCKLMask(cast<ShuffleVectorSDNode>(N)); 00631 00632 } 00633 inline bool Predicate_mmx_unpckl_undef(SDNode *N) { 00634 00635 return X86::isUNPCKL_v_undef_Mask(cast<ShuffleVectorSDNode>(N)); 00636 00637 } 00638 inline bool Predicate_movddup(SDNode *N) { 00639 00640 return X86::isMOVDDUPMask(cast<ShuffleVectorSDNode>(N)); 00641 00642 } 00643 inline bool Predicate_movhlps(SDNode *N) { 00644 00645 return X86::isMOVHLPSMask(cast<ShuffleVectorSDNode>(N)); 00646 00647 } 00648 inline bool Predicate_movhlps_undef(SDNode *N) { 00649 00650 return X86::isMOVHLPS_v_undef_Mask(cast<ShuffleVectorSDNode>(N)); 00651 00652 } 00653 inline bool Predicate_movhp(SDNode *N) { 00654 00655 return X86::isMOVHPMask(cast<ShuffleVectorSDNode>(N)); 00656 00657 } 00658 inline bool Predicate_movl(SDNode *N) { 00659 00660 return X86::isMOVLMask(cast<ShuffleVectorSDNode>(N)); 00661 00662 } 00663 inline bool Predicate_movlp(SDNode *N) { 00664 00665 return X86::isMOVLPMask(cast<ShuffleVectorSDNode>(N)); 00666 00667 } 00668 inline bool Predicate_movshdup(SDNode *N) { 00669 00670 return X86::isMOVSHDUPMask(cast<ShuffleVectorSDNode>(N)); 00671 00672 } 00673 inline bool Predicate_movsldup(SDNode *N) { 00674 00675 return X86::isMOVSLDUPMask(cast<ShuffleVectorSDNode>(N)); 00676 00677 } 00678 inline bool Predicate_nvloadi32(SDNode *N) { 00679 00680 LoadSDNode *LD = cast<LoadSDNode>(N); 00681 if (const Value *Src = LD->getSrcValue()) 00682 if (const PointerType *PT = dyn_cast<PointerType>(Src->getType())) 00683 if (PT->getAddressSpace() > 255) 00684 return false; 00685 if (LD->isVolatile()) 00686 return false; 00687 ISD::LoadExtType ExtType = LD->getExtensionType(); 00688 if (ExtType == ISD::NON_EXTLOAD) 00689 return true; 00690 if (ExtType == ISD::EXTLOAD) 00691 return LD->getAlignment() >= 4; 00692 return false; 00693 00694 } 00695 inline bool Predicate_post_store(SDNode *N) { 00696 00697 ISD::MemIndexedMode AM = cast<StoreSDNode>(N)->getAddressingMode(); 00698 return AM == ISD::POST_INC || AM == ISD::POST_DEC; 00699 00700 } 00701 inline bool Predicate_post_truncst(SDNode *N) { 00702 00703 ISD::MemIndexedMode AM = cast<StoreSDNode>(N)->getAddressingMode(); 00704 return AM == ISD::POST_INC || AM == ISD::POST_DEC; 00705 00706 } 00707 inline bool Predicate_post_truncstf32(SDNode *N) { 00708 00709 return cast<StoreSDNode>(N)->getMemoryVT() == MVT::f32; 00710 00711 } 00712 inline bool Predicate_post_truncsti1(SDNode *N) { 00713 00714 return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i1; 00715 00716 } 00717 inline bool Predicate_post_truncsti16(SDNode *N) { 00718 00719 return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i16; 00720 00721 } 00722 inline bool Predicate_post_truncsti32(SDNode *N) { 00723 00724 return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i32; 00725 00726 } 00727 inline bool Predicate_post_truncsti8(SDNode *N) { 00728 00729 return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i8; 00730 00731 } 00732 inline bool Predicate_pre_store(SDNode *N) { 00733 00734 ISD::MemIndexedMode AM = cast<StoreSDNode>(N)->getAddressingMode(); 00735 return AM == ISD::PRE_INC || AM == ISD::PRE_DEC; 00736 00737 } 00738 inline bool Predicate_pre_truncst(SDNode *N) { 00739 00740 ISD::MemIndexedMode AM = cast<StoreSDNode>(N)->getAddressingMode(); 00741 return AM == ISD::PRE_INC || AM == ISD::PRE_DEC; 00742 00743 } 00744 inline bool Predicate_pre_truncstf32(SDNode *N) { 00745 00746 return cast<StoreSDNode>(N)->getMemoryVT() == MVT::f32; 00747 00748 } 00749 inline bool Predicate_pre_truncsti1(SDNode *N) { 00750 00751 return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i1; 00752 00753 } 00754 inline bool Predicate_pre_truncsti16(SDNode *N) { 00755 00756 return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i16; 00757 00758 } 00759 inline bool Predicate_pre_truncsti32(SDNode *N) { 00760 00761 return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i32; 00762 00763 } 00764 inline bool Predicate_pre_truncsti8(SDNode *N) { 00765 00766 return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i8; 00767 00768 } 00769 inline bool Predicate_pshufd(SDNode *N) { 00770 00771 return X86::isPSHUFDMask(cast<ShuffleVectorSDNode>(N)); 00772 00773 } 00774 inline bool Predicate_pshufhw(SDNode *N) { 00775 00776 return X86::isPSHUFHWMask(cast<ShuffleVectorSDNode>(N)); 00777 00778 } 00779 inline bool Predicate_pshuflw(SDNode *N) { 00780 00781 return X86::isPSHUFLWMask(cast<ShuffleVectorSDNode>(N)); 00782 00783 } 00784 inline bool Predicate_sextload(SDNode *N) { 00785 00786 return cast<LoadSDNode>(N)->getExtensionType() == ISD::SEXTLOAD; 00787 00788 } 00789 inline bool Predicate_sextloadi1(SDNode *N) { 00790 00791 return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i1; 00792 00793 } 00794 inline bool Predicate_sextloadi16(SDNode *N) { 00795 00796 return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i16; 00797 00798 } 00799 inline bool Predicate_sextloadi32(SDNode *N) { 00800 00801 return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i32; 00802 00803 } 00804 inline bool Predicate_sextloadi8(SDNode *N) { 00805 00806 return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i8; 00807 00808 } 00809 inline bool Predicate_shld(SDNode *N) { 00810 00811 assert(N->getOpcode() == ISD::OR); 00812 return N->getOperand(0).getOpcode() == ISD::SHL && 00813 N->getOperand(1).getOpcode() == ISD::SRL && 00814 isa<ConstantSDNode>(N->getOperand(0).getOperand(1)) && 00815 isa<ConstantSDNode>(N->getOperand(1).getOperand(1)) && 00816 N->getOperand(0).getConstantOperandVal(1) == 00817 N->getValueSizeInBits(0) - N->getOperand(1).getConstantOperandVal(1); 00818 00819 } 00820 inline bool Predicate_shrd(SDNode *N) { 00821 00822 assert(N->getOpcode() == ISD::OR); 00823 return N->getOperand(0).getOpcode() == ISD::SRL && 00824 N->getOperand(1).getOpcode() == ISD::SHL && 00825 isa<ConstantSDNode>(N->getOperand(0).getOperand(1)) && 00826 isa<ConstantSDNode>(N->getOperand(1).getOperand(1)) && 00827 N->getOperand(0).getConstantOperandVal(1) == 00828 N->getValueSizeInBits(0) - N->getOperand(1).getConstantOperandVal(1); 00829 00830 } 00831 inline bool Predicate_shufp(SDNode *N) { 00832 00833 return X86::isSHUFPMask(cast<ShuffleVectorSDNode>(N)); 00834 00835 } 00836 inline bool Predicate_splat_lo(SDNode *N) { 00837 00838 ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N); 00839 return SVOp->isSplat() && SVOp->getSplatIndex() == 0; 00840 00841 } 00842 inline bool Predicate_srl_su(SDNode *N) { 00843 00844 return N->hasOneUse(); 00845 00846 } 00847 inline bool Predicate_store(SDNode *N) { 00848 00849 return !cast<StoreSDNode>(N)->isTruncatingStore(); 00850 00851 } 00852 inline bool Predicate_trunc_su(SDNode *N) { 00853 00854 return N->hasOneUse(); 00855 00856 } 00857 inline bool Predicate_truncstore(SDNode *N) { 00858 00859 return cast<StoreSDNode>(N)->isTruncatingStore(); 00860 00861 } 00862 inline bool Predicate_truncstoref32(SDNode *N) { 00863 00864 return cast<StoreSDNode>(N)->getMemoryVT() == MVT::f32; 00865 00866 } 00867 inline bool Predicate_truncstoref64(SDNode *N) { 00868 00869 return cast<StoreSDNode>(N)->getMemoryVT() == MVT::f64; 00870 00871 } 00872 inline bool Predicate_truncstorei16(SDNode *N) { 00873 00874 return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i16; 00875 00876 } 00877 inline bool Predicate_truncstorei32(SDNode *N) { 00878 00879 return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i32; 00880 00881 } 00882 inline bool Predicate_truncstorei8(SDNode *N) { 00883 00884 return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i8; 00885 00886 } 00887 inline bool Predicate_unindexedload(SDNode *N) { 00888 00889 return cast<LoadSDNode>(N)->getAddressingMode() == ISD::UNINDEXED; 00890 00891 } 00892 inline bool Predicate_unindexedstore(SDNode *N) { 00893 00894 return cast<StoreSDNode>(N)->getAddressingMode() == ISD::UNINDEXED; 00895 00896 } 00897 inline bool Predicate_unpckh(SDNode *N) { 00898 00899 return X86::isUNPCKHMask(cast<ShuffleVectorSDNode>(N)); 00900 00901 } 00902 inline bool Predicate_unpckh_undef(SDNode *N) { 00903 00904 return X86::isUNPCKH_v_undef_Mask(cast<ShuffleVectorSDNode>(N)); 00905 00906 } 00907 inline bool Predicate_unpckl(SDNode *N) { 00908 00909 return X86::isUNPCKLMask(cast<ShuffleVectorSDNode>(N)); 00910 00911 } 00912 inline bool Predicate_unpckl_undef(SDNode *N) { 00913 00914 return X86::isUNPCKL_v_undef_Mask(cast<ShuffleVectorSDNode>(N)); 00915 00916 } 00917 inline bool Predicate_vtFP(SDNode *inN) { 00918 VTSDNode *N = cast<VTSDNode>(inN); 00919 return N->getVT().isFloatingPoint(); 00920 } 00921 inline bool Predicate_vtInt(SDNode *inN) { 00922 VTSDNode *N = cast<VTSDNode>(inN); 00923 return N->getVT().isInteger(); 00924 } 00925 inline bool Predicate_zextload(SDNode *N) { 00926 00927 return cast<LoadSDNode>(N)->getExtensionType() == ISD::ZEXTLOAD; 00928 00929 } 00930 inline bool Predicate_zextloadi1(SDNode *N) { 00931 00932 return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i1; 00933 00934 } 00935 inline bool Predicate_zextloadi16(SDNode *N) { 00936 00937 return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i16; 00938 00939 } 00940 inline bool Predicate_zextloadi32(SDNode *N) { 00941 00942 return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i32; 00943 00944 } 00945 inline bool Predicate_zextloadi8(SDNode *N) { 00946 00947 return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i8; 00948 00949 } 00950 00951 00952 SDNode *Emit_0(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 00953 SDValue N0 = N.getOperand(0); 00954 SDValue N1 = N.getOperand(1); 00955 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::i32, N0); 00956 } 00957 SDNode *Emit_1(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 00958 SDValue N0 = N.getOperand(0); 00959 SDValue N1 = N.getOperand(1); 00960 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::i32, N0, N1); 00961 } 00962 SDNode *Emit_2(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 00963 SDValue N0 = N.getOperand(0); 00964 SDValue N1 = N.getOperand(1); 00965 SDValue Chain1 = N1.getOperand(0); 00966 SDValue N11 = N1.getOperand(1); 00967 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 00968 SDValue Ops0[] = { N0, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1 }; 00969 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::i32, MVT::Other, Ops0, 8); 00970 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 2)); 00971 return ResNode; 00972 } 00973 SDNode *Emit_3(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 00974 SDValue N0 = N.getOperand(0); 00975 SDValue N1 = N.getOperand(1); 00976 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i8); 00977 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::i32, N0, Tmp1); 00978 } 00979 SDNode *Emit_4(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 00980 SDValue N0 = N.getOperand(0); 00981 SDValue Chain0 = N0.getOperand(0); 00982 SDValue N01 = N0.getOperand(1); 00983 SDValue N1 = N.getOperand(1); 00984 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 00985 SDValue Ops0[] = { N1, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, LSI_N0, Chain0 }; 00986 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::i32, MVT::Other, Ops0, 8); 00987 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 2)); 00988 return ResNode; 00989 } 00990 SDNode *Select_ISD_ADD_i8(const SDValue &N) { 00991 if (OptLevel != CodeGenOpt::None) { 00992 SDValue N0 = N.getOperand(0); 00993 00994 // Pattern: (add:i8 GR8:i8:$src1, (ld:i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 00995 // Emits: (ADD8rm:i8 GR8:i8:$src1, addr:iPTR:$src2) 00996 // Pattern complexity = 25 cost = 1 size = 3 00997 { 00998 SDValue N1 = N.getOperand(1); 00999 if (N1.getOpcode() == ISD::LOAD && 01000 N1.hasOneUse() && 01001 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 01002 SDValue Chain1 = N1.getOperand(0); 01003 if (Predicate_unindexedload(N1.getNode()) && 01004 Predicate_load(N1.getNode())) { 01005 SDValue N11 = N1.getOperand(1); 01006 SDValue CPTmpN11_0; 01007 SDValue CPTmpN11_1; 01008 SDValue CPTmpN11_2; 01009 SDValue CPTmpN11_3; 01010 SDValue CPTmpN11_4; 01011 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 01012 SDNode *Result = Emit_2(N, X86::ADD8rm, MVT::i8, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 01013 return Result; 01014 } 01015 } 01016 } 01017 } 01018 01019 // Pattern: (add:i8 (ld:i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR8:i8:$src1) 01020 // Emits: (ADD8rm:i8 GR8:i8:$src1, addr:iPTR:$src2) 01021 // Pattern complexity = 25 cost = 1 size = 3 01022 if (N0.getOpcode() == ISD::LOAD && 01023 N0.hasOneUse() && 01024 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 01025 SDValue Chain0 = N0.getOperand(0); 01026 if (Predicate_unindexedload(N0.getNode()) && 01027 Predicate_load(N0.getNode())) { 01028 SDValue N01 = N0.getOperand(1); 01029 SDValue CPTmpN01_0; 01030 SDValue CPTmpN01_1; 01031 SDValue CPTmpN01_2; 01032 SDValue CPTmpN01_3; 01033 SDValue CPTmpN01_4; 01034 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 01035 SDNode *Result = Emit_4(N, X86::ADD8rm, MVT::i8, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 01036 return Result; 01037 } 01038 } 01039 } 01040 } 01041 { 01042 SDValue N0 = N.getOperand(0); 01043 SDValue N1 = N.getOperand(1); 01044 { 01045 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 01046 if (Tmp0) { 01047 int64_t CN1 = Tmp0->getSExtValue(); 01048 01049 // Pattern: (add:i8 GR8:i8:$src, 1:i8) 01050 // Emits: (INC8r:i8 GR8:i8:$src) 01051 // Pattern complexity = 8 cost = 1 size = 2 01052 if (CN1 == INT64_C(1)) { 01053 SDNode *Result = Emit_0(N, X86::INC8r, MVT::i8); 01054 return Result; 01055 } 01056 01057 // Pattern: (add:i8 GR8:i8:$src, -1:i8) 01058 // Emits: (DEC8r:i8 GR8:i8:$src) 01059 // Pattern complexity = 8 cost = 1 size = 2 01060 if (CN1 == INT64_C(-1)) { 01061 SDNode *Result = Emit_0(N, X86::DEC8r, MVT::i8); 01062 return Result; 01063 } 01064 } 01065 } 01066 01067 // Pattern: (add:i8 GR8:i8:$src1, (imm:i8):$src2) 01068 // Emits: (ADD8ri:i8 GR8:i8:$src1, (imm:i8):$src2) 01069 // Pattern complexity = 6 cost = 1 size = 3 01070 if (N1.getOpcode() == ISD::Constant) { 01071 SDNode *Result = Emit_3(N, X86::ADD8ri, MVT::i8); 01072 return Result; 01073 } 01074 } 01075 01076 // Pattern: (add:i8 GR8:i8:$src1, GR8:i8:$src2) 01077 // Emits: (ADD8rr:i8 GR8:i8:$src1, GR8:i8:$src2) 01078 // Pattern complexity = 3 cost = 1 size = 3 01079 SDNode *Result = Emit_1(N, X86::ADD8rr, MVT::i8); 01080 return Result; 01081 } 01082 01083 SDNode *Emit_5(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 01084 SDValue N0 = N.getOperand(0); 01085 SDValue N1 = N.getOperand(1); 01086 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned short) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i16); 01087 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::i32, N0, Tmp1); 01088 } 01089 SDNode *Emit_6(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 01090 SDValue N0 = N.getOperand(0); 01091 SDValue N1 = N.getOperand(1); 01092 SDValue Tmp3 = CurDAG->getTargetConstant(0xFFFFFFFFFFFFFF80ULL, MVT::i16); 01093 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, Tmp3); 01094 } 01095 SDNode *Select_ISD_ADD_i16(const SDValue &N) { 01096 if (OptLevel != CodeGenOpt::None) { 01097 SDValue N0 = N.getOperand(0); 01098 01099 // Pattern: (add:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 01100 // Emits: (ADD16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 01101 // Pattern complexity = 25 cost = 1 size = 3 01102 { 01103 SDValue N1 = N.getOperand(1); 01104 if (N1.getOpcode() == ISD::LOAD && 01105 N1.hasOneUse() && 01106 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 01107 SDValue Chain1 = N1.getOperand(0); 01108 if (Predicate_unindexedload(N1.getNode()) && 01109 Predicate_load(N1.getNode())) { 01110 SDValue N11 = N1.getOperand(1); 01111 SDValue CPTmpN11_0; 01112 SDValue CPTmpN11_1; 01113 SDValue CPTmpN11_2; 01114 SDValue CPTmpN11_3; 01115 SDValue CPTmpN11_4; 01116 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 01117 SDNode *Result = Emit_2(N, X86::ADD16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 01118 return Result; 01119 } 01120 } 01121 } 01122 } 01123 01124 // Pattern: (add:i16 (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR16:i16:$src1) 01125 // Emits: (ADD16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 01126 // Pattern complexity = 25 cost = 1 size = 3 01127 if (N0.getOpcode() == ISD::LOAD && 01128 N0.hasOneUse() && 01129 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 01130 SDValue Chain0 = N0.getOperand(0); 01131 if (Predicate_unindexedload(N0.getNode()) && 01132 Predicate_load(N0.getNode())) { 01133 SDValue N01 = N0.getOperand(1); 01134 SDValue CPTmpN01_0; 01135 SDValue CPTmpN01_1; 01136 SDValue CPTmpN01_2; 01137 SDValue CPTmpN01_3; 01138 SDValue CPTmpN01_4; 01139 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 01140 SDNode *Result = Emit_4(N, X86::ADD16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 01141 return Result; 01142 } 01143 } 01144 } 01145 } 01146 if ((!Subtarget->is64Bit())) { 01147 SDValue N0 = N.getOperand(0); 01148 SDValue N1 = N.getOperand(1); 01149 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 01150 if (Tmp0) { 01151 int64_t CN1 = Tmp0->getSExtValue(); 01152 01153 // Pattern: (add:i16 GR16:i16:$src, 1:i16) 01154 // Emits: (INC16r:i16 GR16:i16:$src) 01155 // Pattern complexity = 8 cost = 1 size = 1 01156 if (CN1 == INT64_C(1)) { 01157 SDNode *Result = Emit_0(N, X86::INC16r, MVT::i16); 01158 return Result; 01159 } 01160 01161 // Pattern: (add:i16 GR16:i16:$src, -1:i16) 01162 // Emits: (DEC16r:i16 GR16:i16:$src) 01163 // Pattern complexity = 8 cost = 1 size = 1 01164 if (CN1 == INT64_C(-1)) { 01165 SDNode *Result = Emit_0(N, X86::DEC16r, MVT::i16); 01166 return Result; 01167 } 01168 } 01169 } 01170 if ((Subtarget->is64Bit())) { 01171 SDValue N0 = N.getOperand(0); 01172 SDValue N1 = N.getOperand(1); 01173 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 01174 if (Tmp0) { 01175 int64_t CN1 = Tmp0->getSExtValue(); 01176 01177 // Pattern: (add:i16 GR16:i16:$src, 1:i16) 01178 // Emits: (INC64_16r:i16 GR16:i16:$src) 01179 // Pattern complexity = 8 cost = 1 size = 2 01180 if (CN1 == INT64_C(1)) { 01181 SDNode *Result = Emit_0(N, X86::INC64_16r, MVT::i16); 01182 return Result; 01183 } 01184 01185 // Pattern: (add:i16 GR16:i16:$src, -1:i16) 01186 // Emits: (DEC64_16r:i16 GR16:i16:$src) 01187 // Pattern complexity = 8 cost = 1 size = 2 01188 if (CN1 == INT64_C(-1)) { 01189 SDNode *Result = Emit_0(N, X86::DEC64_16r, MVT::i16); 01190 return Result; 01191 } 01192 } 01193 } 01194 { 01195 SDValue N0 = N.getOperand(0); 01196 SDValue N1 = N.getOperand(1); 01197 01198 // Pattern: (add:i16 GR16:i16:$src1, 128:i16) 01199 // Emits: (SUB16ri8:i16 GR16:i16:$src1, -128:i16) 01200 // Pattern complexity = 8 cost = 1 size = 3 01201 { 01202 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 01203 if (Tmp0) { 01204 int64_t CN1 = Tmp0->getSExtValue(); 01205 if (CN1 == INT64_C(128)) { 01206 SDNode *Result = Emit_6(N, X86::SUB16ri8, MVT::i16); 01207 return Result; 01208 } 01209 } 01210 } 01211 if (N1.getOpcode() == ISD::Constant) { 01212 01213 // Pattern: (add:i16 GR16:i16:$src1, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 01214 // Emits: (ADD16ri8:i16 GR16:i16:$src1, (imm:i16):$src2) 01215 // Pattern complexity = 7 cost = 1 size = 3 01216 if (Predicate_i16immSExt8(N1.getNode())) { 01217 SDNode *Result = Emit_5(N, X86::ADD16ri8, MVT::i16); 01218 return Result; 01219 } 01220 01221 // Pattern: (add:i16 GR16:i16:$src1, (imm:i16):$src2) 01222 // Emits: (ADD16ri:i16 GR16:i16:$src1, (imm:i16):$src2) 01223 // Pattern complexity = 6 cost = 1 size = 3 01224 SDNode *Result = Emit_5(N, X86::ADD16ri, MVT::i16); 01225 return Result; 01226 } 01227 } 01228 01229 // Pattern: (add:i16 GR16:i16:$src1, GR16:i16:$src2) 01230 // Emits: (ADD16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 01231 // Pattern complexity = 3 cost = 1 size = 3 01232 SDNode *Result = Emit_1(N, X86::ADD16rr, MVT::i16); 01233 return Result; 01234 } 01235 01236 SDNode *Emit_7(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN_0, SDValue &CPTmpN_1, SDValue &CPTmpN_2, SDValue &CPTmpN_3) DISABLE_INLINE { 01237 SDValue Ops0[] = { CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3 }; 01238 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, Ops0, 4); 01239 } 01240 SDNode *Emit_8(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 01241 SDValue N0 = N.getOperand(0); 01242 SDValue N1 = N.getOperand(1); 01243 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i32); 01244 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::i32, N0, Tmp1); 01245 } 01246 SDNode *Emit_9(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 01247 SDValue N0 = N.getOperand(0); 01248 SDValue N1 = N.getOperand(1); 01249 SDValue Tmp3 = CurDAG->getTargetConstant(0xFFFFFFFFFFFFFF80ULL, MVT::i32); 01250 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, Tmp3); 01251 } 01252 SDNode *Emit_10(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 01253 SDValue N0 = N.getOperand(0); 01254 SDValue N1 = N.getOperand(1); 01255 SDValue N10 = N1.getOperand(0); 01256 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, N10); 01257 } 01258 SDNode *Emit_11(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 01259 SDValue N0 = N.getOperand(0); 01260 SDValue N00 = N0.getOperand(0); 01261 SDValue N1 = N.getOperand(1); 01262 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N1, N00); 01263 } 01264 SDNode *Select_ISD_ADD_i32(const SDValue &N) { 01265 if (OptLevel != CodeGenOpt::None) { 01266 SDValue N0 = N.getOperand(0); 01267 01268 // Pattern: (add:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 01269 // Emits: (ADD32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 01270 // Pattern complexity = 25 cost = 1 size = 3 01271 { 01272 SDValue N1 = N.getOperand(1); 01273 if (N1.getOpcode() == ISD::LOAD && 01274 N1.hasOneUse() && 01275 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 01276 SDValue Chain1 = N1.getOperand(0); 01277 if (Predicate_unindexedload(N1.getNode()) && 01278 Predicate_load(N1.getNode())) { 01279 SDValue N11 = N1.getOperand(1); 01280 SDValue CPTmpN11_0; 01281 SDValue CPTmpN11_1; 01282 SDValue CPTmpN11_2; 01283 SDValue CPTmpN11_3; 01284 SDValue CPTmpN11_4; 01285 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 01286 SDNode *Result = Emit_2(N, X86::ADD32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 01287 return Result; 01288 } 01289 } 01290 } 01291 } 01292 01293 // Pattern: (add:i32 (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR32:i32:$src1) 01294 // Emits: (ADD32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 01295 // Pattern complexity = 25 cost = 1 size = 3 01296 if (N0.getOpcode() == ISD::LOAD && 01297 N0.hasOneUse() && 01298 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 01299 SDValue Chain0 = N0.getOperand(0); 01300 if (Predicate_unindexedload(N0.getNode()) && 01301 Predicate_load(N0.getNode())) { 01302 SDValue N01 = N0.getOperand(1); 01303 SDValue CPTmpN01_0; 01304 SDValue CPTmpN01_1; 01305 SDValue CPTmpN01_2; 01306 SDValue CPTmpN01_3; 01307 SDValue CPTmpN01_4; 01308 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 01309 SDNode *Result = Emit_4(N, X86::ADD32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 01310 return Result; 01311 } 01312 } 01313 } 01314 } 01315 01316 // Pattern: lea32addr:i32:$src 01317 // Emits: (LEA64_32r:i32 lea32addr:i32:$src) 01318 // Pattern complexity = 15 cost = 1 size = 3 01319 if ((Subtarget->is64Bit())) { 01320 SDValue CPTmpN_0; 01321 SDValue CPTmpN_1; 01322 SDValue CPTmpN_2; 01323 SDValue CPTmpN_3; 01324 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 01325 SDNode *Result = Emit_7(N, X86::LEA64_32r, MVT::i32, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 01326 return Result; 01327 } 01328 } 01329 01330 // Pattern: lea32addr:i32:$src 01331 // Emits: (LEA32r:i32 lea32addr:i32:$src) 01332 // Pattern complexity = 15 cost = 1 size = 3 01333 if ((!Subtarget->is64Bit())) { 01334 SDValue CPTmpN_0; 01335 SDValue CPTmpN_1; 01336 SDValue CPTmpN_2; 01337 SDValue CPTmpN_3; 01338 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 01339 SDNode *Result = Emit_7(N, X86::LEA32r, MVT::i32, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 01340 return Result; 01341 } 01342 } 01343 { 01344 SDValue N0 = N.getOperand(0); 01345 { 01346 SDValue N1 = N.getOperand(1); 01347 if (N1.getOpcode() == X86ISD::Wrapper) { 01348 SDValue N10 = N1.getOperand(0); 01349 01350 // Pattern: (add:i32 GR32:i32:$src1, (X86Wrapper:i32 (tconstpool:i32):$src2)) 01351 // Emits: (ADD32ri:i32 GR32:i32:$src1, (tconstpool:i32):$src2) 01352 // Pattern complexity = 9 cost = 1 size = 3 01353 if (N10.getOpcode() == ISD::TargetConstantPool) { 01354 SDNode *Result = Emit_10(N, X86::ADD32ri, MVT::i32); 01355 return Result; 01356 } 01357 01358 // Pattern: (add:i32 GR32:i32:$src1, (X86Wrapper:i32 (tjumptable:i32):$src2)) 01359 // Emits: (ADD32ri:i32 GR32:i32:$src1, (tjumptable:i32):$src2) 01360 // Pattern complexity = 9 cost = 1 size = 3 01361 if (N10.getOpcode() == ISD::TargetJumpTable) { 01362 SDNode *Result = Emit_10(N, X86::ADD32ri, MVT::i32); 01363 return Result; 01364 } 01365 01366 // Pattern: (add:i32 GR32:i32:$src1, (X86Wrapper:i32 (tglobaladdr:i32):$src2)) 01367 // Emits: (ADD32ri:i32 GR32:i32:$src1, (tglobaladdr:i32):$src2) 01368 // Pattern complexity = 9 cost = 1 size = 3 01369 if (N10.getOpcode() == ISD::TargetGlobalAddress) { 01370 SDNode *Result = Emit_10(N, X86::ADD32ri, MVT::i32); 01371 return Result; 01372 } 01373 01374 // Pattern: (add:i32 GR32:i32:$src1, (X86Wrapper:i32 (texternalsym:i32):$src2)) 01375 // Emits: (ADD32ri:i32 GR32:i32:$src1, (texternalsym:i32):$src2) 01376 // Pattern complexity = 9 cost = 1 size = 3 01377 if (N10.getOpcode() == ISD::TargetExternalSymbol) { 01378 SDNode *Result = Emit_10(N, X86::ADD32ri, MVT::i32); 01379 return Result; 01380 } 01381 } 01382 } 01383 if (N0.getOpcode() == X86ISD::Wrapper) { 01384 SDValue N00 = N0.getOperand(0); 01385 01386 // Pattern: (add:i32 (X86Wrapper:i32 (tconstpool:i32):$src2), GR32:i32:$src1) 01387 // Emits: (ADD32ri:i32 GR32:i32:$src1, (tconstpool:i32):$src2) 01388 // Pattern complexity = 9 cost = 1 size = 3 01389 if (N00.getOpcode() == ISD::TargetConstantPool) { 01390 SDNode *Result = Emit_11(N, X86::ADD32ri, MVT::i32); 01391 return Result; 01392 } 01393 01394 // Pattern: (add:i32 (X86Wrapper:i32 (tjumptable:i32):$src2), GR32:i32:$src1) 01395 // Emits: (ADD32ri:i32 GR32:i32:$src1, (tjumptable:i32):$src2) 01396 // Pattern complexity = 9 cost = 1 size = 3 01397 if (N00.getOpcode() == ISD::TargetJumpTable) { 01398 SDNode *Result = Emit_11(N, X86::ADD32ri, MVT::i32); 01399 return Result; 01400 } 01401 01402 // Pattern: (add:i32 (X86Wrapper:i32 (tglobaladdr:i32):$src2), GR32:i32:$src1) 01403 // Emits: (ADD32ri:i32 GR32:i32:$src1, (tglobaladdr:i32):$src2) 01404 // Pattern complexity = 9 cost = 1 size = 3 01405 if (N00.getOpcode() == ISD::TargetGlobalAddress) { 01406 SDNode *Result = Emit_11(N, X86::ADD32ri, MVT::i32); 01407 return Result; 01408 } 01409 01410 // Pattern: (add:i32 (X86Wrapper:i32 (texternalsym:i32):$src2), GR32:i32:$src1) 01411 // Emits: (ADD32ri:i32 GR32:i32:$src1, (texternalsym:i32):$src2) 01412 // Pattern complexity = 9 cost = 1 size = 3 01413 if (N00.getOpcode() == ISD::TargetExternalSymbol) { 01414 SDNode *Result = Emit_11(N, X86::ADD32ri, MVT::i32); 01415 return Result; 01416 } 01417 } 01418 } 01419 if ((!Subtarget->is64Bit())) { 01420 SDValue N0 = N.getOperand(0); 01421 SDValue N1 = N.getOperand(1); 01422 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 01423 if (Tmp0) { 01424 int64_t CN1 = Tmp0->getSExtValue(); 01425 01426 // Pattern: (add:i32 GR32:i32:$src, 1:i32) 01427 // Emits: (INC32r:i32 GR32:i32:$src) 01428 // Pattern complexity = 8 cost = 1 size = 1 01429 if (CN1 == INT64_C(1)) { 01430 SDNode *Result = Emit_0(N, X86::INC32r, MVT::i32); 01431 return Result; 01432 } 01433 01434 // Pattern: (add:i32 GR32:i32:$src, -1:i32) 01435 // Emits: (DEC32r:i32 GR32:i32:$src) 01436 // Pattern complexity = 8 cost = 1 size = 1 01437 if (CN1 == INT64_C(-1)) { 01438 SDNode *Result = Emit_0(N, X86::DEC32r, MVT::i32); 01439 return Result; 01440 } 01441 } 01442 } 01443 if ((Subtarget->is64Bit())) { 01444 SDValue N0 = N.getOperand(0); 01445 SDValue N1 = N.getOperand(1); 01446 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 01447 if (Tmp0) { 01448 int64_t CN1 = Tmp0->getSExtValue(); 01449 01450 // Pattern: (add:i32 GR32:i32:$src, 1:i32) 01451 // Emits: (INC64_32r:i32 GR32:i32:$src) 01452 // Pattern complexity = 8 cost = 1 size = 2 01453 if (CN1 == INT64_C(1)) { 01454 SDNode *Result = Emit_0(N, X86::INC64_32r, MVT::i32); 01455 return Result; 01456 } 01457 01458 // Pattern: (add:i32 GR32:i32:$src, -1:i32) 01459 // Emits: (DEC64_32r:i32 GR32:i32:$src) 01460 // Pattern complexity = 8 cost = 1 size = 2 01461 if (CN1 == INT64_C(-1)) { 01462 SDNode *Result = Emit_0(N, X86::DEC64_32r, MVT::i32); 01463 return Result; 01464 } 01465 } 01466 } 01467 { 01468 SDValue N0 = N.getOperand(0); 01469 SDValue N1 = N.getOperand(1); 01470 01471 // Pattern: (add:i32 GR32:i32:$src1, 128:i32) 01472 // Emits: (SUB32ri8:i32 GR32:i32:$src1, -128:i32) 01473 // Pattern complexity = 8 cost = 1 size = 3 01474 { 01475 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 01476 if (Tmp0) { 01477 int64_t CN1 = Tmp0->getSExtValue(); 01478 if (CN1 == INT64_C(128)) { 01479 SDNode *Result = Emit_9(N, X86::SUB32ri8, MVT::i32); 01480 return Result; 01481 } 01482 } 01483 } 01484 if (N1.getOpcode() == ISD::Constant) { 01485 01486 // Pattern: (add:i32 GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 01487 // Emits: (ADD32ri8:i32 GR32:i32:$src1, (imm:i32):$src2) 01488 // Pattern complexity = 7 cost = 1 size = 3 01489 if (Predicate_i32immSExt8(N1.getNode())) { 01490 SDNode *Result = Emit_8(N, X86::ADD32ri8, MVT::i32); 01491 return Result; 01492 } 01493 01494 // Pattern: (add:i32 GR32:i32:$src1, (imm:i32):$src2) 01495 // Emits: (ADD32ri:i32 GR32:i32:$src1, (imm:i32):$src2) 01496 // Pattern complexity = 6 cost = 1 size = 3 01497 SDNode *Result = Emit_8(N, X86::ADD32ri, MVT::i32); 01498 return Result; 01499 } 01500 } 01501 01502 // Pattern: (add:i32 GR32:i32:$src1, GR32:i32:$src2) 01503 // Emits: (ADD32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 01504 // Pattern complexity = 3 cost = 1 size = 3 01505 SDNode *Result = Emit_1(N, X86::ADD32rr, MVT::i32); 01506 return Result; 01507 } 01508 01509 SDNode *Emit_12(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 01510 SDValue N0 = N.getOperand(0); 01511 SDValue N1 = N.getOperand(1); 01512 SDValue Tmp1 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i64); 01513 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::i32, N0, Tmp1); 01514 } 01515 SDNode *Emit_13(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 01516 SDValue N0 = N.getOperand(0); 01517 SDValue N1 = N.getOperand(1); 01518 SDValue Tmp3 = CurDAG->getTargetConstant(0xFFFFFFFFFFFFFF80ULL, MVT::i64); 01519 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, Tmp3); 01520 } 01521 SDNode *Emit_14(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 01522 SDValue N0 = N.getOperand(0); 01523 SDValue N1 = N.getOperand(1); 01524 SDValue Tmp3 = CurDAG->getTargetConstant(0xFFFFFFFF80000000ULL, MVT::i64); 01525 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, Tmp3); 01526 } 01527 SDNode *Select_ISD_ADD_i64(const SDValue &N) { 01528 if (OptLevel != CodeGenOpt::None) { 01529 SDValue N0 = N.getOperand(0); 01530 01531 // Pattern: (add:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 01532 // Emits: (ADD64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 01533 // Pattern complexity = 25 cost = 1 size = 3 01534 { 01535 SDValue N1 = N.getOperand(1); 01536 if (N1.getOpcode() == ISD::LOAD && 01537 N1.hasOneUse() && 01538 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 01539 SDValue Chain1 = N1.getOperand(0); 01540 if (Predicate_unindexedload(N1.getNode()) && 01541 Predicate_load(N1.getNode())) { 01542 SDValue N11 = N1.getOperand(1); 01543 SDValue CPTmpN11_0; 01544 SDValue CPTmpN11_1; 01545 SDValue CPTmpN11_2; 01546 SDValue CPTmpN11_3; 01547 SDValue CPTmpN11_4; 01548 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 01549 SDNode *Result = Emit_2(N, X86::ADD64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 01550 return Result; 01551 } 01552 } 01553 } 01554 } 01555 01556 // Pattern: (add:i64 (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR64:i64:$src1) 01557 // Emits: (ADD64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 01558 // Pattern complexity = 25 cost = 1 size = 3 01559 if (N0.getOpcode() == ISD::LOAD && 01560 N0.hasOneUse() && 01561 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 01562 SDValue Chain0 = N0.getOperand(0); 01563 if (Predicate_unindexedload(N0.getNode()) && 01564 Predicate_load(N0.getNode())) { 01565 SDValue N01 = N0.getOperand(1); 01566 SDValue CPTmpN01_0; 01567 SDValue CPTmpN01_1; 01568 SDValue CPTmpN01_2; 01569 SDValue CPTmpN01_3; 01570 SDValue CPTmpN01_4; 01571 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 01572 SDNode *Result = Emit_4(N, X86::ADD64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 01573 return Result; 01574 } 01575 } 01576 } 01577 } 01578 01579 // Pattern: lea64addr:i64:$src 01580 // Emits: (LEA64r:i64 lea64addr:i64:$src) 01581 // Pattern complexity = 15 cost = 1 size = 3 01582 { 01583 SDValue CPTmpN_0; 01584 SDValue CPTmpN_1; 01585 SDValue CPTmpN_2; 01586 SDValue CPTmpN_3; 01587 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 01588 SDNode *Result = Emit_7(N, X86::LEA64r, MVT::i64, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 01589 return Result; 01590 } 01591 } 01592 { 01593 SDValue N0 = N.getOperand(0); 01594 SDValue N1 = N.getOperand(1); 01595 { 01596 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 01597 if (Tmp0) { 01598 int64_t CN1 = Tmp0->getSExtValue(); 01599 01600 // Pattern: (add:i64 GR64:i64:$src, 1:i64) 01601 // Emits: (INC64r:i64 GR64:i64:$src) 01602 // Pattern complexity = 8 cost = 1 size = 2 01603 if (CN1 == INT64_C(1)) { 01604 SDNode *Result = Emit_0(N, X86::INC64r, MVT::i64); 01605 return Result; 01606 } 01607 01608 // Pattern: (add:i64 GR64:i64:$src, -1:i64) 01609 // Emits: (DEC64r:i64 GR64:i64:$src) 01610 // Pattern complexity = 8 cost = 1 size = 2 01611 if (CN1 == INT64_C(-1)) { 01612 SDNode *Result = Emit_0(N, X86::DEC64r, MVT::i64); 01613 return Result; 01614 } 01615 01616 // Pattern: (add:i64 GR64:i64:$src1, 128:i64) 01617 // Emits: (SUB64ri8:i64 GR64:i64:$src1, -128:i64) 01618 // Pattern complexity = 8 cost = 1 size = 3 01619 if (CN1 == INT64_C(128)) { 01620 SDNode *Result = Emit_13(N, X86::SUB64ri8, MVT::i64); 01621 return Result; 01622 } 01623 01624 // Pattern: (add:i64 GR64:i64:$src1, 2147483648:i64) 01625 // Emits: (SUB64ri32:i64 GR64:i64:$src1, -2147483648:i64) 01626 // Pattern complexity = 8 cost = 1 size = 3 01627 if (CN1 == INT64_C(2147483648)) { 01628 SDNode *Result = Emit_14(N, X86::SUB64ri32, MVT::i64); 01629 return Result; 01630 } 01631 } 01632 } 01633 if (N1.getOpcode() == ISD::Constant) { 01634 01635 // Pattern: (add:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 01636 // Emits: (ADD64ri8:i64 GR64:i64:$src1, (imm:i64):$src2) 01637 // Pattern complexity = 7 cost = 1 size = 3 01638 if (Predicate_i64immSExt8(N1.getNode())) { 01639 SDNode *Result = Emit_12(N, X86::ADD64ri8, MVT::i64); 01640 return Result; 01641 } 01642 01643 // Pattern: (add:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 01644 // Emits: (ADD64ri32:i64 GR64:i64:$src1, (imm:i64):$src2) 01645 // Pattern complexity = 7 cost = 1 size = 3 01646 if (Predicate_i64immSExt32(N1.getNode())) { 01647 SDNode *Result = Emit_12(N, X86::ADD64ri32, MVT::i64); 01648 return Result; 01649 } 01650 } 01651 } 01652 01653 // Pattern: (add:i64 GR64:i64:$src1, GR64:i64:$src2) 01654 // Emits: (ADD64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 01655 // Pattern complexity = 3 cost = 1 size = 3 01656 SDNode *Result = Emit_1(N, X86::ADD64rr, MVT::i64); 01657 return Result; 01658 } 01659 01660 SDNode *Emit_15(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 01661 SDValue N0 = N.getOperand(0); 01662 SDValue N1 = N.getOperand(1); 01663 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, N1); 01664 } 01665 SDNode *Emit_16(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 01666 SDValue N0 = N.getOperand(0); 01667 SDValue N1 = N.getOperand(1); 01668 SDValue N10 = N1.getOperand(0); 01669 SDValue Chain10 = N10.getOperand(0); 01670 SDValue N101 = N10.getOperand(1); 01671 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 01672 SDValue Ops0[] = { N0, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, LSI_N10, Chain10 }; 01673 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 01674 ReplaceUses(SDValue(N10.getNode(), 1), SDValue(ResNode, 1)); 01675 return ResNode; 01676 } 01677 SDNode *Emit_17(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN001_0, SDValue &CPTmpN001_1, SDValue &CPTmpN001_2, SDValue &CPTmpN001_3, SDValue &CPTmpN001_4) DISABLE_INLINE { 01678 SDValue N0 = N.getOperand(0); 01679 SDValue N00 = N0.getOperand(0); 01680 SDValue Chain00 = N00.getOperand(0); 01681 SDValue N001 = N00.getOperand(1); 01682 SDValue N1 = N.getOperand(1); 01683 SDValue LSI_N00 = CurDAG->getMemOperand(cast<MemSDNode>(N00)->getMemOperand()); 01684 SDValue Ops0[] = { N1, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4, LSI_N00, Chain00 }; 01685 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 01686 ReplaceUses(SDValue(N00.getNode(), 1), SDValue(ResNode, 1)); 01687 return ResNode; 01688 } 01689 SDNode *Select_ISD_ADD_v8i8(const SDValue &N) { 01690 if (OptLevel != CodeGenOpt::None && 01691 (Subtarget->hasMMX())) { 01692 SDValue N0 = N.getOperand(0); 01693 01694 // Pattern: (add:v8i8 VR64:v8i8:$src1, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 01695 // Emits: (MMX_PADDBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 01696 // Pattern complexity = 28 cost = 1 size = 3 01697 { 01698 SDValue N1 = N.getOperand(1); 01699 if (N1.getOpcode() == ISD::BIT_CONVERT && 01700 N1.hasOneUse()) { 01701 SDValue N10 = N1.getOperand(0); 01702 if (N10.getOpcode() == ISD::LOAD && 01703 N10.hasOneUse() && 01704 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 01705 SDValue Chain10 = N10.getOperand(0); 01706 if (Predicate_unindexedload(N10.getNode()) && 01707 Predicate_load(N10.getNode())) { 01708 SDValue N101 = N10.getOperand(1); 01709 SDValue CPTmpN101_0; 01710 SDValue CPTmpN101_1; 01711 SDValue CPTmpN101_2; 01712 SDValue CPTmpN101_3; 01713 SDValue CPTmpN101_4; 01714 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 01715 N10.getNode()->getValueType(0) == MVT::v1i64) { 01716 SDNode *Result = Emit_16(N, X86::MMX_PADDBrm, MVT::v8i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 01717 return Result; 01718 } 01719 } 01720 } 01721 } 01722 } 01723 01724 // Pattern: (add:v8i8 (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v8i8:$src1) 01725 // Emits: (MMX_PADDBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 01726 // Pattern complexity = 28 cost = 1 size = 3 01727 if (N0.getOpcode() == ISD::BIT_CONVERT && 01728 N0.hasOneUse()) { 01729 SDValue N00 = N0.getOperand(0); 01730 if (N00.getOpcode() == ISD::LOAD && 01731 N00.hasOneUse() && 01732 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 01733 SDValue Chain00 = N00.getOperand(0); 01734 if (Predicate_unindexedload(N00.getNode()) && 01735 Predicate_load(N00.getNode())) { 01736 SDValue N001 = N00.getOperand(1); 01737 SDValue CPTmpN001_0; 01738 SDValue CPTmpN001_1; 01739 SDValue CPTmpN001_2; 01740 SDValue CPTmpN001_3; 01741 SDValue CPTmpN001_4; 01742 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 01743 SDValue N1 = N.getOperand(1); 01744 if (N00.getNode()->getValueType(0) == MVT::v1i64) { 01745 SDNode *Result = Emit_17(N, X86::MMX_PADDBrm, MVT::v8i8, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 01746 return Result; 01747 } 01748 } 01749 } 01750 } 01751 } 01752 } 01753 01754 // Pattern: (add:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 01755 // Emits: (MMX_PADDBrr:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 01756 // Pattern complexity = 3 cost = 1 size = 3 01757 if ((Subtarget->hasMMX())) { 01758 SDNode *Result = Emit_15(N, X86::MMX_PADDBrr, MVT::v8i8); 01759 return Result; 01760 } 01761 01762 CannotYetSelect(N); 01763 return NULL; 01764 } 01765 01766 SDNode *Select_ISD_ADD_v16i8(const SDValue &N) { 01767 if (OptLevel != CodeGenOpt::None && 01768 (Subtarget->hasSSE2())) { 01769 SDValue N0 = N.getOperand(0); 01770 01771 // Pattern: (add:v16i8 VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 01772 // Emits: (PADDBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 01773 // Pattern complexity = 28 cost = 1 size = 3 01774 { 01775 SDValue N1 = N.getOperand(1); 01776 if (N1.getOpcode() == ISD::BIT_CONVERT && 01777 N1.hasOneUse()) { 01778 SDValue N10 = N1.getOperand(0); 01779 if (N10.getOpcode() == ISD::LOAD && 01780 N10.hasOneUse() && 01781 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 01782 SDValue Chain10 = N10.getOperand(0); 01783 if (Predicate_unindexedload(N10.getNode()) && 01784 Predicate_load(N10.getNode()) && 01785 Predicate_memop(N10.getNode())) { 01786 SDValue N101 = N10.getOperand(1); 01787 SDValue CPTmpN101_0; 01788 SDValue CPTmpN101_1; 01789 SDValue CPTmpN101_2; 01790 SDValue CPTmpN101_3; 01791 SDValue CPTmpN101_4; 01792 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 01793 N10.getNode()->getValueType(0) == MVT::v2i64) { 01794 SDNode *Result = Emit_16(N, X86::PADDBrm, MVT::v16i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 01795 return Result; 01796 } 01797 } 01798 } 01799 } 01800 } 01801 01802 // Pattern: (add:v16i8 (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v16i8:$src1) 01803 // Emits: (PADDBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 01804 // Pattern complexity = 28 cost = 1 size = 3 01805 if (N0.getOpcode() == ISD::BIT_CONVERT && 01806 N0.hasOneUse()) { 01807 SDValue N00 = N0.getOperand(0); 01808 if (N00.getOpcode() == ISD::LOAD && 01809 N00.hasOneUse() && 01810 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 01811 SDValue Chain00 = N00.getOperand(0); 01812 if (Predicate_unindexedload(N00.getNode()) && 01813 Predicate_load(N00.getNode()) && 01814 Predicate_memop(N00.getNode())) { 01815 SDValue N001 = N00.getOperand(1); 01816 SDValue CPTmpN001_0; 01817 SDValue CPTmpN001_1; 01818 SDValue CPTmpN001_2; 01819 SDValue CPTmpN001_3; 01820 SDValue CPTmpN001_4; 01821 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 01822 SDValue N1 = N.getOperand(1); 01823 if (N00.getNode()->getValueType(0) == MVT::v2i64) { 01824 SDNode *Result = Emit_17(N, X86::PADDBrm, MVT::v16i8, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 01825 return Result; 01826 } 01827 } 01828 } 01829 } 01830 } 01831 } 01832 01833 // Pattern: (add:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 01834 // Emits: (PADDBrr:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 01835 // Pattern complexity = 3 cost = 1 size = 3 01836 if ((Subtarget->hasSSE2())) { 01837 SDNode *Result = Emit_15(N, X86::PADDBrr, MVT::v16i8); 01838 return Result; 01839 } 01840 01841 CannotYetSelect(N); 01842 return NULL; 01843 } 01844 01845 SDNode *Select_ISD_ADD_v4i16(const SDValue &N) { 01846 if (OptLevel != CodeGenOpt::None && 01847 (Subtarget->hasMMX())) { 01848 SDValue N0 = N.getOperand(0); 01849 01850 // Pattern: (add:v4i16 VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 01851 // Emits: (MMX_PADDWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 01852 // Pattern complexity = 28 cost = 1 size = 3 01853 { 01854 SDValue N1 = N.getOperand(1); 01855 if (N1.getOpcode() == ISD::BIT_CONVERT && 01856 N1.hasOneUse()) { 01857 SDValue N10 = N1.getOperand(0); 01858 if (N10.getOpcode() == ISD::LOAD && 01859 N10.hasOneUse() && 01860 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 01861 SDValue Chain10 = N10.getOperand(0); 01862 if (Predicate_unindexedload(N10.getNode()) && 01863 Predicate_load(N10.getNode())) { 01864 SDValue N101 = N10.getOperand(1); 01865 SDValue CPTmpN101_0; 01866 SDValue CPTmpN101_1; 01867 SDValue CPTmpN101_2; 01868 SDValue CPTmpN101_3; 01869 SDValue CPTmpN101_4; 01870 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 01871 N10.getNode()->getValueType(0) == MVT::v1i64) { 01872 SDNode *Result = Emit_16(N, X86::MMX_PADDWrm, MVT::v4i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 01873 return Result; 01874 } 01875 } 01876 } 01877 } 01878 } 01879 01880 // Pattern: (add:v4i16 (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v4i16:$src1) 01881 // Emits: (MMX_PADDWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 01882 // Pattern complexity = 28 cost = 1 size = 3 01883 if (N0.getOpcode() == ISD::BIT_CONVERT && 01884 N0.hasOneUse()) { 01885 SDValue N00 = N0.getOperand(0); 01886 if (N00.getOpcode() == ISD::LOAD && 01887 N00.hasOneUse() && 01888 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 01889 SDValue Chain00 = N00.getOperand(0); 01890 if (Predicate_unindexedload(N00.getNode()) && 01891 Predicate_load(N00.getNode())) { 01892 SDValue N001 = N00.getOperand(1); 01893 SDValue CPTmpN001_0; 01894 SDValue CPTmpN001_1; 01895 SDValue CPTmpN001_2; 01896 SDValue CPTmpN001_3; 01897 SDValue CPTmpN001_4; 01898 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 01899 SDValue N1 = N.getOperand(1); 01900 if (N00.getNode()->getValueType(0) == MVT::v1i64) { 01901 SDNode *Result = Emit_17(N, X86::MMX_PADDWrm, MVT::v4i16, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 01902 return Result; 01903 } 01904 } 01905 } 01906 } 01907 } 01908 } 01909 01910 // Pattern: (add:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 01911 // Emits: (MMX_PADDWrr:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 01912 // Pattern complexity = 3 cost = 1 size = 3 01913 if ((Subtarget->hasMMX())) { 01914 SDNode *Result = Emit_15(N, X86::MMX_PADDWrr, MVT::v4i16); 01915 return Result; 01916 } 01917 01918 CannotYetSelect(N); 01919 return NULL; 01920 } 01921 01922 SDNode *Select_ISD_ADD_v8i16(const SDValue &N) { 01923 if (OptLevel != CodeGenOpt::None && 01924 (Subtarget->hasSSE2())) { 01925 SDValue N0 = N.getOperand(0); 01926 01927 // Pattern: (add:v8i16 VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 01928 // Emits: (PADDWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 01929 // Pattern complexity = 28 cost = 1 size = 3 01930 { 01931 SDValue N1 = N.getOperand(1); 01932 if (N1.getOpcode() == ISD::BIT_CONVERT && 01933 N1.hasOneUse()) { 01934 SDValue N10 = N1.getOperand(0); 01935 if (N10.getOpcode() == ISD::LOAD && 01936 N10.hasOneUse() && 01937 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 01938 SDValue Chain10 = N10.getOperand(0); 01939 if (Predicate_unindexedload(N10.getNode()) && 01940 Predicate_load(N10.getNode()) && 01941 Predicate_memop(N10.getNode())) { 01942 SDValue N101 = N10.getOperand(1); 01943 SDValue CPTmpN101_0; 01944 SDValue CPTmpN101_1; 01945 SDValue CPTmpN101_2; 01946 SDValue CPTmpN101_3; 01947 SDValue CPTmpN101_4; 01948 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 01949 N10.getNode()->getValueType(0) == MVT::v2i64) { 01950 SDNode *Result = Emit_16(N, X86::PADDWrm, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 01951 return Result; 01952 } 01953 } 01954 } 01955 } 01956 } 01957 01958 // Pattern: (add:v8i16 (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v8i16:$src1) 01959 // Emits: (PADDWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 01960 // Pattern complexity = 28 cost = 1 size = 3 01961 if (N0.getOpcode() == ISD::BIT_CONVERT && 01962 N0.hasOneUse()) { 01963 SDValue N00 = N0.getOperand(0); 01964 if (N00.getOpcode() == ISD::LOAD && 01965 N00.hasOneUse() && 01966 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 01967 SDValue Chain00 = N00.getOperand(0); 01968 if (Predicate_unindexedload(N00.getNode()) && 01969 Predicate_load(N00.getNode()) && 01970 Predicate_memop(N00.getNode())) { 01971 SDValue N001 = N00.getOperand(1); 01972 SDValue CPTmpN001_0; 01973 SDValue CPTmpN001_1; 01974 SDValue CPTmpN001_2; 01975 SDValue CPTmpN001_3; 01976 SDValue CPTmpN001_4; 01977 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 01978 SDValue N1 = N.getOperand(1); 01979 if (N00.getNode()->getValueType(0) == MVT::v2i64) { 01980 SDNode *Result = Emit_17(N, X86::PADDWrm, MVT::v8i16, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 01981 return Result; 01982 } 01983 } 01984 } 01985 } 01986 } 01987 } 01988 01989 // Pattern: (add:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 01990 // Emits: (PADDWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 01991 // Pattern complexity = 3 cost = 1 size = 3 01992 if ((Subtarget->hasSSE2())) { 01993 SDNode *Result = Emit_15(N, X86::PADDWrr, MVT::v8i16); 01994 return Result; 01995 } 01996 01997 CannotYetSelect(N); 01998 return NULL; 01999 } 02000 02001 SDNode *Select_ISD_ADD_v2i32(const SDValue &N) { 02002 if (OptLevel != CodeGenOpt::None && 02003 (Subtarget->hasMMX())) { 02004 SDValue N0 = N.getOperand(0); 02005 02006 // Pattern: (add:v2i32 VR64:v2i32:$src1, (bitconvert:v2i32 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 02007 // Emits: (MMX_PADDDrm:v2i32 VR64:v2i32:$src1, addr:iPTR:$src2) 02008 // Pattern complexity = 28 cost = 1 size = 3 02009 { 02010 SDValue N1 = N.getOperand(1); 02011 if (N1.getOpcode() == ISD::BIT_CONVERT && 02012 N1.hasOneUse()) { 02013 SDValue N10 = N1.getOperand(0); 02014 if (N10.getOpcode() == ISD::LOAD && 02015 N10.hasOneUse() && 02016 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 02017 SDValue Chain10 = N10.getOperand(0); 02018 if (Predicate_unindexedload(N10.getNode()) && 02019 Predicate_load(N10.getNode())) { 02020 SDValue N101 = N10.getOperand(1); 02021 SDValue CPTmpN101_0; 02022 SDValue CPTmpN101_1; 02023 SDValue CPTmpN101_2; 02024 SDValue CPTmpN101_3; 02025 SDValue CPTmpN101_4; 02026 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 02027 N10.getNode()->getValueType(0) == MVT::v1i64) { 02028 SDNode *Result = Emit_16(N, X86::MMX_PADDDrm, MVT::v2i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 02029 return Result; 02030 } 02031 } 02032 } 02033 } 02034 } 02035 02036 // Pattern: (add:v2i32 (bitconvert:v2i32 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v2i32:$src1) 02037 // Emits: (MMX_PADDDrm:v2i32 VR64:v2i32:$src1, addr:iPTR:$src2) 02038 // Pattern complexity = 28 cost = 1 size = 3 02039 if (N0.getOpcode() == ISD::BIT_CONVERT && 02040 N0.hasOneUse()) { 02041 SDValue N00 = N0.getOperand(0); 02042 if (N00.getOpcode() == ISD::LOAD && 02043 N00.hasOneUse() && 02044 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 02045 SDValue Chain00 = N00.getOperand(0); 02046 if (Predicate_unindexedload(N00.getNode()) && 02047 Predicate_load(N00.getNode())) { 02048 SDValue N001 = N00.getOperand(1); 02049 SDValue CPTmpN001_0; 02050 SDValue CPTmpN001_1; 02051 SDValue CPTmpN001_2; 02052 SDValue CPTmpN001_3; 02053 SDValue CPTmpN001_4; 02054 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 02055 SDValue N1 = N.getOperand(1); 02056 if (N00.getNode()->getValueType(0) == MVT::v1i64) { 02057 SDNode *Result = Emit_17(N, X86::MMX_PADDDrm, MVT::v2i32, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 02058 return Result; 02059 } 02060 } 02061 } 02062 } 02063 } 02064 } 02065 02066 // Pattern: (add:v2i32 VR64:v2i32:$src1, VR64:v2i32:$src2) 02067 // Emits: (MMX_PADDDrr:v2i32 VR64:v2i32:$src1, VR64:v2i32:$src2) 02068 // Pattern complexity = 3 cost = 1 size = 3 02069 if ((Subtarget->hasMMX())) { 02070 SDNode *Result = Emit_15(N, X86::MMX_PADDDrr, MVT::v2i32); 02071 return Result; 02072 } 02073 02074 CannotYetSelect(N); 02075 return NULL; 02076 } 02077 02078 SDNode *Select_ISD_ADD_v4i32(const SDValue &N) { 02079 if (OptLevel != CodeGenOpt::None && 02080 (Subtarget->hasSSE2())) { 02081 SDValue N0 = N.getOperand(0); 02082 02083 // Pattern: (add:v4i32 VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 02084 // Emits: (PADDDrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 02085 // Pattern complexity = 28 cost = 1 size = 3 02086 { 02087 SDValue N1 = N.getOperand(1); 02088 if (N1.getOpcode() == ISD::BIT_CONVERT && 02089 N1.hasOneUse()) { 02090 SDValue N10 = N1.getOperand(0); 02091 if (N10.getOpcode() == ISD::LOAD && 02092 N10.hasOneUse() && 02093 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 02094 SDValue Chain10 = N10.getOperand(0); 02095 if (Predicate_unindexedload(N10.getNode()) && 02096 Predicate_load(N10.getNode()) && 02097 Predicate_memop(N10.getNode())) { 02098 SDValue N101 = N10.getOperand(1); 02099 SDValue CPTmpN101_0; 02100 SDValue CPTmpN101_1; 02101 SDValue CPTmpN101_2; 02102 SDValue CPTmpN101_3; 02103 SDValue CPTmpN101_4; 02104 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 02105 N10.getNode()->getValueType(0) == MVT::v2i64) { 02106 SDNode *Result = Emit_16(N, X86::PADDDrm, MVT::v4i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 02107 return Result; 02108 } 02109 } 02110 } 02111 } 02112 } 02113 02114 // Pattern: (add:v4i32 (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v4i32:$src1) 02115 // Emits: (PADDDrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 02116 // Pattern complexity = 28 cost = 1 size = 3 02117 if (N0.getOpcode() == ISD::BIT_CONVERT && 02118 N0.hasOneUse()) { 02119 SDValue N00 = N0.getOperand(0); 02120 if (N00.getOpcode() == ISD::LOAD && 02121 N00.hasOneUse() && 02122 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 02123 SDValue Chain00 = N00.getOperand(0); 02124 if (Predicate_unindexedload(N00.getNode()) && 02125 Predicate_load(N00.getNode()) && 02126 Predicate_memop(N00.getNode())) { 02127 SDValue N001 = N00.getOperand(1); 02128 SDValue CPTmpN001_0; 02129 SDValue CPTmpN001_1; 02130 SDValue CPTmpN001_2; 02131 SDValue CPTmpN001_3; 02132 SDValue CPTmpN001_4; 02133 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 02134 SDValue N1 = N.getOperand(1); 02135 if (N00.getNode()->getValueType(0) == MVT::v2i64) { 02136 SDNode *Result = Emit_17(N, X86::PADDDrm, MVT::v4i32, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 02137 return Result; 02138 } 02139 } 02140 } 02141 } 02142 } 02143 } 02144 02145 // Pattern: (add:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 02146 // Emits: (PADDDrr:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 02147 // Pattern complexity = 3 cost = 1 size = 3 02148 if ((Subtarget->hasSSE2())) { 02149 SDNode *Result = Emit_15(N, X86::PADDDrr, MVT::v4i32); 02150 return Result; 02151 } 02152 02153 CannotYetSelect(N); 02154 return NULL; 02155 } 02156 02157 SDNode *Select_ISD_ADD_v1i64(const SDValue &N) { 02158 if (OptLevel != CodeGenOpt::None && 02159 (Subtarget->hasMMX())) { 02160 SDValue N0 = N.getOperand(0); 02161 02162 // Pattern: (add:v1i64 VR64:v1i64:$src1, (bitconvert:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 02163 // Emits: (MMX_PADDQrm:v1i64 VR64:v1i64:$src1, addr:iPTR:$src2) 02164 // Pattern complexity = 28 cost = 1 size = 3 02165 { 02166 SDValue N1 = N.getOperand(1); 02167 if (N1.getOpcode() == ISD::BIT_CONVERT && 02168 N1.hasOneUse()) { 02169 SDValue N10 = N1.getOperand(0); 02170 if (N10.getOpcode() == ISD::LOAD && 02171 N10.hasOneUse() && 02172 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 02173 SDValue Chain10 = N10.getOperand(0); 02174 if (Predicate_unindexedload(N10.getNode()) && 02175 Predicate_load(N10.getNode())) { 02176 SDValue N101 = N10.getOperand(1); 02177 SDValue CPTmpN101_0; 02178 SDValue CPTmpN101_1; 02179 SDValue CPTmpN101_2; 02180 SDValue CPTmpN101_3; 02181 SDValue CPTmpN101_4; 02182 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 02183 N10.getNode()->getValueType(0) == MVT::v1i64) { 02184 SDNode *Result = Emit_16(N, X86::MMX_PADDQrm, MVT::v1i64, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 02185 return Result; 02186 } 02187 } 02188 } 02189 } 02190 } 02191 02192 // Pattern: (add:v1i64 (bitconvert:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v1i64:$src1) 02193 // Emits: (MMX_PADDQrm:v1i64 VR64:v1i64:$src1, addr:iPTR:$src2) 02194 // Pattern complexity = 28 cost = 1 size = 3 02195 if (N0.getOpcode() == ISD::BIT_CONVERT && 02196 N0.hasOneUse()) { 02197 SDValue N00 = N0.getOperand(0); 02198 if (N00.getOpcode() == ISD::LOAD && 02199 N00.hasOneUse() && 02200 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 02201 SDValue Chain00 = N00.getOperand(0); 02202 if (Predicate_unindexedload(N00.getNode()) && 02203 Predicate_load(N00.getNode())) { 02204 SDValue N001 = N00.getOperand(1); 02205 SDValue CPTmpN001_0; 02206 SDValue CPTmpN001_1; 02207 SDValue CPTmpN001_2; 02208 SDValue CPTmpN001_3; 02209 SDValue CPTmpN001_4; 02210 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 02211 SDValue N1 = N.getOperand(1); 02212 if (N00.getNode()->getValueType(0) == MVT::v1i64) { 02213 SDNode *Result = Emit_17(N, X86::MMX_PADDQrm, MVT::v1i64, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 02214 return Result; 02215 } 02216 } 02217 } 02218 } 02219 } 02220 } 02221 02222 // Pattern: (add:v1i64 VR64:v1i64:$src1, VR64:v1i64:$src2) 02223 // Emits: (MMX_PADDQrr:v1i64 VR64:v1i64:$src1, VR64:v1i64:$src2) 02224 // Pattern complexity = 3 cost = 1 size = 3 02225 if ((Subtarget->hasMMX())) { 02226 SDNode *Result = Emit_15(N, X86::MMX_PADDQrr, MVT::v1i64); 02227 return Result; 02228 } 02229 02230 CannotYetSelect(N); 02231 return NULL; 02232 } 02233 02234 SDNode *Emit_18(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 02235 SDValue N0 = N.getOperand(0); 02236 SDValue N1 = N.getOperand(1); 02237 SDValue Chain1 = N1.getOperand(0); 02238 SDValue N11 = N1.getOperand(1); 02239 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 02240 SDValue Ops0[] = { N0, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1 }; 02241 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 02242 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 02243 return ResNode; 02244 } 02245 SDNode *Emit_19(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 02246 SDValue N0 = N.getOperand(0); 02247 SDValue Chain0 = N0.getOperand(0); 02248 SDValue N01 = N0.getOperand(1); 02249 SDValue N1 = N.getOperand(1); 02250 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 02251 SDValue Ops0[] = { N1, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, LSI_N0, Chain0 }; 02252 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 02253 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 02254 return ResNode; 02255 } 02256 SDNode *Select_ISD_ADD_v2i64(const SDValue &N) { 02257 if (OptLevel != CodeGenOpt::None && 02258 (Subtarget->hasSSE2())) { 02259 SDValue N0 = N.getOperand(0); 02260 02261 // Pattern: (add:v2i64 VR128:v2i64:$src1, (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 02262 // Emits: (PADDQrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 02263 // Pattern complexity = 25 cost = 1 size = 3 02264 { 02265 SDValue N1 = N.getOperand(1); 02266 if (N1.getOpcode() == ISD::LOAD && 02267 N1.hasOneUse() && 02268 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 02269 SDValue Chain1 = N1.getOperand(0); 02270 if (Predicate_unindexedload(N1.getNode()) && 02271 Predicate_load(N1.getNode()) && 02272 Predicate_memop(N1.getNode())) { 02273 SDValue N11 = N1.getOperand(1); 02274 SDValue CPTmpN11_0; 02275 SDValue CPTmpN11_1; 02276 SDValue CPTmpN11_2; 02277 SDValue CPTmpN11_3; 02278 SDValue CPTmpN11_4; 02279 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 02280 SDNode *Result = Emit_18(N, X86::PADDQrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 02281 return Result; 02282 } 02283 } 02284 } 02285 } 02286 02287 // Pattern: (add:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, VR128:v2i64:$src1) 02288 // Emits: (PADDQrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 02289 // Pattern complexity = 25 cost = 1 size = 3 02290 if (N0.getOpcode() == ISD::LOAD && 02291 N0.hasOneUse() && 02292 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 02293 SDValue Chain0 = N0.getOperand(0); 02294 if (Predicate_unindexedload(N0.getNode()) && 02295 Predicate_load(N0.getNode()) && 02296 Predicate_memop(N0.getNode())) { 02297 SDValue N01 = N0.getOperand(1); 02298 SDValue CPTmpN01_0; 02299 SDValue CPTmpN01_1; 02300 SDValue CPTmpN01_2; 02301 SDValue CPTmpN01_3; 02302 SDValue CPTmpN01_4; 02303 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 02304 SDNode *Result = Emit_19(N, X86::PADDQrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 02305 return Result; 02306 } 02307 } 02308 } 02309 } 02310 02311 // Pattern: (add:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 02312 // Emits: (PADDQrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 02313 // Pattern complexity = 3 cost = 1 size = 3 02314 if ((Subtarget->hasSSE2())) { 02315 SDNode *Result = Emit_15(N, X86::PADDQrr, MVT::v2i64); 02316 return Result; 02317 } 02318 02319 CannotYetSelect(N); 02320 return NULL; 02321 } 02322 02323 SDNode *Emit_20(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 02324 SDValue N0 = N.getOperand(0); 02325 SDValue N1 = N.getOperand(1); 02326 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Flag, N0, N1); 02327 SDValue InFlag(ResNode, 1); 02328 ReplaceUses(SDValue(N.getNode(), 1), InFlag); 02329 return ResNode; 02330 } 02331 SDNode *Emit_21(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 02332 SDValue N0 = N.getOperand(0); 02333 SDValue N1 = N.getOperand(1); 02334 SDValue Chain1 = N1.getOperand(0); 02335 SDValue N11 = N1.getOperand(1); 02336 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 02337 SDValue Ops0[] = { N0, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1 }; 02338 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, MVT::Flag, Ops0, 8); 02339 SDValue InFlag(ResNode, 2); 02340 const SDValue Froms[] = { 02341 SDValue(N1.getNode(), 1), 02342 SDValue(N.getNode(), 1) 02343 }; 02344 const SDValue Tos[] = { 02345 SDValue(ResNode, 1), 02346 InFlag 02347 }; 02348 ReplaceUses(Froms, Tos, 2); 02349 return ResNode; 02350 } 02351 SDNode *Emit_22(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 02352 SDValue N0 = N.getOperand(0); 02353 SDValue N1 = N.getOperand(1); 02354 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i32); 02355 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Flag, N0, Tmp1); 02356 SDValue InFlag(ResNode, 1); 02357 ReplaceUses(SDValue(N.getNode(), 1), InFlag); 02358 return ResNode; 02359 } 02360 SDNode *Emit_23(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 02361 SDValue N0 = N.getOperand(0); 02362 SDValue Chain0 = N0.getOperand(0); 02363 SDValue N01 = N0.getOperand(1); 02364 SDValue N1 = N.getOperand(1); 02365 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 02366 SDValue Ops0[] = { N1, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, LSI_N0, Chain0 }; 02367 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, MVT::Flag, Ops0, 8); 02368 SDValue InFlag(ResNode, 2); 02369 const SDValue Froms[] = { 02370 SDValue(N0.getNode(), 1), 02371 SDValue(N.getNode(), 1) 02372 }; 02373 const SDValue Tos[] = { 02374 SDValue(ResNode, 1), 02375 InFlag 02376 }; 02377 ReplaceUses(Froms, Tos, 2); 02378 return ResNode; 02379 } 02380 SDNode *Select_ISD_ADDC_i32(const SDValue &N) { 02381 if (OptLevel != CodeGenOpt::None) { 02382 SDValue N0 = N.getOperand(0); 02383 02384 // Pattern: (addc:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 02385 // Emits: (ADD32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 02386 // Pattern complexity = 25 cost = 1 size = 3 02387 { 02388 SDValue N1 = N.getOperand(1); 02389 if (N1.getOpcode() == ISD::LOAD && 02390 N1.hasOneUse() && 02391 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 02392 SDValue Chain1 = N1.getOperand(0); 02393 if (Predicate_unindexedload(N1.getNode()) && 02394 Predicate_load(N1.getNode())) { 02395 SDValue N11 = N1.getOperand(1); 02396 SDValue CPTmpN11_0; 02397 SDValue CPTmpN11_1; 02398 SDValue CPTmpN11_2; 02399 SDValue CPTmpN11_3; 02400 SDValue CPTmpN11_4; 02401 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 02402 SDNode *Result = Emit_21(N, X86::ADD32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 02403 return Result; 02404 } 02405 } 02406 } 02407 } 02408 02409 // Pattern: (addc:i32 (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR32:i32:$src1) 02410 // Emits: (ADD32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 02411 // Pattern complexity = 25 cost = 1 size = 3 02412 if (N0.getOpcode() == ISD::LOAD && 02413 N0.hasOneUse() && 02414 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 02415 SDValue Chain0 = N0.getOperand(0); 02416 if (Predicate_unindexedload(N0.getNode()) && 02417 Predicate_load(N0.getNode())) { 02418 SDValue N01 = N0.getOperand(1); 02419 SDValue CPTmpN01_0; 02420 SDValue CPTmpN01_1; 02421 SDValue CPTmpN01_2; 02422 SDValue CPTmpN01_3; 02423 SDValue CPTmpN01_4; 02424 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 02425 SDNode *Result = Emit_23(N, X86::ADD32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 02426 return Result; 02427 } 02428 } 02429 } 02430 } 02431 { 02432 SDValue N0 = N.getOperand(0); 02433 SDValue N1 = N.getOperand(1); 02434 if (N1.getOpcode() == ISD::Constant) { 02435 02436 // Pattern: (addc:i32 GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 02437 // Emits: (ADD32ri8:i32 GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 02438 // Pattern complexity = 7 cost = 1 size = 3 02439 if (Predicate_i32immSExt8(N1.getNode())) { 02440 SDNode *Result = Emit_22(N, X86::ADD32ri8, MVT::i32); 02441 return Result; 02442 } 02443 02444 // Pattern: (addc:i32 GR32:i32:$src1, (imm:i32):$src2) 02445 // Emits: (ADD32ri:i32 GR32:i32:$src1, (imm:i32):$src2) 02446 // Pattern complexity = 6 cost = 1 size = 3 02447 SDNode *Result = Emit_22(N, X86::ADD32ri, MVT::i32); 02448 return Result; 02449 } 02450 } 02451 02452 // Pattern: (addc:i32 GR32:i32:$src1, GR32:i32:$src2) 02453 // Emits: (ADD32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 02454 // Pattern complexity = 3 cost = 1 size = 3 02455 SDNode *Result = Emit_20(N, X86::ADD32rr, MVT::i32); 02456 return Result; 02457 } 02458 02459 SDNode *Emit_24(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 02460 SDValue N0 = N.getOperand(0); 02461 SDValue N1 = N.getOperand(1); 02462 SDValue Tmp1 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i64); 02463 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Flag, N0, Tmp1); 02464 SDValue InFlag(ResNode, 1); 02465 ReplaceUses(SDValue(N.getNode(), 1), InFlag); 02466 return ResNode; 02467 } 02468 SDNode *Select_ISD_ADDC_i64(const SDValue &N) { 02469 if (OptLevel != CodeGenOpt::None) { 02470 SDValue N0 = N.getOperand(0); 02471 02472 // Pattern: (addc:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 02473 // Emits: (ADD64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 02474 // Pattern complexity = 25 cost = 1 size = 3 02475 { 02476 SDValue N1 = N.getOperand(1); 02477 if (N1.getOpcode() == ISD::LOAD && 02478 N1.hasOneUse() && 02479 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 02480 SDValue Chain1 = N1.getOperand(0); 02481 if (Predicate_unindexedload(N1.getNode()) && 02482 Predicate_load(N1.getNode())) { 02483 SDValue N11 = N1.getOperand(1); 02484 SDValue CPTmpN11_0; 02485 SDValue CPTmpN11_1; 02486 SDValue CPTmpN11_2; 02487 SDValue CPTmpN11_3; 02488 SDValue CPTmpN11_4; 02489 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 02490 SDNode *Result = Emit_21(N, X86::ADD64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 02491 return Result; 02492 } 02493 } 02494 } 02495 } 02496 02497 // Pattern: (addc:i64 (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR64:i64:$src1) 02498 // Emits: (ADD64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 02499 // Pattern complexity = 25 cost = 1 size = 3 02500 if (N0.getOpcode() == ISD::LOAD && 02501 N0.hasOneUse() && 02502 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 02503 SDValue Chain0 = N0.getOperand(0); 02504 if (Predicate_unindexedload(N0.getNode()) && 02505 Predicate_load(N0.getNode())) { 02506 SDValue N01 = N0.getOperand(1); 02507 SDValue CPTmpN01_0; 02508 SDValue CPTmpN01_1; 02509 SDValue CPTmpN01_2; 02510 SDValue CPTmpN01_3; 02511 SDValue CPTmpN01_4; 02512 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 02513 SDNode *Result = Emit_23(N, X86::ADD64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 02514 return Result; 02515 } 02516 } 02517 } 02518 } 02519 { 02520 SDValue N0 = N.getOperand(0); 02521 SDValue N1 = N.getOperand(1); 02522 if (N1.getOpcode() == ISD::Constant) { 02523 02524 // Pattern: (addc:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 02525 // Emits: (ADD64ri8:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 02526 // Pattern complexity = 7 cost = 1 size = 3 02527 if (Predicate_i64immSExt8(N1.getNode())) { 02528 SDNode *Result = Emit_24(N, X86::ADD64ri8, MVT::i64); 02529 return Result; 02530 } 02531 02532 // Pattern: (addc:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 02533 // Emits: (ADD64ri32:i64 GR64:i64:$src1, (imm:i64):$src2) 02534 // Pattern complexity = 7 cost = 1 size = 3 02535 if (Predicate_i64immSExt32(N1.getNode())) { 02536 SDNode *Result = Emit_24(N, X86::ADD64ri32, MVT::i64); 02537 return Result; 02538 } 02539 } 02540 } 02541 02542 // Pattern: (addc:i64 GR64:i64:$src1, GR64:i64:$src2) 02543 // Emits: (ADD64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 02544 // Pattern complexity = 3 cost = 1 size = 3 02545 SDNode *Result = Emit_20(N, X86::ADD64rr, MVT::i64); 02546 return Result; 02547 } 02548 02549 SDNode *Emit_25(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 02550 SDValue N0 = N.getOperand(0); 02551 SDValue N1 = N.getOperand(1); 02552 SDValue InFlag = N.getOperand(2); 02553 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Flag, N0, N1, InFlag); 02554 InFlag = SDValue(ResNode, 1); 02555 ReplaceUses(SDValue(N.getNode(), 1), InFlag); 02556 return ResNode; 02557 } 02558 SDNode *Emit_26(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 02559 SDValue N0 = N.getOperand(0); 02560 SDValue N1 = N.getOperand(1); 02561 SDValue Chain1 = N1.getOperand(0); 02562 SDValue N11 = N1.getOperand(1); 02563 SDValue InFlag = N.getOperand(2); 02564 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 02565 SDValue Ops0[] = { N0, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1, InFlag }; 02566 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, MVT::Flag, Ops0, 9); 02567 InFlag = SDValue(ResNode, 2); 02568 const SDValue Froms[] = { 02569 SDValue(N1.getNode(), 1), 02570 SDValue(N.getNode(), 1) 02571 }; 02572 const SDValue Tos[] = { 02573 SDValue(ResNode, 1), 02574 InFlag 02575 }; 02576 ReplaceUses(Froms, Tos, 2); 02577 return ResNode; 02578 } 02579 SDNode *Emit_27(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 02580 SDValue N0 = N.getOperand(0); 02581 SDValue N1 = N.getOperand(1); 02582 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i8); 02583 SDValue InFlag = N.getOperand(2); 02584 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Flag, N0, Tmp1, InFlag); 02585 InFlag = SDValue(ResNode, 1); 02586 ReplaceUses(SDValue(N.getNode(), 1), InFlag); 02587 return ResNode; 02588 } 02589 SDNode *Emit_28(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 02590 SDValue N0 = N.getOperand(0); 02591 SDValue Chain0 = N0.getOperand(0); 02592 SDValue N01 = N0.getOperand(1); 02593 SDValue N1 = N.getOperand(1); 02594 SDValue InFlag = N.getOperand(2); 02595 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 02596 SDValue Ops0[] = { N1, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, LSI_N0, Chain0, InFlag }; 02597 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, MVT::Flag, Ops0, 9); 02598 InFlag = SDValue(ResNode, 2); 02599 const SDValue Froms[] = { 02600 SDValue(N0.getNode(), 1), 02601 SDValue(N.getNode(), 1) 02602 }; 02603 const SDValue Tos[] = { 02604 SDValue(ResNode, 1), 02605 InFlag 02606 }; 02607 ReplaceUses(Froms, Tos, 2); 02608 return ResNode; 02609 } 02610 SDNode *Select_ISD_ADDE_i8(const SDValue &N) { 02611 if (OptLevel != CodeGenOpt::None) { 02612 SDValue N0 = N.getOperand(0); 02613 02614 // Pattern: (adde:i8 GR8:i8:$src1, (ld:i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 02615 // Emits: (ADC8rm:i8 GR8:i8:$src1, addr:iPTR:$src2) 02616 // Pattern complexity = 25 cost = 1 size = 3 02617 { 02618 SDValue N1 = N.getOperand(1); 02619 if (N1.getOpcode() == ISD::LOAD && 02620 N1.hasOneUse() && 02621 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 02622 SDValue Chain1 = N1.getOperand(0); 02623 if (Predicate_unindexedload(N1.getNode()) && 02624 Predicate_load(N1.getNode())) { 02625 SDValue N11 = N1.getOperand(1); 02626 SDValue CPTmpN11_0; 02627 SDValue CPTmpN11_1; 02628 SDValue CPTmpN11_2; 02629 SDValue CPTmpN11_3; 02630 SDValue CPTmpN11_4; 02631 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 02632 SDNode *Result = Emit_26(N, X86::ADC8rm, MVT::i8, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 02633 return Result; 02634 } 02635 } 02636 } 02637 } 02638 02639 // Pattern: (adde:i8 (ld:i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR8:i8:$src1) 02640 // Emits: (ADC8rm:i8 GR8:i8:$src1, addr:iPTR:$src2) 02641 // Pattern complexity = 25 cost = 1 size = 3 02642 if (N0.getOpcode() == ISD::LOAD && 02643 N0.hasOneUse() && 02644 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 02645 SDValue Chain0 = N0.getOperand(0); 02646 if (Predicate_unindexedload(N0.getNode()) && 02647 Predicate_load(N0.getNode())) { 02648 SDValue N01 = N0.getOperand(1); 02649 SDValue CPTmpN01_0; 02650 SDValue CPTmpN01_1; 02651 SDValue CPTmpN01_2; 02652 SDValue CPTmpN01_3; 02653 SDValue CPTmpN01_4; 02654 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 02655 SDNode *Result = Emit_28(N, X86::ADC8rm, MVT::i8, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 02656 return Result; 02657 } 02658 } 02659 } 02660 } 02661 02662 // Pattern: (adde:i8 GR8:i8:$src1, (imm:i8):$src2) 02663 // Emits: (ADC8ri:i8 GR8:i8:$src1, (imm:i8):$src2) 02664 // Pattern complexity = 6 cost = 1 size = 3 02665 { 02666 SDValue N0 = N.getOperand(0); 02667 SDValue N1 = N.getOperand(1); 02668 if (N1.getOpcode() == ISD::Constant) { 02669 SDNode *Result = Emit_27(N, X86::ADC8ri, MVT::i8); 02670 return Result; 02671 } 02672 } 02673 02674 // Pattern: (adde:i8 GR8:i8:$src1, GR8:i8:$src2) 02675 // Emits: (ADC8rr:i8 GR8:i8:$src1, GR8:i8:$src2) 02676 // Pattern complexity = 3 cost = 1 size = 3 02677 SDNode *Result = Emit_25(N, X86::ADC8rr, MVT::i8); 02678 return Result; 02679 } 02680 02681 SDNode *Emit_29(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 02682 SDValue N0 = N.getOperand(0); 02683 SDValue N1 = N.getOperand(1); 02684 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned short) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i16); 02685 SDValue InFlag = N.getOperand(2); 02686 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Flag, N0, Tmp1, InFlag); 02687 InFlag = SDValue(ResNode, 1); 02688 ReplaceUses(SDValue(N.getNode(), 1), InFlag); 02689 return ResNode; 02690 } 02691 SDNode *Select_ISD_ADDE_i16(const SDValue &N) { 02692 if (OptLevel != CodeGenOpt::None) { 02693 SDValue N0 = N.getOperand(0); 02694 02695 // Pattern: (adde:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 02696 // Emits: (ADC16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 02697 // Pattern complexity = 25 cost = 1 size = 3 02698 { 02699 SDValue N1 = N.getOperand(1); 02700 if (N1.getOpcode() == ISD::LOAD && 02701 N1.hasOneUse() && 02702 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 02703 SDValue Chain1 = N1.getOperand(0); 02704 if (Predicate_unindexedload(N1.getNode()) && 02705 Predicate_load(N1.getNode())) { 02706 SDValue N11 = N1.getOperand(1); 02707 SDValue CPTmpN11_0; 02708 SDValue CPTmpN11_1; 02709 SDValue CPTmpN11_2; 02710 SDValue CPTmpN11_3; 02711 SDValue CPTmpN11_4; 02712 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 02713 SDNode *Result = Emit_26(N, X86::ADC16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 02714 return Result; 02715 } 02716 } 02717 } 02718 } 02719 02720 // Pattern: (adde:i16 (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR16:i16:$src1) 02721 // Emits: (ADC16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 02722 // Pattern complexity = 25 cost = 1 size = 3 02723 if (N0.getOpcode() == ISD::LOAD && 02724 N0.hasOneUse() && 02725 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 02726 SDValue Chain0 = N0.getOperand(0); 02727 if (Predicate_unindexedload(N0.getNode()) && 02728 Predicate_load(N0.getNode())) { 02729 SDValue N01 = N0.getOperand(1); 02730 SDValue CPTmpN01_0; 02731 SDValue CPTmpN01_1; 02732 SDValue CPTmpN01_2; 02733 SDValue CPTmpN01_3; 02734 SDValue CPTmpN01_4; 02735 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 02736 SDNode *Result = Emit_28(N, X86::ADC16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 02737 return Result; 02738 } 02739 } 02740 } 02741 } 02742 { 02743 SDValue N0 = N.getOperand(0); 02744 SDValue N1 = N.getOperand(1); 02745 if (N1.getOpcode() == ISD::Constant) { 02746 02747 // Pattern: (adde:i16 GR16:i16:$src1, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 02748 // Emits: (ADC16ri8:i16 GR16:i16:$src1, (imm:i16):$src2) 02749 // Pattern complexity = 7 cost = 1 size = 3 02750 if (Predicate_i16immSExt8(N1.getNode())) { 02751 SDNode *Result = Emit_29(N, X86::ADC16ri8, MVT::i16); 02752 return Result; 02753 } 02754 02755 // Pattern: (adde:i16 GR16:i16:$src1, (imm:i16):$src2) 02756 // Emits: (ADC16ri:i16 GR16:i16:$src1, (imm:i16):$src2) 02757 // Pattern complexity = 6 cost = 1 size = 3 02758 SDNode *Result = Emit_29(N, X86::ADC16ri, MVT::i16); 02759 return Result; 02760 } 02761 } 02762 02763 // Pattern: (adde:i16 GR16:i16:$src1, GR16:i16:$src2) 02764 // Emits: (ADC16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 02765 // Pattern complexity = 3 cost = 1 size = 3 02766 SDNode *Result = Emit_25(N, X86::ADC16rr, MVT::i16); 02767 return Result; 02768 } 02769 02770 SDNode *Emit_30(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 02771 SDValue N0 = N.getOperand(0); 02772 SDValue N1 = N.getOperand(1); 02773 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i32); 02774 SDValue InFlag = N.getOperand(2); 02775 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Flag, N0, Tmp1, InFlag); 02776 InFlag = SDValue(ResNode, 1); 02777 ReplaceUses(SDValue(N.getNode(), 1), InFlag); 02778 return ResNode; 02779 } 02780 SDNode *Select_ISD_ADDE_i32(const SDValue &N) { 02781 if (OptLevel != CodeGenOpt::None) { 02782 SDValue N0 = N.getOperand(0); 02783 02784 // Pattern: (adde:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 02785 // Emits: (ADC32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 02786 // Pattern complexity = 25 cost = 1 size = 3 02787 { 02788 SDValue N1 = N.getOperand(1); 02789 if (N1.getOpcode() == ISD::LOAD && 02790 N1.hasOneUse() && 02791 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 02792 SDValue Chain1 = N1.getOperand(0); 02793 if (Predicate_unindexedload(N1.getNode()) && 02794 Predicate_load(N1.getNode())) { 02795 SDValue N11 = N1.getOperand(1); 02796 SDValue CPTmpN11_0; 02797 SDValue CPTmpN11_1; 02798 SDValue CPTmpN11_2; 02799 SDValue CPTmpN11_3; 02800 SDValue CPTmpN11_4; 02801 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 02802 SDNode *Result = Emit_26(N, X86::ADC32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 02803 return Result; 02804 } 02805 } 02806 } 02807 } 02808 02809 // Pattern: (adde:i32 (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR32:i32:$src1) 02810 // Emits: (ADC32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 02811 // Pattern complexity = 25 cost = 1 size = 3 02812 if (N0.getOpcode() == ISD::LOAD && 02813 N0.hasOneUse() && 02814 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 02815 SDValue Chain0 = N0.getOperand(0); 02816 if (Predicate_unindexedload(N0.getNode()) && 02817 Predicate_load(N0.getNode())) { 02818 SDValue N01 = N0.getOperand(1); 02819 SDValue CPTmpN01_0; 02820 SDValue CPTmpN01_1; 02821 SDValue CPTmpN01_2; 02822 SDValue CPTmpN01_3; 02823 SDValue CPTmpN01_4; 02824 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 02825 SDNode *Result = Emit_28(N, X86::ADC32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 02826 return Result; 02827 } 02828 } 02829 } 02830 } 02831 { 02832 SDValue N0 = N.getOperand(0); 02833 SDValue N1 = N.getOperand(1); 02834 if (N1.getOpcode() == ISD::Constant) { 02835 02836 // Pattern: (adde:i32 GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 02837 // Emits: (ADC32ri8:i32 GR32:i32:$src1, (imm:i32):$src2) 02838 // Pattern complexity = 7 cost = 1 size = 3 02839 if (Predicate_i32immSExt8(N1.getNode())) { 02840 SDNode *Result = Emit_30(N, X86::ADC32ri8, MVT::i32); 02841 return Result; 02842 } 02843 02844 // Pattern: (adde:i32 GR32:i32:$src1, (imm:i32):$src2) 02845 // Emits: (ADC32ri:i32 GR32:i32:$src1, (imm:i32):$src2) 02846 // Pattern complexity = 6 cost = 1 size = 3 02847 SDNode *Result = Emit_30(N, X86::ADC32ri, MVT::i32); 02848 return Result; 02849 } 02850 } 02851 02852 // Pattern: (adde:i32 GR32:i32:$src1, GR32:i32:$src2) 02853 // Emits: (ADC32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 02854 // Pattern complexity = 3 cost = 1 size = 3 02855 SDNode *Result = Emit_25(N, X86::ADC32rr, MVT::i32); 02856 return Result; 02857 } 02858 02859 SDNode *Emit_31(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 02860 SDValue N0 = N.getOperand(0); 02861 SDValue N1 = N.getOperand(1); 02862 SDValue Tmp1 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i64); 02863 SDValue InFlag = N.getOperand(2); 02864 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Flag, N0, Tmp1, InFlag); 02865 InFlag = SDValue(ResNode, 1); 02866 ReplaceUses(SDValue(N.getNode(), 1), InFlag); 02867 return ResNode; 02868 } 02869 SDNode *Select_ISD_ADDE_i64(const SDValue &N) { 02870 if (OptLevel != CodeGenOpt::None) { 02871 SDValue N0 = N.getOperand(0); 02872 02873 // Pattern: (adde:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 02874 // Emits: (ADC64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 02875 // Pattern complexity = 25 cost = 1 size = 3 02876 { 02877 SDValue N1 = N.getOperand(1); 02878 if (N1.getOpcode() == ISD::LOAD && 02879 N1.hasOneUse() && 02880 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 02881 SDValue Chain1 = N1.getOperand(0); 02882 if (Predicate_unindexedload(N1.getNode()) && 02883 Predicate_load(N1.getNode())) { 02884 SDValue N11 = N1.getOperand(1); 02885 SDValue CPTmpN11_0; 02886 SDValue CPTmpN11_1; 02887 SDValue CPTmpN11_2; 02888 SDValue CPTmpN11_3; 02889 SDValue CPTmpN11_4; 02890 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 02891 SDNode *Result = Emit_26(N, X86::ADC64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 02892 return Result; 02893 } 02894 } 02895 } 02896 } 02897 02898 // Pattern: (adde:i64 (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR64:i64:$src1) 02899 // Emits: (ADC64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 02900 // Pattern complexity = 25 cost = 1 size = 3 02901 if (N0.getOpcode() == ISD::LOAD && 02902 N0.hasOneUse() && 02903 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 02904 SDValue Chain0 = N0.getOperand(0); 02905 if (Predicate_unindexedload(N0.getNode()) && 02906 Predicate_load(N0.getNode())) { 02907 SDValue N01 = N0.getOperand(1); 02908 SDValue CPTmpN01_0; 02909 SDValue CPTmpN01_1; 02910 SDValue CPTmpN01_2; 02911 SDValue CPTmpN01_3; 02912 SDValue CPTmpN01_4; 02913 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 02914 SDNode *Result = Emit_28(N, X86::ADC64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 02915 return Result; 02916 } 02917 } 02918 } 02919 } 02920 { 02921 SDValue N0 = N.getOperand(0); 02922 SDValue N1 = N.getOperand(1); 02923 if (N1.getOpcode() == ISD::Constant) { 02924 02925 // Pattern: (adde:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 02926 // Emits: (ADC64ri8:i64 GR64:i64:$src1, (imm:i64):$src2) 02927 // Pattern complexity = 7 cost = 1 size = 3 02928 if (Predicate_i64immSExt8(N1.getNode())) { 02929 SDNode *Result = Emit_31(N, X86::ADC64ri8, MVT::i64); 02930 return Result; 02931 } 02932 02933 // Pattern: (adde:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 02934 // Emits: (ADC64ri32:i64 GR64:i64:$src1, (imm:i64):$src2) 02935 // Pattern complexity = 7 cost = 1 size = 3 02936 if (Predicate_i64immSExt32(N1.getNode())) { 02937 SDNode *Result = Emit_31(N, X86::ADC64ri32, MVT::i64); 02938 return Result; 02939 } 02940 } 02941 } 02942 02943 // Pattern: (adde:i64 GR64:i64:$src1, GR64:i64:$src2) 02944 // Emits: (ADC64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 02945 // Pattern complexity = 3 cost = 1 size = 3 02946 SDNode *Result = Emit_25(N, X86::ADC64rr, MVT::i64); 02947 return Result; 02948 } 02949 02950 SDNode *Select_ISD_AND_i8(const SDValue &N) { 02951 if (OptLevel != CodeGenOpt::None) { 02952 SDValue N0 = N.getOperand(0); 02953 02954 // Pattern: (and:i8 GR8:i8:$src1, (ld:i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>) 02955 // Emits: (AND8rm:i8 GR8:i8:$src1, addr:iPTR:$src2) 02956 // Pattern complexity = 25 cost = 1 size = 3 02957 { 02958 SDValue N1 = N.getOperand(1); 02959 if (N1.getOpcode() == ISD::LOAD && 02960 N1.hasOneUse() && 02961 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 02962 SDValue Chain1 = N1.getOperand(0); 02963 if (Predicate_unindexedload(N1.getNode()) && 02964 Predicate_load(N1.getNode()) && 02965 Predicate_loadi8(N1.getNode())) { 02966 SDValue N11 = N1.getOperand(1); 02967 SDValue CPTmpN11_0; 02968 SDValue CPTmpN11_1; 02969 SDValue CPTmpN11_2; 02970 SDValue CPTmpN11_3; 02971 SDValue CPTmpN11_4; 02972 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 02973 SDNode *Result = Emit_2(N, X86::AND8rm, MVT::i8, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 02974 return Result; 02975 } 02976 } 02977 } 02978 } 02979 02980 // Pattern: (and:i8 (ld:i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, GR8:i8:$src1) 02981 // Emits: (AND8rm:i8 GR8:i8:$src1, addr:iPTR:$src2) 02982 // Pattern complexity = 25 cost = 1 size = 3 02983 if (N0.getOpcode() == ISD::LOAD && 02984 N0.hasOneUse() && 02985 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 02986 SDValue Chain0 = N0.getOperand(0); 02987 if (Predicate_unindexedload(N0.getNode()) && 02988 Predicate_load(N0.getNode()) && 02989 Predicate_loadi8(N0.getNode())) { 02990 SDValue N01 = N0.getOperand(1); 02991 SDValue CPTmpN01_0; 02992 SDValue CPTmpN01_1; 02993 SDValue CPTmpN01_2; 02994 SDValue CPTmpN01_3; 02995 SDValue CPTmpN01_4; 02996 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 02997 SDNode *Result = Emit_4(N, X86::AND8rm, MVT::i8, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 02998 return Result; 02999 } 03000 } 03001 } 03002 } 03003 03004 // Pattern: (and:i8 GR8:i8:$src1, (imm:i8):$src2) 03005 // Emits: (AND8ri:i8 GR8:i8:$src1, (imm:i8):$src2) 03006 // Pattern complexity = 6 cost = 1 size = 3 03007 { 03008 SDValue N0 = N.getOperand(0); 03009 SDValue N1 = N.getOperand(1); 03010 if (N1.getOpcode() == ISD::Constant) { 03011 SDNode *Result = Emit_3(N, X86::AND8ri, MVT::i8); 03012 return Result; 03013 } 03014 } 03015 03016 // Pattern: (and:i8 GR8:i8:$src1, GR8:i8:$src2) 03017 // Emits: (AND8rr:i8 GR8:i8:$src1, GR8:i8:$src2) 03018 // Pattern complexity = 3 cost = 1 size = 3 03019 SDNode *Result = Emit_1(N, X86::AND8rr, MVT::i8); 03020 return Result; 03021 } 03022 03023 SDNode *Emit_32(const SDValue &N, unsigned Opc0, unsigned Opc1, unsigned Opc2, EVT VT0, EVT VT1, EVT VT2) DISABLE_INLINE { 03024 SDValue N0 = N.getOperand(0); 03025 SDValue N1 = N.getOperand(1); 03026 SDValue Tmp2 = CurDAG->getTargetConstant(X86::GR16_ABCDRegClassID, MVT::i32); 03027 SDValue Tmp3(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N0, Tmp2), 0); 03028 SDValue Tmp4 = CurDAG->getTargetConstant(0x1ULL, MVT::i32); 03029 SDValue Tmp5(CurDAG->getTargetNode(Opc1, N.getDebugLoc(), VT1, Tmp3, Tmp4), 0); 03030 return CurDAG->SelectNodeTo(N.getNode(), Opc2, VT2, Tmp5); 03031 } 03032 SDNode *Emit_33(const SDValue &N, unsigned Opc0, unsigned Opc1, EVT VT0, EVT VT1) DISABLE_INLINE { 03033 SDValue N0 = N.getOperand(0); 03034 SDValue N1 = N.getOperand(1); 03035 SDValue Tmp2 = CurDAG->getTargetConstant(0x1ULL, MVT::i32); 03036 SDValue Tmp3(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N0, Tmp2), 0); 03037 return CurDAG->SelectNodeTo(N.getNode(), Opc1, VT1, Tmp3); 03038 } 03039 SDNode *Select_ISD_AND_i16(const SDValue &N) { 03040 if (OptLevel != CodeGenOpt::None) { 03041 SDValue N0 = N.getOperand(0); 03042 03043 // Pattern: (and:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>) 03044 // Emits: (AND16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 03045 // Pattern complexity = 25 cost = 1 size = 3 03046 { 03047 SDValue N1 = N.getOperand(1); 03048 if (N1.getOpcode() == ISD::LOAD && 03049 N1.hasOneUse() && 03050 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 03051 SDValue Chain1 = N1.getOperand(0); 03052 if (Predicate_unindexedload(N1.getNode()) && 03053 Predicate_loadi16(N1.getNode())) { 03054 SDValue N11 = N1.getOperand(1); 03055 SDValue CPTmpN11_0; 03056 SDValue CPTmpN11_1; 03057 SDValue CPTmpN11_2; 03058 SDValue CPTmpN11_3; 03059 SDValue CPTmpN11_4; 03060 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 03061 SDNode *Result = Emit_2(N, X86::AND16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 03062 return Result; 03063 } 03064 } 03065 } 03066 } 03067 03068 // Pattern: (and:i16 (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src1) 03069 // Emits: (AND16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 03070 // Pattern complexity = 25 cost = 1 size = 3 03071 if (N0.getOpcode() == ISD::LOAD && 03072 N0.hasOneUse() && 03073 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 03074 SDValue Chain0 = N0.getOperand(0); 03075 if (Predicate_unindexedload(N0.getNode()) && 03076 Predicate_loadi16(N0.getNode())) { 03077 SDValue N01 = N0.getOperand(1); 03078 SDValue CPTmpN01_0; 03079 SDValue CPTmpN01_1; 03080 SDValue CPTmpN01_2; 03081 SDValue CPTmpN01_3; 03082 SDValue CPTmpN01_4; 03083 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 03084 SDNode *Result = Emit_4(N, X86::AND16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 03085 return Result; 03086 } 03087 } 03088 } 03089 } 03090 03091 // Pattern: (and:i16 GR16:i16:$src1, 255:i16) 03092 // Emits: (MOVZX16rr8:i16 (EXTRACT_SUBREG:i8 GR16:i16:$src1, 1:i32)) 03093 // Pattern complexity = 8 cost = 2 size = 3 03094 if ((Subtarget->is64Bit())) { 03095 SDValue N0 = N.getOperand(0); 03096 SDValue N1 = N.getOperand(1); 03097 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 03098 if (Tmp0 && 03099 CheckAndMask(N0, Tmp0, INT64_C(255))) { 03100 SDNode *Result = Emit_33(N, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVZX16rr8, MVT::i8, MVT::i16); 03101 return Result; 03102 } 03103 } 03104 03105 // Pattern: (and:i16 GR16:i16:$src1, 255:i16) 03106 // Emits: (MOVZX16rr8:i16 (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i16 GR16:i16:$src1, GR16_ABCD:i16), 1:i32)) 03107 // Pattern complexity = 8 cost = 3 size = 3 03108 if ((!Subtarget->is64Bit())) { 03109 SDValue N0 = N.getOperand(0); 03110 SDValue N1 = N.getOperand(1); 03111 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 03112 if (Tmp0 && 03113 CheckAndMask(N0, Tmp0, INT64_C(255))) { 03114 SDNode *Result = Emit_32(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVZX16rr8, MVT::i16, MVT::i8, MVT::i16); 03115 return Result; 03116 } 03117 } 03118 { 03119 SDValue N0 = N.getOperand(0); 03120 SDValue N1 = N.getOperand(1); 03121 if (N1.getOpcode() == ISD::Constant) { 03122 03123 // Pattern: (and:i16 GR16:i16:$src1, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 03124 // Emits: (AND16ri8:i16 GR16:i16:$src1, (imm:i16):$src2) 03125 // Pattern complexity = 7 cost = 1 size = 3 03126 if (Predicate_i16immSExt8(N1.getNode())) { 03127 SDNode *Result = Emit_5(N, X86::AND16ri8, MVT::i16); 03128 return Result; 03129 } 03130 03131 // Pattern: (and:i16 GR16:i16:$src1, (imm:i16):$src2) 03132 // Emits: (AND16ri:i16 GR16:i16:$src1, (imm:i16):$src2) 03133 // Pattern complexity = 6 cost = 1 size = 3 03134 SDNode *Result = Emit_5(N, X86::AND16ri, MVT::i16); 03135 return Result; 03136 } 03137 } 03138 03139 // Pattern: (and:i16 GR16:i16:$src1, GR16:i16:$src2) 03140 // Emits: (AND16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 03141 // Pattern complexity = 3 cost = 1 size = 3 03142 SDNode *Result = Emit_1(N, X86::AND16rr, MVT::i16); 03143 return Result; 03144 } 03145 03146 SDNode *Emit_34(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 03147 SDValue N0 = N.getOperand(0); 03148 SDValue N1 = N.getOperand(1); 03149 SDValue Chain0 = N0.getOperand(0); 03150 SDValue N01 = N0.getOperand(1); 03151 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 03152 SDValue Ops0[] = { CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, LSI_N0, Chain0 }; 03153 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 7); 03154 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 03155 return ResNode; 03156 } 03157 SDNode *Emit_35(const SDValue &N, unsigned Opc0, unsigned Opc1, EVT VT0, EVT VT1) DISABLE_INLINE { 03158 SDValue N0 = N.getOperand(0); 03159 SDValue N1 = N.getOperand(1); 03160 SDValue Tmp2 = CurDAG->getTargetConstant(0x3ULL, MVT::i32); 03161 SDValue Tmp3(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N0, Tmp2), 0); 03162 return CurDAG->SelectNodeTo(N.getNode(), Opc1, VT1, Tmp3); 03163 } 03164 SDNode *Emit_36(const SDValue &N, unsigned Opc0, unsigned Opc1, unsigned Opc2, EVT VT0, EVT VT1, EVT VT2) DISABLE_INLINE { 03165 SDValue N0 = N.getOperand(0); 03166 SDValue N1 = N.getOperand(1); 03167 SDValue Tmp2 = CurDAG->getTargetConstant(X86::GR32_ABCDRegClassID, MVT::i32); 03168 SDValue Tmp3(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N0, Tmp2), 0); 03169 SDValue Tmp4 = CurDAG->getTargetConstant(0x1ULL, MVT::i32); 03170 SDValue Tmp5(CurDAG->getTargetNode(Opc1, N.getDebugLoc(), VT1, Tmp3, Tmp4), 0); 03171 return CurDAG->SelectNodeTo(N.getNode(), Opc2, VT2, Tmp5); 03172 } 03173 SDNode *Emit_37(const SDValue &N, unsigned Opc0, unsigned Opc1, unsigned Opc2, EVT VT0, EVT VT1, EVT VT2) DISABLE_INLINE { 03174 SDValue N0 = N.getOperand(0); 03175 SDValue N1 = N.getOperand(1); 03176 SDValue N00 = N0.getOperand(0); 03177 SDValue N01 = N0.getOperand(1); 03178 SDValue Tmp4 = CurDAG->getTargetConstant(X86::GR32_ABCDRegClassID, MVT::i32); 03179 SDValue Tmp5(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N00, Tmp4), 0); 03180 SDValue Tmp6 = CurDAG->getTargetConstant(0x2ULL, MVT::i32); 03181 SDValue Tmp7(CurDAG->getTargetNode(Opc1, N.getDebugLoc(), VT1, Tmp5, Tmp6), 0); 03182 return CurDAG->SelectNodeTo(N.getNode(), Opc2, VT2, Tmp7); 03183 } 03184 SDNode *Select_ISD_AND_i32(const SDValue &N) { 03185 if (OptLevel != CodeGenOpt::None) { 03186 SDValue N0 = N.getOperand(0); 03187 { 03188 SDValue N1 = N.getOperand(1); 03189 { 03190 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 03191 if (Tmp0) { 03192 03193 // Pattern: (and:i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_nvloadi32>>, 255:i32) 03194 // Emits: (MOVZX32rm8:i32 addr:iPTR:$src) 03195 // Pattern complexity = 30 cost = 1 size = 3 03196 if (CheckAndMask(N0, Tmp0, INT64_C(255)) && 03197 N0.getOpcode() == ISD::LOAD && 03198 N0.hasOneUse() && 03199 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 03200 SDValue Chain0 = N0.getOperand(0); 03201 if (Predicate_unindexedload(N0.getNode()) && 03202 Predicate_nvloadi32(N0.getNode())) { 03203 SDValue N01 = N0.getOperand(1); 03204 SDValue CPTmpN01_0; 03205 SDValue CPTmpN01_1; 03206 SDValue CPTmpN01_2; 03207 SDValue CPTmpN01_3; 03208 SDValue CPTmpN01_4; 03209 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 03210 SDNode *Result = Emit_34(N, X86::MOVZX32rm8, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 03211 return Result; 03212 } 03213 } 03214 } 03215 03216 // Pattern: (and:i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_nvloadi32>>, 65535:i32) 03217 // Emits: (MOVZX32rm16:i32 addr:iPTR:$src) 03218 // Pattern complexity = 30 cost = 1 size = 3 03219 if (CheckAndMask(N0, Tmp0, INT64_C(65535)) && 03220 N0.getOpcode() == ISD::LOAD && 03221 N0.hasOneUse() && 03222 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 03223 SDValue Chain0 = N0.getOperand(0); 03224 if (Predicate_unindexedload(N0.getNode()) && 03225 Predicate_nvloadi32(N0.getNode())) { 03226 SDValue N01 = N0.getOperand(1); 03227 SDValue CPTmpN01_0; 03228 SDValue CPTmpN01_1; 03229 SDValue CPTmpN01_2; 03230 SDValue CPTmpN01_3; 03231 SDValue CPTmpN01_4; 03232 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 03233 SDNode *Result = Emit_34(N, X86::MOVZX32rm16, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 03234 return Result; 03235 } 03236 } 03237 } 03238 } 03239 } 03240 03241 // Pattern: (and:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>) 03242 // Emits: (AND32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 03243 // Pattern complexity = 25 cost = 1 size = 3 03244 if (N1.getOpcode() == ISD::LOAD && 03245 N1.hasOneUse() && 03246 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 03247 SDValue Chain1 = N1.getOperand(0); 03248 if (Predicate_unindexedload(N1.getNode()) && 03249 Predicate_loadi32(N1.getNode())) { 03250 SDValue N11 = N1.getOperand(1); 03251 SDValue CPTmpN11_0; 03252 SDValue CPTmpN11_1; 03253 SDValue CPTmpN11_2; 03254 SDValue CPTmpN11_3; 03255 SDValue CPTmpN11_4; 03256 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 03257 SDNode *Result = Emit_2(N, X86::AND32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 03258 return Result; 03259 } 03260 } 03261 } 03262 } 03263 03264 // Pattern: (and:i32 (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src1) 03265 // Emits: (AND32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 03266 // Pattern complexity = 25 cost = 1 size = 3 03267 if (N0.getOpcode() == ISD::LOAD && 03268 N0.hasOneUse() && 03269 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 03270 SDValue Chain0 = N0.getOperand(0); 03271 if (Predicate_unindexedload(N0.getNode()) && 03272 Predicate_loadi32(N0.getNode())) { 03273 SDValue N01 = N0.getOperand(1); 03274 SDValue CPTmpN01_0; 03275 SDValue CPTmpN01_1; 03276 SDValue CPTmpN01_2; 03277 SDValue CPTmpN01_3; 03278 SDValue CPTmpN01_4; 03279 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 03280 SDNode *Result = Emit_4(N, X86::AND32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 03281 return Result; 03282 } 03283 } 03284 } 03285 } 03286 03287 // Pattern: (and:i32 (srl:i32 GR32:i32:$src, 8:i8)<<P:Predicate_srl_su>>, 255:i32) 03288 // Emits: (MOVZX32rr8:i32 (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i32 GR32:i32:$src, GR32_ABCD:i32), 2:i32)) 03289 // Pattern complexity = 17 cost = 3 size = 3 03290 if ((!Subtarget->is64Bit())) { 03291 SDValue N0 = N.getOperand(0); 03292 SDValue N1 = N.getOperand(1); 03293 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 03294 if (Tmp0 && 03295 CheckAndMask(N0, Tmp0, INT64_C(255)) && 03296 N0.getOpcode() == ISD::SRL && 03297 Predicate_srl_su(N0.getNode())) { 03298 SDValue N00 = N0.getOperand(0); 03299 SDValue N01 = N0.getOperand(1); 03300 ConstantSDNode *Tmp1 = dyn_cast<ConstantSDNode>(N01); 03301 if (Tmp1) { 03302 int64_t CN2 = Tmp1->getSExtValue(); 03303 if (CN2 == INT64_C(8) && 03304 N01.getNode()->getValueType(0) == MVT::i8) { 03305 SDNode *Result = Emit_37(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVZX32rr8, MVT::i32, MVT::i8, MVT::i32); 03306 return Result; 03307 } 03308 } 03309 } 03310 } 03311 03312 // Pattern: (and:i32 (srl:i32 GR32:i32:$src, 8:i8)<<P:Predicate_srl_su>>, 255:i32) 03313 // Emits: (MOVZX32_NOREXrr8:i32 (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i32 GR32:i32:$src, GR32_ABCD:i32), 2:i32)) 03314 // Pattern complexity = 17 cost = 3 size = 3 03315 if ((Subtarget->is64Bit())) { 03316 SDValue N0 = N.getOperand(0); 03317 SDValue N1 = N.getOperand(1); 03318 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 03319 if (Tmp0 && 03320 CheckAndMask(N0, Tmp0, INT64_C(255)) && 03321 N0.getOpcode() == ISD::SRL && 03322 Predicate_srl_su(N0.getNode())) { 03323 SDValue N00 = N0.getOperand(0); 03324 SDValue N01 = N0.getOperand(1); 03325 ConstantSDNode *Tmp1 = dyn_cast<ConstantSDNode>(N01); 03326 if (Tmp1) { 03327 int64_t CN2 = Tmp1->getSExtValue(); 03328 if (CN2 == INT64_C(8) && 03329 N01.getNode()->getValueType(0) == MVT::i8) { 03330 SDNode *Result = Emit_37(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVZX32_NOREXrr8, MVT::i32, MVT::i8, MVT::i32); 03331 return Result; 03332 } 03333 } 03334 } 03335 } 03336 03337 // Pattern: (and:i32 GR32:i32:$src1, 65535:i32) 03338 // Emits: (MOVZX32rr16:i32 (EXTRACT_SUBREG:i16 GR32:i32:$src1, 3:i32)) 03339 // Pattern complexity = 8 cost = 2 size = 3 03340 { 03341 SDValue N0 = N.getOperand(0); 03342 SDValue N1 = N.getOperand(1); 03343 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 03344 if (Tmp0 && 03345 CheckAndMask(N0, Tmp0, INT64_C(65535))) { 03346 SDNode *Result = Emit_35(N, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVZX32rr16, MVT::i16, MVT::i32); 03347 return Result; 03348 } 03349 } 03350 03351 // Pattern: (and:i32 GR32:i32:$src1, 255:i32) 03352 // Emits: (MOVZX32rr8:i32 (EXTRACT_SUBREG:i8 GR32:i32:$src1, 1:i32)) 03353 // Pattern complexity = 8 cost = 2 size = 3 03354 if ((Subtarget->is64Bit())) { 03355 SDValue N0 = N.getOperand(0); 03356 SDValue N1 = N.getOperand(1); 03357 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 03358 if (Tmp0 && 03359 CheckAndMask(N0, Tmp0, INT64_C(255))) { 03360 SDNode *Result = Emit_33(N, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVZX32rr8, MVT::i8, MVT::i32); 03361 return Result; 03362 } 03363 } 03364 03365 // Pattern: (and:i32 GR32:i32:$src1, 255:i32) 03366 // Emits: (MOVZX32rr8:i32 (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i32 GR32:i32:$src1, GR32_ABCD:i32), 1:i32)) 03367 // Pattern complexity = 8 cost = 3 size = 3 03368 if ((!Subtarget->is64Bit())) { 03369 SDValue N0 = N.getOperand(0); 03370 SDValue N1 = N.getOperand(1); 03371 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 03372 if (Tmp0 && 03373 CheckAndMask(N0, Tmp0, INT64_C(255))) { 03374 SDNode *Result = Emit_36(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVZX32rr8, MVT::i32, MVT::i8, MVT::i32); 03375 return Result; 03376 } 03377 } 03378 { 03379 SDValue N0 = N.getOperand(0); 03380 SDValue N1 = N.getOperand(1); 03381 if (N1.getOpcode() == ISD::Constant) { 03382 03383 // Pattern: (and:i32 GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 03384 // Emits: (AND32ri8:i32 GR32:i32:$src1, (imm:i32):$src2) 03385 // Pattern complexity = 7 cost = 1 size = 3 03386 if (Predicate_i32immSExt8(N1.getNode())) { 03387 SDNode *Result = Emit_8(N, X86::AND32ri8, MVT::i32); 03388 return Result; 03389 } 03390 03391 // Pattern: (and:i32 GR32:i32:$src1, (imm:i32):$src2) 03392 // Emits: (AND32ri:i32 GR32:i32:$src1, (imm:i32):$src2) 03393 // Pattern complexity = 6 cost = 1 size = 3 03394 SDNode *Result = Emit_8(N, X86::AND32ri, MVT::i32); 03395 return Result; 03396 } 03397 } 03398 03399 // Pattern: (and:i32 GR32:i32:$src1, GR32:i32:$src2) 03400 // Emits: (AND32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 03401 // Pattern complexity = 3 cost = 1 size = 3 03402 SDNode *Result = Emit_1(N, X86::AND32rr, MVT::i32); 03403 return Result; 03404 } 03405 03406 SDNode *Emit_38(const SDValue &N, unsigned Opc0, unsigned Opc1, EVT VT0, EVT VT1) DISABLE_INLINE { 03407 SDValue N0 = N.getOperand(0); 03408 SDValue N1 = N.getOperand(1); 03409 SDValue Tmp2 = CurDAG->getTargetConstant(0x4ULL, MVT::i32); 03410 SDValue Tmp3(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N0, Tmp2), 0); 03411 return CurDAG->SelectNodeTo(N.getNode(), Opc1, VT1, Tmp3); 03412 } 03413 SDNode *Emit_39(const SDValue &N, unsigned Opc0, unsigned Opc1, unsigned Opc2, unsigned Opc3, EVT VT0, EVT VT1, EVT VT2, EVT VT3) DISABLE_INLINE { 03414 SDValue N0 = N.getOperand(0); 03415 SDValue N1 = N.getOperand(1); 03416 SDValue N00 = N0.getOperand(0); 03417 SDValue N01 = N0.getOperand(1); 03418 SDValue Tmp3 = CurDAG->getTargetConstant(0x0ULL, MVT::i64); 03419 SDValue Tmp5 = CurDAG->getTargetConstant(X86::GR64_ABCDRegClassID, MVT::i32); 03420 SDValue Tmp6(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N00, Tmp5), 0); 03421 SDValue Tmp7 = CurDAG->getTargetConstant(0x2ULL, MVT::i32); 03422 SDValue Tmp8(CurDAG->getTargetNode(Opc1, N.getDebugLoc(), VT1, Tmp6, Tmp7), 0); 03423 SDValue Tmp9(CurDAG->getTargetNode(Opc2, N.getDebugLoc(), VT2, Tmp8), 0); 03424 SDValue Tmp10 = CurDAG->getTargetConstant(0x4ULL, MVT::i32); 03425 return CurDAG->SelectNodeTo(N.getNode(), Opc3, VT3, Tmp3, Tmp9, Tmp10); 03426 } 03427 SDNode *Select_ISD_AND_i64(const SDValue &N) { 03428 if (OptLevel != CodeGenOpt::None) { 03429 SDValue N0 = N.getOperand(0); 03430 03431 // Pattern: (and:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 03432 // Emits: (AND64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 03433 // Pattern complexity = 25 cost = 1 size = 3 03434 { 03435 SDValue N1 = N.getOperand(1); 03436 if (N1.getOpcode() == ISD::LOAD && 03437 N1.hasOneUse() && 03438 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 03439 SDValue Chain1 = N1.getOperand(0); 03440 if (Predicate_unindexedload(N1.getNode()) && 03441 Predicate_load(N1.getNode())) { 03442 SDValue N11 = N1.getOperand(1); 03443 SDValue CPTmpN11_0; 03444 SDValue CPTmpN11_1; 03445 SDValue CPTmpN11_2; 03446 SDValue CPTmpN11_3; 03447 SDValue CPTmpN11_4; 03448 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 03449 SDNode *Result = Emit_2(N, X86::AND64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 03450 return Result; 03451 } 03452 } 03453 } 03454 } 03455 03456 // Pattern: (and:i64 (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR64:i64:$src1) 03457 // Emits: (AND64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 03458 // Pattern complexity = 25 cost = 1 size = 3 03459 if (N0.getOpcode() == ISD::LOAD && 03460 N0.hasOneUse() && 03461 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 03462 SDValue Chain0 = N0.getOperand(0); 03463 if (Predicate_unindexedload(N0.getNode()) && 03464 Predicate_load(N0.getNode())) { 03465 SDValue N01 = N0.getOperand(1); 03466 SDValue CPTmpN01_0; 03467 SDValue CPTmpN01_1; 03468 SDValue CPTmpN01_2; 03469 SDValue CPTmpN01_3; 03470 SDValue CPTmpN01_4; 03471 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 03472 SDNode *Result = Emit_4(N, X86::AND64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 03473 return Result; 03474 } 03475 } 03476 } 03477 } 03478 { 03479 SDValue N0 = N.getOperand(0); 03480 SDValue N1 = N.getOperand(1); 03481 { 03482 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 03483 if (Tmp0) { 03484 03485 // Pattern: (and:i64 (srl:i64 GR64:i64:$src, 8:i8)<<P:Predicate_srl_su>>, 255:i64) 03486 // Emits: (SUBREG_TO_REG:i64 0:i64, (MOVZX32_NOREXrr8:i32 (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i64 GR64:i64:$src, GR64_ABCD:i64), 2:i32)), 4:i32) 03487 // Pattern complexity = 17 cost = 4 size = 3 03488 if (CheckAndMask(N0, Tmp0, INT64_C(255)) && 03489 N0.getOpcode() == ISD::SRL && 03490 Predicate_srl_su(N0.getNode())) { 03491 SDValue N00 = N0.getOperand(0); 03492 SDValue N01 = N0.getOperand(1); 03493 ConstantSDNode *Tmp1 = dyn_cast<ConstantSDNode>(N01); 03494 if (Tmp1) { 03495 int64_t CN2 = Tmp1->getSExtValue(); 03496 if (CN2 == INT64_C(8) && 03497 N01.getNode()->getValueType(0) == MVT::i8) { 03498 SDNode *Result = Emit_39(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVZX32_NOREXrr8, TargetInstrInfo::SUBREG_TO_REG, MVT::i64, MVT::i8, MVT::i32, MVT::i64); 03499 return Result; 03500 } 03501 } 03502 } 03503 03504 // Pattern: (and:i64 GR64:i64:$src, 4294967295:i64) 03505 // Emits: (MOVZX64rr32:i64 (EXTRACT_SUBREG:i32 GR64:i64:$src, 4:i32)) 03506 // Pattern complexity = 8 cost = 2 size = 3 03507 if (CheckAndMask(N0, Tmp0, INT64_C(4294967295))) { 03508 SDNode *Result = Emit_38(N, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVZX64rr32, MVT::i32, MVT::i64); 03509 return Result; 03510 } 03511 03512 // Pattern: (and:i64 GR64:i64:$src, 65535:i64) 03513 // Emits: (MOVZX64rr16:i64 (EXTRACT_SUBREG:i16 GR64:i64:$src, 3:i32)) 03514 // Pattern complexity = 8 cost = 2 size = 3 03515 if (CheckAndMask(N0, Tmp0, INT64_C(65535))) { 03516 SDNode *Result = Emit_35(N, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVZX64rr16, MVT::i16, MVT::i64); 03517 return Result; 03518 } 03519 03520 // Pattern: (and:i64 GR64:i64:$src, 255:i64) 03521 // Emits: (MOVZX64rr8:i64 (EXTRACT_SUBREG:i8 GR64:i64:$src, 1:i32)) 03522 // Pattern complexity = 8 cost = 2 size = 3 03523 if (CheckAndMask(N0, Tmp0, INT64_C(255))) { 03524 SDNode *Result = Emit_33(N, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVZX64rr8, MVT::i8, MVT::i64); 03525 return Result; 03526 } 03527 } 03528 } 03529 if (N1.getOpcode() == ISD::Constant) { 03530 03531 // Pattern: (and:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 03532 // Emits: (AND64ri8:i64 GR64:i64:$src1, (imm:i64):$src2) 03533 // Pattern complexity = 7 cost = 1 size = 3 03534 if (Predicate_i64immSExt8(N1.getNode())) { 03535 SDNode *Result = Emit_12(N, X86::AND64ri8, MVT::i64); 03536 return Result; 03537 } 03538 03539 // Pattern: (and:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 03540 // Emits: (AND64ri32:i64 GR64:i64:$src1, (imm:i64):$src2) 03541 // Pattern complexity = 7 cost = 1 size = 3 03542 if (Predicate_i64immSExt32(N1.getNode())) { 03543 SDNode *Result = Emit_12(N, X86::AND64ri32, MVT::i64); 03544 return Result; 03545 } 03546 } 03547 } 03548 03549 // Pattern: (and:i64 GR64:i64:$src1, GR64:i64:$src2) 03550 // Emits: (AND64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 03551 // Pattern complexity = 3 cost = 1 size = 3 03552 SDNode *Result = Emit_1(N, X86::AND64rr, MVT::i64); 03553 return Result; 03554 } 03555 03556 SDNode *Emit_40(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 03557 SDValue N0 = N.getOperand(0); 03558 SDValue N00 = N0.getOperand(0); 03559 SDValue N01 = N0.getOperand(1); 03560 SDValue N1 = N.getOperand(1); 03561 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N00, N1); 03562 } 03563 SDNode *Emit_41(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 03564 SDValue N0 = N.getOperand(0); 03565 SDValue N00 = N0.getOperand(0); 03566 SDValue N01 = N0.getOperand(1); 03567 SDValue N1 = N.getOperand(1); 03568 SDValue Chain1 = N1.getOperand(0); 03569 SDValue N11 = N1.getOperand(1); 03570 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 03571 SDValue Ops0[] = { N00, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1 }; 03572 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 03573 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 03574 return ResNode; 03575 } 03576 SDNode *Emit_42(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 03577 SDValue N0 = N.getOperand(0); 03578 SDValue N00 = N0.getOperand(0); 03579 SDValue N01 = N0.getOperand(1); 03580 SDValue N010 = N01.getOperand(0); 03581 SDValue N1 = N.getOperand(1); 03582 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N00, N1); 03583 } 03584 SDNode *Emit_43(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 03585 SDValue N0 = N.getOperand(0); 03586 SDValue N00 = N0.getOperand(0); 03587 SDValue N01 = N0.getOperand(1); 03588 SDValue N010 = N01.getOperand(0); 03589 SDValue N1 = N.getOperand(1); 03590 SDValue Chain1 = N1.getOperand(0); 03591 SDValue N11 = N1.getOperand(1); 03592 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 03593 SDValue Ops0[] = { N00, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1 }; 03594 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 03595 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 03596 return ResNode; 03597 } 03598 SDNode *Emit_44(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 03599 SDValue N0 = N.getOperand(0); 03600 SDValue N00 = N0.getOperand(0); 03601 SDValue N01 = N0.getOperand(1); 03602 SDValue N1 = N.getOperand(1); 03603 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N01, N1); 03604 } 03605 SDNode *Emit_45(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 03606 SDValue N0 = N.getOperand(0); 03607 SDValue N1 = N.getOperand(1); 03608 SDValue N10 = N1.getOperand(0); 03609 SDValue N11 = N1.getOperand(1); 03610 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N10, N0); 03611 } 03612 SDNode *Emit_46(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 03613 SDValue N0 = N.getOperand(0); 03614 SDValue N1 = N.getOperand(1); 03615 SDValue N10 = N1.getOperand(0); 03616 SDValue N11 = N1.getOperand(1); 03617 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N11, N0); 03618 } 03619 SDNode *Emit_47(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 03620 SDValue N0 = N.getOperand(0); 03621 SDValue N00 = N0.getOperand(0); 03622 SDValue N01 = N0.getOperand(1); 03623 SDValue N1 = N.getOperand(1); 03624 SDValue Chain1 = N1.getOperand(0); 03625 SDValue N11 = N1.getOperand(1); 03626 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 03627 SDValue Ops0[] = { N01, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1 }; 03628 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 03629 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 03630 return ResNode; 03631 } 03632 SDNode *Emit_48(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 03633 SDValue N0 = N.getOperand(0); 03634 SDValue Chain0 = N0.getOperand(0); 03635 SDValue N01 = N0.getOperand(1); 03636 SDValue N1 = N.getOperand(1); 03637 SDValue N10 = N1.getOperand(0); 03638 SDValue N11 = N1.getOperand(1); 03639 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 03640 SDValue Ops0[] = { N10, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, LSI_N0, Chain0 }; 03641 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 03642 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 03643 return ResNode; 03644 } 03645 SDNode *Emit_49(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 03646 SDValue N0 = N.getOperand(0); 03647 SDValue Chain0 = N0.getOperand(0); 03648 SDValue N01 = N0.getOperand(1); 03649 SDValue N1 = N.getOperand(1); 03650 SDValue N10 = N1.getOperand(0); 03651 SDValue N11 = N1.getOperand(1); 03652 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 03653 SDValue Ops0[] = { N11, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, LSI_N0, Chain0 }; 03654 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 03655 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 03656 return ResNode; 03657 } 03658 SDNode *Emit_50(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 03659 SDValue N0 = N.getOperand(0); 03660 SDValue N00 = N0.getOperand(0); 03661 SDValue N000 = N00.getOperand(0); 03662 SDValue N01 = N0.getOperand(1); 03663 SDValue N1 = N.getOperand(1); 03664 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N01, N1); 03665 } 03666 SDNode *Emit_51(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 03667 SDValue N0 = N.getOperand(0); 03668 SDValue N1 = N.getOperand(1); 03669 SDValue N10 = N1.getOperand(0); 03670 SDValue N11 = N1.getOperand(1); 03671 SDValue N110 = N11.getOperand(0); 03672 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N10, N0); 03673 } 03674 SDNode *Emit_52(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 03675 SDValue N0 = N.getOperand(0); 03676 SDValue N1 = N.getOperand(1); 03677 SDValue N10 = N1.getOperand(0); 03678 SDValue N100 = N10.getOperand(0); 03679 SDValue N11 = N1.getOperand(1); 03680 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N11, N0); 03681 } 03682 SDNode *Emit_53(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 03683 SDValue N0 = N.getOperand(0); 03684 SDValue N00 = N0.getOperand(0); 03685 SDValue N000 = N00.getOperand(0); 03686 SDValue N01 = N0.getOperand(1); 03687 SDValue N1 = N.getOperand(1); 03688 SDValue Chain1 = N1.getOperand(0); 03689 SDValue N11 = N1.getOperand(1); 03690 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 03691 SDValue Ops0[] = { N01, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1 }; 03692 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 03693 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 03694 return ResNode; 03695 } 03696 SDNode *Emit_54(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 03697 SDValue N0 = N.getOperand(0); 03698 SDValue Chain0 = N0.getOperand(0); 03699 SDValue N01 = N0.getOperand(1); 03700 SDValue N1 = N.getOperand(1); 03701 SDValue N10 = N1.getOperand(0); 03702 SDValue N11 = N1.getOperand(1); 03703 SDValue N110 = N11.getOperand(0); 03704 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 03705 SDValue Ops0[] = { N10, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, LSI_N0, Chain0 }; 03706 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 03707 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 03708 return ResNode; 03709 } 03710 SDNode *Emit_55(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 03711 SDValue N0 = N.getOperand(0); 03712 SDValue Chain0 = N0.getOperand(0); 03713 SDValue N01 = N0.getOperand(1); 03714 SDValue N1 = N.getOperand(1); 03715 SDValue N10 = N1.getOperand(0); 03716 SDValue N100 = N10.getOperand(0); 03717 SDValue N11 = N1.getOperand(1); 03718 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 03719 SDValue Ops0[] = { N11, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, LSI_N0, Chain0 }; 03720 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 03721 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 03722 return ResNode; 03723 } 03724 SDNode *Select_ISD_AND_v1i64(const SDValue &N) { 03725 if (OptLevel != CodeGenOpt::None) { 03726 { 03727 SDValue N0 = N.getOperand(0); 03728 if (N0.getOpcode() == ISD::XOR) { 03729 SDValue N00 = N0.getOperand(0); 03730 { 03731 SDValue N01 = N0.getOperand(1); 03732 if (N01.getOpcode() == ISD::BIT_CONVERT) { 03733 SDValue N010 = N01.getOperand(0); 03734 03735 // Pattern: (and:v1i64 (xor:v1i64 VR64:v1i64:$src1, (bitconvert:v1i64 (build_vector:v2i32)<<P:Predicate_immAllOnesV>>)), (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 03736 // Emits: (MMX_PANDNrm:v1i64 VR64:v8i8:$src1, addr:iPTR:$src2) 03737 // Pattern complexity = 35 cost = 1 size = 3 03738 if (N010.getOpcode() == ISD::BUILD_VECTOR && 03739 Predicate_immAllOnesV(N010.getNode())) { 03740 SDValue N1 = N.getOperand(1); 03741 if (N1.getOpcode() == ISD::LOAD && 03742 N1.hasOneUse() && 03743 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 03744 SDValue Chain1 = N1.getOperand(0); 03745 if (Predicate_unindexedload(N1.getNode()) && 03746 Predicate_load(N1.getNode())) { 03747 SDValue N11 = N1.getOperand(1); 03748 SDValue CPTmpN11_0; 03749 SDValue CPTmpN11_1; 03750 SDValue CPTmpN11_2; 03751 SDValue CPTmpN11_3; 03752 SDValue CPTmpN11_4; 03753 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 03754 N010.getNode()->getValueType(0) == MVT::v2i32) { 03755 SDNode *Result = Emit_43(N, X86::MMX_PANDNrm, MVT::v1i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 03756 return Result; 03757 } 03758 } 03759 } 03760 } 03761 if (N010.getOpcode() == ISD::BIT_CONVERT && 03762 Predicate_immAllOnesV_bc(N010.getNode())) { 03763 SDValue N1 = N.getOperand(1); 03764 if (N1.getOpcode() == ISD::LOAD && 03765 N1.hasOneUse() && 03766 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 03767 SDValue Chain1 = N1.getOperand(0); 03768 if (Predicate_unindexedload(N1.getNode()) && 03769 Predicate_load(N1.getNode())) { 03770 SDValue N11 = N1.getOperand(1); 03771 SDValue CPTmpN11_0; 03772 SDValue CPTmpN11_1; 03773 SDValue CPTmpN11_2; 03774 SDValue CPTmpN11_3; 03775 SDValue CPTmpN11_4; 03776 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 03777 03778 // Pattern: (and:v1i64 (xor:v1i64 VR64:v1i64:$src1, (bitconvert:v1i64 (bitconvert:v4i16)<<P:Predicate_immAllOnesV_bc>>)), (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 03779 // Emits: (MMX_PANDNrm:v1i64 VR64:v8i8:$src1, addr:iPTR:$src2) 03780 // Pattern complexity = 35 cost = 1 size = 3 03781 if (N010.getNode()->getValueType(0) == MVT::v4i16) { 03782 SDNode *Result = Emit_43(N, X86::MMX_PANDNrm, MVT::v1i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 03783 return Result; 03784 } 03785 03786 // Pattern: (and:v1i64 (xor:v1i64 VR64:v1i64:$src1, (bitconvert:v1i64 (bitconvert:v8i8)<<P:Predicate_immAllOnesV_bc>>)), (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 03787 // Emits: (MMX_PANDNrm:v1i64 VR64:v8i8:$src1, addr:iPTR:$src2) 03788 // Pattern complexity = 35 cost = 1 size = 3 03789 if (N010.getNode()->getValueType(0) == MVT::v8i8) { 03790 SDNode *Result = Emit_43(N, X86::MMX_PANDNrm, MVT::v1i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 03791 return Result; 03792 } 03793 } 03794 } 03795 } 03796 } 03797 } 03798 } 03799 03800 // Pattern: (and:v1i64 (xor:v1i64 (bitconvert:v1i64 (build_vector:v2i32)<<P:Predicate_immAllOnesV>>), VR64:v1i64:$src1), (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 03801 // Emits: (MMX_PANDNrm:v1i64 VR64:v8i8:$src1, addr:iPTR:$src2) 03802 // Pattern complexity = 35 cost = 1 size = 3 03803 if (N00.getOpcode() == ISD::BIT_CONVERT) { 03804 SDValue N000 = N00.getOperand(0); 03805 if (N000.getOpcode() == ISD::BUILD_VECTOR && 03806 Predicate_immAllOnesV(N000.getNode())) { 03807 SDValue N01 = N0.getOperand(1); 03808 SDValue N1 = N.getOperand(1); 03809 if (N1.getOpcode() == ISD::LOAD && 03810 N1.hasOneUse() && 03811 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 03812 SDValue Chain1 = N1.getOperand(0); 03813 if (Predicate_unindexedload(N1.getNode()) && 03814 Predicate_load(N1.getNode())) { 03815 SDValue N11 = N1.getOperand(1); 03816 SDValue CPTmpN11_0; 03817 SDValue CPTmpN11_1; 03818 SDValue CPTmpN11_2; 03819 SDValue CPTmpN11_3; 03820 SDValue CPTmpN11_4; 03821 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 03822 N000.getNode()->getValueType(0) == MVT::v2i32) { 03823 SDNode *Result = Emit_53(N, X86::MMX_PANDNrm, MVT::v1i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 03824 return Result; 03825 } 03826 } 03827 } 03828 } 03829 } 03830 } 03831 if (N0.getOpcode() == ISD::LOAD && 03832 N0.hasOneUse() && 03833 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 03834 SDValue Chain0 = N0.getOperand(0); 03835 if (Predicate_unindexedload(N0.getNode()) && 03836 Predicate_load(N0.getNode())) { 03837 SDValue N01 = N0.getOperand(1); 03838 SDValue CPTmpN01_0; 03839 SDValue CPTmpN01_1; 03840 SDValue CPTmpN01_2; 03841 SDValue CPTmpN01_3; 03842 SDValue CPTmpN01_4; 03843 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 03844 SDValue N1 = N.getOperand(1); 03845 if (N1.getOpcode() == ISD::XOR) { 03846 SDValue N10 = N1.getOperand(0); 03847 03848 // Pattern: (and:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (xor:v1i64 VR64:v1i64:$src1, (bitconvert:v1i64 (build_vector:v2i32)<<P:Predicate_immAllOnesV>>))) 03849 // Emits: (MMX_PANDNrm:v1i64 VR64:v8i8:$src1, addr:iPTR:$src2) 03850 // Pattern complexity = 35 cost = 1 size = 3 03851 { 03852 SDValue N11 = N1.getOperand(1); 03853 if (N11.getOpcode() == ISD::BIT_CONVERT) { 03854 SDValue N110 = N11.getOperand(0); 03855 if (N110.getOpcode() == ISD::BUILD_VECTOR && 03856 Predicate_immAllOnesV(N110.getNode()) && 03857 N110.getNode()->getValueType(0) == MVT::v2i32) { 03858 SDNode *Result = Emit_54(N, X86::MMX_PANDNrm, MVT::v1i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 03859 return Result; 03860 } 03861 } 03862 } 03863 03864 // Pattern: (and:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (xor:v1i64 (bitconvert:v1i64 (build_vector:v2i32)<<P:Predicate_immAllOnesV>>), VR64:v1i64:$src1)) 03865 // Emits: (MMX_PANDNrm:v1i64 VR64:v8i8:$src1, addr:iPTR:$src2) 03866 // Pattern complexity = 35 cost = 1 size = 3 03867 if (N10.getOpcode() == ISD::BIT_CONVERT) { 03868 SDValue N100 = N10.getOperand(0); 03869 if (N100.getOpcode() == ISD::BUILD_VECTOR && 03870 Predicate_immAllOnesV(N100.getNode())) { 03871 SDValue N11 = N1.getOperand(1); 03872 if (N100.getNode()->getValueType(0) == MVT::v2i32) { 03873 SDNode *Result = Emit_55(N, X86::MMX_PANDNrm, MVT::v1i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 03874 return Result; 03875 } 03876 } 03877 } 03878 } 03879 } 03880 } 03881 } 03882 03883 // Pattern: (and:v1i64 (xor:v1i64 (bitconvert:v1i64 (bitconvert:v4i16)<<P:Predicate_immAllOnesV_bc>>), VR64:v1i64:$src1), (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 03884 // Emits: (MMX_PANDNrm:v1i64 VR64:v8i8:$src1, addr:iPTR:$src2) 03885 // Pattern complexity = 35 cost = 1 size = 3 03886 if (N0.getOpcode() == ISD::XOR) { 03887 SDValue N00 = N0.getOperand(0); 03888 if (N00.getOpcode() == ISD::BIT_CONVERT) { 03889 SDValue N000 = N00.getOperand(0); 03890 if (N000.getOpcode() == ISD::BIT_CONVERT && 03891 Predicate_immAllOnesV_bc(N000.getNode())) { 03892 SDValue N01 = N0.getOperand(1); 03893 SDValue N1 = N.getOperand(1); 03894 if (N1.getOpcode() == ISD::LOAD && 03895 N1.hasOneUse() && 03896 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 03897 SDValue Chain1 = N1.getOperand(0); 03898 if (Predicate_unindexedload(N1.getNode()) && 03899 Predicate_load(N1.getNode())) { 03900 SDValue N11 = N1.getOperand(1); 03901 SDValue CPTmpN11_0; 03902 SDValue CPTmpN11_1; 03903 SDValue CPTmpN11_2; 03904 SDValue CPTmpN11_3; 03905 SDValue CPTmpN11_4; 03906 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 03907 N000.getNode()->getValueType(0) == MVT::v4i16) { 03908 SDNode *Result = Emit_53(N, X86::MMX_PANDNrm, MVT::v1i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 03909 return Result; 03910 } 03911 } 03912 } 03913 } 03914 } 03915 } 03916 if (N0.getOpcode() == ISD::LOAD && 03917 N0.hasOneUse() && 03918 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 03919 SDValue Chain0 = N0.getOperand(0); 03920 if (Predicate_unindexedload(N0.getNode()) && 03921 Predicate_load(N0.getNode())) { 03922 SDValue N01 = N0.getOperand(1); 03923 SDValue CPTmpN01_0; 03924 SDValue CPTmpN01_1; 03925 SDValue CPTmpN01_2; 03926 SDValue CPTmpN01_3; 03927 SDValue CPTmpN01_4; 03928 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 03929 SDValue N1 = N.getOperand(1); 03930 if (N1.getOpcode() == ISD::XOR) { 03931 SDValue N10 = N1.getOperand(0); 03932 03933 // Pattern: (and:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (xor:v1i64 VR64:v1i64:$src1, (bitconvert:v1i64 (bitconvert:v4i16)<<P:Predicate_immAllOnesV_bc>>))) 03934 // Emits: (MMX_PANDNrm:v1i64 VR64:v8i8:$src1, addr:iPTR:$src2) 03935 // Pattern complexity = 35 cost = 1 size = 3 03936 { 03937 SDValue N11 = N1.getOperand(1); 03938 if (N11.getOpcode() == ISD::BIT_CONVERT) { 03939 SDValue N110 = N11.getOperand(0); 03940 if (N110.getOpcode() == ISD::BIT_CONVERT && 03941 Predicate_immAllOnesV_bc(N110.getNode()) && 03942 N110.getNode()->getValueType(0) == MVT::v4i16) { 03943 SDNode *Result = Emit_54(N, X86::MMX_PANDNrm, MVT::v1i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 03944 return Result; 03945 } 03946 } 03947 } 03948 03949 // Pattern: (and:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (xor:v1i64 (bitconvert:v1i64 (bitconvert:v4i16)<<P:Predicate_immAllOnesV_bc>>), VR64:v1i64:$src1)) 03950 // Emits: (MMX_PANDNrm:v1i64 VR64:v8i8:$src1, addr:iPTR:$src2) 03951 // Pattern complexity = 35 cost = 1 size = 3 03952 if (N10.getOpcode() == ISD::BIT_CONVERT) { 03953 SDValue N100 = N10.getOperand(0); 03954 if (N100.getOpcode() == ISD::BIT_CONVERT && 03955 Predicate_immAllOnesV_bc(N100.getNode())) { 03956 SDValue N11 = N1.getOperand(1); 03957 if (N100.getNode()->getValueType(0) == MVT::v4i16) { 03958 SDNode *Result = Emit_55(N, X86::MMX_PANDNrm, MVT::v1i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 03959 return Result; 03960 } 03961 } 03962 } 03963 } 03964 } 03965 } 03966 } 03967 03968 // Pattern: (and:v1i64 (xor:v1i64 (bitconvert:v1i64 (bitconvert:v8i8)<<P:Predicate_immAllOnesV_bc>>), VR64:v1i64:$src1), (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 03969 // Emits: (MMX_PANDNrm:v1i64 VR64:v8i8:$src1, addr:iPTR:$src2) 03970 // Pattern complexity = 35 cost = 1 size = 3 03971 if (N0.getOpcode() == ISD::XOR) { 03972 SDValue N00 = N0.getOperand(0); 03973 if (N00.getOpcode() == ISD::BIT_CONVERT) { 03974 SDValue N000 = N00.getOperand(0); 03975 if (N000.getOpcode() == ISD::BIT_CONVERT && 03976 Predicate_immAllOnesV_bc(N000.getNode())) { 03977 SDValue N01 = N0.getOperand(1); 03978 SDValue N1 = N.getOperand(1); 03979 if (N1.getOpcode() == ISD::LOAD && 03980 N1.hasOneUse() && 03981 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 03982 SDValue Chain1 = N1.getOperand(0); 03983 if (Predicate_unindexedload(N1.getNode()) && 03984 Predicate_load(N1.getNode())) { 03985 SDValue N11 = N1.getOperand(1); 03986 SDValue CPTmpN11_0; 03987 SDValue CPTmpN11_1; 03988 SDValue CPTmpN11_2; 03989 SDValue CPTmpN11_3; 03990 SDValue CPTmpN11_4; 03991 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 03992 N000.getNode()->getValueType(0) == MVT::v8i8) { 03993 SDNode *Result = Emit_53(N, X86::MMX_PANDNrm, MVT::v1i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 03994 return Result; 03995 } 03996 } 03997 } 03998 } 03999 } 04000 } 04001 if (N0.getOpcode() == ISD::LOAD && 04002 N0.hasOneUse() && 04003 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 04004 SDValue Chain0 = N0.getOperand(0); 04005 if (Predicate_unindexedload(N0.getNode()) && 04006 Predicate_load(N0.getNode())) { 04007 SDValue N01 = N0.getOperand(1); 04008 SDValue CPTmpN01_0; 04009 SDValue CPTmpN01_1; 04010 SDValue CPTmpN01_2; 04011 SDValue CPTmpN01_3; 04012 SDValue CPTmpN01_4; 04013 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 04014 SDValue N1 = N.getOperand(1); 04015 if (N1.getOpcode() == ISD::XOR) { 04016 SDValue N10 = N1.getOperand(0); 04017 04018 // Pattern: (and:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (xor:v1i64 VR64:v1i64:$src1, (bitconvert:v1i64 (bitconvert:v8i8)<<P:Predicate_immAllOnesV_bc>>))) 04019 // Emits: (MMX_PANDNrm:v1i64 VR64:v8i8:$src1, addr:iPTR:$src2) 04020 // Pattern complexity = 35 cost = 1 size = 3 04021 { 04022 SDValue N11 = N1.getOperand(1); 04023 if (N11.getOpcode() == ISD::BIT_CONVERT) { 04024 SDValue N110 = N11.getOperand(0); 04025 if (N110.getOpcode() == ISD::BIT_CONVERT && 04026 Predicate_immAllOnesV_bc(N110.getNode()) && 04027 N110.getNode()->getValueType(0) == MVT::v8i8) { 04028 SDNode *Result = Emit_54(N, X86::MMX_PANDNrm, MVT::v1i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 04029 return Result; 04030 } 04031 } 04032 } 04033 04034 // Pattern: (and:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (xor:v1i64 (bitconvert:v1i64 (bitconvert:v8i8)<<P:Predicate_immAllOnesV_bc>>), VR64:v1i64:$src1)) 04035 // Emits: (MMX_PANDNrm:v1i64 VR64:v8i8:$src1, addr:iPTR:$src2) 04036 // Pattern complexity = 35 cost = 1 size = 3 04037 if (N10.getOpcode() == ISD::BIT_CONVERT) { 04038 SDValue N100 = N10.getOperand(0); 04039 if (N100.getOpcode() == ISD::BIT_CONVERT && 04040 Predicate_immAllOnesV_bc(N100.getNode())) { 04041 SDValue N11 = N1.getOperand(1); 04042 if (N100.getNode()->getValueType(0) == MVT::v8i8) { 04043 SDNode *Result = Emit_55(N, X86::MMX_PANDNrm, MVT::v1i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 04044 return Result; 04045 } 04046 } 04047 } 04048 } 04049 } 04050 } 04051 } 04052 } 04053 if ((Subtarget->hasMMX())) { 04054 SDValue N0 = N.getOperand(0); 04055 if (N0.getOpcode() == ISD::XOR) { 04056 SDValue N00 = N0.getOperand(0); 04057 04058 // Pattern: (and:v1i64 (xor:v1i64 VR64:v1i64:$src1, (build_vector:v1i64)<<P:Predicate_immAllOnesV>>), (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 04059 // Emits: (MMX_PANDNrm:v1i64 VR64:v1i64:$src1, addr:iPTR:$src2) 04060 // Pattern complexity = 32 cost = 1 size = 3 04061 { 04062 SDValue N01 = N0.getOperand(1); 04063 if (N01.getOpcode() == ISD::BUILD_VECTOR && 04064 Predicate_immAllOnesV(N01.getNode())) { 04065 SDValue N1 = N.getOperand(1); 04066 if (N1.getOpcode() == ISD::LOAD && 04067 N1.hasOneUse() && 04068 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 04069 SDValue Chain1 = N1.getOperand(0); 04070 if (Predicate_unindexedload(N1.getNode()) && 04071 Predicate_load(N1.getNode())) { 04072 SDValue N11 = N1.getOperand(1); 04073 SDValue CPTmpN11_0; 04074 SDValue CPTmpN11_1; 04075 SDValue CPTmpN11_2; 04076 SDValue CPTmpN11_3; 04077 SDValue CPTmpN11_4; 04078 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 04079 SDNode *Result = Emit_41(N, X86::MMX_PANDNrm, MVT::v1i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 04080 return Result; 04081 } 04082 } 04083 } 04084 } 04085 } 04086 04087 // Pattern: (and:v1i64 (xor:v1i64 (build_vector:v1i64)<<P:Predicate_immAllOnesV>>, VR64:v1i64:$src1), (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 04088 // Emits: (MMX_PANDNrm:v1i64 VR64:v1i64:$src1, addr:iPTR:$src2) 04089 // Pattern complexity = 32 cost = 1 size = 3 04090 if (N00.getOpcode() == ISD::BUILD_VECTOR && 04091 Predicate_immAllOnesV(N00.getNode())) { 04092 SDValue N01 = N0.getOperand(1); 04093 SDValue N1 = N.getOperand(1); 04094 if (N1.getOpcode() == ISD::LOAD && 04095 N1.hasOneUse() && 04096 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 04097 SDValue Chain1 = N1.getOperand(0); 04098 if (Predicate_unindexedload(N1.getNode()) && 04099 Predicate_load(N1.getNode())) { 04100 SDValue N11 = N1.getOperand(1); 04101 SDValue CPTmpN11_0; 04102 SDValue CPTmpN11_1; 04103 SDValue CPTmpN11_2; 04104 SDValue CPTmpN11_3; 04105 SDValue CPTmpN11_4; 04106 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 04107 SDNode *Result = Emit_47(N, X86::MMX_PANDNrm, MVT::v1i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 04108 return Result; 04109 } 04110 } 04111 } 04112 } 04113 } 04114 if (N0.getOpcode() == ISD::LOAD && 04115 N0.hasOneUse() && 04116 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 04117 SDValue Chain0 = N0.getOperand(0); 04118 if (Predicate_unindexedload(N0.getNode()) && 04119 Predicate_load(N0.getNode())) { 04120 SDValue N01 = N0.getOperand(1); 04121 SDValue CPTmpN01_0; 04122 SDValue CPTmpN01_1; 04123 SDValue CPTmpN01_2; 04124 SDValue CPTmpN01_3; 04125 SDValue CPTmpN01_4; 04126 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 04127 SDValue N1 = N.getOperand(1); 04128 if (N1.getOpcode() == ISD::XOR) { 04129 SDValue N10 = N1.getOperand(0); 04130 04131 // Pattern: (and:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (xor:v1i64 VR64:v1i64:$src1, (build_vector:v1i64)<<P:Predicate_immAllOnesV>>)) 04132 // Emits: (MMX_PANDNrm:v1i64 VR64:v1i64:$src1, addr:iPTR:$src2) 04133 // Pattern complexity = 32 cost = 1 size = 3 04134 { 04135 SDValue N11 = N1.getOperand(1); 04136 if (N11.getOpcode() == ISD::BUILD_VECTOR && 04137 Predicate_immAllOnesV(N11.getNode())) { 04138 SDNode *Result = Emit_48(N, X86::MMX_PANDNrm, MVT::v1i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 04139 return Result; 04140 } 04141 } 04142 04143 // Pattern: (and:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (xor:v1i64 (build_vector:v1i64)<<P:Predicate_immAllOnesV>>, VR64:v1i64:$src1)) 04144 // Emits: (MMX_PANDNrm:v1i64 VR64:v1i64:$src1, addr:iPTR:$src2) 04145 // Pattern complexity = 32 cost = 1 size = 3 04146 if (N10.getOpcode() == ISD::BUILD_VECTOR && 04147 Predicate_immAllOnesV(N10.getNode())) { 04148 SDNode *Result = Emit_49(N, X86::MMX_PANDNrm, MVT::v1i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 04149 return Result; 04150 } 04151 } 04152 } 04153 } 04154 } 04155 04156 // Pattern: (and:v1i64 VR64:v1i64:$src1, (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 04157 // Emits: (MMX_PANDrm:v1i64 VR64:v1i64:$src1, addr:iPTR:$src2) 04158 // Pattern complexity = 25 cost = 1 size = 3 04159 { 04160 SDValue N1 = N.getOperand(1); 04161 if (N1.getOpcode() == ISD::LOAD && 04162 N1.hasOneUse() && 04163 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 04164 SDValue Chain1 = N1.getOperand(0); 04165 if (Predicate_unindexedload(N1.getNode()) && 04166 Predicate_load(N1.getNode())) { 04167 SDValue N11 = N1.getOperand(1); 04168 SDValue CPTmpN11_0; 04169 SDValue CPTmpN11_1; 04170 SDValue CPTmpN11_2; 04171 SDValue CPTmpN11_3; 04172 SDValue CPTmpN11_4; 04173 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 04174 SDNode *Result = Emit_18(N, X86::MMX_PANDrm, MVT::v1i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 04175 return Result; 04176 } 04177 } 04178 } 04179 } 04180 04181 // Pattern: (and:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, VR64:v1i64:$src1) 04182 // Emits: (MMX_PANDrm:v1i64 VR64:v1i64:$src1, addr:iPTR:$src2) 04183 // Pattern complexity = 25 cost = 1 size = 3 04184 if (N0.getOpcode() == ISD::LOAD && 04185 N0.hasOneUse() && 04186 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 04187 SDValue Chain0 = N0.getOperand(0); 04188 if (Predicate_unindexedload(N0.getNode()) && 04189 Predicate_load(N0.getNode())) { 04190 SDValue N01 = N0.getOperand(1); 04191 SDValue CPTmpN01_0; 04192 SDValue CPTmpN01_1; 04193 SDValue CPTmpN01_2; 04194 SDValue CPTmpN01_3; 04195 SDValue CPTmpN01_4; 04196 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 04197 SDNode *Result = Emit_19(N, X86::MMX_PANDrm, MVT::v1i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 04198 return Result; 04199 } 04200 } 04201 } 04202 } 04203 } 04204 { 04205 SDValue N0 = N.getOperand(0); 04206 if (N0.getOpcode() == ISD::XOR) { 04207 SDValue N00 = N0.getOperand(0); 04208 { 04209 SDValue N01 = N0.getOperand(1); 04210 if (N01.getOpcode() == ISD::BIT_CONVERT) { 04211 SDValue N010 = N01.getOperand(0); 04212 04213 // Pattern: (and:v1i64 (xor:v1i64 VR64:v1i64:$src1, (bitconvert:v1i64 (build_vector:v2i32)<<P:Predicate_immAllOnesV>>)), VR64:v1i64:$src2) 04214 // Emits: (MMX_PANDNrr:v1i64 VR64:v8i8:$src1, VR64:v8i8:$src2) 04215 // Pattern complexity = 13 cost = 1 size = 3 04216 if (N010.getOpcode() == ISD::BUILD_VECTOR && 04217 Predicate_immAllOnesV(N010.getNode())) { 04218 SDValue N1 = N.getOperand(1); 04219 if (N010.getNode()->getValueType(0) == MVT::v2i32) { 04220 SDNode *Result = Emit_42(N, X86::MMX_PANDNrr, MVT::v1i64); 04221 return Result; 04222 } 04223 } 04224 if (N010.getOpcode() == ISD::BIT_CONVERT && 04225 Predicate_immAllOnesV_bc(N010.getNode())) { 04226 SDValue N1 = N.getOperand(1); 04227 04228 // Pattern: (and:v1i64 (xor:v1i64 VR64:v1i64:$src1, (bitconvert:v1i64 (bitconvert:v4i16)<<P:Predicate_immAllOnesV_bc>>)), VR64:v1i64:$src2) 04229 // Emits: (MMX_PANDNrr:v1i64 VR64:v8i8:$src1, VR64:v8i8:$src2) 04230 // Pattern complexity = 13 cost = 1 size = 3 04231 if (N010.getNode()->getValueType(0) == MVT::v4i16) { 04232 SDNode *Result = Emit_42(N, X86::MMX_PANDNrr, MVT::v1i64); 04233 return Result; 04234 } 04235 04236 // Pattern: (and:v1i64 (xor:v1i64 VR64:v1i64:$src1, (bitconvert:v1i64 (bitconvert:v8i8)<<P:Predicate_immAllOnesV_bc>>)), VR64:v1i64:$src2) 04237 // Emits: (MMX_PANDNrr:v1i64 VR64:v8i8:$src1, VR64:v8i8:$src2) 04238 // Pattern complexity = 13 cost = 1 size = 3 04239 if (N010.getNode()->getValueType(0) == MVT::v8i8) { 04240 SDNode *Result = Emit_42(N, X86::MMX_PANDNrr, MVT::v1i64); 04241 return Result; 04242 } 04243 } 04244 } 04245 } 04246 04247 // Pattern: (and:v1i64 (xor:v1i64 (bitconvert:v1i64 (build_vector:v2i32)<<P:Predicate_immAllOnesV>>), VR64:v1i64:$src1), VR64:v1i64:$src2) 04248 // Emits: (MMX_PANDNrr:v1i64 VR64:v8i8:$src1, VR64:v8i8:$src2) 04249 // Pattern complexity = 13 cost = 1 size = 3 04250 if (N00.getOpcode() == ISD::BIT_CONVERT) { 04251 SDValue N000 = N00.getOperand(0); 04252 if (N000.getOpcode() == ISD::BUILD_VECTOR && 04253 Predicate_immAllOnesV(N000.getNode())) { 04254 SDValue N01 = N0.getOperand(1); 04255 SDValue N1 = N.getOperand(1); 04256 if (N000.getNode()->getValueType(0) == MVT::v2i32) { 04257 SDNode *Result = Emit_50(N, X86::MMX_PANDNrr, MVT::v1i64); 04258 return Result; 04259 } 04260 } 04261 } 04262 } 04263 { 04264 SDValue N1 = N.getOperand(1); 04265 if (N1.getOpcode() == ISD::XOR) { 04266 SDValue N10 = N1.getOperand(0); 04267 04268 // Pattern: (and:v1i64 VR64:v1i64:$src2, (xor:v1i64 VR64:v1i64:$src1, (bitconvert:v1i64 (build_vector:v2i32)<<P:Predicate_immAllOnesV>>))) 04269 // Emits: (MMX_PANDNrr:v1i64 VR64:v8i8:$src1, VR64:v8i8:$src2) 04270 // Pattern complexity = 13 cost = 1 size = 3 04271 { 04272 SDValue N11 = N1.getOperand(1); 04273 if (N11.getOpcode() == ISD::BIT_CONVERT) { 04274 SDValue N110 = N11.getOperand(0); 04275 if (N110.getOpcode() == ISD::BUILD_VECTOR && 04276 Predicate_immAllOnesV(N110.getNode()) && 04277 N110.getNode()->getValueType(0) == MVT::v2i32) { 04278 SDNode *Result = Emit_51(N, X86::MMX_PANDNrr, MVT::v1i64); 04279 return Result; 04280 } 04281 } 04282 } 04283 04284 // Pattern: (and:v1i64 VR64:v1i64:$src2, (xor:v1i64 (bitconvert:v1i64 (build_vector:v2i32)<<P:Predicate_immAllOnesV>>), VR64:v1i64:$src1)) 04285 // Emits: (MMX_PANDNrr:v1i64 VR64:v8i8:$src1, VR64:v8i8:$src2) 04286 // Pattern complexity = 13 cost = 1 size = 3 04287 if (N10.getOpcode() == ISD::BIT_CONVERT) { 04288 SDValue N100 = N10.getOperand(0); 04289 if (N100.getOpcode() == ISD::BUILD_VECTOR && 04290 Predicate_immAllOnesV(N100.getNode())) { 04291 SDValue N11 = N1.getOperand(1); 04292 if (N100.getNode()->getValueType(0) == MVT::v2i32) { 04293 SDNode *Result = Emit_52(N, X86::MMX_PANDNrr, MVT::v1i64); 04294 return Result; 04295 } 04296 } 04297 } 04298 } 04299 } 04300 04301 // Pattern: (and:v1i64 (xor:v1i64 (bitconvert:v1i64 (bitconvert:v4i16)<<P:Predicate_immAllOnesV_bc>>), VR64:v1i64:$src1), VR64:v1i64:$src2) 04302 // Emits: (MMX_PANDNrr:v1i64 VR64:v8i8:$src1, VR64:v8i8:$src2) 04303 // Pattern complexity = 13 cost = 1 size = 3 04304 if (N0.getOpcode() == ISD::XOR) { 04305 SDValue N00 = N0.getOperand(0); 04306 if (N00.getOpcode() == ISD::BIT_CONVERT) { 04307 SDValue N000 = N00.getOperand(0); 04308 if (N000.getOpcode() == ISD::BIT_CONVERT && 04309 Predicate_immAllOnesV_bc(N000.getNode())) { 04310 SDValue N01 = N0.getOperand(1); 04311 SDValue N1 = N.getOperand(1); 04312 if (N000.getNode()->getValueType(0) == MVT::v4i16) { 04313 SDNode *Result = Emit_50(N, X86::MMX_PANDNrr, MVT::v1i64); 04314 return Result; 04315 } 04316 } 04317 } 04318 } 04319 { 04320 SDValue N1 = N.getOperand(1); 04321 if (N1.getOpcode() == ISD::XOR) { 04322 SDValue N10 = N1.getOperand(0); 04323 04324 // Pattern: (and:v1i64 VR64:v1i64:$src2, (xor:v1i64 VR64:v1i64:$src1, (bitconvert:v1i64 (bitconvert:v4i16)<<P:Predicate_immAllOnesV_bc>>))) 04325 // Emits: (MMX_PANDNrr:v1i64 VR64:v8i8:$src1, VR64:v8i8:$src2) 04326 // Pattern complexity = 13 cost = 1 size = 3 04327 { 04328 SDValue N11 = N1.getOperand(1); 04329 if (N11.getOpcode() == ISD::BIT_CONVERT) { 04330 SDValue N110 = N11.getOperand(0); 04331 if (N110.getOpcode() == ISD::BIT_CONVERT && 04332 Predicate_immAllOnesV_bc(N110.getNode()) && 04333 N110.getNode()->getValueType(0) == MVT::v4i16) { 04334 SDNode *Result = Emit_51(N, X86::MMX_PANDNrr, MVT::v1i64); 04335 return Result; 04336 } 04337 } 04338 } 04339 04340 // Pattern: (and:v1i64 VR64:v1i64:$src2, (xor:v1i64 (bitconvert:v1i64 (bitconvert:v4i16)<<P:Predicate_immAllOnesV_bc>>), VR64:v1i64:$src1)) 04341 // Emits: (MMX_PANDNrr:v1i64 VR64:v8i8:$src1, VR64:v8i8:$src2) 04342 // Pattern complexity = 13 cost = 1 size = 3 04343 if (N10.getOpcode() == ISD::BIT_CONVERT) { 04344 SDValue N100 = N10.getOperand(0); 04345 if (N100.getOpcode() == ISD::BIT_CONVERT && 04346 Predicate_immAllOnesV_bc(N100.getNode())) { 04347 SDValue N11 = N1.getOperand(1); 04348 if (N100.getNode()->getValueType(0) == MVT::v4i16) { 04349 SDNode *Result = Emit_52(N, X86::MMX_PANDNrr, MVT::v1i64); 04350 return Result; 04351 } 04352 } 04353 } 04354 } 04355 } 04356 04357 // Pattern: (and:v1i64 (xor:v1i64 (bitconvert:v1i64 (bitconvert:v8i8)<<P:Predicate_immAllOnesV_bc>>), VR64:v1i64:$src1), VR64:v1i64:$src2) 04358 // Emits: (MMX_PANDNrr:v1i64 VR64:v8i8:$src1, VR64:v8i8:$src2) 04359 // Pattern complexity = 13 cost = 1 size = 3 04360 if (N0.getOpcode() == ISD::XOR) { 04361 SDValue N00 = N0.getOperand(0); 04362 if (N00.getOpcode() == ISD::BIT_CONVERT) { 04363 SDValue N000 = N00.getOperand(0); 04364 if (N000.getOpcode() == ISD::BIT_CONVERT && 04365 Predicate_immAllOnesV_bc(N000.getNode())) { 04366 SDValue N01 = N0.getOperand(1); 04367 SDValue N1 = N.getOperand(1); 04368 if (N000.getNode()->getValueType(0) == MVT::v8i8) { 04369 SDNode *Result = Emit_50(N, X86::MMX_PANDNrr, MVT::v1i64); 04370 return Result; 04371 } 04372 } 04373 } 04374 } 04375 SDValue N1 = N.getOperand(1); 04376 if (N1.getOpcode() == ISD::XOR) { 04377 SDValue N10 = N1.getOperand(0); 04378 04379 // Pattern: (and:v1i64 VR64:v1i64:$src2, (xor:v1i64 VR64:v1i64:$src1, (bitconvert:v1i64 (bitconvert:v8i8)<<P:Predicate_immAllOnesV_bc>>))) 04380 // Emits: (MMX_PANDNrr:v1i64 VR64:v8i8:$src1, VR64:v8i8:$src2) 04381 // Pattern complexity = 13 cost = 1 size = 3 04382 { 04383 SDValue N11 = N1.getOperand(1); 04384 if (N11.getOpcode() == ISD::BIT_CONVERT) { 04385 SDValue N110 = N11.getOperand(0); 04386 if (N110.getOpcode() == ISD::BIT_CONVERT && 04387 Predicate_immAllOnesV_bc(N110.getNode()) && 04388 N110.getNode()->getValueType(0) == MVT::v8i8) { 04389 SDNode *Result = Emit_51(N, X86::MMX_PANDNrr, MVT::v1i64); 04390 return Result; 04391 } 04392 } 04393 } 04394 04395 // Pattern: (and:v1i64 VR64:v1i64:$src2, (xor:v1i64 (bitconvert:v1i64 (bitconvert:v8i8)<<P:Predicate_immAllOnesV_bc>>), VR64:v1i64:$src1)) 04396 // Emits: (MMX_PANDNrr:v1i64 VR64:v8i8:$src1, VR64:v8i8:$src2) 04397 // Pattern complexity = 13 cost = 1 size = 3 04398 if (N10.getOpcode() == ISD::BIT_CONVERT) { 04399 SDValue N100 = N10.getOperand(0); 04400 if (N100.getOpcode() == ISD::BIT_CONVERT && 04401 Predicate_immAllOnesV_bc(N100.getNode())) { 04402 SDValue N11 = N1.getOperand(1); 04403 if (N100.getNode()->getValueType(0) == MVT::v8i8) { 04404 SDNode *Result = Emit_52(N, X86::MMX_PANDNrr, MVT::v1i64); 04405 return Result; 04406 } 04407 } 04408 } 04409 } 04410 } 04411 if ((Subtarget->hasMMX())) { 04412 { 04413 SDValue N0 = N.getOperand(0); 04414 if (N0.getOpcode() == ISD::XOR) { 04415 SDValue N00 = N0.getOperand(0); 04416 04417 // Pattern: (and:v1i64 (xor:v1i64 VR64:v1i64:$src1, (build_vector:v1i64)<<P:Predicate_immAllOnesV>>), VR64:v1i64:$src2) 04418 // Emits: (MMX_PANDNrr:v1i64 VR64:v1i64:$src1, VR64:v1i64:$src2) 04419 // Pattern complexity = 10 cost = 1 size = 3 04420 { 04421 SDValue N01 = N0.getOperand(1); 04422 if (N01.getOpcode() == ISD::BUILD_VECTOR && 04423 Predicate_immAllOnesV(N01.getNode())) { 04424 SDNode *Result = Emit_40(N, X86::MMX_PANDNrr, MVT::v1i64); 04425 return Result; 04426 } 04427 } 04428 04429 // Pattern: (and:v1i64 (xor:v1i64 (build_vector:v1i64)<<P:Predicate_immAllOnesV>>, VR64:v1i64:$src1), VR64:v1i64:$src2) 04430 // Emits: (MMX_PANDNrr:v1i64 VR64:v1i64:$src1, VR64:v1i64:$src2) 04431 // Pattern complexity = 10 cost = 1 size = 3 04432 if (N00.getOpcode() == ISD::BUILD_VECTOR && 04433 Predicate_immAllOnesV(N00.getNode())) { 04434 SDNode *Result = Emit_44(N, X86::MMX_PANDNrr, MVT::v1i64); 04435 return Result; 04436 } 04437 } 04438 SDValue N1 = N.getOperand(1); 04439 if (N1.getOpcode() == ISD::XOR) { 04440 SDValue N10 = N1.getOperand(0); 04441 04442 // Pattern: (and:v1i64 VR64:v1i64:$src2, (xor:v1i64 VR64:v1i64:$src1, (build_vector:v1i64)<<P:Predicate_immAllOnesV>>)) 04443 // Emits: (MMX_PANDNrr:v1i64 VR64:v1i64:$src1, VR64:v1i64:$src2) 04444 // Pattern complexity = 10 cost = 1 size = 3 04445 { 04446 SDValue N11 = N1.getOperand(1); 04447 if (N11.getOpcode() == ISD::BUILD_VECTOR && 04448 Predicate_immAllOnesV(N11.getNode())) { 04449 SDNode *Result = Emit_45(N, X86::MMX_PANDNrr, MVT::v1i64); 04450 return Result; 04451 } 04452 } 04453 04454 // Pattern: (and:v1i64 VR64:v1i64:$src2, (xor:v1i64 (build_vector:v1i64)<<P:Predicate_immAllOnesV>>, VR64:v1i64:$src1)) 04455 // Emits: (MMX_PANDNrr:v1i64 VR64:v1i64:$src1, VR64:v1i64:$src2) 04456 // Pattern complexity = 10 cost = 1 size = 3 04457 if (N10.getOpcode() == ISD::BUILD_VECTOR && 04458 Predicate_immAllOnesV(N10.getNode())) { 04459 SDNode *Result = Emit_46(N, X86::MMX_PANDNrr, MVT::v1i64); 04460 return Result; 04461 } 04462 } 04463 } 04464 04465 // Pattern: (and:v1i64 VR64:v1i64:$src1, VR64:v1i64:$src2) 04466 // Emits: (MMX_PANDrr:v1i64 VR64:v1i64:$src1, VR64:v1i64:$src2) 04467 // Pattern complexity = 3 cost = 1 size = 3 04468 SDNode *Result = Emit_15(N, X86::MMX_PANDrr, MVT::v1i64); 04469 return Result; 04470 } 04471 04472 CannotYetSelect(N); 04473 return NULL; 04474 } 04475 04476 SDNode *Emit_56(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 04477 SDValue N0 = N.getOperand(0); 04478 SDValue N00 = N0.getOperand(0); 04479 SDValue N1 = N.getOperand(1); 04480 SDValue Chain1 = N1.getOperand(0); 04481 SDValue N11 = N1.getOperand(1); 04482 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 04483 SDValue Ops0[] = { N00, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1 }; 04484 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 04485 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 04486 return ResNode; 04487 } 04488 SDNode *Emit_57(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 04489 SDValue N0 = N.getOperand(0); 04490 SDValue N00 = N0.getOperand(0); 04491 SDValue N000 = N00.getOperand(0); 04492 SDValue N01 = N0.getOperand(1); 04493 SDValue N010 = N01.getOperand(0); 04494 SDValue N1 = N.getOperand(1); 04495 SDValue Chain1 = N1.getOperand(0); 04496 SDValue N11 = N1.getOperand(1); 04497 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 04498 SDValue Ops0[] = { N000, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1 }; 04499 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 04500 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 04501 return ResNode; 04502 } 04503 SDNode *Emit_58(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 04504 SDValue N0 = N.getOperand(0); 04505 SDValue N00 = N0.getOperand(0); 04506 SDValue N1 = N.getOperand(1); 04507 SDValue N10 = N1.getOperand(0); 04508 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N00, N10); 04509 } 04510 SDNode *Emit_59(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 04511 SDValue N0 = N.getOperand(0); 04512 SDValue N00 = N0.getOperand(0); 04513 SDValue N000 = N00.getOperand(0); 04514 SDValue N01 = N0.getOperand(1); 04515 SDValue N1 = N.getOperand(1); 04516 SDValue N10 = N1.getOperand(0); 04517 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N000, N10); 04518 } 04519 SDNode *Emit_60(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 04520 SDValue N0 = N.getOperand(0); 04521 SDValue N00 = N0.getOperand(0); 04522 SDValue N000 = N00.getOperand(0); 04523 SDValue N01 = N0.getOperand(1); 04524 SDValue N1 = N.getOperand(1); 04525 SDValue Chain1 = N1.getOperand(0); 04526 SDValue N11 = N1.getOperand(1); 04527 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 04528 SDValue Ops0[] = { N000, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1 }; 04529 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 04530 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 04531 return ResNode; 04532 } 04533 SDNode *Emit_61(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 04534 SDValue N0 = N.getOperand(0); 04535 SDValue Chain0 = N0.getOperand(0); 04536 SDValue N01 = N0.getOperand(1); 04537 SDValue N1 = N.getOperand(1); 04538 SDValue N10 = N1.getOperand(0); 04539 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 04540 SDValue Ops0[] = { N10, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, LSI_N0, Chain0 }; 04541 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 04542 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 04543 return ResNode; 04544 } 04545 SDNode *Emit_62(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 04546 SDValue N0 = N.getOperand(0); 04547 SDValue N00 = N0.getOperand(0); 04548 SDValue N000 = N00.getOperand(0); 04549 SDValue N01 = N0.getOperand(1); 04550 SDValue N010 = N01.getOperand(0); 04551 SDValue N1 = N.getOperand(1); 04552 SDValue Chain1 = N1.getOperand(0); 04553 SDValue N11 = N1.getOperand(1); 04554 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 04555 SDValue Ops0[] = { N010, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1 }; 04556 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 04557 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 04558 return ResNode; 04559 } 04560 SDNode *Emit_63(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 04561 SDValue N0 = N.getOperand(0); 04562 SDValue Chain0 = N0.getOperand(0); 04563 SDValue N01 = N0.getOperand(1); 04564 SDValue N1 = N.getOperand(1); 04565 SDValue N10 = N1.getOperand(0); 04566 SDValue N100 = N10.getOperand(0); 04567 SDValue N11 = N1.getOperand(1); 04568 SDValue N110 = N11.getOperand(0); 04569 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 04570 SDValue Ops0[] = { N100, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, LSI_N0, Chain0 }; 04571 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 04572 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 04573 return ResNode; 04574 } 04575 SDNode *Emit_64(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 04576 SDValue N0 = N.getOperand(0); 04577 SDValue Chain0 = N0.getOperand(0); 04578 SDValue N01 = N0.getOperand(1); 04579 SDValue N1 = N.getOperand(1); 04580 SDValue N10 = N1.getOperand(0); 04581 SDValue N100 = N10.getOperand(0); 04582 SDValue N11 = N1.getOperand(1); 04583 SDValue N110 = N11.getOperand(0); 04584 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 04585 SDValue Ops0[] = { N110, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, LSI_N0, Chain0 }; 04586 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 04587 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 04588 return ResNode; 04589 } 04590 SDNode *Emit_65(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 04591 SDValue N0 = N.getOperand(0); 04592 SDValue N00 = N0.getOperand(0); 04593 SDValue N01 = N0.getOperand(1); 04594 SDValue N010 = N01.getOperand(0); 04595 SDValue N1 = N.getOperand(1); 04596 SDValue N10 = N1.getOperand(0); 04597 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N010, N10); 04598 } 04599 SDNode *Emit_66(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 04600 SDValue N0 = N.getOperand(0); 04601 SDValue N00 = N0.getOperand(0); 04602 SDValue N1 = N.getOperand(1); 04603 SDValue N10 = N1.getOperand(0); 04604 SDValue N100 = N10.getOperand(0); 04605 SDValue N11 = N1.getOperand(1); 04606 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N100, N00); 04607 } 04608 SDNode *Emit_67(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 04609 SDValue N0 = N.getOperand(0); 04610 SDValue N00 = N0.getOperand(0); 04611 SDValue N1 = N.getOperand(1); 04612 SDValue N10 = N1.getOperand(0); 04613 SDValue N11 = N1.getOperand(1); 04614 SDValue N110 = N11.getOperand(0); 04615 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N110, N00); 04616 } 04617 SDNode *Emit_68(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 04618 SDValue N0 = N.getOperand(0); 04619 SDValue N00 = N0.getOperand(0); 04620 SDValue N01 = N0.getOperand(1); 04621 SDValue N010 = N01.getOperand(0); 04622 SDValue N1 = N.getOperand(1); 04623 SDValue Chain1 = N1.getOperand(0); 04624 SDValue N11 = N1.getOperand(1); 04625 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 04626 SDValue Ops0[] = { N010, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1 }; 04627 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 04628 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 04629 return ResNode; 04630 } 04631 SDNode *Emit_69(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 04632 SDValue N0 = N.getOperand(0); 04633 SDValue Chain0 = N0.getOperand(0); 04634 SDValue N01 = N0.getOperand(1); 04635 SDValue N1 = N.getOperand(1); 04636 SDValue N10 = N1.getOperand(0); 04637 SDValue N100 = N10.getOperand(0); 04638 SDValue N11 = N1.getOperand(1); 04639 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 04640 SDValue Ops0[] = { N100, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, LSI_N0, Chain0 }; 04641 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 04642 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 04643 return ResNode; 04644 } 04645 SDNode *Emit_70(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 04646 SDValue N0 = N.getOperand(0); 04647 SDValue Chain0 = N0.getOperand(0); 04648 SDValue N01 = N0.getOperand(1); 04649 SDValue N1 = N.getOperand(1); 04650 SDValue N10 = N1.getOperand(0); 04651 SDValue N11 = N1.getOperand(1); 04652 SDValue N110 = N11.getOperand(0); 04653 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 04654 SDValue Ops0[] = { N110, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, LSI_N0, Chain0 }; 04655 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 04656 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 04657 return ResNode; 04658 } 04659 SDNode *Select_ISD_AND_v2i64(const SDValue &N) { 04660 if (OptLevel != CodeGenOpt::None) { 04661 if ((Subtarget->hasSSE1())) { 04662 SDValue N0 = N.getOperand(0); 04663 if (N0.getOpcode() == ISD::XOR) { 04664 SDValue N00 = N0.getOperand(0); 04665 if (N00.getOpcode() == ISD::BIT_CONVERT) { 04666 SDValue N000 = N00.getOperand(0); 04667 04668 // Pattern: (and:v2i64 (xor:v2i64 (bitconvert:v2i64 VR128:v4f32:$src1), (bitconvert:v2i64 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>)), (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 04669 // Emits: (ANDNPSrm:v2i64 VR128:v4f32:$src1, addr:iPTR:$src2) 04670 // Pattern complexity = 38 cost = 1 size = 3 04671 { 04672 SDValue N01 = N0.getOperand(1); 04673 if (N01.getOpcode() == ISD::BIT_CONVERT) { 04674 SDValue N010 = N01.getOperand(0); 04675 if (N010.getOpcode() == ISD::BUILD_VECTOR && 04676 Predicate_immAllOnesV(N010.getNode())) { 04677 SDValue N1 = N.getOperand(1); 04678 if (N1.getOpcode() == ISD::LOAD && 04679 N1.hasOneUse() && 04680 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 04681 SDValue Chain1 = N1.getOperand(0); 04682 if (Predicate_unindexedload(N1.getNode()) && 04683 Predicate_load(N1.getNode()) && 04684 Predicate_memop(N1.getNode())) { 04685 SDValue N11 = N1.getOperand(1); 04686 SDValue CPTmpN11_0; 04687 SDValue CPTmpN11_1; 04688 SDValue CPTmpN11_2; 04689 SDValue CPTmpN11_3; 04690 SDValue CPTmpN11_4; 04691 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 04692 N000.getNode()->getValueType(0) == MVT::v4f32 && 04693 N010.getNode()->getValueType(0) == MVT::v4i32) { 04694 SDNode *Result = Emit_57(N, X86::ANDNPSrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 04695 return Result; 04696 } 04697 } 04698 } 04699 } 04700 } 04701 } 04702 04703 // Pattern: (and:v2i64 (xor:v2i64 (bitconvert:v2i64 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>), (bitconvert:v2i64 VR128:v4f32:$src1)), (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 04704 // Emits: (ANDNPSrm:v2i64 VR128:v4f32:$src1, addr:iPTR:$src2) 04705 // Pattern complexity = 38 cost = 1 size = 3 04706 if (N000.getOpcode() == ISD::BUILD_VECTOR && 04707 Predicate_immAllOnesV(N000.getNode())) { 04708 SDValue N01 = N0.getOperand(1); 04709 if (N01.getOpcode() == ISD::BIT_CONVERT) { 04710 SDValue N010 = N01.getOperand(0); 04711 SDValue N1 = N.getOperand(1); 04712 if (N1.getOpcode() == ISD::LOAD && 04713 N1.hasOneUse() && 04714 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 04715 SDValue Chain1 = N1.getOperand(0); 04716 if (Predicate_unindexedload(N1.getNode()) && 04717 Predicate_load(N1.getNode()) && 04718 Predicate_memop(N1.getNode())) { 04719 SDValue N11 = N1.getOperand(1); 04720 SDValue CPTmpN11_0; 04721 SDValue CPTmpN11_1; 04722 SDValue CPTmpN11_2; 04723 SDValue CPTmpN11_3; 04724 SDValue CPTmpN11_4; 04725 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 04726 N000.getNode()->getValueType(0) == MVT::v4i32 && 04727 N010.getNode()->getValueType(0) == MVT::v4f32) { 04728 SDNode *Result = Emit_62(N, X86::ANDNPSrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 04729 return Result; 04730 } 04731 } 04732 } 04733 } 04734 } 04735 } 04736 } 04737 if (N0.getOpcode() == ISD::LOAD && 04738 N0.hasOneUse() && 04739 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 04740 SDValue Chain0 = N0.getOperand(0); 04741 if (Predicate_unindexedload(N0.getNode()) && 04742 Predicate_load(N0.getNode()) && 04743 Predicate_memop(N0.getNode())) { 04744 SDValue N01 = N0.getOperand(1); 04745 SDValue CPTmpN01_0; 04746 SDValue CPTmpN01_1; 04747 SDValue CPTmpN01_2; 04748 SDValue CPTmpN01_3; 04749 SDValue CPTmpN01_4; 04750 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 04751 SDValue N1 = N.getOperand(1); 04752 if (N1.getOpcode() == ISD::XOR) { 04753 SDValue N10 = N1.getOperand(0); 04754 if (N10.getOpcode() == ISD::BIT_CONVERT) { 04755 SDValue N100 = N10.getOperand(0); 04756 04757 // Pattern: (and:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (xor:v2i64 (bitconvert:v2i64 VR128:v4f32:$src1), (bitconvert:v2i64 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>))) 04758 // Emits: (ANDNPSrm:v2i64 VR128:v4f32:$src1, addr:iPTR:$src2) 04759 // Pattern complexity = 38 cost = 1 size = 3 04760 { 04761 SDValue N11 = N1.getOperand(1); 04762 if (N11.getOpcode() == ISD::BIT_CONVERT) { 04763 SDValue N110 = N11.getOperand(0); 04764 if (N110.getOpcode() == ISD::BUILD_VECTOR && 04765 Predicate_immAllOnesV(N110.getNode()) && 04766 N100.getNode()->getValueType(0) == MVT::v4f32 && 04767 N110.getNode()->getValueType(0) == MVT::v4i32) { 04768 SDNode *Result = Emit_63(N, X86::ANDNPSrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 04769 return Result; 04770 } 04771 } 04772 } 04773 04774 // Pattern: (and:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (xor:v2i64 (bitconvert:v2i64 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>), (bitconvert:v2i64 VR128:v4f32:$src1))) 04775 // Emits: (ANDNPSrm:v2i64 VR128:v4f32:$src1, addr:iPTR:$src2) 04776 // Pattern complexity = 38 cost = 1 size = 3 04777 if (N100.getOpcode() == ISD::BUILD_VECTOR && 04778 Predicate_immAllOnesV(N100.getNode())) { 04779 SDValue N11 = N1.getOperand(1); 04780 if (N11.getOpcode() == ISD::BIT_CONVERT) { 04781 SDValue N110 = N11.getOperand(0); 04782 if (N100.getNode()->getValueType(0) == MVT::v4i32 && 04783 N110.getNode()->getValueType(0) == MVT::v4f32) { 04784 SDNode *Result = Emit_64(N, X86::ANDNPSrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 04785 return Result; 04786 } 04787 } 04788 } 04789 } 04790 } 04791 } 04792 } 04793 } 04794 } 04795 if ((Subtarget->hasSSE2())) { 04796 SDValue N0 = N.getOperand(0); 04797 if (N0.getOpcode() == ISD::XOR) { 04798 SDValue N00 = N0.getOperand(0); 04799 04800 // Pattern: (and:v2i64 (xor:v2i64 (bitconvert:v2i64 VR128:v2f64:$src1), (build_vector:v2i64)<<P:Predicate_immAllOnesV>>), (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 04801 // Emits: (ANDNPDrm:v2i64 VR128:v2f64:$src1, addr:iPTR:$src2) 04802 // Pattern complexity = 35 cost = 1 size = 3 04803 if (N00.getOpcode() == ISD::BIT_CONVERT) { 04804 SDValue N000 = N00.getOperand(0); 04805 SDValue N01 = N0.getOperand(1); 04806 if (N01.getOpcode() == ISD::BUILD_VECTOR && 04807 Predicate_immAllOnesV(N01.getNode())) { 04808 SDValue N1 = N.getOperand(1); 04809 if (N1.getOpcode() == ISD::LOAD && 04810 N1.hasOneUse() && 04811 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 04812 SDValue Chain1 = N1.getOperand(0); 04813 if (Predicate_unindexedload(N1.getNode()) && 04814 Predicate_load(N1.getNode()) && 04815 Predicate_memop(N1.getNode())) { 04816 SDValue N11 = N1.getOperand(1); 04817 SDValue CPTmpN11_0; 04818 SDValue CPTmpN11_1; 04819 SDValue CPTmpN11_2; 04820 SDValue CPTmpN11_3; 04821 SDValue CPTmpN11_4; 04822 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 04823 N000.getNode()->getValueType(0) == MVT::v2f64) { 04824 SDNode *Result = Emit_60(N, X86::ANDNPDrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 04825 return Result; 04826 } 04827 } 04828 } 04829 } 04830 } 04831 { 04832 SDValue N01 = N0.getOperand(1); 04833 if (N01.getOpcode() == ISD::BIT_CONVERT) { 04834 SDValue N010 = N01.getOperand(0); 04835 if (N010.getOpcode() == ISD::BUILD_VECTOR && 04836 Predicate_immAllOnesV(N010.getNode())) { 04837 SDValue N1 = N.getOperand(1); 04838 if (N1.getOpcode() == ISD::LOAD && 04839 N1.hasOneUse() && 04840 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 04841 SDValue Chain1 = N1.getOperand(0); 04842 if (Predicate_unindexedload(N1.getNode()) && 04843 Predicate_load(N1.getNode()) && 04844 Predicate_memop(N1.getNode())) { 04845 SDValue N11 = N1.getOperand(1); 04846 SDValue CPTmpN11_0; 04847 SDValue CPTmpN11_1; 04848 SDValue CPTmpN11_2; 04849 SDValue CPTmpN11_3; 04850 SDValue CPTmpN11_4; 04851 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 04852 04853 // Pattern: (and:v2i64 (xor:v2i64 VR128:v2i64:$src1, (bitconvert:v2i64 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>)), (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 04854 // Emits: (PANDNrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 04855 // Pattern complexity = 35 cost = 1 size = 3 04856 if (N010.getNode()->getValueType(0) == MVT::v4i32) { 04857 SDNode *Result = Emit_43(N, X86::PANDNrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 04858 return Result; 04859 } 04860 04861 // Pattern: (and:v2i64 (xor:v2i64 VR128:v2i64:$src1, (bitconvert:v2i64 (build_vector:v8i16)<<P:Predicate_immAllOnesV>>)), (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 04862 // Emits: (PANDNrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 04863 // Pattern complexity = 35 cost = 1 size = 3 04864 if (N010.getNode()->getValueType(0) == MVT::v8i16) { 04865 SDNode *Result = Emit_43(N, X86::PANDNrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 04866 return Result; 04867 } 04868 04869 // Pattern: (and:v2i64 (xor:v2i64 VR128:v2i64:$src1, (bitconvert:v2i64 (build_vector:v16i8)<<P:Predicate_immAllOnesV>>)), (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 04870 // Emits: (PANDNrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 04871 // Pattern complexity = 35 cost = 1 size = 3 04872 if (N010.getNode()->getValueType(0) == MVT::v16i8) { 04873 SDNode *Result = Emit_43(N, X86::PANDNrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 04874 return Result; 04875 } 04876 } 04877 } 04878 } 04879 } 04880 } 04881 } 04882 04883 // Pattern: (and:v2i64 (xor:v2i64 (build_vector:v2i64)<<P:Predicate_immAllOnesV>>, (bitconvert:v2i64 VR128:v2f64:$src1)), (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 04884 // Emits: (ANDNPDrm:v2i64 VR128:v2f64:$src1, addr:iPTR:$src2) 04885 // Pattern complexity = 35 cost = 1 size = 3 04886 if (N00.getOpcode() == ISD::BUILD_VECTOR && 04887 Predicate_immAllOnesV(N00.getNode())) { 04888 SDValue N01 = N0.getOperand(1); 04889 if (N01.getOpcode() == ISD::BIT_CONVERT) { 04890 SDValue N010 = N01.getOperand(0); 04891 SDValue N1 = N.getOperand(1); 04892 if (N1.getOpcode() == ISD::LOAD && 04893 N1.hasOneUse() && 04894 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 04895 SDValue Chain1 = N1.getOperand(0); 04896 if (Predicate_unindexedload(N1.getNode()) && 04897 Predicate_load(N1.getNode()) && 04898 Predicate_memop(N1.getNode())) { 04899 SDValue N11 = N1.getOperand(1); 04900 SDValue CPTmpN11_0; 04901 SDValue CPTmpN11_1; 04902 SDValue CPTmpN11_2; 04903 SDValue CPTmpN11_3; 04904 SDValue CPTmpN11_4; 04905 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 04906 N010.getNode()->getValueType(0) == MVT::v2f64) { 04907 SDNode *Result = Emit_68(N, X86::ANDNPDrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 04908 return Result; 04909 } 04910 } 04911 } 04912 } 04913 } 04914 } 04915 if (N0.getOpcode() == ISD::LOAD && 04916 N0.hasOneUse() && 04917 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 04918 SDValue Chain0 = N0.getOperand(0); 04919 if (Predicate_unindexedload(N0.getNode()) && 04920 Predicate_load(N0.getNode()) && 04921 Predicate_memop(N0.getNode())) { 04922 SDValue N01 = N0.getOperand(1); 04923 SDValue CPTmpN01_0; 04924 SDValue CPTmpN01_1; 04925 SDValue CPTmpN01_2; 04926 SDValue CPTmpN01_3; 04927 SDValue CPTmpN01_4; 04928 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 04929 SDValue N1 = N.getOperand(1); 04930 if (N1.getOpcode() == ISD::XOR) { 04931 SDValue N10 = N1.getOperand(0); 04932 04933 // Pattern: (and:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (xor:v2i64 (bitconvert:v2i64 VR128:v2f64:$src1), (build_vector:v2i64)<<P:Predicate_immAllOnesV>>)) 04934 // Emits: (ANDNPDrm:v2i64 VR128:v2f64:$src1, addr:iPTR:$src2) 04935 // Pattern complexity = 35 cost = 1 size = 3 04936 if (N10.getOpcode() == ISD::BIT_CONVERT) { 04937 SDValue N100 = N10.getOperand(0); 04938 SDValue N11 = N1.getOperand(1); 04939 if (N11.getOpcode() == ISD::BUILD_VECTOR && 04940 Predicate_immAllOnesV(N11.getNode()) && 04941 N100.getNode()->getValueType(0) == MVT::v2f64) { 04942 SDNode *Result = Emit_69(N, X86::ANDNPDrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 04943 return Result; 04944 } 04945 } 04946 04947 // Pattern: (and:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (xor:v2i64 (build_vector:v2i64)<<P:Predicate_immAllOnesV>>, (bitconvert:v2i64 VR128:v2f64:$src1))) 04948 // Emits: (ANDNPDrm:v2i64 VR128:v2f64:$src1, addr:iPTR:$src2) 04949 // Pattern complexity = 35 cost = 1 size = 3 04950 if (N10.getOpcode() == ISD::BUILD_VECTOR && 04951 Predicate_immAllOnesV(N10.getNode())) { 04952 SDValue N11 = N1.getOperand(1); 04953 if (N11.getOpcode() == ISD::BIT_CONVERT) { 04954 SDValue N110 = N11.getOperand(0); 04955 if (N110.getNode()->getValueType(0) == MVT::v2f64) { 04956 SDNode *Result = Emit_70(N, X86::ANDNPDrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 04957 return Result; 04958 } 04959 } 04960 } 04961 } 04962 } 04963 } 04964 } 04965 04966 // Pattern: (and:v2i64 (xor:v2i64 (bitconvert:v2i64 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>), VR128:v2i64:$src1), (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 04967 // Emits: (PANDNrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 04968 // Pattern complexity = 35 cost = 1 size = 3 04969 if (N0.getOpcode() == ISD::XOR) { 04970 SDValue N00 = N0.getOperand(0); 04971 if (N00.getOpcode() == ISD::BIT_CONVERT) { 04972 SDValue N000 = N00.getOperand(0); 04973 if (N000.getOpcode() == ISD::BUILD_VECTOR && 04974 Predicate_immAllOnesV(N000.getNode())) { 04975 SDValue N01 = N0.getOperand(1); 04976 SDValue N1 = N.getOperand(1); 04977 if (N1.getOpcode() == ISD::LOAD && 04978 N1.hasOneUse() && 04979 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 04980 SDValue Chain1 = N1.getOperand(0); 04981 if (Predicate_unindexedload(N1.getNode()) && 04982 Predicate_load(N1.getNode()) && 04983 Predicate_memop(N1.getNode())) { 04984 SDValue N11 = N1.getOperand(1); 04985 SDValue CPTmpN11_0; 04986 SDValue CPTmpN11_1; 04987 SDValue CPTmpN11_2; 04988 SDValue CPTmpN11_3; 04989 SDValue CPTmpN11_4; 04990 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 04991 N000.getNode()->getValueType(0) == MVT::v4i32) { 04992 SDNode *Result = Emit_53(N, X86::PANDNrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 04993 return Result; 04994 } 04995 } 04996 } 04997 } 04998 } 04999 } 05000 if (N0.getOpcode() == ISD::LOAD && 05001 N0.hasOneUse() && 05002 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 05003 SDValue Chain0 = N0.getOperand(0); 05004 if (Predicate_unindexedload(N0.getNode()) && 05005 Predicate_load(N0.getNode()) && 05006 Predicate_memop(N0.getNode())) { 05007 SDValue N01 = N0.getOperand(1); 05008 SDValue CPTmpN01_0; 05009 SDValue CPTmpN01_1; 05010 SDValue CPTmpN01_2; 05011 SDValue CPTmpN01_3; 05012 SDValue CPTmpN01_4; 05013 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 05014 SDValue N1 = N.getOperand(1); 05015 if (N1.getOpcode() == ISD::XOR) { 05016 SDValue N10 = N1.getOperand(0); 05017 05018 // Pattern: (and:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (xor:v2i64 VR128:v2i64:$src1, (bitconvert:v2i64 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>))) 05019 // Emits: (PANDNrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 05020 // Pattern complexity = 35 cost = 1 size = 3 05021 { 05022 SDValue N11 = N1.getOperand(1); 05023 if (N11.getOpcode() == ISD::BIT_CONVERT) { 05024 SDValue N110 = N11.getOperand(0); 05025 if (N110.getOpcode() == ISD::BUILD_VECTOR && 05026 Predicate_immAllOnesV(N110.getNode()) && 05027 N110.getNode()->getValueType(0) == MVT::v4i32) { 05028 SDNode *Result = Emit_54(N, X86::PANDNrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 05029 return Result; 05030 } 05031 } 05032 } 05033 05034 // Pattern: (and:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (xor:v2i64 (bitconvert:v2i64 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>), VR128:v2i64:$src1)) 05035 // Emits: (PANDNrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 05036 // Pattern complexity = 35 cost = 1 size = 3 05037 if (N10.getOpcode() == ISD::BIT_CONVERT) { 05038 SDValue N100 = N10.getOperand(0); 05039 if (N100.getOpcode() == ISD::BUILD_VECTOR && 05040 Predicate_immAllOnesV(N100.getNode())) { 05041 SDValue N11 = N1.getOperand(1); 05042 if (N100.getNode()->getValueType(0) == MVT::v4i32) { 05043 SDNode *Result = Emit_55(N, X86::PANDNrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 05044 return Result; 05045 } 05046 } 05047 } 05048 } 05049 } 05050 } 05051 } 05052 05053 // Pattern: (and:v2i64 (xor:v2i64 (bitconvert:v2i64 (build_vector:v8i16)<<P:Predicate_immAllOnesV>>), VR128:v2i64:$src1), (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 05054 // Emits: (PANDNrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 05055 // Pattern complexity = 35 cost = 1 size = 3 05056 if (N0.getOpcode() == ISD::XOR) { 05057 SDValue N00 = N0.getOperand(0); 05058 if (N00.getOpcode() == ISD::BIT_CONVERT) { 05059 SDValue N000 = N00.getOperand(0); 05060 if (N000.getOpcode() == ISD::BUILD_VECTOR && 05061 Predicate_immAllOnesV(N000.getNode())) { 05062 SDValue N01 = N0.getOperand(1); 05063 SDValue N1 = N.getOperand(1); 05064 if (N1.getOpcode() == ISD::LOAD && 05065 N1.hasOneUse() && 05066 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 05067 SDValue Chain1 = N1.getOperand(0); 05068 if (Predicate_unindexedload(N1.getNode()) && 05069 Predicate_load(N1.getNode()) && 05070 Predicate_memop(N1.getNode())) { 05071 SDValue N11 = N1.getOperand(1); 05072 SDValue CPTmpN11_0; 05073 SDValue CPTmpN11_1; 05074 SDValue CPTmpN11_2; 05075 SDValue CPTmpN11_3; 05076 SDValue CPTmpN11_4; 05077 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 05078 N000.getNode()->getValueType(0) == MVT::v8i16) { 05079 SDNode *Result = Emit_53(N, X86::PANDNrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 05080 return Result; 05081 } 05082 } 05083 } 05084 } 05085 } 05086 } 05087 if (N0.getOpcode() == ISD::LOAD && 05088 N0.hasOneUse() && 05089 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 05090 SDValue Chain0 = N0.getOperand(0); 05091 if (Predicate_unindexedload(N0.getNode()) && 05092 Predicate_load(N0.getNode()) && 05093 Predicate_memop(N0.getNode())) { 05094 SDValue N01 = N0.getOperand(1); 05095 SDValue CPTmpN01_0; 05096 SDValue CPTmpN01_1; 05097 SDValue CPTmpN01_2; 05098 SDValue CPTmpN01_3; 05099 SDValue CPTmpN01_4; 05100 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 05101 SDValue N1 = N.getOperand(1); 05102 if (N1.getOpcode() == ISD::XOR) { 05103 SDValue N10 = N1.getOperand(0); 05104 05105 // Pattern: (and:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (xor:v2i64 VR128:v2i64:$src1, (bitconvert:v2i64 (build_vector:v8i16)<<P:Predicate_immAllOnesV>>))) 05106 // Emits: (PANDNrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 05107 // Pattern complexity = 35 cost = 1 size = 3 05108 { 05109 SDValue N11 = N1.getOperand(1); 05110 if (N11.getOpcode() == ISD::BIT_CONVERT) { 05111 SDValue N110 = N11.getOperand(0); 05112 if (N110.getOpcode() == ISD::BUILD_VECTOR && 05113 Predicate_immAllOnesV(N110.getNode()) && 05114 N110.getNode()->getValueType(0) == MVT::v8i16) { 05115 SDNode *Result = Emit_54(N, X86::PANDNrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 05116 return Result; 05117 } 05118 } 05119 } 05120 05121 // Pattern: (and:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (xor:v2i64 (bitconvert:v2i64 (build_vector:v8i16)<<P:Predicate_immAllOnesV>>), VR128:v2i64:$src1)) 05122 // Emits: (PANDNrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 05123 // Pattern complexity = 35 cost = 1 size = 3 05124 if (N10.getOpcode() == ISD::BIT_CONVERT) { 05125 SDValue N100 = N10.getOperand(0); 05126 if (N100.getOpcode() == ISD::BUILD_VECTOR && 05127 Predicate_immAllOnesV(N100.getNode())) { 05128 SDValue N11 = N1.getOperand(1); 05129 if (N100.getNode()->getValueType(0) == MVT::v8i16) { 05130 SDNode *Result = Emit_55(N, X86::PANDNrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 05131 return Result; 05132 } 05133 } 05134 } 05135 } 05136 } 05137 } 05138 } 05139 05140 // Pattern: (and:v2i64 (xor:v2i64 (bitconvert:v2i64 (build_vector:v16i8)<<P:Predicate_immAllOnesV>>), VR128:v2i64:$src1), (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 05141 // Emits: (PANDNrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 05142 // Pattern complexity = 35 cost = 1 size = 3 05143 if (N0.getOpcode() == ISD::XOR) { 05144 SDValue N00 = N0.getOperand(0); 05145 if (N00.getOpcode() == ISD::BIT_CONVERT) { 05146 SDValue N000 = N00.getOperand(0); 05147 if (N000.getOpcode() == ISD::BUILD_VECTOR && 05148 Predicate_immAllOnesV(N000.getNode())) { 05149 SDValue N01 = N0.getOperand(1); 05150 SDValue N1 = N.getOperand(1); 05151 if (N1.getOpcode() == ISD::LOAD && 05152 N1.hasOneUse() && 05153 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 05154 SDValue Chain1 = N1.getOperand(0); 05155 if (Predicate_unindexedload(N1.getNode()) && 05156 Predicate_load(N1.getNode()) && 05157 Predicate_memop(N1.getNode())) { 05158 SDValue N11 = N1.getOperand(1); 05159 SDValue CPTmpN11_0; 05160 SDValue CPTmpN11_1; 05161 SDValue CPTmpN11_2; 05162 SDValue CPTmpN11_3; 05163 SDValue CPTmpN11_4; 05164 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 05165 N000.getNode()->getValueType(0) == MVT::v16i8) { 05166 SDNode *Result = Emit_53(N, X86::PANDNrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 05167 return Result; 05168 } 05169 } 05170 } 05171 } 05172 } 05173 } 05174 if (N0.getOpcode() == ISD::LOAD && 05175 N0.hasOneUse() && 05176 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 05177 SDValue Chain0 = N0.getOperand(0); 05178 if (Predicate_unindexedload(N0.getNode()) && 05179 Predicate_load(N0.getNode()) && 05180 Predicate_memop(N0.getNode())) { 05181 SDValue N01 = N0.getOperand(1); 05182 SDValue CPTmpN01_0; 05183 SDValue CPTmpN01_1; 05184 SDValue CPTmpN01_2; 05185 SDValue CPTmpN01_3; 05186 SDValue CPTmpN01_4; 05187 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 05188 SDValue N1 = N.getOperand(1); 05189 if (N1.getOpcode() == ISD::XOR) { 05190 SDValue N10 = N1.getOperand(0); 05191 05192 // Pattern: (and:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (xor:v2i64 VR128:v2i64:$src1, (bitconvert:v2i64 (build_vector:v16i8)<<P:Predicate_immAllOnesV>>))) 05193 // Emits: (PANDNrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 05194 // Pattern complexity = 35 cost = 1 size = 3 05195 { 05196 SDValue N11 = N1.getOperand(1); 05197 if (N11.getOpcode() == ISD::BIT_CONVERT) { 05198 SDValue N110 = N11.getOperand(0); 05199 if (N110.getOpcode() == ISD::BUILD_VECTOR && 05200 Predicate_immAllOnesV(N110.getNode()) && 05201 N110.getNode()->getValueType(0) == MVT::v16i8) { 05202 SDNode *Result = Emit_54(N, X86::PANDNrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 05203 return Result; 05204 } 05205 } 05206 } 05207 05208 // Pattern: (and:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (xor:v2i64 (bitconvert:v2i64 (build_vector:v16i8)<<P:Predicate_immAllOnesV>>), VR128:v2i64:$src1)) 05209 // Emits: (PANDNrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 05210 // Pattern complexity = 35 cost = 1 size = 3 05211 if (N10.getOpcode() == ISD::BIT_CONVERT) { 05212 SDValue N100 = N10.getOperand(0); 05213 if (N100.getOpcode() == ISD::BUILD_VECTOR && 05214 Predicate_immAllOnesV(N100.getNode())) { 05215 SDValue N11 = N1.getOperand(1); 05216 if (N100.getNode()->getValueType(0) == MVT::v16i8) { 05217 SDNode *Result = Emit_55(N, X86::PANDNrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 05218 return Result; 05219 } 05220 } 05221 } 05222 } 05223 } 05224 } 05225 } 05226 if (N0.getOpcode() == ISD::XOR) { 05227 SDValue N00 = N0.getOperand(0); 05228 05229 // Pattern: (and:v2i64 (xor:v2i64 VR128:v2i64:$src1, (build_vector:v2i64)<<P:Predicate_immAllOnesV>>), (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 05230 // Emits: (PANDNrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 05231 // Pattern complexity = 32 cost = 1 size = 3 05232 { 05233 SDValue N01 = N0.getOperand(1); 05234 if (N01.getOpcode() == ISD::BUILD_VECTOR && 05235 Predicate_immAllOnesV(N01.getNode())) { 05236 SDValue N1 = N.getOperand(1); 05237 if (N1.getOpcode() == ISD::LOAD && 05238 N1.hasOneUse() && 05239 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 05240 SDValue Chain1 = N1.getOperand(0); 05241 if (Predicate_unindexedload(N1.getNode()) && 05242 Predicate_load(N1.getNode()) && 05243 Predicate_memop(N1.getNode())) { 05244 SDValue N11 = N1.getOperand(1); 05245 SDValue CPTmpN11_0; 05246 SDValue CPTmpN11_1; 05247 SDValue CPTmpN11_2; 05248 SDValue CPTmpN11_3; 05249 SDValue CPTmpN11_4; 05250 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 05251 SDNode *Result = Emit_41(N, X86::PANDNrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 05252 return Result; 05253 } 05254 } 05255 } 05256 } 05257 } 05258 05259 // Pattern: (and:v2i64 (xor:v2i64 (build_vector:v2i64)<<P:Predicate_immAllOnesV>>, VR128:v2i64:$src1), (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 05260 // Emits: (PANDNrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 05261 // Pattern complexity = 32 cost = 1 size = 3 05262 if (N00.getOpcode() == ISD::BUILD_VECTOR && 05263 Predicate_immAllOnesV(N00.getNode())) { 05264 SDValue N01 = N0.getOperand(1); 05265 SDValue N1 = N.getOperand(1); 05266 if (N1.getOpcode() == ISD::LOAD && 05267 N1.hasOneUse() && 05268 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 05269 SDValue Chain1 = N1.getOperand(0); 05270 if (Predicate_unindexedload(N1.getNode()) && 05271 Predicate_load(N1.getNode()) && 05272 Predicate_memop(N1.getNode())) { 05273 SDValue N11 = N1.getOperand(1); 05274 SDValue CPTmpN11_0; 05275 SDValue CPTmpN11_1; 05276 SDValue CPTmpN11_2; 05277 SDValue CPTmpN11_3; 05278 SDValue CPTmpN11_4; 05279 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 05280 SDNode *Result = Emit_47(N, X86::PANDNrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 05281 return Result; 05282 } 05283 } 05284 } 05285 } 05286 } 05287 if (N0.getOpcode() == ISD::LOAD && 05288 N0.hasOneUse() && 05289 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 05290 SDValue Chain0 = N0.getOperand(0); 05291 if (Predicate_unindexedload(N0.getNode()) && 05292 Predicate_load(N0.getNode()) && 05293 Predicate_memop(N0.getNode())) { 05294 SDValue N01 = N0.getOperand(1); 05295 SDValue CPTmpN01_0; 05296 SDValue CPTmpN01_1; 05297 SDValue CPTmpN01_2; 05298 SDValue CPTmpN01_3; 05299 SDValue CPTmpN01_4; 05300 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 05301 SDValue N1 = N.getOperand(1); 05302 if (N1.getOpcode() == ISD::XOR) { 05303 SDValue N10 = N1.getOperand(0); 05304 05305 // Pattern: (and:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (xor:v2i64 VR128:v2i64:$src1, (build_vector:v2i64)<<P:Predicate_immAllOnesV>>)) 05306 // Emits: (PANDNrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 05307 // Pattern complexity = 32 cost = 1 size = 3 05308 { 05309 SDValue N11 = N1.getOperand(1); 05310 if (N11.getOpcode() == ISD::BUILD_VECTOR && 05311 Predicate_immAllOnesV(N11.getNode())) { 05312 SDNode *Result = Emit_48(N, X86::PANDNrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 05313 return Result; 05314 } 05315 } 05316 05317 // Pattern: (and:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (xor:v2i64 (build_vector:v2i64)<<P:Predicate_immAllOnesV>>, VR128:v2i64:$src1)) 05318 // Emits: (PANDNrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 05319 // Pattern complexity = 32 cost = 1 size = 3 05320 if (N10.getOpcode() == ISD::BUILD_VECTOR && 05321 Predicate_immAllOnesV(N10.getNode())) { 05322 SDNode *Result = Emit_49(N, X86::PANDNrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 05323 return Result; 05324 } 05325 } 05326 } 05327 } 05328 } 05329 } 05330 05331 // Pattern: (and:v2i64 (bitconvert:v2i64 VR128:v4f32:$src1), (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 05332 // Emits: (ANDPSrm:v2i64 VR128:v4f32:$src1, addr:iPTR:$src2) 05333 // Pattern complexity = 28 cost = 1 size = 3 05334 if ((Subtarget->hasSSE1())) { 05335 SDValue N0 = N.getOperand(0); 05336 if (N0.getOpcode() == ISD::BIT_CONVERT) { 05337 SDValue N00 = N0.getOperand(0); 05338 SDValue N1 = N.getOperand(1); 05339 if (N1.getOpcode() == ISD::LOAD && 05340 N1.hasOneUse() && 05341 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 05342 SDValue Chain1 = N1.getOperand(0); 05343 if (Predicate_unindexedload(N1.getNode()) && 05344 Predicate_load(N1.getNode()) && 05345 Predicate_memop(N1.getNode())) { 05346 SDValue N11 = N1.getOperand(1); 05347 SDValue CPTmpN11_0; 05348 SDValue CPTmpN11_1; 05349 SDValue CPTmpN11_2; 05350 SDValue CPTmpN11_3; 05351 SDValue CPTmpN11_4; 05352 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 05353 N00.getNode()->getValueType(0) == MVT::v4f32) { 05354 SDNode *Result = Emit_56(N, X86::ANDPSrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 05355 return Result; 05356 } 05357 } 05358 } 05359 } 05360 } 05361 05362 // Pattern: (and:v2i64 (bitconvert:v2i64 VR128:v2f64:$src1), (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 05363 // Emits: (ANDPDrm:v2i64 VR128:v2f64:$src1, addr:iPTR:$src2) 05364 // Pattern complexity = 28 cost = 1 size = 3 05365 if ((Subtarget->hasSSE2())) { 05366 SDValue N0 = N.getOperand(0); 05367 if (N0.getOpcode() == ISD::BIT_CONVERT) { 05368 SDValue N00 = N0.getOperand(0); 05369 SDValue N1 = N.getOperand(1); 05370 if (N1.getOpcode() == ISD::LOAD && 05371 N1.hasOneUse() && 05372 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 05373 SDValue Chain1 = N1.getOperand(0); 05374 if (Predicate_unindexedload(N1.getNode()) && 05375 Predicate_load(N1.getNode()) && 05376 Predicate_memop(N1.getNode())) { 05377 SDValue N11 = N1.getOperand(1); 05378 SDValue CPTmpN11_0; 05379 SDValue CPTmpN11_1; 05380 SDValue CPTmpN11_2; 05381 SDValue CPTmpN11_3; 05382 SDValue CPTmpN11_4; 05383 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 05384 N00.getNode()->getValueType(0) == MVT::v2f64) { 05385 SDNode *Result = Emit_56(N, X86::ANDPDrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 05386 return Result; 05387 } 05388 } 05389 } 05390 } 05391 } 05392 05393 // Pattern: (and:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (bitconvert:v2i64 VR128:v4f32:$src1)) 05394 // Emits: (ANDPSrm:v2i64 VR128:v4f32:$src1, addr:iPTR:$src2) 05395 // Pattern complexity = 28 cost = 1 size = 3 05396 if ((Subtarget->hasSSE1())) { 05397 SDValue N0 = N.getOperand(0); 05398 if (N0.getOpcode() == ISD::LOAD && 05399 N0.hasOneUse() && 05400 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 05401 SDValue Chain0 = N0.getOperand(0); 05402 if (Predicate_unindexedload(N0.getNode()) && 05403 Predicate_load(N0.getNode()) && 05404 Predicate_memop(N0.getNode())) { 05405 SDValue N01 = N0.getOperand(1); 05406 SDValue CPTmpN01_0; 05407 SDValue CPTmpN01_1; 05408 SDValue CPTmpN01_2; 05409 SDValue CPTmpN01_3; 05410 SDValue CPTmpN01_4; 05411 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 05412 SDValue N1 = N.getOperand(1); 05413 if (N1.getOpcode() == ISD::BIT_CONVERT) { 05414 SDValue N10 = N1.getOperand(0); 05415 if (N10.getNode()->getValueType(0) == MVT::v4f32) { 05416 SDNode *Result = Emit_61(N, X86::ANDPSrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 05417 return Result; 05418 } 05419 } 05420 } 05421 } 05422 } 05423 } 05424 if ((Subtarget->hasSSE2())) { 05425 SDValue N0 = N.getOperand(0); 05426 05427 // Pattern: (and:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (bitconvert:v2i64 VR128:v2f64:$src1)) 05428 // Emits: (ANDPDrm:v2i64 VR128:v2f64:$src1, addr:iPTR:$src2) 05429 // Pattern complexity = 28 cost = 1 size = 3 05430 if (N0.getOpcode() == ISD::LOAD && 05431 N0.hasOneUse() && 05432 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 05433 SDValue Chain0 = N0.getOperand(0); 05434 if (Predicate_unindexedload(N0.getNode()) && 05435 Predicate_load(N0.getNode()) && 05436 Predicate_memop(N0.getNode())) { 05437 SDValue N01 = N0.getOperand(1); 05438 SDValue CPTmpN01_0; 05439 SDValue CPTmpN01_1; 05440 SDValue CPTmpN01_2; 05441 SDValue CPTmpN01_3; 05442 SDValue CPTmpN01_4; 05443 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 05444 SDValue N1 = N.getOperand(1); 05445 if (N1.getOpcode() == ISD::BIT_CONVERT) { 05446 SDValue N10 = N1.getOperand(0); 05447 if (N10.getNode()->getValueType(0) == MVT::v2f64) { 05448 SDNode *Result = Emit_61(N, X86::ANDPDrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 05449 return Result; 05450 } 05451 } 05452 } 05453 } 05454 } 05455 05456 // Pattern: (and:v2i64 VR128:v2i64:$src1, (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 05457 // Emits: (PANDrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 05458 // Pattern complexity = 25 cost = 1 size = 3 05459 { 05460 SDValue N1 = N.getOperand(1); 05461 if (N1.getOpcode() == ISD::LOAD && 05462 N1.hasOneUse() && 05463 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 05464 SDValue Chain1 = N1.getOperand(0); 05465 if (Predicate_unindexedload(N1.getNode()) && 05466 Predicate_load(N1.getNode()) && 05467 Predicate_memop(N1.getNode())) { 05468 SDValue N11 = N1.getOperand(1); 05469 SDValue CPTmpN11_0; 05470 SDValue CPTmpN11_1; 05471 SDValue CPTmpN11_2; 05472 SDValue CPTmpN11_3; 05473 SDValue CPTmpN11_4; 05474 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 05475 SDNode *Result = Emit_18(N, X86::PANDrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 05476 return Result; 05477 } 05478 } 05479 } 05480 } 05481 05482 // Pattern: (and:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, VR128:v2i64:$src1) 05483 // Emits: (PANDrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 05484 // Pattern complexity = 25 cost = 1 size = 3 05485 if (N0.getOpcode() == ISD::LOAD && 05486 N0.hasOneUse() && 05487 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 05488 SDValue Chain0 = N0.getOperand(0); 05489 if (Predicate_unindexedload(N0.getNode()) && 05490 Predicate_load(N0.getNode()) && 05491 Predicate_memop(N0.getNode())) { 05492 SDValue N01 = N0.getOperand(1); 05493 SDValue CPTmpN01_0; 05494 SDValue CPTmpN01_1; 05495 SDValue CPTmpN01_2; 05496 SDValue CPTmpN01_3; 05497 SDValue CPTmpN01_4; 05498 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 05499 SDNode *Result = Emit_19(N, X86::PANDrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 05500 return Result; 05501 } 05502 } 05503 } 05504 } 05505 } 05506 if ((Subtarget->hasSSE2())) { 05507 SDValue N0 = N.getOperand(0); 05508 if (N0.getOpcode() == ISD::XOR) { 05509 SDValue N00 = N0.getOperand(0); 05510 05511 // Pattern: (and:v2i64 (xor:v2i64 (bitconvert:v2i64 VR128:v2f64:$src1), (build_vector:v2i64)<<P:Predicate_immAllOnesV>>), (bitconvert:v2i64 VR128:v2f64:$src2)) 05512 // Emits: (ANDNPDrr:v2i64 VR128:v2f64:$src1, VR128:v2f64:$src2) 05513 // Pattern complexity = 16 cost = 1 size = 3 05514 if (N00.getOpcode() == ISD::BIT_CONVERT) { 05515 SDValue N000 = N00.getOperand(0); 05516 SDValue N01 = N0.getOperand(1); 05517 if (N01.getOpcode() == ISD::BUILD_VECTOR && 05518 Predicate_immAllOnesV(N01.getNode())) { 05519 SDValue N1 = N.getOperand(1); 05520 if (N1.getOpcode() == ISD::BIT_CONVERT) { 05521 SDValue N10 = N1.getOperand(0); 05522 if (N000.getNode()->getValueType(0) == MVT::v2f64 && 05523 N10.getNode()->getValueType(0) == MVT::v2f64) { 05524 SDNode *Result = Emit_59(N, X86::ANDNPDrr, MVT::v2i64); 05525 return Result; 05526 } 05527 } 05528 } 05529 } 05530 05531 // Pattern: (and:v2i64 (xor:v2i64 (build_vector:v2i64)<<P:Predicate_immAllOnesV>>, (bitconvert:v2i64 VR128:v2f64:$src1)), (bitconvert:v2i64 VR128:v2f64:$src2)) 05532 // Emits: (ANDNPDrr:v2i64 VR128:v2f64:$src1, VR128:v2f64:$src2) 05533 // Pattern complexity = 16 cost = 1 size = 3 05534 if (N00.getOpcode() == ISD::BUILD_VECTOR && 05535 Predicate_immAllOnesV(N00.getNode())) { 05536 SDValue N01 = N0.getOperand(1); 05537 if (N01.getOpcode() == ISD::BIT_CONVERT) { 05538 SDValue N010 = N01.getOperand(0); 05539 SDValue N1 = N.getOperand(1); 05540 if (N1.getOpcode() == ISD::BIT_CONVERT) { 05541 SDValue N10 = N1.getOperand(0); 05542 if (N010.getNode()->getValueType(0) == MVT::v2f64 && 05543 N10.getNode()->getValueType(0) == MVT::v2f64) { 05544 SDNode *Result = Emit_65(N, X86::ANDNPDrr, MVT::v2i64); 05545 return Result; 05546 } 05547 } 05548 } 05549 } 05550 } 05551 if (N0.getOpcode() == ISD::BIT_CONVERT) { 05552 SDValue N00 = N0.getOperand(0); 05553 SDValue N1 = N.getOperand(1); 05554 if (N1.getOpcode() == ISD::XOR) { 05555 SDValue N10 = N1.getOperand(0); 05556 05557 // Pattern: (and:v2i64 (bitconvert:v2i64 VR128:v2f64:$src2), (xor:v2i64 (bitconvert:v2i64 VR128:v2f64:$src1), (build_vector:v2i64)<<P:Predicate_immAllOnesV>>)) 05558 // Emits: (ANDNPDrr:v2i64 VR128:v2f64:$src1, VR128:v2f64:$src2) 05559 // Pattern complexity = 16 cost = 1 size = 3 05560 if (N10.getOpcode() == ISD::BIT_CONVERT) { 05561 SDValue N100 = N10.getOperand(0); 05562 SDValue N11 = N1.getOperand(1); 05563 if (N11.getOpcode() == ISD::BUILD_VECTOR && 05564 Predicate_immAllOnesV(N11.getNode()) && 05565 N00.getNode()->getValueType(0) == MVT::v2f64 && 05566 N100.getNode()->getValueType(0) == MVT::v2f64) { 05567 SDNode *Result = Emit_66(N, X86::ANDNPDrr, MVT::v2i64); 05568 return Result; 05569 } 05570 } 05571 05572 // Pattern: (and:v2i64 (bitconvert:v2i64 VR128:v2f64:$src2), (xor:v2i64 (build_vector:v2i64)<<P:Predicate_immAllOnesV>>, (bitconvert:v2i64 VR128:v2f64:$src1))) 05573 // Emits: (ANDNPDrr:v2i64 VR128:v2f64:$src1, VR128:v2f64:$src2) 05574 // Pattern complexity = 16 cost = 1 size = 3 05575 if (N10.getOpcode() == ISD::BUILD_VECTOR && 05576 Predicate_immAllOnesV(N10.getNode())) { 05577 SDValue N11 = N1.getOperand(1); 05578 if (N11.getOpcode() == ISD::BIT_CONVERT) { 05579 SDValue N110 = N11.getOperand(0); 05580 if (N00.getNode()->getValueType(0) == MVT::v2f64 && 05581 N110.getNode()->getValueType(0) == MVT::v2f64) { 05582 SDNode *Result = Emit_67(N, X86::ANDNPDrr, MVT::v2i64); 05583 return Result; 05584 } 05585 } 05586 } 05587 } 05588 } 05589 } 05590 05591 // Pattern: (and:v2i64 (xor:v2i64 VR128:v2i64:$src1, (bitconvert:v2i64 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>)), VR128:v2i64:$src2) 05592 // Emits: (ANDNPSrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 05593 // Pattern complexity = 13 cost = 1 size = 3 05594 if ((Subtarget->hasSSE1())) { 05595 SDValue N0 = N.getOperand(0); 05596 if (N0.getOpcode() == ISD::XOR) { 05597 SDValue N00 = N0.getOperand(0); 05598 SDValue N01 = N0.getOperand(1); 05599 if (N01.getOpcode() == ISD::BIT_CONVERT) { 05600 SDValue N010 = N01.getOperand(0); 05601 if (N010.getOpcode() == ISD::BUILD_VECTOR && 05602 Predicate_immAllOnesV(N010.getNode())) { 05603 SDValue N1 = N.getOperand(1); 05604 if (N010.getNode()->getValueType(0) == MVT::v4i32) { 05605 SDNode *Result = Emit_42(N, X86::ANDNPSrr, MVT::v2i64); 05606 return Result; 05607 } 05608 } 05609 } 05610 } 05611 } 05612 if ((Subtarget->hasSSE2())) { 05613 SDValue N0 = N.getOperand(0); 05614 if (N0.getOpcode() == ISD::XOR) { 05615 SDValue N00 = N0.getOperand(0); 05616 SDValue N01 = N0.getOperand(1); 05617 if (N01.getOpcode() == ISD::BIT_CONVERT) { 05618 SDValue N010 = N01.getOperand(0); 05619 if (N010.getOpcode() == ISD::BUILD_VECTOR && 05620 Predicate_immAllOnesV(N010.getNode())) { 05621 SDValue N1 = N.getOperand(1); 05622 05623 // Pattern: (and:v2i64 (xor:v2i64 VR128:v2i64:$src1, (bitconvert:v2i64 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>)), VR128:v2i64:$src2) 05624 // Emits: (PANDNrr:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src2) 05625 // Pattern complexity = 13 cost = 1 size = 3 05626 if (N010.getNode()->getValueType(0) == MVT::v4i32) { 05627 SDNode *Result = Emit_42(N, X86::PANDNrr, MVT::v2i64); 05628 return Result; 05629 } 05630 05631 // Pattern: (and:v2i64 (xor:v2i64 VR128:v2i64:$src1, (bitconvert:v2i64 (build_vector:v8i16)<<P:Predicate_immAllOnesV>>)), VR128:v2i64:$src2) 05632 // Emits: (PANDNrr:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src2) 05633 // Pattern complexity = 13 cost = 1 size = 3 05634 if (N010.getNode()->getValueType(0) == MVT::v8i16) { 05635 SDNode *Result = Emit_42(N, X86::PANDNrr, MVT::v2i64); 05636 return Result; 05637 } 05638 05639 // Pattern: (and:v2i64 (xor:v2i64 VR128:v2i64:$src1, (bitconvert:v2i64 (build_vector:v16i8)<<P:Predicate_immAllOnesV>>)), VR128:v2i64:$src2) 05640 // Emits: (PANDNrr:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src2) 05641 // Pattern complexity = 13 cost = 1 size = 3 05642 if (N010.getNode()->getValueType(0) == MVT::v16i8) { 05643 SDNode *Result = Emit_42(N, X86::PANDNrr, MVT::v2i64); 05644 return Result; 05645 } 05646 } 05647 } 05648 } 05649 } 05650 if ((Subtarget->hasSSE1())) { 05651 SDValue N0 = N.getOperand(0); 05652 05653 // Pattern: (and:v2i64 (xor:v2i64 (bitconvert:v2i64 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>), VR128:v2i64:$src1), VR128:v2i64:$src2) 05654 // Emits: (ANDNPSrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 05655 // Pattern complexity = 13 cost = 1 size = 3 05656 if (N0.getOpcode() == ISD::XOR) { 05657 SDValue N00 = N0.getOperand(0); 05658 if (N00.getOpcode() == ISD::BIT_CONVERT) { 05659 SDValue N000 = N00.getOperand(0); 05660 if (N000.getOpcode() == ISD::BUILD_VECTOR && 05661 Predicate_immAllOnesV(N000.getNode())) { 05662 SDValue N01 = N0.getOperand(1); 05663 SDValue N1 = N.getOperand(1); 05664 if (N000.getNode()->getValueType(0) == MVT::v4i32) { 05665 SDNode *Result = Emit_50(N, X86::ANDNPSrr, MVT::v2i64); 05666 return Result; 05667 } 05668 } 05669 } 05670 } 05671 SDValue N1 = N.getOperand(1); 05672 if (N1.getOpcode() == ISD::XOR) { 05673 SDValue N10 = N1.getOperand(0); 05674 05675 // Pattern: (and:v2i64 VR128:v2i64:$src2, (xor:v2i64 VR128:v2i64:$src1, (bitconvert:v2i64 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>))) 05676 // Emits: (ANDNPSrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 05677 // Pattern complexity = 13 cost = 1 size = 3 05678 { 05679 SDValue N11 = N1.getOperand(1); 05680 if (N11.getOpcode() == ISD::BIT_CONVERT) { 05681 SDValue N110 = N11.getOperand(0); 05682 if (N110.getOpcode() == ISD::BUILD_VECTOR && 05683 Predicate_immAllOnesV(N110.getNode()) && 05684 N110.getNode()->getValueType(0) == MVT::v4i32) { 05685 SDNode *Result = Emit_51(N, X86::ANDNPSrr, MVT::v2i64); 05686 return Result; 05687 } 05688 } 05689 } 05690 05691 // Pattern: (and:v2i64 VR128:v2i64:$src2, (xor:v2i64 (bitconvert:v2i64 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>), VR128:v2i64:$src1)) 05692 // Emits: (ANDNPSrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 05693 // Pattern complexity = 13 cost = 1 size = 3 05694 if (N10.getOpcode() == ISD::BIT_CONVERT) { 05695 SDValue N100 = N10.getOperand(0); 05696 if (N100.getOpcode() == ISD::BUILD_VECTOR && 05697 Predicate_immAllOnesV(N100.getNode())) { 05698 SDValue N11 = N1.getOperand(1); 05699 if (N100.getNode()->getValueType(0) == MVT::v4i32) { 05700 SDNode *Result = Emit_52(N, X86::ANDNPSrr, MVT::v2i64); 05701 return Result; 05702 } 05703 } 05704 } 05705 } 05706 } 05707 if ((Subtarget->hasSSE2())) { 05708 SDValue N0 = N.getOperand(0); 05709 05710 // Pattern: (and:v2i64 (xor:v2i64 (bitconvert:v2i64 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>), VR128:v2i64:$src1), VR128:v2i64:$src2) 05711 // Emits: (PANDNrr:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src2) 05712 // Pattern complexity = 13 cost = 1 size = 3 05713 if (N0.getOpcode() == ISD::XOR) { 05714 SDValue N00 = N0.getOperand(0); 05715 if (N00.getOpcode() == ISD::BIT_CONVERT) { 05716 SDValue N000 = N00.getOperand(0); 05717 if (N000.getOpcode() == ISD::BUILD_VECTOR && 05718 Predicate_immAllOnesV(N000.getNode())) { 05719 SDValue N01 = N0.getOperand(1); 05720 SDValue N1 = N.getOperand(1); 05721 if (N000.getNode()->getValueType(0) == MVT::v4i32) { 05722 SDNode *Result = Emit_50(N, X86::PANDNrr, MVT::v2i64); 05723 return Result; 05724 } 05725 } 05726 } 05727 } 05728 { 05729 SDValue N1 = N.getOperand(1); 05730 if (N1.getOpcode() == ISD::XOR) { 05731 SDValue N10 = N1.getOperand(0); 05732 05733 // Pattern: (and:v2i64 VR128:v2i64:$src2, (xor:v2i64 VR128:v2i64:$src1, (bitconvert:v2i64 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>))) 05734 // Emits: (PANDNrr:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src2) 05735 // Pattern complexity = 13 cost = 1 size = 3 05736 { 05737 SDValue N11 = N1.getOperand(1); 05738 if (N11.getOpcode() == ISD::BIT_CONVERT) { 05739 SDValue N110 = N11.getOperand(0); 05740 if (N110.getOpcode() == ISD::BUILD_VECTOR && 05741 Predicate_immAllOnesV(N110.getNode()) && 05742 N110.getNode()->getValueType(0) == MVT::v4i32) { 05743 SDNode *Result = Emit_51(N, X86::PANDNrr, MVT::v2i64); 05744 return Result; 05745 } 05746 } 05747 } 05748 05749 // Pattern: (and:v2i64 VR128:v2i64:$src2, (xor:v2i64 (bitconvert:v2i64 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>), VR128:v2i64:$src1)) 05750 // Emits: (PANDNrr:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src2) 05751 // Pattern complexity = 13 cost = 1 size = 3 05752 if (N10.getOpcode() == ISD::BIT_CONVERT) { 05753 SDValue N100 = N10.getOperand(0); 05754 if (N100.getOpcode() == ISD::BUILD_VECTOR && 05755 Predicate_immAllOnesV(N100.getNode())) { 05756 SDValue N11 = N1.getOperand(1); 05757 if (N100.getNode()->getValueType(0) == MVT::v4i32) { 05758 SDNode *Result = Emit_52(N, X86::PANDNrr, MVT::v2i64); 05759 return Result; 05760 } 05761 } 05762 } 05763 } 05764 } 05765 05766 // Pattern: (and:v2i64 (xor:v2i64 (bitconvert:v2i64 (build_vector:v8i16)<<P:Predicate_immAllOnesV>>), VR128:v2i64:$src1), VR128:v2i64:$src2) 05767 // Emits: (PANDNrr:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src2) 05768 // Pattern complexity = 13 cost = 1 size = 3 05769 if (N0.getOpcode() == ISD::XOR) { 05770 SDValue N00 = N0.getOperand(0); 05771 if (N00.getOpcode() == ISD::BIT_CONVERT) { 05772 SDValue N000 = N00.getOperand(0); 05773 if (N000.getOpcode() == ISD::BUILD_VECTOR && 05774 Predicate_immAllOnesV(N000.getNode())) { 05775 SDValue N01 = N0.getOperand(1); 05776 SDValue N1 = N.getOperand(1); 05777 if (N000.getNode()->getValueType(0) == MVT::v8i16) { 05778 SDNode *Result = Emit_50(N, X86::PANDNrr, MVT::v2i64); 05779 return Result; 05780 } 05781 } 05782 } 05783 } 05784 { 05785 SDValue N1 = N.getOperand(1); 05786 if (N1.getOpcode() == ISD::XOR) { 05787 SDValue N10 = N1.getOperand(0); 05788 05789 // Pattern: (and:v2i64 VR128:v2i64:$src2, (xor:v2i64 VR128:v2i64:$src1, (bitconvert:v2i64 (build_vector:v8i16)<<P:Predicate_immAllOnesV>>))) 05790 // Emits: (PANDNrr:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src2) 05791 // Pattern complexity = 13 cost = 1 size = 3 05792 { 05793 SDValue N11 = N1.getOperand(1); 05794 if (N11.getOpcode() == ISD::BIT_CONVERT) { 05795 SDValue N110 = N11.getOperand(0); 05796 if (N110.getOpcode() == ISD::BUILD_VECTOR && 05797 Predicate_immAllOnesV(N110.getNode()) && 05798 N110.getNode()->getValueType(0) == MVT::v8i16) { 05799 SDNode *Result = Emit_51(N, X86::PANDNrr, MVT::v2i64); 05800 return Result; 05801 } 05802 } 05803 } 05804 05805 // Pattern: (and:v2i64 VR128:v2i64:$src2, (xor:v2i64 (bitconvert:v2i64 (build_vector:v8i16)<<P:Predicate_immAllOnesV>>), VR128:v2i64:$src1)) 05806 // Emits: (PANDNrr:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src2) 05807 // Pattern complexity = 13 cost = 1 size = 3 05808 if (N10.getOpcode() == ISD::BIT_CONVERT) { 05809 SDValue N100 = N10.getOperand(0); 05810 if (N100.getOpcode() == ISD::BUILD_VECTOR && 05811 Predicate_immAllOnesV(N100.getNode())) { 05812 SDValue N11 = N1.getOperand(1); 05813 if (N100.getNode()->getValueType(0) == MVT::v8i16) { 05814 SDNode *Result = Emit_52(N, X86::PANDNrr, MVT::v2i64); 05815 return Result; 05816 } 05817 } 05818 } 05819 } 05820 } 05821 05822 // Pattern: (and:v2i64 (xor:v2i64 (bitconvert:v2i64 (build_vector:v16i8)<<P:Predicate_immAllOnesV>>), VR128:v2i64:$src1), VR128:v2i64:$src2) 05823 // Emits: (PANDNrr:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src2) 05824 // Pattern complexity = 13 cost = 1 size = 3 05825 if (N0.getOpcode() == ISD::XOR) { 05826 SDValue N00 = N0.getOperand(0); 05827 if (N00.getOpcode() == ISD::BIT_CONVERT) { 05828 SDValue N000 = N00.getOperand(0); 05829 if (N000.getOpcode() == ISD::BUILD_VECTOR && 05830 Predicate_immAllOnesV(N000.getNode())) { 05831 SDValue N01 = N0.getOperand(1); 05832 SDValue N1 = N.getOperand(1); 05833 if (N000.getNode()->getValueType(0) == MVT::v16i8) { 05834 SDNode *Result = Emit_50(N, X86::PANDNrr, MVT::v2i64); 05835 return Result; 05836 } 05837 } 05838 } 05839 } 05840 { 05841 SDValue N1 = N.getOperand(1); 05842 if (N1.getOpcode() == ISD::XOR) { 05843 SDValue N10 = N1.getOperand(0); 05844 05845 // Pattern: (and:v2i64 VR128:v2i64:$src2, (xor:v2i64 VR128:v2i64:$src1, (bitconvert:v2i64 (build_vector:v16i8)<<P:Predicate_immAllOnesV>>))) 05846 // Emits: (PANDNrr:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src2) 05847 // Pattern complexity = 13 cost = 1 size = 3 05848 { 05849 SDValue N11 = N1.getOperand(1); 05850 if (N11.getOpcode() == ISD::BIT_CONVERT) { 05851 SDValue N110 = N11.getOperand(0); 05852 if (N110.getOpcode() == ISD::BUILD_VECTOR && 05853 Predicate_immAllOnesV(N110.getNode()) && 05854 N110.getNode()->getValueType(0) == MVT::v16i8) { 05855 SDNode *Result = Emit_51(N, X86::PANDNrr, MVT::v2i64); 05856 return Result; 05857 } 05858 } 05859 } 05860 05861 // Pattern: (and:v2i64 VR128:v2i64:$src2, (xor:v2i64 (bitconvert:v2i64 (build_vector:v16i8)<<P:Predicate_immAllOnesV>>), VR128:v2i64:$src1)) 05862 // Emits: (PANDNrr:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src2) 05863 // Pattern complexity = 13 cost = 1 size = 3 05864 if (N10.getOpcode() == ISD::BIT_CONVERT) { 05865 SDValue N100 = N10.getOperand(0); 05866 if (N100.getOpcode() == ISD::BUILD_VECTOR && 05867 Predicate_immAllOnesV(N100.getNode())) { 05868 SDValue N11 = N1.getOperand(1); 05869 if (N100.getNode()->getValueType(0) == MVT::v16i8) { 05870 SDNode *Result = Emit_52(N, X86::PANDNrr, MVT::v2i64); 05871 return Result; 05872 } 05873 } 05874 } 05875 } 05876 } 05877 if (N0.getOpcode() == ISD::XOR) { 05878 SDValue N00 = N0.getOperand(0); 05879 05880 // Pattern: (and:v2i64 (xor:v2i64 VR128:v2i64:$src1, (build_vector:v2i64)<<P:Predicate_immAllOnesV>>), VR128:v2i64:$src2) 05881 // Emits: (PANDNrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 05882 // Pattern complexity = 10 cost = 1 size = 3 05883 { 05884 SDValue N01 = N0.getOperand(1); 05885 if (N01.getOpcode() == ISD::BUILD_VECTOR && 05886 Predicate_immAllOnesV(N01.getNode())) { 05887 SDNode *Result = Emit_40(N, X86::PANDNrr, MVT::v2i64); 05888 return Result; 05889 } 05890 } 05891 05892 // Pattern: (and:v2i64 (xor:v2i64 (build_vector:v2i64)<<P:Predicate_immAllOnesV>>, VR128:v2i64:$src1), VR128:v2i64:$src2) 05893 // Emits: (PANDNrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 05894 // Pattern complexity = 10 cost = 1 size = 3 05895 if (N00.getOpcode() == ISD::BUILD_VECTOR && 05896 Predicate_immAllOnesV(N00.getNode())) { 05897 SDNode *Result = Emit_44(N, X86::PANDNrr, MVT::v2i64); 05898 return Result; 05899 } 05900 } 05901 { 05902 SDValue N1 = N.getOperand(1); 05903 if (N1.getOpcode() == ISD::XOR) { 05904 SDValue N10 = N1.getOperand(0); 05905 05906 // Pattern: (and:v2i64 VR128:v2i64:$src2, (xor:v2i64 VR128:v2i64:$src1, (build_vector:v2i64)<<P:Predicate_immAllOnesV>>)) 05907 // Emits: (PANDNrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 05908 // Pattern complexity = 10 cost = 1 size = 3 05909 { 05910 SDValue N11 = N1.getOperand(1); 05911 if (N11.getOpcode() == ISD::BUILD_VECTOR && 05912 Predicate_immAllOnesV(N11.getNode())) { 05913 SDNode *Result = Emit_45(N, X86::PANDNrr, MVT::v2i64); 05914 return Result; 05915 } 05916 } 05917 05918 // Pattern: (and:v2i64 VR128:v2i64:$src2, (xor:v2i64 (build_vector:v2i64)<<P:Predicate_immAllOnesV>>, VR128:v2i64:$src1)) 05919 // Emits: (PANDNrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 05920 // Pattern complexity = 10 cost = 1 size = 3 05921 if (N10.getOpcode() == ISD::BUILD_VECTOR && 05922 Predicate_immAllOnesV(N10.getNode())) { 05923 SDNode *Result = Emit_46(N, X86::PANDNrr, MVT::v2i64); 05924 return Result; 05925 } 05926 } 05927 } 05928 05929 // Pattern: (and:v2i64 (bitconvert:v2i64 VR128:v2f64:$src1), (bitconvert:v2i64 VR128:v2f64:$src2)) 05930 // Emits: (ANDPDrr:v2i64 VR128:v2f64:$src1, VR128:v2f64:$src2) 05931 // Pattern complexity = 9 cost = 1 size = 3 05932 if (N0.getOpcode() == ISD::BIT_CONVERT) { 05933 SDValue N00 = N0.getOperand(0); 05934 SDValue N1 = N.getOperand(1); 05935 if (N1.getOpcode() == ISD::BIT_CONVERT) { 05936 SDValue N10 = N1.getOperand(0); 05937 if (N00.getNode()->getValueType(0) == MVT::v2f64 && 05938 N10.getNode()->getValueType(0) == MVT::v2f64) { 05939 SDNode *Result = Emit_58(N, X86::ANDPDrr, MVT::v2i64); 05940 return Result; 05941 } 05942 } 05943 } 05944 } 05945 05946 // Pattern: (and:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 05947 // Emits: (ANDPSrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 05948 // Pattern complexity = 3 cost = 1 size = 3 05949 if ((Subtarget->hasSSE1())) { 05950 SDNode *Result = Emit_15(N, X86::ANDPSrr, MVT::v2i64); 05951 return Result; 05952 } 05953 05954 // Pattern: (and:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 05955 // Emits: (PANDrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 05956 // Pattern complexity = 3 cost = 1 size = 3 05957 if ((Subtarget->hasSSE2())) { 05958 SDNode *Result = Emit_15(N, X86::PANDrr, MVT::v2i64); 05959 return Result; 05960 } 05961 05962 CannotYetSelect(N); 05963 return NULL; 05964 } 05965 05966 SDNode *Emit_71(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 05967 SDValue N0 = N.getOperand(0); 05968 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0); 05969 } 05970 SDNode *Emit_72(const SDValue &N, unsigned Opc0, unsigned Opc1, EVT VT0, EVT VT1) DISABLE_INLINE { 05971 SDValue N0 = N.getOperand(0); 05972 SDValue Tmp0(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0), 0); 05973 SDValue Tmp2 = CurDAG->getTargetConstant(0x1ULL, MVT::i32); 05974 return CurDAG->SelectNodeTo(N.getNode(), Opc1, VT1, Tmp0, N0, Tmp2); 05975 } 05976 SDNode *Select_ISD_ANY_EXTEND_i16(const SDValue &N) { 05977 05978 // Pattern: (anyext:i16 GR8:i8:$src) 05979 // Emits: (MOVZX16rr8:i16 GR8:i8:$src) 05980 // Pattern complexity = 3 cost = 1 size = 3 05981 if ((!Subtarget->is64Bit())) { 05982 SDValue N0 = N.getOperand(0); 05983 if (N0.getNode()->getValueType(0) == MVT::i8) { 05984 SDNode *Result = Emit_71(N, X86::MOVZX16rr8, MVT::i16); 05985 return Result; 05986 } 05987 } 05988 05989 // Pattern: (anyext:i16 GR8:i8:$src) 05990 // Emits: (INSERT_SUBREG:i16 (IMPLICIT_DEF:i16), GR8:i8:$src, 1:i32) 05991 // Pattern complexity = 3 cost = 2 size = 0 05992 if ((Subtarget->is64Bit())) { 05993 SDValue N0 = N.getOperand(0); 05994 if (N0.getNode()->getValueType(0) == MVT::i8) { 05995 SDNode *Result = Emit_72(N, TargetInstrInfo::IMPLICIT_DEF, TargetInstrInfo::INSERT_SUBREG, MVT::i16, MVT::i16); 05996 return Result; 05997 } 05998 } 05999 06000 CannotYetSelect(N); 06001 return NULL; 06002 } 06003 06004 SDNode *Emit_73(const SDValue &N, unsigned Opc0, unsigned Opc1, EVT VT0, EVT VT1) DISABLE_INLINE { 06005 SDValue N0 = N.getOperand(0); 06006 SDValue Tmp0(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0), 0); 06007 SDValue Tmp2 = CurDAG->getTargetConstant(0x3ULL, MVT::i32); 06008 return CurDAG->SelectNodeTo(N.getNode(), Opc1, VT1, Tmp0, N0, Tmp2); 06009 } 06010 SDNode *Select_ISD_ANY_EXTEND_i32(const SDValue &N) { 06011 06012 // Pattern: (anyext:i32 GR8:i8:$src) 06013 // Emits: (MOVZX32rr8:i32 GR8:i8:$src) 06014 // Pattern complexity = 3 cost = 1 size = 3 06015 if ((!Subtarget->is64Bit())) { 06016 SDValue N0 = N.getOperand(0); 06017 if (N0.getNode()->getValueType(0) == MVT::i8) { 06018 SDNode *Result = Emit_71(N, X86::MOVZX32rr8, MVT::i32); 06019 return Result; 06020 } 06021 } 06022 06023 // Pattern: (anyext:i32 GR16:i16:$src) 06024 // Emits: (INSERT_SUBREG:i32 (IMPLICIT_DEF:i32), GR16:i16:$src, 3:i32) 06025 // Pattern complexity = 3 cost = 2 size = 0 06026 { 06027 SDValue N0 = N.getOperand(0); 06028 if (N0.getNode()->getValueType(0) == MVT::i16) { 06029 SDNode *Result = Emit_73(N, TargetInstrInfo::IMPLICIT_DEF, TargetInstrInfo::INSERT_SUBREG, MVT::i32, MVT::i32); 06030 return Result; 06031 } 06032 } 06033 06034 // Pattern: (anyext:i32 GR8:i8:$src) 06035 // Emits: (INSERT_SUBREG:i32 (IMPLICIT_DEF:i32), GR8:i8:$src, 1:i32) 06036 // Pattern complexity = 3 cost = 2 size = 0 06037 if ((Subtarget->is64Bit())) { 06038 SDValue N0 = N.getOperand(0); 06039 if (N0.getNode()->getValueType(0) == MVT::i8) { 06040 SDNode *Result = Emit_72(N, TargetInstrInfo::IMPLICIT_DEF, TargetInstrInfo::INSERT_SUBREG, MVT::i32, MVT::i32); 06041 return Result; 06042 } 06043 } 06044 06045 CannotYetSelect(N); 06046 return NULL; 06047 } 06048 06049 SDNode *Emit_74(const SDValue &N, unsigned Opc0, unsigned Opc1, EVT VT0, EVT VT1) DISABLE_INLINE { 06050 SDValue N0 = N.getOperand(0); 06051 SDValue Tmp0(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0), 0); 06052 SDValue Tmp2 = CurDAG->getTargetConstant(0x4ULL, MVT::i32); 06053 return CurDAG->SelectNodeTo(N.getNode(), Opc1, VT1, Tmp0, N0, Tmp2); 06054 } 06055 SDNode *Select_ISD_ANY_EXTEND_i64(const SDValue &N) { 06056 SDValue N0 = N.getOperand(0); 06057 06058 // Pattern: (anyext:i64 GR8:i8:$src) 06059 // Emits: (INSERT_SUBREG:i64 (IMPLICIT_DEF:i64), GR8:i8:$src, 1:i32) 06060 // Pattern complexity = 3 cost = 2 size = 0 06061 if (N0.getNode()->getValueType(0) == MVT::i8) { 06062 SDNode *Result = Emit_72(N, TargetInstrInfo::IMPLICIT_DEF, TargetInstrInfo::INSERT_SUBREG, MVT::i64, MVT::i64); 06063 return Result; 06064 } 06065 06066 // Pattern: (anyext:i64 GR16:i16:$src) 06067 // Emits: (INSERT_SUBREG:i64 (IMPLICIT_DEF:i64), GR16:i16:$src, 3:i32) 06068 // Pattern complexity = 3 cost = 2 size = 0 06069 if (N0.getNode()->getValueType(0) == MVT::i16) { 06070 SDNode *Result = Emit_73(N, TargetInstrInfo::IMPLICIT_DEF, TargetInstrInfo::INSERT_SUBREG, MVT::i64, MVT::i64); 06071 return Result; 06072 } 06073 06074 // Pattern: (anyext:i64 GR32:i32:$src) 06075 // Emits: (INSERT_SUBREG:i64 (IMPLICIT_DEF:i64), GR32:i32:$src, 4:i32) 06076 // Pattern complexity = 3 cost = 2 size = 0 06077 if (N0.getNode()->getValueType(0) == MVT::i32) { 06078 SDNode *Result = Emit_74(N, TargetInstrInfo::IMPLICIT_DEF, TargetInstrInfo::INSERT_SUBREG, MVT::i64, MVT::i64); 06079 return Result; 06080 } 06081 06082 CannotYetSelect(N); 06083 return NULL; 06084 } 06085 06086 SDNode *Emit_75(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN1_0, SDValue &CPTmpN1_1, SDValue &CPTmpN1_2, SDValue &CPTmpN1_3, SDValue &CPTmpN1_4) DISABLE_INLINE { 06087 SDValue Chain = N.getOperand(0); 06088 SDValue N1 = N.getOperand(1); 06089 SDValue N2 = N.getOperand(2); 06090 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 06091 SDValue Ops0[] = { CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, N2, LSI_N, Chain }; 06092 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 06093 } 06094 SDNode *Select_ISD_ATOMIC_LOAD_ADD_i8(const SDValue &N) { 06095 SDValue Chain = N.getOperand(0); 06096 if (Predicate_atomic_load_add_8(N.getNode())) { 06097 SDValue N1 = N.getOperand(1); 06098 SDValue CPTmpN1_0; 06099 SDValue CPTmpN1_1; 06100 SDValue CPTmpN1_2; 06101 SDValue CPTmpN1_3; 06102 SDValue CPTmpN1_4; 06103 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06104 SDNode *Result = Emit_75(N, X86::LXADD8, MVT::i8, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06105 return Result; 06106 } 06107 } 06108 06109 CannotYetSelect(N); 06110 return NULL; 06111 } 06112 06113 SDNode *Select_ISD_ATOMIC_LOAD_ADD_i16(const SDValue &N) { 06114 SDValue Chain = N.getOperand(0); 06115 if (Predicate_atomic_load_add_16(N.getNode())) { 06116 SDValue N1 = N.getOperand(1); 06117 SDValue CPTmpN1_0; 06118 SDValue CPTmpN1_1; 06119 SDValue CPTmpN1_2; 06120 SDValue CPTmpN1_3; 06121 SDValue CPTmpN1_4; 06122 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06123 SDNode *Result = Emit_75(N, X86::LXADD16, MVT::i16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06124 return Result; 06125 } 06126 } 06127 06128 CannotYetSelect(N); 06129 return NULL; 06130 } 06131 06132 SDNode *Select_ISD_ATOMIC_LOAD_ADD_i32(const SDValue &N) { 06133 SDValue Chain = N.getOperand(0); 06134 if (Predicate_atomic_load_add_32(N.getNode())) { 06135 SDValue N1 = N.getOperand(1); 06136 SDValue CPTmpN1_0; 06137 SDValue CPTmpN1_1; 06138 SDValue CPTmpN1_2; 06139 SDValue CPTmpN1_3; 06140 SDValue CPTmpN1_4; 06141 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06142 SDNode *Result = Emit_75(N, X86::LXADD32, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06143 return Result; 06144 } 06145 } 06146 06147 CannotYetSelect(N); 06148 return NULL; 06149 } 06150 06151 SDNode *Select_ISD_ATOMIC_LOAD_ADD_i64(const SDValue &N) { 06152 SDValue Chain = N.getOperand(0); 06153 if (Predicate_atomic_load_add_64(N.getNode())) { 06154 SDValue N1 = N.getOperand(1); 06155 SDValue CPTmpN1_0; 06156 SDValue CPTmpN1_1; 06157 SDValue CPTmpN1_2; 06158 SDValue CPTmpN1_3; 06159 SDValue CPTmpN1_4; 06160 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06161 SDNode *Result = Emit_75(N, X86::LXADD64, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06162 return Result; 06163 } 06164 } 06165 06166 CannotYetSelect(N); 06167 return NULL; 06168 } 06169 06170 SDNode *Select_ISD_ATOMIC_LOAD_AND_i8(const SDValue &N) { 06171 SDValue Chain = N.getOperand(0); 06172 if (Predicate_atomic_load_and_8(N.getNode())) { 06173 SDValue N1 = N.getOperand(1); 06174 SDValue CPTmpN1_0; 06175 SDValue CPTmpN1_1; 06176 SDValue CPTmpN1_2; 06177 SDValue CPTmpN1_3; 06178 SDValue CPTmpN1_4; 06179 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06180 SDNode *Result = Emit_75(N, X86::ATOMAND8, MVT::i8, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06181 return Result; 06182 } 06183 } 06184 06185 CannotYetSelect(N); 06186 return NULL; 06187 } 06188 06189 SDNode *Select_ISD_ATOMIC_LOAD_AND_i16(const SDValue &N) { 06190 SDValue Chain = N.getOperand(0); 06191 if (Predicate_atomic_load_and_16(N.getNode())) { 06192 SDValue N1 = N.getOperand(1); 06193 SDValue CPTmpN1_0; 06194 SDValue CPTmpN1_1; 06195 SDValue CPTmpN1_2; 06196 SDValue CPTmpN1_3; 06197 SDValue CPTmpN1_4; 06198 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06199 SDNode *Result = Emit_75(N, X86::ATOMAND16, MVT::i16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06200 return Result; 06201 } 06202 } 06203 06204 CannotYetSelect(N); 06205 return NULL; 06206 } 06207 06208 SDNode *Select_ISD_ATOMIC_LOAD_AND_i32(const SDValue &N) { 06209 SDValue Chain = N.getOperand(0); 06210 if (Predicate_atomic_load_and_32(N.getNode())) { 06211 SDValue N1 = N.getOperand(1); 06212 SDValue CPTmpN1_0; 06213 SDValue CPTmpN1_1; 06214 SDValue CPTmpN1_2; 06215 SDValue CPTmpN1_3; 06216 SDValue CPTmpN1_4; 06217 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06218 SDNode *Result = Emit_75(N, X86::ATOMAND32, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06219 return Result; 06220 } 06221 } 06222 06223 CannotYetSelect(N); 06224 return NULL; 06225 } 06226 06227 SDNode *Select_ISD_ATOMIC_LOAD_AND_i64(const SDValue &N) { 06228 SDValue Chain = N.getOperand(0); 06229 if (Predicate_atomic_load_and_64(N.getNode())) { 06230 SDValue N1 = N.getOperand(1); 06231 SDValue CPTmpN1_0; 06232 SDValue CPTmpN1_1; 06233 SDValue CPTmpN1_2; 06234 SDValue CPTmpN1_3; 06235 SDValue CPTmpN1_4; 06236 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06237 SDNode *Result = Emit_75(N, X86::ATOMAND64, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06238 return Result; 06239 } 06240 } 06241 06242 CannotYetSelect(N); 06243 return NULL; 06244 } 06245 06246 SDNode *Select_ISD_ATOMIC_LOAD_MAX_i16(const SDValue &N) { 06247 SDValue Chain = N.getOperand(0); 06248 if (Predicate_atomic_load_max_16(N.getNode())) { 06249 SDValue N1 = N.getOperand(1); 06250 SDValue CPTmpN1_0; 06251 SDValue CPTmpN1_1; 06252 SDValue CPTmpN1_2; 06253 SDValue CPTmpN1_3; 06254 SDValue CPTmpN1_4; 06255 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06256 SDNode *Result = Emit_75(N, X86::ATOMMAX16, MVT::i16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06257 return Result; 06258 } 06259 } 06260 06261 CannotYetSelect(N); 06262 return NULL; 06263 } 06264 06265 SDNode *Select_ISD_ATOMIC_LOAD_MAX_i32(const SDValue &N) { 06266 SDValue Chain = N.getOperand(0); 06267 if (Predicate_atomic_load_max_32(N.getNode())) { 06268 SDValue N1 = N.getOperand(1); 06269 SDValue CPTmpN1_0; 06270 SDValue CPTmpN1_1; 06271 SDValue CPTmpN1_2; 06272 SDValue CPTmpN1_3; 06273 SDValue CPTmpN1_4; 06274 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06275 SDNode *Result = Emit_75(N, X86::ATOMMAX32, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06276 return Result; 06277 } 06278 } 06279 06280 CannotYetSelect(N); 06281 return NULL; 06282 } 06283 06284 SDNode *Select_ISD_ATOMIC_LOAD_MAX_i64(const SDValue &N) { 06285 SDValue Chain = N.getOperand(0); 06286 if (Predicate_atomic_load_max_64(N.getNode())) { 06287 SDValue N1 = N.getOperand(1); 06288 SDValue CPTmpN1_0; 06289 SDValue CPTmpN1_1; 06290 SDValue CPTmpN1_2; 06291 SDValue CPTmpN1_3; 06292 SDValue CPTmpN1_4; 06293 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06294 SDNode *Result = Emit_75(N, X86::ATOMMAX64, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06295 return Result; 06296 } 06297 } 06298 06299 CannotYetSelect(N); 06300 return NULL; 06301 } 06302 06303 SDNode *Select_ISD_ATOMIC_LOAD_MIN_i16(const SDValue &N) { 06304 SDValue Chain = N.getOperand(0); 06305 if (Predicate_atomic_load_min_16(N.getNode())) { 06306 SDValue N1 = N.getOperand(1); 06307 SDValue CPTmpN1_0; 06308 SDValue CPTmpN1_1; 06309 SDValue CPTmpN1_2; 06310 SDValue CPTmpN1_3; 06311 SDValue CPTmpN1_4; 06312 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06313 SDNode *Result = Emit_75(N, X86::ATOMMIN16, MVT::i16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06314 return Result; 06315 } 06316 } 06317 06318 CannotYetSelect(N); 06319 return NULL; 06320 } 06321 06322 SDNode *Select_ISD_ATOMIC_LOAD_MIN_i32(const SDValue &N) { 06323 SDValue Chain = N.getOperand(0); 06324 if (Predicate_atomic_load_min_32(N.getNode())) { 06325 SDValue N1 = N.getOperand(1); 06326 SDValue CPTmpN1_0; 06327 SDValue CPTmpN1_1; 06328 SDValue CPTmpN1_2; 06329 SDValue CPTmpN1_3; 06330 SDValue CPTmpN1_4; 06331 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06332 SDNode *Result = Emit_75(N, X86::ATOMMIN32, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06333 return Result; 06334 } 06335 } 06336 06337 CannotYetSelect(N); 06338 return NULL; 06339 } 06340 06341 SDNode *Select_ISD_ATOMIC_LOAD_MIN_i64(const SDValue &N) { 06342 SDValue Chain = N.getOperand(0); 06343 if (Predicate_atomic_load_min_64(N.getNode())) { 06344 SDValue N1 = N.getOperand(1); 06345 SDValue CPTmpN1_0; 06346 SDValue CPTmpN1_1; 06347 SDValue CPTmpN1_2; 06348 SDValue CPTmpN1_3; 06349 SDValue CPTmpN1_4; 06350 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06351 SDNode *Result = Emit_75(N, X86::ATOMMIN64, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06352 return Result; 06353 } 06354 } 06355 06356 CannotYetSelect(N); 06357 return NULL; 06358 } 06359 06360 SDNode *Select_ISD_ATOMIC_LOAD_NAND_i8(const SDValue &N) { 06361 SDValue Chain = N.getOperand(0); 06362 if (Predicate_atomic_load_nand_8(N.getNode())) { 06363 SDValue N1 = N.getOperand(1); 06364 SDValue CPTmpN1_0; 06365 SDValue CPTmpN1_1; 06366 SDValue CPTmpN1_2; 06367 SDValue CPTmpN1_3; 06368 SDValue CPTmpN1_4; 06369 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06370 SDNode *Result = Emit_75(N, X86::ATOMNAND8, MVT::i8, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06371 return Result; 06372 } 06373 } 06374 06375 CannotYetSelect(N); 06376 return NULL; 06377 } 06378 06379 SDNode *Select_ISD_ATOMIC_LOAD_NAND_i16(const SDValue &N) { 06380 SDValue Chain = N.getOperand(0); 06381 if (Predicate_atomic_load_nand_16(N.getNode())) { 06382 SDValue N1 = N.getOperand(1); 06383 SDValue CPTmpN1_0; 06384 SDValue CPTmpN1_1; 06385 SDValue CPTmpN1_2; 06386 SDValue CPTmpN1_3; 06387 SDValue CPTmpN1_4; 06388 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06389 SDNode *Result = Emit_75(N, X86::ATOMNAND16, MVT::i16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06390 return Result; 06391 } 06392 } 06393 06394 CannotYetSelect(N); 06395 return NULL; 06396 } 06397 06398 SDNode *Select_ISD_ATOMIC_LOAD_NAND_i32(const SDValue &N) { 06399 SDValue Chain = N.getOperand(0); 06400 if (Predicate_atomic_load_nand_32(N.getNode())) { 06401 SDValue N1 = N.getOperand(1); 06402 SDValue CPTmpN1_0; 06403 SDValue CPTmpN1_1; 06404 SDValue CPTmpN1_2; 06405 SDValue CPTmpN1_3; 06406 SDValue CPTmpN1_4; 06407 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06408 SDNode *Result = Emit_75(N, X86::ATOMNAND32, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06409 return Result; 06410 } 06411 } 06412 06413 CannotYetSelect(N); 06414 return NULL; 06415 } 06416 06417 SDNode *Select_ISD_ATOMIC_LOAD_NAND_i64(const SDValue &N) { 06418 SDValue Chain = N.getOperand(0); 06419 if (Predicate_atomic_load_nand_64(N.getNode())) { 06420 SDValue N1 = N.getOperand(1); 06421 SDValue CPTmpN1_0; 06422 SDValue CPTmpN1_1; 06423 SDValue CPTmpN1_2; 06424 SDValue CPTmpN1_3; 06425 SDValue CPTmpN1_4; 06426 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06427 SDNode *Result = Emit_75(N, X86::ATOMNAND64, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06428 return Result; 06429 } 06430 } 06431 06432 CannotYetSelect(N); 06433 return NULL; 06434 } 06435 06436 SDNode *Select_ISD_ATOMIC_LOAD_OR_i8(const SDValue &N) { 06437 SDValue Chain = N.getOperand(0); 06438 if (Predicate_atomic_load_or_8(N.getNode())) { 06439 SDValue N1 = N.getOperand(1); 06440 SDValue CPTmpN1_0; 06441 SDValue CPTmpN1_1; 06442 SDValue CPTmpN1_2; 06443 SDValue CPTmpN1_3; 06444 SDValue CPTmpN1_4; 06445 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06446 SDNode *Result = Emit_75(N, X86::ATOMOR8, MVT::i8, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06447 return Result; 06448 } 06449 } 06450 06451 CannotYetSelect(N); 06452 return NULL; 06453 } 06454 06455 SDNode *Select_ISD_ATOMIC_LOAD_OR_i16(const SDValue &N) { 06456 SDValue Chain = N.getOperand(0); 06457 if (Predicate_atomic_load_or_16(N.getNode())) { 06458 SDValue N1 = N.getOperand(1); 06459 SDValue CPTmpN1_0; 06460 SDValue CPTmpN1_1; 06461 SDValue CPTmpN1_2; 06462 SDValue CPTmpN1_3; 06463 SDValue CPTmpN1_4; 06464 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06465 SDNode *Result = Emit_75(N, X86::ATOMOR16, MVT::i16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06466 return Result; 06467 } 06468 } 06469 06470 CannotYetSelect(N); 06471 return NULL; 06472 } 06473 06474 SDNode *Select_ISD_ATOMIC_LOAD_OR_i32(const SDValue &N) { 06475 SDValue Chain = N.getOperand(0); 06476 if (Predicate_atomic_load_or_32(N.getNode())) { 06477 SDValue N1 = N.getOperand(1); 06478 SDValue CPTmpN1_0; 06479 SDValue CPTmpN1_1; 06480 SDValue CPTmpN1_2; 06481 SDValue CPTmpN1_3; 06482 SDValue CPTmpN1_4; 06483 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06484 SDNode *Result = Emit_75(N, X86::ATOMOR32, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06485 return Result; 06486 } 06487 } 06488 06489 CannotYetSelect(N); 06490 return NULL; 06491 } 06492 06493 SDNode *Select_ISD_ATOMIC_LOAD_OR_i64(const SDValue &N) { 06494 SDValue Chain = N.getOperand(0); 06495 if (Predicate_atomic_load_or_64(N.getNode())) { 06496 SDValue N1 = N.getOperand(1); 06497 SDValue CPTmpN1_0; 06498 SDValue CPTmpN1_1; 06499 SDValue CPTmpN1_2; 06500 SDValue CPTmpN1_3; 06501 SDValue CPTmpN1_4; 06502 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06503 SDNode *Result = Emit_75(N, X86::ATOMOR64, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06504 return Result; 06505 } 06506 } 06507 06508 CannotYetSelect(N); 06509 return NULL; 06510 } 06511 06512 SDNode *Select_ISD_ATOMIC_LOAD_UMAX_i16(const SDValue &N) { 06513 SDValue Chain = N.getOperand(0); 06514 if (Predicate_atomic_load_umax_16(N.getNode())) { 06515 SDValue N1 = N.getOperand(1); 06516 SDValue CPTmpN1_0; 06517 SDValue CPTmpN1_1; 06518 SDValue CPTmpN1_2; 06519 SDValue CPTmpN1_3; 06520 SDValue CPTmpN1_4; 06521 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06522 SDNode *Result = Emit_75(N, X86::ATOMUMAX16, MVT::i16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06523 return Result; 06524 } 06525 } 06526 06527 CannotYetSelect(N); 06528 return NULL; 06529 } 06530 06531 SDNode *Select_ISD_ATOMIC_LOAD_UMAX_i32(const SDValue &N) { 06532 SDValue Chain = N.getOperand(0); 06533 if (Predicate_atomic_load_umax_32(N.getNode())) { 06534 SDValue N1 = N.getOperand(1); 06535 SDValue CPTmpN1_0; 06536 SDValue CPTmpN1_1; 06537 SDValue CPTmpN1_2; 06538 SDValue CPTmpN1_3; 06539 SDValue CPTmpN1_4; 06540 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06541 SDNode *Result = Emit_75(N, X86::ATOMUMAX32, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06542 return Result; 06543 } 06544 } 06545 06546 CannotYetSelect(N); 06547 return NULL; 06548 } 06549 06550 SDNode *Select_ISD_ATOMIC_LOAD_UMAX_i64(const SDValue &N) { 06551 SDValue Chain = N.getOperand(0); 06552 if (Predicate_atomic_load_umax_64(N.getNode())) { 06553 SDValue N1 = N.getOperand(1); 06554 SDValue CPTmpN1_0; 06555 SDValue CPTmpN1_1; 06556 SDValue CPTmpN1_2; 06557 SDValue CPTmpN1_3; 06558 SDValue CPTmpN1_4; 06559 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06560 SDNode *Result = Emit_75(N, X86::ATOMUMAX64, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06561 return Result; 06562 } 06563 } 06564 06565 CannotYetSelect(N); 06566 return NULL; 06567 } 06568 06569 SDNode *Select_ISD_ATOMIC_LOAD_UMIN_i16(const SDValue &N) { 06570 SDValue Chain = N.getOperand(0); 06571 if (Predicate_atomic_load_umin_16(N.getNode())) { 06572 SDValue N1 = N.getOperand(1); 06573 SDValue CPTmpN1_0; 06574 SDValue CPTmpN1_1; 06575 SDValue CPTmpN1_2; 06576 SDValue CPTmpN1_3; 06577 SDValue CPTmpN1_4; 06578 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06579 SDNode *Result = Emit_75(N, X86::ATOMUMIN16, MVT::i16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06580 return Result; 06581 } 06582 } 06583 06584 CannotYetSelect(N); 06585 return NULL; 06586 } 06587 06588 SDNode *Select_ISD_ATOMIC_LOAD_UMIN_i32(const SDValue &N) { 06589 SDValue Chain = N.getOperand(0); 06590 if (Predicate_atomic_load_umin_32(N.getNode())) { 06591 SDValue N1 = N.getOperand(1); 06592 SDValue CPTmpN1_0; 06593 SDValue CPTmpN1_1; 06594 SDValue CPTmpN1_2; 06595 SDValue CPTmpN1_3; 06596 SDValue CPTmpN1_4; 06597 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06598 SDNode *Result = Emit_75(N, X86::ATOMUMIN32, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06599 return Result; 06600 } 06601 } 06602 06603 CannotYetSelect(N); 06604 return NULL; 06605 } 06606 06607 SDNode *Select_ISD_ATOMIC_LOAD_UMIN_i64(const SDValue &N) { 06608 SDValue Chain = N.getOperand(0); 06609 if (Predicate_atomic_load_umin_64(N.getNode())) { 06610 SDValue N1 = N.getOperand(1); 06611 SDValue CPTmpN1_0; 06612 SDValue CPTmpN1_1; 06613 SDValue CPTmpN1_2; 06614 SDValue CPTmpN1_3; 06615 SDValue CPTmpN1_4; 06616 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06617 SDNode *Result = Emit_75(N, X86::ATOMUMIN64, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06618 return Result; 06619 } 06620 } 06621 06622 CannotYetSelect(N); 06623 return NULL; 06624 } 06625 06626 SDNode *Select_ISD_ATOMIC_LOAD_XOR_i8(const SDValue &N) { 06627 SDValue Chain = N.getOperand(0); 06628 if (Predicate_atomic_load_xor_8(N.getNode())) { 06629 SDValue N1 = N.getOperand(1); 06630 SDValue CPTmpN1_0; 06631 SDValue CPTmpN1_1; 06632 SDValue CPTmpN1_2; 06633 SDValue CPTmpN1_3; 06634 SDValue CPTmpN1_4; 06635 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06636 SDNode *Result = Emit_75(N, X86::ATOMXOR8, MVT::i8, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06637 return Result; 06638 } 06639 } 06640 06641 CannotYetSelect(N); 06642 return NULL; 06643 } 06644 06645 SDNode *Select_ISD_ATOMIC_LOAD_XOR_i16(const SDValue &N) { 06646 SDValue Chain = N.getOperand(0); 06647 if (Predicate_atomic_load_xor_16(N.getNode())) { 06648 SDValue N1 = N.getOperand(1); 06649 SDValue CPTmpN1_0; 06650 SDValue CPTmpN1_1; 06651 SDValue CPTmpN1_2; 06652 SDValue CPTmpN1_3; 06653 SDValue CPTmpN1_4; 06654 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06655 SDNode *Result = Emit_75(N, X86::ATOMXOR16, MVT::i16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06656 return Result; 06657 } 06658 } 06659 06660 CannotYetSelect(N); 06661 return NULL; 06662 } 06663 06664 SDNode *Select_ISD_ATOMIC_LOAD_XOR_i32(const SDValue &N) { 06665 SDValue Chain = N.getOperand(0); 06666 if (Predicate_atomic_load_xor_32(N.getNode())) { 06667 SDValue N1 = N.getOperand(1); 06668 SDValue CPTmpN1_0; 06669 SDValue CPTmpN1_1; 06670 SDValue CPTmpN1_2; 06671 SDValue CPTmpN1_3; 06672 SDValue CPTmpN1_4; 06673 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06674 SDNode *Result = Emit_75(N, X86::ATOMXOR32, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06675 return Result; 06676 } 06677 } 06678 06679 CannotYetSelect(N); 06680 return NULL; 06681 } 06682 06683 SDNode *Select_ISD_ATOMIC_LOAD_XOR_i64(const SDValue &N) { 06684 SDValue Chain = N.getOperand(0); 06685 if (Predicate_atomic_load_xor_64(N.getNode())) { 06686 SDValue N1 = N.getOperand(1); 06687 SDValue CPTmpN1_0; 06688 SDValue CPTmpN1_1; 06689 SDValue CPTmpN1_2; 06690 SDValue CPTmpN1_3; 06691 SDValue CPTmpN1_4; 06692 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06693 SDNode *Result = Emit_75(N, X86::ATOMXOR64, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06694 return Result; 06695 } 06696 } 06697 06698 CannotYetSelect(N); 06699 return NULL; 06700 } 06701 06702 SDNode *Select_ISD_ATOMIC_SWAP_i8(const SDValue &N) { 06703 SDValue Chain = N.getOperand(0); 06704 if (Predicate_atomic_swap_8(N.getNode())) { 06705 SDValue N1 = N.getOperand(1); 06706 SDValue CPTmpN1_0; 06707 SDValue CPTmpN1_1; 06708 SDValue CPTmpN1_2; 06709 SDValue CPTmpN1_3; 06710 SDValue CPTmpN1_4; 06711 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06712 SDNode *Result = Emit_75(N, X86::XCHG8rm, MVT::i8, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06713 return Result; 06714 } 06715 } 06716 06717 CannotYetSelect(N); 06718 return NULL; 06719 } 06720 06721 SDNode *Select_ISD_ATOMIC_SWAP_i16(const SDValue &N) { 06722 SDValue Chain = N.getOperand(0); 06723 if (Predicate_atomic_swap_16(N.getNode())) { 06724 SDValue N1 = N.getOperand(1); 06725 SDValue CPTmpN1_0; 06726 SDValue CPTmpN1_1; 06727 SDValue CPTmpN1_2; 06728 SDValue CPTmpN1_3; 06729 SDValue CPTmpN1_4; 06730 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06731 SDNode *Result = Emit_75(N, X86::XCHG16rm, MVT::i16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06732 return Result; 06733 } 06734 } 06735 06736 CannotYetSelect(N); 06737 return NULL; 06738 } 06739 06740 SDNode *Select_ISD_ATOMIC_SWAP_i32(const SDValue &N) { 06741 SDValue Chain = N.getOperand(0); 06742 if (Predicate_atomic_swap_32(N.getNode())) { 06743 SDValue N1 = N.getOperand(1); 06744 SDValue CPTmpN1_0; 06745 SDValue CPTmpN1_1; 06746 SDValue CPTmpN1_2; 06747 SDValue CPTmpN1_3; 06748 SDValue CPTmpN1_4; 06749 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06750 SDNode *Result = Emit_75(N, X86::XCHG32rm, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06751 return Result; 06752 } 06753 } 06754 06755 CannotYetSelect(N); 06756 return NULL; 06757 } 06758 06759 SDNode *Select_ISD_ATOMIC_SWAP_i64(const SDValue &N) { 06760 SDValue Chain = N.getOperand(0); 06761 if (Predicate_atomic_swap_64(N.getNode())) { 06762 SDValue N1 = N.getOperand(1); 06763 SDValue CPTmpN1_0; 06764 SDValue CPTmpN1_1; 06765 SDValue CPTmpN1_2; 06766 SDValue CPTmpN1_3; 06767 SDValue CPTmpN1_4; 06768 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 06769 SDNode *Result = Emit_75(N, X86::XCHG64rm, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 06770 return Result; 06771 } 06772 } 06773 06774 CannotYetSelect(N); 06775 return NULL; 06776 } 06777 06778 SDNode *Select_ISD_BIT_CONVERT_i32(const SDValue &N) { 06779 if ((Subtarget->hasSSE2())) { 06780 SDValue N0 = N.getOperand(0); 06781 if (N0.getNode()->getValueType(0) == MVT::f32) { 06782 SDNode *Result = Emit_71(N, X86::MOVSS2DIrr, MVT::i32); 06783 return Result; 06784 } 06785 } 06786 06787 CannotYetSelect(N); 06788 return NULL; 06789 } 06790 06791 SDNode *Select_ISD_BIT_CONVERT_i64(const SDValue &N) { 06792 06793 // Pattern: (bitconvert:i64 FR64:f64:$src) 06794 // Emits: (MOVSDto64rr:i64 FR64:f64:$src) 06795 // Pattern complexity = 3 cost = 1 size = 3 06796 if ((Subtarget->hasSSE2())) { 06797 SDValue N0 = N.getOperand(0); 06798 if (N0.getNode()->getValueType(0) == MVT::f64) { 06799 SDNode *Result = Emit_71(N, X86::MOVSDto64rr, MVT::i64); 06800 return Result; 06801 } 06802 } 06803 SDValue N0 = N.getOperand(0); 06804 06805 // Pattern: (bitconvert:i64 VR64:v1i64:$src) 06806 // Emits: (MMX_MOVD64from64rr:i64 VR64:v8i8:$src) 06807 // Pattern complexity = 3 cost = 1 size = 3 06808 if (N0.getNode()->getValueType(0) == MVT::v1i64) { 06809 SDNode *Result = Emit_71(N, X86::MMX_MOVD64from64rr, MVT::i64); 06810 return Result; 06811 } 06812 06813 // Pattern: (bitconvert:i64 VR64:v2i32:$src) 06814 // Emits: (MMX_MOVD64from64rr:i64 VR64:v8i8:$src) 06815 // Pattern complexity = 3 cost = 1 size = 3 06816 if (N0.getNode()->getValueType(0) == MVT::v2i32) { 06817 SDNode *Result = Emit_71(N, X86::MMX_MOVD64from64rr, MVT::i64); 06818 return Result; 06819 } 06820 06821 // Pattern: (bitconvert:i64 VR64:v2f32:$src) 06822 // Emits: (MMX_MOVD64from64rr:i64 VR64:v8i8:$src) 06823 // Pattern complexity = 3 cost = 1 size = 3 06824 if (N0.getNode()->getValueType(0) == MVT::v2f32) { 06825 SDNode *Result = Emit_71(N, X86::MMX_MOVD64from64rr, MVT::i64); 06826 return Result; 06827 } 06828 06829 // Pattern: (bitconvert:i64 VR64:v4i16:$src) 06830 // Emits: (MMX_MOVD64from64rr:i64 VR64:v8i8:$src) 06831 // Pattern complexity = 3 cost = 1 size = 3 06832 if (N0.getNode()->getValueType(0) == MVT::v4i16) { 06833 SDNode *Result = Emit_71(N, X86::MMX_MOVD64from64rr, MVT::i64); 06834 return Result; 06835 } 06836 06837 // Pattern: (bitconvert:i64 VR64:v8i8:$src) 06838 // Emits: (MMX_MOVD64from64rr:i64 VR64:v8i8:$src) 06839 // Pattern complexity = 3 cost = 1 size = 3 06840 if (N0.getNode()->getValueType(0) == MVT::v8i8) { 06841 SDNode *Result = Emit_71(N, X86::MMX_MOVD64from64rr, MVT::i64); 06842 return Result; 06843 } 06844 06845 CannotYetSelect(N); 06846 return NULL; 06847 } 06848 06849 SDNode *Emit_76(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 06850 SDValue N0 = N.getOperand(0); 06851 SDValue Chain0 = N0.getOperand(0); 06852 SDValue N01 = N0.getOperand(1); 06853 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 06854 SDValue Ops0[] = { CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, LSI_N0, Chain0 }; 06855 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 7); 06856 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 06857 return ResNode; 06858 } 06859 SDNode *Select_ISD_BIT_CONVERT_f32(const SDValue &N) { 06860 06861 // Pattern: (bitconvert:f32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>) 06862 // Emits: (MOVDI2SSrm:f32 addr:iPTR:$src) 06863 // Pattern complexity = 25 cost = 1 size = 3 06864 if (OptLevel != CodeGenOpt::None && 06865 (Subtarget->hasSSE2())) { 06866 SDValue N0 = N.getOperand(0); 06867 if (N0.getOpcode() == ISD::LOAD && 06868 N0.hasOneUse()) { 06869 SDValue Chain0 = N0.getOperand(0); 06870 if (Predicate_unindexedload(N0.getNode()) && 06871 Predicate_loadi32(N0.getNode())) { 06872 SDValue N01 = N0.getOperand(1); 06873 SDValue CPTmpN01_0; 06874 SDValue CPTmpN01_1; 06875 SDValue CPTmpN01_2; 06876 SDValue CPTmpN01_3; 06877 SDValue CPTmpN01_4; 06878 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4) && 06879 N0.getNode()->getValueType(0) == MVT::i32) { 06880 SDNode *Result = Emit_76(N, X86::MOVDI2SSrm, MVT::f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 06881 return Result; 06882 } 06883 } 06884 } 06885 } 06886 06887 // Pattern: (bitconvert:f32 GR32:i32:$src) 06888 // Emits: (MOVDI2SSrr:f32 GR32:i32:$src) 06889 // Pattern complexity = 3 cost = 1 size = 3 06890 if ((Subtarget->hasSSE2())) { 06891 SDValue N0 = N.getOperand(0); 06892 if (N0.getNode()->getValueType(0) == MVT::i32) { 06893 SDNode *Result = Emit_71(N, X86::MOVDI2SSrr, MVT::f32); 06894 return Result; 06895 } 06896 } 06897 06898 CannotYetSelect(N); 06899 return NULL; 06900 } 06901 06902 SDNode *Select_ISD_BIT_CONVERT_f64(const SDValue &N) { 06903 06904 // Pattern: (bitconvert:f64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>) 06905 // Emits: (MOV64toSDrm:f64 addr:iPTR:$src) 06906 // Pattern complexity = 25 cost = 1 size = 3 06907 if (OptLevel != CodeGenOpt::None && 06908 (Subtarget->hasSSE2())) { 06909 SDValue N0 = N.getOperand(0); 06910 if (N0.getOpcode() == ISD::LOAD && 06911 N0.hasOneUse()) { 06912 SDValue Chain0 = N0.getOperand(0); 06913 if (Predicate_unindexedload(N0.getNode()) && 06914 Predicate_load(N0.getNode()) && 06915 Predicate_loadi64(N0.getNode())) { 06916 SDValue N01 = N0.getOperand(1); 06917 SDValue CPTmpN01_0; 06918 SDValue CPTmpN01_1; 06919 SDValue CPTmpN01_2; 06920 SDValue CPTmpN01_3; 06921 SDValue CPTmpN01_4; 06922 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4) && 06923 N0.getNode()->getValueType(0) == MVT::i64) { 06924 SDNode *Result = Emit_76(N, X86::MOV64toSDrm, MVT::f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 06925 return Result; 06926 } 06927 } 06928 } 06929 } 06930 06931 // Pattern: (bitconvert:f64 GR64:i64:$src) 06932 // Emits: (MOV64toSDrr:f64 GR64:i64:$src) 06933 // Pattern complexity = 3 cost = 1 size = 3 06934 if ((Subtarget->hasSSE2())) { 06935 SDValue N0 = N.getOperand(0); 06936 if (N0.getNode()->getValueType(0) == MVT::i64) { 06937 SDNode *Result = Emit_71(N, X86::MOV64toSDrr, MVT::f64); 06938 return Result; 06939 } 06940 } 06941 SDValue N0 = N.getOperand(0); 06942 06943 // Pattern: (bitconvert:f64 VR64:v1i64:$src) 06944 // Emits: (MMX_MOVQ2FR64rr:f64 VR64:v8i8:$src) 06945 // Pattern complexity = 3 cost = 1 size = 3 06946 if (N0.getNode()->getValueType(0) == MVT::v1i64) { 06947 SDNode *Result = Emit_71(N, X86::MMX_MOVQ2FR64rr, MVT::f64); 06948 return Result; 06949 } 06950 06951 // Pattern: (bitconvert:f64 VR64:v2i32:$src) 06952 // Emits: (MMX_MOVQ2FR64rr:f64 VR64:v8i8:$src) 06953 // Pattern complexity = 3 cost = 1 size = 3 06954 if (N0.getNode()->getValueType(0) == MVT::v2i32) { 06955 SDNode *Result = Emit_71(N, X86::MMX_MOVQ2FR64rr, MVT::f64); 06956 return Result; 06957 } 06958 06959 // Pattern: (bitconvert:f64 VR64:v4i16:$src) 06960 // Emits: (MMX_MOVQ2FR64rr:f64 VR64:v8i8:$src) 06961 // Pattern complexity = 3 cost = 1 size = 3 06962 if (N0.getNode()->getValueType(0) == MVT::v4i16) { 06963 SDNode *Result = Emit_71(N, X86::MMX_MOVQ2FR64rr, MVT::f64); 06964 return Result; 06965 } 06966 06967 // Pattern: (bitconvert:f64 VR64:v8i8:$src) 06968 // Emits: (MMX_MOVQ2FR64rr:f64 VR64:v8i8:$src) 06969 // Pattern complexity = 3 cost = 1 size = 3 06970 if (N0.getNode()->getValueType(0) == MVT::v8i8) { 06971 SDNode *Result = Emit_71(N, X86::MMX_MOVQ2FR64rr, MVT::f64); 06972 return Result; 06973 } 06974 06975 CannotYetSelect(N); 06976 return NULL; 06977 } 06978 06979 SDNode *Emit_77(const SDValue &N) DISABLE_INLINE { 06980 SDValue N0 = N.getOperand(0); 06981 ReplaceUses(N, N0); 06982 return NULL; 06983 } 06984 SDNode *Emit_78(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 06985 SDValue N0 = N.getOperand(0); 06986 SDValue N00 = N0.getOperand(0); 06987 SDValue N01 = N0.getOperand(1); 06988 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N00); 06989 } 06990 SDNode *Select_ISD_BIT_CONVERT_v8i8(const SDValue &N) { 06991 SDValue N0 = N.getOperand(0); 06992 06993 // Pattern: (bitconvert:v8i8 (vector_extract:i64 VR128:v2i64:$src, 0:iPTR)) 06994 // Emits: (MMX_MOVDQ2Qrr:v8i8 VR128:v16i8:$src) 06995 // Pattern complexity = 11 cost = 1 size = 3 06996 if (N0.getOpcode() == ISD::EXTRACT_VECTOR_ELT) { 06997 SDValue N00 = N0.getOperand(0); 06998 SDValue N01 = N0.getOperand(1); 06999 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N01); 07000 if (Tmp0) { 07001 int64_t CN1 = Tmp0->getSExtValue(); 07002 if (CN1 == INT64_C(0) && 07003 N0.getNode()->getValueType(0) == MVT::i64 && 07004 N00.getNode()->getValueType(0) == MVT::v2i64) { 07005 SDNode *Result = Emit_78(N, X86::MMX_MOVDQ2Qrr, MVT::v8i8); 07006 return Result; 07007 } 07008 } 07009 } 07010 07011 // Pattern: (bitconvert:v8i8 VR64:v1i64:$src) 07012 // Emits: VR64:v8i8:$src 07013 // Pattern complexity = 3 cost = 0 size = 0 07014 if (N0.getNode()->getValueType(0) == MVT::v1i64) { 07015 SDNode *Result = Emit_77(N); 07016 return Result; 07017 } 07018 07019 // Pattern: (bitconvert:v8i8 VR64:v2i32:$src) 07020 // Emits: VR64:v8i8:$src 07021 // Pattern complexity = 3 cost = 0 size = 0 07022 if (N0.getNode()->getValueType(0) == MVT::v2i32) { 07023 SDNode *Result = Emit_77(N); 07024 return Result; 07025 } 07026 07027 // Pattern: (bitconvert:v8i8 VR64:v2f32:$src) 07028 // Emits: VR64:v8i8:$src 07029 // Pattern complexity = 3 cost = 0 size = 0 07030 if (N0.getNode()->getValueType(0) == MVT::v2f32) { 07031 SDNode *Result = Emit_77(N); 07032 return Result; 07033 } 07034 07035 // Pattern: (bitconvert:v8i8 VR64:v4i16:$src) 07036 // Emits: VR64:v8i8:$src 07037 // Pattern complexity = 3 cost = 0 size = 0 07038 if (N0.getNode()->getValueType(0) == MVT::v4i16) { 07039 SDNode *Result = Emit_77(N); 07040 return Result; 07041 } 07042 07043 // Pattern: (bitconvert:v8i8 GR64:i64:$src) 07044 // Emits: (MMX_MOVD64to64rr:v8i8 GR64:i64:$src) 07045 // Pattern complexity = 3 cost = 1 size = 3 07046 if (N0.getNode()->getValueType(0) == MVT::i64) { 07047 SDNode *Result = Emit_71(N, X86::MMX_MOVD64to64rr, MVT::v8i8); 07048 return Result; 07049 } 07050 07051 CannotYetSelect(N); 07052 return NULL; 07053 } 07054 07055 SDNode *Select_ISD_BIT_CONVERT_v16i8(const SDValue &N) { 07056 if ((Subtarget->hasSSE2())) { 07057 SDValue N0 = N.getOperand(0); 07058 07059 // Pattern: (bitconvert:v16i8 VR128:v2i64:$src) 07060 // Emits: VR128:v16i8:$src 07061 // Pattern complexity = 3 cost = 0 size = 0 07062 if (N0.getNode()->getValueType(0) == MVT::v2i64) { 07063 SDNode *Result = Emit_77(N); 07064 return Result; 07065 } 07066 07067 // Pattern: (bitconvert:v16i8 VR128:v4i32:$src) 07068 // Emits: VR128:v16i8:$src 07069 // Pattern complexity = 3 cost = 0 size = 0 07070 if (N0.getNode()->getValueType(0) == MVT::v4i32) { 07071 SDNode *Result = Emit_77(N); 07072 return Result; 07073 } 07074 07075 // Pattern: (bitconvert:v16i8 VR128:v8i16:$src) 07076 // Emits: VR128:v16i8:$src 07077 // Pattern complexity = 3 cost = 0 size = 0 07078 if (N0.getNode()->getValueType(0) == MVT::v8i16) { 07079 SDNode *Result = Emit_77(N); 07080 return Result; 07081 } 07082 07083 // Pattern: (bitconvert:v16i8 VR128:v2f64:$src) 07084 // Emits: VR128:v16i8:$src 07085 // Pattern complexity = 3 cost = 0 size = 0 07086 if (N0.getNode()->getValueType(0) == MVT::v2f64) { 07087 SDNode *Result = Emit_77(N); 07088 return Result; 07089 } 07090 07091 // Pattern: (bitconvert:v16i8 VR128:v4f32:$src) 07092 // Emits: VR128:v16i8:$src 07093 // Pattern complexity = 3 cost = 0 size = 0 07094 if (N0.getNode()->getValueType(0) == MVT::v4f32) { 07095 SDNode *Result = Emit_77(N); 07096 return Result; 07097 } 07098 } 07099 07100 CannotYetSelect(N); 07101 return NULL; 07102 } 07103 07104 SDNode *Select_ISD_BIT_CONVERT_v4i16(const SDValue &N) { 07105 SDValue N0 = N.getOperand(0); 07106 07107 // Pattern: (bitconvert:v4i16 (vector_extract:i64 VR128:v2i64:$src, 0:iPTR)) 07108 // Emits: (MMX_MOVDQ2Qrr:v4i16 VR128:v16i8:$src) 07109 // Pattern complexity = 11 cost = 1 size = 3 07110 if (N0.getOpcode() == ISD::EXTRACT_VECTOR_ELT) { 07111 SDValue N00 = N0.getOperand(0); 07112 SDValue N01 = N0.getOperand(1); 07113 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N01); 07114 if (Tmp0) { 07115 int64_t CN1 = Tmp0->getSExtValue(); 07116 if (CN1 == INT64_C(0) && 07117 N0.getNode()->getValueType(0) == MVT::i64 && 07118 N00.getNode()->getValueType(0) == MVT::v2i64) { 07119 SDNode *Result = Emit_78(N, X86::MMX_MOVDQ2Qrr, MVT::v4i16); 07120 return Result; 07121 } 07122 } 07123 } 07124 07125 // Pattern: (bitconvert:v4i16 VR64:v1i64:$src) 07126 // Emits: VR64:v4i16:$src 07127 // Pattern complexity = 3 cost = 0 size = 0 07128 if (N0.getNode()->getValueType(0) == MVT::v1i64) { 07129 SDNode *Result = Emit_77(N); 07130 return Result; 07131 } 07132 07133 // Pattern: (bitconvert:v4i16 VR64:v2i32:$src) 07134 // Emits: VR64:v4i16:$src 07135 // Pattern complexity = 3 cost = 0 size = 0 07136 if (N0.getNode()->getValueType(0) == MVT::v2i32) { 07137 SDNode *Result = Emit_77(N); 07138 return Result; 07139 } 07140 07141 // Pattern: (bitconvert:v4i16 VR64:v2f32:$src) 07142 // Emits: VR64:v4i16:$src 07143 // Pattern complexity = 3 cost = 0 size = 0 07144 if (N0.getNode()->getValueType(0) == MVT::v2f32) { 07145 SDNode *Result = Emit_77(N); 07146 return Result; 07147 } 07148 07149 // Pattern: (bitconvert:v4i16 VR64:v8i8:$src) 07150 // Emits: VR64:v4i16:$src 07151 // Pattern complexity = 3 cost = 0 size = 0 07152 if (N0.getNode()->getValueType(0) == MVT::v8i8) { 07153 SDNode *Result = Emit_77(N); 07154 return Result; 07155 } 07156 07157 // Pattern: (bitconvert:v4i16 GR64:i64:$src) 07158 // Emits: (MMX_MOVD64to64rr:v4i16 GR64:i64:$src) 07159 // Pattern complexity = 3 cost = 1 size = 3 07160 if (N0.getNode()->getValueType(0) == MVT::i64) { 07161 SDNode *Result = Emit_71(N, X86::MMX_MOVD64to64rr, MVT::v4i16); 07162 return Result; 07163 } 07164 07165 CannotYetSelect(N); 07166 return NULL; 07167 } 07168 07169 SDNode *Select_ISD_BIT_CONVERT_v8i16(const SDValue &N) { 07170 if ((Subtarget->hasSSE2())) { 07171 SDValue N0 = N.getOperand(0); 07172 07173 // Pattern: (bitconvert:v8i16 VR128:v2i64:$src) 07174 // Emits: VR128:v8i16:$src 07175 // Pattern complexity = 3 cost = 0 size = 0 07176 if (N0.getNode()->getValueType(0) == MVT::v2i64) { 07177 SDNode *Result = Emit_77(N); 07178 return Result; 07179 } 07180 07181 // Pattern: (bitconvert:v8i16 VR128:v4i32:$src) 07182 // Emits: VR128:v8i16:$src 07183 // Pattern complexity = 3 cost = 0 size = 0 07184 if (N0.getNode()->getValueType(0) == MVT::v4i32) { 07185 SDNode *Result = Emit_77(N); 07186 return Result; 07187 } 07188 07189 // Pattern: (bitconvert:v8i16 VR128:v16i8:$src) 07190 // Emits: VR128:v8i16:$src 07191 // Pattern complexity = 3 cost = 0 size = 0 07192 if (N0.getNode()->getValueType(0) == MVT::v16i8) { 07193 SDNode *Result = Emit_77(N); 07194 return Result; 07195 } 07196 07197 // Pattern: (bitconvert:v8i16 VR128:v2f64:$src) 07198 // Emits: VR128:v8i16:$src 07199 // Pattern complexity = 3 cost = 0 size = 0 07200 if (N0.getNode()->getValueType(0) == MVT::v2f64) { 07201 SDNode *Result = Emit_77(N); 07202 return Result; 07203 } 07204 07205 // Pattern: (bitconvert:v8i16 VR128:v4f32:$src) 07206 // Emits: VR128:v8i16:$src 07207 // Pattern complexity = 3 cost = 0 size = 0 07208 if (N0.getNode()->getValueType(0) == MVT::v4f32) { 07209 SDNode *Result = Emit_77(N); 07210 return Result; 07211 } 07212 } 07213 07214 CannotYetSelect(N); 07215 return NULL; 07216 } 07217 07218 SDNode *Emit_79(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN0101_0, SDValue &CPTmpN0101_1, SDValue &CPTmpN0101_2, SDValue &CPTmpN0101_3, SDValue &CPTmpN0101_4) DISABLE_INLINE { 07219 SDValue N0 = N.getOperand(0); 07220 SDValue N00 = N0.getOperand(0); 07221 SDValue N01 = N0.getOperand(1); 07222 SDValue N010 = N01.getOperand(0); 07223 SDValue Chain010 = N010.getOperand(0); 07224 SDValue N0101 = N010.getOperand(1); 07225 SDValue LSI_N010 = CurDAG->getMemOperand(cast<MemSDNode>(N010)->getMemOperand()); 07226 SDValue Ops0[] = { N0101, N0101, LSI_N010, Chain010 }; 07227 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 4); 07228 ReplaceUses(SDValue(N010.getNode(), 1), SDValue(ResNode, 1)); 07229 return ResNode; 07230 } 07231 SDNode *Select_ISD_BIT_CONVERT_v2i32(const SDValue &N) { 07232 07233 // Pattern: (bitconvert:v2i32 (vector_shuffle:v2i32 (build_vector:v2i32)<<P:Predicate_immAllZerosV>>, (scalar_to_vector:v2i32 (ld:v1i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>))<<P:Predicate_mmx_unpckl>>) 07234 // Emits: (MMX_PUNPCKLDQrm:v2i32 VR64:v8i8:$src, VR64:v8i8:$src) 07235 // Pattern complexity = 56 cost = 1 size = 3 07236 if (OptLevel != CodeGenOpt::None) { 07237 SDValue N0 = N.getOperand(0); 07238 if (N0.getOpcode() == ISD::VECTOR_SHUFFLE && 07239 N0.hasOneUse() && 07240 Predicate_mmx_unpckl(N0.getNode())) { 07241 SDValue N00 = N0.getOperand(0); 07242 if (N00.getOpcode() == ISD::BUILD_VECTOR && 07243 Predicate_immAllZerosV(N00.getNode())) { 07244 SDValue N01 = N0.getOperand(1); 07245 if (N01.getOpcode() == ISD::SCALAR_TO_VECTOR && 07246 N01.hasOneUse()) { 07247 SDValue N010 = N01.getOperand(0); 07248 if (N010.getOpcode() == ISD::LOAD && 07249 N010.hasOneUse() && 07250 IsLegalAndProfitableToFold(N010.getNode(), N01.getNode(), N.getNode())) { 07251 SDValue Chain010 = N010.getOperand(0); 07252 if (Predicate_unindexedload(N010.getNode()) && 07253 Predicate_load(N010.getNode())) { 07254 SDValue N0101 = N010.getOperand(1); 07255 SDValue CPTmpN0101_0; 07256 SDValue CPTmpN0101_1; 07257 SDValue CPTmpN0101_2; 07258 SDValue CPTmpN0101_3; 07259 SDValue CPTmpN0101_4; 07260 if (SelectAddr(N, N0101, CPTmpN0101_0, CPTmpN0101_1, CPTmpN0101_2, CPTmpN0101_3, CPTmpN0101_4) && 07261 N0.getNode()->getValueType(0) == MVT::v2i32 && 07262 N010.getNode()->getValueType(0) == MVT::v1i64) { 07263 SDNode *Result = Emit_79(N, X86::MMX_PUNPCKLDQrm, MVT::v2i32, CPTmpN0101_0, CPTmpN0101_1, CPTmpN0101_2, CPTmpN0101_3, CPTmpN0101_4); 07264 return Result; 07265 } 07266 } 07267 } 07268 } 07269 } 07270 } 07271 } 07272 SDValue N0 = N.getOperand(0); 07273 07274 // Pattern: (bitconvert:v2i32 (vector_extract:i64 VR128:v2i64:$src, 0:iPTR)) 07275 // Emits: (MMX_MOVDQ2Qrr:v2i32 VR128:v16i8:$src) 07276 // Pattern complexity = 11 cost = 1 size = 3 07277 if (N0.getOpcode() == ISD::EXTRACT_VECTOR_ELT) { 07278 SDValue N00 = N0.getOperand(0); 07279 SDValue N01 = N0.getOperand(1); 07280 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N01); 07281 if (Tmp0) { 07282 int64_t CN1 = Tmp0->getSExtValue(); 07283 if (CN1 == INT64_C(0) && 07284 N0.getNode()->getValueType(0) == MVT::i64 && 07285 N00.getNode()->getValueType(0) == MVT::v2i64) { 07286 SDNode *Result = Emit_78(N, X86::MMX_MOVDQ2Qrr, MVT::v2i32); 07287 return Result; 07288 } 07289 } 07290 } 07291 07292 // Pattern: (bitconvert:v2i32 VR64:v1i64:$src) 07293 // Emits: VR64:v2i32:$src 07294 // Pattern complexity = 3 cost = 0 size = 0 07295 if (N0.getNode()->getValueType(0) == MVT::v1i64) { 07296 SDNode *Result = Emit_77(N); 07297 return Result; 07298 } 07299 07300 // Pattern: (bitconvert:v2i32 VR64:v2f32:$src) 07301 // Emits: VR64:v2i32:$src 07302 // Pattern complexity = 3 cost = 0 size = 0 07303 if (N0.getNode()->getValueType(0) == MVT::v2f32) { 07304 SDNode *Result = Emit_77(N); 07305 return Result; 07306 } 07307 07308 // Pattern: (bitconvert:v2i32 VR64:v4i16:$src) 07309 // Emits: VR64:v2i32:$src 07310 // Pattern complexity = 3 cost = 0 size = 0 07311 if (N0.getNode()->getValueType(0) == MVT::v4i16) { 07312 SDNode *Result = Emit_77(N); 07313 return Result; 07314 } 07315 07316 // Pattern: (bitconvert:v2i32 VR64:v8i8:$src) 07317 // Emits: VR64:v2i32:$src 07318 // Pattern complexity = 3 cost = 0 size = 0 07319 if (N0.getNode()->getValueType(0) == MVT::v8i8) { 07320 SDNode *Result = Emit_77(N); 07321 return Result; 07322 } 07323 07324 // Pattern: (bitconvert:v2i32 GR64:i64:$src) 07325 // Emits: (MMX_MOVD64to64rr:v2i32 GR64:i64:$src) 07326 // Pattern complexity = 3 cost = 1 size = 3 07327 if (N0.getNode()->getValueType(0) == MVT::i64) { 07328 SDNode *Result = Emit_71(N, X86::MMX_MOVD64to64rr, MVT::v2i32); 07329 return Result; 07330 } 07331 07332 CannotYetSelect(N); 07333 return NULL; 07334 } 07335 07336 SDNode *Select_ISD_BIT_CONVERT_v4i32(const SDValue &N) { 07337 if ((Subtarget->hasSSE2())) { 07338 SDValue N0 = N.getOperand(0); 07339 07340 // Pattern: (bitconvert:v4i32 VR128:v2i64:$src) 07341 // Emits: VR128:v4i32:$src 07342 // Pattern complexity = 3 cost = 0 size = 0 07343 if (N0.getNode()->getValueType(0) == MVT::v2i64) { 07344 SDNode *Result = Emit_77(N); 07345 return Result; 07346 } 07347 07348 // Pattern: (bitconvert:v4i32 VR128:v8i16:$src) 07349 // Emits: VR128:v4i32:$src 07350 // Pattern complexity = 3 cost = 0 size = 0 07351 if (N0.getNode()->getValueType(0) == MVT::v8i16) { 07352 SDNode *Result = Emit_77(N); 07353 return Result; 07354 } 07355 07356 // Pattern: (bitconvert:v4i32 VR128:v16i8:$src) 07357 // Emits: VR128:v4i32:$src 07358 // Pattern complexity = 3 cost = 0 size = 0 07359 if (N0.getNode()->getValueType(0) == MVT::v16i8) { 07360 SDNode *Result = Emit_77(N); 07361 return Result; 07362 } 07363 07364 // Pattern: (bitconvert:v4i32 VR128:v2f64:$src) 07365 // Emits: VR128:v4i32:$src 07366 // Pattern complexity = 3 cost = 0 size = 0 07367 if (N0.getNode()->getValueType(0) == MVT::v2f64) { 07368 SDNode *Result = Emit_77(N); 07369 return Result; 07370 } 07371 07372 // Pattern: (bitconvert:v4i32 VR128:v4f32:$src) 07373 // Emits: VR128:v4i32:$src 07374 // Pattern complexity = 3 cost = 0 size = 0 07375 if (N0.getNode()->getValueType(0) == MVT::v4f32) { 07376 SDNode *Result = Emit_77(N); 07377 return Result; 07378 } 07379 } 07380 07381 CannotYetSelect(N); 07382 return NULL; 07383 } 07384 07385 SDNode *Select_ISD_BIT_CONVERT_v1i64(const SDValue &N) { 07386 07387 // Pattern: (bitconvert:v1i64 (vector_extract:i64 VR128:v2i64:$src, 0:iPTR)) 07388 // Emits: (MMX_MOVDQ2Qrr:v1i64 VR128:v2i64:$src) 07389 // Pattern complexity = 11 cost = 1 size = 3 07390 if ((Subtarget->hasSSE2())) { 07391 SDValue N0 = N.getOperand(0); 07392 if (N0.getOpcode() == ISD::EXTRACT_VECTOR_ELT) { 07393 SDValue N00 = N0.getOperand(0); 07394 SDValue N01 = N0.getOperand(1); 07395 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N01); 07396 if (Tmp0) { 07397 int64_t CN1 = Tmp0->getSExtValue(); 07398 if (CN1 == INT64_C(0) && 07399 N0.getNode()->getValueType(0) == MVT::i64 && 07400 N00.getNode()->getValueType(0) == MVT::v2i64) { 07401 SDNode *Result = Emit_78(N, X86::MMX_MOVDQ2Qrr, MVT::v1i64); 07402 return Result; 07403 } 07404 } 07405 } 07406 } 07407 SDValue N0 = N.getOperand(0); 07408 07409 // Pattern: (bitconvert:v1i64 VR64:v2i32:$src) 07410 // Emits: VR64:v1i64:$src 07411 // Pattern complexity = 3 cost = 0 size = 0 07412 if (N0.getNode()->getValueType(0) == MVT::v2i32) { 07413 SDNode *Result = Emit_77(N); 07414 return Result; 07415 } 07416 07417 // Pattern: (bitconvert:v1i64 VR64:v2f32:$src) 07418 // Emits: VR64:v1i64:$src 07419 // Pattern complexity = 3 cost = 0 size = 0 07420 if (N0.getNode()->getValueType(0) == MVT::v2f32) { 07421 SDNode *Result = Emit_77(N); 07422 return Result; 07423 } 07424 07425 // Pattern: (bitconvert:v1i64 VR64:v4i16:$src) 07426 // Emits: VR64:v1i64:$src 07427 // Pattern complexity = 3 cost = 0 size = 0 07428 if (N0.getNode()->getValueType(0) == MVT::v4i16) { 07429 SDNode *Result = Emit_77(N); 07430 return Result; 07431 } 07432 07433 // Pattern: (bitconvert:v1i64 VR64:v8i8:$src) 07434 // Emits: VR64:v1i64:$src 07435 // Pattern complexity = 3 cost = 0 size = 0 07436 if (N0.getNode()->getValueType(0) == MVT::v8i8) { 07437 SDNode *Result = Emit_77(N); 07438 return Result; 07439 } 07440 07441 // Pattern: (bitconvert:v1i64 GR64:i64:$src) 07442 // Emits: (MMX_MOVD64to64rr:v1i64 GR64:i64:$src) 07443 // Pattern complexity = 3 cost = 1 size = 3 07444 if (N0.getNode()->getValueType(0) == MVT::i64) { 07445 SDNode *Result = Emit_71(N, X86::MMX_MOVD64to64rr, MVT::v1i64); 07446 return Result; 07447 } 07448 07449 CannotYetSelect(N); 07450 return NULL; 07451 } 07452 07453 SDNode *Select_ISD_BIT_CONVERT_v2i64(const SDValue &N) { 07454 if ((Subtarget->hasSSE2())) { 07455 SDValue N0 = N.getOperand(0); 07456 07457 // Pattern: (bitconvert:v2i64 VR128:v4i32:$src) 07458 // Emits: VR128:v2i64:$src 07459 // Pattern complexity = 3 cost = 0 size = 0 07460 if (N0.getNode()->getValueType(0) == MVT::v4i32) { 07461 SDNode *Result = Emit_77(N); 07462 return Result; 07463 } 07464 07465 // Pattern: (bitconvert:v2i64 VR128:v8i16:$src) 07466 // Emits: VR128:v2i64:$src 07467 // Pattern complexity = 3 cost = 0 size = 0 07468 if (N0.getNode()->getValueType(0) == MVT::v8i16) { 07469 SDNode *Result = Emit_77(N); 07470 return Result; 07471 } 07472 07473 // Pattern: (bitconvert:v2i64 VR128:v16i8:$src) 07474 // Emits: VR128:v2i64:$src 07475 // Pattern complexity = 3 cost = 0 size = 0 07476 if (N0.getNode()->getValueType(0) == MVT::v16i8) { 07477 SDNode *Result = Emit_77(N); 07478 return Result; 07479 } 07480 07481 // Pattern: (bitconvert:v2i64 VR128:v2f64:$src) 07482 // Emits: VR128:v2i64:$src 07483 // Pattern complexity = 3 cost = 0 size = 0 07484 if (N0.getNode()->getValueType(0) == MVT::v2f64) { 07485 SDNode *Result = Emit_77(N); 07486 return Result; 07487 } 07488 07489 // Pattern: (bitconvert:v2i64 VR128:v4f32:$src) 07490 // Emits: VR128:v2i64:$src 07491 // Pattern complexity = 3 cost = 0 size = 0 07492 if (N0.getNode()->getValueType(0) == MVT::v4f32) { 07493 SDNode *Result = Emit_77(N); 07494 return Result; 07495 } 07496 } 07497 07498 CannotYetSelect(N); 07499 return NULL; 07500 } 07501 07502 SDNode *Select_ISD_BIT_CONVERT_v2f32(const SDValue &N) { 07503 SDValue N0 = N.getOperand(0); 07504 07505 // Pattern: (bitconvert:v2f32 VR64:v1i64:$src) 07506 // Emits: VR64:v2f32:$src 07507 // Pattern complexity = 3 cost = 0 size = 0 07508 if (N0.getNode()->getValueType(0) == MVT::v1i64) { 07509 SDNode *Result = Emit_77(N); 07510 return Result; 07511 } 07512 07513 // Pattern: (bitconvert:v2f32 VR64:v2i32:$src) 07514 // Emits: VR64:v2f32:$src 07515 // Pattern complexity = 3 cost = 0 size = 0 07516 if (N0.getNode()->getValueType(0) == MVT::v2i32) { 07517 SDNode *Result = Emit_77(N); 07518 return Result; 07519 } 07520 07521 // Pattern: (bitconvert:v2f32 VR64:v4i16:$src) 07522 // Emits: VR64:v2f32:$src 07523 // Pattern complexity = 3 cost = 0 size = 0 07524 if (N0.getNode()->getValueType(0) == MVT::v4i16) { 07525 SDNode *Result = Emit_77(N); 07526 return Result; 07527 } 07528 07529 // Pattern: (bitconvert:v2f32 VR64:v8i8:$src) 07530 // Emits: VR64:v2f32:$src 07531 // Pattern complexity = 3 cost = 0 size = 0 07532 if (N0.getNode()->getValueType(0) == MVT::v8i8) { 07533 SDNode *Result = Emit_77(N); 07534 return Result; 07535 } 07536 07537 // Pattern: (bitconvert:v2f32 GR64:i64:$src) 07538 // Emits: (MMX_MOVD64to64rr:v2f32 GR64:i64:$src) 07539 // Pattern complexity = 3 cost = 1 size = 3 07540 if (N0.getNode()->getValueType(0) == MVT::i64) { 07541 SDNode *Result = Emit_71(N, X86::MMX_MOVD64to64rr, MVT::v2f32); 07542 return Result; 07543 } 07544 07545 CannotYetSelect(N); 07546 return NULL; 07547 } 07548 07549 SDNode *Select_ISD_BIT_CONVERT_v4f32(const SDValue &N) { 07550 if ((Subtarget->hasSSE2())) { 07551 SDValue N0 = N.getOperand(0); 07552 07553 // Pattern: (bitconvert:v4f32 VR128:v2i64:$src) 07554 // Emits: VR128:v4f32:$src 07555 // Pattern complexity = 3 cost = 0 size = 0 07556 if (N0.getNode()->getValueType(0) == MVT::v2i64) { 07557 SDNode *Result = Emit_77(N); 07558 return Result; 07559 } 07560 07561 // Pattern: (bitconvert:v4f32 VR128:v4i32:$src) 07562 // Emits: VR128:v4f32:$src 07563 // Pattern complexity = 3 cost = 0 size = 0 07564 if (N0.getNode()->getValueType(0) == MVT::v4i32) { 07565 SDNode *Result = Emit_77(N); 07566 return Result; 07567 } 07568 07569 // Pattern: (bitconvert:v4f32 VR128:v8i16:$src) 07570 // Emits: VR128:v4f32:$src 07571 // Pattern complexity = 3 cost = 0 size = 0 07572 if (N0.getNode()->getValueType(0) == MVT::v8i16) { 07573 SDNode *Result = Emit_77(N); 07574 return Result; 07575 } 07576 07577 // Pattern: (bitconvert:v4f32 VR128:v16i8:$src) 07578 // Emits: VR128:v4f32:$src 07579 // Pattern complexity = 3 cost = 0 size = 0 07580 if (N0.getNode()->getValueType(0) == MVT::v16i8) { 07581 SDNode *Result = Emit_77(N); 07582 return Result; 07583 } 07584 07585 // Pattern: (bitconvert:v4f32 VR128:v2f64:$src) 07586 // Emits: VR128:v4f32:$src 07587 // Pattern complexity = 3 cost = 0 size = 0 07588 if (N0.getNode()->getValueType(0) == MVT::v2f64) { 07589 SDNode *Result = Emit_77(N); 07590 return Result; 07591 } 07592 } 07593 07594 CannotYetSelect(N); 07595 return NULL; 07596 } 07597 07598 SDNode *Select_ISD_BIT_CONVERT_v2f64(const SDValue &N) { 07599 if ((Subtarget->hasSSE2())) { 07600 SDValue N0 = N.getOperand(0); 07601 07602 // Pattern: (bitconvert:v2f64 VR128:v2i64:$src) 07603 // Emits: VR128:v2f64:$src 07604 // Pattern complexity = 3 cost = 0 size = 0 07605 if (N0.getNode()->getValueType(0) == MVT::v2i64) { 07606 SDNode *Result = Emit_77(N); 07607 return Result; 07608 } 07609 07610 // Pattern: (bitconvert:v2f64 VR128:v4i32:$src) 07611 // Emits: VR128:v2f64:$src 07612 // Pattern complexity = 3 cost = 0 size = 0 07613 if (N0.getNode()->getValueType(0) == MVT::v4i32) { 07614 SDNode *Result = Emit_77(N); 07615 return Result; 07616 } 07617 07618 // Pattern: (bitconvert:v2f64 VR128:v8i16:$src) 07619 // Emits: VR128:v2f64:$src 07620 // Pattern complexity = 3 cost = 0 size = 0 07621 if (N0.getNode()->getValueType(0) == MVT::v8i16) { 07622 SDNode *Result = Emit_77(N); 07623 return Result; 07624 } 07625 07626 // Pattern: (bitconvert:v2f64 VR128:v16i8:$src) 07627 // Emits: VR128:v2f64:$src 07628 // Pattern complexity = 3 cost = 0 size = 0 07629 if (N0.getNode()->getValueType(0) == MVT::v16i8) { 07630 SDNode *Result = Emit_77(N); 07631 return Result; 07632 } 07633 07634 // Pattern: (bitconvert:v2f64 VR128:v4f32:$src) 07635 // Emits: VR128:v2f64:$src 07636 // Pattern complexity = 3 cost = 0 size = 0 07637 if (N0.getNode()->getValueType(0) == MVT::v4f32) { 07638 SDNode *Result = Emit_77(N); 07639 return Result; 07640 } 07641 } 07642 07643 CannotYetSelect(N); 07644 return NULL; 07645 } 07646 07647 SDNode *Emit_80(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 07648 SDValue Chain = N.getOperand(0); 07649 SDValue N1 = N.getOperand(1); 07650 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, N1, Chain); 07651 } 07652 SDNode *Select_ISD_BR(const SDValue &N) { 07653 SDValue Chain = N.getOperand(0); 07654 SDValue N1 = N.getOperand(1); 07655 if (N1.getOpcode() == ISD::BasicBlock) { 07656 SDNode *Result = Emit_80(N, X86::JMP); 07657 return Result; 07658 } 07659 07660 CannotYetSelect(N); 07661 return NULL; 07662 } 07663 07664 SDNode *Emit_81(const SDValue &N, unsigned Opc0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 07665 SDValue Chain = N.getOperand(0); 07666 SDValue N1 = N.getOperand(1); 07667 SDValue Chain1 = N1.getOperand(0); 07668 SDValue N11 = N1.getOperand(1); 07669 SmallVector<SDValue, 8> InChains; 07670 if (Chain.getNode() != N1.getNode()) { 07671 InChains.push_back(Chain); 07672 } 07673 InChains.push_back(Chain1); 07674 Chain1 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 07675 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 07676 SDValue Ops0[] = { CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1 }; 07677 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 7); 07678 Chain1 = SDValue(ResNode, 0); 07679 const SDValue Froms[] = { 07680 SDValue(N1.getNode(), 1), 07681 SDValue(N.getNode(), 0) 07682 }; 07683 const SDValue Tos[] = { 07684 SDValue(ResNode, 0), 07685 SDValue(Chain1.getNode(), Chain1.getResNo()) 07686 }; 07687 ReplaceUses(Froms, Tos, 2); 07688 return ResNode; 07689 } 07690 SDNode *Select_ISD_BRIND(const SDValue &N) { 07691 SDValue Chain = N.getOperand(0); 07692 SDValue N1 = N.getOperand(1); 07693 if (N1.getOpcode() == ISD::LOAD && 07694 N1.hasOneUse() && 07695 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode()) && 07696 (Chain.getNode() == N1.getNode() || IsChainCompatible(Chain.getNode(), N1.getNode()))) { 07697 SDValue Chain1 = N1.getOperand(0); 07698 if (Predicate_unindexedload(N1.getNode())) { 07699 07700 // Pattern: (brind:isVoid (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>) 07701 // Emits: (JMP32m:isVoid addr:iPTR:$dst) 07702 // Pattern complexity = 25 cost = 1 size = 3 07703 if (Predicate_loadi32(N1.getNode())) { 07704 SDValue N11 = N1.getOperand(1); 07705 SDValue CPTmpN11_0; 07706 SDValue CPTmpN11_1; 07707 SDValue CPTmpN11_2; 07708 SDValue CPTmpN11_3; 07709 SDValue CPTmpN11_4; 07710 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 07711 N1.getNode()->getValueType(0) == MVT::i32) { 07712 SDNode *Result = Emit_81(N, X86::JMP32m, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 07713 return Result; 07714 } 07715 } 07716 07717 // Pattern: (brind:isVoid (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>) 07718 // Emits: (JMP64m:isVoid addr:iPTR:$dst) 07719 // Pattern complexity = 25 cost = 1 size = 3 07720 if (Predicate_load(N1.getNode()) && 07721 Predicate_loadi64(N1.getNode())) { 07722 SDValue N11 = N1.getOperand(1); 07723 SDValue CPTmpN11_0; 07724 SDValue CPTmpN11_1; 07725 SDValue CPTmpN11_2; 07726 SDValue CPTmpN11_3; 07727 SDValue CPTmpN11_4; 07728 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 07729 N1.getNode()->getValueType(0) == MVT::i64) { 07730 SDNode *Result = Emit_81(N, X86::JMP64m, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 07731 return Result; 07732 } 07733 } 07734 } 07735 } 07736 07737 // Pattern: (brind:isVoid GR32:i32:$dst) 07738 // Emits: (JMP32r:isVoid GR32:i32:$dst) 07739 // Pattern complexity = 3 cost = 1 size = 3 07740 if (N1.getNode()->getValueType(0) == MVT::i32) { 07741 SDNode *Result = Emit_80(N, X86::JMP32r); 07742 return Result; 07743 } 07744 07745 // Pattern: (brind:isVoid GR64:i64:$dst) 07746 // Emits: (JMP64r:isVoid GR64:i64:$dst) 07747 // Pattern complexity = 3 cost = 1 size = 3 07748 if (N1.getNode()->getValueType(0) == MVT::i64) { 07749 SDNode *Result = Emit_80(N, X86::JMP64r); 07750 return Result; 07751 } 07752 07753 CannotYetSelect(N); 07754 return NULL; 07755 } 07756 07757 SDNode *Select_ISD_BSWAP_i32(const SDValue &N) { 07758 SDNode *Result = Emit_71(N, X86::BSWAP32r, MVT::i32); 07759 return Result; 07760 } 07761 07762 SDNode *Select_ISD_BSWAP_i64(const SDValue &N) { 07763 SDNode *Result = Emit_71(N, X86::BSWAP64r, MVT::i64); 07764 return Result; 07765 } 07766 07767 SDNode *Emit_82(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 07768 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0); 07769 } 07770 SDNode *Select_ISD_BUILD_VECTOR_v8i8(const SDValue &N) { 07771 if ((Subtarget->hasMMX()) && 07772 Predicate_immAllZerosV(N.getNode())) { 07773 SDNode *Result = Emit_82(N, X86::MMX_V_SET0, MVT::v8i8); 07774 return Result; 07775 } 07776 07777 CannotYetSelect(N); 07778 return NULL; 07779 } 07780 07781 SDNode *Select_ISD_BUILD_VECTOR_v16i8(const SDValue &N) { 07782 if ((Subtarget->hasSSE1()) && 07783 Predicate_immAllZerosV(N.getNode())) { 07784 SDNode *Result = Emit_82(N, X86::V_SET0, MVT::v16i8); 07785 return Result; 07786 } 07787 07788 CannotYetSelect(N); 07789 return NULL; 07790 } 07791 07792 SDNode *Select_ISD_BUILD_VECTOR_v4i16(const SDValue &N) { 07793 if ((Subtarget->hasMMX()) && 07794 Predicate_immAllZerosV(N.getNode())) { 07795 SDNode *Result = Emit_82(N, X86::MMX_V_SET0, MVT::v4i16); 07796 return Result; 07797 } 07798 07799 CannotYetSelect(N); 07800 return NULL; 07801 } 07802 07803 SDNode *Select_ISD_BUILD_VECTOR_v8i16(const SDValue &N) { 07804 if ((Subtarget->hasSSE1()) && 07805 Predicate_immAllZerosV(N.getNode())) { 07806 SDNode *Result = Emit_82(N, X86::V_SET0, MVT::v8i16); 07807 return Result; 07808 } 07809 07810 CannotYetSelect(N); 07811 return NULL; 07812 } 07813 07814 SDNode *Select_ISD_BUILD_VECTOR_v2i32(const SDValue &N) { 07815 if ((Subtarget->hasMMX())) { 07816 07817 // Pattern: (build_vector:v2i32)<<P:Predicate_immAllZerosV>> 07818 // Emits: (MMX_V_SET0:v2i32) 07819 // Pattern complexity = 4 cost = 1 size = 3 07820 if (Predicate_immAllZerosV(N.getNode())) { 07821 SDNode *Result = Emit_82(N, X86::MMX_V_SET0, MVT::v2i32); 07822 return Result; 07823 } 07824 07825 // Pattern: (build_vector:v2i32)<<P:Predicate_immAllOnesV>> 07826 // Emits: (MMX_V_SETALLONES:v2i32) 07827 // Pattern complexity = 4 cost = 1 size = 3 07828 if (Predicate_immAllOnesV(N.getNode())) { 07829 SDNode *Result = Emit_82(N, X86::MMX_V_SETALLONES, MVT::v2i32); 07830 return Result; 07831 } 07832 } 07833 07834 CannotYetSelect(N); 07835 return NULL; 07836 } 07837 07838 SDNode *Select_ISD_BUILD_VECTOR_v4i32(const SDValue &N) { 07839 07840 // Pattern: (build_vector:v4i32)<<P:Predicate_immAllZerosV>> 07841 // Emits: (V_SET0:v4i32) 07842 // Pattern complexity = 4 cost = 1 size = 3 07843 if ((Subtarget->hasSSE1()) && 07844 Predicate_immAllZerosV(N.getNode())) { 07845 SDNode *Result = Emit_82(N, X86::V_SET0, MVT::v4i32); 07846 return Result; 07847 } 07848 07849 // Pattern: (build_vector:v4i32)<<P:Predicate_immAllOnesV>> 07850 // Emits: (V_SETALLONES:v4i32) 07851 // Pattern complexity = 4 cost = 1 size = 3 07852 if ((Subtarget->hasSSE2()) && 07853 Predicate_immAllOnesV(N.getNode())) { 07854 SDNode *Result = Emit_82(N, X86::V_SETALLONES, MVT::v4i32); 07855 return Result; 07856 } 07857 07858 CannotYetSelect(N); 07859 return NULL; 07860 } 07861 07862 SDNode *Select_ISD_BUILD_VECTOR_v1i64(const SDValue &N) { 07863 if ((Subtarget->hasMMX()) && 07864 Predicate_immAllZerosV(N.getNode())) { 07865 SDNode *Result = Emit_82(N, X86::MMX_V_SET0, MVT::v1i64); 07866 return Result; 07867 } 07868 07869 CannotYetSelect(N); 07870 return NULL; 07871 } 07872 07873 SDNode *Select_ISD_BUILD_VECTOR_v2i64(const SDValue &N) { 07874 if ((Subtarget->hasSSE1()) && 07875 Predicate_immAllZerosV(N.getNode())) { 07876 SDNode *Result = Emit_82(N, X86::V_SET0, MVT::v2i64); 07877 return Result; 07878 } 07879 07880 CannotYetSelect(N); 07881 return NULL; 07882 } 07883 07884 SDNode *Select_ISD_BUILD_VECTOR_v4f32(const SDValue &N) { 07885 if ((Subtarget->hasSSE1()) && 07886 Predicate_immAllZerosV(N.getNode())) { 07887 SDNode *Result = Emit_82(N, X86::V_SET0, MVT::v4f32); 07888 return Result; 07889 } 07890 07891 CannotYetSelect(N); 07892 return NULL; 07893 } 07894 07895 SDNode *Select_ISD_BUILD_VECTOR_v2f64(const SDValue &N) { 07896 if ((Subtarget->hasSSE1()) && 07897 Predicate_immAllZerosV(N.getNode())) { 07898 SDNode *Result = Emit_82(N, X86::V_SET0, MVT::v2f64); 07899 return Result; 07900 } 07901 07902 CannotYetSelect(N); 07903 return NULL; 07904 } 07905 07906 SDNode *Emit_83(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 07907 SDValue Chain = N.getOperand(0); 07908 SDValue N1 = N.getOperand(1); 07909 SDValue N2 = N.getOperand(2); 07910 bool HasInFlag = (N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag); 07911 SDValue InFlag(0, 0); 07912 if (HasInFlag) { 07913 InFlag = N.getOperand(N.getNumOperands()-1); 07914 } 07915 SDValue Ops0[] = { N1, N2, Chain, InFlag }; 07916 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, MVT::Flag, Ops0, HasInFlag ? 4 : 3); 07917 Chain = SDValue(ResNode, 0); 07918 InFlag = SDValue(ResNode, 1); 07919 const SDValue Froms[] = { 07920 SDValue(N.getNode(), 1), 07921 SDValue(N.getNode(), 0) 07922 }; 07923 const SDValue Tos[] = { 07924 InFlag, 07925 SDValue(Chain.getNode(), Chain.getResNo()) 07926 }; 07927 ReplaceUses(Froms, Tos, 2); 07928 return ResNode; 07929 } 07930 SDNode *Select_ISD_CALLSEQ_END(const SDValue &N) { 07931 07932 // Pattern: (X86callseq_end:isVoid (timm:i32):$amt1, (timm:i32):$amt2) 07933 // Emits: (ADJCALLSTACKUP32:isVoid (timm:i32):$amt1, (timm:i32):$amt2) 07934 // Pattern complexity = 9 cost = 1 size = 3 07935 if ((!Subtarget->is64Bit())) { 07936 SDValue Chain = N.getOperand(0); 07937 SDValue N1 = N.getOperand(1); 07938 if (N1.getOpcode() == ISD::TargetConstant) { 07939 SDValue N2 = N.getOperand(2); 07940 if (N2.getOpcode() == ISD::TargetConstant) { 07941 SDNode *Result = Emit_83(N, X86::ADJCALLSTACKUP32); 07942 return Result; 07943 } 07944 } 07945 } 07946 07947 // Pattern: (X86callseq_end:isVoid (timm:i32):$amt1, (timm:i32):$amt2) 07948 // Emits: (ADJCALLSTACKUP64:isVoid (timm:i32):$amt1, (timm:i32):$amt2) 07949 // Pattern complexity = 9 cost = 1 size = 3 07950 if ((Subtarget->is64Bit())) { 07951 SDValue Chain = N.getOperand(0); 07952 SDValue N1 = N.getOperand(1); 07953 if (N1.getOpcode() == ISD::TargetConstant) { 07954 SDValue N2 = N.getOperand(2); 07955 if (N2.getOpcode() == ISD::TargetConstant) { 07956 SDNode *Result = Emit_83(N, X86::ADJCALLSTACKUP64); 07957 return Result; 07958 } 07959 } 07960 } 07961 07962 CannotYetSelect(N); 07963 return NULL; 07964 } 07965 07966 SDNode *Emit_84(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 07967 SDValue Chain = N.getOperand(0); 07968 SDValue N1 = N.getOperand(1); 07969 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, MVT::Flag, N1, Chain); 07970 Chain = SDValue(ResNode, 0); 07971 SDValue InFlag(ResNode, 1); 07972 const SDValue Froms[] = { 07973 SDValue(N.getNode(), 1), 07974 SDValue(N.getNode(), 0) 07975 }; 07976 const SDValue Tos[] = { 07977 InFlag, 07978 SDValue(Chain.getNode(), Chain.getResNo()) 07979 }; 07980 ReplaceUses(Froms, Tos, 2); 07981 return ResNode; 07982 } 07983 SDNode *Select_ISD_CALLSEQ_START(const SDValue &N) { 07984 07985 // Pattern: (X86callseq_start:isVoid (timm:i32):$amt) 07986 // Emits: (ADJCALLSTACKDOWN32:isVoid (timm:i32):$amt) 07987 // Pattern complexity = 6 cost = 1 size = 3 07988 if ((!Subtarget->is64Bit())) { 07989 SDValue Chain = N.getOperand(0); 07990 SDValue N1 = N.getOperand(1); 07991 if (N1.getOpcode() == ISD::TargetConstant) { 07992 SDNode *Result = Emit_84(N, X86::ADJCALLSTACKDOWN32); 07993 return Result; 07994 } 07995 } 07996 07997 // Pattern: (X86callseq_start:isVoid (timm:i32):$amt) 07998 // Emits: (ADJCALLSTACKDOWN64:isVoid (timm:i32):$amt) 07999 // Pattern complexity = 6 cost = 1 size = 3 08000 if ((Subtarget->is64Bit())) { 08001 SDValue Chain = N.getOperand(0); 08002 SDValue N1 = N.getOperand(1); 08003 if (N1.getOpcode() == ISD::TargetConstant) { 08004 SDNode *Result = Emit_84(N, X86::ADJCALLSTACKDOWN64); 08005 return Result; 08006 } 08007 } 08008 08009 CannotYetSelect(N); 08010 return NULL; 08011 } 08012 08013 SDNode *Emit_85(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 08014 SDValue Tmp0 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N)->getZExtValue()), MVT::i8); 08015 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, Tmp0); 08016 } 08017 SDNode *Select_ISD_Constant_i8(const SDValue &N) { 08018 08019 // Pattern: 0:i8 08020 // Emits: (MOV8r0:i8) 08021 // Pattern complexity = 5 cost = 1 size = 3 08022 if (cast<ConstantSDNode>(N)->getSExtValue() == INT64_C(0)) { 08023 SDNode *Result = Emit_82(N, X86::MOV8r0, MVT::i8); 08024 return Result; 08025 } 08026 08027 // Pattern: (imm:i8):$src 08028 // Emits: (MOV8ri:i8 (imm:i8):$src) 08029 // Pattern complexity = 3 cost = 1 size = 3 08030 SDNode *Result = Emit_85(N, X86::MOV8ri, MVT::i8); 08031 return Result; 08032 } 08033 08034 SDNode *Emit_86(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 08035 SDValue Tmp0 = CurDAG->getTargetConstant(((unsigned short) cast<ConstantSDNode>(N)->getZExtValue()), MVT::i16); 08036 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, Tmp0); 08037 } 08038 SDNode *Select_ISD_Constant_i16(const SDValue &N) { 08039 08040 // Pattern: 0:i16 08041 // Emits: (MOV16r0:i16) 08042 // Pattern complexity = 5 cost = 1 size = 3 08043 if (cast<ConstantSDNode>(N)->getSExtValue() == INT64_C(0)) { 08044 SDNode *Result = Emit_82(N, X86::MOV16r0, MVT::i16); 08045 return Result; 08046 } 08047 08048 // Pattern: (imm:i16):$src 08049 // Emits: (MOV16ri:i16 (imm:i16):$src) 08050 // Pattern complexity = 3 cost = 1 size = 3 08051 SDNode *Result = Emit_86(N, X86::MOV16ri, MVT::i16); 08052 return Result; 08053 } 08054 08055 SDNode *Emit_87(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 08056 SDValue Tmp0 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N)->getZExtValue()), MVT::i32); 08057 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, Tmp0); 08058 } 08059 SDNode *Select_ISD_Constant_i32(const SDValue &N) { 08060 08061 // Pattern: 0:i32 08062 // Emits: (MOV32r0:i32) 08063 // Pattern complexity = 5 cost = 1 size = 3 08064 if (cast<ConstantSDNode>(N)->getSExtValue() == INT64_C(0)) { 08065 SDNode *Result = Emit_82(N, X86::MOV32r0, MVT::i32); 08066 return Result; 08067 } 08068 08069 // Pattern: (imm:i32):$src 08070 // Emits: (MOV32ri:i32 (imm:i32):$src) 08071 // Pattern complexity = 3 cost = 1 size = 3 08072 SDNode *Result = Emit_87(N, X86::MOV32ri, MVT::i32); 08073 return Result; 08074 } 08075 08076 SDNode *Emit_88(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 08077 SDValue Tmp0 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N)->getZExtValue()), MVT::i64); 08078 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, Tmp0); 08079 } 08080 SDNode *Emit_89(const SDValue &N, unsigned Opc0, unsigned Opc1, EVT VT0, EVT VT1) DISABLE_INLINE { 08081 SDValue Tmp0 = CurDAG->getTargetConstant(0x0ULL, MVT::i64); 08082 SDValue Tmp1(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0), 0); 08083 SDValue Tmp2 = CurDAG->getTargetConstant(0x4ULL, MVT::i32); 08084 return CurDAG->SelectNodeTo(N.getNode(), Opc1, VT1, Tmp0, Tmp1, Tmp2); 08085 } 08086 SDNode *Select_ISD_Constant_i64(const SDValue &N) { 08087 08088 // Pattern: 0:i64 08089 // Emits: (SUBREG_TO_REG:i64 0:i64, (MOV32r0:i32), 4:i32) 08090 // Pattern complexity = 6 cost = 2 size = 3 08091 if (cast<ConstantSDNode>(N)->getSExtValue() == INT64_C(0)) { 08092 SDNode *Result = Emit_89(N, X86::MOV32r0, TargetInstrInfo::SUBREG_TO_REG, MVT::i32, MVT::i64); 08093 return Result; 08094 } 08095 08096 // Pattern: (imm:i64)<<P:Predicate_i64immZExt32>>:$src 08097 // Emits: (MOV64ri64i32:i64 (imm:i64):$src) 08098 // Pattern complexity = 5 cost = 1 size = 3 08099 if (Predicate_i64immZExt32(N.getNode())) { 08100 SDNode *Result = Emit_88(N, X86::MOV64ri64i32, MVT::i64); 08101 return Result; 08102 } 08103 08104 // Pattern: (imm:i64)<<P:Predicate_i64immSExt32>>:$src 08105 // Emits: (MOV64ri32:i64 (imm:i64):$src) 08106 // Pattern complexity = 4 cost = 1 size = 3 08107 if (Predicate_i64immSExt32(N.getNode())) { 08108 SDNode *Result = Emit_88(N, X86::MOV64ri32, MVT::i64); 08109 return Result; 08110 } 08111 08112 // Pattern: (imm:i64):$src 08113 // Emits: (MOV64ri:i64 (imm:i64):$src) 08114 // Pattern complexity = 3 cost = 1 size = 3 08115 SDNode *Result = Emit_88(N, X86::MOV64ri, MVT::i64); 08116 return Result; 08117 } 08118 08119 SDNode *Emit_90(const SDValue &N, unsigned Opc0, unsigned Opc1, EVT VT0, EVT VT1) DISABLE_INLINE { 08120 SDValue Tmp0(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0), 0); 08121 return CurDAG->SelectNodeTo(N.getNode(), Opc1, VT1, Tmp0); 08122 } 08123 SDNode *Select_ISD_ConstantFP_f32(const SDValue &N) { 08124 if ((!Subtarget->hasSSE1())) { 08125 08126 // Pattern: (fpimm:f32)<<P:Predicate_fpimm0>> 08127 // Emits: (LD_Fp032:f32) 08128 // Pattern complexity = 4 cost = 1 size = 0 08129 if (Predicate_fpimm0(N.getNode())) { 08130 SDNode *Result = Emit_82(N, X86::LD_Fp032, MVT::f32); 08131 return Result; 08132 } 08133 08134 // Pattern: (fpimm:f32)<<P:Predicate_fpimm1>> 08135 // Emits: (LD_Fp132:f32) 08136 // Pattern complexity = 4 cost = 1 size = 0 08137 if (Predicate_fpimm1(N.getNode())) { 08138 SDNode *Result = Emit_82(N, X86::LD_Fp132, MVT::f32); 08139 return Result; 08140 } 08141 } 08142 08143 // Pattern: (fpimm:f32)<<P:Predicate_fp32imm0>> 08144 // Emits: (FsFLD0SS:f32) 08145 // Pattern complexity = 4 cost = 1 size = 3 08146 if ((Subtarget->hasSSE1()) && 08147 Predicate_fp32imm0(N.getNode())) { 08148 SDNode *Result = Emit_82(N, X86::FsFLD0SS, MVT::f32); 08149 return Result; 08150 } 08151 if ((!Subtarget->hasSSE1())) { 08152 08153 // Pattern: (fpimm:f32)<<P:Predicate_fpimmneg0>> 08154 // Emits: (CHS_Fp32:f32 (LD_Fp032:f32)) 08155 // Pattern complexity = 4 cost = 2 size = 0 08156 if (Predicate_fpimmneg0(N.getNode())) { 08157 SDNode *Result = Emit_90(N, X86::LD_Fp032, X86::CHS_Fp32, MVT::f32, MVT::f32); 08158 return Result; 08159 } 08160 08161 // Pattern: (fpimm:f32)<<P:Predicate_fpimmneg1>> 08162 // Emits: (CHS_Fp32:f32 (LD_Fp132:f32)) 08163 // Pattern complexity = 4 cost = 2 size = 0 08164 if (Predicate_fpimmneg1(N.getNode())) { 08165 SDNode *Result = Emit_90(N, X86::LD_Fp132, X86::CHS_Fp32, MVT::f32, MVT::f32); 08166 return Result; 08167 } 08168 } 08169 08170 CannotYetSelect(N); 08171 return NULL; 08172 } 08173 08174 SDNode *Select_ISD_ConstantFP_f64(const SDValue &N) { 08175 if ((!Subtarget->hasSSE2())) { 08176 08177 // Pattern: (fpimm:f64)<<P:Predicate_fpimm0>> 08178 // Emits: (LD_Fp064:f64) 08179 // Pattern complexity = 4 cost = 1 size = 0 08180 if (Predicate_fpimm0(N.getNode())) { 08181 SDNode *Result = Emit_82(N, X86::LD_Fp064, MVT::f64); 08182 return Result; 08183 } 08184 08185 // Pattern: (fpimm:f64)<<P:Predicate_fpimm1>> 08186 // Emits: (LD_Fp164:f64) 08187 // Pattern complexity = 4 cost = 1 size = 0 08188 if (Predicate_fpimm1(N.getNode())) { 08189 SDNode *Result = Emit_82(N, X86::LD_Fp164, MVT::f64); 08190 return Result; 08191 } 08192 } 08193 08194 // Pattern: (fpimm:f64)<<P:Predicate_fpimm0>> 08195 // Emits: (FsFLD0SD:f64) 08196 // Pattern complexity = 4 cost = 1 size = 3 08197 if ((Subtarget->hasSSE2()) && 08198 Predicate_fpimm0(N.getNode())) { 08199 SDNode *Result = Emit_82(N, X86::FsFLD0SD, MVT::f64); 08200 return Result; 08201 } 08202 if ((!Subtarget->hasSSE2())) { 08203 08204 // Pattern: (fpimm:f64)<<P:Predicate_fpimmneg0>> 08205 // Emits: (CHS_Fp64:f64 (LD_Fp064:f64)) 08206 // Pattern complexity = 4 cost = 2 size = 0 08207 if (Predicate_fpimmneg0(N.getNode())) { 08208 SDNode *Result = Emit_90(N, X86::LD_Fp064, X86::CHS_Fp64, MVT::f64, MVT::f64); 08209 return Result; 08210 } 08211 08212 // Pattern: (fpimm:f64)<<P:Predicate_fpimmneg1>> 08213 // Emits: (CHS_Fp64:f64 (LD_Fp164:f64)) 08214 // Pattern complexity = 4 cost = 2 size = 0 08215 if (Predicate_fpimmneg1(N.getNode())) { 08216 SDNode *Result = Emit_90(N, X86::LD_Fp164, X86::CHS_Fp64, MVT::f64, MVT::f64); 08217 return Result; 08218 } 08219 } 08220 08221 CannotYetSelect(N); 08222 return NULL; 08223 } 08224 08225 SDNode *Select_ISD_ConstantFP_f80(const SDValue &N) { 08226 08227 // Pattern: (fpimm:f80)<<P:Predicate_fpimm0>> 08228 // Emits: (LD_Fp080:f80) 08229 // Pattern complexity = 4 cost = 1 size = 0 08230 if (Predicate_fpimm0(N.getNode())) { 08231 SDNode *Result = Emit_82(N, X86::LD_Fp080, MVT::f80); 08232 return Result; 08233 } 08234 08235 // Pattern: (fpimm:f80)<<P:Predicate_fpimm1>> 08236 // Emits: (LD_Fp180:f80) 08237 // Pattern complexity = 4 cost = 1 size = 0 08238 if (Predicate_fpimm1(N.getNode())) { 08239 SDNode *Result = Emit_82(N, X86::LD_Fp180, MVT::f80); 08240 return Result; 08241 } 08242 08243 // Pattern: (fpimm:f80)<<P:Predicate_fpimmneg0>> 08244 // Emits: (CHS_Fp80:f80 (LD_Fp080:f80)) 08245 // Pattern complexity = 4 cost = 2 size = 0 08246 if (Predicate_fpimmneg0(N.getNode())) { 08247 SDNode *Result = Emit_90(N, X86::LD_Fp080, X86::CHS_Fp80, MVT::f80, MVT::f80); 08248 return Result; 08249 } 08250 08251 // Pattern: (fpimm:f80)<<P:Predicate_fpimmneg1>> 08252 // Emits: (CHS_Fp80:f80 (LD_Fp180:f80)) 08253 // Pattern complexity = 4 cost = 2 size = 0 08254 if (Predicate_fpimmneg1(N.getNode())) { 08255 SDNode *Result = Emit_90(N, X86::LD_Fp180, X86::CHS_Fp80, MVT::f80, MVT::f80); 08256 return Result; 08257 } 08258 08259 CannotYetSelect(N); 08260 return NULL; 08261 } 08262 08263 SDNode *Emit_91(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 08264 SDValue Chain = N.getOperand(0); 08265 SDValue N1 = N.getOperand(1); 08266 SDValue N2 = N.getOperand(2); 08267 SDValue N3 = N.getOperand(3); 08268 SDValue Tmp0 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i32); 08269 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N2)->getZExtValue()), MVT::i32); 08270 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N3)->getZExtValue()), MVT::i32); 08271 SDValue Ops0[] = { Tmp0, Tmp1, Tmp2, Chain }; 08272 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 4); 08273 } 08274 SDNode *Select_ISD_DEBUG_LOC(const SDValue &N) { 08275 SDValue Chain = N.getOperand(0); 08276 SDValue N1 = N.getOperand(1); 08277 if (N1.getOpcode() == ISD::Constant) { 08278 SDValue N2 = N.getOperand(2); 08279 if (N2.getOpcode() == ISD::Constant) { 08280 SDValue N3 = N.getOperand(3); 08281 if (N3.getOpcode() == ISD::Constant && 08282 N1.getNode()->getValueType(0) == MVT::i32 && 08283 N2.getNode()->getValueType(0) == MVT::i32 && 08284 N3.getNode()->getValueType(0) == MVT::i32) { 08285 SDNode *Result = Emit_91(N, X86::DWARF_LOC); 08286 return Result; 08287 } 08288 } 08289 } 08290 08291 CannotYetSelect(N); 08292 return NULL; 08293 } 08294 08295 SDNode *Emit_92(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 08296 SDValue N0 = N.getOperand(0); 08297 SDValue N1 = N.getOperand(1); 08298 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0); 08299 } 08300 SDNode *Emit_93(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 08301 SDValue N0 = N.getOperand(0); 08302 SDValue N1 = N.getOperand(1); 08303 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i32); 08304 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, Tmp1); 08305 } 08306 SDNode *Emit_94(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 08307 SDValue N0 = N.getOperand(0); 08308 SDValue N00 = N0.getOperand(0); 08309 SDValue N1 = N.getOperand(1); 08310 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i32); 08311 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N00, Tmp1); 08312 } 08313 SDNode *Select_ISD_EXTRACT_VECTOR_ELT_i32(const SDValue &N) { 08314 08315 // Pattern: (extractelt:i32 (bitconvert:v4i32 VR128:v4f32:$src1), (imm:iPTR):$src2) 08316 // Emits: (EXTRACTPSrr:i32 VR128:v4f32:$src1, (imm:i32):$src2) 08317 // Pattern complexity = 9 cost = 1 size = 3 08318 if ((Subtarget->hasSSE41())) { 08319 SDValue N0 = N.getOperand(0); 08320 if (N0.getOpcode() == ISD::BIT_CONVERT) { 08321 SDValue N00 = N0.getOperand(0); 08322 SDValue N1 = N.getOperand(1); 08323 if (N1.getOpcode() == ISD::Constant && 08324 N0.getNode()->getValueType(0) == MVT::v4i32 && 08325 N00.getNode()->getValueType(0) == MVT::v4f32) { 08326 SDNode *Result = Emit_94(N, X86::EXTRACTPSrr, MVT::i32); 08327 return Result; 08328 } 08329 } 08330 } 08331 08332 // Pattern: (vector_extract:i32 VR128:v4i32:$src, 0:iPTR) 08333 // Emits: (MOVPDI2DIrr:i32 VR128:v4i32:$src) 08334 // Pattern complexity = 8 cost = 1 size = 3 08335 if ((Subtarget->hasSSE2())) { 08336 SDValue N0 = N.getOperand(0); 08337 SDValue N1 = N.getOperand(1); 08338 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 08339 if (Tmp0) { 08340 int64_t CN1 = Tmp0->getSExtValue(); 08341 if (CN1 == INT64_C(0) && 08342 N0.getNode()->getValueType(0) == MVT::v4i32) { 08343 SDNode *Result = Emit_92(N, X86::MOVPDI2DIrr, MVT::i32); 08344 return Result; 08345 } 08346 } 08347 } 08348 08349 // Pattern: (extractelt:i32 VR128:v4i32:$src1, (imm:iPTR):$src2) 08350 // Emits: (PEXTRDrr:i32 VR128:v4i32:$src1, (imm:i32):$src2) 08351 // Pattern complexity = 6 cost = 1 size = 3 08352 if ((Subtarget->hasSSE41())) { 08353 SDValue N0 = N.getOperand(0); 08354 SDValue N1 = N.getOperand(1); 08355 if (N1.getOpcode() == ISD::Constant && 08356 N0.getNode()->getValueType(0) == MVT::v4i32) { 08357 SDNode *Result = Emit_93(N, X86::PEXTRDrr, MVT::i32); 08358 return Result; 08359 } 08360 } 08361 08362 CannotYetSelect(N); 08363 return NULL; 08364 } 08365 08366 SDNode *Select_ISD_EXTRACT_VECTOR_ELT_i64(const SDValue &N) { 08367 08368 // Pattern: (vector_extract:i64 VR128:v2i64:$src, 0:iPTR) 08369 // Emits: (MOVPQIto64rr:i64 VR128:v2i64:$src) 08370 // Pattern complexity = 8 cost = 1 size = 3 08371 if ((Subtarget->hasSSE2())) { 08372 SDValue N0 = N.getOperand(0); 08373 SDValue N1 = N.getOperand(1); 08374 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 08375 if (Tmp0) { 08376 int64_t CN1 = Tmp0->getSExtValue(); 08377 if (CN1 == INT64_C(0) && 08378 N0.getNode()->getValueType(0) == MVT::v2i64) { 08379 SDNode *Result = Emit_92(N, X86::MOVPQIto64rr, MVT::i64); 08380 return Result; 08381 } 08382 } 08383 } 08384 08385 // Pattern: (extractelt:i64 VR128:v2i64:$src1, (imm:iPTR):$src2) 08386 // Emits: (PEXTRQrr:i64 VR128:v2i64:$src1, (imm:i32):$src2) 08387 // Pattern complexity = 6 cost = 1 size = 3 08388 if ((Subtarget->hasSSE41())) { 08389 SDValue N0 = N.getOperand(0); 08390 SDValue N1 = N.getOperand(1); 08391 if (N1.getOpcode() == ISD::Constant && 08392 N0.getNode()->getValueType(0) == MVT::v2i64) { 08393 SDNode *Result = Emit_93(N, X86::PEXTRQrr, MVT::i64); 08394 return Result; 08395 } 08396 } 08397 08398 CannotYetSelect(N); 08399 return NULL; 08400 } 08401 08402 SDNode *Select_ISD_EXTRACT_VECTOR_ELT_f32(const SDValue &N) { 08403 if ((Subtarget->hasSSE1())) { 08404 SDValue N0 = N.getOperand(0); 08405 SDValue N1 = N.getOperand(1); 08406 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 08407 if (Tmp0) { 08408 int64_t CN1 = Tmp0->getSExtValue(); 08409 if (CN1 == INT64_C(0) && 08410 N0.getNode()->getValueType(0) == MVT::v4f32) { 08411 SDNode *Result = Emit_92(N, X86::MOVPS2SSrr, MVT::f32); 08412 return Result; 08413 } 08414 } 08415 } 08416 08417 CannotYetSelect(N); 08418 return NULL; 08419 } 08420 08421 SDNode *Select_ISD_EXTRACT_VECTOR_ELT_f64(const SDValue &N) { 08422 if ((Subtarget->hasSSE2())) { 08423 SDValue N0 = N.getOperand(0); 08424 SDValue N1 = N.getOperand(1); 08425 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 08426 if (Tmp0) { 08427 int64_t CN1 = Tmp0->getSExtValue(); 08428 if (CN1 == INT64_C(0) && 08429 N0.getNode()->getValueType(0) == MVT::v2f64) { 08430 SDNode *Result = Emit_92(N, X86::MOVPD2SDrr, MVT::f64); 08431 return Result; 08432 } 08433 } 08434 } 08435 08436 CannotYetSelect(N); 08437 return NULL; 08438 } 08439 08440 SDNode *Select_ISD_FABS_f32(const SDValue &N) { 08441 if ((!Subtarget->hasSSE1())) { 08442 SDNode *Result = Emit_71(N, X86::ABS_Fp32, MVT::f32); 08443 return Result; 08444 } 08445 08446 CannotYetSelect(N); 08447 return NULL; 08448 } 08449 08450 SDNode *Select_ISD_FABS_f64(const SDValue &N) { 08451 if ((!Subtarget->hasSSE2())) { 08452 SDNode *Result = Emit_71(N, X86::ABS_Fp64, MVT::f64); 08453 return Result; 08454 } 08455 08456 CannotYetSelect(N); 08457 return NULL; 08458 } 08459 08460 SDNode *Select_ISD_FABS_f80(const SDValue &N) { 08461 SDNode *Result = Emit_71(N, X86::ABS_Fp80, MVT::f80); 08462 return Result; 08463 } 08464 08465 SDNode *Emit_95(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 08466 SDValue N0 = N.getOperand(0); 08467 SDValue N1 = N.getOperand(1); 08468 SDValue Chain1 = N1.getOperand(0); 08469 SDValue N11 = N1.getOperand(1); 08470 SDValue N12 = N1.getOperand(2); 08471 SDValue Ops0[] = { N0, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, Chain1 }; 08472 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 7); 08473 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 08474 return ResNode; 08475 } 08476 SDNode *Emit_96(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 08477 SDValue N0 = N.getOperand(0); 08478 SDValue Chain0 = N0.getOperand(0); 08479 SDValue N01 = N0.getOperand(1); 08480 SDValue N02 = N0.getOperand(2); 08481 SDValue N1 = N.getOperand(1); 08482 SDValue Ops0[] = { N1, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, Chain0 }; 08483 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 7); 08484 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 08485 return ResNode; 08486 } 08487 SDNode *Select_ISD_FADD_f32(const SDValue &N) { 08488 if (OptLevel != CodeGenOpt::None) { 08489 if ((!Subtarget->hasSSE1())) { 08490 SDValue N0 = N.getOperand(0); 08491 08492 // Pattern: (fadd:f32 RFP32:f32:$src1, (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf32>>) 08493 // Emits: (ADD_Fp32m:f32 RFP32:f32:$src1, addr:iPTR:$src2) 08494 // Pattern complexity = 25 cost = 1 size = 0 08495 { 08496 SDValue N1 = N.getOperand(1); 08497 if (N1.getOpcode() == ISD::LOAD && 08498 N1.hasOneUse() && 08499 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 08500 SDValue Chain1 = N1.getOperand(0); 08501 if (Predicate_unindexedload(N1.getNode()) && 08502 Predicate_load(N1.getNode()) && 08503 Predicate_loadf32(N1.getNode())) { 08504 SDValue N11 = N1.getOperand(1); 08505 SDValue CPTmpN11_0; 08506 SDValue CPTmpN11_1; 08507 SDValue CPTmpN11_2; 08508 SDValue CPTmpN11_3; 08509 SDValue CPTmpN11_4; 08510 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 08511 SDNode *Result = Emit_18(N, X86::ADD_Fp32m, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 08512 return Result; 08513 } 08514 } 08515 } 08516 } 08517 08518 // Pattern: (fadd:f32 (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf32>>, RFP32:f32:$src1) 08519 // Emits: (ADD_Fp32m:f32 RFP32:f32:$src1, addr:iPTR:$src2) 08520 // Pattern complexity = 25 cost = 1 size = 0 08521 if (N0.getOpcode() == ISD::LOAD && 08522 N0.hasOneUse() && 08523 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 08524 SDValue Chain0 = N0.getOperand(0); 08525 if (Predicate_unindexedload(N0.getNode()) && 08526 Predicate_load(N0.getNode()) && 08527 Predicate_loadf32(N0.getNode())) { 08528 SDValue N01 = N0.getOperand(1); 08529 SDValue CPTmpN01_0; 08530 SDValue CPTmpN01_1; 08531 SDValue CPTmpN01_2; 08532 SDValue CPTmpN01_3; 08533 SDValue CPTmpN01_4; 08534 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 08535 SDNode *Result = Emit_19(N, X86::ADD_Fp32m, MVT::f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 08536 return Result; 08537 } 08538 } 08539 } 08540 } 08541 if ((Subtarget->hasSSE1())) { 08542 SDValue N0 = N.getOperand(0); 08543 08544 // Pattern: (fadd:f32 FR32:f32:$src1, (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 08545 // Emits: (ADDSSrm:f32 FR32:f32:$src1, addr:iPTR:$src2) 08546 // Pattern complexity = 25 cost = 1 size = 3 08547 { 08548 SDValue N1 = N.getOperand(1); 08549 if (N1.getOpcode() == ISD::LOAD && 08550 N1.hasOneUse() && 08551 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 08552 SDValue Chain1 = N1.getOperand(0); 08553 if (Predicate_unindexedload(N1.getNode()) && 08554 Predicate_load(N1.getNode())) { 08555 SDValue N11 = N1.getOperand(1); 08556 SDValue CPTmpN11_0; 08557 SDValue CPTmpN11_1; 08558 SDValue CPTmpN11_2; 08559 SDValue CPTmpN11_3; 08560 SDValue CPTmpN11_4; 08561 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 08562 SDNode *Result = Emit_18(N, X86::ADDSSrm, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 08563 return Result; 08564 } 08565 } 08566 } 08567 } 08568 08569 // Pattern: (fadd:f32 (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, FR32:f32:$src1) 08570 // Emits: (ADDSSrm:f32 FR32:f32:$src1, addr:iPTR:$src2) 08571 // Pattern complexity = 25 cost = 1 size = 3 08572 if (N0.getOpcode() == ISD::LOAD && 08573 N0.hasOneUse() && 08574 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 08575 SDValue Chain0 = N0.getOperand(0); 08576 if (Predicate_unindexedload(N0.getNode()) && 08577 Predicate_load(N0.getNode())) { 08578 SDValue N01 = N0.getOperand(1); 08579 SDValue CPTmpN01_0; 08580 SDValue CPTmpN01_1; 08581 SDValue CPTmpN01_2; 08582 SDValue CPTmpN01_3; 08583 SDValue CPTmpN01_4; 08584 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 08585 SDNode *Result = Emit_19(N, X86::ADDSSrm, MVT::f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 08586 return Result; 08587 } 08588 } 08589 } 08590 } 08591 if ((!Subtarget->hasSSE1())) { 08592 SDValue N0 = N.getOperand(0); 08593 { 08594 SDValue N1 = N.getOperand(1); 08595 if (N1.getOpcode() == X86ISD::FILD && 08596 N1.hasOneUse() && 08597 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 08598 SDValue Chain1 = N1.getOperand(0); 08599 SDValue N11 = N1.getOperand(1); 08600 SDValue CPTmpN11_0; 08601 SDValue CPTmpN11_1; 08602 SDValue CPTmpN11_2; 08603 SDValue CPTmpN11_3; 08604 SDValue CPTmpN11_4; 08605 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 08606 SDValue N12 = N1.getOperand(2); 08607 08608 // Pattern: (fadd:f32 RFP32:f32:$src1, (X86fild:f32 addr:iPTR:$src2, i16:Other)) 08609 // Emits: (ADD_FpI16m32:f32 RFP32:f32:$src1, addr:iPTR:$src2) 08610 // Pattern complexity = 24 cost = 1 size = 0 08611 if (cast<VTSDNode>(N12)->getVT() == MVT::i16) { 08612 SDNode *Result = Emit_95(N, X86::ADD_FpI16m32, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 08613 return Result; 08614 } 08615 08616 // Pattern: (fadd:f32 RFP32:f32:$src1, (X86fild:f32 addr:iPTR:$src2, i32:Other)) 08617 // Emits: (ADD_FpI32m32:f32 RFP32:f32:$src1, addr:iPTR:$src2) 08618 // Pattern complexity = 24 cost = 1 size = 0 08619 if (cast<VTSDNode>(N12)->getVT() == MVT::i32) { 08620 SDNode *Result = Emit_95(N, X86::ADD_FpI32m32, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 08621 return Result; 08622 } 08623 } 08624 } 08625 } 08626 if (N0.getOpcode() == X86ISD::FILD && 08627 N0.hasOneUse() && 08628 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 08629 SDValue Chain0 = N0.getOperand(0); 08630 SDValue N01 = N0.getOperand(1); 08631 SDValue CPTmpN01_0; 08632 SDValue CPTmpN01_1; 08633 SDValue CPTmpN01_2; 08634 SDValue CPTmpN01_3; 08635 SDValue CPTmpN01_4; 08636 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 08637 SDValue N02 = N0.getOperand(2); 08638 08639 // Pattern: (fadd:f32 (X86fild:f32 addr:iPTR:$src2, i16:Other), RFP32:f32:$src1) 08640 // Emits: (ADD_FpI16m32:f32 RFP32:f32:$src1, addr:iPTR:$src2) 08641 // Pattern complexity = 24 cost = 1 size = 0 08642 if (cast<VTSDNode>(N02)->getVT() == MVT::i16) { 08643 SDNode *Result = Emit_96(N, X86::ADD_FpI16m32, MVT::f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 08644 return Result; 08645 } 08646 08647 // Pattern: (fadd:f32 (X86fild:f32 addr:iPTR:$src2, i32:Other), RFP32:f32:$src1) 08648 // Emits: (ADD_FpI32m32:f32 RFP32:f32:$src1, addr:iPTR:$src2) 08649 // Pattern complexity = 24 cost = 1 size = 0 08650 if (cast<VTSDNode>(N02)->getVT() == MVT::i32) { 08651 SDNode *Result = Emit_96(N, X86::ADD_FpI32m32, MVT::f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 08652 return Result; 08653 } 08654 } 08655 } 08656 } 08657 } 08658 08659 // Pattern: (fadd:f32 RFP32:f32:$src1, RFP32:f32:$src2) 08660 // Emits: (ADD_Fp32:f32 RFP32:f32:$src1, RFP32:f32:$src2) 08661 // Pattern complexity = 3 cost = 1 size = 0 08662 if ((!Subtarget->hasSSE1())) { 08663 SDNode *Result = Emit_15(N, X86::ADD_Fp32, MVT::f32); 08664 return Result; 08665 } 08666 08667 // Pattern: (fadd:f32 FR32:f32:$src1, FR32:f32:$src2) 08668 // Emits: (ADDSSrr:f32 FR32:f32:$src1, FR32:f32:$src2) 08669 // Pattern complexity = 3 cost = 1 size = 3 08670 if ((Subtarget->hasSSE1())) { 08671 SDNode *Result = Emit_15(N, X86::ADDSSrr, MVT::f32); 08672 return Result; 08673 } 08674 08675 CannotYetSelect(N); 08676 return NULL; 08677 } 08678 08679 SDNode *Select_ISD_FADD_f64(const SDValue &N) { 08680 if (OptLevel != CodeGenOpt::None) { 08681 if ((!Subtarget->hasSSE2())) { 08682 SDValue N0 = N.getOperand(0); 08683 { 08684 SDValue N1 = N.getOperand(1); 08685 if (N1.getOpcode() == ISD::LOAD && 08686 N1.hasOneUse() && 08687 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 08688 SDValue Chain1 = N1.getOperand(0); 08689 if (Predicate_unindexedload(N1.getNode())) { 08690 08691 // Pattern: (fadd:f64 RFP64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>) 08692 // Emits: (ADD_Fp64m:f64 RFP64:f64:$src1, addr:iPTR:$src2) 08693 // Pattern complexity = 25 cost = 1 size = 0 08694 if (Predicate_load(N1.getNode()) && 08695 Predicate_loadf64(N1.getNode())) { 08696 SDValue N11 = N1.getOperand(1); 08697 SDValue CPTmpN11_0; 08698 SDValue CPTmpN11_1; 08699 SDValue CPTmpN11_2; 08700 SDValue CPTmpN11_3; 08701 SDValue CPTmpN11_4; 08702 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 08703 SDNode *Result = Emit_18(N, X86::ADD_Fp64m, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 08704 return Result; 08705 } 08706 } 08707 08708 // Pattern: (fadd:f64 RFP64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>>) 08709 // Emits: (ADD_Fp64m32:f64 RFP64:f64:$src1, addr:iPTR:$src2) 08710 // Pattern complexity = 25 cost = 1 size = 0 08711 if (Predicate_extload(N1.getNode()) && 08712 Predicate_extloadf32(N1.getNode())) { 08713 SDValue N11 = N1.getOperand(1); 08714 SDValue CPTmpN11_0; 08715 SDValue CPTmpN11_1; 08716 SDValue CPTmpN11_2; 08717 SDValue CPTmpN11_3; 08718 SDValue CPTmpN11_4; 08719 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 08720 SDNode *Result = Emit_18(N, X86::ADD_Fp64m32, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 08721 return Result; 08722 } 08723 } 08724 } 08725 } 08726 } 08727 if (N0.getOpcode() == ISD::LOAD && 08728 N0.hasOneUse() && 08729 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 08730 SDValue Chain0 = N0.getOperand(0); 08731 if (Predicate_unindexedload(N0.getNode())) { 08732 08733 // Pattern: (fadd:f64 (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>, RFP64:f64:$src1) 08734 // Emits: (ADD_Fp64m:f64 RFP64:f64:$src1, addr:iPTR:$src2) 08735 // Pattern complexity = 25 cost = 1 size = 0 08736 if (Predicate_load(N0.getNode()) && 08737 Predicate_loadf64(N0.getNode())) { 08738 SDValue N01 = N0.getOperand(1); 08739 SDValue CPTmpN01_0; 08740 SDValue CPTmpN01_1; 08741 SDValue CPTmpN01_2; 08742 SDValue CPTmpN01_3; 08743 SDValue CPTmpN01_4; 08744 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 08745 SDNode *Result = Emit_19(N, X86::ADD_Fp64m, MVT::f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 08746 return Result; 08747 } 08748 } 08749 08750 // Pattern: (fadd:f64 (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>>, RFP64:f64:$src1) 08751 // Emits: (ADD_Fp64m32:f64 RFP64:f64:$src1, addr:iPTR:$src2) 08752 // Pattern complexity = 25 cost = 1 size = 0 08753 if (Predicate_extload(N0.getNode()) && 08754 Predicate_extloadf32(N0.getNode())) { 08755 SDValue N01 = N0.getOperand(1); 08756 SDValue CPTmpN01_0; 08757 SDValue CPTmpN01_1; 08758 SDValue CPTmpN01_2; 08759 SDValue CPTmpN01_3; 08760 SDValue CPTmpN01_4; 08761 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 08762 SDNode *Result = Emit_19(N, X86::ADD_Fp64m32, MVT::f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 08763 return Result; 08764 } 08765 } 08766 } 08767 } 08768 } 08769 if ((Subtarget->hasSSE2())) { 08770 SDValue N0 = N.getOperand(0); 08771 08772 // Pattern: (fadd:f64 FR64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 08773 // Emits: (ADDSDrm:f64 FR64:f64:$src1, addr:iPTR:$src2) 08774 // Pattern complexity = 25 cost = 1 size = 3 08775 { 08776 SDValue N1 = N.getOperand(1); 08777 if (N1.getOpcode() == ISD::LOAD && 08778 N1.hasOneUse() && 08779 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 08780 SDValue Chain1 = N1.getOperand(0); 08781 if (Predicate_unindexedload(N1.getNode()) && 08782 Predicate_load(N1.getNode())) { 08783 SDValue N11 = N1.getOperand(1); 08784 SDValue CPTmpN11_0; 08785 SDValue CPTmpN11_1; 08786 SDValue CPTmpN11_2; 08787 SDValue CPTmpN11_3; 08788 SDValue CPTmpN11_4; 08789 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 08790 SDNode *Result = Emit_18(N, X86::ADDSDrm, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 08791 return Result; 08792 } 08793 } 08794 } 08795 } 08796 08797 // Pattern: (fadd:f64 (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, FR64:f64:$src1) 08798 // Emits: (ADDSDrm:f64 FR64:f64:$src1, addr:iPTR:$src2) 08799 // Pattern complexity = 25 cost = 1 size = 3 08800 if (N0.getOpcode() == ISD::LOAD && 08801 N0.hasOneUse() && 08802 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 08803 SDValue Chain0 = N0.getOperand(0); 08804 if (Predicate_unindexedload(N0.getNode()) && 08805 Predicate_load(N0.getNode())) { 08806 SDValue N01 = N0.getOperand(1); 08807 SDValue CPTmpN01_0; 08808 SDValue CPTmpN01_1; 08809 SDValue CPTmpN01_2; 08810 SDValue CPTmpN01_3; 08811 SDValue CPTmpN01_4; 08812 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 08813 SDNode *Result = Emit_19(N, X86::ADDSDrm, MVT::f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 08814 return Result; 08815 } 08816 } 08817 } 08818 } 08819 if ((!Subtarget->hasSSE2())) { 08820 SDValue N0 = N.getOperand(0); 08821 { 08822 SDValue N1 = N.getOperand(1); 08823 if (N1.getOpcode() == X86ISD::FILD && 08824 N1.hasOneUse() && 08825 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 08826 SDValue Chain1 = N1.getOperand(0); 08827 SDValue N11 = N1.getOperand(1); 08828 SDValue CPTmpN11_0; 08829 SDValue CPTmpN11_1; 08830 SDValue CPTmpN11_2; 08831 SDValue CPTmpN11_3; 08832 SDValue CPTmpN11_4; 08833 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 08834 SDValue N12 = N1.getOperand(2); 08835 08836 // Pattern: (fadd:f64 RFP64:f64:$src1, (X86fild:f64 addr:iPTR:$src2, i16:Other)) 08837 // Emits: (ADD_FpI16m64:f64 RFP64:f64:$src1, addr:iPTR:$src2) 08838 // Pattern complexity = 24 cost = 1 size = 0 08839 if (cast<VTSDNode>(N12)->getVT() == MVT::i16) { 08840 SDNode *Result = Emit_95(N, X86::ADD_FpI16m64, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 08841 return Result; 08842 } 08843 08844 // Pattern: (fadd:f64 RFP64:f64:$src1, (X86fild:f64 addr:iPTR:$src2, i32:Other)) 08845 // Emits: (ADD_FpI32m64:f64 RFP64:f64:$src1, addr:iPTR:$src2) 08846 // Pattern complexity = 24 cost = 1 size = 0 08847 if (cast<VTSDNode>(N12)->getVT() == MVT::i32) { 08848 SDNode *Result = Emit_95(N, X86::ADD_FpI32m64, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 08849 return Result; 08850 } 08851 } 08852 } 08853 } 08854 if (N0.getOpcode() == X86ISD::FILD && 08855 N0.hasOneUse() && 08856 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 08857 SDValue Chain0 = N0.getOperand(0); 08858 SDValue N01 = N0.getOperand(1); 08859 SDValue CPTmpN01_0; 08860 SDValue CPTmpN01_1; 08861 SDValue CPTmpN01_2; 08862 SDValue CPTmpN01_3; 08863 SDValue CPTmpN01_4; 08864 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 08865 SDValue N02 = N0.getOperand(2); 08866 08867 // Pattern: (fadd:f64 (X86fild:f64 addr:iPTR:$src2, i16:Other), RFP64:f64:$src1) 08868 // Emits: (ADD_FpI16m64:f64 RFP64:f64:$src1, addr:iPTR:$src2) 08869 // Pattern complexity = 24 cost = 1 size = 0 08870 if (cast<VTSDNode>(N02)->getVT() == MVT::i16) { 08871 SDNode *Result = Emit_96(N, X86::ADD_FpI16m64, MVT::f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 08872 return Result; 08873 } 08874 08875 // Pattern: (fadd:f64 (X86fild:f64 addr:iPTR:$src2, i32:Other), RFP64:f64:$src1) 08876 // Emits: (ADD_FpI32m64:f64 RFP64:f64:$src1, addr:iPTR:$src2) 08877 // Pattern complexity = 24 cost = 1 size = 0 08878 if (cast<VTSDNode>(N02)->getVT() == MVT::i32) { 08879 SDNode *Result = Emit_96(N, X86::ADD_FpI32m64, MVT::f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 08880 return Result; 08881 } 08882 } 08883 } 08884 } 08885 } 08886 08887 // Pattern: (fadd:f64 RFP64:f64:$src1, RFP64:f64:$src2) 08888 // Emits: (ADD_Fp64:f64 RFP64:f64:$src1, RFP64:f64:$src2) 08889 // Pattern complexity = 3 cost = 1 size = 0 08890 if ((!Subtarget->hasSSE2())) { 08891 SDNode *Result = Emit_15(N, X86::ADD_Fp64, MVT::f64); 08892 return Result; 08893 } 08894 08895 // Pattern: (fadd:f64 FR64:f64:$src1, FR64:f64:$src2) 08896 // Emits: (ADDSDrr:f64 FR64:f64:$src1, FR64:f64:$src2) 08897 // Pattern complexity = 3 cost = 1 size = 3 08898 if ((Subtarget->hasSSE2())) { 08899 SDNode *Result = Emit_15(N, X86::ADDSDrr, MVT::f64); 08900 return Result; 08901 } 08902 08903 CannotYetSelect(N); 08904 return NULL; 08905 } 08906 08907 SDNode *Select_ISD_FADD_f80(const SDValue &N) { 08908 if (OptLevel != CodeGenOpt::None) { 08909 SDValue N0 = N.getOperand(0); 08910 { 08911 SDValue N1 = N.getOperand(1); 08912 if (N1.getOpcode() == ISD::LOAD && 08913 N1.hasOneUse() && 08914 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 08915 SDValue Chain1 = N1.getOperand(0); 08916 if (Predicate_unindexedload(N1.getNode()) && 08917 Predicate_extload(N1.getNode())) { 08918 08919 // Pattern: (fadd:f80 RFP80:f80:$src1, (ld:f80 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>>) 08920 // Emits: (ADD_Fp80m32:f80 RFP80:f80:$src1, addr:iPTR:$src2) 08921 // Pattern complexity = 25 cost = 1 size = 0 08922 if (Predicate_extloadf32(N1.getNode())) { 08923 SDValue N11 = N1.getOperand(1); 08924 SDValue CPTmpN11_0; 08925 SDValue CPTmpN11_1; 08926 SDValue CPTmpN11_2; 08927 SDValue CPTmpN11_3; 08928 SDValue CPTmpN11_4; 08929 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 08930 SDNode *Result = Emit_18(N, X86::ADD_Fp80m32, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 08931 return Result; 08932 } 08933 } 08934 08935 // Pattern: (fadd:f80 RFP80:f80:$src1, (ld:f80 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf64>>) 08936 // Emits: (ADD_Fp80m64:f80 RFP80:f80:$src1, addr:iPTR:$src2) 08937 // Pattern complexity = 25 cost = 1 size = 0 08938 if (Predicate_extloadf64(N1.getNode())) { 08939 SDValue N11 = N1.getOperand(1); 08940 SDValue CPTmpN11_0; 08941 SDValue CPTmpN11_1; 08942 SDValue CPTmpN11_2; 08943 SDValue CPTmpN11_3; 08944 SDValue CPTmpN11_4; 08945 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 08946 SDNode *Result = Emit_18(N, X86::ADD_Fp80m64, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 08947 return Result; 08948 } 08949 } 08950 } 08951 } 08952 } 08953 if (N0.getOpcode() == ISD::LOAD && 08954 N0.hasOneUse() && 08955 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 08956 SDValue Chain0 = N0.getOperand(0); 08957 if (Predicate_unindexedload(N0.getNode()) && 08958 Predicate_extload(N0.getNode())) { 08959 08960 // Pattern: (fadd:f80 (ld:f80 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>>, RFP80:f80:$src1) 08961 // Emits: (ADD_Fp80m32:f80 RFP80:f80:$src1, addr:iPTR:$src2) 08962 // Pattern complexity = 25 cost = 1 size = 0 08963 if (Predicate_extloadf32(N0.getNode())) { 08964 SDValue N01 = N0.getOperand(1); 08965 SDValue CPTmpN01_0; 08966 SDValue CPTmpN01_1; 08967 SDValue CPTmpN01_2; 08968 SDValue CPTmpN01_3; 08969 SDValue CPTmpN01_4; 08970 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 08971 SDNode *Result = Emit_19(N, X86::ADD_Fp80m32, MVT::f80, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 08972 return Result; 08973 } 08974 } 08975 08976 // Pattern: (fadd:f80 (ld:f80 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf64>>, RFP80:f80:$src1) 08977 // Emits: (ADD_Fp80m64:f80 RFP80:f80:$src1, addr:iPTR:$src2) 08978 // Pattern complexity = 25 cost = 1 size = 0 08979 if (Predicate_extloadf64(N0.getNode())) { 08980 SDValue N01 = N0.getOperand(1); 08981 SDValue CPTmpN01_0; 08982 SDValue CPTmpN01_1; 08983 SDValue CPTmpN01_2; 08984 SDValue CPTmpN01_3; 08985 SDValue CPTmpN01_4; 08986 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 08987 SDNode *Result = Emit_19(N, X86::ADD_Fp80m64, MVT::f80, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 08988 return Result; 08989 } 08990 } 08991 } 08992 } 08993 { 08994 SDValue N1 = N.getOperand(1); 08995 if (N1.getOpcode() == X86ISD::FILD && 08996 N1.hasOneUse() && 08997 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 08998 SDValue Chain1 = N1.getOperand(0); 08999 SDValue N11 = N1.getOperand(1); 09000 SDValue CPTmpN11_0; 09001 SDValue CPTmpN11_1; 09002 SDValue CPTmpN11_2; 09003 SDValue CPTmpN11_3; 09004 SDValue CPTmpN11_4; 09005 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09006 SDValue N12 = N1.getOperand(2); 09007 09008 // Pattern: (fadd:f80 RFP80:f80:$src1, (X86fild:f80 addr:iPTR:$src2, i16:Other)) 09009 // Emits: (ADD_FpI16m80:f80 RFP80:f80:$src1, addr:iPTR:$src2) 09010 // Pattern complexity = 24 cost = 1 size = 0 09011 if (cast<VTSDNode>(N12)->getVT() == MVT::i16) { 09012 SDNode *Result = Emit_95(N, X86::ADD_FpI16m80, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09013 return Result; 09014 } 09015 09016 // Pattern: (fadd:f80 RFP80:f80:$src1, (X86fild:f80 addr:iPTR:$src2, i32:Other)) 09017 // Emits: (ADD_FpI32m80:f80 RFP80:f80:$src1, addr:iPTR:$src2) 09018 // Pattern complexity = 24 cost = 1 size = 0 09019 if (cast<VTSDNode>(N12)->getVT() == MVT::i32) { 09020 SDNode *Result = Emit_95(N, X86::ADD_FpI32m80, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09021 return Result; 09022 } 09023 } 09024 } 09025 } 09026 if (N0.getOpcode() == X86ISD::FILD && 09027 N0.hasOneUse() && 09028 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 09029 SDValue Chain0 = N0.getOperand(0); 09030 SDValue N01 = N0.getOperand(1); 09031 SDValue CPTmpN01_0; 09032 SDValue CPTmpN01_1; 09033 SDValue CPTmpN01_2; 09034 SDValue CPTmpN01_3; 09035 SDValue CPTmpN01_4; 09036 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 09037 SDValue N02 = N0.getOperand(2); 09038 09039 // Pattern: (fadd:f80 (X86fild:f80 addr:iPTR:$src2, i16:Other), RFP80:f80:$src1) 09040 // Emits: (ADD_FpI16m80:f80 RFP80:f80:$src1, addr:iPTR:$src2) 09041 // Pattern complexity = 24 cost = 1 size = 0 09042 if (cast<VTSDNode>(N02)->getVT() == MVT::i16) { 09043 SDNode *Result = Emit_96(N, X86::ADD_FpI16m80, MVT::f80, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 09044 return Result; 09045 } 09046 09047 // Pattern: (fadd:f80 (X86fild:f80 addr:iPTR:$src2, i32:Other), RFP80:f80:$src1) 09048 // Emits: (ADD_FpI32m80:f80 RFP80:f80:$src1, addr:iPTR:$src2) 09049 // Pattern complexity = 24 cost = 1 size = 0 09050 if (cast<VTSDNode>(N02)->getVT() == MVT::i32) { 09051 SDNode *Result = Emit_96(N, X86::ADD_FpI32m80, MVT::f80, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 09052 return Result; 09053 } 09054 } 09055 } 09056 } 09057 09058 // Pattern: (fadd:f80 RFP80:f80:$src1, RFP80:f80:$src2) 09059 // Emits: (ADD_Fp80:f80 RFP80:f80:$src1, RFP80:f80:$src2) 09060 // Pattern complexity = 3 cost = 1 size = 0 09061 SDNode *Result = Emit_15(N, X86::ADD_Fp80, MVT::f80); 09062 return Result; 09063 } 09064 09065 SDNode *Select_ISD_FADD_v4f32(const SDValue &N) { 09066 if (OptLevel != CodeGenOpt::None && 09067 (Subtarget->hasSSE1())) { 09068 SDValue N0 = N.getOperand(0); 09069 09070 // Pattern: (fadd:v4f32 VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 09071 // Emits: (ADDPSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 09072 // Pattern complexity = 25 cost = 1 size = 3 09073 { 09074 SDValue N1 = N.getOperand(1); 09075 if (N1.getOpcode() == ISD::LOAD && 09076 N1.hasOneUse() && 09077 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 09078 SDValue Chain1 = N1.getOperand(0); 09079 if (Predicate_unindexedload(N1.getNode()) && 09080 Predicate_load(N1.getNode()) && 09081 Predicate_memop(N1.getNode())) { 09082 SDValue N11 = N1.getOperand(1); 09083 SDValue CPTmpN11_0; 09084 SDValue CPTmpN11_1; 09085 SDValue CPTmpN11_2; 09086 SDValue CPTmpN11_3; 09087 SDValue CPTmpN11_4; 09088 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09089 SDNode *Result = Emit_18(N, X86::ADDPSrm, MVT::v4f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09090 return Result; 09091 } 09092 } 09093 } 09094 } 09095 09096 // Pattern: (fadd:v4f32 (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, VR128:v4f32:$src1) 09097 // Emits: (ADDPSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 09098 // Pattern complexity = 25 cost = 1 size = 3 09099 if (N0.getOpcode() == ISD::LOAD && 09100 N0.hasOneUse() && 09101 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 09102 SDValue Chain0 = N0.getOperand(0); 09103 if (Predicate_unindexedload(N0.getNode()) && 09104 Predicate_load(N0.getNode()) && 09105 Predicate_memop(N0.getNode())) { 09106 SDValue N01 = N0.getOperand(1); 09107 SDValue CPTmpN01_0; 09108 SDValue CPTmpN01_1; 09109 SDValue CPTmpN01_2; 09110 SDValue CPTmpN01_3; 09111 SDValue CPTmpN01_4; 09112 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 09113 SDNode *Result = Emit_19(N, X86::ADDPSrm, MVT::v4f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 09114 return Result; 09115 } 09116 } 09117 } 09118 } 09119 09120 // Pattern: (fadd:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 09121 // Emits: (ADDPSrr:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 09122 // Pattern complexity = 3 cost = 1 size = 3 09123 if ((Subtarget->hasSSE1())) { 09124 SDNode *Result = Emit_15(N, X86::ADDPSrr, MVT::v4f32); 09125 return Result; 09126 } 09127 09128 CannotYetSelect(N); 09129 return NULL; 09130 } 09131 09132 SDNode *Select_ISD_FADD_v2f64(const SDValue &N) { 09133 if (OptLevel != CodeGenOpt::None && 09134 (Subtarget->hasSSE2())) { 09135 SDValue N0 = N.getOperand(0); 09136 09137 // Pattern: (fadd:v2f64 VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 09138 // Emits: (ADDPDrm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 09139 // Pattern complexity = 25 cost = 1 size = 3 09140 { 09141 SDValue N1 = N.getOperand(1); 09142 if (N1.getOpcode() == ISD::LOAD && 09143 N1.hasOneUse() && 09144 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 09145 SDValue Chain1 = N1.getOperand(0); 09146 if (Predicate_unindexedload(N1.getNode()) && 09147 Predicate_load(N1.getNode()) && 09148 Predicate_memop(N1.getNode())) { 09149 SDValue N11 = N1.getOperand(1); 09150 SDValue CPTmpN11_0; 09151 SDValue CPTmpN11_1; 09152 SDValue CPTmpN11_2; 09153 SDValue CPTmpN11_3; 09154 SDValue CPTmpN11_4; 09155 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09156 SDNode *Result = Emit_18(N, X86::ADDPDrm, MVT::v2f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09157 return Result; 09158 } 09159 } 09160 } 09161 } 09162 09163 // Pattern: (fadd:v2f64 (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, VR128:v2f64:$src1) 09164 // Emits: (ADDPDrm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 09165 // Pattern complexity = 25 cost = 1 size = 3 09166 if (N0.getOpcode() == ISD::LOAD && 09167 N0.hasOneUse() && 09168 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 09169 SDValue Chain0 = N0.getOperand(0); 09170 if (Predicate_unindexedload(N0.getNode()) && 09171 Predicate_load(N0.getNode()) && 09172 Predicate_memop(N0.getNode())) { 09173 SDValue N01 = N0.getOperand(1); 09174 SDValue CPTmpN01_0; 09175 SDValue CPTmpN01_1; 09176 SDValue CPTmpN01_2; 09177 SDValue CPTmpN01_3; 09178 SDValue CPTmpN01_4; 09179 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 09180 SDNode *Result = Emit_19(N, X86::ADDPDrm, MVT::v2f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 09181 return Result; 09182 } 09183 } 09184 } 09185 } 09186 09187 // Pattern: (fadd:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 09188 // Emits: (ADDPDrr:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 09189 // Pattern complexity = 3 cost = 1 size = 3 09190 if ((Subtarget->hasSSE2())) { 09191 SDNode *Result = Emit_15(N, X86::ADDPDrr, MVT::v2f64); 09192 return Result; 09193 } 09194 09195 CannotYetSelect(N); 09196 return NULL; 09197 } 09198 09199 SDNode *Select_ISD_FCOS_f32(const SDValue &N) { 09200 if ((!Subtarget->hasSSE1())) { 09201 SDNode *Result = Emit_71(N, X86::COS_Fp32, MVT::f32); 09202 return Result; 09203 } 09204 09205 CannotYetSelect(N); 09206 return NULL; 09207 } 09208 09209 SDNode *Select_ISD_FCOS_f64(const SDValue &N) { 09210 if ((!Subtarget->hasSSE2())) { 09211 SDNode *Result = Emit_71(N, X86::COS_Fp64, MVT::f64); 09212 return Result; 09213 } 09214 09215 CannotYetSelect(N); 09216 return NULL; 09217 } 09218 09219 SDNode *Select_ISD_FCOS_f80(const SDValue &N) { 09220 SDNode *Result = Emit_71(N, X86::COS_Fp80, MVT::f80); 09221 return Result; 09222 } 09223 09224 SDNode *Select_ISD_FDIV_f32(const SDValue &N) { 09225 if (OptLevel != CodeGenOpt::None) { 09226 if ((!Subtarget->hasSSE1())) { 09227 SDValue N0 = N.getOperand(0); 09228 SDValue N1 = N.getOperand(1); 09229 if (N1.getOpcode() == ISD::LOAD && 09230 N1.hasOneUse() && 09231 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 09232 SDValue Chain1 = N1.getOperand(0); 09233 if (Predicate_unindexedload(N1.getNode()) && 09234 Predicate_load(N1.getNode()) && 09235 Predicate_loadf32(N1.getNode())) { 09236 SDValue N11 = N1.getOperand(1); 09237 SDValue CPTmpN11_0; 09238 SDValue CPTmpN11_1; 09239 SDValue CPTmpN11_2; 09240 SDValue CPTmpN11_3; 09241 SDValue CPTmpN11_4; 09242 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09243 09244 // Pattern: (fdiv:f32 RFP32:f32:$src1, (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf32>>) 09245 // Emits: (DIV_Fp32m:f32 RFP32:f32:$src1, addr:iPTR:$src2) 09246 // Pattern complexity = 25 cost = 1 size = 0 09247 { 09248 SDNode *Result = Emit_18(N, X86::DIV_Fp32m, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09249 return Result; 09250 } 09251 09252 // Pattern: (fdiv:f32 RFP32:f32:$src1, (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf32>>) 09253 // Emits: (DIVR_Fp32m:f32 RFP32:f32:$src1, addr:iPTR:$src2) 09254 // Pattern complexity = 25 cost = 1 size = 0 09255 SDNode *Result = Emit_18(N, X86::DIVR_Fp32m, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09256 return Result; 09257 } 09258 } 09259 } 09260 } 09261 09262 // Pattern: (fdiv:f32 FR32:f32:$src1, (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 09263 // Emits: (DIVSSrm:f32 FR32:f32:$src1, addr:iPTR:$src2) 09264 // Pattern complexity = 25 cost = 1 size = 3 09265 if ((Subtarget->hasSSE1())) { 09266 SDValue N0 = N.getOperand(0); 09267 SDValue N1 = N.getOperand(1); 09268 if (N1.getOpcode() == ISD::LOAD && 09269 N1.hasOneUse() && 09270 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 09271 SDValue Chain1 = N1.getOperand(0); 09272 if (Predicate_unindexedload(N1.getNode()) && 09273 Predicate_load(N1.getNode())) { 09274 SDValue N11 = N1.getOperand(1); 09275 SDValue CPTmpN11_0; 09276 SDValue CPTmpN11_1; 09277 SDValue CPTmpN11_2; 09278 SDValue CPTmpN11_3; 09279 SDValue CPTmpN11_4; 09280 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09281 SDNode *Result = Emit_18(N, X86::DIVSSrm, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09282 return Result; 09283 } 09284 } 09285 } 09286 } 09287 if ((!Subtarget->hasSSE1())) { 09288 SDValue N0 = N.getOperand(0); 09289 SDValue N1 = N.getOperand(1); 09290 if (N1.getOpcode() == X86ISD::FILD && 09291 N1.hasOneUse() && 09292 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 09293 SDValue Chain1 = N1.getOperand(0); 09294 SDValue N11 = N1.getOperand(1); 09295 SDValue CPTmpN11_0; 09296 SDValue CPTmpN11_1; 09297 SDValue CPTmpN11_2; 09298 SDValue CPTmpN11_3; 09299 SDValue CPTmpN11_4; 09300 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09301 SDValue N12 = N1.getOperand(2); 09302 09303 // Pattern: (fdiv:f32 RFP32:f32:$src1, (X86fild:f32 addr:iPTR:$src2, i16:Other)) 09304 // Emits: (DIV_FpI16m32:f32 RFP32:f32:$src1, addr:iPTR:$src2) 09305 // Pattern complexity = 24 cost = 1 size = 0 09306 if (cast<VTSDNode>(N12)->getVT() == MVT::i16) { 09307 SDNode *Result = Emit_95(N, X86::DIV_FpI16m32, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09308 return Result; 09309 } 09310 09311 // Pattern: (fdiv:f32 RFP32:f32:$src1, (X86fild:f32 addr:iPTR:$src2, i32:Other)) 09312 // Emits: (DIV_FpI32m32:f32 RFP32:f32:$src1, addr:iPTR:$src2) 09313 // Pattern complexity = 24 cost = 1 size = 0 09314 if (cast<VTSDNode>(N12)->getVT() == MVT::i32) { 09315 SDNode *Result = Emit_95(N, X86::DIV_FpI32m32, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09316 return Result; 09317 } 09318 09319 // Pattern: (fdiv:f32 RFP32:f32:$src1, (X86fild:f32 addr:iPTR:$src2, i16:Other)) 09320 // Emits: (DIVR_FpI16m32:f32 RFP32:f32:$src1, addr:iPTR:$src2) 09321 // Pattern complexity = 24 cost = 1 size = 0 09322 if (cast<VTSDNode>(N12)->getVT() == MVT::i16) { 09323 SDNode *Result = Emit_95(N, X86::DIVR_FpI16m32, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09324 return Result; 09325 } 09326 09327 // Pattern: (fdiv:f32 RFP32:f32:$src1, (X86fild:f32 addr:iPTR:$src2, i32:Other)) 09328 // Emits: (DIVR_FpI32m32:f32 RFP32:f32:$src1, addr:iPTR:$src2) 09329 // Pattern complexity = 24 cost = 1 size = 0 09330 if (cast<VTSDNode>(N12)->getVT() == MVT::i32) { 09331 SDNode *Result = Emit_95(N, X86::DIVR_FpI32m32, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09332 return Result; 09333 } 09334 } 09335 } 09336 } 09337 } 09338 09339 // Pattern: (fdiv:f32 RFP32:f32:$src1, RFP32:f32:$src2) 09340 // Emits: (DIV_Fp32:f32 RFP32:f32:$src1, RFP32:f32:$src2) 09341 // Pattern complexity = 3 cost = 1 size = 0 09342 if ((!Subtarget->hasSSE1())) { 09343 SDNode *Result = Emit_15(N, X86::DIV_Fp32, MVT::f32); 09344 return Result; 09345 } 09346 09347 // Pattern: (fdiv:f32 FR32:f32:$src1, FR32:f32:$src2) 09348 // Emits: (DIVSSrr:f32 FR32:f32:$src1, FR32:f32:$src2) 09349 // Pattern complexity = 3 cost = 1 size = 3 09350 if ((Subtarget->hasSSE1())) { 09351 SDNode *Result = Emit_15(N, X86::DIVSSrr, MVT::f32); 09352 return Result; 09353 } 09354 09355 CannotYetSelect(N); 09356 return NULL; 09357 } 09358 09359 SDNode *Select_ISD_FDIV_f64(const SDValue &N) { 09360 if (OptLevel != CodeGenOpt::None) { 09361 if ((!Subtarget->hasSSE2())) { 09362 SDValue N0 = N.getOperand(0); 09363 SDValue N1 = N.getOperand(1); 09364 if (N1.getOpcode() == ISD::LOAD && 09365 N1.hasOneUse() && 09366 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 09367 SDValue Chain1 = N1.getOperand(0); 09368 if (Predicate_unindexedload(N1.getNode())) { 09369 09370 // Pattern: (fdiv:f64 RFP64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>) 09371 // Emits: (DIV_Fp64m:f64 RFP64:f64:$src1, addr:iPTR:$src2) 09372 // Pattern complexity = 25 cost = 1 size = 0 09373 if (Predicate_load(N1.getNode()) && 09374 Predicate_loadf64(N1.getNode())) { 09375 SDValue N11 = N1.getOperand(1); 09376 SDValue CPTmpN11_0; 09377 SDValue CPTmpN11_1; 09378 SDValue CPTmpN11_2; 09379 SDValue CPTmpN11_3; 09380 SDValue CPTmpN11_4; 09381 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09382 SDNode *Result = Emit_18(N, X86::DIV_Fp64m, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09383 return Result; 09384 } 09385 } 09386 09387 // Pattern: (fdiv:f64 RFP64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>>) 09388 // Emits: (DIV_Fp64m32:f64 RFP64:f64:$src1, addr:iPTR:$src2) 09389 // Pattern complexity = 25 cost = 1 size = 0 09390 if (Predicate_extload(N1.getNode()) && 09391 Predicate_extloadf32(N1.getNode())) { 09392 SDValue N11 = N1.getOperand(1); 09393 SDValue CPTmpN11_0; 09394 SDValue CPTmpN11_1; 09395 SDValue CPTmpN11_2; 09396 SDValue CPTmpN11_3; 09397 SDValue CPTmpN11_4; 09398 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09399 SDNode *Result = Emit_18(N, X86::DIV_Fp64m32, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09400 return Result; 09401 } 09402 } 09403 09404 // Pattern: (fdiv:f64 RFP64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>) 09405 // Emits: (DIVR_Fp64m:f64 RFP64:f64:$src1, addr:iPTR:$src2) 09406 // Pattern complexity = 25 cost = 1 size = 0 09407 if (Predicate_load(N1.getNode()) && 09408 Predicate_loadf64(N1.getNode())) { 09409 SDValue N11 = N1.getOperand(1); 09410 SDValue CPTmpN11_0; 09411 SDValue CPTmpN11_1; 09412 SDValue CPTmpN11_2; 09413 SDValue CPTmpN11_3; 09414 SDValue CPTmpN11_4; 09415 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09416 SDNode *Result = Emit_18(N, X86::DIVR_Fp64m, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09417 return Result; 09418 } 09419 } 09420 09421 // Pattern: (fdiv:f64 RFP64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>>) 09422 // Emits: (DIVR_Fp64m32:f64 RFP64:f64:$src1, addr:iPTR:$src2) 09423 // Pattern complexity = 25 cost = 1 size = 0 09424 if (Predicate_extload(N1.getNode()) && 09425 Predicate_extloadf32(N1.getNode())) { 09426 SDValue N11 = N1.getOperand(1); 09427 SDValue CPTmpN11_0; 09428 SDValue CPTmpN11_1; 09429 SDValue CPTmpN11_2; 09430 SDValue CPTmpN11_3; 09431 SDValue CPTmpN11_4; 09432 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09433 SDNode *Result = Emit_18(N, X86::DIVR_Fp64m32, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09434 return Result; 09435 } 09436 } 09437 } 09438 } 09439 } 09440 09441 // Pattern: (fdiv:f64 FR64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 09442 // Emits: (DIVSDrm:f64 FR64:f64:$src1, addr:iPTR:$src2) 09443 // Pattern complexity = 25 cost = 1 size = 3 09444 if ((Subtarget->hasSSE2())) { 09445 SDValue N0 = N.getOperand(0); 09446 SDValue N1 = N.getOperand(1); 09447 if (N1.getOpcode() == ISD::LOAD && 09448 N1.hasOneUse() && 09449 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 09450 SDValue Chain1 = N1.getOperand(0); 09451 if (Predicate_unindexedload(N1.getNode()) && 09452 Predicate_load(N1.getNode())) { 09453 SDValue N11 = N1.getOperand(1); 09454 SDValue CPTmpN11_0; 09455 SDValue CPTmpN11_1; 09456 SDValue CPTmpN11_2; 09457 SDValue CPTmpN11_3; 09458 SDValue CPTmpN11_4; 09459 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09460 SDNode *Result = Emit_18(N, X86::DIVSDrm, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09461 return Result; 09462 } 09463 } 09464 } 09465 } 09466 if ((!Subtarget->hasSSE2())) { 09467 SDValue N0 = N.getOperand(0); 09468 SDValue N1 = N.getOperand(1); 09469 if (N1.getOpcode() == X86ISD::FILD && 09470 N1.hasOneUse() && 09471 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 09472 SDValue Chain1 = N1.getOperand(0); 09473 SDValue N11 = N1.getOperand(1); 09474 SDValue CPTmpN11_0; 09475 SDValue CPTmpN11_1; 09476 SDValue CPTmpN11_2; 09477 SDValue CPTmpN11_3; 09478 SDValue CPTmpN11_4; 09479 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09480 SDValue N12 = N1.getOperand(2); 09481 09482 // Pattern: (fdiv:f64 RFP64:f64:$src1, (X86fild:f64 addr:iPTR:$src2, i16:Other)) 09483 // Emits: (DIV_FpI16m64:f64 RFP64:f64:$src1, addr:iPTR:$src2) 09484 // Pattern complexity = 24 cost = 1 size = 0 09485 if (cast<VTSDNode>(N12)->getVT() == MVT::i16) { 09486 SDNode *Result = Emit_95(N, X86::DIV_FpI16m64, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09487 return Result; 09488 } 09489 09490 // Pattern: (fdiv:f64 RFP64:f64:$src1, (X86fild:f64 addr:iPTR:$src2, i32:Other)) 09491 // Emits: (DIV_FpI32m64:f64 RFP64:f64:$src1, addr:iPTR:$src2) 09492 // Pattern complexity = 24 cost = 1 size = 0 09493 if (cast<VTSDNode>(N12)->getVT() == MVT::i32) { 09494 SDNode *Result = Emit_95(N, X86::DIV_FpI32m64, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09495 return Result; 09496 } 09497 09498 // Pattern: (fdiv:f64 RFP64:f64:$src1, (X86fild:f64 addr:iPTR:$src2, i16:Other)) 09499 // Emits: (DIVR_FpI16m64:f64 RFP64:f64:$src1, addr:iPTR:$src2) 09500 // Pattern complexity = 24 cost = 1 size = 0 09501 if (cast<VTSDNode>(N12)->getVT() == MVT::i16) { 09502 SDNode *Result = Emit_95(N, X86::DIVR_FpI16m64, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09503 return Result; 09504 } 09505 09506 // Pattern: (fdiv:f64 RFP64:f64:$src1, (X86fild:f64 addr:iPTR:$src2, i32:Other)) 09507 // Emits: (DIVR_FpI32m64:f64 RFP64:f64:$src1, addr:iPTR:$src2) 09508 // Pattern complexity = 24 cost = 1 size = 0 09509 if (cast<VTSDNode>(N12)->getVT() == MVT::i32) { 09510 SDNode *Result = Emit_95(N, X86::DIVR_FpI32m64, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09511 return Result; 09512 } 09513 } 09514 } 09515 } 09516 } 09517 09518 // Pattern: (fdiv:f64 RFP64:f64:$src1, RFP64:f64:$src2) 09519 // Emits: (DIV_Fp64:f64 RFP64:f64:$src1, RFP64:f64:$src2) 09520 // Pattern complexity = 3 cost = 1 size = 0 09521 if ((!Subtarget->hasSSE2())) { 09522 SDNode *Result = Emit_15(N, X86::DIV_Fp64, MVT::f64); 09523 return Result; 09524 } 09525 09526 // Pattern: (fdiv:f64 FR64:f64:$src1, FR64:f64:$src2) 09527 // Emits: (DIVSDrr:f64 FR64:f64:$src1, FR64:f64:$src2) 09528 // Pattern complexity = 3 cost = 1 size = 3 09529 if ((Subtarget->hasSSE2())) { 09530 SDNode *Result = Emit_15(N, X86::DIVSDrr, MVT::f64); 09531 return Result; 09532 } 09533 09534 CannotYetSelect(N); 09535 return NULL; 09536 } 09537 09538 SDNode *Select_ISD_FDIV_f80(const SDValue &N) { 09539 if (OptLevel != CodeGenOpt::None) { 09540 SDValue N0 = N.getOperand(0); 09541 SDValue N1 = N.getOperand(1); 09542 if (N1.getOpcode() == ISD::LOAD && 09543 N1.hasOneUse() && 09544 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 09545 SDValue Chain1 = N1.getOperand(0); 09546 if (Predicate_unindexedload(N1.getNode()) && 09547 Predicate_extload(N1.getNode())) { 09548 09549 // Pattern: (fdiv:f80 RFP80:f80:$src1, (ld:f80 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>>) 09550 // Emits: (DIV_Fp80m32:f80 RFP80:f80:$src1, addr:iPTR:$src2) 09551 // Pattern complexity = 25 cost = 1 size = 0 09552 if (Predicate_extloadf32(N1.getNode())) { 09553 SDValue N11 = N1.getOperand(1); 09554 SDValue CPTmpN11_0; 09555 SDValue CPTmpN11_1; 09556 SDValue CPTmpN11_2; 09557 SDValue CPTmpN11_3; 09558 SDValue CPTmpN11_4; 09559 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09560 SDNode *Result = Emit_18(N, X86::DIV_Fp80m32, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09561 return Result; 09562 } 09563 } 09564 09565 // Pattern: (fdiv:f80 RFP80:f80:$src1, (ld:f80 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf64>>) 09566 // Emits: (DIV_Fp80m64:f80 RFP80:f80:$src1, addr:iPTR:$src2) 09567 // Pattern complexity = 25 cost = 1 size = 0 09568 if (Predicate_extloadf64(N1.getNode())) { 09569 SDValue N11 = N1.getOperand(1); 09570 SDValue CPTmpN11_0; 09571 SDValue CPTmpN11_1; 09572 SDValue CPTmpN11_2; 09573 SDValue CPTmpN11_3; 09574 SDValue CPTmpN11_4; 09575 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09576 SDNode *Result = Emit_18(N, X86::DIV_Fp80m64, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09577 return Result; 09578 } 09579 } 09580 09581 // Pattern: (fdiv:f80 RFP80:f80:$src1, (ld:f80 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>>) 09582 // Emits: (DIVR_Fp80m32:f80 RFP80:f80:$src1, addr:iPTR:$src2) 09583 // Pattern complexity = 25 cost = 1 size = 0 09584 if (Predicate_extloadf32(N1.getNode())) { 09585 SDValue N11 = N1.getOperand(1); 09586 SDValue CPTmpN11_0; 09587 SDValue CPTmpN11_1; 09588 SDValue CPTmpN11_2; 09589 SDValue CPTmpN11_3; 09590 SDValue CPTmpN11_4; 09591 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09592 SDNode *Result = Emit_18(N, X86::DIVR_Fp80m32, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09593 return Result; 09594 } 09595 } 09596 09597 // Pattern: (fdiv:f80 RFP80:f80:$src1, (ld:f80 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf64>>) 09598 // Emits: (DIVR_Fp80m64:f80 RFP80:f80:$src1, addr:iPTR:$src2) 09599 // Pattern complexity = 25 cost = 1 size = 0 09600 if (Predicate_extloadf64(N1.getNode())) { 09601 SDValue N11 = N1.getOperand(1); 09602 SDValue CPTmpN11_0; 09603 SDValue CPTmpN11_1; 09604 SDValue CPTmpN11_2; 09605 SDValue CPTmpN11_3; 09606 SDValue CPTmpN11_4; 09607 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09608 SDNode *Result = Emit_18(N, X86::DIVR_Fp80m64, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09609 return Result; 09610 } 09611 } 09612 } 09613 } 09614 if (N1.getOpcode() == X86ISD::FILD && 09615 N1.hasOneUse() && 09616 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 09617 SDValue Chain1 = N1.getOperand(0); 09618 SDValue N11 = N1.getOperand(1); 09619 SDValue CPTmpN11_0; 09620 SDValue CPTmpN11_1; 09621 SDValue CPTmpN11_2; 09622 SDValue CPTmpN11_3; 09623 SDValue CPTmpN11_4; 09624 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09625 SDValue N12 = N1.getOperand(2); 09626 09627 // Pattern: (fdiv:f80 RFP80:f80:$src1, (X86fild:f80 addr:iPTR:$src2, i16:Other)) 09628 // Emits: (DIV_FpI16m80:f80 RFP80:f80:$src1, addr:iPTR:$src2) 09629 // Pattern complexity = 24 cost = 1 size = 0 09630 if (cast<VTSDNode>(N12)->getVT() == MVT::i16) { 09631 SDNode *Result = Emit_95(N, X86::DIV_FpI16m80, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09632 return Result; 09633 } 09634 09635 // Pattern: (fdiv:f80 RFP80:f80:$src1, (X86fild:f80 addr:iPTR:$src2, i32:Other)) 09636 // Emits: (DIV_FpI32m80:f80 RFP80:f80:$src1, addr:iPTR:$src2) 09637 // Pattern complexity = 24 cost = 1 size = 0 09638 if (cast<VTSDNode>(N12)->getVT() == MVT::i32) { 09639 SDNode *Result = Emit_95(N, X86::DIV_FpI32m80, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09640 return Result; 09641 } 09642 09643 // Pattern: (fdiv:f80 RFP80:f80:$src1, (X86fild:f80 addr:iPTR:$src2, i16:Other)) 09644 // Emits: (DIVR_FpI16m80:f80 RFP80:f80:$src1, addr:iPTR:$src2) 09645 // Pattern complexity = 24 cost = 1 size = 0 09646 if (cast<VTSDNode>(N12)->getVT() == MVT::i16) { 09647 SDNode *Result = Emit_95(N, X86::DIVR_FpI16m80, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09648 return Result; 09649 } 09650 09651 // Pattern: (fdiv:f80 RFP80:f80:$src1, (X86fild:f80 addr:iPTR:$src2, i32:Other)) 09652 // Emits: (DIVR_FpI32m80:f80 RFP80:f80:$src1, addr:iPTR:$src2) 09653 // Pattern complexity = 24 cost = 1 size = 0 09654 if (cast<VTSDNode>(N12)->getVT() == MVT::i32) { 09655 SDNode *Result = Emit_95(N, X86::DIVR_FpI32m80, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09656 return Result; 09657 } 09658 } 09659 } 09660 } 09661 09662 // Pattern: (fdiv:f80 RFP80:f80:$src1, RFP80:f80:$src2) 09663 // Emits: (DIV_Fp80:f80 RFP80:f80:$src1, RFP80:f80:$src2) 09664 // Pattern complexity = 3 cost = 1 size = 0 09665 SDNode *Result = Emit_15(N, X86::DIV_Fp80, MVT::f80); 09666 return Result; 09667 } 09668 09669 SDNode *Select_ISD_FDIV_v4f32(const SDValue &N) { 09670 09671 // Pattern: (fdiv:v4f32 VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 09672 // Emits: (DIVPSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 09673 // Pattern complexity = 25 cost = 1 size = 3 09674 if (OptLevel != CodeGenOpt::None && 09675 (Subtarget->hasSSE1())) { 09676 SDValue N0 = N.getOperand(0); 09677 SDValue N1 = N.getOperand(1); 09678 if (N1.getOpcode() == ISD::LOAD && 09679 N1.hasOneUse() && 09680 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 09681 SDValue Chain1 = N1.getOperand(0); 09682 if (Predicate_unindexedload(N1.getNode()) && 09683 Predicate_load(N1.getNode()) && 09684 Predicate_memop(N1.getNode())) { 09685 SDValue N11 = N1.getOperand(1); 09686 SDValue CPTmpN11_0; 09687 SDValue CPTmpN11_1; 09688 SDValue CPTmpN11_2; 09689 SDValue CPTmpN11_3; 09690 SDValue CPTmpN11_4; 09691 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09692 SDNode *Result = Emit_18(N, X86::DIVPSrm, MVT::v4f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09693 return Result; 09694 } 09695 } 09696 } 09697 } 09698 09699 // Pattern: (fdiv:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 09700 // Emits: (DIVPSrr:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 09701 // Pattern complexity = 3 cost = 1 size = 3 09702 if ((Subtarget->hasSSE1())) { 09703 SDNode *Result = Emit_15(N, X86::DIVPSrr, MVT::v4f32); 09704 return Result; 09705 } 09706 09707 CannotYetSelect(N); 09708 return NULL; 09709 } 09710 09711 SDNode *Select_ISD_FDIV_v2f64(const SDValue &N) { 09712 09713 // Pattern: (fdiv:v2f64 VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 09714 // Emits: (DIVPDrm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 09715 // Pattern complexity = 25 cost = 1 size = 3 09716 if (OptLevel != CodeGenOpt::None && 09717 (Subtarget->hasSSE2())) { 09718 SDValue N0 = N.getOperand(0); 09719 SDValue N1 = N.getOperand(1); 09720 if (N1.getOpcode() == ISD::LOAD && 09721 N1.hasOneUse() && 09722 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 09723 SDValue Chain1 = N1.getOperand(0); 09724 if (Predicate_unindexedload(N1.getNode()) && 09725 Predicate_load(N1.getNode()) && 09726 Predicate_memop(N1.getNode())) { 09727 SDValue N11 = N1.getOperand(1); 09728 SDValue CPTmpN11_0; 09729 SDValue CPTmpN11_1; 09730 SDValue CPTmpN11_2; 09731 SDValue CPTmpN11_3; 09732 SDValue CPTmpN11_4; 09733 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09734 SDNode *Result = Emit_18(N, X86::DIVPDrm, MVT::v2f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09735 return Result; 09736 } 09737 } 09738 } 09739 } 09740 09741 // Pattern: (fdiv:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 09742 // Emits: (DIVPDrr:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 09743 // Pattern complexity = 3 cost = 1 size = 3 09744 if ((Subtarget->hasSSE2())) { 09745 SDNode *Result = Emit_15(N, X86::DIVPDrr, MVT::v2f64); 09746 return Result; 09747 } 09748 09749 CannotYetSelect(N); 09750 return NULL; 09751 } 09752 09753 SDNode *Select_ISD_FMUL_f32(const SDValue &N) { 09754 if (OptLevel != CodeGenOpt::None) { 09755 if ((!Subtarget->hasSSE1())) { 09756 SDValue N0 = N.getOperand(0); 09757 09758 // Pattern: (fmul:f32 RFP32:f32:$src1, (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf32>>) 09759 // Emits: (MUL_Fp32m:f32 RFP32:f32:$src1, addr:iPTR:$src2) 09760 // Pattern complexity = 25 cost = 1 size = 0 09761 { 09762 SDValue N1 = N.getOperand(1); 09763 if (N1.getOpcode() == ISD::LOAD && 09764 N1.hasOneUse() && 09765 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 09766 SDValue Chain1 = N1.getOperand(0); 09767 if (Predicate_unindexedload(N1.getNode()) && 09768 Predicate_load(N1.getNode()) && 09769 Predicate_loadf32(N1.getNode())) { 09770 SDValue N11 = N1.getOperand(1); 09771 SDValue CPTmpN11_0; 09772 SDValue CPTmpN11_1; 09773 SDValue CPTmpN11_2; 09774 SDValue CPTmpN11_3; 09775 SDValue CPTmpN11_4; 09776 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09777 SDNode *Result = Emit_18(N, X86::MUL_Fp32m, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09778 return Result; 09779 } 09780 } 09781 } 09782 } 09783 09784 // Pattern: (fmul:f32 (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf32>>, RFP32:f32:$src1) 09785 // Emits: (MUL_Fp32m:f32 RFP32:f32:$src1, addr:iPTR:$src2) 09786 // Pattern complexity = 25 cost = 1 size = 0 09787 if (N0.getOpcode() == ISD::LOAD && 09788 N0.hasOneUse() && 09789 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 09790 SDValue Chain0 = N0.getOperand(0); 09791 if (Predicate_unindexedload(N0.getNode()) && 09792 Predicate_load(N0.getNode()) && 09793 Predicate_loadf32(N0.getNode())) { 09794 SDValue N01 = N0.getOperand(1); 09795 SDValue CPTmpN01_0; 09796 SDValue CPTmpN01_1; 09797 SDValue CPTmpN01_2; 09798 SDValue CPTmpN01_3; 09799 SDValue CPTmpN01_4; 09800 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 09801 SDNode *Result = Emit_19(N, X86::MUL_Fp32m, MVT::f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 09802 return Result; 09803 } 09804 } 09805 } 09806 } 09807 if ((Subtarget->hasSSE1())) { 09808 SDValue N0 = N.getOperand(0); 09809 09810 // Pattern: (fmul:f32 FR32:f32:$src1, (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 09811 // Emits: (MULSSrm:f32 FR32:f32:$src1, addr:iPTR:$src2) 09812 // Pattern complexity = 25 cost = 1 size = 3 09813 { 09814 SDValue N1 = N.getOperand(1); 09815 if (N1.getOpcode() == ISD::LOAD && 09816 N1.hasOneUse() && 09817 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 09818 SDValue Chain1 = N1.getOperand(0); 09819 if (Predicate_unindexedload(N1.getNode()) && 09820 Predicate_load(N1.getNode())) { 09821 SDValue N11 = N1.getOperand(1); 09822 SDValue CPTmpN11_0; 09823 SDValue CPTmpN11_1; 09824 SDValue CPTmpN11_2; 09825 SDValue CPTmpN11_3; 09826 SDValue CPTmpN11_4; 09827 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09828 SDNode *Result = Emit_18(N, X86::MULSSrm, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09829 return Result; 09830 } 09831 } 09832 } 09833 } 09834 09835 // Pattern: (fmul:f32 (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, FR32:f32:$src1) 09836 // Emits: (MULSSrm:f32 FR32:f32:$src1, addr:iPTR:$src2) 09837 // Pattern complexity = 25 cost = 1 size = 3 09838 if (N0.getOpcode() == ISD::LOAD && 09839 N0.hasOneUse() && 09840 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 09841 SDValue Chain0 = N0.getOperand(0); 09842 if (Predicate_unindexedload(N0.getNode()) && 09843 Predicate_load(N0.getNode())) { 09844 SDValue N01 = N0.getOperand(1); 09845 SDValue CPTmpN01_0; 09846 SDValue CPTmpN01_1; 09847 SDValue CPTmpN01_2; 09848 SDValue CPTmpN01_3; 09849 SDValue CPTmpN01_4; 09850 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 09851 SDNode *Result = Emit_19(N, X86::MULSSrm, MVT::f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 09852 return Result; 09853 } 09854 } 09855 } 09856 } 09857 if ((!Subtarget->hasSSE1())) { 09858 SDValue N0 = N.getOperand(0); 09859 { 09860 SDValue N1 = N.getOperand(1); 09861 if (N1.getOpcode() == X86ISD::FILD && 09862 N1.hasOneUse() && 09863 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 09864 SDValue Chain1 = N1.getOperand(0); 09865 SDValue N11 = N1.getOperand(1); 09866 SDValue CPTmpN11_0; 09867 SDValue CPTmpN11_1; 09868 SDValue CPTmpN11_2; 09869 SDValue CPTmpN11_3; 09870 SDValue CPTmpN11_4; 09871 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09872 SDValue N12 = N1.getOperand(2); 09873 09874 // Pattern: (fmul:f32 RFP32:f32:$src1, (X86fild:f32 addr:iPTR:$src2, i16:Other)) 09875 // Emits: (MUL_FpI16m32:f32 RFP32:f32:$src1, addr:iPTR:$src2) 09876 // Pattern complexity = 24 cost = 1 size = 0 09877 if (cast<VTSDNode>(N12)->getVT() == MVT::i16) { 09878 SDNode *Result = Emit_95(N, X86::MUL_FpI16m32, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09879 return Result; 09880 } 09881 09882 // Pattern: (fmul:f32 RFP32:f32:$src1, (X86fild:f32 addr:iPTR:$src2, i32:Other)) 09883 // Emits: (MUL_FpI32m32:f32 RFP32:f32:$src1, addr:iPTR:$src2) 09884 // Pattern complexity = 24 cost = 1 size = 0 09885 if (cast<VTSDNode>(N12)->getVT() == MVT::i32) { 09886 SDNode *Result = Emit_95(N, X86::MUL_FpI32m32, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09887 return Result; 09888 } 09889 } 09890 } 09891 } 09892 if (N0.getOpcode() == X86ISD::FILD && 09893 N0.hasOneUse() && 09894 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 09895 SDValue Chain0 = N0.getOperand(0); 09896 SDValue N01 = N0.getOperand(1); 09897 SDValue CPTmpN01_0; 09898 SDValue CPTmpN01_1; 09899 SDValue CPTmpN01_2; 09900 SDValue CPTmpN01_3; 09901 SDValue CPTmpN01_4; 09902 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 09903 SDValue N02 = N0.getOperand(2); 09904 09905 // Pattern: (fmul:f32 (X86fild:f32 addr:iPTR:$src2, i16:Other), RFP32:f32:$src1) 09906 // Emits: (MUL_FpI16m32:f32 RFP32:f32:$src1, addr:iPTR:$src2) 09907 // Pattern complexity = 24 cost = 1 size = 0 09908 if (cast<VTSDNode>(N02)->getVT() == MVT::i16) { 09909 SDNode *Result = Emit_96(N, X86::MUL_FpI16m32, MVT::f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 09910 return Result; 09911 } 09912 09913 // Pattern: (fmul:f32 (X86fild:f32 addr:iPTR:$src2, i32:Other), RFP32:f32:$src1) 09914 // Emits: (MUL_FpI32m32:f32 RFP32:f32:$src1, addr:iPTR:$src2) 09915 // Pattern complexity = 24 cost = 1 size = 0 09916 if (cast<VTSDNode>(N02)->getVT() == MVT::i32) { 09917 SDNode *Result = Emit_96(N, X86::MUL_FpI32m32, MVT::f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 09918 return Result; 09919 } 09920 } 09921 } 09922 } 09923 } 09924 09925 // Pattern: (fmul:f32 RFP32:f32:$src1, RFP32:f32:$src2) 09926 // Emits: (MUL_Fp32:f32 RFP32:f32:$src1, RFP32:f32:$src2) 09927 // Pattern complexity = 3 cost = 1 size = 0 09928 if ((!Subtarget->hasSSE1())) { 09929 SDNode *Result = Emit_15(N, X86::MUL_Fp32, MVT::f32); 09930 return Result; 09931 } 09932 09933 // Pattern: (fmul:f32 FR32:f32:$src1, FR32:f32:$src2) 09934 // Emits: (MULSSrr:f32 FR32:f32:$src1, FR32:f32:$src2) 09935 // Pattern complexity = 3 cost = 1 size = 3 09936 if ((Subtarget->hasSSE1())) { 09937 SDNode *Result = Emit_15(N, X86::MULSSrr, MVT::f32); 09938 return Result; 09939 } 09940 09941 CannotYetSelect(N); 09942 return NULL; 09943 } 09944 09945 SDNode *Select_ISD_FMUL_f64(const SDValue &N) { 09946 if (OptLevel != CodeGenOpt::None) { 09947 if ((!Subtarget->hasSSE2())) { 09948 SDValue N0 = N.getOperand(0); 09949 { 09950 SDValue N1 = N.getOperand(1); 09951 if (N1.getOpcode() == ISD::LOAD && 09952 N1.hasOneUse() && 09953 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 09954 SDValue Chain1 = N1.getOperand(0); 09955 if (Predicate_unindexedload(N1.getNode())) { 09956 09957 // Pattern: (fmul:f64 RFP64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>) 09958 // Emits: (MUL_Fp64m:f64 RFP64:f64:$src1, addr:iPTR:$src2) 09959 // Pattern complexity = 25 cost = 1 size = 0 09960 if (Predicate_load(N1.getNode()) && 09961 Predicate_loadf64(N1.getNode())) { 09962 SDValue N11 = N1.getOperand(1); 09963 SDValue CPTmpN11_0; 09964 SDValue CPTmpN11_1; 09965 SDValue CPTmpN11_2; 09966 SDValue CPTmpN11_3; 09967 SDValue CPTmpN11_4; 09968 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09969 SDNode *Result = Emit_18(N, X86::MUL_Fp64m, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09970 return Result; 09971 } 09972 } 09973 09974 // Pattern: (fmul:f64 RFP64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>>) 09975 // Emits: (MUL_Fp64m32:f64 RFP64:f64:$src1, addr:iPTR:$src2) 09976 // Pattern complexity = 25 cost = 1 size = 0 09977 if (Predicate_extload(N1.getNode()) && 09978 Predicate_extloadf32(N1.getNode())) { 09979 SDValue N11 = N1.getOperand(1); 09980 SDValue CPTmpN11_0; 09981 SDValue CPTmpN11_1; 09982 SDValue CPTmpN11_2; 09983 SDValue CPTmpN11_3; 09984 SDValue CPTmpN11_4; 09985 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 09986 SDNode *Result = Emit_18(N, X86::MUL_Fp64m32, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 09987 return Result; 09988 } 09989 } 09990 } 09991 } 09992 } 09993 if (N0.getOpcode() == ISD::LOAD && 09994 N0.hasOneUse() && 09995 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 09996 SDValue Chain0 = N0.getOperand(0); 09997 if (Predicate_unindexedload(N0.getNode())) { 09998 09999 // Pattern: (fmul:f64 (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>, RFP64:f64:$src1) 10000 // Emits: (MUL_Fp64m:f64 RFP64:f64:$src1, addr:iPTR:$src2) 10001 // Pattern complexity = 25 cost = 1 size = 0 10002 if (Predicate_load(N0.getNode()) && 10003 Predicate_loadf64(N0.getNode())) { 10004 SDValue N01 = N0.getOperand(1); 10005 SDValue CPTmpN01_0; 10006 SDValue CPTmpN01_1; 10007 SDValue CPTmpN01_2; 10008 SDValue CPTmpN01_3; 10009 SDValue CPTmpN01_4; 10010 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 10011 SDNode *Result = Emit_19(N, X86::MUL_Fp64m, MVT::f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10012 return Result; 10013 } 10014 } 10015 10016 // Pattern: (fmul:f64 (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>>, RFP64:f64:$src1) 10017 // Emits: (MUL_Fp64m32:f64 RFP64:f64:$src1, addr:iPTR:$src2) 10018 // Pattern complexity = 25 cost = 1 size = 0 10019 if (Predicate_extload(N0.getNode()) && 10020 Predicate_extloadf32(N0.getNode())) { 10021 SDValue N01 = N0.getOperand(1); 10022 SDValue CPTmpN01_0; 10023 SDValue CPTmpN01_1; 10024 SDValue CPTmpN01_2; 10025 SDValue CPTmpN01_3; 10026 SDValue CPTmpN01_4; 10027 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 10028 SDNode *Result = Emit_19(N, X86::MUL_Fp64m32, MVT::f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10029 return Result; 10030 } 10031 } 10032 } 10033 } 10034 } 10035 if ((Subtarget->hasSSE2())) { 10036 SDValue N0 = N.getOperand(0); 10037 10038 // Pattern: (fmul:f64 FR64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 10039 // Emits: (MULSDrm:f64 FR64:f64:$src1, addr:iPTR:$src2) 10040 // Pattern complexity = 25 cost = 1 size = 3 10041 { 10042 SDValue N1 = N.getOperand(1); 10043 if (N1.getOpcode() == ISD::LOAD && 10044 N1.hasOneUse() && 10045 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 10046 SDValue Chain1 = N1.getOperand(0); 10047 if (Predicate_unindexedload(N1.getNode()) && 10048 Predicate_load(N1.getNode())) { 10049 SDValue N11 = N1.getOperand(1); 10050 SDValue CPTmpN11_0; 10051 SDValue CPTmpN11_1; 10052 SDValue CPTmpN11_2; 10053 SDValue CPTmpN11_3; 10054 SDValue CPTmpN11_4; 10055 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 10056 SDNode *Result = Emit_18(N, X86::MULSDrm, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 10057 return Result; 10058 } 10059 } 10060 } 10061 } 10062 10063 // Pattern: (fmul:f64 (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, FR64:f64:$src1) 10064 // Emits: (MULSDrm:f64 FR64:f64:$src1, addr:iPTR:$src2) 10065 // Pattern complexity = 25 cost = 1 size = 3 10066 if (N0.getOpcode() == ISD::LOAD && 10067 N0.hasOneUse() && 10068 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 10069 SDValue Chain0 = N0.getOperand(0); 10070 if (Predicate_unindexedload(N0.getNode()) && 10071 Predicate_load(N0.getNode())) { 10072 SDValue N01 = N0.getOperand(1); 10073 SDValue CPTmpN01_0; 10074 SDValue CPTmpN01_1; 10075 SDValue CPTmpN01_2; 10076 SDValue CPTmpN01_3; 10077 SDValue CPTmpN01_4; 10078 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 10079 SDNode *Result = Emit_19(N, X86::MULSDrm, MVT::f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10080 return Result; 10081 } 10082 } 10083 } 10084 } 10085 if ((!Subtarget->hasSSE2())) { 10086 SDValue N0 = N.getOperand(0); 10087 { 10088 SDValue N1 = N.getOperand(1); 10089 if (N1.getOpcode() == X86ISD::FILD && 10090 N1.hasOneUse() && 10091 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 10092 SDValue Chain1 = N1.getOperand(0); 10093 SDValue N11 = N1.getOperand(1); 10094 SDValue CPTmpN11_0; 10095 SDValue CPTmpN11_1; 10096 SDValue CPTmpN11_2; 10097 SDValue CPTmpN11_3; 10098 SDValue CPTmpN11_4; 10099 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 10100 SDValue N12 = N1.getOperand(2); 10101 10102 // Pattern: (fmul:f64 RFP64:f64:$src1, (X86fild:f64 addr:iPTR:$src2, i16:Other)) 10103 // Emits: (MUL_FpI16m64:f64 RFP64:f64:$src1, addr:iPTR:$src2) 10104 // Pattern complexity = 24 cost = 1 size = 0 10105 if (cast<VTSDNode>(N12)->getVT() == MVT::i16) { 10106 SDNode *Result = Emit_95(N, X86::MUL_FpI16m64, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 10107 return Result; 10108 } 10109 10110 // Pattern: (fmul:f64 RFP64:f64:$src1, (X86fild:f64 addr:iPTR:$src2, i32:Other)) 10111 // Emits: (MUL_FpI32m64:f64 RFP64:f64:$src1, addr:iPTR:$src2) 10112 // Pattern complexity = 24 cost = 1 size = 0 10113 if (cast<VTSDNode>(N12)->getVT() == MVT::i32) { 10114 SDNode *Result = Emit_95(N, X86::MUL_FpI32m64, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 10115 return Result; 10116 } 10117 } 10118 } 10119 } 10120 if (N0.getOpcode() == X86ISD::FILD && 10121 N0.hasOneUse() && 10122 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 10123 SDValue Chain0 = N0.getOperand(0); 10124 SDValue N01 = N0.getOperand(1); 10125 SDValue CPTmpN01_0; 10126 SDValue CPTmpN01_1; 10127 SDValue CPTmpN01_2; 10128 SDValue CPTmpN01_3; 10129 SDValue CPTmpN01_4; 10130 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 10131 SDValue N02 = N0.getOperand(2); 10132 10133 // Pattern: (fmul:f64 (X86fild:f64 addr:iPTR:$src2, i16:Other), RFP64:f64:$src1) 10134 // Emits: (MUL_FpI16m64:f64 RFP64:f64:$src1, addr:iPTR:$src2) 10135 // Pattern complexity = 24 cost = 1 size = 0 10136 if (cast<VTSDNode>(N02)->getVT() == MVT::i16) { 10137 SDNode *Result = Emit_96(N, X86::MUL_FpI16m64, MVT::f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10138 return Result; 10139 } 10140 10141 // Pattern: (fmul:f64 (X86fild:f64 addr:iPTR:$src2, i32:Other), RFP64:f64:$src1) 10142 // Emits: (MUL_FpI32m64:f64 RFP64:f64:$src1, addr:iPTR:$src2) 10143 // Pattern complexity = 24 cost = 1 size = 0 10144 if (cast<VTSDNode>(N02)->getVT() == MVT::i32) { 10145 SDNode *Result = Emit_96(N, X86::MUL_FpI32m64, MVT::f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10146 return Result; 10147 } 10148 } 10149 } 10150 } 10151 } 10152 10153 // Pattern: (fmul:f64 RFP64:f64:$src1, RFP64:f64:$src2) 10154 // Emits: (MUL_Fp64:f64 RFP64:f64:$src1, RFP64:f64:$src2) 10155 // Pattern complexity = 3 cost = 1 size = 0 10156 if ((!Subtarget->hasSSE2())) { 10157 SDNode *Result = Emit_15(N, X86::MUL_Fp64, MVT::f64); 10158 return Result; 10159 } 10160 10161 // Pattern: (fmul:f64 FR64:f64:$src1, FR64:f64:$src2) 10162 // Emits: (MULSDrr:f64 FR64:f64:$src1, FR64:f64:$src2) 10163 // Pattern complexity = 3 cost = 1 size = 3 10164 if ((Subtarget->hasSSE2())) { 10165 SDNode *Result = Emit_15(N, X86::MULSDrr, MVT::f64); 10166 return Result; 10167 } 10168 10169 CannotYetSelect(N); 10170 return NULL; 10171 } 10172 10173 SDNode *Select_ISD_FMUL_f80(const SDValue &N) { 10174 if (OptLevel != CodeGenOpt::None) { 10175 SDValue N0 = N.getOperand(0); 10176 { 10177 SDValue N1 = N.getOperand(1); 10178 if (N1.getOpcode() == ISD::LOAD && 10179 N1.hasOneUse() && 10180 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 10181 SDValue Chain1 = N1.getOperand(0); 10182 if (Predicate_unindexedload(N1.getNode()) && 10183 Predicate_extload(N1.getNode())) { 10184 10185 // Pattern: (fmul:f80 RFP80:f80:$src1, (ld:f80 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>>) 10186 // Emits: (MUL_Fp80m32:f80 RFP80:f80:$src1, addr:iPTR:$src2) 10187 // Pattern complexity = 25 cost = 1 size = 0 10188 if (Predicate_extloadf32(N1.getNode())) { 10189 SDValue N11 = N1.getOperand(1); 10190 SDValue CPTmpN11_0; 10191 SDValue CPTmpN11_1; 10192 SDValue CPTmpN11_2; 10193 SDValue CPTmpN11_3; 10194 SDValue CPTmpN11_4; 10195 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 10196 SDNode *Result = Emit_18(N, X86::MUL_Fp80m32, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 10197 return Result; 10198 } 10199 } 10200 10201 // Pattern: (fmul:f80 RFP80:f80:$src1, (ld:f80 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf64>>) 10202 // Emits: (MUL_Fp80m64:f80 RFP80:f80:$src1, addr:iPTR:$src2) 10203 // Pattern complexity = 25 cost = 1 size = 0 10204 if (Predicate_extloadf64(N1.getNode())) { 10205 SDValue N11 = N1.getOperand(1); 10206 SDValue CPTmpN11_0; 10207 SDValue CPTmpN11_1; 10208 SDValue CPTmpN11_2; 10209 SDValue CPTmpN11_3; 10210 SDValue CPTmpN11_4; 10211 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 10212 SDNode *Result = Emit_18(N, X86::MUL_Fp80m64, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 10213 return Result; 10214 } 10215 } 10216 } 10217 } 10218 } 10219 if (N0.getOpcode() == ISD::LOAD && 10220 N0.hasOneUse() && 10221 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 10222 SDValue Chain0 = N0.getOperand(0); 10223 if (Predicate_unindexedload(N0.getNode()) && 10224 Predicate_extload(N0.getNode())) { 10225 10226 // Pattern: (fmul:f80 (ld:f80 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>>, RFP80:f80:$src1) 10227 // Emits: (MUL_Fp80m32:f80 RFP80:f80:$src1, addr:iPTR:$src2) 10228 // Pattern complexity = 25 cost = 1 size = 0 10229 if (Predicate_extloadf32(N0.getNode())) { 10230 SDValue N01 = N0.getOperand(1); 10231 SDValue CPTmpN01_0; 10232 SDValue CPTmpN01_1; 10233 SDValue CPTmpN01_2; 10234 SDValue CPTmpN01_3; 10235 SDValue CPTmpN01_4; 10236 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 10237 SDNode *Result = Emit_19(N, X86::MUL_Fp80m32, MVT::f80, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10238 return Result; 10239 } 10240 } 10241 10242 // Pattern: (fmul:f80 (ld:f80 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf64>>, RFP80:f80:$src1) 10243 // Emits: (MUL_Fp80m64:f80 RFP80:f80:$src1, addr:iPTR:$src2) 10244 // Pattern complexity = 25 cost = 1 size = 0 10245 if (Predicate_extloadf64(N0.getNode())) { 10246 SDValue N01 = N0.getOperand(1); 10247 SDValue CPTmpN01_0; 10248 SDValue CPTmpN01_1; 10249 SDValue CPTmpN01_2; 10250 SDValue CPTmpN01_3; 10251 SDValue CPTmpN01_4; 10252 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 10253 SDNode *Result = Emit_19(N, X86::MUL_Fp80m64, MVT::f80, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10254 return Result; 10255 } 10256 } 10257 } 10258 } 10259 { 10260 SDValue N1 = N.getOperand(1); 10261 if (N1.getOpcode() == X86ISD::FILD && 10262 N1.hasOneUse() && 10263 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 10264 SDValue Chain1 = N1.getOperand(0); 10265 SDValue N11 = N1.getOperand(1); 10266 SDValue CPTmpN11_0; 10267 SDValue CPTmpN11_1; 10268 SDValue CPTmpN11_2; 10269 SDValue CPTmpN11_3; 10270 SDValue CPTmpN11_4; 10271 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 10272 SDValue N12 = N1.getOperand(2); 10273 10274 // Pattern: (fmul:f80 RFP80:f80:$src1, (X86fild:f80 addr:iPTR:$src2, i16:Other)) 10275 // Emits: (MUL_FpI16m80:f80 RFP80:f80:$src1, addr:iPTR:$src2) 10276 // Pattern complexity = 24 cost = 1 size = 0 10277 if (cast<VTSDNode>(N12)->getVT() == MVT::i16) { 10278 SDNode *Result = Emit_95(N, X86::MUL_FpI16m80, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 10279 return Result; 10280 } 10281 10282 // Pattern: (fmul:f80 RFP80:f80:$src1, (X86fild:f80 addr:iPTR:$src2, i32:Other)) 10283 // Emits: (MUL_FpI32m80:f80 RFP80:f80:$src1, addr:iPTR:$src2) 10284 // Pattern complexity = 24 cost = 1 size = 0 10285 if (cast<VTSDNode>(N12)->getVT() == MVT::i32) { 10286 SDNode *Result = Emit_95(N, X86::MUL_FpI32m80, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 10287 return Result; 10288 } 10289 } 10290 } 10291 } 10292 if (N0.getOpcode() == X86ISD::FILD && 10293 N0.hasOneUse() && 10294 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 10295 SDValue Chain0 = N0.getOperand(0); 10296 SDValue N01 = N0.getOperand(1); 10297 SDValue CPTmpN01_0; 10298 SDValue CPTmpN01_1; 10299 SDValue CPTmpN01_2; 10300 SDValue CPTmpN01_3; 10301 SDValue CPTmpN01_4; 10302 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 10303 SDValue N02 = N0.getOperand(2); 10304 10305 // Pattern: (fmul:f80 (X86fild:f80 addr:iPTR:$src2, i16:Other), RFP80:f80:$src1) 10306 // Emits: (MUL_FpI16m80:f80 RFP80:f80:$src1, addr:iPTR:$src2) 10307 // Pattern complexity = 24 cost = 1 size = 0 10308 if (cast<VTSDNode>(N02)->getVT() == MVT::i16) { 10309 SDNode *Result = Emit_96(N, X86::MUL_FpI16m80, MVT::f80, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10310 return Result; 10311 } 10312 10313 // Pattern: (fmul:f80 (X86fild:f80 addr:iPTR:$src2, i32:Other), RFP80:f80:$src1) 10314 // Emits: (MUL_FpI32m80:f80 RFP80:f80:$src1, addr:iPTR:$src2) 10315 // Pattern complexity = 24 cost = 1 size = 0 10316 if (cast<VTSDNode>(N02)->getVT() == MVT::i32) { 10317 SDNode *Result = Emit_96(N, X86::MUL_FpI32m80, MVT::f80, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10318 return Result; 10319 } 10320 } 10321 } 10322 } 10323 10324 // Pattern: (fmul:f80 RFP80:f80:$src1, RFP80:f80:$src2) 10325 // Emits: (MUL_Fp80:f80 RFP80:f80:$src1, RFP80:f80:$src2) 10326 // Pattern complexity = 3 cost = 1 size = 0 10327 SDNode *Result = Emit_15(N, X86::MUL_Fp80, MVT::f80); 10328 return Result; 10329 } 10330 10331 SDNode *Select_ISD_FMUL_v4f32(const SDValue &N) { 10332 if (OptLevel != CodeGenOpt::None && 10333 (Subtarget->hasSSE1())) { 10334 SDValue N0 = N.getOperand(0); 10335 10336 // Pattern: (fmul:v4f32 VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 10337 // Emits: (MULPSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 10338 // Pattern complexity = 25 cost = 1 size = 3 10339 { 10340 SDValue N1 = N.getOperand(1); 10341 if (N1.getOpcode() == ISD::LOAD && 10342 N1.hasOneUse() && 10343 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 10344 SDValue Chain1 = N1.getOperand(0); 10345 if (Predicate_unindexedload(N1.getNode()) && 10346 Predicate_load(N1.getNode()) && 10347 Predicate_memop(N1.getNode())) { 10348 SDValue N11 = N1.getOperand(1); 10349 SDValue CPTmpN11_0; 10350 SDValue CPTmpN11_1; 10351 SDValue CPTmpN11_2; 10352 SDValue CPTmpN11_3; 10353 SDValue CPTmpN11_4; 10354 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 10355 SDNode *Result = Emit_18(N, X86::MULPSrm, MVT::v4f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 10356 return Result; 10357 } 10358 } 10359 } 10360 } 10361 10362 // Pattern: (fmul:v4f32 (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, VR128:v4f32:$src1) 10363 // Emits: (MULPSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 10364 // Pattern complexity = 25 cost = 1 size = 3 10365 if (N0.getOpcode() == ISD::LOAD && 10366 N0.hasOneUse() && 10367 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 10368 SDValue Chain0 = N0.getOperand(0); 10369 if (Predicate_unindexedload(N0.getNode()) && 10370 Predicate_load(N0.getNode()) && 10371 Predicate_memop(N0.getNode())) { 10372 SDValue N01 = N0.getOperand(1); 10373 SDValue CPTmpN01_0; 10374 SDValue CPTmpN01_1; 10375 SDValue CPTmpN01_2; 10376 SDValue CPTmpN01_3; 10377 SDValue CPTmpN01_4; 10378 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 10379 SDNode *Result = Emit_19(N, X86::MULPSrm, MVT::v4f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10380 return Result; 10381 } 10382 } 10383 } 10384 } 10385 10386 // Pattern: (fmul:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 10387 // Emits: (MULPSrr:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 10388 // Pattern complexity = 3 cost = 1 size = 3 10389 if ((Subtarget->hasSSE1())) { 10390 SDNode *Result = Emit_15(N, X86::MULPSrr, MVT::v4f32); 10391 return Result; 10392 } 10393 10394 CannotYetSelect(N); 10395 return NULL; 10396 } 10397 10398 SDNode *Select_ISD_FMUL_v2f64(const SDValue &N) { 10399 if (OptLevel != CodeGenOpt::None && 10400 (Subtarget->hasSSE2())) { 10401 SDValue N0 = N.getOperand(0); 10402 10403 // Pattern: (fmul:v2f64 VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 10404 // Emits: (MULPDrm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 10405 // Pattern complexity = 25 cost = 1 size = 3 10406 { 10407 SDValue N1 = N.getOperand(1); 10408 if (N1.getOpcode() == ISD::LOAD && 10409 N1.hasOneUse() && 10410 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 10411 SDValue Chain1 = N1.getOperand(0); 10412 if (Predicate_unindexedload(N1.getNode()) && 10413 Predicate_load(N1.getNode()) && 10414 Predicate_memop(N1.getNode())) { 10415 SDValue N11 = N1.getOperand(1); 10416 SDValue CPTmpN11_0; 10417 SDValue CPTmpN11_1; 10418 SDValue CPTmpN11_2; 10419 SDValue CPTmpN11_3; 10420 SDValue CPTmpN11_4; 10421 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 10422 SDNode *Result = Emit_18(N, X86::MULPDrm, MVT::v2f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 10423 return Result; 10424 } 10425 } 10426 } 10427 } 10428 10429 // Pattern: (fmul:v2f64 (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, VR128:v2f64:$src1) 10430 // Emits: (MULPDrm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 10431 // Pattern complexity = 25 cost = 1 size = 3 10432 if (N0.getOpcode() == ISD::LOAD && 10433 N0.hasOneUse() && 10434 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 10435 SDValue Chain0 = N0.getOperand(0); 10436 if (Predicate_unindexedload(N0.getNode()) && 10437 Predicate_load(N0.getNode()) && 10438 Predicate_memop(N0.getNode())) { 10439 SDValue N01 = N0.getOperand(1); 10440 SDValue CPTmpN01_0; 10441 SDValue CPTmpN01_1; 10442 SDValue CPTmpN01_2; 10443 SDValue CPTmpN01_3; 10444 SDValue CPTmpN01_4; 10445 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 10446 SDNode *Result = Emit_19(N, X86::MULPDrm, MVT::v2f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10447 return Result; 10448 } 10449 } 10450 } 10451 } 10452 10453 // Pattern: (fmul:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 10454 // Emits: (MULPDrr:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 10455 // Pattern complexity = 3 cost = 1 size = 3 10456 if ((Subtarget->hasSSE2())) { 10457 SDNode *Result = Emit_15(N, X86::MULPDrr, MVT::v2f64); 10458 return Result; 10459 } 10460 10461 CannotYetSelect(N); 10462 return NULL; 10463 } 10464 10465 SDNode *Select_ISD_FNEG_f32(const SDValue &N) { 10466 if ((!Subtarget->hasSSE1())) { 10467 SDNode *Result = Emit_71(N, X86::CHS_Fp32, MVT::f32); 10468 return Result; 10469 } 10470 10471 CannotYetSelect(N); 10472 return NULL; 10473 } 10474 10475 SDNode *Select_ISD_FNEG_f64(const SDValue &N) { 10476 if ((!Subtarget->hasSSE2())) { 10477 SDNode *Result = Emit_71(N, X86::CHS_Fp64, MVT::f64); 10478 return Result; 10479 } 10480 10481 CannotYetSelect(N); 10482 return NULL; 10483 } 10484 10485 SDNode *Select_ISD_FNEG_f80(const SDValue &N) { 10486 SDNode *Result = Emit_71(N, X86::CHS_Fp80, MVT::f80); 10487 return Result; 10488 } 10489 10490 SDNode *Select_ISD_FP_EXTEND_f64(const SDValue &N) { 10491 10492 // Pattern: (fextend:f64 (ld:f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf32>>) 10493 // Emits: (CVTSS2SDrm:f64 addr:iPTR:$src) 10494 // Pattern complexity = 25 cost = 1 size = 3 10495 if (OptLevel != CodeGenOpt::None && 10496 (Subtarget->hasSSE2())) { 10497 SDValue N0 = N.getOperand(0); 10498 if (N0.getOpcode() == ISD::LOAD && 10499 N0.hasOneUse()) { 10500 SDValue Chain0 = N0.getOperand(0); 10501 if (Predicate_unindexedload(N0.getNode()) && 10502 Predicate_load(N0.getNode()) && 10503 Predicate_loadf32(N0.getNode())) { 10504 SDValue N01 = N0.getOperand(1); 10505 SDValue CPTmpN01_0; 10506 SDValue CPTmpN01_1; 10507 SDValue CPTmpN01_2; 10508 SDValue CPTmpN01_3; 10509 SDValue CPTmpN01_4; 10510 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4) && 10511 N0.getNode()->getValueType(0) == MVT::f32) { 10512 SDNode *Result = Emit_76(N, X86::CVTSS2SDrm, MVT::f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10513 return Result; 10514 } 10515 } 10516 } 10517 } 10518 10519 // Pattern: (fextend:f64 RFP32:f32:$src) 10520 // Emits: (MOV_Fp3264:f64 RFP32:f32:$src) 10521 // Pattern complexity = 3 cost = 1 size = 0 10522 if ((!Subtarget->hasSSE1())) { 10523 SDValue N0 = N.getOperand(0); 10524 if (N0.getNode()->getValueType(0) == MVT::f32) { 10525 SDNode *Result = Emit_71(N, X86::MOV_Fp3264, MVT::f64); 10526 return Result; 10527 } 10528 } 10529 10530 // Pattern: (fextend:f64 FR32:f32:$src) 10531 // Emits: (CVTSS2SDrr:f64 FR32:f32:$src) 10532 // Pattern complexity = 3 cost = 1 size = 3 10533 if ((Subtarget->hasSSE2())) { 10534 SDValue N0 = N.getOperand(0); 10535 if (N0.getNode()->getValueType(0) == MVT::f32) { 10536 SDNode *Result = Emit_71(N, X86::CVTSS2SDrr, MVT::f64); 10537 return Result; 10538 } 10539 } 10540 10541 CannotYetSelect(N); 10542 return NULL; 10543 } 10544 10545 SDNode *Select_ISD_FP_EXTEND_f80(const SDValue &N) { 10546 10547 // Pattern: (fextend:f80 RFP32:f32:$src) 10548 // Emits: (MOV_Fp3280:f80 RFP32:f32:$src) 10549 // Pattern complexity = 3 cost = 1 size = 0 10550 if ((!Subtarget->hasSSE1())) { 10551 SDValue N0 = N.getOperand(0); 10552 if (N0.getNode()->getValueType(0) == MVT::f32) { 10553 SDNode *Result = Emit_71(N, X86::MOV_Fp3280, MVT::f80); 10554 return Result; 10555 } 10556 } 10557 10558 // Pattern: (fextend:f80 RFP64:f64:$src) 10559 // Emits: (MOV_Fp6480:f80 RFP64:f64:$src) 10560 // Pattern complexity = 3 cost = 1 size = 0 10561 if ((!Subtarget->hasSSE2())) { 10562 SDValue N0 = N.getOperand(0); 10563 if (N0.getNode()->getValueType(0) == MVT::f64) { 10564 SDNode *Result = Emit_71(N, X86::MOV_Fp6480, MVT::f80); 10565 return Result; 10566 } 10567 } 10568 10569 CannotYetSelect(N); 10570 return NULL; 10571 } 10572 10573 SDNode *Select_ISD_FP_ROUND_f32(const SDValue &N) { 10574 10575 // Pattern: (fround:f32 (ld:f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>) 10576 // Emits: (CVTSD2SSrm:f32 addr:iPTR:$src) 10577 // Pattern complexity = 25 cost = 1 size = 3 10578 if (OptLevel != CodeGenOpt::None && 10579 (Subtarget->hasSSE2())) { 10580 SDValue N0 = N.getOperand(0); 10581 if (N0.getOpcode() == ISD::LOAD && 10582 N0.hasOneUse()) { 10583 SDValue Chain0 = N0.getOperand(0); 10584 if (Predicate_unindexedload(N0.getNode()) && 10585 Predicate_load(N0.getNode()) && 10586 Predicate_loadf64(N0.getNode())) { 10587 SDValue N01 = N0.getOperand(1); 10588 SDValue CPTmpN01_0; 10589 SDValue CPTmpN01_1; 10590 SDValue CPTmpN01_2; 10591 SDValue CPTmpN01_3; 10592 SDValue CPTmpN01_4; 10593 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4) && 10594 N0.getNode()->getValueType(0) == MVT::f64) { 10595 SDNode *Result = Emit_76(N, X86::CVTSD2SSrm, MVT::f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10596 return Result; 10597 } 10598 } 10599 } 10600 } 10601 if ((!Subtarget->hasSSE1())) { 10602 SDValue N0 = N.getOperand(0); 10603 10604 // Pattern: (fround:f32 RFP64:f64:$src) 10605 // Emits: (MOV_Fp6432:f32 RFP64:f64:$src) 10606 // Pattern complexity = 3 cost = 1 size = 0 10607 if (N0.getNode()->getValueType(0) == MVT::f64) { 10608 SDNode *Result = Emit_71(N, X86::MOV_Fp6432, MVT::f32); 10609 return Result; 10610 } 10611 10612 // Pattern: (fround:f32 RFP80:f80:$src) 10613 // Emits: (MOV_Fp8032:f32 RFP80:f80:$src) 10614 // Pattern complexity = 3 cost = 1 size = 0 10615 if (N0.getNode()->getValueType(0) == MVT::f80) { 10616 SDNode *Result = Emit_71(N, X86::MOV_Fp8032, MVT::f32); 10617 return Result; 10618 } 10619 } 10620 10621 // Pattern: (fround:f32 FR64:f64:$src) 10622 // Emits: (CVTSD2SSrr:f32 FR64:f64:$src) 10623 // Pattern complexity = 3 cost = 1 size = 3 10624 if ((Subtarget->hasSSE2())) { 10625 SDValue N0 = N.getOperand(0); 10626 if (N0.getNode()->getValueType(0) == MVT::f64) { 10627 SDNode *Result = Emit_71(N, X86::CVTSD2SSrr, MVT::f32); 10628 return Result; 10629 } 10630 } 10631 10632 CannotYetSelect(N); 10633 return NULL; 10634 } 10635 10636 SDNode *Select_ISD_FP_ROUND_f64(const SDValue &N) { 10637 if ((!Subtarget->hasSSE2())) { 10638 SDValue N0 = N.getOperand(0); 10639 if (N0.getNode()->getValueType(0) == MVT::f80) { 10640 SDNode *Result = Emit_71(N, X86::MOV_Fp8064, MVT::f64); 10641 return Result; 10642 } 10643 } 10644 10645 CannotYetSelect(N); 10646 return NULL; 10647 } 10648 10649 SDNode *Select_ISD_FP_TO_SINT_i32(const SDValue &N) { 10650 if (OptLevel != CodeGenOpt::None) { 10651 10652 // Pattern: (fp_to_sint:i32 (ld:f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf32>>) 10653 // Emits: (CVTTSS2SIrm:i32 addr:iPTR:$src) 10654 // Pattern complexity = 25 cost = 1 size = 3 10655 if ((Subtarget->hasSSE1())) { 10656 SDValue N0 = N.getOperand(0); 10657 if (N0.getOpcode() == ISD::LOAD && 10658 N0.hasOneUse()) { 10659 SDValue Chain0 = N0.getOperand(0); 10660 if (Predicate_unindexedload(N0.getNode()) && 10661 Predicate_load(N0.getNode()) && 10662 Predicate_loadf32(N0.getNode())) { 10663 SDValue N01 = N0.getOperand(1); 10664 SDValue CPTmpN01_0; 10665 SDValue CPTmpN01_1; 10666 SDValue CPTmpN01_2; 10667 SDValue CPTmpN01_3; 10668 SDValue CPTmpN01_4; 10669 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4) && 10670 N0.getNode()->getValueType(0) == MVT::f32) { 10671 SDNode *Result = Emit_76(N, X86::CVTTSS2SIrm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10672 return Result; 10673 } 10674 } 10675 } 10676 } 10677 10678 // Pattern: (fp_to_sint:i32 (ld:f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>) 10679 // Emits: (CVTTSD2SIrm:i32 addr:iPTR:$src) 10680 // Pattern complexity = 25 cost = 1 size = 3 10681 if ((Subtarget->hasSSE2())) { 10682 SDValue N0 = N.getOperand(0); 10683 if (N0.getOpcode() == ISD::LOAD && 10684 N0.hasOneUse()) { 10685 SDValue Chain0 = N0.getOperand(0); 10686 if (Predicate_unindexedload(N0.getNode()) && 10687 Predicate_load(N0.getNode()) && 10688 Predicate_loadf64(N0.getNode())) { 10689 SDValue N01 = N0.getOperand(1); 10690 SDValue CPTmpN01_0; 10691 SDValue CPTmpN01_1; 10692 SDValue CPTmpN01_2; 10693 SDValue CPTmpN01_3; 10694 SDValue CPTmpN01_4; 10695 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4) && 10696 N0.getNode()->getValueType(0) == MVT::f64) { 10697 SDNode *Result = Emit_76(N, X86::CVTTSD2SIrm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10698 return Result; 10699 } 10700 } 10701 } 10702 } 10703 } 10704 10705 // Pattern: (fp_to_sint:i32 FR32:f32:$src) 10706 // Emits: (CVTTSS2SIrr:i32 FR32:f32:$src) 10707 // Pattern complexity = 3 cost = 1 size = 3 10708 if ((Subtarget->hasSSE1())) { 10709 SDValue N0 = N.getOperand(0); 10710 if (N0.getNode()->getValueType(0) == MVT::f32) { 10711 SDNode *Result = Emit_71(N, X86::CVTTSS2SIrr, MVT::i32); 10712 return Result; 10713 } 10714 } 10715 10716 // Pattern: (fp_to_sint:i32 FR64:f64:$src) 10717 // Emits: (CVTTSD2SIrr:i32 FR64:f64:$src) 10718 // Pattern complexity = 3 cost = 1 size = 3 10719 if ((Subtarget->hasSSE2())) { 10720 SDValue N0 = N.getOperand(0); 10721 if (N0.getNode()->getValueType(0) == MVT::f64) { 10722 SDNode *Result = Emit_71(N, X86::CVTTSD2SIrr, MVT::i32); 10723 return Result; 10724 } 10725 } 10726 10727 CannotYetSelect(N); 10728 return NULL; 10729 } 10730 10731 SDNode *Select_ISD_FP_TO_SINT_i64(const SDValue &N) { 10732 if (OptLevel != CodeGenOpt::None) { 10733 10734 // Pattern: (fp_to_sint:i64 (ld:f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>) 10735 // Emits: (CVTTSD2SI64rm:i64 addr:iPTR:$src) 10736 // Pattern complexity = 25 cost = 1 size = 3 10737 if ((Subtarget->hasSSE2())) { 10738 SDValue N0 = N.getOperand(0); 10739 if (N0.getOpcode() == ISD::LOAD && 10740 N0.hasOneUse()) { 10741 SDValue Chain0 = N0.getOperand(0); 10742 if (Predicate_unindexedload(N0.getNode()) && 10743 Predicate_load(N0.getNode()) && 10744 Predicate_loadf64(N0.getNode())) { 10745 SDValue N01 = N0.getOperand(1); 10746 SDValue CPTmpN01_0; 10747 SDValue CPTmpN01_1; 10748 SDValue CPTmpN01_2; 10749 SDValue CPTmpN01_3; 10750 SDValue CPTmpN01_4; 10751 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4) && 10752 N0.getNode()->getValueType(0) == MVT::f64) { 10753 SDNode *Result = Emit_76(N, X86::CVTTSD2SI64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10754 return Result; 10755 } 10756 } 10757 } 10758 } 10759 10760 // Pattern: (fp_to_sint:i64 (ld:f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf32>>) 10761 // Emits: (CVTTSS2SI64rm:i64 addr:iPTR:$src) 10762 // Pattern complexity = 25 cost = 1 size = 3 10763 if ((Subtarget->hasSSE1())) { 10764 SDValue N0 = N.getOperand(0); 10765 if (N0.getOpcode() == ISD::LOAD && 10766 N0.hasOneUse()) { 10767 SDValue Chain0 = N0.getOperand(0); 10768 if (Predicate_unindexedload(N0.getNode()) && 10769 Predicate_load(N0.getNode()) && 10770 Predicate_loadf32(N0.getNode())) { 10771 SDValue N01 = N0.getOperand(1); 10772 SDValue CPTmpN01_0; 10773 SDValue CPTmpN01_1; 10774 SDValue CPTmpN01_2; 10775 SDValue CPTmpN01_3; 10776 SDValue CPTmpN01_4; 10777 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4) && 10778 N0.getNode()->getValueType(0) == MVT::f32) { 10779 SDNode *Result = Emit_76(N, X86::CVTTSS2SI64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10780 return Result; 10781 } 10782 } 10783 } 10784 } 10785 } 10786 10787 // Pattern: (fp_to_sint:i64 FR64:f64:$src) 10788 // Emits: (CVTTSD2SI64rr:i64 FR64:f64:$src) 10789 // Pattern complexity = 3 cost = 1 size = 3 10790 if ((Subtarget->hasSSE2())) { 10791 SDValue N0 = N.getOperand(0); 10792 if (N0.getNode()->getValueType(0) == MVT::f64) { 10793 SDNode *Result = Emit_71(N, X86::CVTTSD2SI64rr, MVT::i64); 10794 return Result; 10795 } 10796 } 10797 10798 // Pattern: (fp_to_sint:i64 FR32:f32:$src) 10799 // Emits: (CVTTSS2SI64rr:i64 FR32:f32:$src) 10800 // Pattern complexity = 3 cost = 1 size = 3 10801 if ((Subtarget->hasSSE1())) { 10802 SDValue N0 = N.getOperand(0); 10803 if (N0.getNode()->getValueType(0) == MVT::f32) { 10804 SDNode *Result = Emit_71(N, X86::CVTTSS2SI64rr, MVT::i64); 10805 return Result; 10806 } 10807 } 10808 10809 CannotYetSelect(N); 10810 return NULL; 10811 } 10812 10813 SDNode *Select_ISD_FP_TO_SINT_v2i32(const SDValue &N) { 10814 if ((Subtarget->hasSSE2())) { 10815 SDValue N0 = N.getOperand(0); 10816 if (N0.getNode()->getValueType(0) == MVT::v2f64) { 10817 SDNode *Result = Emit_71(N, X86::Int_CVTTPD2PIrr, MVT::v2i32); 10818 return Result; 10819 } 10820 } 10821 10822 CannotYetSelect(N); 10823 return NULL; 10824 } 10825 10826 SDNode *Select_ISD_FP_TO_SINT_v4i32(const SDValue &N) { 10827 if ((Subtarget->hasSSE2())) { 10828 SDValue N0 = N.getOperand(0); 10829 if (N0.getNode()->getValueType(0) == MVT::v4f32) { 10830 SDNode *Result = Emit_71(N, X86::Int_CVTTPS2DQrr, MVT::v4i32); 10831 return Result; 10832 } 10833 } 10834 10835 CannotYetSelect(N); 10836 return NULL; 10837 } 10838 10839 SDNode *Select_ISD_FSIN_f32(const SDValue &N) { 10840 if ((!Subtarget->hasSSE1())) { 10841 SDNode *Result = Emit_71(N, X86::SIN_Fp32, MVT::f32); 10842 return Result; 10843 } 10844 10845 CannotYetSelect(N); 10846 return NULL; 10847 } 10848 10849 SDNode *Select_ISD_FSIN_f64(const SDValue &N) { 10850 if ((!Subtarget->hasSSE2())) { 10851 SDNode *Result = Emit_71(N, X86::SIN_Fp64, MVT::f64); 10852 return Result; 10853 } 10854 10855 CannotYetSelect(N); 10856 return NULL; 10857 } 10858 10859 SDNode *Select_ISD_FSIN_f80(const SDValue &N) { 10860 SDNode *Result = Emit_71(N, X86::SIN_Fp80, MVT::f80); 10861 return Result; 10862 } 10863 10864 SDNode *Select_ISD_FSQRT_f32(const SDValue &N) { 10865 10866 // Pattern: (fsqrt:f32 (ld:f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 10867 // Emits: (SQRTSSm:f32 addr:iPTR:$src) 10868 // Pattern complexity = 25 cost = 1 size = 3 10869 if (OptLevel != CodeGenOpt::None && 10870 (Subtarget->hasSSE1())) { 10871 SDValue N0 = N.getOperand(0); 10872 if (N0.getOpcode() == ISD::LOAD && 10873 N0.hasOneUse()) { 10874 SDValue Chain0 = N0.getOperand(0); 10875 if (Predicate_unindexedload(N0.getNode()) && 10876 Predicate_load(N0.getNode())) { 10877 SDValue N01 = N0.getOperand(1); 10878 SDValue CPTmpN01_0; 10879 SDValue CPTmpN01_1; 10880 SDValue CPTmpN01_2; 10881 SDValue CPTmpN01_3; 10882 SDValue CPTmpN01_4; 10883 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 10884 SDNode *Result = Emit_76(N, X86::SQRTSSm, MVT::f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10885 return Result; 10886 } 10887 } 10888 } 10889 } 10890 10891 // Pattern: (fsqrt:f32 RFP32:f32:$src) 10892 // Emits: (SQRT_Fp32:f32 RFP32:f32:$src) 10893 // Pattern complexity = 3 cost = 1 size = 0 10894 if ((!Subtarget->hasSSE1())) { 10895 SDNode *Result = Emit_71(N, X86::SQRT_Fp32, MVT::f32); 10896 return Result; 10897 } 10898 10899 // Pattern: (fsqrt:f32 FR32:f32:$src) 10900 // Emits: (SQRTSSr:f32 FR32:f32:$src) 10901 // Pattern complexity = 3 cost = 1 size = 3 10902 if ((Subtarget->hasSSE1())) { 10903 SDNode *Result = Emit_71(N, X86::SQRTSSr, MVT::f32); 10904 return Result; 10905 } 10906 10907 CannotYetSelect(N); 10908 return NULL; 10909 } 10910 10911 SDNode *Select_ISD_FSQRT_f64(const SDValue &N) { 10912 10913 // Pattern: (fsqrt:f64 (ld:f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 10914 // Emits: (SQRTSDm:f64 addr:iPTR:$src) 10915 // Pattern complexity = 25 cost = 1 size = 3 10916 if (OptLevel != CodeGenOpt::None && 10917 (Subtarget->hasSSE2())) { 10918 SDValue N0 = N.getOperand(0); 10919 if (N0.getOpcode() == ISD::LOAD && 10920 N0.hasOneUse()) { 10921 SDValue Chain0 = N0.getOperand(0); 10922 if (Predicate_unindexedload(N0.getNode()) && 10923 Predicate_load(N0.getNode())) { 10924 SDValue N01 = N0.getOperand(1); 10925 SDValue CPTmpN01_0; 10926 SDValue CPTmpN01_1; 10927 SDValue CPTmpN01_2; 10928 SDValue CPTmpN01_3; 10929 SDValue CPTmpN01_4; 10930 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 10931 SDNode *Result = Emit_76(N, X86::SQRTSDm, MVT::f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10932 return Result; 10933 } 10934 } 10935 } 10936 } 10937 10938 // Pattern: (fsqrt:f64 RFP64:f64:$src) 10939 // Emits: (SQRT_Fp64:f64 RFP64:f64:$src) 10940 // Pattern complexity = 3 cost = 1 size = 0 10941 if ((!Subtarget->hasSSE2())) { 10942 SDNode *Result = Emit_71(N, X86::SQRT_Fp64, MVT::f64); 10943 return Result; 10944 } 10945 10946 // Pattern: (fsqrt:f64 FR64:f64:$src) 10947 // Emits: (SQRTSDr:f64 FR64:f64:$src) 10948 // Pattern complexity = 3 cost = 1 size = 3 10949 if ((Subtarget->hasSSE2())) { 10950 SDNode *Result = Emit_71(N, X86::SQRTSDr, MVT::f64); 10951 return Result; 10952 } 10953 10954 CannotYetSelect(N); 10955 return NULL; 10956 } 10957 10958 SDNode *Select_ISD_FSQRT_f80(const SDValue &N) { 10959 SDNode *Result = Emit_71(N, X86::SQRT_Fp80, MVT::f80); 10960 return Result; 10961 } 10962 10963 SDNode *Select_ISD_FSQRT_v4f32(const SDValue &N) { 10964 10965 // Pattern: (fsqrt:v4f32 (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 10966 // Emits: (SQRTPSm:v4f32 addr:iPTR:$src) 10967 // Pattern complexity = 25 cost = 1 size = 3 10968 if (OptLevel != CodeGenOpt::None && 10969 (Subtarget->hasSSE1())) { 10970 SDValue N0 = N.getOperand(0); 10971 if (N0.getOpcode() == ISD::LOAD && 10972 N0.hasOneUse()) { 10973 SDValue Chain0 = N0.getOperand(0); 10974 if (Predicate_unindexedload(N0.getNode()) && 10975 Predicate_load(N0.getNode()) && 10976 Predicate_memop(N0.getNode())) { 10977 SDValue N01 = N0.getOperand(1); 10978 SDValue CPTmpN01_0; 10979 SDValue CPTmpN01_1; 10980 SDValue CPTmpN01_2; 10981 SDValue CPTmpN01_3; 10982 SDValue CPTmpN01_4; 10983 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 10984 SDNode *Result = Emit_76(N, X86::SQRTPSm, MVT::v4f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 10985 return Result; 10986 } 10987 } 10988 } 10989 } 10990 10991 // Pattern: (fsqrt:v4f32 VR128:v4f32:$src) 10992 // Emits: (SQRTPSr:v4f32 VR128:v4f32:$src) 10993 // Pattern complexity = 3 cost = 1 size = 3 10994 if ((Subtarget->hasSSE1())) { 10995 SDNode *Result = Emit_71(N, X86::SQRTPSr, MVT::v4f32); 10996 return Result; 10997 } 10998 10999 CannotYetSelect(N); 11000 return NULL; 11001 } 11002 11003 SDNode *Select_ISD_FSQRT_v2f64(const SDValue &N) { 11004 11005 // Pattern: (fsqrt:v2f64 (ld:v2f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 11006 // Emits: (SQRTPDm:v2f64 addr:iPTR:$src) 11007 // Pattern complexity = 25 cost = 1 size = 3 11008 if (OptLevel != CodeGenOpt::None && 11009 (Subtarget->hasSSE2())) { 11010 SDValue N0 = N.getOperand(0); 11011 if (N0.getOpcode() == ISD::LOAD && 11012 N0.hasOneUse()) { 11013 SDValue Chain0 = N0.getOperand(0); 11014 if (Predicate_unindexedload(N0.getNode()) && 11015 Predicate_load(N0.getNode()) && 11016 Predicate_memop(N0.getNode())) { 11017 SDValue N01 = N0.getOperand(1); 11018 SDValue CPTmpN01_0; 11019 SDValue CPTmpN01_1; 11020 SDValue CPTmpN01_2; 11021 SDValue CPTmpN01_3; 11022 SDValue CPTmpN01_4; 11023 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 11024 SDNode *Result = Emit_76(N, X86::SQRTPDm, MVT::v2f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 11025 return Result; 11026 } 11027 } 11028 } 11029 } 11030 11031 // Pattern: (fsqrt:v2f64 VR128:v2f64:$src) 11032 // Emits: (SQRTPDr:v2f64 VR128:v2f64:$src) 11033 // Pattern complexity = 3 cost = 1 size = 3 11034 if ((Subtarget->hasSSE2())) { 11035 SDNode *Result = Emit_71(N, X86::SQRTPDr, MVT::v2f64); 11036 return Result; 11037 } 11038 11039 CannotYetSelect(N); 11040 return NULL; 11041 } 11042 11043 SDNode *Select_ISD_FSUB_f32(const SDValue &N) { 11044 if (OptLevel != CodeGenOpt::None) { 11045 if ((!Subtarget->hasSSE1())) { 11046 SDValue N0 = N.getOperand(0); 11047 SDValue N1 = N.getOperand(1); 11048 if (N1.getOpcode() == ISD::LOAD && 11049 N1.hasOneUse() && 11050 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 11051 SDValue Chain1 = N1.getOperand(0); 11052 if (Predicate_unindexedload(N1.getNode()) && 11053 Predicate_load(N1.getNode()) && 11054 Predicate_loadf32(N1.getNode())) { 11055 SDValue N11 = N1.getOperand(1); 11056 SDValue CPTmpN11_0; 11057 SDValue CPTmpN11_1; 11058 SDValue CPTmpN11_2; 11059 SDValue CPTmpN11_3; 11060 SDValue CPTmpN11_4; 11061 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 11062 11063 // Pattern: (fsub:f32 RFP32:f32:$src1, (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf32>>) 11064 // Emits: (SUB_Fp32m:f32 RFP32:f32:$src1, addr:iPTR:$src2) 11065 // Pattern complexity = 25 cost = 1 size = 0 11066 { 11067 SDNode *Result = Emit_18(N, X86::SUB_Fp32m, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11068 return Result; 11069 } 11070 11071 // Pattern: (fsub:f32 RFP32:f32:$src1, (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf32>>) 11072 // Emits: (SUBR_Fp32m:f32 RFP32:f32:$src1, addr:iPTR:$src2) 11073 // Pattern complexity = 25 cost = 1 size = 0 11074 SDNode *Result = Emit_18(N, X86::SUBR_Fp32m, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11075 return Result; 11076 } 11077 } 11078 } 11079 } 11080 11081 // Pattern: (fsub:f32 FR32:f32:$src1, (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 11082 // Emits: (SUBSSrm:f32 FR32:f32:$src1, addr:iPTR:$src2) 11083 // Pattern complexity = 25 cost = 1 size = 3 11084 if ((Subtarget->hasSSE1())) { 11085 SDValue N0 = N.getOperand(0); 11086 SDValue N1 = N.getOperand(1); 11087 if (N1.getOpcode() == ISD::LOAD && 11088 N1.hasOneUse() && 11089 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 11090 SDValue Chain1 = N1.getOperand(0); 11091 if (Predicate_unindexedload(N1.getNode()) && 11092 Predicate_load(N1.getNode())) { 11093 SDValue N11 = N1.getOperand(1); 11094 SDValue CPTmpN11_0; 11095 SDValue CPTmpN11_1; 11096 SDValue CPTmpN11_2; 11097 SDValue CPTmpN11_3; 11098 SDValue CPTmpN11_4; 11099 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 11100 SDNode *Result = Emit_18(N, X86::SUBSSrm, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11101 return Result; 11102 } 11103 } 11104 } 11105 } 11106 if ((!Subtarget->hasSSE1())) { 11107 SDValue N0 = N.getOperand(0); 11108 SDValue N1 = N.getOperand(1); 11109 if (N1.getOpcode() == X86ISD::FILD && 11110 N1.hasOneUse() && 11111 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 11112 SDValue Chain1 = N1.getOperand(0); 11113 SDValue N11 = N1.getOperand(1); 11114 SDValue CPTmpN11_0; 11115 SDValue CPTmpN11_1; 11116 SDValue CPTmpN11_2; 11117 SDValue CPTmpN11_3; 11118 SDValue CPTmpN11_4; 11119 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 11120 SDValue N12 = N1.getOperand(2); 11121 11122 // Pattern: (fsub:f32 RFP32:f32:$src1, (X86fild:f32 addr:iPTR:$src2, i16:Other)) 11123 // Emits: (SUB_FpI16m32:f32 RFP32:f32:$src1, addr:iPTR:$src2) 11124 // Pattern complexity = 24 cost = 1 size = 0 11125 if (cast<VTSDNode>(N12)->getVT() == MVT::i16) { 11126 SDNode *Result = Emit_95(N, X86::SUB_FpI16m32, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11127 return Result; 11128 } 11129 11130 // Pattern: (fsub:f32 RFP32:f32:$src1, (X86fild:f32 addr:iPTR:$src2, i32:Other)) 11131 // Emits: (SUB_FpI32m32:f32 RFP32:f32:$src1, addr:iPTR:$src2) 11132 // Pattern complexity = 24 cost = 1 size = 0 11133 if (cast<VTSDNode>(N12)->getVT() == MVT::i32) { 11134 SDNode *Result = Emit_95(N, X86::SUB_FpI32m32, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11135 return Result; 11136 } 11137 11138 // Pattern: (fsub:f32 RFP32:f32:$src1, (X86fild:f32 addr:iPTR:$src2, i16:Other)) 11139 // Emits: (SUBR_FpI16m32:f32 RFP32:f32:$src1, addr:iPTR:$src2) 11140 // Pattern complexity = 24 cost = 1 size = 0 11141 if (cast<VTSDNode>(N12)->getVT() == MVT::i16) { 11142 SDNode *Result = Emit_95(N, X86::SUBR_FpI16m32, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11143 return Result; 11144 } 11145 11146 // Pattern: (fsub:f32 RFP32:f32:$src1, (X86fild:f32 addr:iPTR:$src2, i32:Other)) 11147 // Emits: (SUBR_FpI32m32:f32 RFP32:f32:$src1, addr:iPTR:$src2) 11148 // Pattern complexity = 24 cost = 1 size = 0 11149 if (cast<VTSDNode>(N12)->getVT() == MVT::i32) { 11150 SDNode *Result = Emit_95(N, X86::SUBR_FpI32m32, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11151 return Result; 11152 } 11153 } 11154 } 11155 } 11156 } 11157 11158 // Pattern: (fsub:f32 RFP32:f32:$src1, RFP32:f32:$src2) 11159 // Emits: (SUB_Fp32:f32 RFP32:f32:$src1, RFP32:f32:$src2) 11160 // Pattern complexity = 3 cost = 1 size = 0 11161 if ((!Subtarget->hasSSE1())) { 11162 SDNode *Result = Emit_15(N, X86::SUB_Fp32, MVT::f32); 11163 return Result; 11164 } 11165 11166 // Pattern: (fsub:f32 FR32:f32:$src1, FR32:f32:$src2) 11167 // Emits: (SUBSSrr:f32 FR32:f32:$src1, FR32:f32:$src2) 11168 // Pattern complexity = 3 cost = 1 size = 3 11169 if ((Subtarget->hasSSE1())) { 11170 SDNode *Result = Emit_15(N, X86::SUBSSrr, MVT::f32); 11171 return Result; 11172 } 11173 11174 CannotYetSelect(N); 11175 return NULL; 11176 } 11177 11178 SDNode *Select_ISD_FSUB_f64(const SDValue &N) { 11179 if (OptLevel != CodeGenOpt::None) { 11180 if ((!Subtarget->hasSSE2())) { 11181 SDValue N0 = N.getOperand(0); 11182 SDValue N1 = N.getOperand(1); 11183 if (N1.getOpcode() == ISD::LOAD && 11184 N1.hasOneUse() && 11185 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 11186 SDValue Chain1 = N1.getOperand(0); 11187 if (Predicate_unindexedload(N1.getNode())) { 11188 11189 // Pattern: (fsub:f64 RFP64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>) 11190 // Emits: (SUB_Fp64m:f64 RFP64:f64:$src1, addr:iPTR:$src2) 11191 // Pattern complexity = 25 cost = 1 size = 0 11192 if (Predicate_load(N1.getNode()) && 11193 Predicate_loadf64(N1.getNode())) { 11194 SDValue N11 = N1.getOperand(1); 11195 SDValue CPTmpN11_0; 11196 SDValue CPTmpN11_1; 11197 SDValue CPTmpN11_2; 11198 SDValue CPTmpN11_3; 11199 SDValue CPTmpN11_4; 11200 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 11201 SDNode *Result = Emit_18(N, X86::SUB_Fp64m, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11202 return Result; 11203 } 11204 } 11205 11206 // Pattern: (fsub:f64 RFP64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>>) 11207 // Emits: (SUB_Fp64m32:f64 RFP64:f64:$src1, addr:iPTR:$src2) 11208 // Pattern complexity = 25 cost = 1 size = 0 11209 if (Predicate_extload(N1.getNode()) && 11210 Predicate_extloadf32(N1.getNode())) { 11211 SDValue N11 = N1.getOperand(1); 11212 SDValue CPTmpN11_0; 11213 SDValue CPTmpN11_1; 11214 SDValue CPTmpN11_2; 11215 SDValue CPTmpN11_3; 11216 SDValue CPTmpN11_4; 11217 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 11218 SDNode *Result = Emit_18(N, X86::SUB_Fp64m32, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11219 return Result; 11220 } 11221 } 11222 11223 // Pattern: (fsub:f64 RFP64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>) 11224 // Emits: (SUBR_Fp64m:f64 RFP64:f64:$src1, addr:iPTR:$src2) 11225 // Pattern complexity = 25 cost = 1 size = 0 11226 if (Predicate_load(N1.getNode()) && 11227 Predicate_loadf64(N1.getNode())) { 11228 SDValue N11 = N1.getOperand(1); 11229 SDValue CPTmpN11_0; 11230 SDValue CPTmpN11_1; 11231 SDValue CPTmpN11_2; 11232 SDValue CPTmpN11_3; 11233 SDValue CPTmpN11_4; 11234 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 11235 SDNode *Result = Emit_18(N, X86::SUBR_Fp64m, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11236 return Result; 11237 } 11238 } 11239 11240 // Pattern: (fsub:f64 RFP64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>>) 11241 // Emits: (SUBR_Fp64m32:f64 RFP64:f64:$src1, addr:iPTR:$src2) 11242 // Pattern complexity = 25 cost = 1 size = 0 11243 if (Predicate_extload(N1.getNode()) && 11244 Predicate_extloadf32(N1.getNode())) { 11245 SDValue N11 = N1.getOperand(1); 11246 SDValue CPTmpN11_0; 11247 SDValue CPTmpN11_1; 11248 SDValue CPTmpN11_2; 11249 SDValue CPTmpN11_3; 11250 SDValue CPTmpN11_4; 11251 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 11252 SDNode *Result = Emit_18(N, X86::SUBR_Fp64m32, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11253 return Result; 11254 } 11255 } 11256 } 11257 } 11258 } 11259 11260 // Pattern: (fsub:f64 FR64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 11261 // Emits: (SUBSDrm:f64 FR64:f64:$src1, addr:iPTR:$src2) 11262 // Pattern complexity = 25 cost = 1 size = 3 11263 if ((Subtarget->hasSSE2())) { 11264 SDValue N0 = N.getOperand(0); 11265 SDValue N1 = N.getOperand(1); 11266 if (N1.getOpcode() == ISD::LOAD && 11267 N1.hasOneUse() && 11268 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 11269 SDValue Chain1 = N1.getOperand(0); 11270 if (Predicate_unindexedload(N1.getNode()) && 11271 Predicate_load(N1.getNode())) { 11272 SDValue N11 = N1.getOperand(1); 11273 SDValue CPTmpN11_0; 11274 SDValue CPTmpN11_1; 11275 SDValue CPTmpN11_2; 11276 SDValue CPTmpN11_3; 11277 SDValue CPTmpN11_4; 11278 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 11279 SDNode *Result = Emit_18(N, X86::SUBSDrm, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11280 return Result; 11281 } 11282 } 11283 } 11284 } 11285 if ((!Subtarget->hasSSE2())) { 11286 SDValue N0 = N.getOperand(0); 11287 SDValue N1 = N.getOperand(1); 11288 if (N1.getOpcode() == X86ISD::FILD && 11289 N1.hasOneUse() && 11290 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 11291 SDValue Chain1 = N1.getOperand(0); 11292 SDValue N11 = N1.getOperand(1); 11293 SDValue CPTmpN11_0; 11294 SDValue CPTmpN11_1; 11295 SDValue CPTmpN11_2; 11296 SDValue CPTmpN11_3; 11297 SDValue CPTmpN11_4; 11298 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 11299 SDValue N12 = N1.getOperand(2); 11300 11301 // Pattern: (fsub:f64 RFP64:f64:$src1, (X86fild:f64 addr:iPTR:$src2, i16:Other)) 11302 // Emits: (SUB_FpI16m64:f64 RFP64:f64:$src1, addr:iPTR:$src2) 11303 // Pattern complexity = 24 cost = 1 size = 0 11304 if (cast<VTSDNode>(N12)->getVT() == MVT::i16) { 11305 SDNode *Result = Emit_95(N, X86::SUB_FpI16m64, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11306 return Result; 11307 } 11308 11309 // Pattern: (fsub:f64 RFP64:f64:$src1, (X86fild:f64 addr:iPTR:$src2, i32:Other)) 11310 // Emits: (SUB_FpI32m64:f64 RFP64:f64:$src1, addr:iPTR:$src2) 11311 // Pattern complexity = 24 cost = 1 size = 0 11312 if (cast<VTSDNode>(N12)->getVT() == MVT::i32) { 11313 SDNode *Result = Emit_95(N, X86::SUB_FpI32m64, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11314 return Result; 11315 } 11316 11317 // Pattern: (fsub:f64 RFP64:f64:$src1, (X86fild:f64 addr:iPTR:$src2, i16:Other)) 11318 // Emits: (SUBR_FpI16m64:f64 RFP64:f64:$src1, addr:iPTR:$src2) 11319 // Pattern complexity = 24 cost = 1 size = 0 11320 if (cast<VTSDNode>(N12)->getVT() == MVT::i16) { 11321 SDNode *Result = Emit_95(N, X86::SUBR_FpI16m64, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11322 return Result; 11323 } 11324 11325 // Pattern: (fsub:f64 RFP64:f64:$src1, (X86fild:f64 addr:iPTR:$src2, i32:Other)) 11326 // Emits: (SUBR_FpI32m64:f64 RFP64:f64:$src1, addr:iPTR:$src2) 11327 // Pattern complexity = 24 cost = 1 size = 0 11328 if (cast<VTSDNode>(N12)->getVT() == MVT::i32) { 11329 SDNode *Result = Emit_95(N, X86::SUBR_FpI32m64, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11330 return Result; 11331 } 11332 } 11333 } 11334 } 11335 } 11336 11337 // Pattern: (fsub:f64 RFP64:f64:$src1, RFP64:f64:$src2) 11338 // Emits: (SUB_Fp64:f64 RFP64:f64:$src1, RFP64:f64:$src2) 11339 // Pattern complexity = 3 cost = 1 size = 0 11340 if ((!Subtarget->hasSSE2())) { 11341 SDNode *Result = Emit_15(N, X86::SUB_Fp64, MVT::f64); 11342 return Result; 11343 } 11344 11345 // Pattern: (fsub:f64 FR64:f64:$src1, FR64:f64:$src2) 11346 // Emits: (SUBSDrr:f64 FR64:f64:$src1, FR64:f64:$src2) 11347 // Pattern complexity = 3 cost = 1 size = 3 11348 if ((Subtarget->hasSSE2())) { 11349 SDNode *Result = Emit_15(N, X86::SUBSDrr, MVT::f64); 11350 return Result; 11351 } 11352 11353 CannotYetSelect(N); 11354 return NULL; 11355 } 11356 11357 SDNode *Select_ISD_FSUB_f80(const SDValue &N) { 11358 if (OptLevel != CodeGenOpt::None) { 11359 SDValue N0 = N.getOperand(0); 11360 SDValue N1 = N.getOperand(1); 11361 if (N1.getOpcode() == ISD::LOAD && 11362 N1.hasOneUse() && 11363 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 11364 SDValue Chain1 = N1.getOperand(0); 11365 if (Predicate_unindexedload(N1.getNode()) && 11366 Predicate_extload(N1.getNode())) { 11367 11368 // Pattern: (fsub:f80 RFP80:f80:$src1, (ld:f80 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>>) 11369 // Emits: (SUB_Fp80m32:f80 RFP80:f80:$src1, addr:iPTR:$src2) 11370 // Pattern complexity = 25 cost = 1 size = 0 11371 if (Predicate_extloadf32(N1.getNode())) { 11372 SDValue N11 = N1.getOperand(1); 11373 SDValue CPTmpN11_0; 11374 SDValue CPTmpN11_1; 11375 SDValue CPTmpN11_2; 11376 SDValue CPTmpN11_3; 11377 SDValue CPTmpN11_4; 11378 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 11379 SDNode *Result = Emit_18(N, X86::SUB_Fp80m32, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11380 return Result; 11381 } 11382 } 11383 11384 // Pattern: (fsub:f80 RFP80:f80:$src1, (ld:f80 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf64>>) 11385 // Emits: (SUB_Fp80m64:f80 RFP80:f80:$src1, addr:iPTR:$src2) 11386 // Pattern complexity = 25 cost = 1 size = 0 11387 if (Predicate_extloadf64(N1.getNode())) { 11388 SDValue N11 = N1.getOperand(1); 11389 SDValue CPTmpN11_0; 11390 SDValue CPTmpN11_1; 11391 SDValue CPTmpN11_2; 11392 SDValue CPTmpN11_3; 11393 SDValue CPTmpN11_4; 11394 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 11395 SDNode *Result = Emit_18(N, X86::SUB_Fp80m64, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11396 return Result; 11397 } 11398 } 11399 11400 // Pattern: (fsub:f80 RFP80:f80:$src1, (ld:f80 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>>) 11401 // Emits: (SUBR_Fp80m32:f80 RFP80:f80:$src1, addr:iPTR:$src2) 11402 // Pattern complexity = 25 cost = 1 size = 0 11403 if (Predicate_extloadf32(N1.getNode())) { 11404 SDValue N11 = N1.getOperand(1); 11405 SDValue CPTmpN11_0; 11406 SDValue CPTmpN11_1; 11407 SDValue CPTmpN11_2; 11408 SDValue CPTmpN11_3; 11409 SDValue CPTmpN11_4; 11410 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 11411 SDNode *Result = Emit_18(N, X86::SUBR_Fp80m32, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11412 return Result; 11413 } 11414 } 11415 11416 // Pattern: (fsub:f80 RFP80:f80:$src1, (ld:f80 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf64>>) 11417 // Emits: (SUBR_Fp80m64:f80 RFP80:f80:$src1, addr:iPTR:$src2) 11418 // Pattern complexity = 25 cost = 1 size = 0 11419 if (Predicate_extloadf64(N1.getNode())) { 11420 SDValue N11 = N1.getOperand(1); 11421 SDValue CPTmpN11_0; 11422 SDValue CPTmpN11_1; 11423 SDValue CPTmpN11_2; 11424 SDValue CPTmpN11_3; 11425 SDValue CPTmpN11_4; 11426 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 11427 SDNode *Result = Emit_18(N, X86::SUBR_Fp80m64, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11428 return Result; 11429 } 11430 } 11431 } 11432 } 11433 if (N1.getOpcode() == X86ISD::FILD && 11434 N1.hasOneUse() && 11435 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 11436 SDValue Chain1 = N1.getOperand(0); 11437 SDValue N11 = N1.getOperand(1); 11438 SDValue CPTmpN11_0; 11439 SDValue CPTmpN11_1; 11440 SDValue CPTmpN11_2; 11441 SDValue CPTmpN11_3; 11442 SDValue CPTmpN11_4; 11443 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 11444 SDValue N12 = N1.getOperand(2); 11445 11446 // Pattern: (fsub:f80 RFP80:f80:$src1, (X86fild:f80 addr:iPTR:$src2, i16:Other)) 11447 // Emits: (SUB_FpI16m80:f80 RFP80:f80:$src1, addr:iPTR:$src2) 11448 // Pattern complexity = 24 cost = 1 size = 0 11449 if (cast<VTSDNode>(N12)->getVT() == MVT::i16) { 11450 SDNode *Result = Emit_95(N, X86::SUB_FpI16m80, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11451 return Result; 11452 } 11453 11454 // Pattern: (fsub:f80 RFP80:f80:$src1, (X86fild:f80 addr:iPTR:$src2, i32:Other)) 11455 // Emits: (SUB_FpI32m80:f80 RFP80:f80:$src1, addr:iPTR:$src2) 11456 // Pattern complexity = 24 cost = 1 size = 0 11457 if (cast<VTSDNode>(N12)->getVT() == MVT::i32) { 11458 SDNode *Result = Emit_95(N, X86::SUB_FpI32m80, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11459 return Result; 11460 } 11461 11462 // Pattern: (fsub:f80 RFP80:f80:$src1, (X86fild:f80 addr:iPTR:$src2, i16:Other)) 11463 // Emits: (SUBR_FpI16m80:f80 RFP80:f80:$src1, addr:iPTR:$src2) 11464 // Pattern complexity = 24 cost = 1 size = 0 11465 if (cast<VTSDNode>(N12)->getVT() == MVT::i16) { 11466 SDNode *Result = Emit_95(N, X86::SUBR_FpI16m80, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11467 return Result; 11468 } 11469 11470 // Pattern: (fsub:f80 RFP80:f80:$src1, (X86fild:f80 addr:iPTR:$src2, i32:Other)) 11471 // Emits: (SUBR_FpI32m80:f80 RFP80:f80:$src1, addr:iPTR:$src2) 11472 // Pattern complexity = 24 cost = 1 size = 0 11473 if (cast<VTSDNode>(N12)->getVT() == MVT::i32) { 11474 SDNode *Result = Emit_95(N, X86::SUBR_FpI32m80, MVT::f80, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11475 return Result; 11476 } 11477 } 11478 } 11479 } 11480 11481 // Pattern: (fsub:f80 RFP80:f80:$src1, RFP80:f80:$src2) 11482 // Emits: (SUB_Fp80:f80 RFP80:f80:$src1, RFP80:f80:$src2) 11483 // Pattern complexity = 3 cost = 1 size = 0 11484 SDNode *Result = Emit_15(N, X86::SUB_Fp80, MVT::f80); 11485 return Result; 11486 } 11487 11488 SDNode *Select_ISD_FSUB_v4f32(const SDValue &N) { 11489 11490 // Pattern: (fsub:v4f32 VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 11491 // Emits: (SUBPSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 11492 // Pattern complexity = 25 cost = 1 size = 3 11493 if (OptLevel != CodeGenOpt::None && 11494 (Subtarget->hasSSE1())) { 11495 SDValue N0 = N.getOperand(0); 11496 SDValue N1 = N.getOperand(1); 11497 if (N1.getOpcode() == ISD::LOAD && 11498 N1.hasOneUse() && 11499 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 11500 SDValue Chain1 = N1.getOperand(0); 11501 if (Predicate_unindexedload(N1.getNode()) && 11502 Predicate_load(N1.getNode()) && 11503 Predicate_memop(N1.getNode())) { 11504 SDValue N11 = N1.getOperand(1); 11505 SDValue CPTmpN11_0; 11506 SDValue CPTmpN11_1; 11507 SDValue CPTmpN11_2; 11508 SDValue CPTmpN11_3; 11509 SDValue CPTmpN11_4; 11510 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 11511 SDNode *Result = Emit_18(N, X86::SUBPSrm, MVT::v4f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11512 return Result; 11513 } 11514 } 11515 } 11516 } 11517 11518 // Pattern: (fsub:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 11519 // Emits: (SUBPSrr:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 11520 // Pattern complexity = 3 cost = 1 size = 3 11521 if ((Subtarget->hasSSE1())) { 11522 SDNode *Result = Emit_15(N, X86::SUBPSrr, MVT::v4f32); 11523 return Result; 11524 } 11525 11526 CannotYetSelect(N); 11527 return NULL; 11528 } 11529 11530 SDNode *Select_ISD_FSUB_v2f64(const SDValue &N) { 11531 11532 // Pattern: (fsub:v2f64 VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 11533 // Emits: (SUBPDrm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 11534 // Pattern complexity = 25 cost = 1 size = 3 11535 if (OptLevel != CodeGenOpt::None && 11536 (Subtarget->hasSSE2())) { 11537 SDValue N0 = N.getOperand(0); 11538 SDValue N1 = N.getOperand(1); 11539 if (N1.getOpcode() == ISD::LOAD && 11540 N1.hasOneUse() && 11541 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 11542 SDValue Chain1 = N1.getOperand(0); 11543 if (Predicate_unindexedload(N1.getNode()) && 11544 Predicate_load(N1.getNode()) && 11545 Predicate_memop(N1.getNode())) { 11546 SDValue N11 = N1.getOperand(1); 11547 SDValue CPTmpN11_0; 11548 SDValue CPTmpN11_1; 11549 SDValue CPTmpN11_2; 11550 SDValue CPTmpN11_3; 11551 SDValue CPTmpN11_4; 11552 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 11553 SDNode *Result = Emit_18(N, X86::SUBPDrm, MVT::v2f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11554 return Result; 11555 } 11556 } 11557 } 11558 } 11559 11560 // Pattern: (fsub:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 11561 // Emits: (SUBPDrr:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 11562 // Pattern complexity = 3 cost = 1 size = 3 11563 if ((Subtarget->hasSSE2())) { 11564 SDNode *Result = Emit_15(N, X86::SUBPDrr, MVT::v2f64); 11565 return Result; 11566 } 11567 11568 CannotYetSelect(N); 11569 return NULL; 11570 } 11571 11572 SDNode *Select_ISD_FrameIndex_i32(const SDValue &N) { 11573 11574 // Pattern: lea32addr:i32:$src 11575 // Emits: (LEA64_32r:i32 lea32addr:i32:$src) 11576 // Pattern complexity = 15 cost = 1 size = 3 11577 if ((Subtarget->is64Bit())) { 11578 SDValue CPTmpN_0; 11579 SDValue CPTmpN_1; 11580 SDValue CPTmpN_2; 11581 SDValue CPTmpN_3; 11582 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 11583 SDNode *Result = Emit_7(N, X86::LEA64_32r, MVT::i32, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 11584 return Result; 11585 } 11586 } 11587 11588 // Pattern: lea32addr:i32:$src 11589 // Emits: (LEA32r:i32 lea32addr:i32:$src) 11590 // Pattern complexity = 15 cost = 1 size = 3 11591 if ((!Subtarget->is64Bit())) { 11592 SDValue CPTmpN_0; 11593 SDValue CPTmpN_1; 11594 SDValue CPTmpN_2; 11595 SDValue CPTmpN_3; 11596 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 11597 SDNode *Result = Emit_7(N, X86::LEA32r, MVT::i32, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 11598 return Result; 11599 } 11600 } 11601 11602 CannotYetSelect(N); 11603 return NULL; 11604 } 11605 11606 SDNode *Select_ISD_FrameIndex_i64(const SDValue &N) { 11607 SDValue CPTmpN_0; 11608 SDValue CPTmpN_1; 11609 SDValue CPTmpN_2; 11610 SDValue CPTmpN_3; 11611 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 11612 SDNode *Result = Emit_7(N, X86::LEA64r, MVT::i64, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 11613 return Result; 11614 } 11615 11616 CannotYetSelect(N); 11617 return NULL; 11618 } 11619 11620 SDNode *Emit_97(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 11621 SDValue N0 = N.getOperand(0); 11622 SDValue N1 = N.getOperand(1); 11623 SDValue N2 = N.getOperand(2); 11624 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N2)->getZExtValue()), MVT::i32); 11625 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, N1, Tmp2); 11626 } 11627 SDNode *Emit_98(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 11628 SDValue N0 = N.getOperand(0); 11629 SDValue N1 = N.getOperand(1); 11630 SDValue Chain1 = N1.getOperand(0); 11631 SDValue N11 = N1.getOperand(1); 11632 SDValue N2 = N.getOperand(2); 11633 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N2)->getZExtValue()), MVT::i32); 11634 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 11635 SDValue Ops0[] = { N0, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, Tmp2, LSI_N1, Chain1 }; 11636 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 9); 11637 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 11638 return ResNode; 11639 } 11640 SDNode *Select_ISD_INSERT_VECTOR_ELT_v4i32(const SDValue &N) { 11641 11642 // Pattern: (insertelt:v4i32 VR128:v4i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:iPTR):$src3) 11643 // Emits: (PINSRDrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2, (imm:i32):$src3) 11644 // Pattern complexity = 28 cost = 1 size = 3 11645 if (OptLevel != CodeGenOpt::None && 11646 (Subtarget->hasSSE41())) { 11647 SDValue N0 = N.getOperand(0); 11648 SDValue N1 = N.getOperand(1); 11649 if (N1.getOpcode() == ISD::LOAD && 11650 N1.hasOneUse() && 11651 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 11652 SDValue Chain1 = N1.getOperand(0); 11653 if (Predicate_unindexedload(N1.getNode()) && 11654 Predicate_loadi32(N1.getNode())) { 11655 SDValue N11 = N1.getOperand(1); 11656 SDValue CPTmpN11_0; 11657 SDValue CPTmpN11_1; 11658 SDValue CPTmpN11_2; 11659 SDValue CPTmpN11_3; 11660 SDValue CPTmpN11_4; 11661 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 11662 SDValue N2 = N.getOperand(2); 11663 if (N2.getOpcode() == ISD::Constant) { 11664 SDNode *Result = Emit_98(N, X86::PINSRDrm, MVT::v4i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11665 return Result; 11666 } 11667 } 11668 } 11669 } 11670 } 11671 11672 // Pattern: (insertelt:v4i32 VR128:v4i32:$src1, GR32:i32:$src2, (imm:iPTR):$src3) 11673 // Emits: (PINSRDrr:v4i32 VR128:v4i32:$src1, GR32:i32:$src2, (imm:i32):$src3) 11674 // Pattern complexity = 6 cost = 1 size = 3 11675 if ((Subtarget->hasSSE41())) { 11676 SDValue N0 = N.getOperand(0); 11677 SDValue N1 = N.getOperand(1); 11678 SDValue N2 = N.getOperand(2); 11679 if (N2.getOpcode() == ISD::Constant) { 11680 SDNode *Result = Emit_97(N, X86::PINSRDrr, MVT::v4i32); 11681 return Result; 11682 } 11683 } 11684 11685 CannotYetSelect(N); 11686 return NULL; 11687 } 11688 11689 SDNode *Select_ISD_INSERT_VECTOR_ELT_v2i64(const SDValue &N) { 11690 11691 // Pattern: (insertelt:v2i64 VR128:v2i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:iPTR):$src3) 11692 // Emits: (PINSRQrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2, (imm:i32):$src3) 11693 // Pattern complexity = 28 cost = 1 size = 3 11694 if (OptLevel != CodeGenOpt::None && 11695 (Subtarget->hasSSE41())) { 11696 SDValue N0 = N.getOperand(0); 11697 SDValue N1 = N.getOperand(1); 11698 if (N1.getOpcode() == ISD::LOAD && 11699 N1.hasOneUse() && 11700 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 11701 SDValue Chain1 = N1.getOperand(0); 11702 if (Predicate_unindexedload(N1.getNode()) && 11703 Predicate_load(N1.getNode()) && 11704 Predicate_loadi64(N1.getNode())) { 11705 SDValue N11 = N1.getOperand(1); 11706 SDValue CPTmpN11_0; 11707 SDValue CPTmpN11_1; 11708 SDValue CPTmpN11_2; 11709 SDValue CPTmpN11_3; 11710 SDValue CPTmpN11_4; 11711 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 11712 SDValue N2 = N.getOperand(2); 11713 if (N2.getOpcode() == ISD::Constant) { 11714 SDNode *Result = Emit_98(N, X86::PINSRQrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 11715 return Result; 11716 } 11717 } 11718 } 11719 } 11720 } 11721 11722 // Pattern: (insertelt:v2i64 VR128:v2i64:$src1, GR64:i64:$src2, (imm:iPTR):$src3) 11723 // Emits: (PINSRQrr:v2i64 VR128:v2i64:$src1, GR64:i64:$src2, (imm:i32):$src3) 11724 // Pattern complexity = 6 cost = 1 size = 3 11725 if ((Subtarget->hasSSE41())) { 11726 SDValue N0 = N.getOperand(0); 11727 SDValue N1 = N.getOperand(1); 11728 SDValue N2 = N.getOperand(2); 11729 if (N2.getOpcode() == ISD::Constant) { 11730 SDNode *Result = Emit_97(N, X86::PINSRQrr, MVT::v2i64); 11731 return Result; 11732 } 11733 } 11734 11735 CannotYetSelect(N); 11736 return NULL; 11737 } 11738 11739 SDNode *Emit_99(const SDValue &N, unsigned Opc0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 11740 SDValue Chain = N.getOperand(0); 11741 SDValue N1 = N.getOperand(1); 11742 SDValue N2 = N.getOperand(2); 11743 SDValue N3 = N.getOperand(3); 11744 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, N3, Chain }; 11745 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 7); 11746 } 11747 SDNode *Emit_100(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 11748 SDValue Chain = N.getOperand(0); 11749 SDValue N1 = N.getOperand(1); 11750 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Chain); 11751 } 11752 SDNode *Emit_101(const SDValue &N, unsigned Opc0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 11753 SDValue Chain = N.getOperand(0); 11754 SDValue N1 = N.getOperand(1); 11755 SDValue N2 = N.getOperand(2); 11756 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Chain }; 11757 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 6); 11758 } 11759 SDNode *Emit_102(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 11760 SDValue Chain = N.getOperand(0); 11761 SDValue N1 = N.getOperand(1); 11762 SDValue N2 = N.getOperand(2); 11763 SDValue N3 = N.getOperand(3); 11764 SDValue N4 = N.getOperand(4); 11765 SDValue InFlag(0, 0); 11766 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::EDI, N4, InFlag).getNode(); 11767 Chain = SDValue(ResNode, 0); 11768 InFlag = SDValue(ResNode, 1); 11769 SDValue Ops0[] = { N2, N3, Chain, InFlag }; 11770 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 4); 11771 } 11772 SDNode *Emit_103(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 11773 SDValue Chain = N.getOperand(0); 11774 SDValue N1 = N.getOperand(1); 11775 SDValue N2 = N.getOperand(2); 11776 SDValue N3 = N.getOperand(3); 11777 SDValue N4 = N.getOperand(4); 11778 SDValue InFlag(0, 0); 11779 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::RDI, N4, InFlag).getNode(); 11780 Chain = SDValue(ResNode, 0); 11781 InFlag = SDValue(ResNode, 1); 11782 SDValue Ops0[] = { N2, N3, Chain, InFlag }; 11783 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 4); 11784 } 11785 SDNode *Emit_104(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 11786 SDValue Chain = N.getOperand(0); 11787 SDValue N1 = N.getOperand(1); 11788 SDValue N2 = N.getOperand(2); 11789 SDValue N3 = N.getOperand(3); 11790 SDValue N4 = N.getOperand(4); 11791 SDValue InFlag(0, 0); 11792 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::EAX, N2, InFlag).getNode(); 11793 Chain = SDValue(ResNode, 0); 11794 InFlag = SDValue(ResNode, 1); 11795 ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::ECX, N3, InFlag).getNode(); 11796 Chain = SDValue(ResNode, 0); 11797 InFlag = SDValue(ResNode, 1); 11798 ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::EDX, N4, InFlag).getNode(); 11799 Chain = SDValue(ResNode, 0); 11800 InFlag = SDValue(ResNode, 1); 11801 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Chain, InFlag); 11802 } 11803 SDNode *Emit_105(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 11804 SDValue Chain = N.getOperand(0); 11805 SDValue N1 = N.getOperand(1); 11806 SDValue N2 = N.getOperand(2); 11807 SDValue N3 = N.getOperand(3); 11808 SDValue InFlag(0, 0); 11809 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::ECX, N2, InFlag).getNode(); 11810 Chain = SDValue(ResNode, 0); 11811 InFlag = SDValue(ResNode, 1); 11812 ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::EAX, N3, InFlag).getNode(); 11813 Chain = SDValue(ResNode, 0); 11814 InFlag = SDValue(ResNode, 1); 11815 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Chain, InFlag); 11816 } 11817 SDNode *Select_ISD_INTRINSIC_VOID(const SDValue &N) { 11818 if ((Subtarget->hasSSE1())) { 11819 SDValue Chain = N.getOperand(0); 11820 SDValue N1 = N.getOperand(1); 11821 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 11822 if (Tmp0) { 11823 int64_t CN1 = Tmp0->getSExtValue(); 11824 11825 // Pattern: (intrinsic_void:isVoid 717:iPTR, addr:iPTR:$dst, VR128:v4f32:$src) 11826 // Emits: (MOVUPSmr_Int:isVoid addr:iPTR:$dst, VR128:v4f32:$src) 11827 // Pattern complexity = 26 cost = 1 size = 3 11828 if (CN1 == INT64_C(717)) { 11829 SDValue N2 = N.getOperand(2); 11830 SDValue CPTmpN2_0; 11831 SDValue CPTmpN2_1; 11832 SDValue CPTmpN2_2; 11833 SDValue CPTmpN2_3; 11834 SDValue CPTmpN2_4; 11835 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 11836 SDNode *Result = Emit_99(N, X86::MOVUPSmr_Int, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 11837 return Result; 11838 } 11839 } 11840 11841 // Pattern: (intrinsic_void:isVoid 707:iPTR, addr:iPTR:$dst, VR128:v4f32:$src) 11842 // Emits: (MOVNTPSmr:isVoid addr:iPTR:$dst, VR128:v4f32:$src) 11843 // Pattern complexity = 26 cost = 1 size = 3 11844 if (CN1 == INT64_C(707)) { 11845 SDValue N2 = N.getOperand(2); 11846 SDValue CPTmpN2_0; 11847 SDValue CPTmpN2_1; 11848 SDValue CPTmpN2_2; 11849 SDValue CPTmpN2_3; 11850 SDValue CPTmpN2_4; 11851 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 11852 SDNode *Result = Emit_99(N, X86::MOVNTPSmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 11853 return Result; 11854 } 11855 } 11856 11857 // Pattern: (intrinsic_void:isVoid 700:iPTR, addr:iPTR:$src) 11858 // Emits: (LDMXCSR:isVoid addr:iPTR:$src) 11859 // Pattern complexity = 26 cost = 1 size = 3 11860 if (CN1 == INT64_C(700)) { 11861 SDValue N2 = N.getOperand(2); 11862 SDValue CPTmpN2_0; 11863 SDValue CPTmpN2_1; 11864 SDValue CPTmpN2_2; 11865 SDValue CPTmpN2_3; 11866 SDValue CPTmpN2_4; 11867 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 11868 SDNode *Result = Emit_101(N, X86::LDMXCSR, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 11869 return Result; 11870 } 11871 } 11872 11873 // Pattern: (intrinsic_void:isVoid 716:iPTR, addr:iPTR:$dst) 11874 // Emits: (STMXCSR:isVoid addr:iPTR:$dst) 11875 // Pattern complexity = 26 cost = 1 size = 3 11876 if (CN1 == INT64_C(716)) { 11877 SDValue N2 = N.getOperand(2); 11878 SDValue CPTmpN2_0; 11879 SDValue CPTmpN2_1; 11880 SDValue CPTmpN2_2; 11881 SDValue CPTmpN2_3; 11882 SDValue CPTmpN2_4; 11883 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 11884 SDNode *Result = Emit_101(N, X86::STMXCSR, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 11885 return Result; 11886 } 11887 } 11888 } 11889 } 11890 if ((Subtarget->hasSSE2())) { 11891 SDValue Chain = N.getOperand(0); 11892 SDValue N1 = N.getOperand(1); 11893 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 11894 if (Tmp0) { 11895 int64_t CN1 = Tmp0->getSExtValue(); 11896 11897 // Pattern: (intrinsic_void:isVoid 595:iPTR, addr:iPTR:$dst, VR128:v2f64:$src) 11898 // Emits: (MOVUPDmr_Int:isVoid addr:iPTR:$dst, VR128:v2f64:$src) 11899 // Pattern complexity = 26 cost = 1 size = 3 11900 if (CN1 == INT64_C(595)) { 11901 SDValue N2 = N.getOperand(2); 11902 SDValue CPTmpN2_0; 11903 SDValue CPTmpN2_1; 11904 SDValue CPTmpN2_2; 11905 SDValue CPTmpN2_3; 11906 SDValue CPTmpN2_4; 11907 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 11908 SDNode *Result = Emit_99(N, X86::MOVUPDmr_Int, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 11909 return Result; 11910 } 11911 } 11912 11913 // Pattern: (intrinsic_void:isVoid 594:iPTR, addr:iPTR:$dst, VR128:v16i8:$src) 11914 // Emits: (MOVDQUmr_Int:isVoid addr:iPTR:$dst, VR128:v16i8:$src) 11915 // Pattern complexity = 26 cost = 1 size = 3 11916 if (CN1 == INT64_C(594)) { 11917 SDValue N2 = N.getOperand(2); 11918 SDValue CPTmpN2_0; 11919 SDValue CPTmpN2_1; 11920 SDValue CPTmpN2_2; 11921 SDValue CPTmpN2_3; 11922 SDValue CPTmpN2_4; 11923 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 11924 SDNode *Result = Emit_99(N, X86::MOVDQUmr_Int, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 11925 return Result; 11926 } 11927 } 11928 11929 // Pattern: (intrinsic_void:isVoid 540:iPTR, addr:iPTR:$dst, VR128:v2f64:$src) 11930 // Emits: (MOVNTPDmr:isVoid addr:iPTR:$dst, VR128:v2f64:$src) 11931 // Pattern complexity = 26 cost = 1 size = 3 11932 if (CN1 == INT64_C(540)) { 11933 SDValue N2 = N.getOperand(2); 11934 SDValue CPTmpN2_0; 11935 SDValue CPTmpN2_1; 11936 SDValue CPTmpN2_2; 11937 SDValue CPTmpN2_3; 11938 SDValue CPTmpN2_4; 11939 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 11940 SDNode *Result = Emit_99(N, X86::MOVNTPDmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 11941 return Result; 11942 } 11943 } 11944 11945 // Pattern: (intrinsic_void:isVoid 538:iPTR, addr:iPTR:$dst, VR128:v2i64:$src) 11946 // Emits: (MOVNTDQmr:isVoid addr:iPTR:$dst, VR128:v2i64:$src) 11947 // Pattern complexity = 26 cost = 1 size = 3 11948 if (CN1 == INT64_C(538)) { 11949 SDValue N2 = N.getOperand(2); 11950 SDValue CPTmpN2_0; 11951 SDValue CPTmpN2_1; 11952 SDValue CPTmpN2_2; 11953 SDValue CPTmpN2_3; 11954 SDValue CPTmpN2_4; 11955 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 11956 SDNode *Result = Emit_99(N, X86::MOVNTDQmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 11957 return Result; 11958 } 11959 } 11960 11961 // Pattern: (intrinsic_void:isVoid 539:iPTR, addr:iPTR:$dst, GR32:i32:$src) 11962 // Emits: (MOVNTImr:isVoid addr:iPTR:$dst, GR32:i32:$src) 11963 // Pattern complexity = 26 cost = 1 size = 3 11964 if (CN1 == INT64_C(539)) { 11965 SDValue N2 = N.getOperand(2); 11966 SDValue CPTmpN2_0; 11967 SDValue CPTmpN2_1; 11968 SDValue CPTmpN2_2; 11969 SDValue CPTmpN2_3; 11970 SDValue CPTmpN2_4; 11971 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 11972 SDNode *Result = Emit_99(N, X86::MOVNTImr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 11973 return Result; 11974 } 11975 } 11976 11977 // Pattern: (intrinsic_void:isVoid 502:iPTR, addr:iPTR:$src) 11978 // Emits: (CLFLUSH:isVoid addr:iPTR:$src) 11979 // Pattern complexity = 26 cost = 1 size = 3 11980 if (CN1 == INT64_C(502)) { 11981 SDValue N2 = N.getOperand(2); 11982 SDValue CPTmpN2_0; 11983 SDValue CPTmpN2_1; 11984 SDValue CPTmpN2_2; 11985 SDValue CPTmpN2_3; 11986 SDValue CPTmpN2_4; 11987 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 11988 SDNode *Result = Emit_101(N, X86::CLFLUSH, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 11989 return Result; 11990 } 11991 } 11992 11993 // Pattern: (intrinsic_void:isVoid 593:iPTR, addr:iPTR:$dst, VR128:v4i32:$src) 11994 // Emits: (MOVLQ128mr:isVoid addr:iPTR:$dst, VR128:v4i32:$src) 11995 // Pattern complexity = 26 cost = 1 size = 3 11996 if (CN1 == INT64_C(593)) { 11997 SDValue N2 = N.getOperand(2); 11998 SDValue CPTmpN2_0; 11999 SDValue CPTmpN2_1; 12000 SDValue CPTmpN2_2; 12001 SDValue CPTmpN2_3; 12002 SDValue CPTmpN2_4; 12003 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 12004 SDNode *Result = Emit_99(N, X86::MOVLQ128mr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 12005 return Result; 12006 } 12007 } 12008 } 12009 } 12010 12011 // Pattern: (intrinsic_void:isVoid 455:iPTR, addr:iPTR:$dst, VR64:v1i64:$src) 12012 // Emits: (MMX_MOVNTQmr:isVoid addr:iPTR:$dst, VR64:v1i64:$src) 12013 // Pattern complexity = 26 cost = 1 size = 3 12014 if ((Subtarget->hasMMX())) { 12015 SDValue Chain = N.getOperand(0); 12016 SDValue N1 = N.getOperand(1); 12017 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 12018 if (Tmp0) { 12019 int64_t CN1 = Tmp0->getSExtValue(); 12020 if (CN1 == INT64_C(455)) { 12021 SDValue N2 = N.getOperand(2); 12022 SDValue CPTmpN2_0; 12023 SDValue CPTmpN2_1; 12024 SDValue CPTmpN2_2; 12025 SDValue CPTmpN2_3; 12026 SDValue CPTmpN2_4; 12027 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 12028 SDNode *Result = Emit_99(N, X86::MMX_MOVNTQmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 12029 return Result; 12030 } 12031 } 12032 } 12033 } 12034 12035 // Pattern: (intrinsic_void:isVoid 713:iPTR) 12036 // Emits: (SFENCE:isVoid) 12037 // Pattern complexity = 8 cost = 1 size = 3 12038 if ((Subtarget->hasSSE1())) { 12039 SDValue Chain = N.getOperand(0); 12040 SDValue N1 = N.getOperand(1); 12041 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 12042 if (Tmp0) { 12043 int64_t CN1 = Tmp0->getSExtValue(); 12044 if (CN1 == INT64_C(713)) { 12045 SDNode *Result = Emit_100(N, X86::SFENCE); 12046 return Result; 12047 } 12048 } 12049 } 12050 if ((Subtarget->hasSSE2())) { 12051 SDValue Chain = N.getOperand(0); 12052 SDValue N1 = N.getOperand(1); 12053 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 12054 if (Tmp0) { 12055 int64_t CN1 = Tmp0->getSExtValue(); 12056 if (CN1 == INT64_C(531)) { 12057 SDValue N2 = N.getOperand(2); 12058 SDValue N3 = N.getOperand(3); 12059 SDValue N4 = N.getOperand(4); 12060 12061 // Pattern: (intrinsic_void:isVoid 531:iPTR, VR128:v16i8:$src, VR128:v16i8:$mask, EDI:i32) 12062 // Emits: (MASKMOVDQU:isVoid VR128:v16i8:$src, VR128:v16i8:$mask) 12063 // Pattern complexity = 8 cost = 1 size = 3 12064 if (N4.getNode()->getValueType(0) == MVT::i32) { 12065 SDNode *Result = Emit_102(N, X86::MASKMOVDQU); 12066 return Result; 12067 } 12068 12069 // Pattern: (intrinsic_void:isVoid 531:iPTR, VR128:v16i8:$src, VR128:v16i8:$mask, RDI:i64) 12070 // Emits: (MASKMOVDQU64:isVoid VR128:v16i8:$src, VR128:v16i8:$mask) 12071 // Pattern complexity = 8 cost = 1 size = 3 12072 if (N4.getNode()->getValueType(0) == MVT::i64) { 12073 SDNode *Result = Emit_103(N, X86::MASKMOVDQU64); 12074 return Result; 12075 } 12076 } 12077 12078 // Pattern: (intrinsic_void:isVoid 528:iPTR) 12079 // Emits: (LFENCE:isVoid) 12080 // Pattern complexity = 8 cost = 1 size = 3 12081 if (CN1 == INT64_C(528)) { 12082 SDNode *Result = Emit_100(N, X86::LFENCE); 12083 return Result; 12084 } 12085 12086 // Pattern: (intrinsic_void:isVoid 534:iPTR) 12087 // Emits: (MFENCE:isVoid) 12088 // Pattern complexity = 8 cost = 1 size = 3 12089 if (CN1 == INT64_C(534)) { 12090 SDNode *Result = Emit_100(N, X86::MFENCE); 12091 return Result; 12092 } 12093 } 12094 } 12095 if ((Subtarget->hasSSE3())) { 12096 SDValue Chain = N.getOperand(0); 12097 SDValue N1 = N.getOperand(1); 12098 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 12099 if (Tmp0) { 12100 int64_t CN1 = Tmp0->getSExtValue(); 12101 12102 // Pattern: (intrinsic_void:isVoid 610:iPTR, EAX:i32, ECX:i32, EDX:i32) 12103 // Emits: (MONITOR:isVoid) 12104 // Pattern complexity = 8 cost = 1 size = 3 12105 if (CN1 == INT64_C(610)) { 12106 SDValue N2 = N.getOperand(2); 12107 SDValue N3 = N.getOperand(3); 12108 SDValue N4 = N.getOperand(4); 12109 if (N2.getNode()->getValueType(0) == MVT::i32) { 12110 SDNode *Result = Emit_104(N, X86::MONITOR); 12111 return Result; 12112 } 12113 } 12114 12115 // Pattern: (intrinsic_void:isVoid 611:iPTR, ECX:i32, EAX:i32) 12116 // Emits: (MWAIT:isVoid) 12117 // Pattern complexity = 8 cost = 1 size = 3 12118 if (CN1 == INT64_C(611)) { 12119 SDNode *Result = Emit_105(N, X86::MWAIT); 12120 return Result; 12121 } 12122 } 12123 } 12124 if ((Subtarget->hasMMX())) { 12125 SDValue Chain = N.getOperand(0); 12126 SDValue N1 = N.getOperand(1); 12127 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 12128 if (Tmp0) { 12129 int64_t CN1 = Tmp0->getSExtValue(); 12130 12131 // Pattern: (intrinsic_void:isVoid 452:iPTR) 12132 // Emits: (MMX_EMMS:isVoid) 12133 // Pattern complexity = 8 cost = 1 size = 3 12134 if (CN1 == INT64_C(452)) { 12135 SDNode *Result = Emit_100(N, X86::MMX_EMMS); 12136 return Result; 12137 } 12138 12139 // Pattern: (intrinsic_void:isVoid 453:iPTR) 12140 // Emits: (MMX_FEMMS:isVoid) 12141 // Pattern complexity = 8 cost = 1 size = 3 12142 if (CN1 == INT64_C(453)) { 12143 SDNode *Result = Emit_100(N, X86::MMX_FEMMS); 12144 return Result; 12145 } 12146 12147 // Pattern: (intrinsic_void:isVoid 454:iPTR, VR64:v8i8:$src, VR64:v8i8:$mask, EDI:i32) 12148 // Emits: (MMX_MASKMOVQ:isVoid VR64:v8i8:$src, VR64:v8i8:$mask) 12149 // Pattern complexity = 8 cost = 1 size = 3 12150 if (CN1 == INT64_C(454)) { 12151 SDValue N2 = N.getOperand(2); 12152 SDValue N3 = N.getOperand(3); 12153 SDValue N4 = N.getOperand(4); 12154 if (N4.getNode()->getValueType(0) == MVT::i32) { 12155 SDNode *Result = Emit_102(N, X86::MMX_MASKMOVQ); 12156 return Result; 12157 } 12158 } 12159 } 12160 } 12161 12162 // Pattern: (intrinsic_void:isVoid 454:iPTR, VR64:v8i8:$src, VR64:v8i8:$mask, RDI:i64) 12163 // Emits: (MMX_MASKMOVQ64:isVoid VR64:v8i8:$src, VR64:v8i8:$mask) 12164 // Pattern complexity = 8 cost = 1 size = 3 12165 if ((Subtarget->hasMMX()) && (Subtarget->is64Bit())) { 12166 SDValue Chain = N.getOperand(0); 12167 SDValue N1 = N.getOperand(1); 12168 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 12169 if (Tmp0) { 12170 int64_t CN1 = Tmp0->getSExtValue(); 12171 if (CN1 == INT64_C(454)) { 12172 SDValue N2 = N.getOperand(2); 12173 SDValue N3 = N.getOperand(3); 12174 SDValue N4 = N.getOperand(4); 12175 if (N4.getNode()->getValueType(0) == MVT::i64) { 12176 SDNode *Result = Emit_103(N, X86::MMX_MASKMOVQ64); 12177 return Result; 12178 } 12179 } 12180 } 12181 } 12182 12183 CannotYetSelectIntrinsic(N); 12184 return NULL; 12185 } 12186 12187 SDNode *Emit_106(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 12188 SDValue N0 = N.getOperand(0); 12189 SDValue N1 = N.getOperand(1); 12190 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N1); 12191 } 12192 SDNode *Emit_107(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 12193 SDValue N0 = N.getOperand(0); 12194 SDValue N1 = N.getOperand(1); 12195 SDValue Chain1 = N1.getOperand(0); 12196 SDValue N11 = N1.getOperand(1); 12197 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 12198 SDValue Ops0[] = { CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1 }; 12199 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 7); 12200 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 12201 return ResNode; 12202 } 12203 SDNode *Emit_108(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN21_0, SDValue &CPTmpN21_1, SDValue &CPTmpN21_2, SDValue &CPTmpN21_3, SDValue &CPTmpN21_4) DISABLE_INLINE { 12204 SDValue N0 = N.getOperand(0); 12205 SDValue N1 = N.getOperand(1); 12206 SDValue N2 = N.getOperand(2); 12207 SDValue Chain2 = N2.getOperand(0); 12208 SDValue N21 = N2.getOperand(1); 12209 SDValue LSI_N2 = CurDAG->getMemOperand(cast<MemSDNode>(N2)->getMemOperand()); 12210 SDValue Ops0[] = { N1, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4, LSI_N2, Chain2 }; 12211 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 12212 ReplaceUses(SDValue(N2.getNode(), 1), SDValue(ResNode, 1)); 12213 return ResNode; 12214 } 12215 SDNode *Emit_109(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 12216 SDValue N0 = N.getOperand(0); 12217 SDValue N1 = N.getOperand(1); 12218 SDValue N2 = N.getOperand(2); 12219 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N1, N2); 12220 } 12221 SDNode *Emit_110(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 12222 SDValue N0 = N.getOperand(0); 12223 SDValue N1 = N.getOperand(1); 12224 SDValue N2 = N.getOperand(2); 12225 SDValue N3 = N.getOperand(3); 12226 SDValue Tmp4 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N3)->getZExtValue()), MVT::i8); 12227 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::i32, N1, N2, Tmp4); 12228 } 12229 SDNode *Emit_111(const SDValue &N, unsigned Opc0, SDValue &CPTmpN21_0, SDValue &CPTmpN21_1, SDValue &CPTmpN21_2, SDValue &CPTmpN21_3, SDValue &CPTmpN21_4) DISABLE_INLINE { 12230 SDValue N0 = N.getOperand(0); 12231 SDValue N1 = N.getOperand(1); 12232 SDValue N2 = N.getOperand(2); 12233 SDValue Chain2 = N2.getOperand(0); 12234 SDValue N21 = N2.getOperand(1); 12235 SDValue N3 = N.getOperand(3); 12236 SDValue Tmp4 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N3)->getZExtValue()), MVT::i8); 12237 SDValue LSI_N2 = CurDAG->getMemOperand(cast<MemSDNode>(N2)->getMemOperand()); 12238 SDValue Ops0[] = { N1, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4, Tmp4, LSI_N2, Chain2 }; 12239 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::i32, MVT::Other, Ops0, 9); 12240 ReplaceUses(SDValue(N2.getNode(), 1), SDValue(ResNode, 2)); 12241 return ResNode; 12242 } 12243 SDNode *Emit_112(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 12244 SDValue N0 = N.getOperand(0); 12245 SDValue N1 = N.getOperand(1); 12246 SDValue N2 = N.getOperand(2); 12247 SDValue N3 = N.getOperand(3); 12248 SDValue N4 = N.getOperand(4); 12249 SDValue N5 = N.getOperand(5); 12250 SDValue Tmp4 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N5)->getZExtValue()), MVT::i8); 12251 SDValue Chain = CurDAG->getEntryNode(); 12252 SDValue InFlag(0, 0); 12253 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::EAX, N2, InFlag).getNode(); 12254 Chain = SDValue(ResNode, 0); 12255 InFlag = SDValue(ResNode, 1); 12256 ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::EDX, N4, InFlag).getNode(); 12257 Chain = SDValue(ResNode, 0); 12258 InFlag = SDValue(ResNode, 1); 12259 SDValue Ops0[] = { N1, N3, Tmp4, InFlag }; 12260 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::i32, Ops0, 4); 12261 } 12262 SDNode *Emit_113(const SDValue &N, unsigned Opc0, SDValue &CPTmpN31_0, SDValue &CPTmpN31_1, SDValue &CPTmpN31_2, SDValue &CPTmpN31_3, SDValue &CPTmpN31_4) DISABLE_INLINE { 12263 SDValue N0 = N.getOperand(0); 12264 SDValue N1 = N.getOperand(1); 12265 SDValue N2 = N.getOperand(2); 12266 SDValue N3 = N.getOperand(3); 12267 SDValue Chain3 = N3.getOperand(0); 12268 SDValue N31 = N3.getOperand(1); 12269 SDValue N4 = N.getOperand(4); 12270 SDValue N5 = N.getOperand(5); 12271 SDValue Tmp4 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N5)->getZExtValue()), MVT::i8); 12272 SDValue InFlag(0, 0); 12273 SDNode *ResNode = CurDAG->getCopyToReg(Chain3, N.getDebugLoc(), X86::EAX, N2, InFlag).getNode(); 12274 Chain3 = SDValue(ResNode, 0); 12275 InFlag = SDValue(ResNode, 1); 12276 ResNode = CurDAG->getCopyToReg(Chain3, N.getDebugLoc(), X86::EDX, N4, InFlag).getNode(); 12277 Chain3 = SDValue(ResNode, 0); 12278 InFlag = SDValue(ResNode, 1); 12279 SDValue LSI_N3 = CurDAG->getMemOperand(cast<MemSDNode>(N3)->getMemOperand()); 12280 SDValue Ops0[] = { N1, CPTmpN31_0, CPTmpN31_1, CPTmpN31_2, CPTmpN31_3, CPTmpN31_4, Tmp4, LSI_N3, Chain3, InFlag }; 12281 ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::i32, MVT::Other, Ops0, 10); 12282 ReplaceUses(SDValue(N3.getNode(), 1), SDValue(ResNode, 2)); 12283 return ResNode; 12284 } 12285 SDNode *Select_ISD_INTRINSIC_WO_CHAIN_i32(const SDValue &N) { 12286 if (OptLevel != CodeGenOpt::None) { 12287 if ((Subtarget->hasSSE42())) { 12288 SDValue N0 = N.getOperand(0); 12289 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 12290 if (Tmp0) { 12291 int64_t CN1 = Tmp0->getSExtValue(); 12292 12293 // Pattern: (intrinsic_wo_chain:i32 671:iPTR, VR128:v16i8:$src1, (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i8):$src3) 12294 // Emits: (PCMPISTRIrm:isVoid VR128:v16i8:$src1, addr:iPTR:$src2, (imm:i8):$src3) 12295 // Pattern complexity = 33 cost = 1 size = 3 12296 if (CN1 == INT64_C(671)) { 12297 SDValue N1 = N.getOperand(1); 12298 SDValue N2 = N.getOperand(2); 12299 if (N2.getOpcode() == ISD::LOAD && 12300 N2.hasOneUse() && 12301 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 12302 SDValue Chain2 = N2.getOperand(0); 12303 if (Predicate_unindexedload(N2.getNode()) && 12304 Predicate_load(N2.getNode())) { 12305 SDValue N21 = N2.getOperand(1); 12306 SDValue CPTmpN21_0; 12307 SDValue CPTmpN21_1; 12308 SDValue CPTmpN21_2; 12309 SDValue CPTmpN21_3; 12310 SDValue CPTmpN21_4; 12311 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 12312 SDValue N3 = N.getOperand(3); 12313 if (N3.getOpcode() == ISD::Constant) { 12314 SDNode *Result = Emit_111(N, X86::PCMPISTRIrm, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 12315 return Result; 12316 } 12317 } 12318 } 12319 } 12320 } 12321 12322 // Pattern: (intrinsic_wo_chain:i32 672:iPTR, VR128:v16i8:$src1, (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i8):$src3) 12323 // Emits: (PCMPISTRIArm:isVoid VR128:v16i8:$src1, addr:iPTR:$src2, (imm:i8):$src3) 12324 // Pattern complexity = 33 cost = 1 size = 3 12325 if (CN1 == INT64_C(672)) { 12326 SDValue N1 = N.getOperand(1); 12327 SDValue N2 = N.getOperand(2); 12328 if (N2.getOpcode() == ISD::LOAD && 12329 N2.hasOneUse() && 12330 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 12331 SDValue Chain2 = N2.getOperand(0); 12332 if (Predicate_unindexedload(N2.getNode()) && 12333 Predicate_load(N2.getNode())) { 12334 SDValue N21 = N2.getOperand(1); 12335 SDValue CPTmpN21_0; 12336 SDValue CPTmpN21_1; 12337 SDValue CPTmpN21_2; 12338 SDValue CPTmpN21_3; 12339 SDValue CPTmpN21_4; 12340 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 12341 SDValue N3 = N.getOperand(3); 12342 if (N3.getOpcode() == ISD::Constant) { 12343 SDNode *Result = Emit_111(N, X86::PCMPISTRIArm, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 12344 return Result; 12345 } 12346 } 12347 } 12348 } 12349 } 12350 12351 // Pattern: (intrinsic_wo_chain:i32 673:iPTR, VR128:v16i8:$src1, (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i8):$src3) 12352 // Emits: (PCMPISTRICrm:isVoid VR128:v16i8:$src1, addr:iPTR:$src2, (imm:i8):$src3) 12353 // Pattern complexity = 33 cost = 1 size = 3 12354 if (CN1 == INT64_C(673)) { 12355 SDValue N1 = N.getOperand(1); 12356 SDValue N2 = N.getOperand(2); 12357 if (N2.getOpcode() == ISD::LOAD && 12358 N2.hasOneUse() && 12359 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 12360 SDValue Chain2 = N2.getOperand(0); 12361 if (Predicate_unindexedload(N2.getNode()) && 12362 Predicate_load(N2.getNode())) { 12363 SDValue N21 = N2.getOperand(1); 12364 SDValue CPTmpN21_0; 12365 SDValue CPTmpN21_1; 12366 SDValue CPTmpN21_2; 12367 SDValue CPTmpN21_3; 12368 SDValue CPTmpN21_4; 12369 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 12370 SDValue N3 = N.getOperand(3); 12371 if (N3.getOpcode() == ISD::Constant) { 12372 SDNode *Result = Emit_111(N, X86::PCMPISTRICrm, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 12373 return Result; 12374 } 12375 } 12376 } 12377 } 12378 } 12379 12380 // Pattern: (intrinsic_wo_chain:i32 674:iPTR, VR128:v16i8:$src1, (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i8):$src3) 12381 // Emits: (PCMPISTRIOrm:isVoid VR128:v16i8:$src1, addr:iPTR:$src2, (imm:i8):$src3) 12382 // Pattern complexity = 33 cost = 1 size = 3 12383 if (CN1 == INT64_C(674)) { 12384 SDValue N1 = N.getOperand(1); 12385 SDValue N2 = N.getOperand(2); 12386 if (N2.getOpcode() == ISD::LOAD && 12387 N2.hasOneUse() && 12388 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 12389 SDValue Chain2 = N2.getOperand(0); 12390 if (Predicate_unindexedload(N2.getNode()) && 12391 Predicate_load(N2.getNode())) { 12392 SDValue N21 = N2.getOperand(1); 12393 SDValue CPTmpN21_0; 12394 SDValue CPTmpN21_1; 12395 SDValue CPTmpN21_2; 12396 SDValue CPTmpN21_3; 12397 SDValue CPTmpN21_4; 12398 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 12399 SDValue N3 = N.getOperand(3); 12400 if (N3.getOpcode() == ISD::Constant) { 12401 SDNode *Result = Emit_111(N, X86::PCMPISTRIOrm, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 12402 return Result; 12403 } 12404 } 12405 } 12406 } 12407 } 12408 12409 // Pattern: (intrinsic_wo_chain:i32 675:iPTR, VR128:v16i8:$src1, (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i8):$src3) 12410 // Emits: (PCMPISTRISrm:isVoid VR128:v16i8:$src1, addr:iPTR:$src2, (imm:i8):$src3) 12411 // Pattern complexity = 33 cost = 1 size = 3 12412 if (CN1 == INT64_C(675)) { 12413 SDValue N1 = N.getOperand(1); 12414 SDValue N2 = N.getOperand(2); 12415 if (N2.getOpcode() == ISD::LOAD && 12416 N2.hasOneUse() && 12417 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 12418 SDValue Chain2 = N2.getOperand(0); 12419 if (Predicate_unindexedload(N2.getNode()) && 12420 Predicate_load(N2.getNode())) { 12421 SDValue N21 = N2.getOperand(1); 12422 SDValue CPTmpN21_0; 12423 SDValue CPTmpN21_1; 12424 SDValue CPTmpN21_2; 12425 SDValue CPTmpN21_3; 12426 SDValue CPTmpN21_4; 12427 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 12428 SDValue N3 = N.getOperand(3); 12429 if (N3.getOpcode() == ISD::Constant) { 12430 SDNode *Result = Emit_111(N, X86::PCMPISTRISrm, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 12431 return Result; 12432 } 12433 } 12434 } 12435 } 12436 } 12437 12438 // Pattern: (intrinsic_wo_chain:i32 676:iPTR, VR128:v16i8:$src1, (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i8):$src3) 12439 // Emits: (PCMPISTRIZrm:isVoid VR128:v16i8:$src1, addr:iPTR:$src2, (imm:i8):$src3) 12440 // Pattern complexity = 33 cost = 1 size = 3 12441 if (CN1 == INT64_C(676)) { 12442 SDValue N1 = N.getOperand(1); 12443 SDValue N2 = N.getOperand(2); 12444 if (N2.getOpcode() == ISD::LOAD && 12445 N2.hasOneUse() && 12446 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 12447 SDValue Chain2 = N2.getOperand(0); 12448 if (Predicate_unindexedload(N2.getNode()) && 12449 Predicate_load(N2.getNode())) { 12450 SDValue N21 = N2.getOperand(1); 12451 SDValue CPTmpN21_0; 12452 SDValue CPTmpN21_1; 12453 SDValue CPTmpN21_2; 12454 SDValue CPTmpN21_3; 12455 SDValue CPTmpN21_4; 12456 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 12457 SDValue N3 = N.getOperand(3); 12458 if (N3.getOpcode() == ISD::Constant) { 12459 SDNode *Result = Emit_111(N, X86::PCMPISTRIZrm, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 12460 return Result; 12461 } 12462 } 12463 } 12464 } 12465 } 12466 12467 // Pattern: (intrinsic_wo_chain:i32 663:iPTR, VR128:v16i8:$src1, EAX:i32, (ld:v16i8 addr:iPTR:$src3)<<P:Predicate_unindexedload>><<P:Predicate_load>>, EDX:i32, (imm:i8):$src5) 12468 // Emits: (PCMPESTRIrm:isVoid VR128:v16i8:$src1, addr:iPTR:$src3, (imm:i8):$src5) 12469 // Pattern complexity = 33 cost = 1 size = 3 12470 if (CN1 == INT64_C(663)) { 12471 SDValue N1 = N.getOperand(1); 12472 SDValue N2 = N.getOperand(2); 12473 SDValue N3 = N.getOperand(3); 12474 if (N3.getOpcode() == ISD::LOAD && 12475 N3.hasOneUse() && 12476 IsLegalAndProfitableToFold(N3.getNode(), N.getNode(), N.getNode())) { 12477 SDValue Chain3 = N3.getOperand(0); 12478 if (Predicate_unindexedload(N3.getNode()) && 12479 Predicate_load(N3.getNode())) { 12480 SDValue N31 = N3.getOperand(1); 12481 SDValue CPTmpN31_0; 12482 SDValue CPTmpN31_1; 12483 SDValue CPTmpN31_2; 12484 SDValue CPTmpN31_3; 12485 SDValue CPTmpN31_4; 12486 if (SelectAddr(N, N31, CPTmpN31_0, CPTmpN31_1, CPTmpN31_2, CPTmpN31_3, CPTmpN31_4)) { 12487 SDValue N4 = N.getOperand(4); 12488 SDValue N5 = N.getOperand(5); 12489 if (N5.getOpcode() == ISD::Constant) { 12490 SDNode *Result = Emit_113(N, X86::PCMPESTRIrm, CPTmpN31_0, CPTmpN31_1, CPTmpN31_2, CPTmpN31_3, CPTmpN31_4); 12491 return Result; 12492 } 12493 } 12494 } 12495 } 12496 } 12497 12498 // Pattern: (intrinsic_wo_chain:i32 664:iPTR, VR128:v16i8:$src1, EAX:i32, (ld:v16i8 addr:iPTR:$src3)<<P:Predicate_unindexedload>><<P:Predicate_load>>, EDX:i32, (imm:i8):$src5) 12499 // Emits: (PCMPESTRIArm:isVoid VR128:v16i8:$src1, addr:iPTR:$src3, (imm:i8):$src5) 12500 // Pattern complexity = 33 cost = 1 size = 3 12501 if (CN1 == INT64_C(664)) { 12502 SDValue N1 = N.getOperand(1); 12503 SDValue N2 = N.getOperand(2); 12504 SDValue N3 = N.getOperand(3); 12505 if (N3.getOpcode() == ISD::LOAD && 12506 N3.hasOneUse() && 12507 IsLegalAndProfitableToFold(N3.getNode(), N.getNode(), N.getNode())) { 12508 SDValue Chain3 = N3.getOperand(0); 12509 if (Predicate_unindexedload(N3.getNode()) && 12510 Predicate_load(N3.getNode())) { 12511 SDValue N31 = N3.getOperand(1); 12512 SDValue CPTmpN31_0; 12513 SDValue CPTmpN31_1; 12514 SDValue CPTmpN31_2; 12515 SDValue CPTmpN31_3; 12516 SDValue CPTmpN31_4; 12517 if (SelectAddr(N, N31, CPTmpN31_0, CPTmpN31_1, CPTmpN31_2, CPTmpN31_3, CPTmpN31_4)) { 12518 SDValue N4 = N.getOperand(4); 12519 SDValue N5 = N.getOperand(5); 12520 if (N5.getOpcode() == ISD::Constant) { 12521 SDNode *Result = Emit_113(N, X86::PCMPESTRIArm, CPTmpN31_0, CPTmpN31_1, CPTmpN31_2, CPTmpN31_3, CPTmpN31_4); 12522 return Result; 12523 } 12524 } 12525 } 12526 } 12527 } 12528 12529 // Pattern: (intrinsic_wo_chain:i32 665:iPTR, VR128:v16i8:$src1, EAX:i32, (ld:v16i8 addr:iPTR:$src3)<<P:Predicate_unindexedload>><<P:Predicate_load>>, EDX:i32, (imm:i8):$src5) 12530 // Emits: (PCMPESTRICrm:isVoid VR128:v16i8:$src1, addr:iPTR:$src3, (imm:i8):$src5) 12531 // Pattern complexity = 33 cost = 1 size = 3 12532 if (CN1 == INT64_C(665)) { 12533 SDValue N1 = N.getOperand(1); 12534 SDValue N2 = N.getOperand(2); 12535 SDValue N3 = N.getOperand(3); 12536 if (N3.getOpcode() == ISD::LOAD && 12537 N3.hasOneUse() && 12538 IsLegalAndProfitableToFold(N3.getNode(), N.getNode(), N.getNode())) { 12539 SDValue Chain3 = N3.getOperand(0); 12540 if (Predicate_unindexedload(N3.getNode()) && 12541 Predicate_load(N3.getNode())) { 12542 SDValue N31 = N3.getOperand(1); 12543 SDValue CPTmpN31_0; 12544 SDValue CPTmpN31_1; 12545 SDValue CPTmpN31_2; 12546 SDValue CPTmpN31_3; 12547 SDValue CPTmpN31_4; 12548 if (SelectAddr(N, N31, CPTmpN31_0, CPTmpN31_1, CPTmpN31_2, CPTmpN31_3, CPTmpN31_4)) { 12549 SDValue N4 = N.getOperand(4); 12550 SDValue N5 = N.getOperand(5); 12551 if (N5.getOpcode() == ISD::Constant) { 12552 SDNode *Result = Emit_113(N, X86::PCMPESTRICrm, CPTmpN31_0, CPTmpN31_1, CPTmpN31_2, CPTmpN31_3, CPTmpN31_4); 12553 return Result; 12554 } 12555 } 12556 } 12557 } 12558 } 12559 12560 // Pattern: (intrinsic_wo_chain:i32 666:iPTR, VR128:v16i8:$src1, EAX:i32, (ld:v16i8 addr:iPTR:$src3)<<P:Predicate_unindexedload>><<P:Predicate_load>>, EDX:i32, (imm:i8):$src5) 12561 // Emits: (PCMPESTRIOrm:isVoid VR128:v16i8:$src1, addr:iPTR:$src3, (imm:i8):$src5) 12562 // Pattern complexity = 33 cost = 1 size = 3 12563 if (CN1 == INT64_C(666)) { 12564 SDValue N1 = N.getOperand(1); 12565 SDValue N2 = N.getOperand(2); 12566 SDValue N3 = N.getOperand(3); 12567 if (N3.getOpcode() == ISD::LOAD && 12568 N3.hasOneUse() && 12569 IsLegalAndProfitableToFold(N3.getNode(), N.getNode(), N.getNode())) { 12570 SDValue Chain3 = N3.getOperand(0); 12571 if (Predicate_unindexedload(N3.getNode()) && 12572 Predicate_load(N3.getNode())) { 12573 SDValue N31 = N3.getOperand(1); 12574 SDValue CPTmpN31_0; 12575 SDValue CPTmpN31_1; 12576 SDValue CPTmpN31_2; 12577 SDValue CPTmpN31_3; 12578 SDValue CPTmpN31_4; 12579 if (SelectAddr(N, N31, CPTmpN31_0, CPTmpN31_1, CPTmpN31_2, CPTmpN31_3, CPTmpN31_4)) { 12580 SDValue N4 = N.getOperand(4); 12581 SDValue N5 = N.getOperand(5); 12582 if (N5.getOpcode() == ISD::Constant) { 12583 SDNode *Result = Emit_113(N, X86::PCMPESTRIOrm, CPTmpN31_0, CPTmpN31_1, CPTmpN31_2, CPTmpN31_3, CPTmpN31_4); 12584 return Result; 12585 } 12586 } 12587 } 12588 } 12589 } 12590 12591 // Pattern: (intrinsic_wo_chain:i32 667:iPTR, VR128:v16i8:$src1, EAX:i32, (ld:v16i8 addr:iPTR:$src3)<<P:Predicate_unindexedload>><<P:Predicate_load>>, EDX:i32, (imm:i8):$src5) 12592 // Emits: (PCMPESTRISrm:isVoid VR128:v16i8:$src1, addr:iPTR:$src3, (imm:i8):$src5) 12593 // Pattern complexity = 33 cost = 1 size = 3 12594 if (CN1 == INT64_C(667)) { 12595 SDValue N1 = N.getOperand(1); 12596 SDValue N2 = N.getOperand(2); 12597 SDValue N3 = N.getOperand(3); 12598 if (N3.getOpcode() == ISD::LOAD && 12599 N3.hasOneUse() && 12600 IsLegalAndProfitableToFold(N3.getNode(), N.getNode(), N.getNode())) { 12601 SDValue Chain3 = N3.getOperand(0); 12602 if (Predicate_unindexedload(N3.getNode()) && 12603 Predicate_load(N3.getNode())) { 12604 SDValue N31 = N3.getOperand(1); 12605 SDValue CPTmpN31_0; 12606 SDValue CPTmpN31_1; 12607 SDValue CPTmpN31_2; 12608 SDValue CPTmpN31_3; 12609 SDValue CPTmpN31_4; 12610 if (SelectAddr(N, N31, CPTmpN31_0, CPTmpN31_1, CPTmpN31_2, CPTmpN31_3, CPTmpN31_4)) { 12611 SDValue N4 = N.getOperand(4); 12612 SDValue N5 = N.getOperand(5); 12613 if (N5.getOpcode() == ISD::Constant) { 12614 SDNode *Result = Emit_113(N, X86::PCMPESTRISrm, CPTmpN31_0, CPTmpN31_1, CPTmpN31_2, CPTmpN31_3, CPTmpN31_4); 12615 return Result; 12616 } 12617 } 12618 } 12619 } 12620 } 12621 12622 // Pattern: (intrinsic_wo_chain:i32 668:iPTR, VR128:v16i8:$src1, EAX:i32, (ld:v16i8 addr:iPTR:$src3)<<P:Predicate_unindexedload>><<P:Predicate_load>>, EDX:i32, (imm:i8):$src5) 12623 // Emits: (PCMPESTRIZrm:isVoid VR128:v16i8:$src1, addr:iPTR:$src3, (imm:i8):$src5) 12624 // Pattern complexity = 33 cost = 1 size = 3 12625 if (CN1 == INT64_C(668)) { 12626 SDValue N1 = N.getOperand(1); 12627 SDValue N2 = N.getOperand(2); 12628 SDValue N3 = N.getOperand(3); 12629 if (N3.getOpcode() == ISD::LOAD && 12630 N3.hasOneUse() && 12631 IsLegalAndProfitableToFold(N3.getNode(), N.getNode(), N.getNode())) { 12632 SDValue Chain3 = N3.getOperand(0); 12633 if (Predicate_unindexedload(N3.getNode()) && 12634 Predicate_load(N3.getNode())) { 12635 SDValue N31 = N3.getOperand(1); 12636 SDValue CPTmpN31_0; 12637 SDValue CPTmpN31_1; 12638 SDValue CPTmpN31_2; 12639 SDValue CPTmpN31_3; 12640 SDValue CPTmpN31_4; 12641 if (SelectAddr(N, N31, CPTmpN31_0, CPTmpN31_1, CPTmpN31_2, CPTmpN31_3, CPTmpN31_4)) { 12642 SDValue N4 = N.getOperand(4); 12643 SDValue N5 = N.getOperand(5); 12644 if (N5.getOpcode() == ISD::Constant) { 12645 SDNode *Result = Emit_113(N, X86::PCMPESTRIZrm, CPTmpN31_0, CPTmpN31_1, CPTmpN31_2, CPTmpN31_3, CPTmpN31_4); 12646 return Result; 12647 } 12648 } 12649 } 12650 } 12651 } 12652 } 12653 } 12654 if ((Subtarget->hasSSE1())) { 12655 SDValue N0 = N.getOperand(0); 12656 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 12657 if (Tmp0) { 12658 int64_t CN1 = Tmp0->getSExtValue(); 12659 12660 // Pattern: (intrinsic_wo_chain:i32 693:iPTR, (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 12661 // Emits: (Int_CVTSS2SIrm:i32 addr:iPTR:$src) 12662 // Pattern complexity = 30 cost = 1 size = 3 12663 if (CN1 == INT64_C(693)) { 12664 SDValue N1 = N.getOperand(1); 12665 if (N1.getOpcode() == ISD::LOAD && 12666 N1.hasOneUse() && 12667 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 12668 SDValue Chain1 = N1.getOperand(0); 12669 if (Predicate_unindexedload(N1.getNode()) && 12670 Predicate_load(N1.getNode())) { 12671 SDValue N11 = N1.getOperand(1); 12672 SDValue CPTmpN11_0; 12673 SDValue CPTmpN11_1; 12674 SDValue CPTmpN11_2; 12675 SDValue CPTmpN11_3; 12676 SDValue CPTmpN11_4; 12677 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 12678 SDNode *Result = Emit_107(N, X86::Int_CVTSS2SIrm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 12679 return Result; 12680 } 12681 } 12682 } 12683 } 12684 12685 // Pattern: (intrinsic_wo_chain:i32 697:iPTR, (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 12686 // Emits: (Int_CVTTSS2SIrm:i32 addr:iPTR:$src) 12687 // Pattern complexity = 30 cost = 1 size = 3 12688 if (CN1 == INT64_C(697)) { 12689 SDValue N1 = N.getOperand(1); 12690 if (N1.getOpcode() == ISD::LOAD && 12691 N1.hasOneUse() && 12692 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 12693 SDValue Chain1 = N1.getOperand(0); 12694 if (Predicate_unindexedload(N1.getNode()) && 12695 Predicate_load(N1.getNode())) { 12696 SDValue N11 = N1.getOperand(1); 12697 SDValue CPTmpN11_0; 12698 SDValue CPTmpN11_1; 12699 SDValue CPTmpN11_2; 12700 SDValue CPTmpN11_3; 12701 SDValue CPTmpN11_4; 12702 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 12703 SDNode *Result = Emit_107(N, X86::Int_CVTTSS2SIrm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 12704 return Result; 12705 } 12706 } 12707 } 12708 } 12709 } 12710 } 12711 if ((Subtarget->hasSSE2())) { 12712 SDValue N0 = N.getOperand(0); 12713 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 12714 if (Tmp0) { 12715 int64_t CN1 = Tmp0->getSExtValue(); 12716 12717 // Pattern: (intrinsic_wo_chain:i32 517:iPTR, (ld:v2f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 12718 // Emits: (Int_CVTSD2SIrm:i32 addr:iPTR:$src) 12719 // Pattern complexity = 30 cost = 1 size = 3 12720 if (CN1 == INT64_C(517)) { 12721 SDValue N1 = N.getOperand(1); 12722 if (N1.getOpcode() == ISD::LOAD && 12723 N1.hasOneUse() && 12724 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 12725 SDValue Chain1 = N1.getOperand(0); 12726 if (Predicate_unindexedload(N1.getNode()) && 12727 Predicate_load(N1.getNode())) { 12728 SDValue N11 = N1.getOperand(1); 12729 SDValue CPTmpN11_0; 12730 SDValue CPTmpN11_1; 12731 SDValue CPTmpN11_2; 12732 SDValue CPTmpN11_3; 12733 SDValue CPTmpN11_4; 12734 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 12735 SDNode *Result = Emit_107(N, X86::Int_CVTSD2SIrm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 12736 return Result; 12737 } 12738 } 12739 } 12740 } 12741 12742 // Pattern: (intrinsic_wo_chain:i32 525:iPTR, (ld:v2f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 12743 // Emits: (Int_CVTTSD2SIrm:i32 addr:iPTR:$src) 12744 // Pattern complexity = 30 cost = 1 size = 3 12745 if (CN1 == INT64_C(525)) { 12746 SDValue N1 = N.getOperand(1); 12747 if (N1.getOpcode() == ISD::LOAD && 12748 N1.hasOneUse() && 12749 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 12750 SDValue Chain1 = N1.getOperand(0); 12751 if (Predicate_unindexedload(N1.getNode()) && 12752 Predicate_load(N1.getNode())) { 12753 SDValue N11 = N1.getOperand(1); 12754 SDValue CPTmpN11_0; 12755 SDValue CPTmpN11_1; 12756 SDValue CPTmpN11_2; 12757 SDValue CPTmpN11_3; 12758 SDValue CPTmpN11_4; 12759 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 12760 SDNode *Result = Emit_107(N, X86::Int_CVTTSD2SIrm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 12761 return Result; 12762 } 12763 } 12764 } 12765 } 12766 } 12767 } 12768 if ((Subtarget->hasSSE42())) { 12769 SDValue N0 = N.getOperand(0); 12770 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 12771 if (Tmp0) { 12772 int64_t CN1 = Tmp0->getSExtValue(); 12773 12774 // Pattern: (intrinsic_wo_chain:i32 662:iPTR, GR32:i32:$src1, (ld:i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 12775 // Emits: (CRC32m8:i32 GR32:i32:$src1, addr:iPTR:$src2) 12776 // Pattern complexity = 30 cost = 1 size = 3 12777 if (CN1 == INT64_C(662)) { 12778 SDValue N1 = N.getOperand(1); 12779 SDValue N2 = N.getOperand(2); 12780 if (N2.getOpcode() == ISD::LOAD && 12781 N2.hasOneUse() && 12782 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 12783 SDValue Chain2 = N2.getOperand(0); 12784 if (Predicate_unindexedload(N2.getNode()) && 12785 Predicate_load(N2.getNode())) { 12786 SDValue N21 = N2.getOperand(1); 12787 SDValue CPTmpN21_0; 12788 SDValue CPTmpN21_1; 12789 SDValue CPTmpN21_2; 12790 SDValue CPTmpN21_3; 12791 SDValue CPTmpN21_4; 12792 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 12793 SDNode *Result = Emit_108(N, X86::CRC32m8, MVT::i32, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 12794 return Result; 12795 } 12796 } 12797 } 12798 } 12799 12800 // Pattern: (intrinsic_wo_chain:i32 659:iPTR, GR32:i32:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 12801 // Emits: (CRC32m16:i32 GR32:i32:$src1, addr:iPTR:$src2) 12802 // Pattern complexity = 30 cost = 1 size = 3 12803 if (CN1 == INT64_C(659)) { 12804 SDValue N1 = N.getOperand(1); 12805 SDValue N2 = N.getOperand(2); 12806 if (N2.getOpcode() == ISD::LOAD && 12807 N2.hasOneUse() && 12808 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 12809 SDValue Chain2 = N2.getOperand(0); 12810 if (Predicate_unindexedload(N2.getNode()) && 12811 Predicate_load(N2.getNode())) { 12812 SDValue N21 = N2.getOperand(1); 12813 SDValue CPTmpN21_0; 12814 SDValue CPTmpN21_1; 12815 SDValue CPTmpN21_2; 12816 SDValue CPTmpN21_3; 12817 SDValue CPTmpN21_4; 12818 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 12819 SDNode *Result = Emit_108(N, X86::CRC32m16, MVT::i32, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 12820 return Result; 12821 } 12822 } 12823 } 12824 } 12825 12826 // Pattern: (intrinsic_wo_chain:i32 660:iPTR, GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 12827 // Emits: (CRC32m32:i32 GR32:i32:$src1, addr:iPTR:$src2) 12828 // Pattern complexity = 30 cost = 1 size = 3 12829 if (CN1 == INT64_C(660)) { 12830 SDValue N1 = N.getOperand(1); 12831 SDValue N2 = N.getOperand(2); 12832 if (N2.getOpcode() == ISD::LOAD && 12833 N2.hasOneUse() && 12834 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 12835 SDValue Chain2 = N2.getOperand(0); 12836 if (Predicate_unindexedload(N2.getNode()) && 12837 Predicate_load(N2.getNode())) { 12838 SDValue N21 = N2.getOperand(1); 12839 SDValue CPTmpN21_0; 12840 SDValue CPTmpN21_1; 12841 SDValue CPTmpN21_2; 12842 SDValue CPTmpN21_3; 12843 SDValue CPTmpN21_4; 12844 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 12845 SDNode *Result = Emit_108(N, X86::CRC32m32, MVT::i32, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 12846 return Result; 12847 } 12848 } 12849 } 12850 } 12851 } 12852 } 12853 } 12854 if ((Subtarget->hasSSE42())) { 12855 SDValue N0 = N.getOperand(0); 12856 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 12857 if (Tmp0) { 12858 int64_t CN1 = Tmp0->getSExtValue(); 12859 12860 // Pattern: (intrinsic_wo_chain:i32 671:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i8):$src3) 12861 // Emits: (PCMPISTRIrr:isVoid VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i8):$src3) 12862 // Pattern complexity = 11 cost = 1 size = 3 12863 if (CN1 == INT64_C(671)) { 12864 SDValue N1 = N.getOperand(1); 12865 SDValue N2 = N.getOperand(2); 12866 SDValue N3 = N.getOperand(3); 12867 if (N3.getOpcode() == ISD::Constant) { 12868 SDNode *Result = Emit_110(N, X86::PCMPISTRIrr); 12869 return Result; 12870 } 12871 } 12872 12873 // Pattern: (intrinsic_wo_chain:i32 672:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i8):$src3) 12874 // Emits: (PCMPISTRIArr:isVoid VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i8):$src3) 12875 // Pattern complexity = 11 cost = 1 size = 3 12876 if (CN1 == INT64_C(672)) { 12877 SDValue N1 = N.getOperand(1); 12878 SDValue N2 = N.getOperand(2); 12879 SDValue N3 = N.getOperand(3); 12880 if (N3.getOpcode() == ISD::Constant) { 12881 SDNode *Result = Emit_110(N, X86::PCMPISTRIArr); 12882 return Result; 12883 } 12884 } 12885 12886 // Pattern: (intrinsic_wo_chain:i32 673:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i8):$src3) 12887 // Emits: (PCMPISTRICrr:isVoid VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i8):$src3) 12888 // Pattern complexity = 11 cost = 1 size = 3 12889 if (CN1 == INT64_C(673)) { 12890 SDValue N1 = N.getOperand(1); 12891 SDValue N2 = N.getOperand(2); 12892 SDValue N3 = N.getOperand(3); 12893 if (N3.getOpcode() == ISD::Constant) { 12894 SDNode *Result = Emit_110(N, X86::PCMPISTRICrr); 12895 return Result; 12896 } 12897 } 12898 12899 // Pattern: (intrinsic_wo_chain:i32 674:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i8):$src3) 12900 // Emits: (PCMPISTRIOrr:isVoid VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i8):$src3) 12901 // Pattern complexity = 11 cost = 1 size = 3 12902 if (CN1 == INT64_C(674)) { 12903 SDValue N1 = N.getOperand(1); 12904 SDValue N2 = N.getOperand(2); 12905 SDValue N3 = N.getOperand(3); 12906 if (N3.getOpcode() == ISD::Constant) { 12907 SDNode *Result = Emit_110(N, X86::PCMPISTRIOrr); 12908 return Result; 12909 } 12910 } 12911 12912 // Pattern: (intrinsic_wo_chain:i32 675:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i8):$src3) 12913 // Emits: (PCMPISTRISrr:isVoid VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i8):$src3) 12914 // Pattern complexity = 11 cost = 1 size = 3 12915 if (CN1 == INT64_C(675)) { 12916 SDValue N1 = N.getOperand(1); 12917 SDValue N2 = N.getOperand(2); 12918 SDValue N3 = N.getOperand(3); 12919 if (N3.getOpcode() == ISD::Constant) { 12920 SDNode *Result = Emit_110(N, X86::PCMPISTRISrr); 12921 return Result; 12922 } 12923 } 12924 12925 // Pattern: (intrinsic_wo_chain:i32 676:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i8):$src3) 12926 // Emits: (PCMPISTRIZrr:isVoid VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i8):$src3) 12927 // Pattern complexity = 11 cost = 1 size = 3 12928 if (CN1 == INT64_C(676)) { 12929 SDValue N1 = N.getOperand(1); 12930 SDValue N2 = N.getOperand(2); 12931 SDValue N3 = N.getOperand(3); 12932 if (N3.getOpcode() == ISD::Constant) { 12933 SDNode *Result = Emit_110(N, X86::PCMPISTRIZrr); 12934 return Result; 12935 } 12936 } 12937 12938 // Pattern: (intrinsic_wo_chain:i32 663:iPTR, VR128:v16i8:$src1, EAX:i32, VR128:v16i8:$src3, EDX:i32, (imm:i8):$src5) 12939 // Emits: (PCMPESTRIrr:isVoid VR128:v16i8:$src1, VR128:v16i8:$src3, (imm:i8):$src5) 12940 // Pattern complexity = 11 cost = 1 size = 3 12941 if (CN1 == INT64_C(663)) { 12942 SDValue N1 = N.getOperand(1); 12943 SDValue N2 = N.getOperand(2); 12944 SDValue N3 = N.getOperand(3); 12945 SDValue N4 = N.getOperand(4); 12946 SDValue N5 = N.getOperand(5); 12947 if (N5.getOpcode() == ISD::Constant) { 12948 SDNode *Result = Emit_112(N, X86::PCMPESTRIrr); 12949 return Result; 12950 } 12951 } 12952 12953 // Pattern: (intrinsic_wo_chain:i32 664:iPTR, VR128:v16i8:$src1, EAX:i32, VR128:v16i8:$src3, EDX:i32, (imm:i8):$src5) 12954 // Emits: (PCMPESTRIArr:isVoid VR128:v16i8:$src1, VR128:v16i8:$src3, (imm:i8):$src5) 12955 // Pattern complexity = 11 cost = 1 size = 3 12956 if (CN1 == INT64_C(664)) { 12957 SDValue N1 = N.getOperand(1); 12958 SDValue N2 = N.getOperand(2); 12959 SDValue N3 = N.getOperand(3); 12960 SDValue N4 = N.getOperand(4); 12961 SDValue N5 = N.getOperand(5); 12962 if (N5.getOpcode() == ISD::Constant) { 12963 SDNode *Result = Emit_112(N, X86::PCMPESTRIArr); 12964 return Result; 12965 } 12966 } 12967 12968 // Pattern: (intrinsic_wo_chain:i32 665:iPTR, VR128:v16i8:$src1, EAX:i32, VR128:v16i8:$src3, EDX:i32, (imm:i8):$src5) 12969 // Emits: (PCMPESTRICrr:isVoid VR128:v16i8:$src1, VR128:v16i8:$src3, (imm:i8):$src5) 12970 // Pattern complexity = 11 cost = 1 size = 3 12971 if (CN1 == INT64_C(665)) { 12972 SDValue N1 = N.getOperand(1); 12973 SDValue N2 = N.getOperand(2); 12974 SDValue N3 = N.getOperand(3); 12975 SDValue N4 = N.getOperand(4); 12976 SDValue N5 = N.getOperand(5); 12977 if (N5.getOpcode() == ISD::Constant) { 12978 SDNode *Result = Emit_112(N, X86::PCMPESTRICrr); 12979 return Result; 12980 } 12981 } 12982 12983 // Pattern: (intrinsic_wo_chain:i32 666:iPTR, VR128:v16i8:$src1, EAX:i32, VR128:v16i8:$src3, EDX:i32, (imm:i8):$src5) 12984 // Emits: (PCMPESTRIOrr:isVoid VR128:v16i8:$src1, VR128:v16i8:$src3, (imm:i8):$src5) 12985 // Pattern complexity = 11 cost = 1 size = 3 12986 if (CN1 == INT64_C(666)) { 12987 SDValue N1 = N.getOperand(1); 12988 SDValue N2 = N.getOperand(2); 12989 SDValue N3 = N.getOperand(3); 12990 SDValue N4 = N.getOperand(4); 12991 SDValue N5 = N.getOperand(5); 12992 if (N5.getOpcode() == ISD::Constant) { 12993 SDNode *Result = Emit_112(N, X86::PCMPESTRIOrr); 12994 return Result; 12995 } 12996 } 12997 12998 // Pattern: (intrinsic_wo_chain:i32 667:iPTR, VR128:v16i8:$src1, EAX:i32, VR128:v16i8:$src3, EDX:i32, (imm:i8):$src5) 12999 // Emits: (PCMPESTRISrr:isVoid VR128:v16i8:$src1, VR128:v16i8:$src3, (imm:i8):$src5) 13000 // Pattern complexity = 11 cost = 1 size = 3 13001 if (CN1 == INT64_C(667)) { 13002 SDValue N1 = N.getOperand(1); 13003 SDValue N2 = N.getOperand(2); 13004 SDValue N3 = N.getOperand(3); 13005 SDValue N4 = N.getOperand(4); 13006 SDValue N5 = N.getOperand(5); 13007 if (N5.getOpcode() == ISD::Constant) { 13008 SDNode *Result = Emit_112(N, X86::PCMPESTRISrr); 13009 return Result; 13010 } 13011 } 13012 13013 // Pattern: (intrinsic_wo_chain:i32 668:iPTR, VR128:v16i8:$src1, EAX:i32, VR128:v16i8:$src3, EDX:i32, (imm:i8):$src5) 13014 // Emits: (PCMPESTRIZrr:isVoid VR128:v16i8:$src1, VR128:v16i8:$src3, (imm:i8):$src5) 13015 // Pattern complexity = 11 cost = 1 size = 3 13016 if (CN1 == INT64_C(668)) { 13017 SDValue N1 = N.getOperand(1); 13018 SDValue N2 = N.getOperand(2); 13019 SDValue N3 = N.getOperand(3); 13020 SDValue N4 = N.getOperand(4); 13021 SDValue N5 = N.getOperand(5); 13022 if (N5.getOpcode() == ISD::Constant) { 13023 SDNode *Result = Emit_112(N, X86::PCMPESTRIZrr); 13024 return Result; 13025 } 13026 } 13027 } 13028 } 13029 if ((Subtarget->hasSSE1())) { 13030 SDValue N0 = N.getOperand(0); 13031 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 13032 if (Tmp0) { 13033 int64_t CN1 = Tmp0->getSExtValue(); 13034 13035 // Pattern: (intrinsic_wo_chain:i32 693:iPTR, VR128:v4f32:$src) 13036 // Emits: (Int_CVTSS2SIrr:i32 VR128:v4f32:$src) 13037 // Pattern complexity = 8 cost = 1 size = 3 13038 if (CN1 == INT64_C(693)) { 13039 SDNode *Result = Emit_106(N, X86::Int_CVTSS2SIrr, MVT::i32); 13040 return Result; 13041 } 13042 13043 // Pattern: (intrinsic_wo_chain:i32 697:iPTR, VR128:v4f32:$src) 13044 // Emits: (Int_CVTTSS2SIrr:i32 VR128:v4f32:$src) 13045 // Pattern complexity = 8 cost = 1 size = 3 13046 if (CN1 == INT64_C(697)) { 13047 SDNode *Result = Emit_106(N, X86::Int_CVTTSS2SIrr, MVT::i32); 13048 return Result; 13049 } 13050 13051 // Pattern: (intrinsic_wo_chain:i32 706:iPTR, VR128:v4f32:$src) 13052 // Emits: (MOVMSKPSrr:i32 VR128:v4f32:$src) 13053 // Pattern complexity = 8 cost = 1 size = 3 13054 if (CN1 == INT64_C(706)) { 13055 SDNode *Result = Emit_106(N, X86::MOVMSKPSrr, MVT::i32); 13056 return Result; 13057 } 13058 } 13059 } 13060 if ((Subtarget->hasSSE2())) { 13061 SDValue N0 = N.getOperand(0); 13062 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 13063 if (Tmp0) { 13064 int64_t CN1 = Tmp0->getSExtValue(); 13065 13066 // Pattern: (intrinsic_wo_chain:i32 537:iPTR, VR128:v2f64:$src) 13067 // Emits: (MOVMSKPDrr:i32 VR128:v2f64:$src) 13068 // Pattern complexity = 8 cost = 1 size = 3 13069 if (CN1 == INT64_C(537)) { 13070 SDNode *Result = Emit_106(N, X86::MOVMSKPDrr, MVT::i32); 13071 return Result; 13072 } 13073 13074 // Pattern: (intrinsic_wo_chain:i32 517:iPTR, VR128:v2f64:$src) 13075 // Emits: (Int_CVTSD2SIrr:i32 VR128:v2f64:$src) 13076 // Pattern complexity = 8 cost = 1 size = 3 13077 if (CN1 == INT64_C(517)) { 13078 SDNode *Result = Emit_106(N, X86::Int_CVTSD2SIrr, MVT::i32); 13079 return Result; 13080 } 13081 13082 // Pattern: (intrinsic_wo_chain:i32 525:iPTR, VR128:v2f64:$src) 13083 // Emits: (Int_CVTTSD2SIrr:i32 VR128:v2f64:$src) 13084 // Pattern complexity = 8 cost = 1 size = 3 13085 if (CN1 == INT64_C(525)) { 13086 SDNode *Result = Emit_106(N, X86::Int_CVTTSD2SIrr, MVT::i32); 13087 return Result; 13088 } 13089 13090 // Pattern: (intrinsic_wo_chain:i32 562:iPTR, VR128:v16i8:$src) 13091 // Emits: (PMOVMSKBrr:i32 VR128:v16i8:$src) 13092 // Pattern complexity = 8 cost = 1 size = 3 13093 if (CN1 == INT64_C(562)) { 13094 SDNode *Result = Emit_106(N, X86::PMOVMSKBrr, MVT::i32); 13095 return Result; 13096 } 13097 } 13098 } 13099 if ((Subtarget->hasSSE42())) { 13100 SDValue N0 = N.getOperand(0); 13101 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 13102 if (Tmp0) { 13103 int64_t CN1 = Tmp0->getSExtValue(); 13104 13105 // Pattern: (intrinsic_wo_chain:i32 662:iPTR, GR32:i32:$src1, GR8:i8:$src2) 13106 // Emits: (CRC32r8:i32 GR32:i32:$src1, GR8:i8:$src2) 13107 // Pattern complexity = 8 cost = 1 size = 3 13108 if (CN1 == INT64_C(662)) { 13109 SDNode *Result = Emit_109(N, X86::CRC32r8, MVT::i32); 13110 return Result; 13111 } 13112 13113 // Pattern: (intrinsic_wo_chain:i32 659:iPTR, GR32:i32:$src1, GR16:i16:$src2) 13114 // Emits: (CRC32r16:i32 GR32:i32:$src1, GR16:i16:$src2) 13115 // Pattern complexity = 8 cost = 1 size = 3 13116 if (CN1 == INT64_C(659)) { 13117 SDNode *Result = Emit_109(N, X86::CRC32r16, MVT::i32); 13118 return Result; 13119 } 13120 13121 // Pattern: (intrinsic_wo_chain:i32 660:iPTR, GR32:i32:$src1, GR32:i32:$src2) 13122 // Emits: (CRC32r32:i32 GR32:i32:$src1, GR32:i32:$src2) 13123 // Pattern complexity = 8 cost = 1 size = 3 13124 if (CN1 == INT64_C(660)) { 13125 SDNode *Result = Emit_109(N, X86::CRC32r32, MVT::i32); 13126 return Result; 13127 } 13128 } 13129 } 13130 13131 // Pattern: (intrinsic_wo_chain:i32 476:iPTR, VR64:v8i8:$src) 13132 // Emits: (MMX_PMOVMSKBrr:i32 VR64:v8i8:$src) 13133 // Pattern complexity = 8 cost = 1 size = 3 13134 if ((Subtarget->hasMMX())) { 13135 SDValue N0 = N.getOperand(0); 13136 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 13137 if (Tmp0) { 13138 int64_t CN1 = Tmp0->getSExtValue(); 13139 if (CN1 == INT64_C(476)) { 13140 SDNode *Result = Emit_106(N, X86::MMX_PMOVMSKBrr, MVT::i32); 13141 return Result; 13142 } 13143 } 13144 } 13145 13146 CannotYetSelectIntrinsic(N); 13147 return NULL; 13148 } 13149 13150 SDNode *Select_ISD_INTRINSIC_WO_CHAIN_i64(const SDValue &N) { 13151 if (OptLevel != CodeGenOpt::None) { 13152 if ((Subtarget->hasSSE2())) { 13153 SDValue N0 = N.getOperand(0); 13154 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 13155 if (Tmp0) { 13156 int64_t CN1 = Tmp0->getSExtValue(); 13157 13158 // Pattern: (intrinsic_wo_chain:i64 518:iPTR, (ld:v2f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 13159 // Emits: (Int_CVTSD2SI64rm:i64 addr:iPTR:$src) 13160 // Pattern complexity = 30 cost = 1 size = 3 13161 if (CN1 == INT64_C(518)) { 13162 SDValue N1 = N.getOperand(1); 13163 if (N1.getOpcode() == ISD::LOAD && 13164 N1.hasOneUse() && 13165 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 13166 SDValue Chain1 = N1.getOperand(0); 13167 if (Predicate_unindexedload(N1.getNode()) && 13168 Predicate_load(N1.getNode())) { 13169 SDValue N11 = N1.getOperand(1); 13170 SDValue CPTmpN11_0; 13171 SDValue CPTmpN11_1; 13172 SDValue CPTmpN11_2; 13173 SDValue CPTmpN11_3; 13174 SDValue CPTmpN11_4; 13175 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 13176 SDNode *Result = Emit_107(N, X86::Int_CVTSD2SI64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 13177 return Result; 13178 } 13179 } 13180 } 13181 } 13182 13183 // Pattern: (intrinsic_wo_chain:i64 526:iPTR, (ld:v2f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 13184 // Emits: (Int_CVTTSD2SI64rm:i64 addr:iPTR:$src) 13185 // Pattern complexity = 30 cost = 1 size = 3 13186 if (CN1 == INT64_C(526)) { 13187 SDValue N1 = N.getOperand(1); 13188 if (N1.getOpcode() == ISD::LOAD && 13189 N1.hasOneUse() && 13190 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 13191 SDValue Chain1 = N1.getOperand(0); 13192 if (Predicate_unindexedload(N1.getNode()) && 13193 Predicate_load(N1.getNode())) { 13194 SDValue N11 = N1.getOperand(1); 13195 SDValue CPTmpN11_0; 13196 SDValue CPTmpN11_1; 13197 SDValue CPTmpN11_2; 13198 SDValue CPTmpN11_3; 13199 SDValue CPTmpN11_4; 13200 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 13201 SDNode *Result = Emit_107(N, X86::Int_CVTTSD2SI64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 13202 return Result; 13203 } 13204 } 13205 } 13206 } 13207 } 13208 } 13209 if ((Subtarget->hasSSE1())) { 13210 SDValue N0 = N.getOperand(0); 13211 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 13212 if (Tmp0) { 13213 int64_t CN1 = Tmp0->getSExtValue(); 13214 13215 // Pattern: (intrinsic_wo_chain:i64 694:iPTR, (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 13216 // Emits: (Int_CVTSS2SI64rm:i64 addr:iPTR:$src) 13217 // Pattern complexity = 30 cost = 1 size = 3 13218 if (CN1 == INT64_C(694)) { 13219 SDValue N1 = N.getOperand(1); 13220 if (N1.getOpcode() == ISD::LOAD && 13221 N1.hasOneUse() && 13222 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 13223 SDValue Chain1 = N1.getOperand(0); 13224 if (Predicate_unindexedload(N1.getNode()) && 13225 Predicate_load(N1.getNode())) { 13226 SDValue N11 = N1.getOperand(1); 13227 SDValue CPTmpN11_0; 13228 SDValue CPTmpN11_1; 13229 SDValue CPTmpN11_2; 13230 SDValue CPTmpN11_3; 13231 SDValue CPTmpN11_4; 13232 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 13233 SDNode *Result = Emit_107(N, X86::Int_CVTSS2SI64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 13234 return Result; 13235 } 13236 } 13237 } 13238 } 13239 13240 // Pattern: (intrinsic_wo_chain:i64 698:iPTR, (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 13241 // Emits: (Int_CVTTSS2SI64rm:i64 addr:iPTR:$src) 13242 // Pattern complexity = 30 cost = 1 size = 3 13243 if (CN1 == INT64_C(698)) { 13244 SDValue N1 = N.getOperand(1); 13245 if (N1.getOpcode() == ISD::LOAD && 13246 N1.hasOneUse() && 13247 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 13248 SDValue Chain1 = N1.getOperand(0); 13249 if (Predicate_unindexedload(N1.getNode()) && 13250 Predicate_load(N1.getNode())) { 13251 SDValue N11 = N1.getOperand(1); 13252 SDValue CPTmpN11_0; 13253 SDValue CPTmpN11_1; 13254 SDValue CPTmpN11_2; 13255 SDValue CPTmpN11_3; 13256 SDValue CPTmpN11_4; 13257 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 13258 SDNode *Result = Emit_107(N, X86::Int_CVTTSS2SI64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 13259 return Result; 13260 } 13261 } 13262 } 13263 } 13264 } 13265 } 13266 13267 // Pattern: (intrinsic_wo_chain:i64 661:iPTR, GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 13268 // Emits: (CRC64m64:i64 GR64:i64:$src1, addr:iPTR:$src2) 13269 // Pattern complexity = 30 cost = 1 size = 3 13270 if ((Subtarget->hasSSE42())) { 13271 SDValue N0 = N.getOperand(0); 13272 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 13273 if (Tmp0) { 13274 int64_t CN1 = Tmp0->getSExtValue(); 13275 if (CN1 == INT64_C(661)) { 13276 SDValue N1 = N.getOperand(1); 13277 SDValue N2 = N.getOperand(2); 13278 if (N2.getOpcode() == ISD::LOAD && 13279 N2.hasOneUse() && 13280 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 13281 SDValue Chain2 = N2.getOperand(0); 13282 if (Predicate_unindexedload(N2.getNode()) && 13283 Predicate_load(N2.getNode())) { 13284 SDValue N21 = N2.getOperand(1); 13285 SDValue CPTmpN21_0; 13286 SDValue CPTmpN21_1; 13287 SDValue CPTmpN21_2; 13288 SDValue CPTmpN21_3; 13289 SDValue CPTmpN21_4; 13290 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 13291 SDNode *Result = Emit_108(N, X86::CRC64m64, MVT::i64, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 13292 return Result; 13293 } 13294 } 13295 } 13296 } 13297 } 13298 } 13299 } 13300 if ((Subtarget->hasSSE2())) { 13301 SDValue N0 = N.getOperand(0); 13302 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 13303 if (Tmp0) { 13304 int64_t CN1 = Tmp0->getSExtValue(); 13305 13306 // Pattern: (intrinsic_wo_chain:i64 518:iPTR, VR128:v2f64:$src) 13307 // Emits: (Int_CVTSD2SI64rr:i64 VR128:v2f64:$src) 13308 // Pattern complexity = 8 cost = 1 size = 3 13309 if (CN1 == INT64_C(518)) { 13310 SDNode *Result = Emit_106(N, X86::Int_CVTSD2SI64rr, MVT::i64); 13311 return Result; 13312 } 13313 13314 // Pattern: (intrinsic_wo_chain:i64 526:iPTR, VR128:v2f64:$src) 13315 // Emits: (Int_CVTTSD2SI64rr:i64 VR128:v2f64:$src) 13316 // Pattern complexity = 8 cost = 1 size = 3 13317 if (CN1 == INT64_C(526)) { 13318 SDNode *Result = Emit_106(N, X86::Int_CVTTSD2SI64rr, MVT::i64); 13319 return Result; 13320 } 13321 } 13322 } 13323 if ((Subtarget->hasSSE1())) { 13324 SDValue N0 = N.getOperand(0); 13325 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 13326 if (Tmp0) { 13327 int64_t CN1 = Tmp0->getSExtValue(); 13328 13329 // Pattern: (intrinsic_wo_chain:i64 694:iPTR, VR128:v4f32:$src) 13330 // Emits: (Int_CVTSS2SI64rr:i64 VR128:v4f32:$src) 13331 // Pattern complexity = 8 cost = 1 size = 3 13332 if (CN1 == INT64_C(694)) { 13333 SDNode *Result = Emit_106(N, X86::Int_CVTSS2SI64rr, MVT::i64); 13334 return Result; 13335 } 13336 13337 // Pattern: (intrinsic_wo_chain:i64 698:iPTR, VR128:v4f32:$src) 13338 // Emits: (Int_CVTTSS2SI64rr:i64 VR128:v4f32:$src) 13339 // Pattern complexity = 8 cost = 1 size = 3 13340 if (CN1 == INT64_C(698)) { 13341 SDNode *Result = Emit_106(N, X86::Int_CVTTSS2SI64rr, MVT::i64); 13342 return Result; 13343 } 13344 } 13345 } 13346 13347 // Pattern: (intrinsic_wo_chain:i64 661:iPTR, GR64:i64:$src1, GR64:i64:$src2) 13348 // Emits: (CRC64r64:i64 GR64:i64:$src1, GR64:i64:$src2) 13349 // Pattern complexity = 8 cost = 1 size = 3 13350 if ((Subtarget->hasSSE42())) { 13351 SDValue N0 = N.getOperand(0); 13352 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 13353 if (Tmp0) { 13354 int64_t CN1 = Tmp0->getSExtValue(); 13355 if (CN1 == INT64_C(661)) { 13356 SDNode *Result = Emit_109(N, X86::CRC64r64, MVT::i64); 13357 return Result; 13358 } 13359 } 13360 } 13361 13362 CannotYetSelectIntrinsic(N); 13363 return NULL; 13364 } 13365 13366 SDNode *Emit_114(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 13367 SDValue N0 = N.getOperand(0); 13368 SDValue N1 = N.getOperand(1); 13369 SDValue N10 = N1.getOperand(0); 13370 SDValue Chain10 = N10.getOperand(0); 13371 SDValue N101 = N10.getOperand(1); 13372 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 13373 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, LSI_N10, Chain10 }; 13374 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 7); 13375 ReplaceUses(SDValue(N10.getNode(), 1), SDValue(ResNode, 1)); 13376 return ResNode; 13377 } 13378 SDNode *Emit_115(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN201_0, SDValue &CPTmpN201_1, SDValue &CPTmpN201_2, SDValue &CPTmpN201_3, SDValue &CPTmpN201_4) DISABLE_INLINE { 13379 SDValue N0 = N.getOperand(0); 13380 SDValue N1 = N.getOperand(1); 13381 SDValue N2 = N.getOperand(2); 13382 SDValue N20 = N2.getOperand(0); 13383 SDValue Chain20 = N20.getOperand(0); 13384 SDValue N201 = N20.getOperand(1); 13385 SDValue LSI_N20 = CurDAG->getMemOperand(cast<MemSDNode>(N20)->getMemOperand()); 13386 SDValue Ops0[] = { N1, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4, LSI_N20, Chain20 }; 13387 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 13388 ReplaceUses(SDValue(N20.getNode(), 1), SDValue(ResNode, 1)); 13389 return ResNode; 13390 } 13391 SDNode *Emit_116(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 13392 SDValue N0 = N.getOperand(0); 13393 SDValue N1 = N.getOperand(1); 13394 SDValue N10 = N1.getOperand(0); 13395 SDValue Chain10 = N10.getOperand(0); 13396 SDValue N101 = N10.getOperand(1); 13397 SDValue N2 = N.getOperand(2); 13398 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 13399 SDValue Ops0[] = { N2, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, LSI_N10, Chain10 }; 13400 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 13401 ReplaceUses(SDValue(N10.getNode(), 1), SDValue(ResNode, 1)); 13402 return ResNode; 13403 } 13404 SDNode *Select_ISD_INTRINSIC_WO_CHAIN_v8i8(const SDValue &N) { 13405 if (OptLevel != CodeGenOpt::None) { 13406 if ((Subtarget->hasSSSE3())) { 13407 SDValue N0 = N.getOperand(0); 13408 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 13409 if (Tmp0) { 13410 int64_t CN1 = Tmp0->getSExtValue(); 13411 13412 // Pattern: (intrinsic_wo_chain:v8i8 725:iPTR, (bitconvert:v8i8 (ld:v8i8 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 13413 // Emits: (PABSBrm64:v8i8 addr:iPTR:$src) 13414 // Pattern complexity = 33 cost = 1 size = 3 13415 if (CN1 == INT64_C(725)) { 13416 SDValue N1 = N.getOperand(1); 13417 if (N1.getOpcode() == ISD::BIT_CONVERT && 13418 N1.hasOneUse()) { 13419 SDValue N10 = N1.getOperand(0); 13420 if (N10.getOpcode() == ISD::LOAD && 13421 N10.hasOneUse() && 13422 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 13423 SDValue Chain10 = N10.getOperand(0); 13424 if (Predicate_unindexedload(N10.getNode()) && 13425 Predicate_load(N10.getNode()) && 13426 Predicate_memop64(N10.getNode())) { 13427 SDValue N101 = N10.getOperand(1); 13428 SDValue CPTmpN101_0; 13429 SDValue CPTmpN101_1; 13430 SDValue CPTmpN101_2; 13431 SDValue CPTmpN101_3; 13432 SDValue CPTmpN101_4; 13433 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 13434 N10.getNode()->getValueType(0) == MVT::v8i8) { 13435 SDNode *Result = Emit_114(N, X86::PABSBrm64, MVT::v8i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 13436 return Result; 13437 } 13438 } 13439 } 13440 } 13441 } 13442 13443 // Pattern: (intrinsic_wo_chain:v8i8 749:iPTR, VR64:v8i8:$src1, (bitconvert:v8i8 (ld:v8i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 13444 // Emits: (PSHUFBrm64:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 13445 // Pattern complexity = 33 cost = 1 size = 3 13446 if (CN1 == INT64_C(749)) { 13447 SDValue N1 = N.getOperand(1); 13448 SDValue N2 = N.getOperand(2); 13449 if (N2.getOpcode() == ISD::BIT_CONVERT && 13450 N2.hasOneUse()) { 13451 SDValue N20 = N2.getOperand(0); 13452 if (N20.getOpcode() == ISD::LOAD && 13453 N20.hasOneUse() && 13454 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 13455 SDValue Chain20 = N20.getOperand(0); 13456 if (Predicate_unindexedload(N20.getNode()) && 13457 Predicate_load(N20.getNode()) && 13458 Predicate_memop64(N20.getNode())) { 13459 SDValue N201 = N20.getOperand(1); 13460 SDValue CPTmpN201_0; 13461 SDValue CPTmpN201_1; 13462 SDValue CPTmpN201_2; 13463 SDValue CPTmpN201_3; 13464 SDValue CPTmpN201_4; 13465 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 13466 N20.getNode()->getValueType(0) == MVT::v8i8) { 13467 SDNode *Result = Emit_115(N, X86::PSHUFBrm64, MVT::v8i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 13468 return Result; 13469 } 13470 } 13471 } 13472 } 13473 } 13474 13475 // Pattern: (intrinsic_wo_chain:v8i8 751:iPTR, VR64:v8i8:$src1, (bitconvert:v8i8 (ld:v8i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 13476 // Emits: (PSIGNBrm64:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 13477 // Pattern complexity = 33 cost = 1 size = 3 13478 if (CN1 == INT64_C(751)) { 13479 SDValue N1 = N.getOperand(1); 13480 SDValue N2 = N.getOperand(2); 13481 if (N2.getOpcode() == ISD::BIT_CONVERT && 13482 N2.hasOneUse()) { 13483 SDValue N20 = N2.getOperand(0); 13484 if (N20.getOpcode() == ISD::LOAD && 13485 N20.hasOneUse() && 13486 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 13487 SDValue Chain20 = N20.getOperand(0); 13488 if (Predicate_unindexedload(N20.getNode()) && 13489 Predicate_load(N20.getNode()) && 13490 Predicate_memop64(N20.getNode())) { 13491 SDValue N201 = N20.getOperand(1); 13492 SDValue CPTmpN201_0; 13493 SDValue CPTmpN201_1; 13494 SDValue CPTmpN201_2; 13495 SDValue CPTmpN201_3; 13496 SDValue CPTmpN201_4; 13497 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 13498 N20.getNode()->getValueType(0) == MVT::v8i8) { 13499 SDNode *Result = Emit_115(N, X86::PSIGNBrm64, MVT::v8i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 13500 return Result; 13501 } 13502 } 13503 } 13504 } 13505 } 13506 } 13507 } 13508 if ((Subtarget->hasMMX())) { 13509 SDValue N0 = N.getOperand(0); 13510 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 13511 if (Tmp0) { 13512 int64_t CN1 = Tmp0->getSExtValue(); 13513 13514 // Pattern: (intrinsic_wo_chain:v8i8 459:iPTR, VR64:v8i8:$src1, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 13515 // Emits: (MMX_PADDSBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 13516 // Pattern complexity = 33 cost = 1 size = 3 13517 if (CN1 == INT64_C(459)) { 13518 SDValue N1 = N.getOperand(1); 13519 SDValue N2 = N.getOperand(2); 13520 if (N2.getOpcode() == ISD::BIT_CONVERT && 13521 N2.hasOneUse()) { 13522 SDValue N20 = N2.getOperand(0); 13523 if (N20.getOpcode() == ISD::LOAD && 13524 N20.hasOneUse() && 13525 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 13526 SDValue Chain20 = N20.getOperand(0); 13527 if (Predicate_unindexedload(N20.getNode()) && 13528 Predicate_load(N20.getNode())) { 13529 SDValue N201 = N20.getOperand(1); 13530 SDValue CPTmpN201_0; 13531 SDValue CPTmpN201_1; 13532 SDValue CPTmpN201_2; 13533 SDValue CPTmpN201_3; 13534 SDValue CPTmpN201_4; 13535 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 13536 N20.getNode()->getValueType(0) == MVT::v1i64) { 13537 SDNode *Result = Emit_115(N, X86::MMX_PADDSBrm, MVT::v8i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 13538 return Result; 13539 } 13540 } 13541 } 13542 } 13543 } 13544 13545 // Pattern: (intrinsic_wo_chain:v8i8 461:iPTR, VR64:v8i8:$src1, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 13546 // Emits: (MMX_PADDUSBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 13547 // Pattern complexity = 33 cost = 1 size = 3 13548 if (CN1 == INT64_C(461)) { 13549 SDValue N1 = N.getOperand(1); 13550 SDValue N2 = N.getOperand(2); 13551 if (N2.getOpcode() == ISD::BIT_CONVERT && 13552 N2.hasOneUse()) { 13553 SDValue N20 = N2.getOperand(0); 13554 if (N20.getOpcode() == ISD::LOAD && 13555 N20.hasOneUse() && 13556 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 13557 SDValue Chain20 = N20.getOperand(0); 13558 if (Predicate_unindexedload(N20.getNode()) && 13559 Predicate_load(N20.getNode())) { 13560 SDValue N201 = N20.getOperand(1); 13561 SDValue CPTmpN201_0; 13562 SDValue CPTmpN201_1; 13563 SDValue CPTmpN201_2; 13564 SDValue CPTmpN201_3; 13565 SDValue CPTmpN201_4; 13566 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 13567 N20.getNode()->getValueType(0) == MVT::v1i64) { 13568 SDNode *Result = Emit_115(N, X86::MMX_PADDUSBrm, MVT::v8i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 13569 return Result; 13570 } 13571 } 13572 } 13573 } 13574 } 13575 13576 // Pattern: (intrinsic_wo_chain:v8i8 497:iPTR, VR64:v8i8:$src1, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 13577 // Emits: (MMX_PSUBSBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 13578 // Pattern complexity = 33 cost = 1 size = 3 13579 if (CN1 == INT64_C(497)) { 13580 SDValue N1 = N.getOperand(1); 13581 SDValue N2 = N.getOperand(2); 13582 if (N2.getOpcode() == ISD::BIT_CONVERT && 13583 N2.hasOneUse()) { 13584 SDValue N20 = N2.getOperand(0); 13585 if (N20.getOpcode() == ISD::LOAD && 13586 N20.hasOneUse() && 13587 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 13588 SDValue Chain20 = N20.getOperand(0); 13589 if (Predicate_unindexedload(N20.getNode()) && 13590 Predicate_load(N20.getNode())) { 13591 SDValue N201 = N20.getOperand(1); 13592 SDValue CPTmpN201_0; 13593 SDValue CPTmpN201_1; 13594 SDValue CPTmpN201_2; 13595 SDValue CPTmpN201_3; 13596 SDValue CPTmpN201_4; 13597 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 13598 N20.getNode()->getValueType(0) == MVT::v1i64) { 13599 SDNode *Result = Emit_115(N, X86::MMX_PSUBSBrm, MVT::v8i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 13600 return Result; 13601 } 13602 } 13603 } 13604 } 13605 } 13606 13607 // Pattern: (intrinsic_wo_chain:v8i8 499:iPTR, VR64:v8i8:$src1, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 13608 // Emits: (MMX_PSUBUSBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 13609 // Pattern complexity = 33 cost = 1 size = 3 13610 if (CN1 == INT64_C(499)) { 13611 SDValue N1 = N.getOperand(1); 13612 SDValue N2 = N.getOperand(2); 13613 if (N2.getOpcode() == ISD::BIT_CONVERT && 13614 N2.hasOneUse()) { 13615 SDValue N20 = N2.getOperand(0); 13616 if (N20.getOpcode() == ISD::LOAD && 13617 N20.hasOneUse() && 13618 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 13619 SDValue Chain20 = N20.getOperand(0); 13620 if (Predicate_unindexedload(N20.getNode()) && 13621 Predicate_load(N20.getNode())) { 13622 SDValue N201 = N20.getOperand(1); 13623 SDValue CPTmpN201_0; 13624 SDValue CPTmpN201_1; 13625 SDValue CPTmpN201_2; 13626 SDValue CPTmpN201_3; 13627 SDValue CPTmpN201_4; 13628 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 13629 N20.getNode()->getValueType(0) == MVT::v1i64) { 13630 SDNode *Result = Emit_115(N, X86::MMX_PSUBUSBrm, MVT::v8i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 13631 return Result; 13632 } 13633 } 13634 } 13635 } 13636 } 13637 13638 // Pattern: (intrinsic_wo_chain:v8i8 463:iPTR, VR64:v8i8:$src1, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 13639 // Emits: (MMX_PAVGBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 13640 // Pattern complexity = 33 cost = 1 size = 3 13641 if (CN1 == INT64_C(463)) { 13642 SDValue N1 = N.getOperand(1); 13643 SDValue N2 = N.getOperand(2); 13644 if (N2.getOpcode() == ISD::BIT_CONVERT && 13645 N2.hasOneUse()) { 13646 SDValue N20 = N2.getOperand(0); 13647 if (N20.getOpcode() == ISD::LOAD && 13648 N20.hasOneUse() && 13649 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 13650 SDValue Chain20 = N20.getOperand(0); 13651 if (Predicate_unindexedload(N20.getNode()) && 13652 Predicate_load(N20.getNode())) { 13653 SDValue N201 = N20.getOperand(1); 13654 SDValue CPTmpN201_0; 13655 SDValue CPTmpN201_1; 13656 SDValue CPTmpN201_2; 13657 SDValue CPTmpN201_3; 13658 SDValue CPTmpN201_4; 13659 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 13660 N20.getNode()->getValueType(0) == MVT::v1i64) { 13661 SDNode *Result = Emit_115(N, X86::MMX_PAVGBrm, MVT::v8i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 13662 return Result; 13663 } 13664 } 13665 } 13666 } 13667 } 13668 13669 // Pattern: (intrinsic_wo_chain:v8i8 475:iPTR, VR64:v8i8:$src1, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 13670 // Emits: (MMX_PMINUBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 13671 // Pattern complexity = 33 cost = 1 size = 3 13672 if (CN1 == INT64_C(475)) { 13673 SDValue N1 = N.getOperand(1); 13674 SDValue N2 = N.getOperand(2); 13675 if (N2.getOpcode() == ISD::BIT_CONVERT && 13676 N2.hasOneUse()) { 13677 SDValue N20 = N2.getOperand(0); 13678 if (N20.getOpcode() == ISD::LOAD && 13679 N20.hasOneUse() && 13680 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 13681 SDValue Chain20 = N20.getOperand(0); 13682 if (Predicate_unindexedload(N20.getNode()) && 13683 Predicate_load(N20.getNode())) { 13684 SDValue N201 = N20.getOperand(1); 13685 SDValue CPTmpN201_0; 13686 SDValue CPTmpN201_1; 13687 SDValue CPTmpN201_2; 13688 SDValue CPTmpN201_3; 13689 SDValue CPTmpN201_4; 13690 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 13691 N20.getNode()->getValueType(0) == MVT::v1i64) { 13692 SDNode *Result = Emit_115(N, X86::MMX_PMINUBrm, MVT::v8i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 13693 return Result; 13694 } 13695 } 13696 } 13697 } 13698 } 13699 13700 // Pattern: (intrinsic_wo_chain:v8i8 473:iPTR, VR64:v8i8:$src1, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 13701 // Emits: (MMX_PMAXUBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 13702 // Pattern complexity = 33 cost = 1 size = 3 13703 if (CN1 == INT64_C(473)) { 13704 SDValue N1 = N.getOperand(1); 13705 SDValue N2 = N.getOperand(2); 13706 if (N2.getOpcode() == ISD::BIT_CONVERT && 13707 N2.hasOneUse()) { 13708 SDValue N20 = N2.getOperand(0); 13709 if (N20.getOpcode() == ISD::LOAD && 13710 N20.hasOneUse() && 13711 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 13712 SDValue Chain20 = N20.getOperand(0); 13713 if (Predicate_unindexedload(N20.getNode()) && 13714 Predicate_load(N20.getNode())) { 13715 SDValue N201 = N20.getOperand(1); 13716 SDValue CPTmpN201_0; 13717 SDValue CPTmpN201_1; 13718 SDValue CPTmpN201_2; 13719 SDValue CPTmpN201_3; 13720 SDValue CPTmpN201_4; 13721 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 13722 N20.getNode()->getValueType(0) == MVT::v1i64) { 13723 SDNode *Result = Emit_115(N, X86::MMX_PMAXUBrm, MVT::v8i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 13724 return Result; 13725 } 13726 } 13727 } 13728 } 13729 } 13730 13731 // Pattern: (intrinsic_wo_chain:v8i8 465:iPTR, VR64:v8i8:$src1, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 13732 // Emits: (MMX_PCMPEQBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 13733 // Pattern complexity = 33 cost = 1 size = 3 13734 if (CN1 == INT64_C(465)) { 13735 SDValue N1 = N.getOperand(1); 13736 SDValue N2 = N.getOperand(2); 13737 if (N2.getOpcode() == ISD::BIT_CONVERT && 13738 N2.hasOneUse()) { 13739 SDValue N20 = N2.getOperand(0); 13740 if (N20.getOpcode() == ISD::LOAD && 13741 N20.hasOneUse() && 13742 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 13743 SDValue Chain20 = N20.getOperand(0); 13744 if (Predicate_unindexedload(N20.getNode()) && 13745 Predicate_load(N20.getNode())) { 13746 SDValue N201 = N20.getOperand(1); 13747 SDValue CPTmpN201_0; 13748 SDValue CPTmpN201_1; 13749 SDValue CPTmpN201_2; 13750 SDValue CPTmpN201_3; 13751 SDValue CPTmpN201_4; 13752 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 13753 N20.getNode()->getValueType(0) == MVT::v1i64) { 13754 SDNode *Result = Emit_115(N, X86::MMX_PCMPEQBrm, MVT::v8i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 13755 return Result; 13756 } 13757 } 13758 } 13759 } 13760 } 13761 13762 // Pattern: (intrinsic_wo_chain:v8i8 468:iPTR, VR64:v8i8:$src1, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 13763 // Emits: (MMX_PCMPGTBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 13764 // Pattern complexity = 33 cost = 1 size = 3 13765 if (CN1 == INT64_C(468)) { 13766 SDValue N1 = N.getOperand(1); 13767 SDValue N2 = N.getOperand(2); 13768 if (N2.getOpcode() == ISD::BIT_CONVERT && 13769 N2.hasOneUse()) { 13770 SDValue N20 = N2.getOperand(0); 13771 if (N20.getOpcode() == ISD::LOAD && 13772 N20.hasOneUse() && 13773 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 13774 SDValue Chain20 = N20.getOperand(0); 13775 if (Predicate_unindexedload(N20.getNode()) && 13776 Predicate_load(N20.getNode())) { 13777 SDValue N201 = N20.getOperand(1); 13778 SDValue CPTmpN201_0; 13779 SDValue CPTmpN201_1; 13780 SDValue CPTmpN201_2; 13781 SDValue CPTmpN201_3; 13782 SDValue CPTmpN201_4; 13783 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 13784 N20.getNode()->getValueType(0) == MVT::v1i64) { 13785 SDNode *Result = Emit_115(N, X86::MMX_PCMPGTBrm, MVT::v8i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 13786 return Result; 13787 } 13788 } 13789 } 13790 } 13791 } 13792 13793 // Pattern: (intrinsic_wo_chain:v8i8 457:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 13794 // Emits: (MMX_PACKSSWBrm:v8i8 VR64:v4i16:$src1, addr:iPTR:$src2) 13795 // Pattern complexity = 33 cost = 1 size = 3 13796 if (CN1 == INT64_C(457)) { 13797 SDValue N1 = N.getOperand(1); 13798 SDValue N2 = N.getOperand(2); 13799 if (N2.getOpcode() == ISD::BIT_CONVERT && 13800 N2.hasOneUse()) { 13801 SDValue N20 = N2.getOperand(0); 13802 if (N20.getOpcode() == ISD::LOAD && 13803 N20.hasOneUse() && 13804 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 13805 SDValue Chain20 = N20.getOperand(0); 13806 if (Predicate_unindexedload(N20.getNode()) && 13807 Predicate_load(N20.getNode())) { 13808 SDValue N201 = N20.getOperand(1); 13809 SDValue CPTmpN201_0; 13810 SDValue CPTmpN201_1; 13811 SDValue CPTmpN201_2; 13812 SDValue CPTmpN201_3; 13813 SDValue CPTmpN201_4; 13814 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 13815 N20.getNode()->getValueType(0) == MVT::v1i64) { 13816 SDNode *Result = Emit_115(N, X86::MMX_PACKSSWBrm, MVT::v8i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 13817 return Result; 13818 } 13819 } 13820 } 13821 } 13822 } 13823 13824 // Pattern: (intrinsic_wo_chain:v8i8 458:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 13825 // Emits: (MMX_PACKUSWBrm:v8i8 VR64:v4i16:$src1, addr:iPTR:$src2) 13826 // Pattern complexity = 33 cost = 1 size = 3 13827 if (CN1 == INT64_C(458)) { 13828 SDValue N1 = N.getOperand(1); 13829 SDValue N2 = N.getOperand(2); 13830 if (N2.getOpcode() == ISD::BIT_CONVERT && 13831 N2.hasOneUse()) { 13832 SDValue N20 = N2.getOperand(0); 13833 if (N20.getOpcode() == ISD::LOAD && 13834 N20.hasOneUse() && 13835 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 13836 SDValue Chain20 = N20.getOperand(0); 13837 if (Predicate_unindexedload(N20.getNode()) && 13838 Predicate_load(N20.getNode())) { 13839 SDValue N201 = N20.getOperand(1); 13840 SDValue CPTmpN201_0; 13841 SDValue CPTmpN201_1; 13842 SDValue CPTmpN201_2; 13843 SDValue CPTmpN201_3; 13844 SDValue CPTmpN201_4; 13845 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 13846 N20.getNode()->getValueType(0) == MVT::v1i64) { 13847 SDNode *Result = Emit_115(N, X86::MMX_PACKUSWBrm, MVT::v8i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 13848 return Result; 13849 } 13850 } 13851 } 13852 } 13853 } 13854 13855 // Pattern: (intrinsic_wo_chain:v8i8 459:iPTR, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v8i8:$src1) 13856 // Emits: (MMX_PADDSBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 13857 // Pattern complexity = 33 cost = 1 size = 3 13858 if (CN1 == INT64_C(459)) { 13859 SDValue N1 = N.getOperand(1); 13860 if (N1.getOpcode() == ISD::BIT_CONVERT && 13861 N1.hasOneUse()) { 13862 SDValue N10 = N1.getOperand(0); 13863 if (N10.getOpcode() == ISD::LOAD && 13864 N10.hasOneUse() && 13865 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 13866 SDValue Chain10 = N10.getOperand(0); 13867 if (Predicate_unindexedload(N10.getNode()) && 13868 Predicate_load(N10.getNode())) { 13869 SDValue N101 = N10.getOperand(1); 13870 SDValue CPTmpN101_0; 13871 SDValue CPTmpN101_1; 13872 SDValue CPTmpN101_2; 13873 SDValue CPTmpN101_3; 13874 SDValue CPTmpN101_4; 13875 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 13876 SDValue N2 = N.getOperand(2); 13877 if (N10.getNode()->getValueType(0) == MVT::v1i64) { 13878 SDNode *Result = Emit_116(N, X86::MMX_PADDSBrm, MVT::v8i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 13879 return Result; 13880 } 13881 } 13882 } 13883 } 13884 } 13885 } 13886 13887 // Pattern: (intrinsic_wo_chain:v8i8 461:iPTR, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v8i8:$src1) 13888 // Emits: (MMX_PADDUSBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 13889 // Pattern complexity = 33 cost = 1 size = 3 13890 if (CN1 == INT64_C(461)) { 13891 SDValue N1 = N.getOperand(1); 13892 if (N1.getOpcode() == ISD::BIT_CONVERT && 13893 N1.hasOneUse()) { 13894 SDValue N10 = N1.getOperand(0); 13895 if (N10.getOpcode() == ISD::LOAD && 13896 N10.hasOneUse() && 13897 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 13898 SDValue Chain10 = N10.getOperand(0); 13899 if (Predicate_unindexedload(N10.getNode()) && 13900 Predicate_load(N10.getNode())) { 13901 SDValue N101 = N10.getOperand(1); 13902 SDValue CPTmpN101_0; 13903 SDValue CPTmpN101_1; 13904 SDValue CPTmpN101_2; 13905 SDValue CPTmpN101_3; 13906 SDValue CPTmpN101_4; 13907 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 13908 SDValue N2 = N.getOperand(2); 13909 if (N10.getNode()->getValueType(0) == MVT::v1i64) { 13910 SDNode *Result = Emit_116(N, X86::MMX_PADDUSBrm, MVT::v8i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 13911 return Result; 13912 } 13913 } 13914 } 13915 } 13916 } 13917 } 13918 13919 // Pattern: (intrinsic_wo_chain:v8i8 463:iPTR, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v8i8:$src1) 13920 // Emits: (MMX_PAVGBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 13921 // Pattern complexity = 33 cost = 1 size = 3 13922 if (CN1 == INT64_C(463)) { 13923 SDValue N1 = N.getOperand(1); 13924 if (N1.getOpcode() == ISD::BIT_CONVERT && 13925 N1.hasOneUse()) { 13926 SDValue N10 = N1.getOperand(0); 13927 if (N10.getOpcode() == ISD::LOAD && 13928 N10.hasOneUse() && 13929 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 13930 SDValue Chain10 = N10.getOperand(0); 13931 if (Predicate_unindexedload(N10.getNode()) && 13932 Predicate_load(N10.getNode())) { 13933 SDValue N101 = N10.getOperand(1); 13934 SDValue CPTmpN101_0; 13935 SDValue CPTmpN101_1; 13936 SDValue CPTmpN101_2; 13937 SDValue CPTmpN101_3; 13938 SDValue CPTmpN101_4; 13939 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 13940 SDValue N2 = N.getOperand(2); 13941 if (N10.getNode()->getValueType(0) == MVT::v1i64) { 13942 SDNode *Result = Emit_116(N, X86::MMX_PAVGBrm, MVT::v8i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 13943 return Result; 13944 } 13945 } 13946 } 13947 } 13948 } 13949 } 13950 13951 // Pattern: (intrinsic_wo_chain:v8i8 475:iPTR, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v8i8:$src1) 13952 // Emits: (MMX_PMINUBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 13953 // Pattern complexity = 33 cost = 1 size = 3 13954 if (CN1 == INT64_C(475)) { 13955 SDValue N1 = N.getOperand(1); 13956 if (N1.getOpcode() == ISD::BIT_CONVERT && 13957 N1.hasOneUse()) { 13958 SDValue N10 = N1.getOperand(0); 13959 if (N10.getOpcode() == ISD::LOAD && 13960 N10.hasOneUse() && 13961 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 13962 SDValue Chain10 = N10.getOperand(0); 13963 if (Predicate_unindexedload(N10.getNode()) && 13964 Predicate_load(N10.getNode())) { 13965 SDValue N101 = N10.getOperand(1); 13966 SDValue CPTmpN101_0; 13967 SDValue CPTmpN101_1; 13968 SDValue CPTmpN101_2; 13969 SDValue CPTmpN101_3; 13970 SDValue CPTmpN101_4; 13971 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 13972 SDValue N2 = N.getOperand(2); 13973 if (N10.getNode()->getValueType(0) == MVT::v1i64) { 13974 SDNode *Result = Emit_116(N, X86::MMX_PMINUBrm, MVT::v8i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 13975 return Result; 13976 } 13977 } 13978 } 13979 } 13980 } 13981 } 13982 13983 // Pattern: (intrinsic_wo_chain:v8i8 473:iPTR, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v8i8:$src1) 13984 // Emits: (MMX_PMAXUBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 13985 // Pattern complexity = 33 cost = 1 size = 3 13986 if (CN1 == INT64_C(473)) { 13987 SDValue N1 = N.getOperand(1); 13988 if (N1.getOpcode() == ISD::BIT_CONVERT && 13989 N1.hasOneUse()) { 13990 SDValue N10 = N1.getOperand(0); 13991 if (N10.getOpcode() == ISD::LOAD && 13992 N10.hasOneUse() && 13993 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 13994 SDValue Chain10 = N10.getOperand(0); 13995 if (Predicate_unindexedload(N10.getNode()) && 13996 Predicate_load(N10.getNode())) { 13997 SDValue N101 = N10.getOperand(1); 13998 SDValue CPTmpN101_0; 13999 SDValue CPTmpN101_1; 14000 SDValue CPTmpN101_2; 14001 SDValue CPTmpN101_3; 14002 SDValue CPTmpN101_4; 14003 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 14004 SDValue N2 = N.getOperand(2); 14005 if (N10.getNode()->getValueType(0) == MVT::v1i64) { 14006 SDNode *Result = Emit_116(N, X86::MMX_PMAXUBrm, MVT::v8i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 14007 return Result; 14008 } 14009 } 14010 } 14011 } 14012 } 14013 } 14014 } 14015 } 14016 } 14017 if ((Subtarget->hasSSSE3())) { 14018 SDValue N0 = N.getOperand(0); 14019 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 14020 if (Tmp0) { 14021 int64_t CN1 = Tmp0->getSExtValue(); 14022 14023 // Pattern: (intrinsic_wo_chain:v8i8 725:iPTR, VR64:v8i8:$src) 14024 // Emits: (PABSBrr64:v8i8 VR64:v8i8:$src) 14025 // Pattern complexity = 8 cost = 1 size = 3 14026 if (CN1 == INT64_C(725)) { 14027 SDNode *Result = Emit_106(N, X86::PABSBrr64, MVT::v8i8); 14028 return Result; 14029 } 14030 14031 // Pattern: (intrinsic_wo_chain:v8i8 749:iPTR, VR64:v8i8:$src1, VR64:v8i8:$src2) 14032 // Emits: (PSHUFBrr64:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 14033 // Pattern complexity = 8 cost = 1 size = 3 14034 if (CN1 == INT64_C(749)) { 14035 SDNode *Result = Emit_109(N, X86::PSHUFBrr64, MVT::v8i8); 14036 return Result; 14037 } 14038 14039 // Pattern: (intrinsic_wo_chain:v8i8 751:iPTR, VR64:v8i8:$src1, VR64:v8i8:$src2) 14040 // Emits: (PSIGNBrr64:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 14041 // Pattern complexity = 8 cost = 1 size = 3 14042 if (CN1 == INT64_C(751)) { 14043 SDNode *Result = Emit_109(N, X86::PSIGNBrr64, MVT::v8i8); 14044 return Result; 14045 } 14046 } 14047 } 14048 if ((Subtarget->hasMMX())) { 14049 SDValue N0 = N.getOperand(0); 14050 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 14051 if (Tmp0) { 14052 int64_t CN1 = Tmp0->getSExtValue(); 14053 14054 // Pattern: (intrinsic_wo_chain:v8i8 459:iPTR, VR64:v8i8:$src1, VR64:v8i8:$src2) 14055 // Emits: (MMX_PADDSBrr:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 14056 // Pattern complexity = 8 cost = 1 size = 3 14057 if (CN1 == INT64_C(459)) { 14058 SDNode *Result = Emit_109(N, X86::MMX_PADDSBrr, MVT::v8i8); 14059 return Result; 14060 } 14061 14062 // Pattern: (intrinsic_wo_chain:v8i8 461:iPTR, VR64:v8i8:$src1, VR64:v8i8:$src2) 14063 // Emits: (MMX_PADDUSBrr:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 14064 // Pattern complexity = 8 cost = 1 size = 3 14065 if (CN1 == INT64_C(461)) { 14066 SDNode *Result = Emit_109(N, X86::MMX_PADDUSBrr, MVT::v8i8); 14067 return Result; 14068 } 14069 14070 // Pattern: (intrinsic_wo_chain:v8i8 497:iPTR, VR64:v8i8:$src1, VR64:v8i8:$src2) 14071 // Emits: (MMX_PSUBSBrr:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 14072 // Pattern complexity = 8 cost = 1 size = 3 14073 if (CN1 == INT64_C(497)) { 14074 SDNode *Result = Emit_109(N, X86::MMX_PSUBSBrr, MVT::v8i8); 14075 return Result; 14076 } 14077 14078 // Pattern: (intrinsic_wo_chain:v8i8 499:iPTR, VR64:v8i8:$src1, VR64:v8i8:$src2) 14079 // Emits: (MMX_PSUBUSBrr:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 14080 // Pattern complexity = 8 cost = 1 size = 3 14081 if (CN1 == INT64_C(499)) { 14082 SDNode *Result = Emit_109(N, X86::MMX_PSUBUSBrr, MVT::v8i8); 14083 return Result; 14084 } 14085 14086 // Pattern: (intrinsic_wo_chain:v8i8 463:iPTR, VR64:v8i8:$src1, VR64:v8i8:$src2) 14087 // Emits: (MMX_PAVGBrr:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 14088 // Pattern complexity = 8 cost = 1 size = 3 14089 if (CN1 == INT64_C(463)) { 14090 SDNode *Result = Emit_109(N, X86::MMX_PAVGBrr, MVT::v8i8); 14091 return Result; 14092 } 14093 14094 // Pattern: (intrinsic_wo_chain:v8i8 475:iPTR, VR64:v8i8:$src1, VR64:v8i8:$src2) 14095 // Emits: (MMX_PMINUBrr:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 14096 // Pattern complexity = 8 cost = 1 size = 3 14097 if (CN1 == INT64_C(475)) { 14098 SDNode *Result = Emit_109(N, X86::MMX_PMINUBrr, MVT::v8i8); 14099 return Result; 14100 } 14101 14102 // Pattern: (intrinsic_wo_chain:v8i8 473:iPTR, VR64:v8i8:$src1, VR64:v8i8:$src2) 14103 // Emits: (MMX_PMAXUBrr:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 14104 // Pattern complexity = 8 cost = 1 size = 3 14105 if (CN1 == INT64_C(473)) { 14106 SDNode *Result = Emit_109(N, X86::MMX_PMAXUBrr, MVT::v8i8); 14107 return Result; 14108 } 14109 14110 // Pattern: (intrinsic_wo_chain:v8i8 465:iPTR, VR64:v8i8:$src1, VR64:v8i8:$src2) 14111 // Emits: (MMX_PCMPEQBrr:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 14112 // Pattern complexity = 8 cost = 1 size = 3 14113 if (CN1 == INT64_C(465)) { 14114 SDNode *Result = Emit_109(N, X86::MMX_PCMPEQBrr, MVT::v8i8); 14115 return Result; 14116 } 14117 14118 // Pattern: (intrinsic_wo_chain:v8i8 468:iPTR, VR64:v8i8:$src1, VR64:v8i8:$src2) 14119 // Emits: (MMX_PCMPGTBrr:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 14120 // Pattern complexity = 8 cost = 1 size = 3 14121 if (CN1 == INT64_C(468)) { 14122 SDNode *Result = Emit_109(N, X86::MMX_PCMPGTBrr, MVT::v8i8); 14123 return Result; 14124 } 14125 14126 // Pattern: (intrinsic_wo_chain:v8i8 457:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 14127 // Emits: (MMX_PACKSSWBrr:v8i8 VR64:v4i16:$src1, VR64:v4i16:$src2) 14128 // Pattern complexity = 8 cost = 1 size = 3 14129 if (CN1 == INT64_C(457)) { 14130 SDNode *Result = Emit_109(N, X86::MMX_PACKSSWBrr, MVT::v8i8); 14131 return Result; 14132 } 14133 14134 // Pattern: (intrinsic_wo_chain:v8i8 458:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 14135 // Emits: (MMX_PACKUSWBrr:v8i8 VR64:v4i16:$src1, VR64:v4i16:$src2) 14136 // Pattern complexity = 8 cost = 1 size = 3 14137 if (CN1 == INT64_C(458)) { 14138 SDNode *Result = Emit_109(N, X86::MMX_PACKUSWBrr, MVT::v8i8); 14139 return Result; 14140 } 14141 } 14142 } 14143 14144 CannotYetSelectIntrinsic(N); 14145 return NULL; 14146 } 14147 14148 SDNode *Emit_117(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 14149 SDValue N0 = N.getOperand(0); 14150 SDValue N1 = N.getOperand(1); 14151 SDValue N2 = N.getOperand(2); 14152 SDValue N3 = N.getOperand(3); 14153 SDValue Tmp4 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N3)->getZExtValue()), MVT::i32); 14154 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N1, N2, Tmp4); 14155 } 14156 SDNode *Emit_118(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN201_0, SDValue &CPTmpN201_1, SDValue &CPTmpN201_2, SDValue &CPTmpN201_3, SDValue &CPTmpN201_4) DISABLE_INLINE { 14157 SDValue N0 = N.getOperand(0); 14158 SDValue N1 = N.getOperand(1); 14159 SDValue N2 = N.getOperand(2); 14160 SDValue N20 = N2.getOperand(0); 14161 SDValue Chain20 = N20.getOperand(0); 14162 SDValue N201 = N20.getOperand(1); 14163 SDValue N3 = N.getOperand(3); 14164 SDValue Tmp4 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N3)->getZExtValue()), MVT::i32); 14165 SDValue LSI_N20 = CurDAG->getMemOperand(cast<MemSDNode>(N20)->getMemOperand()); 14166 SDValue Ops0[] = { N1, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4, Tmp4, LSI_N20, Chain20 }; 14167 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 9); 14168 ReplaceUses(SDValue(N20.getNode(), 1), SDValue(ResNode, 1)); 14169 return ResNode; 14170 } 14171 SDNode *Emit_119(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 14172 SDValue N0 = N.getOperand(0); 14173 SDValue N1 = N.getOperand(1); 14174 SDValue N2 = N.getOperand(2); 14175 SDValue N3 = N.getOperand(3); 14176 SDValue Chain = CurDAG->getEntryNode(); 14177 SDValue InFlag(0, 0); 14178 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::XMM0, N3, InFlag).getNode(); 14179 Chain = SDValue(ResNode, 0); 14180 InFlag = SDValue(ResNode, 1); 14181 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N1, N2, InFlag); 14182 } 14183 SDNode *Emit_120(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN201_0, SDValue &CPTmpN201_1, SDValue &CPTmpN201_2, SDValue &CPTmpN201_3, SDValue &CPTmpN201_4) DISABLE_INLINE { 14184 SDValue N0 = N.getOperand(0); 14185 SDValue N1 = N.getOperand(1); 14186 SDValue N2 = N.getOperand(2); 14187 SDValue N20 = N2.getOperand(0); 14188 SDValue Chain20 = N20.getOperand(0); 14189 SDValue N201 = N20.getOperand(1); 14190 SDValue N3 = N.getOperand(3); 14191 SDValue InFlag(0, 0); 14192 SDNode *ResNode = CurDAG->getCopyToReg(Chain20, N.getDebugLoc(), X86::XMM0, N3, InFlag).getNode(); 14193 Chain20 = SDValue(ResNode, 0); 14194 InFlag = SDValue(ResNode, 1); 14195 SDValue LSI_N20 = CurDAG->getMemOperand(cast<MemSDNode>(N20)->getMemOperand()); 14196 SDValue Ops0[] = { N1, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4, LSI_N20, Chain20, InFlag }; 14197 ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 9); 14198 ReplaceUses(SDValue(N20.getNode(), 1), SDValue(ResNode, 1)); 14199 return ResNode; 14200 } 14201 SDNode *Emit_121(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 14202 SDValue N0 = N.getOperand(0); 14203 SDValue N1 = N.getOperand(1); 14204 SDValue N2 = N.getOperand(2); 14205 SDValue N3 = N.getOperand(3); 14206 SDValue Tmp4 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N3)->getZExtValue()), MVT::i8); 14207 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N1, N2, Tmp4); 14208 } 14209 SDNode *Emit_122(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN21_0, SDValue &CPTmpN21_1, SDValue &CPTmpN21_2, SDValue &CPTmpN21_3, SDValue &CPTmpN21_4) DISABLE_INLINE { 14210 SDValue N0 = N.getOperand(0); 14211 SDValue N1 = N.getOperand(1); 14212 SDValue N2 = N.getOperand(2); 14213 SDValue Chain2 = N2.getOperand(0); 14214 SDValue N21 = N2.getOperand(1); 14215 SDValue N3 = N.getOperand(3); 14216 SDValue Tmp4 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N3)->getZExtValue()), MVT::i8); 14217 SDValue LSI_N2 = CurDAG->getMemOperand(cast<MemSDNode>(N2)->getMemOperand()); 14218 SDValue Ops0[] = { N1, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4, Tmp4, LSI_N2, Chain2 }; 14219 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 9); 14220 ReplaceUses(SDValue(N2.getNode(), 1), SDValue(ResNode, 1)); 14221 return ResNode; 14222 } 14223 SDNode *Emit_123(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 14224 SDValue N0 = N.getOperand(0); 14225 SDValue N1 = N.getOperand(1); 14226 SDValue N2 = N.getOperand(2); 14227 SDValue N3 = N.getOperand(3); 14228 SDValue N4 = N.getOperand(4); 14229 SDValue N5 = N.getOperand(5); 14230 SDValue Tmp4 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N5)->getZExtValue()), MVT::i8); 14231 SDValue Chain = CurDAG->getEntryNode(); 14232 SDValue InFlag(0, 0); 14233 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::EAX, N2, InFlag).getNode(); 14234 Chain = SDValue(ResNode, 0); 14235 InFlag = SDValue(ResNode, 1); 14236 ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::EDX, N4, InFlag).getNode(); 14237 Chain = SDValue(ResNode, 0); 14238 InFlag = SDValue(ResNode, 1); 14239 SDValue Ops0[] = { N1, N3, Tmp4, InFlag }; 14240 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, Ops0, 4); 14241 } 14242 SDNode *Emit_124(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN31_0, SDValue &CPTmpN31_1, SDValue &CPTmpN31_2, SDValue &CPTmpN31_3, SDValue &CPTmpN31_4) DISABLE_INLINE { 14243 SDValue N0 = N.getOperand(0); 14244 SDValue N1 = N.getOperand(1); 14245 SDValue N2 = N.getOperand(2); 14246 SDValue N3 = N.getOperand(3); 14247 SDValue Chain3 = N3.getOperand(0); 14248 SDValue N31 = N3.getOperand(1); 14249 SDValue N4 = N.getOperand(4); 14250 SDValue N5 = N.getOperand(5); 14251 SDValue Tmp4 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N5)->getZExtValue()), MVT::i8); 14252 SDValue InFlag(0, 0); 14253 SDNode *ResNode = CurDAG->getCopyToReg(Chain3, N.getDebugLoc(), X86::EAX, N2, InFlag).getNode(); 14254 Chain3 = SDValue(ResNode, 0); 14255 InFlag = SDValue(ResNode, 1); 14256 ResNode = CurDAG->getCopyToReg(Chain3, N.getDebugLoc(), X86::EDX, N4, InFlag).getNode(); 14257 Chain3 = SDValue(ResNode, 0); 14258 InFlag = SDValue(ResNode, 1); 14259 SDValue LSI_N3 = CurDAG->getMemOperand(cast<MemSDNode>(N3)->getMemOperand()); 14260 SDValue Ops0[] = { N1, CPTmpN31_0, CPTmpN31_1, CPTmpN31_2, CPTmpN31_3, CPTmpN31_4, Tmp4, LSI_N3, Chain3, InFlag }; 14261 ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 10); 14262 ReplaceUses(SDValue(N3.getNode(), 1), SDValue(ResNode, 1)); 14263 return ResNode; 14264 } 14265 SDNode *Emit_125(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 14266 SDValue N0 = N.getOperand(0); 14267 SDValue N1 = N.getOperand(1); 14268 SDValue N10 = N1.getOperand(0); 14269 SDValue Chain10 = N10.getOperand(0); 14270 SDValue N101 = N10.getOperand(1); 14271 SDValue N2 = N.getOperand(2); 14272 SDValue N3 = N.getOperand(3); 14273 SDValue Tmp4 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N3)->getZExtValue()), MVT::i32); 14274 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 14275 SDValue Ops0[] = { N2, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, Tmp4, LSI_N10, Chain10 }; 14276 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 9); 14277 ReplaceUses(SDValue(N10.getNode(), 1), SDValue(ResNode, 1)); 14278 return ResNode; 14279 } 14280 SDNode *Select_ISD_INTRINSIC_WO_CHAIN_v16i8(const SDValue &N) { 14281 if (OptLevel != CodeGenOpt::None) { 14282 if ((Subtarget->hasSSE41())) { 14283 SDValue N0 = N.getOperand(0); 14284 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 14285 if (Tmp0) { 14286 int64_t CN1 = Tmp0->getSExtValue(); 14287 if (CN1 == INT64_C(621)) { 14288 SDValue N1 = N.getOperand(1); 14289 14290 // Pattern: (intrinsic_wo_chain:v16i8 621:iPTR, VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), (imm:i32):$src3) 14291 // Emits: (MPSADBWrmi:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2, (imm:i32):$src3) 14292 // Pattern complexity = 36 cost = 1 size = 3 14293 { 14294 SDValue N2 = N.getOperand(2); 14295 if (N2.getOpcode() == ISD::BIT_CONVERT && 14296 N2.hasOneUse()) { 14297 SDValue N20 = N2.getOperand(0); 14298 if (N20.getOpcode() == ISD::LOAD && 14299 N20.hasOneUse() && 14300 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 14301 SDValue Chain20 = N20.getOperand(0); 14302 if (Predicate_unindexedload(N20.getNode()) && 14303 Predicate_load(N20.getNode()) && 14304 Predicate_memop(N20.getNode())) { 14305 SDValue N201 = N20.getOperand(1); 14306 SDValue CPTmpN201_0; 14307 SDValue CPTmpN201_1; 14308 SDValue CPTmpN201_2; 14309 SDValue CPTmpN201_3; 14310 SDValue CPTmpN201_4; 14311 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4)) { 14312 SDValue N3 = N.getOperand(3); 14313 if (N3.getOpcode() == ISD::Constant && 14314 N20.getNode()->getValueType(0) == MVT::v16i8) { 14315 SDNode *Result = Emit_118(N, X86::MPSADBWrmi, MVT::v16i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 14316 return Result; 14317 } 14318 } 14319 } 14320 } 14321 } 14322 } 14323 14324 // Pattern: (intrinsic_wo_chain:v16i8 621:iPTR, (bitconvert:v16i8 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v16i8:$src1, (imm:i32):$src3) 14325 // Emits: (MPSADBWrmi:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2, (imm:i32):$src3) 14326 // Pattern complexity = 36 cost = 1 size = 3 14327 if (N1.getOpcode() == ISD::BIT_CONVERT && 14328 N1.hasOneUse()) { 14329 SDValue N10 = N1.getOperand(0); 14330 if (N10.getOpcode() == ISD::LOAD && 14331 N10.hasOneUse() && 14332 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 14333 SDValue Chain10 = N10.getOperand(0); 14334 if (Predicate_unindexedload(N10.getNode()) && 14335 Predicate_load(N10.getNode()) && 14336 Predicate_memop(N10.getNode())) { 14337 SDValue N101 = N10.getOperand(1); 14338 SDValue CPTmpN101_0; 14339 SDValue CPTmpN101_1; 14340 SDValue CPTmpN101_2; 14341 SDValue CPTmpN101_3; 14342 SDValue CPTmpN101_4; 14343 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 14344 SDValue N2 = N.getOperand(2); 14345 SDValue N3 = N.getOperand(3); 14346 if (N3.getOpcode() == ISD::Constant && 14347 N10.getNode()->getValueType(0) == MVT::v16i8) { 14348 SDNode *Result = Emit_125(N, X86::MPSADBWrmi, MVT::v16i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 14349 return Result; 14350 } 14351 } 14352 } 14353 } 14354 } 14355 } 14356 } 14357 } 14358 if ((Subtarget->hasSSE2())) { 14359 SDValue N0 = N.getOperand(0); 14360 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 14361 if (Tmp0) { 14362 int64_t CN1 = Tmp0->getSExtValue(); 14363 14364 // Pattern: (intrinsic_wo_chain:v16i8 545:iPTR, VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 14365 // Emits: (PADDSBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 14366 // Pattern complexity = 33 cost = 1 size = 3 14367 if (CN1 == INT64_C(545)) { 14368 SDValue N1 = N.getOperand(1); 14369 SDValue N2 = N.getOperand(2); 14370 if (N2.getOpcode() == ISD::BIT_CONVERT && 14371 N2.hasOneUse()) { 14372 SDValue N20 = N2.getOperand(0); 14373 if (N20.getOpcode() == ISD::LOAD && 14374 N20.hasOneUse() && 14375 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 14376 SDValue Chain20 = N20.getOperand(0); 14377 if (Predicate_unindexedload(N20.getNode()) && 14378 Predicate_load(N20.getNode()) && 14379 Predicate_memop(N20.getNode())) { 14380 SDValue N201 = N20.getOperand(1); 14381 SDValue CPTmpN201_0; 14382 SDValue CPTmpN201_1; 14383 SDValue CPTmpN201_2; 14384 SDValue CPTmpN201_3; 14385 SDValue CPTmpN201_4; 14386 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 14387 N20.getNode()->getValueType(0) == MVT::v2i64) { 14388 SDNode *Result = Emit_115(N, X86::PADDSBrm, MVT::v16i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 14389 return Result; 14390 } 14391 } 14392 } 14393 } 14394 } 14395 14396 // Pattern: (intrinsic_wo_chain:v16i8 547:iPTR, VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 14397 // Emits: (PADDUSBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 14398 // Pattern complexity = 33 cost = 1 size = 3 14399 if (CN1 == INT64_C(547)) { 14400 SDValue N1 = N.getOperand(1); 14401 SDValue N2 = N.getOperand(2); 14402 if (N2.getOpcode() == ISD::BIT_CONVERT && 14403 N2.hasOneUse()) { 14404 SDValue N20 = N2.getOperand(0); 14405 if (N20.getOpcode() == ISD::LOAD && 14406 N20.hasOneUse() && 14407 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 14408 SDValue Chain20 = N20.getOperand(0); 14409 if (Predicate_unindexedload(N20.getNode()) && 14410 Predicate_load(N20.getNode()) && 14411 Predicate_memop(N20.getNode())) { 14412 SDValue N201 = N20.getOperand(1); 14413 SDValue CPTmpN201_0; 14414 SDValue CPTmpN201_1; 14415 SDValue CPTmpN201_2; 14416 SDValue CPTmpN201_3; 14417 SDValue CPTmpN201_4; 14418 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 14419 N20.getNode()->getValueType(0) == MVT::v2i64) { 14420 SDNode *Result = Emit_115(N, X86::PADDUSBrm, MVT::v16i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 14421 return Result; 14422 } 14423 } 14424 } 14425 } 14426 } 14427 14428 // Pattern: (intrinsic_wo_chain:v16i8 587:iPTR, VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 14429 // Emits: (PSUBSBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 14430 // Pattern complexity = 33 cost = 1 size = 3 14431 if (CN1 == INT64_C(587)) { 14432 SDValue N1 = N.getOperand(1); 14433 SDValue N2 = N.getOperand(2); 14434 if (N2.getOpcode() == ISD::BIT_CONVERT && 14435 N2.hasOneUse()) { 14436 SDValue N20 = N2.getOperand(0); 14437 if (N20.getOpcode() == ISD::LOAD && 14438 N20.hasOneUse() && 14439 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 14440 SDValue Chain20 = N20.getOperand(0); 14441 if (Predicate_unindexedload(N20.getNode()) && 14442 Predicate_load(N20.getNode()) && 14443 Predicate_memop(N20.getNode())) { 14444 SDValue N201 = N20.getOperand(1); 14445 SDValue CPTmpN201_0; 14446 SDValue CPTmpN201_1; 14447 SDValue CPTmpN201_2; 14448 SDValue CPTmpN201_3; 14449 SDValue CPTmpN201_4; 14450 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 14451 N20.getNode()->getValueType(0) == MVT::v2i64) { 14452 SDNode *Result = Emit_115(N, X86::PSUBSBrm, MVT::v16i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 14453 return Result; 14454 } 14455 } 14456 } 14457 } 14458 } 14459 14460 // Pattern: (intrinsic_wo_chain:v16i8 589:iPTR, VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 14461 // Emits: (PSUBUSBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 14462 // Pattern complexity = 33 cost = 1 size = 3 14463 if (CN1 == INT64_C(589)) { 14464 SDValue N1 = N.getOperand(1); 14465 SDValue N2 = N.getOperand(2); 14466 if (N2.getOpcode() == ISD::BIT_CONVERT && 14467 N2.hasOneUse()) { 14468 SDValue N20 = N2.getOperand(0); 14469 if (N20.getOpcode() == ISD::LOAD && 14470 N20.hasOneUse() && 14471 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 14472 SDValue Chain20 = N20.getOperand(0); 14473 if (Predicate_unindexedload(N20.getNode()) && 14474 Predicate_load(N20.getNode()) && 14475 Predicate_memop(N20.getNode())) { 14476 SDValue N201 = N20.getOperand(1); 14477 SDValue CPTmpN201_0; 14478 SDValue CPTmpN201_1; 14479 SDValue CPTmpN201_2; 14480 SDValue CPTmpN201_3; 14481 SDValue CPTmpN201_4; 14482 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 14483 N20.getNode()->getValueType(0) == MVT::v2i64) { 14484 SDNode *Result = Emit_115(N, X86::PSUBUSBrm, MVT::v16i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 14485 return Result; 14486 } 14487 } 14488 } 14489 } 14490 } 14491 14492 // Pattern: (intrinsic_wo_chain:v16i8 549:iPTR, VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 14493 // Emits: (PAVGBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 14494 // Pattern complexity = 33 cost = 1 size = 3 14495 if (CN1 == INT64_C(549)) { 14496 SDValue N1 = N.getOperand(1); 14497 SDValue N2 = N.getOperand(2); 14498 if (N2.getOpcode() == ISD::BIT_CONVERT && 14499 N2.hasOneUse()) { 14500 SDValue N20 = N2.getOperand(0); 14501 if (N20.getOpcode() == ISD::LOAD && 14502 N20.hasOneUse() && 14503 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 14504 SDValue Chain20 = N20.getOperand(0); 14505 if (Predicate_unindexedload(N20.getNode()) && 14506 Predicate_load(N20.getNode()) && 14507 Predicate_memop(N20.getNode())) { 14508 SDValue N201 = N20.getOperand(1); 14509 SDValue CPTmpN201_0; 14510 SDValue CPTmpN201_1; 14511 SDValue CPTmpN201_2; 14512 SDValue CPTmpN201_3; 14513 SDValue CPTmpN201_4; 14514 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 14515 N20.getNode()->getValueType(0) == MVT::v2i64) { 14516 SDNode *Result = Emit_115(N, X86::PAVGBrm, MVT::v16i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 14517 return Result; 14518 } 14519 } 14520 } 14521 } 14522 } 14523 14524 // Pattern: (intrinsic_wo_chain:v16i8 561:iPTR, VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 14525 // Emits: (PMINUBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 14526 // Pattern complexity = 33 cost = 1 size = 3 14527 if (CN1 == INT64_C(561)) { 14528 SDValue N1 = N.getOperand(1); 14529 SDValue N2 = N.getOperand(2); 14530 if (N2.getOpcode() == ISD::BIT_CONVERT && 14531 N2.hasOneUse()) { 14532 SDValue N20 = N2.getOperand(0); 14533 if (N20.getOpcode() == ISD::LOAD && 14534 N20.hasOneUse() && 14535 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 14536 SDValue Chain20 = N20.getOperand(0); 14537 if (Predicate_unindexedload(N20.getNode()) && 14538 Predicate_load(N20.getNode()) && 14539 Predicate_memop(N20.getNode())) { 14540 SDValue N201 = N20.getOperand(1); 14541 SDValue CPTmpN201_0; 14542 SDValue CPTmpN201_1; 14543 SDValue CPTmpN201_2; 14544 SDValue CPTmpN201_3; 14545 SDValue CPTmpN201_4; 14546 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 14547 N20.getNode()->getValueType(0) == MVT::v2i64) { 14548 SDNode *Result = Emit_115(N, X86::PMINUBrm, MVT::v16i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 14549 return Result; 14550 } 14551 } 14552 } 14553 } 14554 } 14555 14556 // Pattern: (intrinsic_wo_chain:v16i8 559:iPTR, VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 14557 // Emits: (PMAXUBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 14558 // Pattern complexity = 33 cost = 1 size = 3 14559 if (CN1 == INT64_C(559)) { 14560 SDValue N1 = N.getOperand(1); 14561 SDValue N2 = N.getOperand(2); 14562 if (N2.getOpcode() == ISD::BIT_CONVERT && 14563 N2.hasOneUse()) { 14564 SDValue N20 = N2.getOperand(0); 14565 if (N20.getOpcode() == ISD::LOAD && 14566 N20.hasOneUse() && 14567 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 14568 SDValue Chain20 = N20.getOperand(0); 14569 if (Predicate_unindexedload(N20.getNode()) && 14570 Predicate_load(N20.getNode()) && 14571 Predicate_memop(N20.getNode())) { 14572 SDValue N201 = N20.getOperand(1); 14573 SDValue CPTmpN201_0; 14574 SDValue CPTmpN201_1; 14575 SDValue CPTmpN201_2; 14576 SDValue CPTmpN201_3; 14577 SDValue CPTmpN201_4; 14578 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 14579 N20.getNode()->getValueType(0) == MVT::v2i64) { 14580 SDNode *Result = Emit_115(N, X86::PMAXUBrm, MVT::v16i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 14581 return Result; 14582 } 14583 } 14584 } 14585 } 14586 } 14587 14588 // Pattern: (intrinsic_wo_chain:v16i8 551:iPTR, VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 14589 // Emits: (PCMPEQBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 14590 // Pattern complexity = 33 cost = 1 size = 3 14591 if (CN1 == INT64_C(551)) { 14592 SDValue N1 = N.getOperand(1); 14593 SDValue N2 = N.getOperand(2); 14594 if (N2.getOpcode() == ISD::BIT_CONVERT && 14595 N2.hasOneUse()) { 14596 SDValue N20 = N2.getOperand(0); 14597 if (N20.getOpcode() == ISD::LOAD && 14598 N20.hasOneUse() && 14599 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 14600 SDValue Chain20 = N20.getOperand(0); 14601 if (Predicate_unindexedload(N20.getNode()) && 14602 Predicate_load(N20.getNode()) && 14603 Predicate_memop(N20.getNode())) { 14604 SDValue N201 = N20.getOperand(1); 14605 SDValue CPTmpN201_0; 14606 SDValue CPTmpN201_1; 14607 SDValue CPTmpN201_2; 14608 SDValue CPTmpN201_3; 14609 SDValue CPTmpN201_4; 14610 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 14611 N20.getNode()->getValueType(0) == MVT::v2i64) { 14612 SDNode *Result = Emit_115(N, X86::PCMPEQBrm, MVT::v16i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 14613 return Result; 14614 } 14615 } 14616 } 14617 } 14618 } 14619 14620 // Pattern: (intrinsic_wo_chain:v16i8 554:iPTR, VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 14621 // Emits: (PCMPGTBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 14622 // Pattern complexity = 33 cost = 1 size = 3 14623 if (CN1 == INT64_C(554)) { 14624 SDValue N1 = N.getOperand(1); 14625 SDValue N2 = N.getOperand(2); 14626 if (N2.getOpcode() == ISD::BIT_CONVERT && 14627 N2.hasOneUse()) { 14628 SDValue N20 = N2.getOperand(0); 14629 if (N20.getOpcode() == ISD::LOAD && 14630 N20.hasOneUse() && 14631 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 14632 SDValue Chain20 = N20.getOperand(0); 14633 if (Predicate_unindexedload(N20.getNode()) && 14634 Predicate_load(N20.getNode()) && 14635 Predicate_memop(N20.getNode())) { 14636 SDValue N201 = N20.getOperand(1); 14637 SDValue CPTmpN201_0; 14638 SDValue CPTmpN201_1; 14639 SDValue CPTmpN201_2; 14640 SDValue CPTmpN201_3; 14641 SDValue CPTmpN201_4; 14642 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 14643 N20.getNode()->getValueType(0) == MVT::v2i64) { 14644 SDNode *Result = Emit_115(N, X86::PCMPGTBrm, MVT::v16i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 14645 return Result; 14646 } 14647 } 14648 } 14649 } 14650 } 14651 } 14652 } 14653 if ((Subtarget->hasSSSE3())) { 14654 SDValue N0 = N.getOperand(0); 14655 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 14656 if (Tmp0) { 14657 int64_t CN1 = Tmp0->getSExtValue(); 14658 14659 // Pattern: (intrinsic_wo_chain:v16i8 726:iPTR, (bitconvert:v16i8 (ld:v16i8 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 14660 // Emits: (PABSBrm128:v16i8 addr:iPTR:$src) 14661 // Pattern complexity = 33 cost = 1 size = 3 14662 if (CN1 == INT64_C(726)) { 14663 SDValue N1 = N.getOperand(1); 14664 if (N1.getOpcode() == ISD::BIT_CONVERT && 14665 N1.hasOneUse()) { 14666 SDValue N10 = N1.getOperand(0); 14667 if (N10.getOpcode() == ISD::LOAD && 14668 N10.hasOneUse() && 14669 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 14670 SDValue Chain10 = N10.getOperand(0); 14671 if (Predicate_unindexedload(N10.getNode()) && 14672 Predicate_load(N10.getNode()) && 14673 Predicate_memop(N10.getNode())) { 14674 SDValue N101 = N10.getOperand(1); 14675 SDValue CPTmpN101_0; 14676 SDValue CPTmpN101_1; 14677 SDValue CPTmpN101_2; 14678 SDValue CPTmpN101_3; 14679 SDValue CPTmpN101_4; 14680 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 14681 N10.getNode()->getValueType(0) == MVT::v16i8) { 14682 SDNode *Result = Emit_114(N, X86::PABSBrm128, MVT::v16i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 14683 return Result; 14684 } 14685 } 14686 } 14687 } 14688 } 14689 14690 // Pattern: (intrinsic_wo_chain:v16i8 750:iPTR, VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 14691 // Emits: (PSHUFBrm128:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 14692 // Pattern complexity = 33 cost = 1 size = 3 14693 if (CN1 == INT64_C(750)) { 14694 SDValue N1 = N.getOperand(1); 14695 SDValue N2 = N.getOperand(2); 14696 if (N2.getOpcode() == ISD::BIT_CONVERT && 14697 N2.hasOneUse()) { 14698 SDValue N20 = N2.getOperand(0); 14699 if (N20.getOpcode() == ISD::LOAD && 14700 N20.hasOneUse() && 14701 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 14702 SDValue Chain20 = N20.getOperand(0); 14703 if (Predicate_unindexedload(N20.getNode()) && 14704 Predicate_load(N20.getNode()) && 14705 Predicate_memop(N20.getNode())) { 14706 SDValue N201 = N20.getOperand(1); 14707 SDValue CPTmpN201_0; 14708 SDValue CPTmpN201_1; 14709 SDValue CPTmpN201_2; 14710 SDValue CPTmpN201_3; 14711 SDValue CPTmpN201_4; 14712 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 14713 N20.getNode()->getValueType(0) == MVT::v16i8) { 14714 SDNode *Result = Emit_115(N, X86::PSHUFBrm128, MVT::v16i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 14715 return Result; 14716 } 14717 } 14718 } 14719 } 14720 } 14721 14722 // Pattern: (intrinsic_wo_chain:v16i8 752:iPTR, VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 14723 // Emits: (PSIGNBrm128:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 14724 // Pattern complexity = 33 cost = 1 size = 3 14725 if (CN1 == INT64_C(752)) { 14726 SDValue N1 = N.getOperand(1); 14727 SDValue N2 = N.getOperand(2); 14728 if (N2.getOpcode() == ISD::BIT_CONVERT && 14729 N2.hasOneUse()) { 14730 SDValue N20 = N2.getOperand(0); 14731 if (N20.getOpcode() == ISD::LOAD && 14732 N20.hasOneUse() && 14733 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 14734 SDValue Chain20 = N20.getOperand(0); 14735 if (Predicate_unindexedload(N20.getNode()) && 14736 Predicate_load(N20.getNode()) && 14737 Predicate_memop(N20.getNode())) { 14738 SDValue N201 = N20.getOperand(1); 14739 SDValue CPTmpN201_0; 14740 SDValue CPTmpN201_1; 14741 SDValue CPTmpN201_2; 14742 SDValue CPTmpN201_3; 14743 SDValue CPTmpN201_4; 14744 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 14745 N20.getNode()->getValueType(0) == MVT::v16i8) { 14746 SDNode *Result = Emit_115(N, X86::PSIGNBrm128, MVT::v16i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 14747 return Result; 14748 } 14749 } 14750 } 14751 } 14752 } 14753 } 14754 } 14755 if ((Subtarget->hasSSE41())) { 14756 SDValue N0 = N.getOperand(0); 14757 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 14758 if (Tmp0) { 14759 int64_t CN1 = Tmp0->getSExtValue(); 14760 14761 // Pattern: (intrinsic_wo_chain:v16i8 634:iPTR, VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 14762 // Emits: (PMINSBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 14763 // Pattern complexity = 33 cost = 1 size = 3 14764 if (CN1 == INT64_C(634)) { 14765 SDValue N1 = N.getOperand(1); 14766 SDValue N2 = N.getOperand(2); 14767 if (N2.getOpcode() == ISD::BIT_CONVERT && 14768 N2.hasOneUse()) { 14769 SDValue N20 = N2.getOperand(0); 14770 if (N20.getOpcode() == ISD::LOAD && 14771 N20.hasOneUse() && 14772 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 14773 SDValue Chain20 = N20.getOperand(0); 14774 if (Predicate_unindexedload(N20.getNode()) && 14775 Predicate_load(N20.getNode()) && 14776 Predicate_memop(N20.getNode())) { 14777 SDValue N201 = N20.getOperand(1); 14778 SDValue CPTmpN201_0; 14779 SDValue CPTmpN201_1; 14780 SDValue CPTmpN201_2; 14781 SDValue CPTmpN201_3; 14782 SDValue CPTmpN201_4; 14783 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 14784 N20.getNode()->getValueType(0) == MVT::v16i8) { 14785 SDNode *Result = Emit_115(N, X86::PMINSBrm, MVT::v16i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 14786 return Result; 14787 } 14788 } 14789 } 14790 } 14791 } 14792 14793 // Pattern: (intrinsic_wo_chain:v16i8 630:iPTR, VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 14794 // Emits: (PMAXSBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 14795 // Pattern complexity = 33 cost = 1 size = 3 14796 if (CN1 == INT64_C(630)) { 14797 SDValue N1 = N.getOperand(1); 14798 SDValue N2 = N.getOperand(2); 14799 if (N2.getOpcode() == ISD::BIT_CONVERT && 14800 N2.hasOneUse()) { 14801 SDValue N20 = N2.getOperand(0); 14802 if (N20.getOpcode() == ISD::LOAD && 14803 N20.hasOneUse() && 14804 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 14805 SDValue Chain20 = N20.getOperand(0); 14806 if (Predicate_unindexedload(N20.getNode()) && 14807 Predicate_load(N20.getNode()) && 14808 Predicate_memop(N20.getNode())) { 14809 SDValue N201 = N20.getOperand(1); 14810 SDValue CPTmpN201_0; 14811 SDValue CPTmpN201_1; 14812 SDValue CPTmpN201_2; 14813 SDValue CPTmpN201_3; 14814 SDValue CPTmpN201_4; 14815 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 14816 N20.getNode()->getValueType(0) == MVT::v16i8) { 14817 SDNode *Result = Emit_115(N, X86::PMAXSBrm, MVT::v16i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 14818 return Result; 14819 } 14820 } 14821 } 14822 } 14823 } 14824 14825 // Pattern: (intrinsic_wo_chain:v16i8 623:iPTR, VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), XMM0:v16i8) 14826 // Emits: (PBLENDVBrm0:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 14827 // Pattern complexity = 33 cost = 1 size = 3 14828 if (CN1 == INT64_C(623)) { 14829 SDValue N1 = N.getOperand(1); 14830 SDValue N2 = N.getOperand(2); 14831 if (N2.getOpcode() == ISD::BIT_CONVERT && 14832 N2.hasOneUse()) { 14833 SDValue N20 = N2.getOperand(0); 14834 if (N20.getOpcode() == ISD::LOAD && 14835 N20.hasOneUse() && 14836 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 14837 SDValue Chain20 = N20.getOperand(0); 14838 if (Predicate_unindexedload(N20.getNode()) && 14839 Predicate_load(N20.getNode()) && 14840 Predicate_memop(N20.getNode())) { 14841 SDValue N201 = N20.getOperand(1); 14842 SDValue CPTmpN201_0; 14843 SDValue CPTmpN201_1; 14844 SDValue CPTmpN201_2; 14845 SDValue CPTmpN201_3; 14846 SDValue CPTmpN201_4; 14847 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4)) { 14848 SDValue N3 = N.getOperand(3); 14849 if (N20.getNode()->getValueType(0) == MVT::v16i8) { 14850 SDNode *Result = Emit_120(N, X86::PBLENDVBrm0, MVT::v16i8, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 14851 return Result; 14852 } 14853 } 14854 } 14855 } 14856 } 14857 } 14858 } 14859 } 14860 if ((Subtarget->hasSSE2())) { 14861 SDValue N0 = N.getOperand(0); 14862 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 14863 if (Tmp0) { 14864 int64_t CN1 = Tmp0->getSExtValue(); 14865 14866 // Pattern: (intrinsic_wo_chain:v16i8 545:iPTR, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v16i8:$src1) 14867 // Emits: (PADDSBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 14868 // Pattern complexity = 33 cost = 1 size = 3 14869 if (CN1 == INT64_C(545)) { 14870 SDValue N1 = N.getOperand(1); 14871 if (N1.getOpcode() == ISD::BIT_CONVERT && 14872 N1.hasOneUse()) { 14873 SDValue N10 = N1.getOperand(0); 14874 if (N10.getOpcode() == ISD::LOAD && 14875 N10.hasOneUse() && 14876 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 14877 SDValue Chain10 = N10.getOperand(0); 14878 if (Predicate_unindexedload(N10.getNode()) && 14879 Predicate_load(N10.getNode()) && 14880 Predicate_memop(N10.getNode())) { 14881 SDValue N101 = N10.getOperand(1); 14882 SDValue CPTmpN101_0; 14883 SDValue CPTmpN101_1; 14884 SDValue CPTmpN101_2; 14885 SDValue CPTmpN101_3; 14886 SDValue CPTmpN101_4; 14887 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 14888 SDValue N2 = N.getOperand(2); 14889 if (N10.getNode()->getValueType(0) == MVT::v2i64) { 14890 SDNode *Result = Emit_116(N, X86::PADDSBrm, MVT::v16i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 14891 return Result; 14892 } 14893 } 14894 } 14895 } 14896 } 14897 } 14898 14899 // Pattern: (intrinsic_wo_chain:v16i8 547:iPTR, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v16i8:$src1) 14900 // Emits: (PADDUSBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 14901 // Pattern complexity = 33 cost = 1 size = 3 14902 if (CN1 == INT64_C(547)) { 14903 SDValue N1 = N.getOperand(1); 14904 if (N1.getOpcode() == ISD::BIT_CONVERT && 14905 N1.hasOneUse()) { 14906 SDValue N10 = N1.getOperand(0); 14907 if (N10.getOpcode() == ISD::LOAD && 14908 N10.hasOneUse() && 14909 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 14910 SDValue Chain10 = N10.getOperand(0); 14911 if (Predicate_unindexedload(N10.getNode()) && 14912 Predicate_load(N10.getNode()) && 14913 Predicate_memop(N10.getNode())) { 14914 SDValue N101 = N10.getOperand(1); 14915 SDValue CPTmpN101_0; 14916 SDValue CPTmpN101_1; 14917 SDValue CPTmpN101_2; 14918 SDValue CPTmpN101_3; 14919 SDValue CPTmpN101_4; 14920 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 14921 SDValue N2 = N.getOperand(2); 14922 if (N10.getNode()->getValueType(0) == MVT::v2i64) { 14923 SDNode *Result = Emit_116(N, X86::PADDUSBrm, MVT::v16i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 14924 return Result; 14925 } 14926 } 14927 } 14928 } 14929 } 14930 } 14931 14932 // Pattern: (intrinsic_wo_chain:v16i8 549:iPTR, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v16i8:$src1) 14933 // Emits: (PAVGBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 14934 // Pattern complexity = 33 cost = 1 size = 3 14935 if (CN1 == INT64_C(549)) { 14936 SDValue N1 = N.getOperand(1); 14937 if (N1.getOpcode() == ISD::BIT_CONVERT && 14938 N1.hasOneUse()) { 14939 SDValue N10 = N1.getOperand(0); 14940 if (N10.getOpcode() == ISD::LOAD && 14941 N10.hasOneUse() && 14942 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 14943 SDValue Chain10 = N10.getOperand(0); 14944 if (Predicate_unindexedload(N10.getNode()) && 14945 Predicate_load(N10.getNode()) && 14946 Predicate_memop(N10.getNode())) { 14947 SDValue N101 = N10.getOperand(1); 14948 SDValue CPTmpN101_0; 14949 SDValue CPTmpN101_1; 14950 SDValue CPTmpN101_2; 14951 SDValue CPTmpN101_3; 14952 SDValue CPTmpN101_4; 14953 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 14954 SDValue N2 = N.getOperand(2); 14955 if (N10.getNode()->getValueType(0) == MVT::v2i64) { 14956 SDNode *Result = Emit_116(N, X86::PAVGBrm, MVT::v16i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 14957 return Result; 14958 } 14959 } 14960 } 14961 } 14962 } 14963 } 14964 14965 // Pattern: (intrinsic_wo_chain:v16i8 561:iPTR, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v16i8:$src1) 14966 // Emits: (PMINUBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 14967 // Pattern complexity = 33 cost = 1 size = 3 14968 if (CN1 == INT64_C(561)) { 14969 SDValue N1 = N.getOperand(1); 14970 if (N1.getOpcode() == ISD::BIT_CONVERT && 14971 N1.hasOneUse()) { 14972 SDValue N10 = N1.getOperand(0); 14973 if (N10.getOpcode() == ISD::LOAD && 14974 N10.hasOneUse() && 14975 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 14976 SDValue Chain10 = N10.getOperand(0); 14977 if (Predicate_unindexedload(N10.getNode()) && 14978 Predicate_load(N10.getNode()) && 14979 Predicate_memop(N10.getNode())) { 14980 SDValue N101 = N10.getOperand(1); 14981 SDValue CPTmpN101_0; 14982 SDValue CPTmpN101_1; 14983 SDValue CPTmpN101_2; 14984 SDValue CPTmpN101_3; 14985 SDValue CPTmpN101_4; 14986 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 14987 SDValue N2 = N.getOperand(2); 14988 if (N10.getNode()->getValueType(0) == MVT::v2i64) { 14989 SDNode *Result = Emit_116(N, X86::PMINUBrm, MVT::v16i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 14990 return Result; 14991 } 14992 } 14993 } 14994 } 14995 } 14996 } 14997 14998 // Pattern: (intrinsic_wo_chain:v16i8 559:iPTR, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v16i8:$src1) 14999 // Emits: (PMAXUBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 15000 // Pattern complexity = 33 cost = 1 size = 3 15001 if (CN1 == INT64_C(559)) { 15002 SDValue N1 = N.getOperand(1); 15003 if (N1.getOpcode() == ISD::BIT_CONVERT && 15004 N1.hasOneUse()) { 15005 SDValue N10 = N1.getOperand(0); 15006 if (N10.getOpcode() == ISD::LOAD && 15007 N10.hasOneUse() && 15008 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 15009 SDValue Chain10 = N10.getOperand(0); 15010 if (Predicate_unindexedload(N10.getNode()) && 15011 Predicate_load(N10.getNode()) && 15012 Predicate_memop(N10.getNode())) { 15013 SDValue N101 = N10.getOperand(1); 15014 SDValue CPTmpN101_0; 15015 SDValue CPTmpN101_1; 15016 SDValue CPTmpN101_2; 15017 SDValue CPTmpN101_3; 15018 SDValue CPTmpN101_4; 15019 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 15020 SDValue N2 = N.getOperand(2); 15021 if (N10.getNode()->getValueType(0) == MVT::v2i64) { 15022 SDNode *Result = Emit_116(N, X86::PMAXUBrm, MVT::v16i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 15023 return Result; 15024 } 15025 } 15026 } 15027 } 15028 } 15029 } 15030 } 15031 } 15032 if ((Subtarget->hasSSE41())) { 15033 SDValue N0 = N.getOperand(0); 15034 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 15035 if (Tmp0) { 15036 int64_t CN1 = Tmp0->getSExtValue(); 15037 15038 // Pattern: (intrinsic_wo_chain:v16i8 634:iPTR, (bitconvert:v16i8 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v16i8:$src1) 15039 // Emits: (PMINSBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 15040 // Pattern complexity = 33 cost = 1 size = 3 15041 if (CN1 == INT64_C(634)) { 15042 SDValue N1 = N.getOperand(1); 15043 if (N1.getOpcode() == ISD::BIT_CONVERT && 15044 N1.hasOneUse()) { 15045 SDValue N10 = N1.getOperand(0); 15046 if (N10.getOpcode() == ISD::LOAD && 15047 N10.hasOneUse() && 15048 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 15049 SDValue Chain10 = N10.getOperand(0); 15050 if (Predicate_unindexedload(N10.getNode()) && 15051 Predicate_load(N10.getNode()) && 15052 Predicate_memop(N10.getNode())) { 15053 SDValue N101 = N10.getOperand(1); 15054 SDValue CPTmpN101_0; 15055 SDValue CPTmpN101_1; 15056 SDValue CPTmpN101_2; 15057 SDValue CPTmpN101_3; 15058 SDValue CPTmpN101_4; 15059 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 15060 SDValue N2 = N.getOperand(2); 15061 if (N10.getNode()->getValueType(0) == MVT::v16i8) { 15062 SDNode *Result = Emit_116(N, X86::PMINSBrm, MVT::v16i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 15063 return Result; 15064 } 15065 } 15066 } 15067 } 15068 } 15069 } 15070 15071 // Pattern: (intrinsic_wo_chain:v16i8 630:iPTR, (bitconvert:v16i8 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v16i8:$src1) 15072 // Emits: (PMAXSBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 15073 // Pattern complexity = 33 cost = 1 size = 3 15074 if (CN1 == INT64_C(630)) { 15075 SDValue N1 = N.getOperand(1); 15076 if (N1.getOpcode() == ISD::BIT_CONVERT && 15077 N1.hasOneUse()) { 15078 SDValue N10 = N1.getOperand(0); 15079 if (N10.getOpcode() == ISD::LOAD && 15080 N10.hasOneUse() && 15081 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 15082 SDValue Chain10 = N10.getOperand(0); 15083 if (Predicate_unindexedload(N10.getNode()) && 15084 Predicate_load(N10.getNode()) && 15085 Predicate_memop(N10.getNode())) { 15086 SDValue N101 = N10.getOperand(1); 15087 SDValue CPTmpN101_0; 15088 SDValue CPTmpN101_1; 15089 SDValue CPTmpN101_2; 15090 SDValue CPTmpN101_3; 15091 SDValue CPTmpN101_4; 15092 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 15093 SDValue N2 = N.getOperand(2); 15094 if (N10.getNode()->getValueType(0) == MVT::v16i8) { 15095 SDNode *Result = Emit_116(N, X86::PMAXSBrm, MVT::v16i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 15096 return Result; 15097 } 15098 } 15099 } 15100 } 15101 } 15102 } 15103 } 15104 } 15105 if ((Subtarget->hasSSE42())) { 15106 SDValue N0 = N.getOperand(0); 15107 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 15108 if (Tmp0) { 15109 int64_t CN1 = Tmp0->getSExtValue(); 15110 15111 // Pattern: (intrinsic_wo_chain:v16i8 677:iPTR, VR128:v16i8:$src1, (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i8):$src3) 15112 // Emits: (PCMPISTRM128MEM:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2, (imm:i8):$src3) 15113 // Pattern complexity = 33 cost = 11 size = 3 15114 if (CN1 == INT64_C(677)) { 15115 SDValue N1 = N.getOperand(1); 15116 SDValue N2 = N.getOperand(2); 15117 if (N2.getOpcode() == ISD::LOAD && 15118 N2.hasOneUse() && 15119 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 15120 SDValue Chain2 = N2.getOperand(0); 15121 if (Predicate_unindexedload(N2.getNode()) && 15122 Predicate_load(N2.getNode())) { 15123 SDValue N21 = N2.getOperand(1); 15124 SDValue CPTmpN21_0; 15125 SDValue CPTmpN21_1; 15126 SDValue CPTmpN21_2; 15127 SDValue CPTmpN21_3; 15128 SDValue CPTmpN21_4; 15129 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 15130 SDValue N3 = N.getOperand(3); 15131 if (N3.getOpcode() == ISD::Constant) { 15132 SDNode *Result = Emit_122(N, X86::PCMPISTRM128MEM, MVT::v16i8, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 15133 return Result; 15134 } 15135 } 15136 } 15137 } 15138 } 15139 15140 // Pattern: (intrinsic_wo_chain:v16i8 669:iPTR, VR128:v16i8:$src1, EAX:i32, (ld:v16i8 addr:iPTR:$src3)<<P:Predicate_unindexedload>><<P:Predicate_load>>, EDX:i32, (imm:i8):$src5) 15141 // Emits: (PCMPESTRM128MEM:v16i8 VR128:v16i8:$src1, addr:iPTR:$src3, (imm:i8):$src5) 15142 // Pattern complexity = 33 cost = 11 size = 3 15143 if (CN1 == INT64_C(669)) { 15144 SDValue N1 = N.getOperand(1); 15145 SDValue N2 = N.getOperand(2); 15146 SDValue N3 = N.getOperand(3); 15147 if (N3.getOpcode() == ISD::LOAD && 15148 N3.hasOneUse() && 15149 IsLegalAndProfitableToFold(N3.getNode(), N.getNode(), N.getNode())) { 15150 SDValue Chain3 = N3.getOperand(0); 15151 if (Predicate_unindexedload(N3.getNode()) && 15152 Predicate_load(N3.getNode())) { 15153 SDValue N31 = N3.getOperand(1); 15154 SDValue CPTmpN31_0; 15155 SDValue CPTmpN31_1; 15156 SDValue CPTmpN31_2; 15157 SDValue CPTmpN31_3; 15158 SDValue CPTmpN31_4; 15159 if (SelectAddr(N, N31, CPTmpN31_0, CPTmpN31_1, CPTmpN31_2, CPTmpN31_3, CPTmpN31_4)) { 15160 SDValue N4 = N.getOperand(4); 15161 SDValue N5 = N.getOperand(5); 15162 if (N5.getOpcode() == ISD::Constant) { 15163 SDNode *Result = Emit_124(N, X86::PCMPESTRM128MEM, MVT::v16i8, CPTmpN31_0, CPTmpN31_1, CPTmpN31_2, CPTmpN31_3, CPTmpN31_4); 15164 return Result; 15165 } 15166 } 15167 } 15168 } 15169 } 15170 } 15171 } 15172 } 15173 15174 // Pattern: (intrinsic_wo_chain:v16i8 621:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i32):$src3) 15175 // Emits: (MPSADBWrri:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i32):$src3) 15176 // Pattern complexity = 11 cost = 1 size = 3 15177 if ((Subtarget->hasSSE41())) { 15178 SDValue N0 = N.getOperand(0); 15179 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 15180 if (Tmp0) { 15181 int64_t CN1 = Tmp0->getSExtValue(); 15182 if (CN1 == INT64_C(621)) { 15183 SDValue N1 = N.getOperand(1); 15184 SDValue N2 = N.getOperand(2); 15185 SDValue N3 = N.getOperand(3); 15186 if (N3.getOpcode() == ISD::Constant) { 15187 SDNode *Result = Emit_117(N, X86::MPSADBWrri, MVT::v16i8); 15188 return Result; 15189 } 15190 } 15191 } 15192 } 15193 if ((Subtarget->hasSSE42())) { 15194 SDValue N0 = N.getOperand(0); 15195 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 15196 if (Tmp0) { 15197 int64_t CN1 = Tmp0->getSExtValue(); 15198 15199 // Pattern: (intrinsic_wo_chain:v16i8 677:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i8):$src3) 15200 // Emits: (PCMPISTRM128REG:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i8):$src3) 15201 // Pattern complexity = 11 cost = 11 size = 3 15202 if (CN1 == INT64_C(677)) { 15203 SDValue N1 = N.getOperand(1); 15204 SDValue N2 = N.getOperand(2); 15205 SDValue N3 = N.getOperand(3); 15206 if (N3.getOpcode() == ISD::Constant) { 15207 SDNode *Result = Emit_121(N, X86::PCMPISTRM128REG, MVT::v16i8); 15208 return Result; 15209 } 15210 } 15211 15212 // Pattern: (intrinsic_wo_chain:v16i8 669:iPTR, VR128:v16i8:$src1, EAX:i32, VR128:v16i8:$src3, EDX:i32, (imm:i8):$src5) 15213 // Emits: (PCMPESTRM128REG:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src3, (imm:i8):$src5) 15214 // Pattern complexity = 11 cost = 11 size = 3 15215 if (CN1 == INT64_C(669)) { 15216 SDValue N1 = N.getOperand(1); 15217 SDValue N2 = N.getOperand(2); 15218 SDValue N3 = N.getOperand(3); 15219 SDValue N4 = N.getOperand(4); 15220 SDValue N5 = N.getOperand(5); 15221 if (N5.getOpcode() == ISD::Constant) { 15222 SDNode *Result = Emit_123(N, X86::PCMPESTRM128REG, MVT::v16i8); 15223 return Result; 15224 } 15225 } 15226 } 15227 } 15228 if ((Subtarget->hasSSE2())) { 15229 SDValue N0 = N.getOperand(0); 15230 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 15231 if (Tmp0) { 15232 int64_t CN1 = Tmp0->getSExtValue(); 15233 15234 // Pattern: (intrinsic_wo_chain:v16i8 545:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2) 15235 // Emits: (PADDSBrr:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 15236 // Pattern complexity = 8 cost = 1 size = 3 15237 if (CN1 == INT64_C(545)) { 15238 SDNode *Result = Emit_109(N, X86::PADDSBrr, MVT::v16i8); 15239 return Result; 15240 } 15241 15242 // Pattern: (intrinsic_wo_chain:v16i8 547:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2) 15243 // Emits: (PADDUSBrr:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 15244 // Pattern complexity = 8 cost = 1 size = 3 15245 if (CN1 == INT64_C(547)) { 15246 SDNode *Result = Emit_109(N, X86::PADDUSBrr, MVT::v16i8); 15247 return Result; 15248 } 15249 15250 // Pattern: (intrinsic_wo_chain:v16i8 587:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2) 15251 // Emits: (PSUBSBrr:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 15252 // Pattern complexity = 8 cost = 1 size = 3 15253 if (CN1 == INT64_C(587)) { 15254 SDNode *Result = Emit_109(N, X86::PSUBSBrr, MVT::v16i8); 15255 return Result; 15256 } 15257 15258 // Pattern: (intrinsic_wo_chain:v16i8 589:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2) 15259 // Emits: (PSUBUSBrr:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 15260 // Pattern complexity = 8 cost = 1 size = 3 15261 if (CN1 == INT64_C(589)) { 15262 SDNode *Result = Emit_109(N, X86::PSUBUSBrr, MVT::v16i8); 15263 return Result; 15264 } 15265 15266 // Pattern: (intrinsic_wo_chain:v16i8 549:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2) 15267 // Emits: (PAVGBrr:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 15268 // Pattern complexity = 8 cost = 1 size = 3 15269 if (CN1 == INT64_C(549)) { 15270 SDNode *Result = Emit_109(N, X86::PAVGBrr, MVT::v16i8); 15271 return Result; 15272 } 15273 15274 // Pattern: (intrinsic_wo_chain:v16i8 561:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2) 15275 // Emits: (PMINUBrr:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 15276 // Pattern complexity = 8 cost = 1 size = 3 15277 if (CN1 == INT64_C(561)) { 15278 SDNode *Result = Emit_109(N, X86::PMINUBrr, MVT::v16i8); 15279 return Result; 15280 } 15281 15282 // Pattern: (intrinsic_wo_chain:v16i8 559:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2) 15283 // Emits: (PMAXUBrr:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 15284 // Pattern complexity = 8 cost = 1 size = 3 15285 if (CN1 == INT64_C(559)) { 15286 SDNode *Result = Emit_109(N, X86::PMAXUBrr, MVT::v16i8); 15287 return Result; 15288 } 15289 15290 // Pattern: (intrinsic_wo_chain:v16i8 551:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2) 15291 // Emits: (PCMPEQBrr:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 15292 // Pattern complexity = 8 cost = 1 size = 3 15293 if (CN1 == INT64_C(551)) { 15294 SDNode *Result = Emit_109(N, X86::PCMPEQBrr, MVT::v16i8); 15295 return Result; 15296 } 15297 15298 // Pattern: (intrinsic_wo_chain:v16i8 554:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2) 15299 // Emits: (PCMPGTBrr:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 15300 // Pattern complexity = 8 cost = 1 size = 3 15301 if (CN1 == INT64_C(554)) { 15302 SDNode *Result = Emit_109(N, X86::PCMPGTBrr, MVT::v16i8); 15303 return Result; 15304 } 15305 } 15306 } 15307 if ((Subtarget->hasSSSE3())) { 15308 SDValue N0 = N.getOperand(0); 15309 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 15310 if (Tmp0) { 15311 int64_t CN1 = Tmp0->getSExtValue(); 15312 15313 // Pattern: (intrinsic_wo_chain:v16i8 726:iPTR, VR128:v16i8:$src) 15314 // Emits: (PABSBrr128:v16i8 VR128:v16i8:$src) 15315 // Pattern complexity = 8 cost = 1 size = 3 15316 if (CN1 == INT64_C(726)) { 15317 SDNode *Result = Emit_106(N, X86::PABSBrr128, MVT::v16i8); 15318 return Result; 15319 } 15320 15321 // Pattern: (intrinsic_wo_chain:v16i8 750:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2) 15322 // Emits: (PSHUFBrr128:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 15323 // Pattern complexity = 8 cost = 1 size = 3 15324 if (CN1 == INT64_C(750)) { 15325 SDNode *Result = Emit_109(N, X86::PSHUFBrr128, MVT::v16i8); 15326 return Result; 15327 } 15328 15329 // Pattern: (intrinsic_wo_chain:v16i8 752:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2) 15330 // Emits: (PSIGNBrr128:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 15331 // Pattern complexity = 8 cost = 1 size = 3 15332 if (CN1 == INT64_C(752)) { 15333 SDNode *Result = Emit_109(N, X86::PSIGNBrr128, MVT::v16i8); 15334 return Result; 15335 } 15336 } 15337 } 15338 if ((Subtarget->hasSSE41())) { 15339 SDValue N0 = N.getOperand(0); 15340 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 15341 if (Tmp0) { 15342 int64_t CN1 = Tmp0->getSExtValue(); 15343 15344 // Pattern: (intrinsic_wo_chain:v16i8 634:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2) 15345 // Emits: (PMINSBrr:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 15346 // Pattern complexity = 8 cost = 1 size = 3 15347 if (CN1 == INT64_C(634)) { 15348 SDNode *Result = Emit_109(N, X86::PMINSBrr, MVT::v16i8); 15349 return Result; 15350 } 15351 15352 // Pattern: (intrinsic_wo_chain:v16i8 630:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2) 15353 // Emits: (PMAXSBrr:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 15354 // Pattern complexity = 8 cost = 1 size = 3 15355 if (CN1 == INT64_C(630)) { 15356 SDNode *Result = Emit_109(N, X86::PMAXSBrr, MVT::v16i8); 15357 return Result; 15358 } 15359 15360 // Pattern: (intrinsic_wo_chain:v16i8 623:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2, XMM0:v16i8) 15361 // Emits: (PBLENDVBrr0:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 15362 // Pattern complexity = 8 cost = 1 size = 3 15363 if (CN1 == INT64_C(623)) { 15364 SDNode *Result = Emit_119(N, X86::PBLENDVBrr0, MVT::v16i8); 15365 return Result; 15366 } 15367 } 15368 } 15369 15370 CannotYetSelectIntrinsic(N); 15371 return NULL; 15372 } 15373 15374 SDNode *Emit_126(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 15375 SDValue N0 = N.getOperand(0); 15376 SDValue N1 = N.getOperand(1); 15377 SDValue N2 = N.getOperand(2); 15378 SDValue Tmp3 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N2)->getZExtValue()), MVT::i32); 15379 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N1, Tmp3); 15380 } 15381 SDNode *Select_ISD_INTRINSIC_WO_CHAIN_v4i16(const SDValue &N) { 15382 if (OptLevel != CodeGenOpt::None) { 15383 if ((Subtarget->hasSSSE3())) { 15384 SDValue N0 = N.getOperand(0); 15385 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 15386 if (Tmp0) { 15387 int64_t CN1 = Tmp0->getSExtValue(); 15388 15389 // Pattern: (intrinsic_wo_chain:v4i16 729:iPTR, (bitconvert:v4i16 (ld:v4i16 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 15390 // Emits: (PABSWrm64:v4i16 addr:iPTR:$src) 15391 // Pattern complexity = 33 cost = 1 size = 3 15392 if (CN1 == INT64_C(729)) { 15393 SDValue N1 = N.getOperand(1); 15394 if (N1.getOpcode() == ISD::BIT_CONVERT && 15395 N1.hasOneUse()) { 15396 SDValue N10 = N1.getOperand(0); 15397 if (N10.getOpcode() == ISD::LOAD && 15398 N10.hasOneUse() && 15399 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 15400 SDValue Chain10 = N10.getOperand(0); 15401 if (Predicate_unindexedload(N10.getNode()) && 15402 Predicate_load(N10.getNode()) && 15403 Predicate_memop64(N10.getNode())) { 15404 SDValue N101 = N10.getOperand(1); 15405 SDValue CPTmpN101_0; 15406 SDValue CPTmpN101_1; 15407 SDValue CPTmpN101_2; 15408 SDValue CPTmpN101_3; 15409 SDValue CPTmpN101_4; 15410 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 15411 N10.getNode()->getValueType(0) == MVT::v4i16) { 15412 SDNode *Result = Emit_114(N, X86::PABSWrm64, MVT::v4i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 15413 return Result; 15414 } 15415 } 15416 } 15417 } 15418 } 15419 15420 // Pattern: (intrinsic_wo_chain:v4i16 737:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v4i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 15421 // Emits: (PHADDWrm64:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 15422 // Pattern complexity = 33 cost = 1 size = 3 15423 if (CN1 == INT64_C(737)) { 15424 SDValue N1 = N.getOperand(1); 15425 SDValue N2 = N.getOperand(2); 15426 if (N2.getOpcode() == ISD::BIT_CONVERT && 15427 N2.hasOneUse()) { 15428 SDValue N20 = N2.getOperand(0); 15429 if (N20.getOpcode() == ISD::LOAD && 15430 N20.hasOneUse() && 15431 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 15432 SDValue Chain20 = N20.getOperand(0); 15433 if (Predicate_unindexedload(N20.getNode()) && 15434 Predicate_load(N20.getNode()) && 15435 Predicate_memop64(N20.getNode())) { 15436 SDValue N201 = N20.getOperand(1); 15437 SDValue CPTmpN201_0; 15438 SDValue CPTmpN201_1; 15439 SDValue CPTmpN201_2; 15440 SDValue CPTmpN201_3; 15441 SDValue CPTmpN201_4; 15442 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 15443 N20.getNode()->getValueType(0) == MVT::v4i16) { 15444 SDNode *Result = Emit_115(N, X86::PHADDWrm64, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 15445 return Result; 15446 } 15447 } 15448 } 15449 } 15450 } 15451 15452 // Pattern: (intrinsic_wo_chain:v4i16 735:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v4i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 15453 // Emits: (PHADDSWrm64:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 15454 // Pattern complexity = 33 cost = 1 size = 3 15455 if (CN1 == INT64_C(735)) { 15456 SDValue N1 = N.getOperand(1); 15457 SDValue N2 = N.getOperand(2); 15458 if (N2.getOpcode() == ISD::BIT_CONVERT && 15459 N2.hasOneUse()) { 15460 SDValue N20 = N2.getOperand(0); 15461 if (N20.getOpcode() == ISD::LOAD && 15462 N20.hasOneUse() && 15463 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 15464 SDValue Chain20 = N20.getOperand(0); 15465 if (Predicate_unindexedload(N20.getNode()) && 15466 Predicate_load(N20.getNode()) && 15467 Predicate_memop64(N20.getNode())) { 15468 SDValue N201 = N20.getOperand(1); 15469 SDValue CPTmpN201_0; 15470 SDValue CPTmpN201_1; 15471 SDValue CPTmpN201_2; 15472 SDValue CPTmpN201_3; 15473 SDValue CPTmpN201_4; 15474 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 15475 N20.getNode()->getValueType(0) == MVT::v4i16) { 15476 SDNode *Result = Emit_115(N, X86::PHADDSWrm64, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 15477 return Result; 15478 } 15479 } 15480 } 15481 } 15482 } 15483 15484 // Pattern: (intrinsic_wo_chain:v4i16 743:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v4i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 15485 // Emits: (PHSUBWrm64:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 15486 // Pattern complexity = 33 cost = 1 size = 3 15487 if (CN1 == INT64_C(743)) { 15488 SDValue N1 = N.getOperand(1); 15489 SDValue N2 = N.getOperand(2); 15490 if (N2.getOpcode() == ISD::BIT_CONVERT && 15491 N2.hasOneUse()) { 15492 SDValue N20 = N2.getOperand(0); 15493 if (N20.getOpcode() == ISD::LOAD && 15494 N20.hasOneUse() && 15495 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 15496 SDValue Chain20 = N20.getOperand(0); 15497 if (Predicate_unindexedload(N20.getNode()) && 15498 Predicate_load(N20.getNode()) && 15499 Predicate_memop64(N20.getNode())) { 15500 SDValue N201 = N20.getOperand(1); 15501 SDValue CPTmpN201_0; 15502 SDValue CPTmpN201_1; 15503 SDValue CPTmpN201_2; 15504 SDValue CPTmpN201_3; 15505 SDValue CPTmpN201_4; 15506 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 15507 N20.getNode()->getValueType(0) == MVT::v4i16) { 15508 SDNode *Result = Emit_115(N, X86::PHSUBWrm64, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 15509 return Result; 15510 } 15511 } 15512 } 15513 } 15514 } 15515 15516 // Pattern: (intrinsic_wo_chain:v4i16 741:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v4i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 15517 // Emits: (PHSUBSWrm64:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 15518 // Pattern complexity = 33 cost = 1 size = 3 15519 if (CN1 == INT64_C(741)) { 15520 SDValue N1 = N.getOperand(1); 15521 SDValue N2 = N.getOperand(2); 15522 if (N2.getOpcode() == ISD::BIT_CONVERT && 15523 N2.hasOneUse()) { 15524 SDValue N20 = N2.getOperand(0); 15525 if (N20.getOpcode() == ISD::LOAD && 15526 N20.hasOneUse() && 15527 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 15528 SDValue Chain20 = N20.getOperand(0); 15529 if (Predicate_unindexedload(N20.getNode()) && 15530 Predicate_load(N20.getNode()) && 15531 Predicate_memop64(N20.getNode())) { 15532 SDValue N201 = N20.getOperand(1); 15533 SDValue CPTmpN201_0; 15534 SDValue CPTmpN201_1; 15535 SDValue CPTmpN201_2; 15536 SDValue CPTmpN201_3; 15537 SDValue CPTmpN201_4; 15538 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 15539 N20.getNode()->getValueType(0) == MVT::v4i16) { 15540 SDNode *Result = Emit_115(N, X86::PHSUBSWrm64, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 15541 return Result; 15542 } 15543 } 15544 } 15545 } 15546 } 15547 15548 // Pattern: (intrinsic_wo_chain:v4i16 745:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v8i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 15549 // Emits: (PMADDUBSWrm64:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 15550 // Pattern complexity = 33 cost = 1 size = 3 15551 if (CN1 == INT64_C(745)) { 15552 SDValue N1 = N.getOperand(1); 15553 SDValue N2 = N.getOperand(2); 15554 if (N2.getOpcode() == ISD::BIT_CONVERT && 15555 N2.hasOneUse()) { 15556 SDValue N20 = N2.getOperand(0); 15557 if (N20.getOpcode() == ISD::LOAD && 15558 N20.hasOneUse() && 15559 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 15560 SDValue Chain20 = N20.getOperand(0); 15561 if (Predicate_unindexedload(N20.getNode()) && 15562 Predicate_load(N20.getNode()) && 15563 Predicate_memop64(N20.getNode())) { 15564 SDValue N201 = N20.getOperand(1); 15565 SDValue CPTmpN201_0; 15566 SDValue CPTmpN201_1; 15567 SDValue CPTmpN201_2; 15568 SDValue CPTmpN201_3; 15569 SDValue CPTmpN201_4; 15570 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 15571 N20.getNode()->getValueType(0) == MVT::v8i8) { 15572 SDNode *Result = Emit_115(N, X86::PMADDUBSWrm64, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 15573 return Result; 15574 } 15575 } 15576 } 15577 } 15578 } 15579 15580 // Pattern: (intrinsic_wo_chain:v4i16 747:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v4i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 15581 // Emits: (PMULHRSWrm64:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 15582 // Pattern complexity = 33 cost = 1 size = 3 15583 if (CN1 == INT64_C(747)) { 15584 SDValue N1 = N.getOperand(1); 15585 SDValue N2 = N.getOperand(2); 15586 if (N2.getOpcode() == ISD::BIT_CONVERT && 15587 N2.hasOneUse()) { 15588 SDValue N20 = N2.getOperand(0); 15589 if (N20.getOpcode() == ISD::LOAD && 15590 N20.hasOneUse() && 15591 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 15592 SDValue Chain20 = N20.getOperand(0); 15593 if (Predicate_unindexedload(N20.getNode()) && 15594 Predicate_load(N20.getNode()) && 15595 Predicate_memop64(N20.getNode())) { 15596 SDValue N201 = N20.getOperand(1); 15597 SDValue CPTmpN201_0; 15598 SDValue CPTmpN201_1; 15599 SDValue CPTmpN201_2; 15600 SDValue CPTmpN201_3; 15601 SDValue CPTmpN201_4; 15602 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 15603 N20.getNode()->getValueType(0) == MVT::v4i16) { 15604 SDNode *Result = Emit_115(N, X86::PMULHRSWrm64, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 15605 return Result; 15606 } 15607 } 15608 } 15609 } 15610 } 15611 15612 // Pattern: (intrinsic_wo_chain:v4i16 755:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v4i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 15613 // Emits: (PSIGNWrm64:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 15614 // Pattern complexity = 33 cost = 1 size = 3 15615 if (CN1 == INT64_C(755)) { 15616 SDValue N1 = N.getOperand(1); 15617 SDValue N2 = N.getOperand(2); 15618 if (N2.getOpcode() == ISD::BIT_CONVERT && 15619 N2.hasOneUse()) { 15620 SDValue N20 = N2.getOperand(0); 15621 if (N20.getOpcode() == ISD::LOAD && 15622 N20.hasOneUse() && 15623 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 15624 SDValue Chain20 = N20.getOperand(0); 15625 if (Predicate_unindexedload(N20.getNode()) && 15626 Predicate_load(N20.getNode()) && 15627 Predicate_memop64(N20.getNode())) { 15628 SDValue N201 = N20.getOperand(1); 15629 SDValue CPTmpN201_0; 15630 SDValue CPTmpN201_1; 15631 SDValue CPTmpN201_2; 15632 SDValue CPTmpN201_3; 15633 SDValue CPTmpN201_4; 15634 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 15635 N20.getNode()->getValueType(0) == MVT::v4i16) { 15636 SDNode *Result = Emit_115(N, X86::PSIGNWrm64, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 15637 return Result; 15638 } 15639 } 15640 } 15641 } 15642 } 15643 } 15644 } 15645 if ((Subtarget->hasMMX())) { 15646 SDValue N0 = N.getOperand(0); 15647 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 15648 if (Tmp0) { 15649 int64_t CN1 = Tmp0->getSExtValue(); 15650 15651 // Pattern: (intrinsic_wo_chain:v4i16 460:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 15652 // Emits: (MMX_PADDSWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 15653 // Pattern complexity = 33 cost = 1 size = 3 15654 if (CN1 == INT64_C(460)) { 15655 SDValue N1 = N.getOperand(1); 15656 SDValue N2 = N.getOperand(2); 15657 if (N2.getOpcode() == ISD::BIT_CONVERT && 15658 N2.hasOneUse()) { 15659 SDValue N20 = N2.getOperand(0); 15660 if (N20.getOpcode() == ISD::LOAD && 15661 N20.hasOneUse() && 15662 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 15663 SDValue Chain20 = N20.getOperand(0); 15664 if (Predicate_unindexedload(N20.getNode()) && 15665 Predicate_load(N20.getNode())) { 15666 SDValue N201 = N20.getOperand(1); 15667 SDValue CPTmpN201_0; 15668 SDValue CPTmpN201_1; 15669 SDValue CPTmpN201_2; 15670 SDValue CPTmpN201_3; 15671 SDValue CPTmpN201_4; 15672 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 15673 N20.getNode()->getValueType(0) == MVT::v1i64) { 15674 SDNode *Result = Emit_115(N, X86::MMX_PADDSWrm, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 15675 return Result; 15676 } 15677 } 15678 } 15679 } 15680 } 15681 15682 // Pattern: (intrinsic_wo_chain:v4i16 462:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 15683 // Emits: (MMX_PADDUSWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 15684 // Pattern complexity = 33 cost = 1 size = 3 15685 if (CN1 == INT64_C(462)) { 15686 SDValue N1 = N.getOperand(1); 15687 SDValue N2 = N.getOperand(2); 15688 if (N2.getOpcode() == ISD::BIT_CONVERT && 15689 N2.hasOneUse()) { 15690 SDValue N20 = N2.getOperand(0); 15691 if (N20.getOpcode() == ISD::LOAD && 15692 N20.hasOneUse() && 15693 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 15694 SDValue Chain20 = N20.getOperand(0); 15695 if (Predicate_unindexedload(N20.getNode()) && 15696 Predicate_load(N20.getNode())) { 15697 SDValue N201 = N20.getOperand(1); 15698 SDValue CPTmpN201_0; 15699 SDValue CPTmpN201_1; 15700 SDValue CPTmpN201_2; 15701 SDValue CPTmpN201_3; 15702 SDValue CPTmpN201_4; 15703 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 15704 N20.getNode()->getValueType(0) == MVT::v1i64) { 15705 SDNode *Result = Emit_115(N, X86::MMX_PADDUSWrm, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 15706 return Result; 15707 } 15708 } 15709 } 15710 } 15711 } 15712 15713 // Pattern: (intrinsic_wo_chain:v4i16 498:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 15714 // Emits: (MMX_PSUBSWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 15715 // Pattern complexity = 33 cost = 1 size = 3 15716 if (CN1 == INT64_C(498)) { 15717 SDValue N1 = N.getOperand(1); 15718 SDValue N2 = N.getOperand(2); 15719 if (N2.getOpcode() == ISD::BIT_CONVERT && 15720 N2.hasOneUse()) { 15721 SDValue N20 = N2.getOperand(0); 15722 if (N20.getOpcode() == ISD::LOAD && 15723 N20.hasOneUse() && 15724 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 15725 SDValue Chain20 = N20.getOperand(0); 15726 if (Predicate_unindexedload(N20.getNode()) && 15727 Predicate_load(N20.getNode())) { 15728 SDValue N201 = N20.getOperand(1); 15729 SDValue CPTmpN201_0; 15730 SDValue CPTmpN201_1; 15731 SDValue CPTmpN201_2; 15732 SDValue CPTmpN201_3; 15733 SDValue CPTmpN201_4; 15734 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 15735 N20.getNode()->getValueType(0) == MVT::v1i64) { 15736 SDNode *Result = Emit_115(N, X86::MMX_PSUBSWrm, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 15737 return Result; 15738 } 15739 } 15740 } 15741 } 15742 } 15743 15744 // Pattern: (intrinsic_wo_chain:v4i16 500:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 15745 // Emits: (MMX_PSUBUSWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 15746 // Pattern complexity = 33 cost = 1 size = 3 15747 if (CN1 == INT64_C(500)) { 15748 SDValue N1 = N.getOperand(1); 15749 SDValue N2 = N.getOperand(2); 15750 if (N2.getOpcode() == ISD::BIT_CONVERT && 15751 N2.hasOneUse()) { 15752 SDValue N20 = N2.getOperand(0); 15753 if (N20.getOpcode() == ISD::LOAD && 15754 N20.hasOneUse() && 15755 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 15756 SDValue Chain20 = N20.getOperand(0); 15757 if (Predicate_unindexedload(N20.getNode()) && 15758 Predicate_load(N20.getNode())) { 15759 SDValue N201 = N20.getOperand(1); 15760 SDValue CPTmpN201_0; 15761 SDValue CPTmpN201_1; 15762 SDValue CPTmpN201_2; 15763 SDValue CPTmpN201_3; 15764 SDValue CPTmpN201_4; 15765 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 15766 N20.getNode()->getValueType(0) == MVT::v1i64) { 15767 SDNode *Result = Emit_115(N, X86::MMX_PSUBUSWrm, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 15768 return Result; 15769 } 15770 } 15771 } 15772 } 15773 } 15774 15775 // Pattern: (intrinsic_wo_chain:v4i16 477:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 15776 // Emits: (MMX_PMULHWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 15777 // Pattern complexity = 33 cost = 1 size = 3 15778 if (CN1 == INT64_C(477)) { 15779 SDValue N1 = N.getOperand(1); 15780 SDValue N2 = N.getOperand(2); 15781 if (N2.getOpcode() == ISD::BIT_CONVERT && 15782 N2.hasOneUse()) { 15783 SDValue N20 = N2.getOperand(0); 15784 if (N20.getOpcode() == ISD::LOAD && 15785 N20.hasOneUse() && 15786 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 15787 SDValue Chain20 = N20.getOperand(0); 15788 if (Predicate_unindexedload(N20.getNode()) && 15789 Predicate_load(N20.getNode())) { 15790 SDValue N201 = N20.getOperand(1); 15791 SDValue CPTmpN201_0; 15792 SDValue CPTmpN201_1; 15793 SDValue CPTmpN201_2; 15794 SDValue CPTmpN201_3; 15795 SDValue CPTmpN201_4; 15796 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 15797 N20.getNode()->getValueType(0) == MVT::v1i64) { 15798 SDNode *Result = Emit_115(N, X86::MMX_PMULHWrm, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 15799 return Result; 15800 } 15801 } 15802 } 15803 } 15804 } 15805 15806 // Pattern: (intrinsic_wo_chain:v4i16 478:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 15807 // Emits: (MMX_PMULHUWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 15808 // Pattern complexity = 33 cost = 1 size = 3 15809 if (CN1 == INT64_C(478)) { 15810 SDValue N1 = N.getOperand(1); 15811 SDValue N2 = N.getOperand(2); 15812 if (N2.getOpcode() == ISD::BIT_CONVERT && 15813 N2.hasOneUse()) { 15814 SDValue N20 = N2.getOperand(0); 15815 if (N20.getOpcode() == ISD::LOAD && 15816 N20.hasOneUse() && 15817 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 15818 SDValue Chain20 = N20.getOperand(0); 15819 if (Predicate_unindexedload(N20.getNode()) && 15820 Predicate_load(N20.getNode())) { 15821 SDValue N201 = N20.getOperand(1); 15822 SDValue CPTmpN201_0; 15823 SDValue CPTmpN201_1; 15824 SDValue CPTmpN201_2; 15825 SDValue CPTmpN201_3; 15826 SDValue CPTmpN201_4; 15827 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 15828 N20.getNode()->getValueType(0) == MVT::v1i64) { 15829 SDNode *Result = Emit_115(N, X86::MMX_PMULHUWrm, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 15830 return Result; 15831 } 15832 } 15833 } 15834 } 15835 } 15836 15837 // Pattern: (intrinsic_wo_chain:v4i16 464:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 15838 // Emits: (MMX_PAVGWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 15839 // Pattern complexity = 33 cost = 1 size = 3 15840 if (CN1 == INT64_C(464)) { 15841 SDValue N1 = N.getOperand(1); 15842 SDValue N2 = N.getOperand(2); 15843 if (N2.getOpcode() == ISD::BIT_CONVERT && 15844 N2.hasOneUse()) { 15845 SDValue N20 = N2.getOperand(0); 15846 if (N20.getOpcode() == ISD::LOAD && 15847 N20.hasOneUse() && 15848 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 15849 SDValue Chain20 = N20.getOperand(0); 15850 if (Predicate_unindexedload(N20.getNode()) && 15851 Predicate_load(N20.getNode())) { 15852 SDValue N201 = N20.getOperand(1); 15853 SDValue CPTmpN201_0; 15854 SDValue CPTmpN201_1; 15855 SDValue CPTmpN201_2; 15856 SDValue CPTmpN201_3; 15857 SDValue CPTmpN201_4; 15858 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 15859 N20.getNode()->getValueType(0) == MVT::v1i64) { 15860 SDNode *Result = Emit_115(N, X86::MMX_PAVGWrm, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 15861 return Result; 15862 } 15863 } 15864 } 15865 } 15866 } 15867 15868 // Pattern: (intrinsic_wo_chain:v4i16 474:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 15869 // Emits: (MMX_PMINSWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 15870 // Pattern complexity = 33 cost = 1 size = 3 15871 if (CN1 == INT64_C(474)) { 15872 SDValue N1 = N.getOperand(1); 15873 SDValue N2 = N.getOperand(2); 15874 if (N2.getOpcode() == ISD::BIT_CONVERT && 15875 N2.hasOneUse()) { 15876 SDValue N20 = N2.getOperand(0); 15877 if (N20.getOpcode() == ISD::LOAD && 15878 N20.hasOneUse() && 15879 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 15880 SDValue Chain20 = N20.getOperand(0); 15881 if (Predicate_unindexedload(N20.getNode()) && 15882 Predicate_load(N20.getNode())) { 15883 SDValue N201 = N20.getOperand(1); 15884 SDValue CPTmpN201_0; 15885 SDValue CPTmpN201_1; 15886 SDValue CPTmpN201_2; 15887 SDValue CPTmpN201_3; 15888 SDValue CPTmpN201_4; 15889 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 15890 N20.getNode()->getValueType(0) == MVT::v1i64) { 15891 SDNode *Result = Emit_115(N, X86::MMX_PMINSWrm, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 15892 return Result; 15893 } 15894 } 15895 } 15896 } 15897 } 15898 15899 // Pattern: (intrinsic_wo_chain:v4i16 472:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 15900 // Emits: (MMX_PMAXSWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 15901 // Pattern complexity = 33 cost = 1 size = 3 15902 if (CN1 == INT64_C(472)) { 15903 SDValue N1 = N.getOperand(1); 15904 SDValue N2 = N.getOperand(2); 15905 if (N2.getOpcode() == ISD::BIT_CONVERT && 15906 N2.hasOneUse()) { 15907 SDValue N20 = N2.getOperand(0); 15908 if (N20.getOpcode() == ISD::LOAD && 15909 N20.hasOneUse() && 15910 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 15911 SDValue Chain20 = N20.getOperand(0); 15912 if (Predicate_unindexedload(N20.getNode()) && 15913 Predicate_load(N20.getNode())) { 15914 SDValue N201 = N20.getOperand(1); 15915 SDValue CPTmpN201_0; 15916 SDValue CPTmpN201_1; 15917 SDValue CPTmpN201_2; 15918 SDValue CPTmpN201_3; 15919 SDValue CPTmpN201_4; 15920 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 15921 N20.getNode()->getValueType(0) == MVT::v1i64) { 15922 SDNode *Result = Emit_115(N, X86::MMX_PMAXSWrm, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 15923 return Result; 15924 } 15925 } 15926 } 15927 } 15928 } 15929 15930 // Pattern: (intrinsic_wo_chain:v4i16 480:iPTR, VR64:v8i8:$src1, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 15931 // Emits: (MMX_PSADBWrm:v4i16 VR64:v8i8:$src1, addr:iPTR:$src2) 15932 // Pattern complexity = 33 cost = 1 size = 3 15933 if (CN1 == INT64_C(480)) { 15934 SDValue N1 = N.getOperand(1); 15935 SDValue N2 = N.getOperand(2); 15936 if (N2.getOpcode() == ISD::BIT_CONVERT && 15937 N2.hasOneUse()) { 15938 SDValue N20 = N2.getOperand(0); 15939 if (N20.getOpcode() == ISD::LOAD && 15940 N20.hasOneUse() && 15941 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 15942 SDValue Chain20 = N20.getOperand(0); 15943 if (Predicate_unindexedload(N20.getNode()) && 15944 Predicate_load(N20.getNode())) { 15945 SDValue N201 = N20.getOperand(1); 15946 SDValue CPTmpN201_0; 15947 SDValue CPTmpN201_1; 15948 SDValue CPTmpN201_2; 15949 SDValue CPTmpN201_3; 15950 SDValue CPTmpN201_4; 15951 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 15952 N20.getNode()->getValueType(0) == MVT::v1i64) { 15953 SDNode *Result = Emit_115(N, X86::MMX_PSADBWrm, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 15954 return Result; 15955 } 15956 } 15957 } 15958 } 15959 } 15960 15961 // Pattern: (intrinsic_wo_chain:v4i16 493:iPTR, VR64:v4i16:$src1, (bitconvert:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 15962 // Emits: (MMX_PSRLWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 15963 // Pattern complexity = 33 cost = 1 size = 3 15964 if (CN1 == INT64_C(493)) { 15965 SDValue N1 = N.getOperand(1); 15966 SDValue N2 = N.getOperand(2); 15967 if (N2.getOpcode() == ISD::BIT_CONVERT && 15968 N2.hasOneUse()) { 15969 SDValue N20 = N2.getOperand(0); 15970 if (N20.getOpcode() == ISD::LOAD && 15971 N20.hasOneUse() && 15972 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 15973 SDValue Chain20 = N20.getOperand(0); 15974 if (Predicate_unindexedload(N20.getNode()) && 15975 Predicate_load(N20.getNode())) { 15976 SDValue N201 = N20.getOperand(1); 15977 SDValue CPTmpN201_0; 15978 SDValue CPTmpN201_1; 15979 SDValue CPTmpN201_2; 15980 SDValue CPTmpN201_3; 15981 SDValue CPTmpN201_4; 15982 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 15983 N20.getNode()->getValueType(0) == MVT::v1i64) { 15984 SDNode *Result = Emit_115(N, X86::MMX_PSRLWrm, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 15985 return Result; 15986 } 15987 } 15988 } 15989 } 15990 } 15991 15992 // Pattern: (intrinsic_wo_chain:v4i16 483:iPTR, VR64:v4i16:$src1, (bitconvert:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 15993 // Emits: (MMX_PSLLWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 15994 // Pattern complexity = 33 cost = 1 size = 3 15995 if (CN1 == INT64_C(483)) { 15996 SDValue N1 = N.getOperand(1); 15997 SDValue N2 = N.getOperand(2); 15998 if (N2.getOpcode() == ISD::BIT_CONVERT && 15999 N2.hasOneUse()) { 16000 SDValue N20 = N2.getOperand(0); 16001 if (N20.getOpcode() == ISD::LOAD && 16002 N20.hasOneUse() && 16003 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 16004 SDValue Chain20 = N20.getOperand(0); 16005 if (Predicate_unindexedload(N20.getNode()) && 16006 Predicate_load(N20.getNode())) { 16007 SDValue N201 = N20.getOperand(1); 16008 SDValue CPTmpN201_0; 16009 SDValue CPTmpN201_1; 16010 SDValue CPTmpN201_2; 16011 SDValue CPTmpN201_3; 16012 SDValue CPTmpN201_4; 16013 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 16014 N20.getNode()->getValueType(0) == MVT::v1i64) { 16015 SDNode *Result = Emit_115(N, X86::MMX_PSLLWrm, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 16016 return Result; 16017 } 16018 } 16019 } 16020 } 16021 } 16022 16023 // Pattern: (intrinsic_wo_chain:v4i16 488:iPTR, VR64:v4i16:$src1, (bitconvert:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 16024 // Emits: (MMX_PSRAWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 16025 // Pattern complexity = 33 cost = 1 size = 3 16026 if (CN1 == INT64_C(488)) { 16027 SDValue N1 = N.getOperand(1); 16028 SDValue N2 = N.getOperand(2); 16029 if (N2.getOpcode() == ISD::BIT_CONVERT && 16030 N2.hasOneUse()) { 16031 SDValue N20 = N2.getOperand(0); 16032 if (N20.getOpcode() == ISD::LOAD && 16033 N20.hasOneUse() && 16034 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 16035 SDValue Chain20 = N20.getOperand(0); 16036 if (Predicate_unindexedload(N20.getNode()) && 16037 Predicate_load(N20.getNode())) { 16038 SDValue N201 = N20.getOperand(1); 16039 SDValue CPTmpN201_0; 16040 SDValue CPTmpN201_1; 16041 SDValue CPTmpN201_2; 16042 SDValue CPTmpN201_3; 16043 SDValue CPTmpN201_4; 16044 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 16045 N20.getNode()->getValueType(0) == MVT::v1i64) { 16046 SDNode *Result = Emit_115(N, X86::MMX_PSRAWrm, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 16047 return Result; 16048 } 16049 } 16050 } 16051 } 16052 } 16053 16054 // Pattern: (intrinsic_wo_chain:v4i16 467:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 16055 // Emits: (MMX_PCMPEQWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 16056 // Pattern complexity = 33 cost = 1 size = 3 16057 if (CN1 == INT64_C(467)) { 16058 SDValue N1 = N.getOperand(1); 16059 SDValue N2 = N.getOperand(2); 16060 if (N2.getOpcode() == ISD::BIT_CONVERT && 16061 N2.hasOneUse()) { 16062 SDValue N20 = N2.getOperand(0); 16063 if (N20.getOpcode() == ISD::LOAD && 16064 N20.hasOneUse() && 16065 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 16066 SDValue Chain20 = N20.getOperand(0); 16067 if (Predicate_unindexedload(N20.getNode()) && 16068 Predicate_load(N20.getNode())) { 16069 SDValue N201 = N20.getOperand(1); 16070 SDValue CPTmpN201_0; 16071 SDValue CPTmpN201_1; 16072 SDValue CPTmpN201_2; 16073 SDValue CPTmpN201_3; 16074 SDValue CPTmpN201_4; 16075 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 16076 N20.getNode()->getValueType(0) == MVT::v1i64) { 16077 SDNode *Result = Emit_115(N, X86::MMX_PCMPEQWrm, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 16078 return Result; 16079 } 16080 } 16081 } 16082 } 16083 } 16084 16085 // Pattern: (intrinsic_wo_chain:v4i16 470:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 16086 // Emits: (MMX_PCMPGTWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 16087 // Pattern complexity = 33 cost = 1 size = 3 16088 if (CN1 == INT64_C(470)) { 16089 SDValue N1 = N.getOperand(1); 16090 SDValue N2 = N.getOperand(2); 16091 if (N2.getOpcode() == ISD::BIT_CONVERT && 16092 N2.hasOneUse()) { 16093 SDValue N20 = N2.getOperand(0); 16094 if (N20.getOpcode() == ISD::LOAD && 16095 N20.hasOneUse() && 16096 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 16097 SDValue Chain20 = N20.getOperand(0); 16098 if (Predicate_unindexedload(N20.getNode()) && 16099 Predicate_load(N20.getNode())) { 16100 SDValue N201 = N20.getOperand(1); 16101 SDValue CPTmpN201_0; 16102 SDValue CPTmpN201_1; 16103 SDValue CPTmpN201_2; 16104 SDValue CPTmpN201_3; 16105 SDValue CPTmpN201_4; 16106 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 16107 N20.getNode()->getValueType(0) == MVT::v1i64) { 16108 SDNode *Result = Emit_115(N, X86::MMX_PCMPGTWrm, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 16109 return Result; 16110 } 16111 } 16112 } 16113 } 16114 } 16115 16116 // Pattern: (intrinsic_wo_chain:v4i16 456:iPTR, VR64:v2i32:$src1, (bitconvert:v2i32 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 16117 // Emits: (MMX_PACKSSDWrm:v4i16 VR64:v2i32:$src1, addr:iPTR:$src2) 16118 // Pattern complexity = 33 cost = 1 size = 3 16119 if (CN1 == INT64_C(456)) { 16120 SDValue N1 = N.getOperand(1); 16121 SDValue N2 = N.getOperand(2); 16122 if (N2.getOpcode() == ISD::BIT_CONVERT && 16123 N2.hasOneUse()) { 16124 SDValue N20 = N2.getOperand(0); 16125 if (N20.getOpcode() == ISD::LOAD && 16126 N20.hasOneUse() && 16127 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 16128 SDValue Chain20 = N20.getOperand(0); 16129 if (Predicate_unindexedload(N20.getNode()) && 16130 Predicate_load(N20.getNode())) { 16131 SDValue N201 = N20.getOperand(1); 16132 SDValue CPTmpN201_0; 16133 SDValue CPTmpN201_1; 16134 SDValue CPTmpN201_2; 16135 SDValue CPTmpN201_3; 16136 SDValue CPTmpN201_4; 16137 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 16138 N20.getNode()->getValueType(0) == MVT::v1i64) { 16139 SDNode *Result = Emit_115(N, X86::MMX_PACKSSDWrm, MVT::v4i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 16140 return Result; 16141 } 16142 } 16143 } 16144 } 16145 } 16146 } 16147 } 16148 16149 // Pattern: (intrinsic_wo_chain:v4i16 747:iPTR, (bitconvert:v4i16 (ld:v4i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>), VR64:v4i16:$src1) 16150 // Emits: (PMULHRSWrm64:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 16151 // Pattern complexity = 33 cost = 1 size = 3 16152 if ((Subtarget->hasSSSE3())) { 16153 SDValue N0 = N.getOperand(0); 16154 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 16155 if (Tmp0) { 16156 int64_t CN1 = Tmp0->getSExtValue(); 16157 if (CN1 == INT64_C(747)) { 16158 SDValue N1 = N.getOperand(1); 16159 if (N1.getOpcode() == ISD::BIT_CONVERT && 16160 N1.hasOneUse()) { 16161 SDValue N10 = N1.getOperand(0); 16162 if (N10.getOpcode() == ISD::LOAD && 16163 N10.hasOneUse() && 16164 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 16165 SDValue Chain10 = N10.getOperand(0); 16166 if (Predicate_unindexedload(N10.getNode()) && 16167 Predicate_load(N10.getNode()) && 16168 Predicate_memop64(N10.getNode())) { 16169 SDValue N101 = N10.getOperand(1); 16170 SDValue CPTmpN101_0; 16171 SDValue CPTmpN101_1; 16172 SDValue CPTmpN101_2; 16173 SDValue CPTmpN101_3; 16174 SDValue CPTmpN101_4; 16175 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 16176 SDValue N2 = N.getOperand(2); 16177 if (N10.getNode()->getValueType(0) == MVT::v4i16) { 16178 SDNode *Result = Emit_116(N, X86::PMULHRSWrm64, MVT::v4i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 16179 return Result; 16180 } 16181 } 16182 } 16183 } 16184 } 16185 } 16186 } 16187 } 16188 if ((Subtarget->hasMMX())) { 16189 SDValue N0 = N.getOperand(0); 16190 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 16191 if (Tmp0) { 16192 int64_t CN1 = Tmp0->getSExtValue(); 16193 16194 // Pattern: (intrinsic_wo_chain:v4i16 460:iPTR, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v4i16:$src1) 16195 // Emits: (MMX_PADDSWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 16196 // Pattern complexity = 33 cost = 1 size = 3 16197 if (CN1 == INT64_C(460)) { 16198 SDValue N1 = N.getOperand(1); 16199 if (N1.getOpcode() == ISD::BIT_CONVERT && 16200 N1.hasOneUse()) { 16201 SDValue N10 = N1.getOperand(0); 16202 if (N10.getOpcode() == ISD::LOAD && 16203 N10.hasOneUse() && 16204 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 16205 SDValue Chain10 = N10.getOperand(0); 16206 if (Predicate_unindexedload(N10.getNode()) && 16207 Predicate_load(N10.getNode())) { 16208 SDValue N101 = N10.getOperand(1); 16209 SDValue CPTmpN101_0; 16210 SDValue CPTmpN101_1; 16211 SDValue CPTmpN101_2; 16212 SDValue CPTmpN101_3; 16213 SDValue CPTmpN101_4; 16214 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 16215 SDValue N2 = N.getOperand(2); 16216 if (N10.getNode()->getValueType(0) == MVT::v1i64) { 16217 SDNode *Result = Emit_116(N, X86::MMX_PADDSWrm, MVT::v4i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 16218 return Result; 16219 } 16220 } 16221 } 16222 } 16223 } 16224 } 16225 16226 // Pattern: (intrinsic_wo_chain:v4i16 462:iPTR, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v4i16:$src1) 16227 // Emits: (MMX_PADDUSWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 16228 // Pattern complexity = 33 cost = 1 size = 3 16229 if (CN1 == INT64_C(462)) { 16230 SDValue N1 = N.getOperand(1); 16231 if (N1.getOpcode() == ISD::BIT_CONVERT && 16232 N1.hasOneUse()) { 16233 SDValue N10 = N1.getOperand(0); 16234 if (N10.getOpcode() == ISD::LOAD && 16235 N10.hasOneUse() && 16236 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 16237 SDValue Chain10 = N10.getOperand(0); 16238 if (Predicate_unindexedload(N10.getNode()) && 16239 Predicate_load(N10.getNode())) { 16240 SDValue N101 = N10.getOperand(1); 16241 SDValue CPTmpN101_0; 16242 SDValue CPTmpN101_1; 16243 SDValue CPTmpN101_2; 16244 SDValue CPTmpN101_3; 16245 SDValue CPTmpN101_4; 16246 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 16247 SDValue N2 = N.getOperand(2); 16248 if (N10.getNode()->getValueType(0) == MVT::v1i64) { 16249 SDNode *Result = Emit_116(N, X86::MMX_PADDUSWrm, MVT::v4i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 16250 return Result; 16251 } 16252 } 16253 } 16254 } 16255 } 16256 } 16257 16258 // Pattern: (intrinsic_wo_chain:v4i16 477:iPTR, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v4i16:$src1) 16259 // Emits: (MMX_PMULHWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 16260 // Pattern complexity = 33 cost = 1 size = 3 16261 if (CN1 == INT64_C(477)) { 16262 SDValue N1 = N.getOperand(1); 16263 if (N1.getOpcode() == ISD::BIT_CONVERT && 16264 N1.hasOneUse()) { 16265 SDValue N10 = N1.getOperand(0); 16266 if (N10.getOpcode() == ISD::LOAD && 16267 N10.hasOneUse() && 16268 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 16269 SDValue Chain10 = N10.getOperand(0); 16270 if (Predicate_unindexedload(N10.getNode()) && 16271 Predicate_load(N10.getNode())) { 16272 SDValue N101 = N10.getOperand(1); 16273 SDValue CPTmpN101_0; 16274 SDValue CPTmpN101_1; 16275 SDValue CPTmpN101_2; 16276 SDValue CPTmpN101_3; 16277 SDValue CPTmpN101_4; 16278 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 16279 SDValue N2 = N.getOperand(2); 16280 if (N10.getNode()->getValueType(0) == MVT::v1i64) { 16281 SDNode *Result = Emit_116(N, X86::MMX_PMULHWrm, MVT::v4i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 16282 return Result; 16283 } 16284 } 16285 } 16286 } 16287 } 16288 } 16289 16290 // Pattern: (intrinsic_wo_chain:v4i16 478:iPTR, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v4i16:$src1) 16291 // Emits: (MMX_PMULHUWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 16292 // Pattern complexity = 33 cost = 1 size = 3 16293 if (CN1 == INT64_C(478)) { 16294 SDValue N1 = N.getOperand(1); 16295 if (N1.getOpcode() == ISD::BIT_CONVERT && 16296 N1.hasOneUse()) { 16297 SDValue N10 = N1.getOperand(0); 16298 if (N10.getOpcode() == ISD::LOAD && 16299 N10.hasOneUse() && 16300 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 16301 SDValue Chain10 = N10.getOperand(0); 16302 if (Predicate_unindexedload(N10.getNode()) && 16303 Predicate_load(N10.getNode())) { 16304 SDValue N101 = N10.getOperand(1); 16305 SDValue CPTmpN101_0; 16306 SDValue CPTmpN101_1; 16307 SDValue CPTmpN101_2; 16308 SDValue CPTmpN101_3; 16309 SDValue CPTmpN101_4; 16310 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 16311 SDValue N2 = N.getOperand(2); 16312 if (N10.getNode()->getValueType(0) == MVT::v1i64) { 16313 SDNode *Result = Emit_116(N, X86::MMX_PMULHUWrm, MVT::v4i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 16314 return Result; 16315 } 16316 } 16317 } 16318 } 16319 } 16320 } 16321 16322 // Pattern: (intrinsic_wo_chain:v4i16 464:iPTR, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v4i16:$src1) 16323 // Emits: (MMX_PAVGWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 16324 // Pattern complexity = 33 cost = 1 size = 3 16325 if (CN1 == INT64_C(464)) { 16326 SDValue N1 = N.getOperand(1); 16327 if (N1.getOpcode() == ISD::BIT_CONVERT && 16328 N1.hasOneUse()) { 16329 SDValue N10 = N1.getOperand(0); 16330 if (N10.getOpcode() == ISD::LOAD && 16331 N10.hasOneUse() && 16332 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 16333 SDValue Chain10 = N10.getOperand(0); 16334 if (Predicate_unindexedload(N10.getNode()) && 16335 Predicate_load(N10.getNode())) { 16336 SDValue N101 = N10.getOperand(1); 16337 SDValue CPTmpN101_0; 16338 SDValue CPTmpN101_1; 16339 SDValue CPTmpN101_2; 16340 SDValue CPTmpN101_3; 16341 SDValue CPTmpN101_4; 16342 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 16343 SDValue N2 = N.getOperand(2); 16344 if (N10.getNode()->getValueType(0) == MVT::v1i64) { 16345 SDNode *Result = Emit_116(N, X86::MMX_PAVGWrm, MVT::v4i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 16346 return Result; 16347 } 16348 } 16349 } 16350 } 16351 } 16352 } 16353 16354 // Pattern: (intrinsic_wo_chain:v4i16 474:iPTR, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v4i16:$src1) 16355 // Emits: (MMX_PMINSWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 16356 // Pattern complexity = 33 cost = 1 size = 3 16357 if (CN1 == INT64_C(474)) { 16358 SDValue N1 = N.getOperand(1); 16359 if (N1.getOpcode() == ISD::BIT_CONVERT && 16360 N1.hasOneUse()) { 16361 SDValue N10 = N1.getOperand(0); 16362 if (N10.getOpcode() == ISD::LOAD && 16363 N10.hasOneUse() && 16364 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 16365 SDValue Chain10 = N10.getOperand(0); 16366 if (Predicate_unindexedload(N10.getNode()) && 16367 Predicate_load(N10.getNode())) { 16368 SDValue N101 = N10.getOperand(1); 16369 SDValue CPTmpN101_0; 16370 SDValue CPTmpN101_1; 16371 SDValue CPTmpN101_2; 16372 SDValue CPTmpN101_3; 16373 SDValue CPTmpN101_4; 16374 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 16375 SDValue N2 = N.getOperand(2); 16376 if (N10.getNode()->getValueType(0) == MVT::v1i64) { 16377 SDNode *Result = Emit_116(N, X86::MMX_PMINSWrm, MVT::v4i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 16378 return Result; 16379 } 16380 } 16381 } 16382 } 16383 } 16384 } 16385 16386 // Pattern: (intrinsic_wo_chain:v4i16 472:iPTR, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v4i16:$src1) 16387 // Emits: (MMX_PMAXSWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 16388 // Pattern complexity = 33 cost = 1 size = 3 16389 if (CN1 == INT64_C(472)) { 16390 SDValue N1 = N.getOperand(1); 16391 if (N1.getOpcode() == ISD::BIT_CONVERT && 16392 N1.hasOneUse()) { 16393 SDValue N10 = N1.getOperand(0); 16394 if (N10.getOpcode() == ISD::LOAD && 16395 N10.hasOneUse() && 16396 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 16397 SDValue Chain10 = N10.getOperand(0); 16398 if (Predicate_unindexedload(N10.getNode()) && 16399 Predicate_load(N10.getNode())) { 16400 SDValue N101 = N10.getOperand(1); 16401 SDValue CPTmpN101_0; 16402 SDValue CPTmpN101_1; 16403 SDValue CPTmpN101_2; 16404 SDValue CPTmpN101_3; 16405 SDValue CPTmpN101_4; 16406 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 16407 SDValue N2 = N.getOperand(2); 16408 if (N10.getNode()->getValueType(0) == MVT::v1i64) { 16409 SDNode *Result = Emit_116(N, X86::MMX_PMAXSWrm, MVT::v4i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 16410 return Result; 16411 } 16412 } 16413 } 16414 } 16415 } 16416 } 16417 16418 // Pattern: (intrinsic_wo_chain:v4i16 480:iPTR, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v8i8:$src1) 16419 // Emits: (MMX_PSADBWrm:v4i16 VR64:v8i8:$src1, addr:iPTR:$src2) 16420 // Pattern complexity = 33 cost = 1 size = 3 16421 if (CN1 == INT64_C(480)) { 16422 SDValue N1 = N.getOperand(1); 16423 if (N1.getOpcode() == ISD::BIT_CONVERT && 16424 N1.hasOneUse()) { 16425 SDValue N10 = N1.getOperand(0); 16426 if (N10.getOpcode() == ISD::LOAD && 16427 N10.hasOneUse() && 16428 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 16429 SDValue Chain10 = N10.getOperand(0); 16430 if (Predicate_unindexedload(N10.getNode()) && 16431 Predicate_load(N10.getNode())) { 16432 SDValue N101 = N10.getOperand(1); 16433 SDValue CPTmpN101_0; 16434 SDValue CPTmpN101_1; 16435 SDValue CPTmpN101_2; 16436 SDValue CPTmpN101_3; 16437 SDValue CPTmpN101_4; 16438 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 16439 SDValue N2 = N.getOperand(2); 16440 if (N10.getNode()->getValueType(0) == MVT::v1i64) { 16441 SDNode *Result = Emit_116(N, X86::MMX_PSADBWrm, MVT::v4i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 16442 return Result; 16443 } 16444 } 16445 } 16446 } 16447 } 16448 } 16449 } 16450 } 16451 } 16452 if ((Subtarget->hasMMX())) { 16453 SDValue N0 = N.getOperand(0); 16454 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 16455 if (Tmp0) { 16456 int64_t CN1 = Tmp0->getSExtValue(); 16457 16458 // Pattern: (intrinsic_wo_chain:v4i16 496:iPTR, VR64:v4i16:$src1, (imm:i32):$src2) 16459 // Emits: (MMX_PSRLWri:v4i16 VR64:v4i16:$src1, (imm:i32):$src2) 16460 // Pattern complexity = 11 cost = 1 size = 3 16461 if (CN1 == INT64_C(496)) { 16462 SDValue N1 = N.getOperand(1); 16463 SDValue N2 = N.getOperand(2); 16464 if (N2.getOpcode() == ISD::Constant) { 16465 SDNode *Result = Emit_126(N, X86::MMX_PSRLWri, MVT::v4i16); 16466 return Result; 16467 } 16468 } 16469 16470 // Pattern: (intrinsic_wo_chain:v4i16 486:iPTR, VR64:v4i16:$src1, (imm:i32):$src2) 16471 // Emits: (MMX_PSLLWri:v4i16 VR64:v4i16:$src1, (imm:i32):$src2) 16472 // Pattern complexity = 11 cost = 1 size = 3 16473 if (CN1 == INT64_C(486)) { 16474 SDValue N1 = N.getOperand(1); 16475 SDValue N2 = N.getOperand(2); 16476 if (N2.getOpcode() == ISD::Constant) { 16477 SDNode *Result = Emit_126(N, X86::MMX_PSLLWri, MVT::v4i16); 16478 return Result; 16479 } 16480 } 16481 16482 // Pattern: (intrinsic_wo_chain:v4i16 490:iPTR, VR64:v4i16:$src1, (imm:i32):$src2) 16483 // Emits: (MMX_PSRAWri:v4i16 VR64:v4i16:$src1, (imm:i32):$src2) 16484 // Pattern complexity = 11 cost = 1 size = 3 16485 if (CN1 == INT64_C(490)) { 16486 SDValue N1 = N.getOperand(1); 16487 SDValue N2 = N.getOperand(2); 16488 if (N2.getOpcode() == ISD::Constant) { 16489 SDNode *Result = Emit_126(N, X86::MMX_PSRAWri, MVT::v4i16); 16490 return Result; 16491 } 16492 } 16493 } 16494 } 16495 if ((Subtarget->hasSSSE3())) { 16496 SDValue N0 = N.getOperand(0); 16497 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 16498 if (Tmp0) { 16499 int64_t CN1 = Tmp0->getSExtValue(); 16500 16501 // Pattern: (intrinsic_wo_chain:v4i16 729:iPTR, VR64:v4i16:$src) 16502 // Emits: (PABSWrr64:v4i16 VR64:v4i16:$src) 16503 // Pattern complexity = 8 cost = 1 size = 3 16504 if (CN1 == INT64_C(729)) { 16505 SDNode *Result = Emit_106(N, X86::PABSWrr64, MVT::v4i16); 16506 return Result; 16507 } 16508 16509 // Pattern: (intrinsic_wo_chain:v4i16 737:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 16510 // Emits: (PHADDWrr64:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 16511 // Pattern complexity = 8 cost = 1 size = 3 16512 if (CN1 == INT64_C(737)) { 16513 SDNode *Result = Emit_109(N, X86::PHADDWrr64, MVT::v4i16); 16514 return Result; 16515 } 16516 16517 // Pattern: (intrinsic_wo_chain:v4i16 735:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 16518 // Emits: (PHADDSWrr64:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 16519 // Pattern complexity = 8 cost = 1 size = 3 16520 if (CN1 == INT64_C(735)) { 16521 SDNode *Result = Emit_109(N, X86::PHADDSWrr64, MVT::v4i16); 16522 return Result; 16523 } 16524 16525 // Pattern: (intrinsic_wo_chain:v4i16 743:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 16526 // Emits: (PHSUBWrr64:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 16527 // Pattern complexity = 8 cost = 1 size = 3 16528 if (CN1 == INT64_C(743)) { 16529 SDNode *Result = Emit_109(N, X86::PHSUBWrr64, MVT::v4i16); 16530 return Result; 16531 } 16532 16533 // Pattern: (intrinsic_wo_chain:v4i16 741:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 16534 // Emits: (PHSUBSWrr64:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 16535 // Pattern complexity = 8 cost = 1 size = 3 16536 if (CN1 == INT64_C(741)) { 16537 SDNode *Result = Emit_109(N, X86::PHSUBSWrr64, MVT::v4i16); 16538 return Result; 16539 } 16540 16541 // Pattern: (intrinsic_wo_chain:v4i16 745:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 16542 // Emits: (PMADDUBSWrr64:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 16543 // Pattern complexity = 8 cost = 1 size = 3 16544 if (CN1 == INT64_C(745)) { 16545 SDNode *Result = Emit_109(N, X86::PMADDUBSWrr64, MVT::v4i16); 16546 return Result; 16547 } 16548 16549 // Pattern: (intrinsic_wo_chain:v4i16 747:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 16550 // Emits: (PMULHRSWrr64:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 16551 // Pattern complexity = 8 cost = 1 size = 3 16552 if (CN1 == INT64_C(747)) { 16553 SDNode *Result = Emit_109(N, X86::PMULHRSWrr64, MVT::v4i16); 16554 return Result; 16555 } 16556 16557 // Pattern: (intrinsic_wo_chain:v4i16 755:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 16558 // Emits: (PSIGNWrr64:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 16559 // Pattern complexity = 8 cost = 1 size = 3 16560 if (CN1 == INT64_C(755)) { 16561 SDNode *Result = Emit_109(N, X86::PSIGNWrr64, MVT::v4i16); 16562 return Result; 16563 } 16564 } 16565 } 16566 if ((Subtarget->hasMMX())) { 16567 SDValue N0 = N.getOperand(0); 16568 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 16569 if (Tmp0) { 16570 int64_t CN1 = Tmp0->getSExtValue(); 16571 16572 // Pattern: (intrinsic_wo_chain:v4i16 460:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 16573 // Emits: (MMX_PADDSWrr:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 16574 // Pattern complexity = 8 cost = 1 size = 3 16575 if (CN1 == INT64_C(460)) { 16576 SDNode *Result = Emit_109(N, X86::MMX_PADDSWrr, MVT::v4i16); 16577 return Result; 16578 } 16579 16580 // Pattern: (intrinsic_wo_chain:v4i16 462:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 16581 // Emits: (MMX_PADDUSWrr:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 16582 // Pattern complexity = 8 cost = 1 size = 3 16583 if (CN1 == INT64_C(462)) { 16584 SDNode *Result = Emit_109(N, X86::MMX_PADDUSWrr, MVT::v4i16); 16585 return Result; 16586 } 16587 16588 // Pattern: (intrinsic_wo_chain:v4i16 498:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 16589 // Emits: (MMX_PSUBSWrr:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 16590 // Pattern complexity = 8 cost = 1 size = 3 16591 if (CN1 == INT64_C(498)) { 16592 SDNode *Result = Emit_109(N, X86::MMX_PSUBSWrr, MVT::v4i16); 16593 return Result; 16594 } 16595 16596 // Pattern: (intrinsic_wo_chain:v4i16 500:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 16597 // Emits: (MMX_PSUBUSWrr:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 16598 // Pattern complexity = 8 cost = 1 size = 3 16599 if (CN1 == INT64_C(500)) { 16600 SDNode *Result = Emit_109(N, X86::MMX_PSUBUSWrr, MVT::v4i16); 16601 return Result; 16602 } 16603 16604 // Pattern: (intrinsic_wo_chain:v4i16 477:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 16605 // Emits: (MMX_PMULHWrr:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 16606 // Pattern complexity = 8 cost = 1 size = 3 16607 if (CN1 == INT64_C(477)) { 16608 SDNode *Result = Emit_109(N, X86::MMX_PMULHWrr, MVT::v4i16); 16609 return Result; 16610 } 16611 16612 // Pattern: (intrinsic_wo_chain:v4i16 478:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 16613 // Emits: (MMX_PMULHUWrr:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 16614 // Pattern complexity = 8 cost = 1 size = 3 16615 if (CN1 == INT64_C(478)) { 16616 SDNode *Result = Emit_109(N, X86::MMX_PMULHUWrr, MVT::v4i16); 16617 return Result; 16618 } 16619 16620 // Pattern: (intrinsic_wo_chain:v4i16 464:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 16621 // Emits: (MMX_PAVGWrr:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 16622 // Pattern complexity = 8 cost = 1 size = 3 16623 if (CN1 == INT64_C(464)) { 16624 SDNode *Result = Emit_109(N, X86::MMX_PAVGWrr, MVT::v4i16); 16625 return Result; 16626 } 16627 16628 // Pattern: (intrinsic_wo_chain:v4i16 474:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 16629 // Emits: (MMX_PMINSWrr:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 16630 // Pattern complexity = 8 cost = 1 size = 3 16631 if (CN1 == INT64_C(474)) { 16632 SDNode *Result = Emit_109(N, X86::MMX_PMINSWrr, MVT::v4i16); 16633 return Result; 16634 } 16635 16636 // Pattern: (intrinsic_wo_chain:v4i16 472:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 16637 // Emits: (MMX_PMAXSWrr:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 16638 // Pattern complexity = 8 cost = 1 size = 3 16639 if (CN1 == INT64_C(472)) { 16640 SDNode *Result = Emit_109(N, X86::MMX_PMAXSWrr, MVT::v4i16); 16641 return Result; 16642 } 16643 16644 // Pattern: (intrinsic_wo_chain:v4i16 480:iPTR, VR64:v8i8:$src1, VR64:v8i8:$src2) 16645 // Emits: (MMX_PSADBWrr:v4i16 VR64:v8i8:$src1, VR64:v8i8:$src2) 16646 // Pattern complexity = 8 cost = 1 size = 3 16647 if (CN1 == INT64_C(480)) { 16648 SDNode *Result = Emit_109(N, X86::MMX_PSADBWrr, MVT::v4i16); 16649 return Result; 16650 } 16651 16652 // Pattern: (intrinsic_wo_chain:v4i16 493:iPTR, VR64:v4i16:$src1, VR64:v1i64:$src2) 16653 // Emits: (MMX_PSRLWrr:v4i16 VR64:v4i16:$src1, VR64:v1i64:$src2) 16654 // Pattern complexity = 8 cost = 1 size = 3 16655 if (CN1 == INT64_C(493)) { 16656 SDNode *Result = Emit_109(N, X86::MMX_PSRLWrr, MVT::v4i16); 16657 return Result; 16658 } 16659 16660 // Pattern: (intrinsic_wo_chain:v4i16 483:iPTR, VR64:v4i16:$src1, VR64:v1i64:$src2) 16661 // Emits: (MMX_PSLLWrr:v4i16 VR64:v4i16:$src1, VR64:v1i64:$src2) 16662 // Pattern complexity = 8 cost = 1 size = 3 16663 if (CN1 == INT64_C(483)) { 16664 SDNode *Result = Emit_109(N, X86::MMX_PSLLWrr, MVT::v4i16); 16665 return Result; 16666 } 16667 16668 // Pattern: (intrinsic_wo_chain:v4i16 488:iPTR, VR64:v4i16:$src1, VR64:v1i64:$src2) 16669 // Emits: (MMX_PSRAWrr:v4i16 VR64:v4i16:$src1, VR64:v1i64:$src2) 16670 // Pattern complexity = 8 cost = 1 size = 3 16671 if (CN1 == INT64_C(488)) { 16672 SDNode *Result = Emit_109(N, X86::MMX_PSRAWrr, MVT::v4i16); 16673 return Result; 16674 } 16675 16676 // Pattern: (intrinsic_wo_chain:v4i16 467:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 16677 // Emits: (MMX_PCMPEQWrr:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 16678 // Pattern complexity = 8 cost = 1 size = 3 16679 if (CN1 == INT64_C(467)) { 16680 SDNode *Result = Emit_109(N, X86::MMX_PCMPEQWrr, MVT::v4i16); 16681 return Result; 16682 } 16683 16684 // Pattern: (intrinsic_wo_chain:v4i16 470:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 16685 // Emits: (MMX_PCMPGTWrr:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 16686 // Pattern complexity = 8 cost = 1 size = 3 16687 if (CN1 == INT64_C(470)) { 16688 SDNode *Result = Emit_109(N, X86::MMX_PCMPGTWrr, MVT::v4i16); 16689 return Result; 16690 } 16691 16692 // Pattern: (intrinsic_wo_chain:v4i16 456:iPTR, VR64:v2i32:$src1, VR64:v2i32:$src2) 16693 // Emits: (MMX_PACKSSDWrr:v4i16 VR64:v2i32:$src1, VR64:v2i32:$src2) 16694 // Pattern complexity = 8 cost = 1 size = 3 16695 if (CN1 == INT64_C(456)) { 16696 SDNode *Result = Emit_109(N, X86::MMX_PACKSSDWrr, MVT::v4i16); 16697 return Result; 16698 } 16699 } 16700 } 16701 16702 CannotYetSelectIntrinsic(N); 16703 return NULL; 16704 } 16705 16706 SDNode *Emit_127(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN1001_0, SDValue &CPTmpN1001_1, SDValue &CPTmpN1001_2, SDValue &CPTmpN1001_3, SDValue &CPTmpN1001_4) DISABLE_INLINE { 16707 SDValue N0 = N.getOperand(0); 16708 SDValue N1 = N.getOperand(1); 16709 SDValue N10 = N1.getOperand(0); 16710 SDValue N100 = N10.getOperand(0); 16711 SDValue Chain100 = N100.getOperand(0); 16712 SDValue N1001 = N100.getOperand(1); 16713 SDValue LSI_N100 = CurDAG->getMemOperand(cast<MemSDNode>(N100)->getMemOperand()); 16714 SDValue Ops0[] = { CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4, LSI_N100, Chain100 }; 16715 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 7); 16716 ReplaceUses(SDValue(N100.getNode(), 1), SDValue(ResNode, 1)); 16717 return ResNode; 16718 } 16719 SDNode *Emit_128(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN10001_0, SDValue &CPTmpN10001_1, SDValue &CPTmpN10001_2, SDValue &CPTmpN10001_3, SDValue &CPTmpN10001_4) DISABLE_INLINE { 16720 SDValue N0 = N.getOperand(0); 16721 SDValue N1 = N.getOperand(1); 16722 SDValue N10 = N1.getOperand(0); 16723 SDValue N100 = N10.getOperand(0); 16724 SDValue N1000 = N100.getOperand(0); 16725 SDValue Chain1000 = N1000.getOperand(0); 16726 SDValue N10001 = N1000.getOperand(1); 16727 SDValue LSI_N1000 = CurDAG->getMemOperand(cast<MemSDNode>(N1000)->getMemOperand()); 16728 SDValue Ops0[] = { CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4, LSI_N1000, Chain1000 }; 16729 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 7); 16730 ReplaceUses(SDValue(N1000.getNode(), 1), SDValue(ResNode, 1)); 16731 return ResNode; 16732 } 16733 SDNode *Emit_129(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 16734 SDValue N0 = N.getOperand(0); 16735 SDValue N1 = N.getOperand(1); 16736 SDValue N10 = N1.getOperand(0); 16737 SDValue Chain10 = N10.getOperand(0); 16738 SDValue N101 = N10.getOperand(1); 16739 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, Chain10 }; 16740 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 6); 16741 ReplaceUses(SDValue(N10.getNode(), 1), SDValue(ResNode, 1)); 16742 return ResNode; 16743 } 16744 SDNode *Select_ISD_INTRINSIC_WO_CHAIN_v8i16(const SDValue &N) { 16745 if (OptLevel != CodeGenOpt::None) { 16746 if ((Subtarget->hasSSE41())) { 16747 SDValue N0 = N.getOperand(0); 16748 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 16749 if (Tmp0) { 16750 int64_t CN1 = Tmp0->getSExtValue(); 16751 16752 // Pattern: (intrinsic_wo_chain:v8i16 640:iPTR, (bitconvert:v16i8 (X86vzmovl:v2i64 (scalar_to_vector:v2i64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>)))) 16753 // Emits: (PMOVSXBWrm:v8i16 addr:iPTR:$src) 16754 // Pattern complexity = 39 cost = 1 size = 3 16755 if (CN1 == INT64_C(640)) { 16756 SDValue N1 = N.getOperand(1); 16757 if (N1.getOpcode() == ISD::BIT_CONVERT && 16758 N1.hasOneUse()) { 16759 SDValue N10 = N1.getOperand(0); 16760 if (N10.getOpcode() == X86ISD::VZEXT_MOVL && 16761 N10.hasOneUse()) { 16762 SDValue N100 = N10.getOperand(0); 16763 if (N100.getOpcode() == ISD::SCALAR_TO_VECTOR && 16764 N100.hasOneUse()) { 16765 SDValue N1000 = N100.getOperand(0); 16766 if (N1000.getOpcode() == ISD::LOAD && 16767 N1000.hasOneUse() && 16768 IsLegalAndProfitableToFold(N1000.getNode(), N100.getNode(), N.getNode())) { 16769 SDValue Chain1000 = N1000.getOperand(0); 16770 if (Predicate_unindexedload(N1000.getNode()) && 16771 Predicate_load(N1000.getNode()) && 16772 Predicate_loadi64(N1000.getNode())) { 16773 SDValue N10001 = N1000.getOperand(1); 16774 SDValue CPTmpN10001_0; 16775 SDValue CPTmpN10001_1; 16776 SDValue CPTmpN10001_2; 16777 SDValue CPTmpN10001_3; 16778 SDValue CPTmpN10001_4; 16779 if (SelectAddr(N, N10001, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4) && 16780 N10.getNode()->getValueType(0) == MVT::v2i64 && 16781 N1000.getNode()->getValueType(0) == MVT::i64) { 16782 SDNode *Result = Emit_128(N, X86::PMOVSXBWrm, MVT::v8i16, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4); 16783 return Result; 16784 } 16785 } 16786 } 16787 } 16788 } 16789 } 16790 } 16791 16792 // Pattern: (intrinsic_wo_chain:v8i16 646:iPTR, (bitconvert:v16i8 (X86vzmovl:v2i64 (scalar_to_vector:v2i64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>)))) 16793 // Emits: (PMOVZXBWrm:v8i16 addr:iPTR:$src) 16794 // Pattern complexity = 39 cost = 1 size = 3 16795 if (CN1 == INT64_C(646)) { 16796 SDValue N1 = N.getOperand(1); 16797 if (N1.getOpcode() == ISD::BIT_CONVERT && 16798 N1.hasOneUse()) { 16799 SDValue N10 = N1.getOperand(0); 16800 if (N10.getOpcode() == X86ISD::VZEXT_MOVL && 16801 N10.hasOneUse()) { 16802 SDValue N100 = N10.getOperand(0); 16803 if (N100.getOpcode() == ISD::SCALAR_TO_VECTOR && 16804 N100.hasOneUse()) { 16805 SDValue N1000 = N100.getOperand(0); 16806 if (N1000.getOpcode() == ISD::LOAD && 16807 N1000.hasOneUse() && 16808 IsLegalAndProfitableToFold(N1000.getNode(), N100.getNode(), N.getNode())) { 16809 SDValue Chain1000 = N1000.getOperand(0); 16810 if (Predicate_unindexedload(N1000.getNode()) && 16811 Predicate_load(N1000.getNode()) && 16812 Predicate_loadi64(N1000.getNode())) { 16813 SDValue N10001 = N1000.getOperand(1); 16814 SDValue CPTmpN10001_0; 16815 SDValue CPTmpN10001_1; 16816 SDValue CPTmpN10001_2; 16817 SDValue CPTmpN10001_3; 16818 SDValue CPTmpN10001_4; 16819 if (SelectAddr(N, N10001, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4) && 16820 N10.getNode()->getValueType(0) == MVT::v2i64 && 16821 N1000.getNode()->getValueType(0) == MVT::i64) { 16822 SDNode *Result = Emit_128(N, X86::PMOVZXBWrm, MVT::v8i16, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4); 16823 return Result; 16824 } 16825 } 16826 } 16827 } 16828 } 16829 } 16830 } 16831 16832 // Pattern: (intrinsic_wo_chain:v8i16 624:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), (imm:i32):$src3) 16833 // Emits: (PBLENDWrmi:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2, (imm:i32):$src3) 16834 // Pattern complexity = 36 cost = 1 size = 3 16835 if (CN1 == INT64_C(624)) { 16836 SDValue N1 = N.getOperand(1); 16837 SDValue N2 = N.getOperand(2); 16838 if (N2.getOpcode() == ISD::BIT_CONVERT && 16839 N2.hasOneUse()) { 16840 SDValue N20 = N2.getOperand(0); 16841 if (N20.getOpcode() == ISD::LOAD && 16842 N20.hasOneUse() && 16843 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 16844 SDValue Chain20 = N20.getOperand(0); 16845 if (Predicate_unindexedload(N20.getNode()) && 16846 Predicate_load(N20.getNode()) && 16847 Predicate_memop(N20.getNode())) { 16848 SDValue N201 = N20.getOperand(1); 16849 SDValue CPTmpN201_0; 16850 SDValue CPTmpN201_1; 16851 SDValue CPTmpN201_2; 16852 SDValue CPTmpN201_3; 16853 SDValue CPTmpN201_4; 16854 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4)) { 16855 SDValue N3 = N.getOperand(3); 16856 if (N3.getOpcode() == ISD::Constant && 16857 N20.getNode()->getValueType(0) == MVT::v16i8) { 16858 SDNode *Result = Emit_118(N, X86::PBLENDWrmi, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 16859 return Result; 16860 } 16861 } 16862 } 16863 } 16864 } 16865 } 16866 16867 // Pattern: (intrinsic_wo_chain:v8i16 640:iPTR, (bitconvert:v16i8 (scalar_to_vector:v2i64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>))) 16868 // Emits: (PMOVSXBWrm:v8i16 addr:iPTR:$src) 16869 // Pattern complexity = 36 cost = 1 size = 3 16870 if (CN1 == INT64_C(640)) { 16871 SDValue N1 = N.getOperand(1); 16872 if (N1.getOpcode() == ISD::BIT_CONVERT && 16873 N1.hasOneUse()) { 16874 SDValue N10 = N1.getOperand(0); 16875 if (N10.getOpcode() == ISD::SCALAR_TO_VECTOR && 16876 N10.hasOneUse()) { 16877 SDValue N100 = N10.getOperand(0); 16878 if (N100.getOpcode() == ISD::LOAD && 16879 N100.hasOneUse() && 16880 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode())) { 16881 SDValue Chain100 = N100.getOperand(0); 16882 if (Predicate_unindexedload(N100.getNode()) && 16883 Predicate_load(N100.getNode()) && 16884 Predicate_loadi64(N100.getNode())) { 16885 SDValue N1001 = N100.getOperand(1); 16886 SDValue CPTmpN1001_0; 16887 SDValue CPTmpN1001_1; 16888 SDValue CPTmpN1001_2; 16889 SDValue CPTmpN1001_3; 16890 SDValue CPTmpN1001_4; 16891 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4) && 16892 N10.getNode()->getValueType(0) == MVT::v2i64 && 16893 N100.getNode()->getValueType(0) == MVT::i64) { 16894 SDNode *Result = Emit_127(N, X86::PMOVSXBWrm, MVT::v8i16, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 16895 return Result; 16896 } 16897 } 16898 } 16899 } 16900 } 16901 } 16902 16903 // Pattern: (intrinsic_wo_chain:v8i16 646:iPTR, (bitconvert:v16i8 (scalar_to_vector:v2i64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>))) 16904 // Emits: (PMOVZXBWrm:v8i16 addr:iPTR:$src) 16905 // Pattern complexity = 36 cost = 1 size = 3 16906 if (CN1 == INT64_C(646)) { 16907 SDValue N1 = N.getOperand(1); 16908 if (N1.getOpcode() == ISD::BIT_CONVERT && 16909 N1.hasOneUse()) { 16910 SDValue N10 = N1.getOperand(0); 16911 if (N10.getOpcode() == ISD::SCALAR_TO_VECTOR && 16912 N10.hasOneUse()) { 16913 SDValue N100 = N10.getOperand(0); 16914 if (N100.getOpcode() == ISD::LOAD && 16915 N100.hasOneUse() && 16916 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode())) { 16917 SDValue Chain100 = N100.getOperand(0); 16918 if (Predicate_unindexedload(N100.getNode()) && 16919 Predicate_load(N100.getNode()) && 16920 Predicate_loadi64(N100.getNode())) { 16921 SDValue N1001 = N100.getOperand(1); 16922 SDValue CPTmpN1001_0; 16923 SDValue CPTmpN1001_1; 16924 SDValue CPTmpN1001_2; 16925 SDValue CPTmpN1001_3; 16926 SDValue CPTmpN1001_4; 16927 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4) && 16928 N10.getNode()->getValueType(0) == MVT::v2i64 && 16929 N100.getNode()->getValueType(0) == MVT::i64) { 16930 SDNode *Result = Emit_127(N, X86::PMOVZXBWrm, MVT::v8i16, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 16931 return Result; 16932 } 16933 } 16934 } 16935 } 16936 } 16937 } 16938 } 16939 } 16940 if ((Subtarget->hasSSE2())) { 16941 SDValue N0 = N.getOperand(0); 16942 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 16943 if (Tmp0) { 16944 int64_t CN1 = Tmp0->getSExtValue(); 16945 16946 // Pattern: (intrinsic_wo_chain:v8i16 546:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 16947 // Emits: (PADDSWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 16948 // Pattern complexity = 33 cost = 1 size = 3 16949 if (CN1 == INT64_C(546)) { 16950 SDValue N1 = N.getOperand(1); 16951 SDValue N2 = N.getOperand(2); 16952 if (N2.getOpcode() == ISD::BIT_CONVERT && 16953 N2.hasOneUse()) { 16954 SDValue N20 = N2.getOperand(0); 16955 if (N20.getOpcode() == ISD::LOAD && 16956 N20.hasOneUse() && 16957 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 16958 SDValue Chain20 = N20.getOperand(0); 16959 if (Predicate_unindexedload(N20.getNode()) && 16960 Predicate_load(N20.getNode()) && 16961 Predicate_memop(N20.getNode())) { 16962 SDValue N201 = N20.getOperand(1); 16963 SDValue CPTmpN201_0; 16964 SDValue CPTmpN201_1; 16965 SDValue CPTmpN201_2; 16966 SDValue CPTmpN201_3; 16967 SDValue CPTmpN201_4; 16968 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 16969 N20.getNode()->getValueType(0) == MVT::v2i64) { 16970 SDNode *Result = Emit_115(N, X86::PADDSWrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 16971 return Result; 16972 } 16973 } 16974 } 16975 } 16976 } 16977 16978 // Pattern: (intrinsic_wo_chain:v8i16 548:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 16979 // Emits: (PADDUSWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 16980 // Pattern complexity = 33 cost = 1 size = 3 16981 if (CN1 == INT64_C(548)) { 16982 SDValue N1 = N.getOperand(1); 16983 SDValue N2 = N.getOperand(2); 16984 if (N2.getOpcode() == ISD::BIT_CONVERT && 16985 N2.hasOneUse()) { 16986 SDValue N20 = N2.getOperand(0); 16987 if (N20.getOpcode() == ISD::LOAD && 16988 N20.hasOneUse() && 16989 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 16990 SDValue Chain20 = N20.getOperand(0); 16991 if (Predicate_unindexedload(N20.getNode()) && 16992 Predicate_load(N20.getNode()) && 16993 Predicate_memop(N20.getNode())) { 16994 SDValue N201 = N20.getOperand(1); 16995 SDValue CPTmpN201_0; 16996 SDValue CPTmpN201_1; 16997 SDValue CPTmpN201_2; 16998 SDValue CPTmpN201_3; 16999 SDValue CPTmpN201_4; 17000 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17001 N20.getNode()->getValueType(0) == MVT::v2i64) { 17002 SDNode *Result = Emit_115(N, X86::PADDUSWrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17003 return Result; 17004 } 17005 } 17006 } 17007 } 17008 } 17009 17010 // Pattern: (intrinsic_wo_chain:v8i16 588:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 17011 // Emits: (PSUBSWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17012 // Pattern complexity = 33 cost = 1 size = 3 17013 if (CN1 == INT64_C(588)) { 17014 SDValue N1 = N.getOperand(1); 17015 SDValue N2 = N.getOperand(2); 17016 if (N2.getOpcode() == ISD::BIT_CONVERT && 17017 N2.hasOneUse()) { 17018 SDValue N20 = N2.getOperand(0); 17019 if (N20.getOpcode() == ISD::LOAD && 17020 N20.hasOneUse() && 17021 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17022 SDValue Chain20 = N20.getOperand(0); 17023 if (Predicate_unindexedload(N20.getNode()) && 17024 Predicate_load(N20.getNode()) && 17025 Predicate_memop(N20.getNode())) { 17026 SDValue N201 = N20.getOperand(1); 17027 SDValue CPTmpN201_0; 17028 SDValue CPTmpN201_1; 17029 SDValue CPTmpN201_2; 17030 SDValue CPTmpN201_3; 17031 SDValue CPTmpN201_4; 17032 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17033 N20.getNode()->getValueType(0) == MVT::v2i64) { 17034 SDNode *Result = Emit_115(N, X86::PSUBSWrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17035 return Result; 17036 } 17037 } 17038 } 17039 } 17040 } 17041 17042 // Pattern: (intrinsic_wo_chain:v8i16 590:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 17043 // Emits: (PSUBUSWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17044 // Pattern complexity = 33 cost = 1 size = 3 17045 if (CN1 == INT64_C(590)) { 17046 SDValue N1 = N.getOperand(1); 17047 SDValue N2 = N.getOperand(2); 17048 if (N2.getOpcode() == ISD::BIT_CONVERT && 17049 N2.hasOneUse()) { 17050 SDValue N20 = N2.getOperand(0); 17051 if (N20.getOpcode() == ISD::LOAD && 17052 N20.hasOneUse() && 17053 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17054 SDValue Chain20 = N20.getOperand(0); 17055 if (Predicate_unindexedload(N20.getNode()) && 17056 Predicate_load(N20.getNode()) && 17057 Predicate_memop(N20.getNode())) { 17058 SDValue N201 = N20.getOperand(1); 17059 SDValue CPTmpN201_0; 17060 SDValue CPTmpN201_1; 17061 SDValue CPTmpN201_2; 17062 SDValue CPTmpN201_3; 17063 SDValue CPTmpN201_4; 17064 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17065 N20.getNode()->getValueType(0) == MVT::v2i64) { 17066 SDNode *Result = Emit_115(N, X86::PSUBUSWrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17067 return Result; 17068 } 17069 } 17070 } 17071 } 17072 } 17073 17074 // Pattern: (intrinsic_wo_chain:v8i16 564:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 17075 // Emits: (PMULHUWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17076 // Pattern complexity = 33 cost = 1 size = 3 17077 if (CN1 == INT64_C(564)) { 17078 SDValue N1 = N.getOperand(1); 17079 SDValue N2 = N.getOperand(2); 17080 if (N2.getOpcode() == ISD::BIT_CONVERT && 17081 N2.hasOneUse()) { 17082 SDValue N20 = N2.getOperand(0); 17083 if (N20.getOpcode() == ISD::LOAD && 17084 N20.hasOneUse() && 17085 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17086 SDValue Chain20 = N20.getOperand(0); 17087 if (Predicate_unindexedload(N20.getNode()) && 17088 Predicate_load(N20.getNode()) && 17089 Predicate_memop(N20.getNode())) { 17090 SDValue N201 = N20.getOperand(1); 17091 SDValue CPTmpN201_0; 17092 SDValue CPTmpN201_1; 17093 SDValue CPTmpN201_2; 17094 SDValue CPTmpN201_3; 17095 SDValue CPTmpN201_4; 17096 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17097 N20.getNode()->getValueType(0) == MVT::v2i64) { 17098 SDNode *Result = Emit_115(N, X86::PMULHUWrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17099 return Result; 17100 } 17101 } 17102 } 17103 } 17104 } 17105 17106 // Pattern: (intrinsic_wo_chain:v8i16 563:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 17107 // Emits: (PMULHWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17108 // Pattern complexity = 33 cost = 1 size = 3 17109 if (CN1 == INT64_C(563)) { 17110 SDValue N1 = N.getOperand(1); 17111 SDValue N2 = N.getOperand(2); 17112 if (N2.getOpcode() == ISD::BIT_CONVERT && 17113 N2.hasOneUse()) { 17114 SDValue N20 = N2.getOperand(0); 17115 if (N20.getOpcode() == ISD::LOAD && 17116 N20.hasOneUse() && 17117 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17118 SDValue Chain20 = N20.getOperand(0); 17119 if (Predicate_unindexedload(N20.getNode()) && 17120 Predicate_load(N20.getNode()) && 17121 Predicate_memop(N20.getNode())) { 17122 SDValue N201 = N20.getOperand(1); 17123 SDValue CPTmpN201_0; 17124 SDValue CPTmpN201_1; 17125 SDValue CPTmpN201_2; 17126 SDValue CPTmpN201_3; 17127 SDValue CPTmpN201_4; 17128 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17129 N20.getNode()->getValueType(0) == MVT::v2i64) { 17130 SDNode *Result = Emit_115(N, X86::PMULHWrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17131 return Result; 17132 } 17133 } 17134 } 17135 } 17136 } 17137 17138 // Pattern: (intrinsic_wo_chain:v8i16 550:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 17139 // Emits: (PAVGWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17140 // Pattern complexity = 33 cost = 1 size = 3 17141 if (CN1 == INT64_C(550)) { 17142 SDValue N1 = N.getOperand(1); 17143 SDValue N2 = N.getOperand(2); 17144 if (N2.getOpcode() == ISD::BIT_CONVERT && 17145 N2.hasOneUse()) { 17146 SDValue N20 = N2.getOperand(0); 17147 if (N20.getOpcode() == ISD::LOAD && 17148 N20.hasOneUse() && 17149 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17150 SDValue Chain20 = N20.getOperand(0); 17151 if (Predicate_unindexedload(N20.getNode()) && 17152 Predicate_load(N20.getNode()) && 17153 Predicate_memop(N20.getNode())) { 17154 SDValue N201 = N20.getOperand(1); 17155 SDValue CPTmpN201_0; 17156 SDValue CPTmpN201_1; 17157 SDValue CPTmpN201_2; 17158 SDValue CPTmpN201_3; 17159 SDValue CPTmpN201_4; 17160 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17161 N20.getNode()->getValueType(0) == MVT::v2i64) { 17162 SDNode *Result = Emit_115(N, X86::PAVGWrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17163 return Result; 17164 } 17165 } 17166 } 17167 } 17168 } 17169 17170 // Pattern: (intrinsic_wo_chain:v8i16 560:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 17171 // Emits: (PMINSWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17172 // Pattern complexity = 33 cost = 1 size = 3 17173 if (CN1 == INT64_C(560)) { 17174 SDValue N1 = N.getOperand(1); 17175 SDValue N2 = N.getOperand(2); 17176 if (N2.getOpcode() == ISD::BIT_CONVERT && 17177 N2.hasOneUse()) { 17178 SDValue N20 = N2.getOperand(0); 17179 if (N20.getOpcode() == ISD::LOAD && 17180 N20.hasOneUse() && 17181 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17182 SDValue Chain20 = N20.getOperand(0); 17183 if (Predicate_unindexedload(N20.getNode()) && 17184 Predicate_load(N20.getNode()) && 17185 Predicate_memop(N20.getNode())) { 17186 SDValue N201 = N20.getOperand(1); 17187 SDValue CPTmpN201_0; 17188 SDValue CPTmpN201_1; 17189 SDValue CPTmpN201_2; 17190 SDValue CPTmpN201_3; 17191 SDValue CPTmpN201_4; 17192 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17193 N20.getNode()->getValueType(0) == MVT::v2i64) { 17194 SDNode *Result = Emit_115(N, X86::PMINSWrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17195 return Result; 17196 } 17197 } 17198 } 17199 } 17200 } 17201 17202 // Pattern: (intrinsic_wo_chain:v8i16 558:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 17203 // Emits: (PMAXSWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17204 // Pattern complexity = 33 cost = 1 size = 3 17205 if (CN1 == INT64_C(558)) { 17206 SDValue N1 = N.getOperand(1); 17207 SDValue N2 = N.getOperand(2); 17208 if (N2.getOpcode() == ISD::BIT_CONVERT && 17209 N2.hasOneUse()) { 17210 SDValue N20 = N2.getOperand(0); 17211 if (N20.getOpcode() == ISD::LOAD && 17212 N20.hasOneUse() && 17213 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17214 SDValue Chain20 = N20.getOperand(0); 17215 if (Predicate_unindexedload(N20.getNode()) && 17216 Predicate_load(N20.getNode()) && 17217 Predicate_memop(N20.getNode())) { 17218 SDValue N201 = N20.getOperand(1); 17219 SDValue CPTmpN201_0; 17220 SDValue CPTmpN201_1; 17221 SDValue CPTmpN201_2; 17222 SDValue CPTmpN201_3; 17223 SDValue CPTmpN201_4; 17224 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17225 N20.getNode()->getValueType(0) == MVT::v2i64) { 17226 SDNode *Result = Emit_115(N, X86::PMAXSWrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17227 return Result; 17228 } 17229 } 17230 } 17231 } 17232 } 17233 17234 // Pattern: (intrinsic_wo_chain:v8i16 571:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 17235 // Emits: (PSLLWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17236 // Pattern complexity = 33 cost = 1 size = 3 17237 if (CN1 == INT64_C(571)) { 17238 SDValue N1 = N.getOperand(1); 17239 SDValue N2 = N.getOperand(2); 17240 if (N2.getOpcode() == ISD::BIT_CONVERT && 17241 N2.hasOneUse()) { 17242 SDValue N20 = N2.getOperand(0); 17243 if (N20.getOpcode() == ISD::LOAD && 17244 N20.hasOneUse() && 17245 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17246 SDValue Chain20 = N20.getOperand(0); 17247 if (Predicate_unindexedload(N20.getNode()) && 17248 Predicate_load(N20.getNode()) && 17249 Predicate_memop(N20.getNode())) { 17250 SDValue N201 = N20.getOperand(1); 17251 SDValue CPTmpN201_0; 17252 SDValue CPTmpN201_1; 17253 SDValue CPTmpN201_2; 17254 SDValue CPTmpN201_3; 17255 SDValue CPTmpN201_4; 17256 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17257 N20.getNode()->getValueType(0) == MVT::v2i64) { 17258 SDNode *Result = Emit_115(N, X86::PSLLWrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17259 return Result; 17260 } 17261 } 17262 } 17263 } 17264 } 17265 17266 // Pattern: (intrinsic_wo_chain:v8i16 583:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 17267 // Emits: (PSRLWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17268 // Pattern complexity = 33 cost = 1 size = 3 17269 if (CN1 == INT64_C(583)) { 17270 SDValue N1 = N.getOperand(1); 17271 SDValue N2 = N.getOperand(2); 17272 if (N2.getOpcode() == ISD::BIT_CONVERT && 17273 N2.hasOneUse()) { 17274 SDValue N20 = N2.getOperand(0); 17275 if (N20.getOpcode() == ISD::LOAD && 17276 N20.hasOneUse() && 17277 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17278 SDValue Chain20 = N20.getOperand(0); 17279 if (Predicate_unindexedload(N20.getNode()) && 17280 Predicate_load(N20.getNode()) && 17281 Predicate_memop(N20.getNode())) { 17282 SDValue N201 = N20.getOperand(1); 17283 SDValue CPTmpN201_0; 17284 SDValue CPTmpN201_1; 17285 SDValue CPTmpN201_2; 17286 SDValue CPTmpN201_3; 17287 SDValue CPTmpN201_4; 17288 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17289 N20.getNode()->getValueType(0) == MVT::v2i64) { 17290 SDNode *Result = Emit_115(N, X86::PSRLWrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17291 return Result; 17292 } 17293 } 17294 } 17295 } 17296 } 17297 17298 // Pattern: (intrinsic_wo_chain:v8i16 576:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 17299 // Emits: (PSRAWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17300 // Pattern complexity = 33 cost = 1 size = 3 17301 if (CN1 == INT64_C(576)) { 17302 SDValue N1 = N.getOperand(1); 17303 SDValue N2 = N.getOperand(2); 17304 if (N2.getOpcode() == ISD::BIT_CONVERT && 17305 N2.hasOneUse()) { 17306 SDValue N20 = N2.getOperand(0); 17307 if (N20.getOpcode() == ISD::LOAD && 17308 N20.hasOneUse() && 17309 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17310 SDValue Chain20 = N20.getOperand(0); 17311 if (Predicate_unindexedload(N20.getNode()) && 17312 Predicate_load(N20.getNode()) && 17313 Predicate_memop(N20.getNode())) { 17314 SDValue N201 = N20.getOperand(1); 17315 SDValue CPTmpN201_0; 17316 SDValue CPTmpN201_1; 17317 SDValue CPTmpN201_2; 17318 SDValue CPTmpN201_3; 17319 SDValue CPTmpN201_4; 17320 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17321 N20.getNode()->getValueType(0) == MVT::v2i64) { 17322 SDNode *Result = Emit_115(N, X86::PSRAWrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17323 return Result; 17324 } 17325 } 17326 } 17327 } 17328 } 17329 17330 // Pattern: (intrinsic_wo_chain:v8i16 553:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 17331 // Emits: (PCMPEQWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17332 // Pattern complexity = 33 cost = 1 size = 3 17333 if (CN1 == INT64_C(553)) { 17334 SDValue N1 = N.getOperand(1); 17335 SDValue N2 = N.getOperand(2); 17336 if (N2.getOpcode() == ISD::BIT_CONVERT && 17337 N2.hasOneUse()) { 17338 SDValue N20 = N2.getOperand(0); 17339 if (N20.getOpcode() == ISD::LOAD && 17340 N20.hasOneUse() && 17341 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17342 SDValue Chain20 = N20.getOperand(0); 17343 if (Predicate_unindexedload(N20.getNode()) && 17344 Predicate_load(N20.getNode()) && 17345 Predicate_memop(N20.getNode())) { 17346 SDValue N201 = N20.getOperand(1); 17347 SDValue CPTmpN201_0; 17348 SDValue CPTmpN201_1; 17349 SDValue CPTmpN201_2; 17350 SDValue CPTmpN201_3; 17351 SDValue CPTmpN201_4; 17352 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17353 N20.getNode()->getValueType(0) == MVT::v2i64) { 17354 SDNode *Result = Emit_115(N, X86::PCMPEQWrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17355 return Result; 17356 } 17357 } 17358 } 17359 } 17360 } 17361 17362 // Pattern: (intrinsic_wo_chain:v8i16 556:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 17363 // Emits: (PCMPGTWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17364 // Pattern complexity = 33 cost = 1 size = 3 17365 if (CN1 == INT64_C(556)) { 17366 SDValue N1 = N.getOperand(1); 17367 SDValue N2 = N.getOperand(2); 17368 if (N2.getOpcode() == ISD::BIT_CONVERT && 17369 N2.hasOneUse()) { 17370 SDValue N20 = N2.getOperand(0); 17371 if (N20.getOpcode() == ISD::LOAD && 17372 N20.hasOneUse() && 17373 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17374 SDValue Chain20 = N20.getOperand(0); 17375 if (Predicate_unindexedload(N20.getNode()) && 17376 Predicate_load(N20.getNode()) && 17377 Predicate_memop(N20.getNode())) { 17378 SDValue N201 = N20.getOperand(1); 17379 SDValue CPTmpN201_0; 17380 SDValue CPTmpN201_1; 17381 SDValue CPTmpN201_2; 17382 SDValue CPTmpN201_3; 17383 SDValue CPTmpN201_4; 17384 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17385 N20.getNode()->getValueType(0) == MVT::v2i64) { 17386 SDNode *Result = Emit_115(N, X86::PCMPGTWrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17387 return Result; 17388 } 17389 } 17390 } 17391 } 17392 } 17393 17394 // Pattern: (intrinsic_wo_chain:v8i16 543:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 17395 // Emits: (PACKSSWBrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17396 // Pattern complexity = 33 cost = 1 size = 3 17397 if (CN1 == INT64_C(543)) { 17398 SDValue N1 = N.getOperand(1); 17399 SDValue N2 = N.getOperand(2); 17400 if (N2.getOpcode() == ISD::BIT_CONVERT && 17401 N2.hasOneUse()) { 17402 SDValue N20 = N2.getOperand(0); 17403 if (N20.getOpcode() == ISD::LOAD && 17404 N20.hasOneUse() && 17405 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17406 SDValue Chain20 = N20.getOperand(0); 17407 if (Predicate_unindexedload(N20.getNode()) && 17408 Predicate_load(N20.getNode()) && 17409 Predicate_memop(N20.getNode())) { 17410 SDValue N201 = N20.getOperand(1); 17411 SDValue CPTmpN201_0; 17412 SDValue CPTmpN201_1; 17413 SDValue CPTmpN201_2; 17414 SDValue CPTmpN201_3; 17415 SDValue CPTmpN201_4; 17416 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17417 N20.getNode()->getValueType(0) == MVT::v2i64) { 17418 SDNode *Result = Emit_115(N, X86::PACKSSWBrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17419 return Result; 17420 } 17421 } 17422 } 17423 } 17424 } 17425 17426 // Pattern: (intrinsic_wo_chain:v8i16 544:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 17427 // Emits: (PACKUSWBrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17428 // Pattern complexity = 33 cost = 1 size = 3 17429 if (CN1 == INT64_C(544)) { 17430 SDValue N1 = N.getOperand(1); 17431 SDValue N2 = N.getOperand(2); 17432 if (N2.getOpcode() == ISD::BIT_CONVERT && 17433 N2.hasOneUse()) { 17434 SDValue N20 = N2.getOperand(0); 17435 if (N20.getOpcode() == ISD::LOAD && 17436 N20.hasOneUse() && 17437 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17438 SDValue Chain20 = N20.getOperand(0); 17439 if (Predicate_unindexedload(N20.getNode()) && 17440 Predicate_load(N20.getNode()) && 17441 Predicate_memop(N20.getNode())) { 17442 SDValue N201 = N20.getOperand(1); 17443 SDValue CPTmpN201_0; 17444 SDValue CPTmpN201_1; 17445 SDValue CPTmpN201_2; 17446 SDValue CPTmpN201_3; 17447 SDValue CPTmpN201_4; 17448 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17449 N20.getNode()->getValueType(0) == MVT::v2i64) { 17450 SDNode *Result = Emit_115(N, X86::PACKUSWBrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17451 return Result; 17452 } 17453 } 17454 } 17455 } 17456 } 17457 } 17458 } 17459 if ((Subtarget->hasSSSE3())) { 17460 SDValue N0 = N.getOperand(0); 17461 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 17462 if (Tmp0) { 17463 int64_t CN1 = Tmp0->getSExtValue(); 17464 17465 // Pattern: (intrinsic_wo_chain:v8i16 730:iPTR, (bitconvert:v8i16 (ld:v8i16 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 17466 // Emits: (PABSWrm128:v8i16 addr:iPTR:$src) 17467 // Pattern complexity = 33 cost = 1 size = 3 17468 if (CN1 == INT64_C(730)) { 17469 SDValue N1 = N.getOperand(1); 17470 if (N1.getOpcode() == ISD::BIT_CONVERT && 17471 N1.hasOneUse()) { 17472 SDValue N10 = N1.getOperand(0); 17473 if (N10.getOpcode() == ISD::LOAD && 17474 N10.hasOneUse() && 17475 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 17476 SDValue Chain10 = N10.getOperand(0); 17477 if (Predicate_unindexedload(N10.getNode()) && 17478 Predicate_load(N10.getNode()) && 17479 Predicate_memop64(N10.getNode())) { 17480 SDValue N101 = N10.getOperand(1); 17481 SDValue CPTmpN101_0; 17482 SDValue CPTmpN101_1; 17483 SDValue CPTmpN101_2; 17484 SDValue CPTmpN101_3; 17485 SDValue CPTmpN101_4; 17486 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 17487 N10.getNode()->getValueType(0) == MVT::v8i16) { 17488 SDNode *Result = Emit_114(N, X86::PABSWrm128, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 17489 return Result; 17490 } 17491 } 17492 } 17493 } 17494 } 17495 17496 // Pattern: (intrinsic_wo_chain:v8i16 738:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v8i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 17497 // Emits: (PHADDWrm128:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17498 // Pattern complexity = 33 cost = 1 size = 3 17499 if (CN1 == INT64_C(738)) { 17500 SDValue N1 = N.getOperand(1); 17501 SDValue N2 = N.getOperand(2); 17502 if (N2.getOpcode() == ISD::BIT_CONVERT && 17503 N2.hasOneUse()) { 17504 SDValue N20 = N2.getOperand(0); 17505 if (N20.getOpcode() == ISD::LOAD && 17506 N20.hasOneUse() && 17507 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17508 SDValue Chain20 = N20.getOperand(0); 17509 if (Predicate_unindexedload(N20.getNode()) && 17510 Predicate_load(N20.getNode()) && 17511 Predicate_memop64(N20.getNode())) { 17512 SDValue N201 = N20.getOperand(1); 17513 SDValue CPTmpN201_0; 17514 SDValue CPTmpN201_1; 17515 SDValue CPTmpN201_2; 17516 SDValue CPTmpN201_3; 17517 SDValue CPTmpN201_4; 17518 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17519 N20.getNode()->getValueType(0) == MVT::v8i16) { 17520 SDNode *Result = Emit_115(N, X86::PHADDWrm128, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17521 return Result; 17522 } 17523 } 17524 } 17525 } 17526 } 17527 17528 // Pattern: (intrinsic_wo_chain:v8i16 744:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v8i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 17529 // Emits: (PHSUBWrm128:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17530 // Pattern complexity = 33 cost = 1 size = 3 17531 if (CN1 == INT64_C(744)) { 17532 SDValue N1 = N.getOperand(1); 17533 SDValue N2 = N.getOperand(2); 17534 if (N2.getOpcode() == ISD::BIT_CONVERT && 17535 N2.hasOneUse()) { 17536 SDValue N20 = N2.getOperand(0); 17537 if (N20.getOpcode() == ISD::LOAD && 17538 N20.hasOneUse() && 17539 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17540 SDValue Chain20 = N20.getOperand(0); 17541 if (Predicate_unindexedload(N20.getNode()) && 17542 Predicate_load(N20.getNode()) && 17543 Predicate_memop64(N20.getNode())) { 17544 SDValue N201 = N20.getOperand(1); 17545 SDValue CPTmpN201_0; 17546 SDValue CPTmpN201_1; 17547 SDValue CPTmpN201_2; 17548 SDValue CPTmpN201_3; 17549 SDValue CPTmpN201_4; 17550 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17551 N20.getNode()->getValueType(0) == MVT::v8i16) { 17552 SDNode *Result = Emit_115(N, X86::PHSUBWrm128, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17553 return Result; 17554 } 17555 } 17556 } 17557 } 17558 } 17559 17560 // Pattern: (intrinsic_wo_chain:v8i16 742:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v8i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 17561 // Emits: (PHSUBSWrm128:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17562 // Pattern complexity = 33 cost = 1 size = 3 17563 if (CN1 == INT64_C(742)) { 17564 SDValue N1 = N.getOperand(1); 17565 SDValue N2 = N.getOperand(2); 17566 if (N2.getOpcode() == ISD::BIT_CONVERT && 17567 N2.hasOneUse()) { 17568 SDValue N20 = N2.getOperand(0); 17569 if (N20.getOpcode() == ISD::LOAD && 17570 N20.hasOneUse() && 17571 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17572 SDValue Chain20 = N20.getOperand(0); 17573 if (Predicate_unindexedload(N20.getNode()) && 17574 Predicate_load(N20.getNode()) && 17575 Predicate_memop64(N20.getNode())) { 17576 SDValue N201 = N20.getOperand(1); 17577 SDValue CPTmpN201_0; 17578 SDValue CPTmpN201_1; 17579 SDValue CPTmpN201_2; 17580 SDValue CPTmpN201_3; 17581 SDValue CPTmpN201_4; 17582 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17583 N20.getNode()->getValueType(0) == MVT::v8i16) { 17584 SDNode *Result = Emit_115(N, X86::PHSUBSWrm128, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17585 return Result; 17586 } 17587 } 17588 } 17589 } 17590 } 17591 17592 // Pattern: (intrinsic_wo_chain:v8i16 746:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 17593 // Emits: (PMADDUBSWrm128:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17594 // Pattern complexity = 33 cost = 1 size = 3 17595 if (CN1 == INT64_C(746)) { 17596 SDValue N1 = N.getOperand(1); 17597 SDValue N2 = N.getOperand(2); 17598 if (N2.getOpcode() == ISD::BIT_CONVERT && 17599 N2.hasOneUse()) { 17600 SDValue N20 = N2.getOperand(0); 17601 if (N20.getOpcode() == ISD::LOAD && 17602 N20.hasOneUse() && 17603 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17604 SDValue Chain20 = N20.getOperand(0); 17605 if (Predicate_unindexedload(N20.getNode()) && 17606 Predicate_load(N20.getNode()) && 17607 Predicate_memop(N20.getNode())) { 17608 SDValue N201 = N20.getOperand(1); 17609 SDValue CPTmpN201_0; 17610 SDValue CPTmpN201_1; 17611 SDValue CPTmpN201_2; 17612 SDValue CPTmpN201_3; 17613 SDValue CPTmpN201_4; 17614 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17615 N20.getNode()->getValueType(0) == MVT::v16i8) { 17616 SDNode *Result = Emit_115(N, X86::PMADDUBSWrm128, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17617 return Result; 17618 } 17619 } 17620 } 17621 } 17622 } 17623 17624 // Pattern: (intrinsic_wo_chain:v8i16 748:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v8i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 17625 // Emits: (PMULHRSWrm128:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17626 // Pattern complexity = 33 cost = 1 size = 3 17627 if (CN1 == INT64_C(748)) { 17628 SDValue N1 = N.getOperand(1); 17629 SDValue N2 = N.getOperand(2); 17630 if (N2.getOpcode() == ISD::BIT_CONVERT && 17631 N2.hasOneUse()) { 17632 SDValue N20 = N2.getOperand(0); 17633 if (N20.getOpcode() == ISD::LOAD && 17634 N20.hasOneUse() && 17635 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17636 SDValue Chain20 = N20.getOperand(0); 17637 if (Predicate_unindexedload(N20.getNode()) && 17638 Predicate_load(N20.getNode()) && 17639 Predicate_memop64(N20.getNode())) { 17640 SDValue N201 = N20.getOperand(1); 17641 SDValue CPTmpN201_0; 17642 SDValue CPTmpN201_1; 17643 SDValue CPTmpN201_2; 17644 SDValue CPTmpN201_3; 17645 SDValue CPTmpN201_4; 17646 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17647 N20.getNode()->getValueType(0) == MVT::v8i16) { 17648 SDNode *Result = Emit_115(N, X86::PMULHRSWrm128, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17649 return Result; 17650 } 17651 } 17652 } 17653 } 17654 } 17655 17656 // Pattern: (intrinsic_wo_chain:v8i16 756:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v8i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 17657 // Emits: (PSIGNWrm128:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17658 // Pattern complexity = 33 cost = 1 size = 3 17659 if (CN1 == INT64_C(756)) { 17660 SDValue N1 = N.getOperand(1); 17661 SDValue N2 = N.getOperand(2); 17662 if (N2.getOpcode() == ISD::BIT_CONVERT && 17663 N2.hasOneUse()) { 17664 SDValue N20 = N2.getOperand(0); 17665 if (N20.getOpcode() == ISD::LOAD && 17666 N20.hasOneUse() && 17667 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17668 SDValue Chain20 = N20.getOperand(0); 17669 if (Predicate_unindexedload(N20.getNode()) && 17670 Predicate_load(N20.getNode()) && 17671 Predicate_memop64(N20.getNode())) { 17672 SDValue N201 = N20.getOperand(1); 17673 SDValue CPTmpN201_0; 17674 SDValue CPTmpN201_1; 17675 SDValue CPTmpN201_2; 17676 SDValue CPTmpN201_3; 17677 SDValue CPTmpN201_4; 17678 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17679 N20.getNode()->getValueType(0) == MVT::v8i16) { 17680 SDNode *Result = Emit_115(N, X86::PSIGNWrm128, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17681 return Result; 17682 } 17683 } 17684 } 17685 } 17686 } 17687 } 17688 } 17689 if ((Subtarget->hasSSE41())) { 17690 SDValue N0 = N.getOperand(0); 17691 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 17692 if (Tmp0) { 17693 int64_t CN1 = Tmp0->getSExtValue(); 17694 17695 // Pattern: (intrinsic_wo_chain:v8i16 629:iPTR, (bitconvert:v8i16 (ld:v8i16 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 17696 // Emits: (PHMINPOSUWrm128:v8i16 addr:iPTR:$src) 17697 // Pattern complexity = 33 cost = 1 size = 3 17698 if (CN1 == INT64_C(629)) { 17699 SDValue N1 = N.getOperand(1); 17700 if (N1.getOpcode() == ISD::BIT_CONVERT && 17701 N1.hasOneUse()) { 17702 SDValue N10 = N1.getOperand(0); 17703 if (N10.getOpcode() == ISD::LOAD && 17704 N10.hasOneUse() && 17705 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 17706 SDValue Chain10 = N10.getOperand(0); 17707 if (Predicate_unindexedload(N10.getNode()) && 17708 Predicate_load(N10.getNode()) && 17709 Predicate_memop64(N10.getNode())) { 17710 SDValue N101 = N10.getOperand(1); 17711 SDValue CPTmpN101_0; 17712 SDValue CPTmpN101_1; 17713 SDValue CPTmpN101_2; 17714 SDValue CPTmpN101_3; 17715 SDValue CPTmpN101_4; 17716 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 17717 N10.getNode()->getValueType(0) == MVT::v8i16) { 17718 SDNode *Result = Emit_114(N, X86::PHMINPOSUWrm128, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 17719 return Result; 17720 } 17721 } 17722 } 17723 } 17724 } 17725 17726 // Pattern: (intrinsic_wo_chain:v8i16 622:iPTR, VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 17727 // Emits: (PACKUSDWrm:v8i16 VR128:v4i32:$src1, addr:iPTR:$src2) 17728 // Pattern complexity = 33 cost = 1 size = 3 17729 if (CN1 == INT64_C(622)) { 17730 SDValue N1 = N.getOperand(1); 17731 SDValue N2 = N.getOperand(2); 17732 if (N2.getOpcode() == ISD::BIT_CONVERT && 17733 N2.hasOneUse()) { 17734 SDValue N20 = N2.getOperand(0); 17735 if (N20.getOpcode() == ISD::LOAD && 17736 N20.hasOneUse() && 17737 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17738 SDValue Chain20 = N20.getOperand(0); 17739 if (Predicate_unindexedload(N20.getNode()) && 17740 Predicate_load(N20.getNode()) && 17741 Predicate_memop(N20.getNode())) { 17742 SDValue N201 = N20.getOperand(1); 17743 SDValue CPTmpN201_0; 17744 SDValue CPTmpN201_1; 17745 SDValue CPTmpN201_2; 17746 SDValue CPTmpN201_3; 17747 SDValue CPTmpN201_4; 17748 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17749 N20.getNode()->getValueType(0) == MVT::v16i8) { 17750 SDNode *Result = Emit_115(N, X86::PACKUSDWrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17751 return Result; 17752 } 17753 } 17754 } 17755 } 17756 } 17757 17758 // Pattern: (intrinsic_wo_chain:v8i16 637:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 17759 // Emits: (PMINUWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17760 // Pattern complexity = 33 cost = 1 size = 3 17761 if (CN1 == INT64_C(637)) { 17762 SDValue N1 = N.getOperand(1); 17763 SDValue N2 = N.getOperand(2); 17764 if (N2.getOpcode() == ISD::BIT_CONVERT && 17765 N2.hasOneUse()) { 17766 SDValue N20 = N2.getOperand(0); 17767 if (N20.getOpcode() == ISD::LOAD && 17768 N20.hasOneUse() && 17769 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17770 SDValue Chain20 = N20.getOperand(0); 17771 if (Predicate_unindexedload(N20.getNode()) && 17772 Predicate_load(N20.getNode()) && 17773 Predicate_memop(N20.getNode())) { 17774 SDValue N201 = N20.getOperand(1); 17775 SDValue CPTmpN201_0; 17776 SDValue CPTmpN201_1; 17777 SDValue CPTmpN201_2; 17778 SDValue CPTmpN201_3; 17779 SDValue CPTmpN201_4; 17780 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17781 N20.getNode()->getValueType(0) == MVT::v16i8) { 17782 SDNode *Result = Emit_115(N, X86::PMINUWrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17783 return Result; 17784 } 17785 } 17786 } 17787 } 17788 } 17789 17790 // Pattern: (intrinsic_wo_chain:v8i16 633:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 17791 // Emits: (PMAXUWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17792 // Pattern complexity = 33 cost = 1 size = 3 17793 if (CN1 == INT64_C(633)) { 17794 SDValue N1 = N.getOperand(1); 17795 SDValue N2 = N.getOperand(2); 17796 if (N2.getOpcode() == ISD::BIT_CONVERT && 17797 N2.hasOneUse()) { 17798 SDValue N20 = N2.getOperand(0); 17799 if (N20.getOpcode() == ISD::LOAD && 17800 N20.hasOneUse() && 17801 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 17802 SDValue Chain20 = N20.getOperand(0); 17803 if (Predicate_unindexedload(N20.getNode()) && 17804 Predicate_load(N20.getNode()) && 17805 Predicate_memop(N20.getNode())) { 17806 SDValue N201 = N20.getOperand(1); 17807 SDValue CPTmpN201_0; 17808 SDValue CPTmpN201_1; 17809 SDValue CPTmpN201_2; 17810 SDValue CPTmpN201_3; 17811 SDValue CPTmpN201_4; 17812 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 17813 N20.getNode()->getValueType(0) == MVT::v16i8) { 17814 SDNode *Result = Emit_115(N, X86::PMAXUWrm, MVT::v8i16, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 17815 return Result; 17816 } 17817 } 17818 } 17819 } 17820 } 17821 } 17822 } 17823 if ((Subtarget->hasSSE2())) { 17824 SDValue N0 = N.getOperand(0); 17825 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 17826 if (Tmp0) { 17827 int64_t CN1 = Tmp0->getSExtValue(); 17828 17829 // Pattern: (intrinsic_wo_chain:v8i16 546:iPTR, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v8i16:$src1) 17830 // Emits: (PADDSWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17831 // Pattern complexity = 33 cost = 1 size = 3 17832 if (CN1 == INT64_C(546)) { 17833 SDValue N1 = N.getOperand(1); 17834 if (N1.getOpcode() == ISD::BIT_CONVERT && 17835 N1.hasOneUse()) { 17836 SDValue N10 = N1.getOperand(0); 17837 if (N10.getOpcode() == ISD::LOAD && 17838 N10.hasOneUse() && 17839 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 17840 SDValue Chain10 = N10.getOperand(0); 17841 if (Predicate_unindexedload(N10.getNode()) && 17842 Predicate_load(N10.getNode()) && 17843 Predicate_memop(N10.getNode())) { 17844 SDValue N101 = N10.getOperand(1); 17845 SDValue CPTmpN101_0; 17846 SDValue CPTmpN101_1; 17847 SDValue CPTmpN101_2; 17848 SDValue CPTmpN101_3; 17849 SDValue CPTmpN101_4; 17850 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 17851 SDValue N2 = N.getOperand(2); 17852 if (N10.getNode()->getValueType(0) == MVT::v2i64) { 17853 SDNode *Result = Emit_116(N, X86::PADDSWrm, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 17854 return Result; 17855 } 17856 } 17857 } 17858 } 17859 } 17860 } 17861 17862 // Pattern: (intrinsic_wo_chain:v8i16 548:iPTR, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v8i16:$src1) 17863 // Emits: (PADDUSWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17864 // Pattern complexity = 33 cost = 1 size = 3 17865 if (CN1 == INT64_C(548)) { 17866 SDValue N1 = N.getOperand(1); 17867 if (N1.getOpcode() == ISD::BIT_CONVERT && 17868 N1.hasOneUse()) { 17869 SDValue N10 = N1.getOperand(0); 17870 if (N10.getOpcode() == ISD::LOAD && 17871 N10.hasOneUse() && 17872 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 17873 SDValue Chain10 = N10.getOperand(0); 17874 if (Predicate_unindexedload(N10.getNode()) && 17875 Predicate_load(N10.getNode()) && 17876 Predicate_memop(N10.getNode())) { 17877 SDValue N101 = N10.getOperand(1); 17878 SDValue CPTmpN101_0; 17879 SDValue CPTmpN101_1; 17880 SDValue CPTmpN101_2; 17881 SDValue CPTmpN101_3; 17882 SDValue CPTmpN101_4; 17883 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 17884 SDValue N2 = N.getOperand(2); 17885 if (N10.getNode()->getValueType(0) == MVT::v2i64) { 17886 SDNode *Result = Emit_116(N, X86::PADDUSWrm, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 17887 return Result; 17888 } 17889 } 17890 } 17891 } 17892 } 17893 } 17894 17895 // Pattern: (intrinsic_wo_chain:v8i16 564:iPTR, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v8i16:$src1) 17896 // Emits: (PMULHUWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17897 // Pattern complexity = 33 cost = 1 size = 3 17898 if (CN1 == INT64_C(564)) { 17899 SDValue N1 = N.getOperand(1); 17900 if (N1.getOpcode() == ISD::BIT_CONVERT && 17901 N1.hasOneUse()) { 17902 SDValue N10 = N1.getOperand(0); 17903 if (N10.getOpcode() == ISD::LOAD && 17904 N10.hasOneUse() && 17905 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 17906 SDValue Chain10 = N10.getOperand(0); 17907 if (Predicate_unindexedload(N10.getNode()) && 17908 Predicate_load(N10.getNode()) && 17909 Predicate_memop(N10.getNode())) { 17910 SDValue N101 = N10.getOperand(1); 17911 SDValue CPTmpN101_0; 17912 SDValue CPTmpN101_1; 17913 SDValue CPTmpN101_2; 17914 SDValue CPTmpN101_3; 17915 SDValue CPTmpN101_4; 17916 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 17917 SDValue N2 = N.getOperand(2); 17918 if (N10.getNode()->getValueType(0) == MVT::v2i64) { 17919 SDNode *Result = Emit_116(N, X86::PMULHUWrm, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 17920 return Result; 17921 } 17922 } 17923 } 17924 } 17925 } 17926 } 17927 17928 // Pattern: (intrinsic_wo_chain:v8i16 563:iPTR, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v8i16:$src1) 17929 // Emits: (PMULHWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17930 // Pattern complexity = 33 cost = 1 size = 3 17931 if (CN1 == INT64_C(563)) { 17932 SDValue N1 = N.getOperand(1); 17933 if (N1.getOpcode() == ISD::BIT_CONVERT && 17934 N1.hasOneUse()) { 17935 SDValue N10 = N1.getOperand(0); 17936 if (N10.getOpcode() == ISD::LOAD && 17937 N10.hasOneUse() && 17938 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 17939 SDValue Chain10 = N10.getOperand(0); 17940 if (Predicate_unindexedload(N10.getNode()) && 17941 Predicate_load(N10.getNode()) && 17942 Predicate_memop(N10.getNode())) { 17943 SDValue N101 = N10.getOperand(1); 17944 SDValue CPTmpN101_0; 17945 SDValue CPTmpN101_1; 17946 SDValue CPTmpN101_2; 17947 SDValue CPTmpN101_3; 17948 SDValue CPTmpN101_4; 17949 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 17950 SDValue N2 = N.getOperand(2); 17951 if (N10.getNode()->getValueType(0) == MVT::v2i64) { 17952 SDNode *Result = Emit_116(N, X86::PMULHWrm, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 17953 return Result; 17954 } 17955 } 17956 } 17957 } 17958 } 17959 } 17960 17961 // Pattern: (intrinsic_wo_chain:v8i16 550:iPTR, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v8i16:$src1) 17962 // Emits: (PAVGWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17963 // Pattern complexity = 33 cost = 1 size = 3 17964 if (CN1 == INT64_C(550)) { 17965 SDValue N1 = N.getOperand(1); 17966 if (N1.getOpcode() == ISD::BIT_CONVERT && 17967 N1.hasOneUse()) { 17968 SDValue N10 = N1.getOperand(0); 17969 if (N10.getOpcode() == ISD::LOAD && 17970 N10.hasOneUse() && 17971 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 17972 SDValue Chain10 = N10.getOperand(0); 17973 if (Predicate_unindexedload(N10.getNode()) && 17974 Predicate_load(N10.getNode()) && 17975 Predicate_memop(N10.getNode())) { 17976 SDValue N101 = N10.getOperand(1); 17977 SDValue CPTmpN101_0; 17978 SDValue CPTmpN101_1; 17979 SDValue CPTmpN101_2; 17980 SDValue CPTmpN101_3; 17981 SDValue CPTmpN101_4; 17982 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 17983 SDValue N2 = N.getOperand(2); 17984 if (N10.getNode()->getValueType(0) == MVT::v2i64) { 17985 SDNode *Result = Emit_116(N, X86::PAVGWrm, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 17986 return Result; 17987 } 17988 } 17989 } 17990 } 17991 } 17992 } 17993 17994 // Pattern: (intrinsic_wo_chain:v8i16 560:iPTR, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v8i16:$src1) 17995 // Emits: (PMINSWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 17996 // Pattern complexity = 33 cost = 1 size = 3 17997 if (CN1 == INT64_C(560)) { 17998 SDValue N1 = N.getOperand(1); 17999 if (N1.getOpcode() == ISD::BIT_CONVERT && 18000 N1.hasOneUse()) { 18001 SDValue N10 = N1.getOperand(0); 18002 if (N10.getOpcode() == ISD::LOAD && 18003 N10.hasOneUse() && 18004 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 18005 SDValue Chain10 = N10.getOperand(0); 18006 if (Predicate_unindexedload(N10.getNode()) && 18007 Predicate_load(N10.getNode()) && 18008 Predicate_memop(N10.getNode())) { 18009 SDValue N101 = N10.getOperand(1); 18010 SDValue CPTmpN101_0; 18011 SDValue CPTmpN101_1; 18012 SDValue CPTmpN101_2; 18013 SDValue CPTmpN101_3; 18014 SDValue CPTmpN101_4; 18015 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 18016 SDValue N2 = N.getOperand(2); 18017 if (N10.getNode()->getValueType(0) == MVT::v2i64) { 18018 SDNode *Result = Emit_116(N, X86::PMINSWrm, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 18019 return Result; 18020 } 18021 } 18022 } 18023 } 18024 } 18025 } 18026 18027 // Pattern: (intrinsic_wo_chain:v8i16 558:iPTR, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v8i16:$src1) 18028 // Emits: (PMAXSWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 18029 // Pattern complexity = 33 cost = 1 size = 3 18030 if (CN1 == INT64_C(558)) { 18031 SDValue N1 = N.getOperand(1); 18032 if (N1.getOpcode() == ISD::BIT_CONVERT && 18033 N1.hasOneUse()) { 18034 SDValue N10 = N1.getOperand(0); 18035 if (N10.getOpcode() == ISD::LOAD && 18036 N10.hasOneUse() && 18037 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 18038 SDValue Chain10 = N10.getOperand(0); 18039 if (Predicate_unindexedload(N10.getNode()) && 18040 Predicate_load(N10.getNode()) && 18041 Predicate_memop(N10.getNode())) { 18042 SDValue N101 = N10.getOperand(1); 18043 SDValue CPTmpN101_0; 18044 SDValue CPTmpN101_1; 18045 SDValue CPTmpN101_2; 18046 SDValue CPTmpN101_3; 18047 SDValue CPTmpN101_4; 18048 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 18049 SDValue N2 = N.getOperand(2); 18050 if (N10.getNode()->getValueType(0) == MVT::v2i64) { 18051 SDNode *Result = Emit_116(N, X86::PMAXSWrm, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 18052 return Result; 18053 } 18054 } 18055 } 18056 } 18057 } 18058 } 18059 } 18060 } 18061 18062 // Pattern: (intrinsic_wo_chain:v8i16 748:iPTR, (bitconvert:v8i16 (ld:v8i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>), VR128:v8i16:$src1) 18063 // Emits: (PMULHRSWrm128:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 18064 // Pattern complexity = 33 cost = 1 size = 3 18065 if ((Subtarget->hasSSSE3())) { 18066 SDValue N0 = N.getOperand(0); 18067 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 18068 if (Tmp0) { 18069 int64_t CN1 = Tmp0->getSExtValue(); 18070 if (CN1 == INT64_C(748)) { 18071 SDValue N1 = N.getOperand(1); 18072 if (N1.getOpcode() == ISD::BIT_CONVERT && 18073 N1.hasOneUse()) { 18074 SDValue N10 = N1.getOperand(0); 18075 if (N10.getOpcode() == ISD::LOAD && 18076 N10.hasOneUse() && 18077 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 18078 SDValue Chain10 = N10.getOperand(0); 18079 if (Predicate_unindexedload(N10.getNode()) && 18080 Predicate_load(N10.getNode()) && 18081 Predicate_memop64(N10.getNode())) { 18082 SDValue N101 = N10.getOperand(1); 18083 SDValue CPTmpN101_0; 18084 SDValue CPTmpN101_1; 18085 SDValue CPTmpN101_2; 18086 SDValue CPTmpN101_3; 18087 SDValue CPTmpN101_4; 18088 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 18089 SDValue N2 = N.getOperand(2); 18090 if (N10.getNode()->getValueType(0) == MVT::v8i16) { 18091 SDNode *Result = Emit_116(N, X86::PMULHRSWrm128, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 18092 return Result; 18093 } 18094 } 18095 } 18096 } 18097 } 18098 } 18099 } 18100 } 18101 if ((Subtarget->hasSSE41())) { 18102 SDValue N0 = N.getOperand(0); 18103 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 18104 if (Tmp0) { 18105 int64_t CN1 = Tmp0->getSExtValue(); 18106 18107 // Pattern: (intrinsic_wo_chain:v8i16 637:iPTR, (bitconvert:v8i16 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v8i16:$src1) 18108 // Emits: (PMINUWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 18109 // Pattern complexity = 33 cost = 1 size = 3 18110 if (CN1 == INT64_C(637)) { 18111 SDValue N1 = N.getOperand(1); 18112 if (N1.getOpcode() == ISD::BIT_CONVERT && 18113 N1.hasOneUse()) { 18114 SDValue N10 = N1.getOperand(0); 18115 if (N10.getOpcode() == ISD::LOAD && 18116 N10.hasOneUse() && 18117 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 18118 SDValue Chain10 = N10.getOperand(0); 18119 if (Predicate_unindexedload(N10.getNode()) && 18120 Predicate_load(N10.getNode()) && 18121 Predicate_memop(N10.getNode())) { 18122 SDValue N101 = N10.getOperand(1); 18123 SDValue CPTmpN101_0; 18124 SDValue CPTmpN101_1; 18125 SDValue CPTmpN101_2; 18126 SDValue CPTmpN101_3; 18127 SDValue CPTmpN101_4; 18128 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 18129 SDValue N2 = N.getOperand(2); 18130 if (N10.getNode()->getValueType(0) == MVT::v16i8) { 18131 SDNode *Result = Emit_116(N, X86::PMINUWrm, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 18132 return Result; 18133 } 18134 } 18135 } 18136 } 18137 } 18138 } 18139 18140 // Pattern: (intrinsic_wo_chain:v8i16 633:iPTR, (bitconvert:v8i16 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v8i16:$src1) 18141 // Emits: (PMAXUWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 18142 // Pattern complexity = 33 cost = 1 size = 3 18143 if (CN1 == INT64_C(633)) { 18144 SDValue N1 = N.getOperand(1); 18145 if (N1.getOpcode() == ISD::BIT_CONVERT && 18146 N1.hasOneUse()) { 18147 SDValue N10 = N1.getOperand(0); 18148 if (N10.getOpcode() == ISD::LOAD && 18149 N10.hasOneUse() && 18150 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 18151 SDValue Chain10 = N10.getOperand(0); 18152 if (Predicate_unindexedload(N10.getNode()) && 18153 Predicate_load(N10.getNode()) && 18154 Predicate_memop(N10.getNode())) { 18155 SDValue N101 = N10.getOperand(1); 18156 SDValue CPTmpN101_0; 18157 SDValue CPTmpN101_1; 18158 SDValue CPTmpN101_2; 18159 SDValue CPTmpN101_3; 18160 SDValue CPTmpN101_4; 18161 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 18162 SDValue N2 = N.getOperand(2); 18163 if (N10.getNode()->getValueType(0) == MVT::v16i8) { 18164 SDNode *Result = Emit_116(N, X86::PMAXUWrm, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 18165 return Result; 18166 } 18167 } 18168 } 18169 } 18170 } 18171 } 18172 18173 // Pattern: (intrinsic_wo_chain:v8i16 640:iPTR, (bitconvert:v16i8 (X86vzload:v2i64 addr:iPTR:$src))) 18174 // Emits: (PMOVSXBWrm:v8i16 addr:iPTR:$src) 18175 // Pattern complexity = 32 cost = 1 size = 3 18176 if (CN1 == INT64_C(640)) { 18177 SDValue N1 = N.getOperand(1); 18178 if (N1.getOpcode() == ISD::BIT_CONVERT && 18179 N1.hasOneUse()) { 18180 SDValue N10 = N1.getOperand(0); 18181 if (N10.getOpcode() == X86ISD::VZEXT_LOAD && 18182 N10.hasOneUse() && 18183 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 18184 SDValue Chain10 = N10.getOperand(0); 18185 SDValue N101 = N10.getOperand(1); 18186 SDValue CPTmpN101_0; 18187 SDValue CPTmpN101_1; 18188 SDValue CPTmpN101_2; 18189 SDValue CPTmpN101_3; 18190 SDValue CPTmpN101_4; 18191 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 18192 N10.getNode()->getValueType(0) == MVT::v2i64) { 18193 SDNode *Result = Emit_129(N, X86::PMOVSXBWrm, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 18194 return Result; 18195 } 18196 } 18197 } 18198 } 18199 18200 // Pattern: (intrinsic_wo_chain:v8i16 646:iPTR, (bitconvert:v16i8 (X86vzload:v2i64 addr:iPTR:$src))) 18201 // Emits: (PMOVZXBWrm:v8i16 addr:iPTR:$src) 18202 // Pattern complexity = 32 cost = 1 size = 3 18203 if (CN1 == INT64_C(646)) { 18204 SDValue N1 = N.getOperand(1); 18205 if (N1.getOpcode() == ISD::BIT_CONVERT && 18206 N1.hasOneUse()) { 18207 SDValue N10 = N1.getOperand(0); 18208 if (N10.getOpcode() == X86ISD::VZEXT_LOAD && 18209 N10.hasOneUse() && 18210 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 18211 SDValue Chain10 = N10.getOperand(0); 18212 SDValue N101 = N10.getOperand(1); 18213 SDValue CPTmpN101_0; 18214 SDValue CPTmpN101_1; 18215 SDValue CPTmpN101_2; 18216 SDValue CPTmpN101_3; 18217 SDValue CPTmpN101_4; 18218 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 18219 N10.getNode()->getValueType(0) == MVT::v2i64) { 18220 SDNode *Result = Emit_129(N, X86::PMOVZXBWrm, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 18221 return Result; 18222 } 18223 } 18224 } 18225 } 18226 } 18227 } 18228 } 18229 if ((Subtarget->hasSSE2())) { 18230 SDValue N0 = N.getOperand(0); 18231 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 18232 if (Tmp0) { 18233 int64_t CN1 = Tmp0->getSExtValue(); 18234 18235 // Pattern: (intrinsic_wo_chain:v8i16 574:iPTR, VR128:v8i16:$src1, (imm:i32):$src2) 18236 // Emits: (PSLLWri:v8i16 VR128:v8i16:$src1, (imm:i32):$src2) 18237 // Pattern complexity = 11 cost = 1 size = 3 18238 if (CN1 == INT64_C(574)) { 18239 SDValue N1 = N.getOperand(1); 18240 SDValue N2 = N.getOperand(2); 18241 if (N2.getOpcode() == ISD::Constant) { 18242 SDNode *Result = Emit_126(N, X86::PSLLWri, MVT::v8i16); 18243 return Result; 18244 } 18245 } 18246 18247 // Pattern: (intrinsic_wo_chain:v8i16 586:iPTR, VR128:v8i16:$src1, (imm:i32):$src2) 18248 // Emits: (PSRLWri:v8i16 VR128:v8i16:$src1, (imm:i32):$src2) 18249 // Pattern complexity = 11 cost = 1 size = 3 18250 if (CN1 == INT64_C(586)) { 18251 SDValue N1 = N.getOperand(1); 18252 SDValue N2 = N.getOperand(2); 18253 if (N2.getOpcode() == ISD::Constant) { 18254 SDNode *Result = Emit_126(N, X86::PSRLWri, MVT::v8i16); 18255 return Result; 18256 } 18257 } 18258 18259 // Pattern: (intrinsic_wo_chain:v8i16 578:iPTR, VR128:v8i16:$src1, (imm:i32):$src2) 18260 // Emits: (PSRAWri:v8i16 VR128:v8i16:$src1, (imm:i32):$src2) 18261 // Pattern complexity = 11 cost = 1 size = 3 18262 if (CN1 == INT64_C(578)) { 18263 SDValue N1 = N.getOperand(1); 18264 SDValue N2 = N.getOperand(2); 18265 if (N2.getOpcode() == ISD::Constant) { 18266 SDNode *Result = Emit_126(N, X86::PSRAWri, MVT::v8i16); 18267 return Result; 18268 } 18269 } 18270 } 18271 } 18272 18273 // Pattern: (intrinsic_wo_chain:v8i16 624:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2, (imm:i32):$src3) 18274 // Emits: (PBLENDWrri:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2, (imm:i32):$src3) 18275 // Pattern complexity = 11 cost = 1 size = 3 18276 if ((Subtarget->hasSSE41())) { 18277 SDValue N0 = N.getOperand(0); 18278 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 18279 if (Tmp0) { 18280 int64_t CN1 = Tmp0->getSExtValue(); 18281 if (CN1 == INT64_C(624)) { 18282 SDValue N1 = N.getOperand(1); 18283 SDValue N2 = N.getOperand(2); 18284 SDValue N3 = N.getOperand(3); 18285 if (N3.getOpcode() == ISD::Constant) { 18286 SDNode *Result = Emit_117(N, X86::PBLENDWrri, MVT::v8i16); 18287 return Result; 18288 } 18289 } 18290 } 18291 } 18292 if ((Subtarget->hasSSE2())) { 18293 SDValue N0 = N.getOperand(0); 18294 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 18295 if (Tmp0) { 18296 int64_t CN1 = Tmp0->getSExtValue(); 18297 18298 // Pattern: (intrinsic_wo_chain:v8i16 546:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18299 // Emits: (PADDSWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18300 // Pattern complexity = 8 cost = 1 size = 3 18301 if (CN1 == INT64_C(546)) { 18302 SDNode *Result = Emit_109(N, X86::PADDSWrr, MVT::v8i16); 18303 return Result; 18304 } 18305 18306 // Pattern: (intrinsic_wo_chain:v8i16 548:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18307 // Emits: (PADDUSWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18308 // Pattern complexity = 8 cost = 1 size = 3 18309 if (CN1 == INT64_C(548)) { 18310 SDNode *Result = Emit_109(N, X86::PADDUSWrr, MVT::v8i16); 18311 return Result; 18312 } 18313 18314 // Pattern: (intrinsic_wo_chain:v8i16 588:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18315 // Emits: (PSUBSWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18316 // Pattern complexity = 8 cost = 1 size = 3 18317 if (CN1 == INT64_C(588)) { 18318 SDNode *Result = Emit_109(N, X86::PSUBSWrr, MVT::v8i16); 18319 return Result; 18320 } 18321 18322 // Pattern: (intrinsic_wo_chain:v8i16 590:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18323 // Emits: (PSUBUSWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18324 // Pattern complexity = 8 cost = 1 size = 3 18325 if (CN1 == INT64_C(590)) { 18326 SDNode *Result = Emit_109(N, X86::PSUBUSWrr, MVT::v8i16); 18327 return Result; 18328 } 18329 18330 // Pattern: (intrinsic_wo_chain:v8i16 564:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18331 // Emits: (PMULHUWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18332 // Pattern complexity = 8 cost = 1 size = 3 18333 if (CN1 == INT64_C(564)) { 18334 SDNode *Result = Emit_109(N, X86::PMULHUWrr, MVT::v8i16); 18335 return Result; 18336 } 18337 18338 // Pattern: (intrinsic_wo_chain:v8i16 563:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18339 // Emits: (PMULHWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18340 // Pattern complexity = 8 cost = 1 size = 3 18341 if (CN1 == INT64_C(563)) { 18342 SDNode *Result = Emit_109(N, X86::PMULHWrr, MVT::v8i16); 18343 return Result; 18344 } 18345 18346 // Pattern: (intrinsic_wo_chain:v8i16 550:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18347 // Emits: (PAVGWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18348 // Pattern complexity = 8 cost = 1 size = 3 18349 if (CN1 == INT64_C(550)) { 18350 SDNode *Result = Emit_109(N, X86::PAVGWrr, MVT::v8i16); 18351 return Result; 18352 } 18353 18354 // Pattern: (intrinsic_wo_chain:v8i16 560:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18355 // Emits: (PMINSWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18356 // Pattern complexity = 8 cost = 1 size = 3 18357 if (CN1 == INT64_C(560)) { 18358 SDNode *Result = Emit_109(N, X86::PMINSWrr, MVT::v8i16); 18359 return Result; 18360 } 18361 18362 // Pattern: (intrinsic_wo_chain:v8i16 558:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18363 // Emits: (PMAXSWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18364 // Pattern complexity = 8 cost = 1 size = 3 18365 if (CN1 == INT64_C(558)) { 18366 SDNode *Result = Emit_109(N, X86::PMAXSWrr, MVT::v8i16); 18367 return Result; 18368 } 18369 18370 // Pattern: (intrinsic_wo_chain:v8i16 571:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18371 // Emits: (PSLLWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18372 // Pattern complexity = 8 cost = 1 size = 3 18373 if (CN1 == INT64_C(571)) { 18374 SDNode *Result = Emit_109(N, X86::PSLLWrr, MVT::v8i16); 18375 return Result; 18376 } 18377 18378 // Pattern: (intrinsic_wo_chain:v8i16 583:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18379 // Emits: (PSRLWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18380 // Pattern complexity = 8 cost = 1 size = 3 18381 if (CN1 == INT64_C(583)) { 18382 SDNode *Result = Emit_109(N, X86::PSRLWrr, MVT::v8i16); 18383 return Result; 18384 } 18385 18386 // Pattern: (intrinsic_wo_chain:v8i16 576:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18387 // Emits: (PSRAWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18388 // Pattern complexity = 8 cost = 1 size = 3 18389 if (CN1 == INT64_C(576)) { 18390 SDNode *Result = Emit_109(N, X86::PSRAWrr, MVT::v8i16); 18391 return Result; 18392 } 18393 18394 // Pattern: (intrinsic_wo_chain:v8i16 553:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18395 // Emits: (PCMPEQWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18396 // Pattern complexity = 8 cost = 1 size = 3 18397 if (CN1 == INT64_C(553)) { 18398 SDNode *Result = Emit_109(N, X86::PCMPEQWrr, MVT::v8i16); 18399 return Result; 18400 } 18401 18402 // Pattern: (intrinsic_wo_chain:v8i16 556:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18403 // Emits: (PCMPGTWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18404 // Pattern complexity = 8 cost = 1 size = 3 18405 if (CN1 == INT64_C(556)) { 18406 SDNode *Result = Emit_109(N, X86::PCMPGTWrr, MVT::v8i16); 18407 return Result; 18408 } 18409 18410 // Pattern: (intrinsic_wo_chain:v8i16 543:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18411 // Emits: (PACKSSWBrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18412 // Pattern complexity = 8 cost = 1 size = 3 18413 if (CN1 == INT64_C(543)) { 18414 SDNode *Result = Emit_109(N, X86::PACKSSWBrr, MVT::v8i16); 18415 return Result; 18416 } 18417 18418 // Pattern: (intrinsic_wo_chain:v8i16 544:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18419 // Emits: (PACKUSWBrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18420 // Pattern complexity = 8 cost = 1 size = 3 18421 if (CN1 == INT64_C(544)) { 18422 SDNode *Result = Emit_109(N, X86::PACKUSWBrr, MVT::v8i16); 18423 return Result; 18424 } 18425 } 18426 } 18427 if ((Subtarget->hasSSSE3())) { 18428 SDValue N0 = N.getOperand(0); 18429 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 18430 if (Tmp0) { 18431 int64_t CN1 = Tmp0->getSExtValue(); 18432 18433 // Pattern: (intrinsic_wo_chain:v8i16 730:iPTR, VR128:v8i16:$src) 18434 // Emits: (PABSWrr128:v8i16 VR128:v8i16:$src) 18435 // Pattern complexity = 8 cost = 1 size = 3 18436 if (CN1 == INT64_C(730)) { 18437 SDNode *Result = Emit_106(N, X86::PABSWrr128, MVT::v8i16); 18438 return Result; 18439 } 18440 18441 // Pattern: (intrinsic_wo_chain:v8i16 738:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18442 // Emits: (PHADDWrr128:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18443 // Pattern complexity = 8 cost = 1 size = 3 18444 if (CN1 == INT64_C(738)) { 18445 SDNode *Result = Emit_109(N, X86::PHADDWrr128, MVT::v8i16); 18446 return Result; 18447 } 18448 18449 // Pattern: (intrinsic_wo_chain:v8i16 744:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18450 // Emits: (PHSUBWrr128:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18451 // Pattern complexity = 8 cost = 1 size = 3 18452 if (CN1 == INT64_C(744)) { 18453 SDNode *Result = Emit_109(N, X86::PHSUBWrr128, MVT::v8i16); 18454 return Result; 18455 } 18456 18457 // Pattern: (intrinsic_wo_chain:v8i16 742:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18458 // Emits: (PHSUBSWrr128:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18459 // Pattern complexity = 8 cost = 1 size = 3 18460 if (CN1 == INT64_C(742)) { 18461 SDNode *Result = Emit_109(N, X86::PHSUBSWrr128, MVT::v8i16); 18462 return Result; 18463 } 18464 18465 // Pattern: (intrinsic_wo_chain:v8i16 746:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18466 // Emits: (PMADDUBSWrr128:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18467 // Pattern complexity = 8 cost = 1 size = 3 18468 if (CN1 == INT64_C(746)) { 18469 SDNode *Result = Emit_109(N, X86::PMADDUBSWrr128, MVT::v8i16); 18470 return Result; 18471 } 18472 18473 // Pattern: (intrinsic_wo_chain:v8i16 748:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18474 // Emits: (PMULHRSWrr128:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18475 // Pattern complexity = 8 cost = 1 size = 3 18476 if (CN1 == INT64_C(748)) { 18477 SDNode *Result = Emit_109(N, X86::PMULHRSWrr128, MVT::v8i16); 18478 return Result; 18479 } 18480 18481 // Pattern: (intrinsic_wo_chain:v8i16 756:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18482 // Emits: (PSIGNWrr128:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18483 // Pattern complexity = 8 cost = 1 size = 3 18484 if (CN1 == INT64_C(756)) { 18485 SDNode *Result = Emit_109(N, X86::PSIGNWrr128, MVT::v8i16); 18486 return Result; 18487 } 18488 } 18489 } 18490 if ((Subtarget->hasSSE41())) { 18491 SDValue N0 = N.getOperand(0); 18492 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 18493 if (Tmp0) { 18494 int64_t CN1 = Tmp0->getSExtValue(); 18495 18496 // Pattern: (intrinsic_wo_chain:v8i16 629:iPTR, VR128:v8i16:$src) 18497 // Emits: (PHMINPOSUWrr128:v8i16 VR128:v8i16:$src) 18498 // Pattern complexity = 8 cost = 1 size = 3 18499 if (CN1 == INT64_C(629)) { 18500 SDNode *Result = Emit_106(N, X86::PHMINPOSUWrr128, MVT::v8i16); 18501 return Result; 18502 } 18503 18504 // Pattern: (intrinsic_wo_chain:v8i16 622:iPTR, VR128:v4i32:$src1, VR128:v4i32:$src2) 18505 // Emits: (PACKUSDWrr:v8i16 VR128:v4i32:$src1, VR128:v4i32:$src2) 18506 // Pattern complexity = 8 cost = 1 size = 3 18507 if (CN1 == INT64_C(622)) { 18508 SDNode *Result = Emit_109(N, X86::PACKUSDWrr, MVT::v8i16); 18509 return Result; 18510 } 18511 18512 // Pattern: (intrinsic_wo_chain:v8i16 637:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18513 // Emits: (PMINUWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18514 // Pattern complexity = 8 cost = 1 size = 3 18515 if (CN1 == INT64_C(637)) { 18516 SDNode *Result = Emit_109(N, X86::PMINUWrr, MVT::v8i16); 18517 return Result; 18518 } 18519 18520 // Pattern: (intrinsic_wo_chain:v8i16 633:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 18521 // Emits: (PMAXUWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 18522 // Pattern complexity = 8 cost = 1 size = 3 18523 if (CN1 == INT64_C(633)) { 18524 SDNode *Result = Emit_109(N, X86::PMAXUWrr, MVT::v8i16); 18525 return Result; 18526 } 18527 18528 // Pattern: (intrinsic_wo_chain:v8i16 640:iPTR, VR128:v16i8:$src) 18529 // Emits: (PMOVSXBWrr:v8i16 VR128:v16i8:$src) 18530 // Pattern complexity = 8 cost = 1 size = 3 18531 if (CN1 == INT64_C(640)) { 18532 SDNode *Result = Emit_106(N, X86::PMOVSXBWrr, MVT::v8i16); 18533 return Result; 18534 } 18535 18536 // Pattern: (intrinsic_wo_chain:v8i16 646:iPTR, VR128:v16i8:$src) 18537 // Emits: (PMOVZXBWrr:v8i16 VR128:v16i8:$src) 18538 // Pattern complexity = 8 cost = 1 size = 3 18539 if (CN1 == INT64_C(646)) { 18540 SDNode *Result = Emit_106(N, X86::PMOVZXBWrr, MVT::v8i16); 18541 return Result; 18542 } 18543 } 18544 } 18545 18546 CannotYetSelectIntrinsic(N); 18547 return NULL; 18548 } 18549 18550 SDNode *Select_ISD_INTRINSIC_WO_CHAIN_v2i32(const SDValue &N) { 18551 if (OptLevel != CodeGenOpt::None) { 18552 if ((Subtarget->hasSSSE3())) { 18553 SDValue N0 = N.getOperand(0); 18554 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 18555 if (Tmp0) { 18556 int64_t CN1 = Tmp0->getSExtValue(); 18557 18558 // Pattern: (intrinsic_wo_chain:v2i32 727:iPTR, (bitconvert:v2i32 (ld:v2i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 18559 // Emits: (PABSDrm64:v2i32 addr:iPTR:$src) 18560 // Pattern complexity = 33 cost = 1 size = 3 18561 if (CN1 == INT64_C(727)) { 18562 SDValue N1 = N.getOperand(1); 18563 if (N1.getOpcode() == ISD::BIT_CONVERT && 18564 N1.hasOneUse()) { 18565 SDValue N10 = N1.getOperand(0); 18566 if (N10.getOpcode() == ISD::LOAD && 18567 N10.hasOneUse() && 18568 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 18569 SDValue Chain10 = N10.getOperand(0); 18570 if (Predicate_unindexedload(N10.getNode()) && 18571 Predicate_load(N10.getNode()) && 18572 Predicate_memop64(N10.getNode())) { 18573 SDValue N101 = N10.getOperand(1); 18574 SDValue CPTmpN101_0; 18575 SDValue CPTmpN101_1; 18576 SDValue CPTmpN101_2; 18577 SDValue CPTmpN101_3; 18578 SDValue CPTmpN101_4; 18579 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 18580 N10.getNode()->getValueType(0) == MVT::v2i32) { 18581 SDNode *Result = Emit_114(N, X86::PABSDrm64, MVT::v2i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 18582 return Result; 18583 } 18584 } 18585 } 18586 } 18587 } 18588 18589 // Pattern: (intrinsic_wo_chain:v2i32 733:iPTR, VR64:v2i32:$src1, (bitconvert:v2i32 (ld:v2i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 18590 // Emits: (PHADDDrm64:v2i32 VR64:v2i32:$src1, addr:iPTR:$src2) 18591 // Pattern complexity = 33 cost = 1 size = 3 18592 if (CN1 == INT64_C(733)) { 18593 SDValue N1 = N.getOperand(1); 18594 SDValue N2 = N.getOperand(2); 18595 if (N2.getOpcode() == ISD::BIT_CONVERT && 18596 N2.hasOneUse()) { 18597 SDValue N20 = N2.getOperand(0); 18598 if (N20.getOpcode() == ISD::LOAD && 18599 N20.hasOneUse() && 18600 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 18601 SDValue Chain20 = N20.getOperand(0); 18602 if (Predicate_unindexedload(N20.getNode()) && 18603 Predicate_load(N20.getNode()) && 18604 Predicate_memop64(N20.getNode())) { 18605 SDValue N201 = N20.getOperand(1); 18606 SDValue CPTmpN201_0; 18607 SDValue CPTmpN201_1; 18608 SDValue CPTmpN201_2; 18609 SDValue CPTmpN201_3; 18610 SDValue CPTmpN201_4; 18611 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 18612 N20.getNode()->getValueType(0) == MVT::v2i32) { 18613 SDNode *Result = Emit_115(N, X86::PHADDDrm64, MVT::v2i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 18614 return Result; 18615 } 18616 } 18617 } 18618 } 18619 } 18620 18621 // Pattern: (intrinsic_wo_chain:v2i32 739:iPTR, VR64:v2i32:$src1, (bitconvert:v2i32 (ld:v2i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 18622 // Emits: (PHSUBDrm64:v2i32 VR64:v2i32:$src1, addr:iPTR:$src2) 18623 // Pattern complexity = 33 cost = 1 size = 3 18624 if (CN1 == INT64_C(739)) { 18625 SDValue N1 = N.getOperand(1); 18626 SDValue N2 = N.getOperand(2); 18627 if (N2.getOpcode() == ISD::BIT_CONVERT && 18628 N2.hasOneUse()) { 18629 SDValue N20 = N2.getOperand(0); 18630 if (N20.getOpcode() == ISD::LOAD && 18631 N20.hasOneUse() && 18632 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 18633 SDValue Chain20 = N20.getOperand(0); 18634 if (Predicate_unindexedload(N20.getNode()) && 18635 Predicate_load(N20.getNode()) && 18636 Predicate_memop64(N20.getNode())) { 18637 SDValue N201 = N20.getOperand(1); 18638 SDValue CPTmpN201_0; 18639 SDValue CPTmpN201_1; 18640 SDValue CPTmpN201_2; 18641 SDValue CPTmpN201_3; 18642 SDValue CPTmpN201_4; 18643 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 18644 N20.getNode()->getValueType(0) == MVT::v2i32) { 18645 SDNode *Result = Emit_115(N, X86::PHSUBDrm64, MVT::v2i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 18646 return Result; 18647 } 18648 } 18649 } 18650 } 18651 } 18652 18653 // Pattern: (intrinsic_wo_chain:v2i32 753:iPTR, VR64:v2i32:$src1, (bitconvert:v2i32 (ld:v2i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 18654 // Emits: (PSIGNDrm64:v2i32 VR64:v2i32:$src1, addr:iPTR:$src2) 18655 // Pattern complexity = 33 cost = 1 size = 3 18656 if (CN1 == INT64_C(753)) { 18657 SDValue N1 = N.getOperand(1); 18658 SDValue N2 = N.getOperand(2); 18659 if (N2.getOpcode() == ISD::BIT_CONVERT && 18660 N2.hasOneUse()) { 18661 SDValue N20 = N2.getOperand(0); 18662 if (N20.getOpcode() == ISD::LOAD && 18663 N20.hasOneUse() && 18664 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 18665 SDValue Chain20 = N20.getOperand(0); 18666 if (Predicate_unindexedload(N20.getNode()) && 18667 Predicate_load(N20.getNode()) && 18668 Predicate_memop64(N20.getNode())) { 18669 SDValue N201 = N20.getOperand(1); 18670 SDValue CPTmpN201_0; 18671 SDValue CPTmpN201_1; 18672 SDValue CPTmpN201_2; 18673 SDValue CPTmpN201_3; 18674 SDValue CPTmpN201_4; 18675 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 18676 N20.getNode()->getValueType(0) == MVT::v2i32) { 18677 SDNode *Result = Emit_115(N, X86::PSIGNDrm64, MVT::v2i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 18678 return Result; 18679 } 18680 } 18681 } 18682 } 18683 } 18684 } 18685 } 18686 if ((Subtarget->hasMMX())) { 18687 SDValue N0 = N.getOperand(0); 18688 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 18689 if (Tmp0) { 18690 int64_t CN1 = Tmp0->getSExtValue(); 18691 18692 // Pattern: (intrinsic_wo_chain:v2i32 479:iPTR, VR64:v2i32:$src1, (bitconvert:v2i32 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 18693 // Emits: (MMX_PMULUDQrm:v2i32 VR64:v2i32:$src1, addr:iPTR:$src2) 18694 // Pattern complexity = 33 cost = 1 size = 3 18695 if (CN1 == INT64_C(479)) { 18696 SDValue N1 = N.getOperand(1); 18697 SDValue N2 = N.getOperand(2); 18698 if (N2.getOpcode() == ISD::BIT_CONVERT && 18699 N2.hasOneUse()) { 18700 SDValue N20 = N2.getOperand(0); 18701 if (N20.getOpcode() == ISD::LOAD && 18702 N20.hasOneUse() && 18703 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 18704 SDValue Chain20 = N20.getOperand(0); 18705 if (Predicate_unindexedload(N20.getNode()) && 18706 Predicate_load(N20.getNode())) { 18707 SDValue N201 = N20.getOperand(1); 18708 SDValue CPTmpN201_0; 18709 SDValue CPTmpN201_1; 18710 SDValue CPTmpN201_2; 18711 SDValue CPTmpN201_3; 18712 SDValue CPTmpN201_4; 18713 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 18714 N20.getNode()->getValueType(0) == MVT::v1i64) { 18715 SDNode *Result = Emit_115(N, X86::MMX_PMULUDQrm, MVT::v2i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 18716 return Result; 18717 } 18718 } 18719 } 18720 } 18721 } 18722 18723 // Pattern: (intrinsic_wo_chain:v2i32 471:iPTR, VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 18724 // Emits: (MMX_PMADDWDrm:v2i32 VR64:v4i16:$src1, addr:iPTR:$src2) 18725 // Pattern complexity = 33 cost = 1 size = 3 18726 if (CN1 == INT64_C(471)) { 18727 SDValue N1 = N.getOperand(1); 18728 SDValue N2 = N.getOperand(2); 18729 if (N2.getOpcode() == ISD::BIT_CONVERT && 18730 N2.hasOneUse()) { 18731 SDValue N20 = N2.getOperand(0); 18732 if (N20.getOpcode() == ISD::LOAD && 18733 N20.hasOneUse() && 18734 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 18735 SDValue Chain20 = N20.getOperand(0); 18736 if (Predicate_unindexedload(N20.getNode()) && 18737 Predicate_load(N20.getNode())) { 18738 SDValue N201 = N20.getOperand(1); 18739 SDValue CPTmpN201_0; 18740 SDValue CPTmpN201_1; 18741 SDValue CPTmpN201_2; 18742 SDValue CPTmpN201_3; 18743 SDValue CPTmpN201_4; 18744 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 18745 N20.getNode()->getValueType(0) == MVT::v1i64) { 18746 SDNode *Result = Emit_115(N, X86::MMX_PMADDWDrm, MVT::v2i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 18747 return Result; 18748 } 18749 } 18750 } 18751 } 18752 } 18753 18754 // Pattern: (intrinsic_wo_chain:v2i32 491:iPTR, VR64:v2i32:$src1, (bitconvert:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 18755 // Emits: (MMX_PSRLDrm:v2i32 VR64:v2i32:$src1, addr:iPTR:$src2) 18756 // Pattern complexity = 33 cost = 1 size = 3 18757 if (CN1 == INT64_C(491)) { 18758 SDValue N1 = N.getOperand(1); 18759 SDValue N2 = N.getOperand(2); 18760 if (N2.getOpcode() == ISD::BIT_CONVERT && 18761 N2.hasOneUse()) { 18762 SDValue N20 = N2.getOperand(0); 18763 if (N20.getOpcode() == ISD::LOAD && 18764 N20.hasOneUse() && 18765 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 18766 SDValue Chain20 = N20.getOperand(0); 18767 if (Predicate_unindexedload(N20.getNode()) && 18768 Predicate_load(N20.getNode())) { 18769 SDValue N201 = N20.getOperand(1); 18770 SDValue CPTmpN201_0; 18771 SDValue CPTmpN201_1; 18772 SDValue CPTmpN201_2; 18773 SDValue CPTmpN201_3; 18774 SDValue CPTmpN201_4; 18775 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 18776 N20.getNode()->getValueType(0) == MVT::v1i64) { 18777 SDNode *Result = Emit_115(N, X86::MMX_PSRLDrm, MVT::v2i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 18778 return Result; 18779 } 18780 } 18781 } 18782 } 18783 } 18784 18785 // Pattern: (intrinsic_wo_chain:v2i32 481:iPTR, VR64:v2i32:$src1, (bitconvert:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 18786 // Emits: (MMX_PSLLDrm:v2i32 VR64:v2i32:$src1, addr:iPTR:$src2) 18787 // Pattern complexity = 33 cost = 1 size = 3 18788 if (CN1 == INT64_C(481)) { 18789 SDValue N1 = N.getOperand(1); 18790 SDValue N2 = N.getOperand(2); 18791 if (N2.getOpcode() == ISD::BIT_CONVERT && 18792 N2.hasOneUse()) { 18793 SDValue N20 = N2.getOperand(0); 18794 if (N20.getOpcode() == ISD::LOAD && 18795 N20.hasOneUse() && 18796 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 18797 SDValue Chain20 = N20.getOperand(0); 18798 if (Predicate_unindexedload(N20.getNode()) && 18799 Predicate_load(N20.getNode())) { 18800 SDValue N201 = N20.getOperand(1); 18801 SDValue CPTmpN201_0; 18802 SDValue CPTmpN201_1; 18803 SDValue CPTmpN201_2; 18804 SDValue CPTmpN201_3; 18805 SDValue CPTmpN201_4; 18806 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 18807 N20.getNode()->getValueType(0) == MVT::v1i64) { 18808 SDNode *Result = Emit_115(N, X86::MMX_PSLLDrm, MVT::v2i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 18809 return Result; 18810 } 18811 } 18812 } 18813 } 18814 } 18815 18816 // Pattern: (intrinsic_wo_chain:v2i32 487:iPTR, VR64:v2i32:$src1, (bitconvert:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 18817 // Emits: (MMX_PSRADrm:v2i32 VR64:v2i32:$src1, addr:iPTR:$src2) 18818 // Pattern complexity = 33 cost = 1 size = 3 18819 if (CN1 == INT64_C(487)) { 18820 SDValue N1 = N.getOperand(1); 18821 SDValue N2 = N.getOperand(2); 18822 if (N2.getOpcode() == ISD::BIT_CONVERT && 18823 N2.hasOneUse()) { 18824 SDValue N20 = N2.getOperand(0); 18825 if (N20.getOpcode() == ISD::LOAD && 18826 N20.hasOneUse() && 18827 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 18828 SDValue Chain20 = N20.getOperand(0); 18829 if (Predicate_unindexedload(N20.getNode()) && 18830 Predicate_load(N20.getNode())) { 18831 SDValue N201 = N20.getOperand(1); 18832 SDValue CPTmpN201_0; 18833 SDValue CPTmpN201_1; 18834 SDValue CPTmpN201_2; 18835 SDValue CPTmpN201_3; 18836 SDValue CPTmpN201_4; 18837 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 18838 N20.getNode()->getValueType(0) == MVT::v1i64) { 18839 SDNode *Result = Emit_115(N, X86::MMX_PSRADrm, MVT::v2i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 18840 return Result; 18841 } 18842 } 18843 } 18844 } 18845 } 18846 18847 // Pattern: (intrinsic_wo_chain:v2i32 466:iPTR, VR64:v2i32:$src1, (bitconvert:v2i32 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 18848 // Emits: (MMX_PCMPEQDrm:v2i32 VR64:v2i32:$src1, addr:iPTR:$src2) 18849 // Pattern complexity = 33 cost = 1 size = 3 18850 if (CN1 == INT64_C(466)) { 18851 SDValue N1 = N.getOperand(1); 18852 SDValue N2 = N.getOperand(2); 18853 if (N2.getOpcode() == ISD::BIT_CONVERT && 18854 N2.hasOneUse()) { 18855 SDValue N20 = N2.getOperand(0); 18856 if (N20.getOpcode() == ISD::LOAD && 18857 N20.hasOneUse() && 18858 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 18859 SDValue Chain20 = N20.getOperand(0); 18860 if (Predicate_unindexedload(N20.getNode()) && 18861 Predicate_load(N20.getNode())) { 18862 SDValue N201 = N20.getOperand(1); 18863 SDValue CPTmpN201_0; 18864 SDValue CPTmpN201_1; 18865 SDValue CPTmpN201_2; 18866 SDValue CPTmpN201_3; 18867 SDValue CPTmpN201_4; 18868 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 18869 N20.getNode()->getValueType(0) == MVT::v1i64) { 18870 SDNode *Result = Emit_115(N, X86::MMX_PCMPEQDrm, MVT::v2i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 18871 return Result; 18872 } 18873 } 18874 } 18875 } 18876 } 18877 18878 // Pattern: (intrinsic_wo_chain:v2i32 469:iPTR, VR64:v2i32:$src1, (bitconvert:v2i32 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 18879 // Emits: (MMX_PCMPGTDrm:v2i32 VR64:v2i32:$src1, addr:iPTR:$src2) 18880 // Pattern complexity = 33 cost = 1 size = 3 18881 if (CN1 == INT64_C(469)) { 18882 SDValue N1 = N.getOperand(1); 18883 SDValue N2 = N.getOperand(2); 18884 if (N2.getOpcode() == ISD::BIT_CONVERT && 18885 N2.hasOneUse()) { 18886 SDValue N20 = N2.getOperand(0); 18887 if (N20.getOpcode() == ISD::LOAD && 18888 N20.hasOneUse() && 18889 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 18890 SDValue Chain20 = N20.getOperand(0); 18891 if (Predicate_unindexedload(N20.getNode()) && 18892 Predicate_load(N20.getNode())) { 18893 SDValue N201 = N20.getOperand(1); 18894 SDValue CPTmpN201_0; 18895 SDValue CPTmpN201_1; 18896 SDValue CPTmpN201_2; 18897 SDValue CPTmpN201_3; 18898 SDValue CPTmpN201_4; 18899 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 18900 N20.getNode()->getValueType(0) == MVT::v1i64) { 18901 SDNode *Result = Emit_115(N, X86::MMX_PCMPGTDrm, MVT::v2i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 18902 return Result; 18903 } 18904 } 18905 } 18906 } 18907 } 18908 18909 // Pattern: (intrinsic_wo_chain:v2i32 479:iPTR, (bitconvert:v2i32 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v2i32:$src1) 18910 // Emits: (MMX_PMULUDQrm:v2i32 VR64:v2i32:$src1, addr:iPTR:$src2) 18911 // Pattern complexity = 33 cost = 1 size = 3 18912 if (CN1 == INT64_C(479)) { 18913 SDValue N1 = N.getOperand(1); 18914 if (N1.getOpcode() == ISD::BIT_CONVERT && 18915 N1.hasOneUse()) { 18916 SDValue N10 = N1.getOperand(0); 18917 if (N10.getOpcode() == ISD::LOAD && 18918 N10.hasOneUse() && 18919 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 18920 SDValue Chain10 = N10.getOperand(0); 18921 if (Predicate_unindexedload(N10.getNode()) && 18922 Predicate_load(N10.getNode())) { 18923 SDValue N101 = N10.getOperand(1); 18924 SDValue CPTmpN101_0; 18925 SDValue CPTmpN101_1; 18926 SDValue CPTmpN101_2; 18927 SDValue CPTmpN101_3; 18928 SDValue CPTmpN101_4; 18929 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 18930 SDValue N2 = N.getOperand(2); 18931 if (N10.getNode()->getValueType(0) == MVT::v1i64) { 18932 SDNode *Result = Emit_116(N, X86::MMX_PMULUDQrm, MVT::v2i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 18933 return Result; 18934 } 18935 } 18936 } 18937 } 18938 } 18939 } 18940 18941 // Pattern: (intrinsic_wo_chain:v2i32 471:iPTR, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v4i16:$src1) 18942 // Emits: (MMX_PMADDWDrm:v2i32 VR64:v4i16:$src1, addr:iPTR:$src2) 18943 // Pattern complexity = 33 cost = 1 size = 3 18944 if (CN1 == INT64_C(471)) { 18945 SDValue N1 = N.getOperand(1); 18946 if (N1.getOpcode() == ISD::BIT_CONVERT && 18947 N1.hasOneUse()) { 18948 SDValue N10 = N1.getOperand(0); 18949 if (N10.getOpcode() == ISD::LOAD && 18950 N10.hasOneUse() && 18951 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 18952 SDValue Chain10 = N10.getOperand(0); 18953 if (Predicate_unindexedload(N10.getNode()) && 18954 Predicate_load(N10.getNode())) { 18955 SDValue N101 = N10.getOperand(1); 18956 SDValue CPTmpN101_0; 18957 SDValue CPTmpN101_1; 18958 SDValue CPTmpN101_2; 18959 SDValue CPTmpN101_3; 18960 SDValue CPTmpN101_4; 18961 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 18962 SDValue N2 = N.getOperand(2); 18963 if (N10.getNode()->getValueType(0) == MVT::v1i64) { 18964 SDNode *Result = Emit_116(N, X86::MMX_PMADDWDrm, MVT::v2i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 18965 return Result; 18966 } 18967 } 18968 } 18969 } 18970 } 18971 } 18972 } 18973 } 18974 if ((Subtarget->hasSSE1())) { 18975 SDValue N0 = N.getOperand(0); 18976 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 18977 if (Tmp0) { 18978 int64_t CN1 = Tmp0->getSExtValue(); 18979 18980 // Pattern: (intrinsic_wo_chain:v2i32 690:iPTR, (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 18981 // Emits: (Int_CVTPS2PIrm:v2i32 addr:iPTR:$src) 18982 // Pattern complexity = 30 cost = 1 size = 3 18983 if (CN1 == INT64_C(690)) { 18984 SDValue N1 = N.getOperand(1); 18985 if (N1.getOpcode() == ISD::LOAD && 18986 N1.hasOneUse() && 18987 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 18988 SDValue Chain1 = N1.getOperand(0); 18989 if (Predicate_unindexedload(N1.getNode()) && 18990 Predicate_load(N1.getNode())) { 18991 SDValue N11 = N1.getOperand(1); 18992 SDValue CPTmpN11_0; 18993 SDValue CPTmpN11_1; 18994 SDValue CPTmpN11_2; 18995 SDValue CPTmpN11_3; 18996 SDValue CPTmpN11_4; 18997 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 18998 SDNode *Result = Emit_107(N, X86::Int_CVTPS2PIrm, MVT::v2i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 18999 return Result; 19000 } 19001 } 19002 } 19003 } 19004 19005 // Pattern: (intrinsic_wo_chain:v2i32 696:iPTR, (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 19006 // Emits: (Int_CVTTPS2PIrm:v2i32 addr:iPTR:$src) 19007 // Pattern complexity = 30 cost = 1 size = 3 19008 if (CN1 == INT64_C(696)) { 19009 SDValue N1 = N.getOperand(1); 19010 if (N1.getOpcode() == ISD::LOAD && 19011 N1.hasOneUse() && 19012 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 19013 SDValue Chain1 = N1.getOperand(0); 19014 if (Predicate_unindexedload(N1.getNode()) && 19015 Predicate_load(N1.getNode())) { 19016 SDValue N11 = N1.getOperand(1); 19017 SDValue CPTmpN11_0; 19018 SDValue CPTmpN11_1; 19019 SDValue CPTmpN11_2; 19020 SDValue CPTmpN11_3; 19021 SDValue CPTmpN11_4; 19022 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 19023 SDNode *Result = Emit_107(N, X86::Int_CVTTPS2PIrm, MVT::v2i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 19024 return Result; 19025 } 19026 } 19027 } 19028 } 19029 } 19030 } 19031 if ((Subtarget->hasSSE2())) { 19032 SDValue N0 = N.getOperand(0); 19033 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 19034 if (Tmp0) { 19035 int64_t CN1 = Tmp0->getSExtValue(); 19036 19037 // Pattern: (intrinsic_wo_chain:v2i32 687:iPTR, (ld:v2f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 19038 // Emits: (Int_CVTPD2PIrm:v2i32 addr:iPTR:$src) 19039 // Pattern complexity = 30 cost = 1 size = 3 19040 if (CN1 == INT64_C(687)) { 19041 SDValue N1 = N.getOperand(1); 19042 if (N1.getOpcode() == ISD::LOAD && 19043 N1.hasOneUse() && 19044 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 19045 SDValue Chain1 = N1.getOperand(0); 19046 if (Predicate_unindexedload(N1.getNode()) && 19047 Predicate_load(N1.getNode()) && 19048 Predicate_memop(N1.getNode())) { 19049 SDValue N11 = N1.getOperand(1); 19050 SDValue CPTmpN11_0; 19051 SDValue CPTmpN11_1; 19052 SDValue CPTmpN11_2; 19053 SDValue CPTmpN11_3; 19054 SDValue CPTmpN11_4; 19055 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 19056 SDNode *Result = Emit_107(N, X86::Int_CVTPD2PIrm, MVT::v2i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 19057 return Result; 19058 } 19059 } 19060 } 19061 } 19062 19063 // Pattern: (intrinsic_wo_chain:v2i32 695:iPTR, (ld:v2f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 19064 // Emits: (Int_CVTTPD2PIrm:v2i32 addr:iPTR:$src) 19065 // Pattern complexity = 30 cost = 1 size = 3 19066 if (CN1 == INT64_C(695)) { 19067 SDValue N1 = N.getOperand(1); 19068 if (N1.getOpcode() == ISD::LOAD && 19069 N1.hasOneUse() && 19070 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 19071 SDValue Chain1 = N1.getOperand(0); 19072 if (Predicate_unindexedload(N1.getNode()) && 19073 Predicate_load(N1.getNode()) && 19074 Predicate_memop(N1.getNode())) { 19075 SDValue N11 = N1.getOperand(1); 19076 SDValue CPTmpN11_0; 19077 SDValue CPTmpN11_1; 19078 SDValue CPTmpN11_2; 19079 SDValue CPTmpN11_3; 19080 SDValue CPTmpN11_4; 19081 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 19082 SDNode *Result = Emit_107(N, X86::Int_CVTTPD2PIrm, MVT::v2i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 19083 return Result; 19084 } 19085 } 19086 } 19087 } 19088 } 19089 } 19090 } 19091 if ((Subtarget->hasMMX())) { 19092 SDValue N0 = N.getOperand(0); 19093 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 19094 if (Tmp0) { 19095 int64_t CN1 = Tmp0->getSExtValue(); 19096 19097 // Pattern: (intrinsic_wo_chain:v2i32 494:iPTR, VR64:v2i32:$src1, (imm:i32):$src2) 19098 // Emits: (MMX_PSRLDri:v2i32 VR64:v2i32:$src1, (imm:i32):$src2) 19099 // Pattern complexity = 11 cost = 1 size = 3 19100 if (CN1 == INT64_C(494)) { 19101 SDValue N1 = N.getOperand(1); 19102 SDValue N2 = N.getOperand(2); 19103 if (N2.getOpcode() == ISD::Constant) { 19104 SDNode *Result = Emit_126(N, X86::MMX_PSRLDri, MVT::v2i32); 19105 return Result; 19106 } 19107 } 19108 19109 // Pattern: (intrinsic_wo_chain:v2i32 484:iPTR, VR64:v2i32:$src1, (imm:i32):$src2) 19110 // Emits: (MMX_PSLLDri:v2i32 VR64:v2i32:$src1, (imm:i32):$src2) 19111 // Pattern complexity = 11 cost = 1 size = 3 19112 if (CN1 == INT64_C(484)) { 19113 SDValue N1 = N.getOperand(1); 19114 SDValue N2 = N.getOperand(2); 19115 if (N2.getOpcode() == ISD::Constant) { 19116 SDNode *Result = Emit_126(N, X86::MMX_PSLLDri, MVT::v2i32); 19117 return Result; 19118 } 19119 } 19120 19121 // Pattern: (intrinsic_wo_chain:v2i32 489:iPTR, VR64:v2i32:$src1, (imm:i32):$src2) 19122 // Emits: (MMX_PSRADri:v2i32 VR64:v2i32:$src1, (imm:i32):$src2) 19123 // Pattern complexity = 11 cost = 1 size = 3 19124 if (CN1 == INT64_C(489)) { 19125 SDValue N1 = N.getOperand(1); 19126 SDValue N2 = N.getOperand(2); 19127 if (N2.getOpcode() == ISD::Constant) { 19128 SDNode *Result = Emit_126(N, X86::MMX_PSRADri, MVT::v2i32); 19129 return Result; 19130 } 19131 } 19132 } 19133 } 19134 if ((Subtarget->hasSSE1())) { 19135 SDValue N0 = N.getOperand(0); 19136 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 19137 if (Tmp0) { 19138 int64_t CN1 = Tmp0->getSExtValue(); 19139 19140 // Pattern: (intrinsic_wo_chain:v2i32 690:iPTR, VR128:v4f32:$src) 19141 // Emits: (Int_CVTPS2PIrr:v2i32 VR128:v4f32:$src) 19142 // Pattern complexity = 8 cost = 1 size = 3 19143 if (CN1 == INT64_C(690)) { 19144 SDNode *Result = Emit_106(N, X86::Int_CVTPS2PIrr, MVT::v2i32); 19145 return Result; 19146 } 19147 19148 // Pattern: (intrinsic_wo_chain:v2i32 696:iPTR, VR128:v4f32:$src) 19149 // Emits: (Int_CVTTPS2PIrr:v2i32 VR128:v4f32:$src) 19150 // Pattern complexity = 8 cost = 1 size = 3 19151 if (CN1 == INT64_C(696)) { 19152 SDNode *Result = Emit_106(N, X86::Int_CVTTPS2PIrr, MVT::v2i32); 19153 return Result; 19154 } 19155 } 19156 } 19157 if ((Subtarget->hasSSE2())) { 19158 SDValue N0 = N.getOperand(0); 19159 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 19160 if (Tmp0) { 19161 int64_t CN1 = Tmp0->getSExtValue(); 19162 19163 // Pattern: (intrinsic_wo_chain:v2i32 687:iPTR, VR128:v2f64:$src) 19164 // Emits: (Int_CVTPD2PIrr:v2i32 VR128:v2f64:$src) 19165 // Pattern complexity = 8 cost = 1 size = 3 19166 if (CN1 == INT64_C(687)) { 19167 SDNode *Result = Emit_106(N, X86::Int_CVTPD2PIrr, MVT::v2i32); 19168 return Result; 19169 } 19170 19171 // Pattern: (intrinsic_wo_chain:v2i32 695:iPTR, VR128:v2f64:$src) 19172 // Emits: (Int_CVTTPD2PIrr:v2i32 VR128:v2f64:$src) 19173 // Pattern complexity = 8 cost = 1 size = 3 19174 if (CN1 == INT64_C(695)) { 19175 SDNode *Result = Emit_106(N, X86::Int_CVTTPD2PIrr, MVT::v2i32); 19176 return Result; 19177 } 19178 } 19179 } 19180 if ((Subtarget->hasSSSE3())) { 19181 SDValue N0 = N.getOperand(0); 19182 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 19183 if (Tmp0) { 19184 int64_t CN1 = Tmp0->getSExtValue(); 19185 19186 // Pattern: (intrinsic_wo_chain:v2i32 727:iPTR, VR64:v2i32:$src) 19187 // Emits: (PABSDrr64:v2i32 VR64:v2i32:$src) 19188 // Pattern complexity = 8 cost = 1 size = 3 19189 if (CN1 == INT64_C(727)) { 19190 SDNode *Result = Emit_106(N, X86::PABSDrr64, MVT::v2i32); 19191 return Result; 19192 } 19193 19194 // Pattern: (intrinsic_wo_chain:v2i32 733:iPTR, VR64:v2i32:$src1, VR64:v2i32:$src2) 19195 // Emits: (PHADDDrr64:v2i32 VR64:v2i32:$src1, VR64:v2i32:$src2) 19196 // Pattern complexity = 8 cost = 1 size = 3 19197 if (CN1 == INT64_C(733)) { 19198 SDNode *Result = Emit_109(N, X86::PHADDDrr64, MVT::v2i32); 19199 return Result; 19200 } 19201 19202 // Pattern: (intrinsic_wo_chain:v2i32 739:iPTR, VR64:v2i32:$src1, VR64:v2i32:$src2) 19203 // Emits: (PHSUBDrr64:v2i32 VR64:v2i32:$src1, VR64:v2i32:$src2) 19204 // Pattern complexity = 8 cost = 1 size = 3 19205 if (CN1 == INT64_C(739)) { 19206 SDNode *Result = Emit_109(N, X86::PHSUBDrr64, MVT::v2i32); 19207 return Result; 19208 } 19209 19210 // Pattern: (intrinsic_wo_chain:v2i32 753:iPTR, VR64:v2i32:$src1, VR64:v2i32:$src2) 19211 // Emits: (PSIGNDrr64:v2i32 VR64:v2i32:$src1, VR64:v2i32:$src2) 19212 // Pattern complexity = 8 cost = 1 size = 3 19213 if (CN1 == INT64_C(753)) { 19214 SDNode *Result = Emit_109(N, X86::PSIGNDrr64, MVT::v2i32); 19215 return Result; 19216 } 19217 } 19218 } 19219 if ((Subtarget->hasMMX())) { 19220 SDValue N0 = N.getOperand(0); 19221 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 19222 if (Tmp0) { 19223 int64_t CN1 = Tmp0->getSExtValue(); 19224 19225 // Pattern: (intrinsic_wo_chain:v2i32 479:iPTR, VR64:v2i32:$src1, VR64:v2i32:$src2) 19226 // Emits: (MMX_PMULUDQrr:v2i32 VR64:v2i32:$src1, VR64:v2i32:$src2) 19227 // Pattern complexity = 8 cost = 1 size = 3 19228 if (CN1 == INT64_C(479)) { 19229 SDNode *Result = Emit_109(N, X86::MMX_PMULUDQrr, MVT::v2i32); 19230 return Result; 19231 } 19232 19233 // Pattern: (intrinsic_wo_chain:v2i32 471:iPTR, VR64:v4i16:$src1, VR64:v4i16:$src2) 19234 // Emits: (MMX_PMADDWDrr:v2i32 VR64:v4i16:$src1, VR64:v4i16:$src2) 19235 // Pattern complexity = 8 cost = 1 size = 3 19236 if (CN1 == INT64_C(471)) { 19237 SDNode *Result = Emit_109(N, X86::MMX_PMADDWDrr, MVT::v2i32); 19238 return Result; 19239 } 19240 19241 // Pattern: (intrinsic_wo_chain:v2i32 491:iPTR, VR64:v2i32:$src1, VR64:v1i64:$src2) 19242 // Emits: (MMX_PSRLDrr:v2i32 VR64:v2i32:$src1, VR64:v1i64:$src2) 19243 // Pattern complexity = 8 cost = 1 size = 3 19244 if (CN1 == INT64_C(491)) { 19245 SDNode *Result = Emit_109(N, X86::MMX_PSRLDrr, MVT::v2i32); 19246 return Result; 19247 } 19248 19249 // Pattern: (intrinsic_wo_chain:v2i32 481:iPTR, VR64:v2i32:$src1, VR64:v1i64:$src2) 19250 // Emits: (MMX_PSLLDrr:v2i32 VR64:v2i32:$src1, VR64:v1i64:$src2) 19251 // Pattern complexity = 8 cost = 1 size = 3 19252 if (CN1 == INT64_C(481)) { 19253 SDNode *Result = Emit_109(N, X86::MMX_PSLLDrr, MVT::v2i32); 19254 return Result; 19255 } 19256 19257 // Pattern: (intrinsic_wo_chain:v2i32 487:iPTR, VR64:v2i32:$src1, VR64:v1i64:$src2) 19258 // Emits: (MMX_PSRADrr:v2i32 VR64:v2i32:$src1, VR64:v1i64:$src2) 19259 // Pattern complexity = 8 cost = 1 size = 3 19260 if (CN1 == INT64_C(487)) { 19261 SDNode *Result = Emit_109(N, X86::MMX_PSRADrr, MVT::v2i32); 19262 return Result; 19263 } 19264 19265 // Pattern: (intrinsic_wo_chain:v2i32 466:iPTR, VR64:v2i32:$src1, VR64:v2i32:$src2) 19266 // Emits: (MMX_PCMPEQDrr:v2i32 VR64:v2i32:$src1, VR64:v2i32:$src2) 19267 // Pattern complexity = 8 cost = 1 size = 3 19268 if (CN1 == INT64_C(466)) { 19269 SDNode *Result = Emit_109(N, X86::MMX_PCMPEQDrr, MVT::v2i32); 19270 return Result; 19271 } 19272 19273 // Pattern: (intrinsic_wo_chain:v2i32 469:iPTR, VR64:v2i32:$src1, VR64:v2i32:$src2) 19274 // Emits: (MMX_PCMPGTDrr:v2i32 VR64:v2i32:$src1, VR64:v2i32:$src2) 19275 // Pattern complexity = 8 cost = 1 size = 3 19276 if (CN1 == INT64_C(469)) { 19277 SDNode *Result = Emit_109(N, X86::MMX_PCMPGTDrr, MVT::v2i32); 19278 return Result; 19279 } 19280 } 19281 } 19282 19283 CannotYetSelectIntrinsic(N); 19284 return NULL; 19285 } 19286 19287 SDNode *Emit_130(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 19288 SDValue N0 = N.getOperand(0); 19289 SDValue N1 = N.getOperand(1); 19290 SDValue Chain1 = N1.getOperand(0); 19291 SDValue N11 = N1.getOperand(1); 19292 SDValue N2 = N.getOperand(2); 19293 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 19294 SDValue Ops0[] = { N2, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1 }; 19295 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 19296 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 19297 return ResNode; 19298 } 19299 SDNode *Select_ISD_INTRINSIC_WO_CHAIN_v4i32(const SDValue &N) { 19300 if (OptLevel != CodeGenOpt::None) { 19301 if ((Subtarget->hasSSE41())) { 19302 SDValue N0 = N.getOperand(0); 19303 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 19304 if (Tmp0) { 19305 int64_t CN1 = Tmp0->getSExtValue(); 19306 19307 // Pattern: (intrinsic_wo_chain:v4i32 642:iPTR, (bitconvert:v8i16 (X86vzmovl:v2i64 (scalar_to_vector:v2i64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>)))) 19308 // Emits: (PMOVSXWDrm:v4i32 addr:iPTR:$src) 19309 // Pattern complexity = 39 cost = 1 size = 3 19310 if (CN1 == INT64_C(642)) { 19311 SDValue N1 = N.getOperand(1); 19312 if (N1.getOpcode() == ISD::BIT_CONVERT && 19313 N1.hasOneUse()) { 19314 SDValue N10 = N1.getOperand(0); 19315 if (N10.getOpcode() == X86ISD::VZEXT_MOVL && 19316 N10.hasOneUse()) { 19317 SDValue N100 = N10.getOperand(0); 19318 if (N100.getOpcode() == ISD::SCALAR_TO_VECTOR && 19319 N100.hasOneUse()) { 19320 SDValue N1000 = N100.getOperand(0); 19321 if (N1000.getOpcode() == ISD::LOAD && 19322 N1000.hasOneUse() && 19323 IsLegalAndProfitableToFold(N1000.getNode(), N100.getNode(), N.getNode())) { 19324 SDValue Chain1000 = N1000.getOperand(0); 19325 if (Predicate_unindexedload(N1000.getNode()) && 19326 Predicate_load(N1000.getNode()) && 19327 Predicate_loadi64(N1000.getNode())) { 19328 SDValue N10001 = N1000.getOperand(1); 19329 SDValue CPTmpN10001_0; 19330 SDValue CPTmpN10001_1; 19331 SDValue CPTmpN10001_2; 19332 SDValue CPTmpN10001_3; 19333 SDValue CPTmpN10001_4; 19334 if (SelectAddr(N, N10001, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4) && 19335 N10.getNode()->getValueType(0) == MVT::v2i64 && 19336 N1000.getNode()->getValueType(0) == MVT::i64) { 19337 SDNode *Result = Emit_128(N, X86::PMOVSXWDrm, MVT::v4i32, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4); 19338 return Result; 19339 } 19340 } 19341 } 19342 } 19343 } 19344 } 19345 } 19346 19347 // Pattern: (intrinsic_wo_chain:v4i32 648:iPTR, (bitconvert:v8i16 (X86vzmovl:v2i64 (scalar_to_vector:v2i64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>)))) 19348 // Emits: (PMOVZXWDrm:v4i32 addr:iPTR:$src) 19349 // Pattern complexity = 39 cost = 1 size = 3 19350 if (CN1 == INT64_C(648)) { 19351 SDValue N1 = N.getOperand(1); 19352 if (N1.getOpcode() == ISD::BIT_CONVERT && 19353 N1.hasOneUse()) { 19354 SDValue N10 = N1.getOperand(0); 19355 if (N10.getOpcode() == X86ISD::VZEXT_MOVL && 19356 N10.hasOneUse()) { 19357 SDValue N100 = N10.getOperand(0); 19358 if (N100.getOpcode() == ISD::SCALAR_TO_VECTOR && 19359 N100.hasOneUse()) { 19360 SDValue N1000 = N100.getOperand(0); 19361 if (N1000.getOpcode() == ISD::LOAD && 19362 N1000.hasOneUse() && 19363 IsLegalAndProfitableToFold(N1000.getNode(), N100.getNode(), N.getNode())) { 19364 SDValue Chain1000 = N1000.getOperand(0); 19365 if (Predicate_unindexedload(N1000.getNode()) && 19366 Predicate_load(N1000.getNode()) && 19367 Predicate_loadi64(N1000.getNode())) { 19368 SDValue N10001 = N1000.getOperand(1); 19369 SDValue CPTmpN10001_0; 19370 SDValue CPTmpN10001_1; 19371 SDValue CPTmpN10001_2; 19372 SDValue CPTmpN10001_3; 19373 SDValue CPTmpN10001_4; 19374 if (SelectAddr(N, N10001, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4) && 19375 N10.getNode()->getValueType(0) == MVT::v2i64 && 19376 N1000.getNode()->getValueType(0) == MVT::i64) { 19377 SDNode *Result = Emit_128(N, X86::PMOVZXWDrm, MVT::v4i32, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4); 19378 return Result; 19379 } 19380 } 19381 } 19382 } 19383 } 19384 } 19385 } 19386 19387 // Pattern: (intrinsic_wo_chain:v4i32 638:iPTR, (bitconvert:v16i8 (X86vzmovl:v4i32 (scalar_to_vector:v4i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>)))) 19388 // Emits: (PMOVSXBDrm:v4i32 addr:iPTR:$src) 19389 // Pattern complexity = 39 cost = 1 size = 3 19390 if (CN1 == INT64_C(638)) { 19391 SDValue N1 = N.getOperand(1); 19392 if (N1.getOpcode() == ISD::BIT_CONVERT && 19393 N1.hasOneUse()) { 19394 SDValue N10 = N1.getOperand(0); 19395 if (N10.getOpcode() == X86ISD::VZEXT_MOVL && 19396 N10.hasOneUse()) { 19397 SDValue N100 = N10.getOperand(0); 19398 if (N100.getOpcode() == ISD::SCALAR_TO_VECTOR && 19399 N100.hasOneUse()) { 19400 SDValue N1000 = N100.getOperand(0); 19401 if (N1000.getOpcode() == ISD::LOAD && 19402 N1000.hasOneUse() && 19403 IsLegalAndProfitableToFold(N1000.getNode(), N100.getNode(), N.getNode())) { 19404 SDValue Chain1000 = N1000.getOperand(0); 19405 if (Predicate_unindexedload(N1000.getNode()) && 19406 Predicate_loadi32(N1000.getNode())) { 19407 SDValue N10001 = N1000.getOperand(1); 19408 SDValue CPTmpN10001_0; 19409 SDValue CPTmpN10001_1; 19410 SDValue CPTmpN10001_2; 19411 SDValue CPTmpN10001_3; 19412 SDValue CPTmpN10001_4; 19413 if (SelectAddr(N, N10001, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4) && 19414 N10.getNode()->getValueType(0) == MVT::v4i32 && 19415 N1000.getNode()->getValueType(0) == MVT::i32) { 19416 SDNode *Result = Emit_128(N, X86::PMOVSXBDrm, MVT::v4i32, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4); 19417 return Result; 19418 } 19419 } 19420 } 19421 } 19422 } 19423 } 19424 } 19425 19426 // Pattern: (intrinsic_wo_chain:v4i32 644:iPTR, (bitconvert:v16i8 (X86vzmovl:v4i32 (scalar_to_vector:v4i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>)))) 19427 // Emits: (PMOVZXBDrm:v4i32 addr:iPTR:$src) 19428 // Pattern complexity = 39 cost = 1 size = 3 19429 if (CN1 == INT64_C(644)) { 19430 SDValue N1 = N.getOperand(1); 19431 if (N1.getOpcode() == ISD::BIT_CONVERT && 19432 N1.hasOneUse()) { 19433 SDValue N10 = N1.getOperand(0); 19434 if (N10.getOpcode() == X86ISD::VZEXT_MOVL && 19435 N10.hasOneUse()) { 19436 SDValue N100 = N10.getOperand(0); 19437 if (N100.getOpcode() == ISD::SCALAR_TO_VECTOR && 19438 N100.hasOneUse()) { 19439 SDValue N1000 = N100.getOperand(0); 19440 if (N1000.getOpcode() == ISD::LOAD && 19441 N1000.hasOneUse() && 19442 IsLegalAndProfitableToFold(N1000.getNode(), N100.getNode(), N.getNode())) { 19443 SDValue Chain1000 = N1000.getOperand(0); 19444 if (Predicate_unindexedload(N1000.getNode()) && 19445 Predicate_loadi32(N1000.getNode())) { 19446 SDValue N10001 = N1000.getOperand(1); 19447 SDValue CPTmpN10001_0; 19448 SDValue CPTmpN10001_1; 19449 SDValue CPTmpN10001_2; 19450 SDValue CPTmpN10001_3; 19451 SDValue CPTmpN10001_4; 19452 if (SelectAddr(N, N10001, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4) && 19453 N10.getNode()->getValueType(0) == MVT::v4i32 && 19454 N1000.getNode()->getValueType(0) == MVT::i32) { 19455 SDNode *Result = Emit_128(N, X86::PMOVZXBDrm, MVT::v4i32, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4); 19456 return Result; 19457 } 19458 } 19459 } 19460 } 19461 } 19462 } 19463 } 19464 19465 // Pattern: (intrinsic_wo_chain:v4i32 642:iPTR, (bitconvert:v8i16 (scalar_to_vector:v2i64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>))) 19466 // Emits: (PMOVSXWDrm:v4i32 addr:iPTR:$src) 19467 // Pattern complexity = 36 cost = 1 size = 3 19468 if (CN1 == INT64_C(642)) { 19469 SDValue N1 = N.getOperand(1); 19470 if (N1.getOpcode() == ISD::BIT_CONVERT && 19471 N1.hasOneUse()) { 19472 SDValue N10 = N1.getOperand(0); 19473 if (N10.getOpcode() == ISD::SCALAR_TO_VECTOR && 19474 N10.hasOneUse()) { 19475 SDValue N100 = N10.getOperand(0); 19476 if (N100.getOpcode() == ISD::LOAD && 19477 N100.hasOneUse() && 19478 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode())) { 19479 SDValue Chain100 = N100.getOperand(0); 19480 if (Predicate_unindexedload(N100.getNode()) && 19481 Predicate_load(N100.getNode()) && 19482 Predicate_loadi64(N100.getNode())) { 19483 SDValue N1001 = N100.getOperand(1); 19484 SDValue CPTmpN1001_0; 19485 SDValue CPTmpN1001_1; 19486 SDValue CPTmpN1001_2; 19487 SDValue CPTmpN1001_3; 19488 SDValue CPTmpN1001_4; 19489 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4) && 19490 N10.getNode()->getValueType(0) == MVT::v2i64 && 19491 N100.getNode()->getValueType(0) == MVT::i64) { 19492 SDNode *Result = Emit_127(N, X86::PMOVSXWDrm, MVT::v4i32, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 19493 return Result; 19494 } 19495 } 19496 } 19497 } 19498 } 19499 } 19500 19501 // Pattern: (intrinsic_wo_chain:v4i32 648:iPTR, (bitconvert:v8i16 (scalar_to_vector:v2i64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>))) 19502 // Emits: (PMOVZXWDrm:v4i32 addr:iPTR:$src) 19503 // Pattern complexity = 36 cost = 1 size = 3 19504 if (CN1 == INT64_C(648)) { 19505 SDValue N1 = N.getOperand(1); 19506 if (N1.getOpcode() == ISD::BIT_CONVERT && 19507 N1.hasOneUse()) { 19508 SDValue N10 = N1.getOperand(0); 19509 if (N10.getOpcode() == ISD::SCALAR_TO_VECTOR && 19510 N10.hasOneUse()) { 19511 SDValue N100 = N10.getOperand(0); 19512 if (N100.getOpcode() == ISD::LOAD && 19513 N100.hasOneUse() && 19514 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode())) { 19515 SDValue Chain100 = N100.getOperand(0); 19516 if (Predicate_unindexedload(N100.getNode()) && 19517 Predicate_load(N100.getNode()) && 19518 Predicate_loadi64(N100.getNode())) { 19519 SDValue N1001 = N100.getOperand(1); 19520 SDValue CPTmpN1001_0; 19521 SDValue CPTmpN1001_1; 19522 SDValue CPTmpN1001_2; 19523 SDValue CPTmpN1001_3; 19524 SDValue CPTmpN1001_4; 19525 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4) && 19526 N10.getNode()->getValueType(0) == MVT::v2i64 && 19527 N100.getNode()->getValueType(0) == MVT::i64) { 19528 SDNode *Result = Emit_127(N, X86::PMOVZXWDrm, MVT::v4i32, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 19529 return Result; 19530 } 19531 } 19532 } 19533 } 19534 } 19535 } 19536 19537 // Pattern: (intrinsic_wo_chain:v4i32 638:iPTR, (bitconvert:v16i8 (scalar_to_vector:v4i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>))) 19538 // Emits: (PMOVSXBDrm:v4i32 addr:iPTR:$src) 19539 // Pattern complexity = 36 cost = 1 size = 3 19540 if (CN1 == INT64_C(638)) { 19541 SDValue N1 = N.getOperand(1); 19542 if (N1.getOpcode() == ISD::BIT_CONVERT && 19543 N1.hasOneUse()) { 19544 SDValue N10 = N1.getOperand(0); 19545 if (N10.getOpcode() == ISD::SCALAR_TO_VECTOR && 19546 N10.hasOneUse()) { 19547 SDValue N100 = N10.getOperand(0); 19548 if (N100.getOpcode() == ISD::LOAD && 19549 N100.hasOneUse() && 19550 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode())) { 19551 SDValue Chain100 = N100.getOperand(0); 19552 if (Predicate_unindexedload(N100.getNode()) && 19553 Predicate_loadi32(N100.getNode())) { 19554 SDValue N1001 = N100.getOperand(1); 19555 SDValue CPTmpN1001_0; 19556 SDValue CPTmpN1001_1; 19557 SDValue CPTmpN1001_2; 19558 SDValue CPTmpN1001_3; 19559 SDValue CPTmpN1001_4; 19560 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4) && 19561 N10.getNode()->getValueType(0) == MVT::v4i32 && 19562 N100.getNode()->getValueType(0) == MVT::i32) { 19563 SDNode *Result = Emit_127(N, X86::PMOVSXBDrm, MVT::v4i32, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 19564 return Result; 19565 } 19566 } 19567 } 19568 } 19569 } 19570 } 19571 19572 // Pattern: (intrinsic_wo_chain:v4i32 644:iPTR, (bitconvert:v16i8 (scalar_to_vector:v4i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>))) 19573 // Emits: (PMOVZXBDrm:v4i32 addr:iPTR:$src) 19574 // Pattern complexity = 36 cost = 1 size = 3 19575 if (CN1 == INT64_C(644)) { 19576 SDValue N1 = N.getOperand(1); 19577 if (N1.getOpcode() == ISD::BIT_CONVERT && 19578 N1.hasOneUse()) { 19579 SDValue N10 = N1.getOperand(0); 19580 if (N10.getOpcode() == ISD::SCALAR_TO_VECTOR && 19581 N10.hasOneUse()) { 19582 SDValue N100 = N10.getOperand(0); 19583 if (N100.getOpcode() == ISD::LOAD && 19584 N100.hasOneUse() && 19585 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode())) { 19586 SDValue Chain100 = N100.getOperand(0); 19587 if (Predicate_unindexedload(N100.getNode()) && 19588 Predicate_loadi32(N100.getNode())) { 19589 SDValue N1001 = N100.getOperand(1); 19590 SDValue CPTmpN1001_0; 19591 SDValue CPTmpN1001_1; 19592 SDValue CPTmpN1001_2; 19593 SDValue CPTmpN1001_3; 19594 SDValue CPTmpN1001_4; 19595 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4) && 19596 N10.getNode()->getValueType(0) == MVT::v4i32 && 19597 N100.getNode()->getValueType(0) == MVT::i32) { 19598 SDNode *Result = Emit_127(N, X86::PMOVZXBDrm, MVT::v4i32, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 19599 return Result; 19600 } 19601 } 19602 } 19603 } 19604 } 19605 } 19606 } 19607 } 19608 if ((Subtarget->hasSSE2())) { 19609 SDValue N0 = N.getOperand(0); 19610 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 19611 if (Tmp0) { 19612 int64_t CN1 = Tmp0->getSExtValue(); 19613 19614 // Pattern: (intrinsic_wo_chain:v4i32 557:iPTR, VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 19615 // Emits: (PMADDWDrm:v4i32 VR128:v8i16:$src1, addr:iPTR:$src2) 19616 // Pattern complexity = 33 cost = 1 size = 3 19617 if (CN1 == INT64_C(557)) { 19618 SDValue N1 = N.getOperand(1); 19619 SDValue N2 = N.getOperand(2); 19620 if (N2.getOpcode() == ISD::BIT_CONVERT && 19621 N2.hasOneUse()) { 19622 SDValue N20 = N2.getOperand(0); 19623 if (N20.getOpcode() == ISD::LOAD && 19624 N20.hasOneUse() && 19625 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 19626 SDValue Chain20 = N20.getOperand(0); 19627 if (Predicate_unindexedload(N20.getNode()) && 19628 Predicate_load(N20.getNode()) && 19629 Predicate_memop(N20.getNode())) { 19630 SDValue N201 = N20.getOperand(1); 19631 SDValue CPTmpN201_0; 19632 SDValue CPTmpN201_1; 19633 SDValue CPTmpN201_2; 19634 SDValue CPTmpN201_3; 19635 SDValue CPTmpN201_4; 19636 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 19637 N20.getNode()->getValueType(0) == MVT::v2i64) { 19638 SDNode *Result = Emit_115(N, X86::PMADDWDrm, MVT::v4i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 19639 return Result; 19640 } 19641 } 19642 } 19643 } 19644 } 19645 19646 // Pattern: (intrinsic_wo_chain:v4i32 567:iPTR, VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 19647 // Emits: (PSLLDrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 19648 // Pattern complexity = 33 cost = 1 size = 3 19649 if (CN1 == INT64_C(567)) { 19650 SDValue N1 = N.getOperand(1); 19651 SDValue N2 = N.getOperand(2); 19652 if (N2.getOpcode() == ISD::BIT_CONVERT && 19653 N2.hasOneUse()) { 19654 SDValue N20 = N2.getOperand(0); 19655 if (N20.getOpcode() == ISD::LOAD && 19656 N20.hasOneUse() && 19657 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 19658 SDValue Chain20 = N20.getOperand(0); 19659 if (Predicate_unindexedload(N20.getNode()) && 19660 Predicate_load(N20.getNode()) && 19661 Predicate_memop(N20.getNode())) { 19662 SDValue N201 = N20.getOperand(1); 19663 SDValue CPTmpN201_0; 19664 SDValue CPTmpN201_1; 19665 SDValue CPTmpN201_2; 19666 SDValue CPTmpN201_3; 19667 SDValue CPTmpN201_4; 19668 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 19669 N20.getNode()->getValueType(0) == MVT::v2i64) { 19670 SDNode *Result = Emit_115(N, X86::PSLLDrm, MVT::v4i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 19671 return Result; 19672 } 19673 } 19674 } 19675 } 19676 } 19677 19678 // Pattern: (intrinsic_wo_chain:v4i32 579:iPTR, VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 19679 // Emits: (PSRLDrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 19680 // Pattern complexity = 33 cost = 1 size = 3 19681 if (CN1 == INT64_C(579)) { 19682 SDValue N1 = N.getOperand(1); 19683 SDValue N2 = N.getOperand(2); 19684 if (N2.getOpcode() == ISD::BIT_CONVERT && 19685 N2.hasOneUse()) { 19686 SDValue N20 = N2.getOperand(0); 19687 if (N20.getOpcode() == ISD::LOAD && 19688 N20.hasOneUse() && 19689 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 19690 SDValue Chain20 = N20.getOperand(0); 19691 if (Predicate_unindexedload(N20.getNode()) && 19692 Predicate_load(N20.getNode()) && 19693 Predicate_memop(N20.getNode())) { 19694 SDValue N201 = N20.getOperand(1); 19695 SDValue CPTmpN201_0; 19696 SDValue CPTmpN201_1; 19697 SDValue CPTmpN201_2; 19698 SDValue CPTmpN201_3; 19699 SDValue CPTmpN201_4; 19700 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 19701 N20.getNode()->getValueType(0) == MVT::v2i64) { 19702 SDNode *Result = Emit_115(N, X86::PSRLDrm, MVT::v4i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 19703 return Result; 19704 } 19705 } 19706 } 19707 } 19708 } 19709 19710 // Pattern: (intrinsic_wo_chain:v4i32 575:iPTR, VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 19711 // Emits: (PSRADrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 19712 // Pattern complexity = 33 cost = 1 size = 3 19713 if (CN1 == INT64_C(575)) { 19714 SDValue N1 = N.getOperand(1); 19715 SDValue N2 = N.getOperand(2); 19716 if (N2.getOpcode() == ISD::BIT_CONVERT && 19717 N2.hasOneUse()) { 19718 SDValue N20 = N2.getOperand(0); 19719 if (N20.getOpcode() == ISD::LOAD && 19720 N20.hasOneUse() && 19721 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 19722 SDValue Chain20 = N20.getOperand(0); 19723 if (Predicate_unindexedload(N20.getNode()) && 19724 Predicate_load(N20.getNode()) && 19725 Predicate_memop(N20.getNode())) { 19726 SDValue N201 = N20.getOperand(1); 19727 SDValue CPTmpN201_0; 19728 SDValue CPTmpN201_1; 19729 SDValue CPTmpN201_2; 19730 SDValue CPTmpN201_3; 19731 SDValue CPTmpN201_4; 19732 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 19733 N20.getNode()->getValueType(0) == MVT::v2i64) { 19734 SDNode *Result = Emit_115(N, X86::PSRADrm, MVT::v4i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 19735 return Result; 19736 } 19737 } 19738 } 19739 } 19740 } 19741 19742 // Pattern: (intrinsic_wo_chain:v4i32 552:iPTR, VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 19743 // Emits: (PCMPEQDrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 19744 // Pattern complexity = 33 cost = 1 size = 3 19745 if (CN1 == INT64_C(552)) { 19746 SDValue N1 = N.getOperand(1); 19747 SDValue N2 = N.getOperand(2); 19748 if (N2.getOpcode() == ISD::BIT_CONVERT && 19749 N2.hasOneUse()) { 19750 SDValue N20 = N2.getOperand(0); 19751 if (N20.getOpcode() == ISD::LOAD && 19752 N20.hasOneUse() && 19753 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 19754 SDValue Chain20 = N20.getOperand(0); 19755 if (Predicate_unindexedload(N20.getNode()) && 19756 Predicate_load(N20.getNode()) && 19757 Predicate_memop(N20.getNode())) { 19758 SDValue N201 = N20.getOperand(1); 19759 SDValue CPTmpN201_0; 19760 SDValue CPTmpN201_1; 19761 SDValue CPTmpN201_2; 19762 SDValue CPTmpN201_3; 19763 SDValue CPTmpN201_4; 19764 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 19765 N20.getNode()->getValueType(0) == MVT::v2i64) { 19766 SDNode *Result = Emit_115(N, X86::PCMPEQDrm, MVT::v4i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 19767 return Result; 19768 } 19769 } 19770 } 19771 } 19772 } 19773 19774 // Pattern: (intrinsic_wo_chain:v4i32 555:iPTR, VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 19775 // Emits: (PCMPGTDrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 19776 // Pattern complexity = 33 cost = 1 size = 3 19777 if (CN1 == INT64_C(555)) { 19778 SDValue N1 = N.getOperand(1); 19779 SDValue N2 = N.getOperand(2); 19780 if (N2.getOpcode() == ISD::BIT_CONVERT && 19781 N2.hasOneUse()) { 19782 SDValue N20 = N2.getOperand(0); 19783 if (N20.getOpcode() == ISD::LOAD && 19784 N20.hasOneUse() && 19785 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 19786 SDValue Chain20 = N20.getOperand(0); 19787 if (Predicate_unindexedload(N20.getNode()) && 19788 Predicate_load(N20.getNode()) && 19789 Predicate_memop(N20.getNode())) { 19790 SDValue N201 = N20.getOperand(1); 19791 SDValue CPTmpN201_0; 19792 SDValue CPTmpN201_1; 19793 SDValue CPTmpN201_2; 19794 SDValue CPTmpN201_3; 19795 SDValue CPTmpN201_4; 19796 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 19797 N20.getNode()->getValueType(0) == MVT::v2i64) { 19798 SDNode *Result = Emit_115(N, X86::PCMPGTDrm, MVT::v4i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 19799 return Result; 19800 } 19801 } 19802 } 19803 } 19804 } 19805 19806 // Pattern: (intrinsic_wo_chain:v4i32 542:iPTR, VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 19807 // Emits: (PACKSSDWrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 19808 // Pattern complexity = 33 cost = 1 size = 3 19809 if (CN1 == INT64_C(542)) { 19810 SDValue N1 = N.getOperand(1); 19811 SDValue N2 = N.getOperand(2); 19812 if (N2.getOpcode() == ISD::BIT_CONVERT && 19813 N2.hasOneUse()) { 19814 SDValue N20 = N2.getOperand(0); 19815 if (N20.getOpcode() == ISD::LOAD && 19816 N20.hasOneUse() && 19817 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 19818 SDValue Chain20 = N20.getOperand(0); 19819 if (Predicate_unindexedload(N20.getNode()) && 19820 Predicate_load(N20.getNode()) && 19821 Predicate_memop(N20.getNode())) { 19822 SDValue N201 = N20.getOperand(1); 19823 SDValue CPTmpN201_0; 19824 SDValue CPTmpN201_1; 19825 SDValue CPTmpN201_2; 19826 SDValue CPTmpN201_3; 19827 SDValue CPTmpN201_4; 19828 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 19829 N20.getNode()->getValueType(0) == MVT::v2i64) { 19830 SDNode *Result = Emit_115(N, X86::PACKSSDWrm, MVT::v4i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 19831 return Result; 19832 } 19833 } 19834 } 19835 } 19836 } 19837 } 19838 } 19839 if ((Subtarget->hasSSSE3())) { 19840 SDValue N0 = N.getOperand(0); 19841 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 19842 if (Tmp0) { 19843 int64_t CN1 = Tmp0->getSExtValue(); 19844 19845 // Pattern: (intrinsic_wo_chain:v4i32 728:iPTR, (bitconvert:v4i32 (ld:v4i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 19846 // Emits: (PABSDrm128:v4i32 addr:iPTR:$src) 19847 // Pattern complexity = 33 cost = 1 size = 3 19848 if (CN1 == INT64_C(728)) { 19849 SDValue N1 = N.getOperand(1); 19850 if (N1.getOpcode() == ISD::BIT_CONVERT && 19851 N1.hasOneUse()) { 19852 SDValue N10 = N1.getOperand(0); 19853 if (N10.getOpcode() == ISD::LOAD && 19854 N10.hasOneUse() && 19855 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 19856 SDValue Chain10 = N10.getOperand(0); 19857 if (Predicate_unindexedload(N10.getNode()) && 19858 Predicate_load(N10.getNode()) && 19859 Predicate_memop(N10.getNode())) { 19860 SDValue N101 = N10.getOperand(1); 19861 SDValue CPTmpN101_0; 19862 SDValue CPTmpN101_1; 19863 SDValue CPTmpN101_2; 19864 SDValue CPTmpN101_3; 19865 SDValue CPTmpN101_4; 19866 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 19867 N10.getNode()->getValueType(0) == MVT::v4i32) { 19868 SDNode *Result = Emit_114(N, X86::PABSDrm128, MVT::v4i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 19869 return Result; 19870 } 19871 } 19872 } 19873 } 19874 } 19875 19876 // Pattern: (intrinsic_wo_chain:v4i32 734:iPTR, VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v4i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 19877 // Emits: (PHADDDrm128:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 19878 // Pattern complexity = 33 cost = 1 size = 3 19879 if (CN1 == INT64_C(734)) { 19880 SDValue N1 = N.getOperand(1); 19881 SDValue N2 = N.getOperand(2); 19882 if (N2.getOpcode() == ISD::BIT_CONVERT && 19883 N2.hasOneUse()) { 19884 SDValue N20 = N2.getOperand(0); 19885 if (N20.getOpcode() == ISD::LOAD && 19886 N20.hasOneUse() && 19887 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 19888 SDValue Chain20 = N20.getOperand(0); 19889 if (Predicate_unindexedload(N20.getNode()) && 19890 Predicate_load(N20.getNode()) && 19891 Predicate_memop(N20.getNode())) { 19892 SDValue N201 = N20.getOperand(1); 19893 SDValue CPTmpN201_0; 19894 SDValue CPTmpN201_1; 19895 SDValue CPTmpN201_2; 19896 SDValue CPTmpN201_3; 19897 SDValue CPTmpN201_4; 19898 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 19899 N20.getNode()->getValueType(0) == MVT::v4i32) { 19900 SDNode *Result = Emit_115(N, X86::PHADDDrm128, MVT::v4i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 19901 return Result; 19902 } 19903 } 19904 } 19905 } 19906 } 19907 19908 // Pattern: (intrinsic_wo_chain:v4i32 736:iPTR, VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v8i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>)) 19909 // Emits: (PHADDSWrm128:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 19910 // Pattern complexity = 33 cost = 1 size = 3 19911 if (CN1 == INT64_C(736)) { 19912 SDValue N1 = N.getOperand(1); 19913 SDValue N2 = N.getOperand(2); 19914 if (N2.getOpcode() == ISD::BIT_CONVERT && 19915 N2.hasOneUse()) { 19916 SDValue N20 = N2.getOperand(0); 19917 if (N20.getOpcode() == ISD::LOAD && 19918 N20.hasOneUse() && 19919 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 19920 SDValue Chain20 = N20.getOperand(0); 19921 if (Predicate_unindexedload(N20.getNode()) && 19922 Predicate_load(N20.getNode()) && 19923 Predicate_memop64(N20.getNode())) { 19924 SDValue N201 = N20.getOperand(1); 19925 SDValue CPTmpN201_0; 19926 SDValue CPTmpN201_1; 19927 SDValue CPTmpN201_2; 19928 SDValue CPTmpN201_3; 19929 SDValue CPTmpN201_4; 19930 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 19931 N20.getNode()->getValueType(0) == MVT::v8i16) { 19932 SDNode *Result = Emit_115(N, X86::PHADDSWrm128, MVT::v4i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 19933 return Result; 19934 } 19935 } 19936 } 19937 } 19938 } 19939 19940 // Pattern: (intrinsic_wo_chain:v4i32 740:iPTR, VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v4i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 19941 // Emits: (PHSUBDrm128:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 19942 // Pattern complexity = 33 cost = 1 size = 3 19943 if (CN1 == INT64_C(740)) { 19944 SDValue N1 = N.getOperand(1); 19945 SDValue N2 = N.getOperand(2); 19946 if (N2.getOpcode() == ISD::BIT_CONVERT && 19947 N2.hasOneUse()) { 19948 SDValue N20 = N2.getOperand(0); 19949 if (N20.getOpcode() == ISD::LOAD && 19950 N20.hasOneUse() && 19951 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 19952 SDValue Chain20 = N20.getOperand(0); 19953 if (Predicate_unindexedload(N20.getNode()) && 19954 Predicate_load(N20.getNode()) && 19955 Predicate_memop(N20.getNode())) { 19956 SDValue N201 = N20.getOperand(1); 19957 SDValue CPTmpN201_0; 19958 SDValue CPTmpN201_1; 19959 SDValue CPTmpN201_2; 19960 SDValue CPTmpN201_3; 19961 SDValue CPTmpN201_4; 19962 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 19963 N20.getNode()->getValueType(0) == MVT::v4i32) { 19964 SDNode *Result = Emit_115(N, X86::PHSUBDrm128, MVT::v4i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 19965 return Result; 19966 } 19967 } 19968 } 19969 } 19970 } 19971 19972 // Pattern: (intrinsic_wo_chain:v4i32 754:iPTR, VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v4i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 19973 // Emits: (PSIGNDrm128:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 19974 // Pattern complexity = 33 cost = 1 size = 3 19975 if (CN1 == INT64_C(754)) { 19976 SDValue N1 = N.getOperand(1); 19977 SDValue N2 = N.getOperand(2); 19978 if (N2.getOpcode() == ISD::BIT_CONVERT && 19979 N2.hasOneUse()) { 19980 SDValue N20 = N2.getOperand(0); 19981 if (N20.getOpcode() == ISD::LOAD && 19982 N20.hasOneUse() && 19983 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 19984 SDValue Chain20 = N20.getOperand(0); 19985 if (Predicate_unindexedload(N20.getNode()) && 19986 Predicate_load(N20.getNode()) && 19987 Predicate_memop(N20.getNode())) { 19988 SDValue N201 = N20.getOperand(1); 19989 SDValue CPTmpN201_0; 19990 SDValue CPTmpN201_1; 19991 SDValue CPTmpN201_2; 19992 SDValue CPTmpN201_3; 19993 SDValue CPTmpN201_4; 19994 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 19995 N20.getNode()->getValueType(0) == MVT::v4i32) { 19996 SDNode *Result = Emit_115(N, X86::PSIGNDrm128, MVT::v4i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 19997 return Result; 19998 } 19999 } 20000 } 20001 } 20002 } 20003 } 20004 } 20005 if ((Subtarget->hasSSE41())) { 20006 SDValue N0 = N.getOperand(0); 20007 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 20008 if (Tmp0) { 20009 int64_t CN1 = Tmp0->getSExtValue(); 20010 20011 // Pattern: (intrinsic_wo_chain:v4i32 635:iPTR, VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 20012 // Emits: (PMINSDrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 20013 // Pattern complexity = 33 cost = 1 size = 3 20014 if (CN1 == INT64_C(635)) { 20015 SDValue N1 = N.getOperand(1); 20016 SDValue N2 = N.getOperand(2); 20017 if (N2.getOpcode() == ISD::BIT_CONVERT && 20018 N2.hasOneUse()) { 20019 SDValue N20 = N2.getOperand(0); 20020 if (N20.getOpcode() == ISD::LOAD && 20021 N20.hasOneUse() && 20022 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 20023 SDValue Chain20 = N20.getOperand(0); 20024 if (Predicate_unindexedload(N20.getNode()) && 20025 Predicate_load(N20.getNode()) && 20026 Predicate_memop(N20.getNode())) { 20027 SDValue N201 = N20.getOperand(1); 20028 SDValue CPTmpN201_0; 20029 SDValue CPTmpN201_1; 20030 SDValue CPTmpN201_2; 20031 SDValue CPTmpN201_3; 20032 SDValue CPTmpN201_4; 20033 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 20034 N20.getNode()->getValueType(0) == MVT::v16i8) { 20035 SDNode *Result = Emit_115(N, X86::PMINSDrm, MVT::v4i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 20036 return Result; 20037 } 20038 } 20039 } 20040 } 20041 } 20042 20043 // Pattern: (intrinsic_wo_chain:v4i32 636:iPTR, VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 20044 // Emits: (PMINUDrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 20045 // Pattern complexity = 33 cost = 1 size = 3 20046 if (CN1 == INT64_C(636)) { 20047 SDValue N1 = N.getOperand(1); 20048 SDValue N2 = N.getOperand(2); 20049 if (N2.getOpcode() == ISD::BIT_CONVERT && 20050 N2.hasOneUse()) { 20051 SDValue N20 = N2.getOperand(0); 20052 if (N20.getOpcode() == ISD::LOAD && 20053 N20.hasOneUse() && 20054 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 20055 SDValue Chain20 = N20.getOperand(0); 20056 if (Predicate_unindexedload(N20.getNode()) && 20057 Predicate_load(N20.getNode()) && 20058 Predicate_memop(N20.getNode())) { 20059 SDValue N201 = N20.getOperand(1); 20060 SDValue CPTmpN201_0; 20061 SDValue CPTmpN201_1; 20062 SDValue CPTmpN201_2; 20063 SDValue CPTmpN201_3; 20064 SDValue CPTmpN201_4; 20065 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 20066 N20.getNode()->getValueType(0) == MVT::v16i8) { 20067 SDNode *Result = Emit_115(N, X86::PMINUDrm, MVT::v4i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 20068 return Result; 20069 } 20070 } 20071 } 20072 } 20073 } 20074 20075 // Pattern: (intrinsic_wo_chain:v4i32 631:iPTR, VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 20076 // Emits: (PMAXSDrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 20077 // Pattern complexity = 33 cost = 1 size = 3 20078 if (CN1 == INT64_C(631)) { 20079 SDValue N1 = N.getOperand(1); 20080 SDValue N2 = N.getOperand(2); 20081 if (N2.getOpcode() == ISD::BIT_CONVERT && 20082 N2.hasOneUse()) { 20083 SDValue N20 = N2.getOperand(0); 20084 if (N20.getOpcode() == ISD::LOAD && 20085 N20.hasOneUse() && 20086 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 20087 SDValue Chain20 = N20.getOperand(0); 20088 if (Predicate_unindexedload(N20.getNode()) && 20089 Predicate_load(N20.getNode()) && 20090 Predicate_memop(N20.getNode())) { 20091 SDValue N201 = N20.getOperand(1); 20092 SDValue CPTmpN201_0; 20093 SDValue CPTmpN201_1; 20094 SDValue CPTmpN201_2; 20095 SDValue CPTmpN201_3; 20096 SDValue CPTmpN201_4; 20097 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 20098 N20.getNode()->getValueType(0) == MVT::v16i8) { 20099 SDNode *Result = Emit_115(N, X86::PMAXSDrm, MVT::v4i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 20100 return Result; 20101 } 20102 } 20103 } 20104 } 20105 } 20106 20107 // Pattern: (intrinsic_wo_chain:v4i32 632:iPTR, VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 20108 // Emits: (PMAXUDrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 20109 // Pattern complexity = 33 cost = 1 size = 3 20110 if (CN1 == INT64_C(632)) { 20111 SDValue N1 = N.getOperand(1); 20112 SDValue N2 = N.getOperand(2); 20113 if (N2.getOpcode() == ISD::BIT_CONVERT && 20114 N2.hasOneUse()) { 20115 SDValue N20 = N2.getOperand(0); 20116 if (N20.getOpcode() == ISD::LOAD && 20117 N20.hasOneUse() && 20118 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 20119 SDValue Chain20 = N20.getOperand(0); 20120 if (Predicate_unindexedload(N20.getNode()) && 20121 Predicate_load(N20.getNode()) && 20122 Predicate_memop(N20.getNode())) { 20123 SDValue N201 = N20.getOperand(1); 20124 SDValue CPTmpN201_0; 20125 SDValue CPTmpN201_1; 20126 SDValue CPTmpN201_2; 20127 SDValue CPTmpN201_3; 20128 SDValue CPTmpN201_4; 20129 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 20130 N20.getNode()->getValueType(0) == MVT::v16i8) { 20131 SDNode *Result = Emit_115(N, X86::PMAXUDrm, MVT::v4i32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 20132 return Result; 20133 } 20134 } 20135 } 20136 } 20137 } 20138 } 20139 } 20140 20141 // Pattern: (intrinsic_wo_chain:v4i32 557:iPTR, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v8i16:$src1) 20142 // Emits: (PMADDWDrm:v4i32 VR128:v8i16:$src1, addr:iPTR:$src2) 20143 // Pattern complexity = 33 cost = 1 size = 3 20144 if ((Subtarget->hasSSE2())) { 20145 SDValue N0 = N.getOperand(0); 20146 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 20147 if (Tmp0) { 20148 int64_t CN1 = Tmp0->getSExtValue(); 20149 if (CN1 == INT64_C(557)) { 20150 SDValue N1 = N.getOperand(1); 20151 if (N1.getOpcode() == ISD::BIT_CONVERT && 20152 N1.hasOneUse()) { 20153 SDValue N10 = N1.getOperand(0); 20154 if (N10.getOpcode() == ISD::LOAD && 20155 N10.hasOneUse() && 20156 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 20157 SDValue Chain10 = N10.getOperand(0); 20158 if (Predicate_unindexedload(N10.getNode()) && 20159 Predicate_load(N10.getNode()) && 20160 Predicate_memop(N10.getNode())) { 20161 SDValue N101 = N10.getOperand(1); 20162 SDValue CPTmpN101_0; 20163 SDValue CPTmpN101_1; 20164 SDValue CPTmpN101_2; 20165 SDValue CPTmpN101_3; 20166 SDValue CPTmpN101_4; 20167 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 20168 SDValue N2 = N.getOperand(2); 20169 if (N10.getNode()->getValueType(0) == MVT::v2i64) { 20170 SDNode *Result = Emit_116(N, X86::PMADDWDrm, MVT::v4i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 20171 return Result; 20172 } 20173 } 20174 } 20175 } 20176 } 20177 } 20178 } 20179 } 20180 if ((Subtarget->hasSSE41())) { 20181 SDValue N0 = N.getOperand(0); 20182 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 20183 if (Tmp0) { 20184 int64_t CN1 = Tmp0->getSExtValue(); 20185 20186 // Pattern: (intrinsic_wo_chain:v4i32 635:iPTR, (bitconvert:v4i32 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v4i32:$src1) 20187 // Emits: (PMINSDrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 20188 // Pattern complexity = 33 cost = 1 size = 3 20189 if (CN1 == INT64_C(635)) { 20190 SDValue N1 = N.getOperand(1); 20191 if (N1.getOpcode() == ISD::BIT_CONVERT && 20192 N1.hasOneUse()) { 20193 SDValue N10 = N1.getOperand(0); 20194 if (N10.getOpcode() == ISD::LOAD && 20195 N10.hasOneUse() && 20196 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 20197 SDValue Chain10 = N10.getOperand(0); 20198 if (Predicate_unindexedload(N10.getNode()) && 20199 Predicate_load(N10.getNode()) && 20200 Predicate_memop(N10.getNode())) { 20201 SDValue N101 = N10.getOperand(1); 20202 SDValue CPTmpN101_0; 20203 SDValue CPTmpN101_1; 20204 SDValue CPTmpN101_2; 20205 SDValue CPTmpN101_3; 20206 SDValue CPTmpN101_4; 20207 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 20208 SDValue N2 = N.getOperand(2); 20209 if (N10.getNode()->getValueType(0) == MVT::v16i8) { 20210 SDNode *Result = Emit_116(N, X86::PMINSDrm, MVT::v4i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 20211 return Result; 20212 } 20213 } 20214 } 20215 } 20216 } 20217 } 20218 20219 // Pattern: (intrinsic_wo_chain:v4i32 636:iPTR, (bitconvert:v4i32 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v4i32:$src1) 20220 // Emits: (PMINUDrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 20221 // Pattern complexity = 33 cost = 1 size = 3 20222 if (CN1 == INT64_C(636)) { 20223 SDValue N1 = N.getOperand(1); 20224 if (N1.getOpcode() == ISD::BIT_CONVERT && 20225 N1.hasOneUse()) { 20226 SDValue N10 = N1.getOperand(0); 20227 if (N10.getOpcode() == ISD::LOAD && 20228 N10.hasOneUse() && 20229 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 20230 SDValue Chain10 = N10.getOperand(0); 20231 if (Predicate_unindexedload(N10.getNode()) && 20232 Predicate_load(N10.getNode()) && 20233 Predicate_memop(N10.getNode())) { 20234 SDValue N101 = N10.getOperand(1); 20235 SDValue CPTmpN101_0; 20236 SDValue CPTmpN101_1; 20237 SDValue CPTmpN101_2; 20238 SDValue CPTmpN101_3; 20239 SDValue CPTmpN101_4; 20240 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 20241 SDValue N2 = N.getOperand(2); 20242 if (N10.getNode()->getValueType(0) == MVT::v16i8) { 20243 SDNode *Result = Emit_116(N, X86::PMINUDrm, MVT::v4i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 20244 return Result; 20245 } 20246 } 20247 } 20248 } 20249 } 20250 } 20251 20252 // Pattern: (intrinsic_wo_chain:v4i32 631:iPTR, (bitconvert:v4i32 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v4i32:$src1) 20253 // Emits: (PMAXSDrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 20254 // Pattern complexity = 33 cost = 1 size = 3 20255 if (CN1 == INT64_C(631)) { 20256 SDValue N1 = N.getOperand(1); 20257 if (N1.getOpcode() == ISD::BIT_CONVERT && 20258 N1.hasOneUse()) { 20259 SDValue N10 = N1.getOperand(0); 20260 if (N10.getOpcode() == ISD::LOAD && 20261 N10.hasOneUse() && 20262 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 20263 SDValue Chain10 = N10.getOperand(0); 20264 if (Predicate_unindexedload(N10.getNode()) && 20265 Predicate_load(N10.getNode()) && 20266 Predicate_memop(N10.getNode())) { 20267 SDValue N101 = N10.getOperand(1); 20268 SDValue CPTmpN101_0; 20269 SDValue CPTmpN101_1; 20270 SDValue CPTmpN101_2; 20271 SDValue CPTmpN101_3; 20272 SDValue CPTmpN101_4; 20273 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 20274 SDValue N2 = N.getOperand(2); 20275 if (N10.getNode()->getValueType(0) == MVT::v16i8) { 20276 SDNode *Result = Emit_116(N, X86::PMAXSDrm, MVT::v4i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 20277 return Result; 20278 } 20279 } 20280 } 20281 } 20282 } 20283 } 20284 20285 // Pattern: (intrinsic_wo_chain:v4i32 632:iPTR, (bitconvert:v4i32 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v4i32:$src1) 20286 // Emits: (PMAXUDrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 20287 // Pattern complexity = 33 cost = 1 size = 3 20288 if (CN1 == INT64_C(632)) { 20289 SDValue N1 = N.getOperand(1); 20290 if (N1.getOpcode() == ISD::BIT_CONVERT && 20291 N1.hasOneUse()) { 20292 SDValue N10 = N1.getOperand(0); 20293 if (N10.getOpcode() == ISD::LOAD && 20294 N10.hasOneUse() && 20295 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 20296 SDValue Chain10 = N10.getOperand(0); 20297 if (Predicate_unindexedload(N10.getNode()) && 20298 Predicate_load(N10.getNode()) && 20299 Predicate_memop(N10.getNode())) { 20300 SDValue N101 = N10.getOperand(1); 20301 SDValue CPTmpN101_0; 20302 SDValue CPTmpN101_1; 20303 SDValue CPTmpN101_2; 20304 SDValue CPTmpN101_3; 20305 SDValue CPTmpN101_4; 20306 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 20307 SDValue N2 = N.getOperand(2); 20308 if (N10.getNode()->getValueType(0) == MVT::v16i8) { 20309 SDNode *Result = Emit_116(N, X86::PMAXUDrm, MVT::v4i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 20310 return Result; 20311 } 20312 } 20313 } 20314 } 20315 } 20316 } 20317 20318 // Pattern: (intrinsic_wo_chain:v4i32 642:iPTR, (bitconvert:v8i16 (X86vzload:v2i64 addr:iPTR:$src))) 20319 // Emits: (PMOVSXWDrm:v4i32 addr:iPTR:$src) 20320 // Pattern complexity = 32 cost = 1 size = 3 20321 if (CN1 == INT64_C(642)) { 20322 SDValue N1 = N.getOperand(1); 20323 if (N1.getOpcode() == ISD::BIT_CONVERT && 20324 N1.hasOneUse()) { 20325 SDValue N10 = N1.getOperand(0); 20326 if (N10.getOpcode() == X86ISD::VZEXT_LOAD && 20327 N10.hasOneUse() && 20328 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 20329 SDValue Chain10 = N10.getOperand(0); 20330 SDValue N101 = N10.getOperand(1); 20331 SDValue CPTmpN101_0; 20332 SDValue CPTmpN101_1; 20333 SDValue CPTmpN101_2; 20334 SDValue CPTmpN101_3; 20335 SDValue CPTmpN101_4; 20336 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 20337 N10.getNode()->getValueType(0) == MVT::v2i64) { 20338 SDNode *Result = Emit_129(N, X86::PMOVSXWDrm, MVT::v4i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 20339 return Result; 20340 } 20341 } 20342 } 20343 } 20344 20345 // Pattern: (intrinsic_wo_chain:v4i32 648:iPTR, (bitconvert:v8i16 (X86vzload:v2i64 addr:iPTR:$src))) 20346 // Emits: (PMOVZXWDrm:v4i32 addr:iPTR:$src) 20347 // Pattern complexity = 32 cost = 1 size = 3 20348 if (CN1 == INT64_C(648)) { 20349 SDValue N1 = N.getOperand(1); 20350 if (N1.getOpcode() == ISD::BIT_CONVERT && 20351 N1.hasOneUse()) { 20352 SDValue N10 = N1.getOperand(0); 20353 if (N10.getOpcode() == X86ISD::VZEXT_LOAD && 20354 N10.hasOneUse() && 20355 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 20356 SDValue Chain10 = N10.getOperand(0); 20357 SDValue N101 = N10.getOperand(1); 20358 SDValue CPTmpN101_0; 20359 SDValue CPTmpN101_1; 20360 SDValue CPTmpN101_2; 20361 SDValue CPTmpN101_3; 20362 SDValue CPTmpN101_4; 20363 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 20364 N10.getNode()->getValueType(0) == MVT::v2i64) { 20365 SDNode *Result = Emit_129(N, X86::PMOVZXWDrm, MVT::v4i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 20366 return Result; 20367 } 20368 } 20369 } 20370 } 20371 } 20372 } 20373 if ((Subtarget->hasSSE2())) { 20374 SDValue N0 = N.getOperand(0); 20375 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 20376 if (Tmp0) { 20377 int64_t CN1 = Tmp0->getSExtValue(); 20378 20379 // Pattern: (intrinsic_wo_chain:v4i32 515:iPTR, (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 20380 // Emits: (Int_CVTPS2DQrm:v4i32 addr:iPTR:$src) 20381 // Pattern complexity = 30 cost = 1 size = 3 20382 if (CN1 == INT64_C(515)) { 20383 SDValue N1 = N.getOperand(1); 20384 if (N1.getOpcode() == ISD::LOAD && 20385 N1.hasOneUse() && 20386 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 20387 SDValue Chain1 = N1.getOperand(0); 20388 if (Predicate_unindexedload(N1.getNode()) && 20389 Predicate_load(N1.getNode()) && 20390 Predicate_memop(N1.getNode())) { 20391 SDValue N11 = N1.getOperand(1); 20392 SDValue CPTmpN11_0; 20393 SDValue CPTmpN11_1; 20394 SDValue CPTmpN11_2; 20395 SDValue CPTmpN11_3; 20396 SDValue CPTmpN11_4; 20397 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 20398 SDNode *Result = Emit_107(N, X86::Int_CVTPS2DQrm, MVT::v4i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 20399 return Result; 20400 } 20401 } 20402 } 20403 } 20404 20405 // Pattern: (intrinsic_wo_chain:v4i32 524:iPTR, (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 20406 // Emits: (Int_CVTTPS2DQrm:v4i32 addr:iPTR:$src) 20407 // Pattern complexity = 30 cost = 1 size = 3 20408 if (CN1 == INT64_C(524)) { 20409 SDValue N1 = N.getOperand(1); 20410 if (N1.getOpcode() == ISD::LOAD && 20411 N1.hasOneUse() && 20412 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 20413 SDValue Chain1 = N1.getOperand(0); 20414 if (Predicate_unindexedload(N1.getNode()) && 20415 Predicate_load(N1.getNode()) && 20416 Predicate_memop(N1.getNode())) { 20417 SDValue N11 = N1.getOperand(1); 20418 SDValue CPTmpN11_0; 20419 SDValue CPTmpN11_1; 20420 SDValue CPTmpN11_2; 20421 SDValue CPTmpN11_3; 20422 SDValue CPTmpN11_4; 20423 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 20424 SDNode *Result = Emit_107(N, X86::Int_CVTTPS2DQrm, MVT::v4i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 20425 return Result; 20426 } 20427 } 20428 } 20429 } 20430 20431 // Pattern: (intrinsic_wo_chain:v4i32 513:iPTR, (ld:v2f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 20432 // Emits: (Int_CVTPD2DQrm:v4i32 addr:iPTR:$src) 20433 // Pattern complexity = 30 cost = 1 size = 3 20434 if (CN1 == INT64_C(513)) { 20435 SDValue N1 = N.getOperand(1); 20436 if (N1.getOpcode() == ISD::LOAD && 20437 N1.hasOneUse() && 20438 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 20439 SDValue Chain1 = N1.getOperand(0); 20440 if (Predicate_unindexedload(N1.getNode()) && 20441 Predicate_load(N1.getNode()) && 20442 Predicate_memop(N1.getNode())) { 20443 SDValue N11 = N1.getOperand(1); 20444 SDValue CPTmpN11_0; 20445 SDValue CPTmpN11_1; 20446 SDValue CPTmpN11_2; 20447 SDValue CPTmpN11_3; 20448 SDValue CPTmpN11_4; 20449 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 20450 SDNode *Result = Emit_107(N, X86::Int_CVTPD2DQrm, MVT::v4i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 20451 return Result; 20452 } 20453 } 20454 } 20455 } 20456 20457 // Pattern: (intrinsic_wo_chain:v4i32 523:iPTR, (ld:v2f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 20458 // Emits: (Int_CVTTPD2DQrm:v4i32 addr:iPTR:$src) 20459 // Pattern complexity = 30 cost = 1 size = 3 20460 if (CN1 == INT64_C(523)) { 20461 SDValue N1 = N.getOperand(1); 20462 if (N1.getOpcode() == ISD::LOAD && 20463 N1.hasOneUse() && 20464 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 20465 SDValue Chain1 = N1.getOperand(0); 20466 if (Predicate_unindexedload(N1.getNode()) && 20467 Predicate_load(N1.getNode()) && 20468 Predicate_memop(N1.getNode())) { 20469 SDValue N11 = N1.getOperand(1); 20470 SDValue CPTmpN11_0; 20471 SDValue CPTmpN11_1; 20472 SDValue CPTmpN11_2; 20473 SDValue CPTmpN11_3; 20474 SDValue CPTmpN11_4; 20475 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 20476 SDNode *Result = Emit_107(N, X86::Int_CVTTPD2DQrm, MVT::v4i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 20477 return Result; 20478 } 20479 } 20480 } 20481 } 20482 } 20483 } 20484 if ((Subtarget->hasSSE41())) { 20485 SDValue N0 = N.getOperand(0); 20486 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 20487 if (Tmp0) { 20488 int64_t CN1 = Tmp0->getSExtValue(); 20489 if (CN1 == INT64_C(651)) { 20490 SDValue N1 = N.getOperand(1); 20491 20492 // Pattern: (intrinsic_wo_chain:v4i32 651:iPTR, VR128:v4i32:$src1, (ld:v4i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 20493 // Emits: (PMULLDrm_int:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 20494 // Pattern complexity = 30 cost = 1 size = 3 20495 { 20496 SDValue N2 = N.getOperand(2); 20497 if (N2.getOpcode() == ISD::LOAD && 20498 N2.hasOneUse() && 20499 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 20500 SDValue Chain2 = N2.getOperand(0); 20501 if (Predicate_unindexedload(N2.getNode()) && 20502 Predicate_load(N2.getNode()) && 20503 Predicate_memop(N2.getNode())) { 20504 SDValue N21 = N2.getOperand(1); 20505 SDValue CPTmpN21_0; 20506 SDValue CPTmpN21_1; 20507 SDValue CPTmpN21_2; 20508 SDValue CPTmpN21_3; 20509 SDValue CPTmpN21_4; 20510 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 20511 SDNode *Result = Emit_108(N, X86::PMULLDrm_int, MVT::v4i32, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 20512 return Result; 20513 } 20514 } 20515 } 20516 } 20517 20518 // Pattern: (intrinsic_wo_chain:v4i32 651:iPTR, (ld:v4i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, VR128:v4i32:$src1) 20519 // Emits: (PMULLDrm_int:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 20520 // Pattern complexity = 30 cost = 1 size = 3 20521 if (N1.getOpcode() == ISD::LOAD && 20522 N1.hasOneUse() && 20523 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 20524 SDValue Chain1 = N1.getOperand(0); 20525 if (Predicate_unindexedload(N1.getNode()) && 20526 Predicate_load(N1.getNode()) && 20527 Predicate_memop(N1.getNode())) { 20528 SDValue N11 = N1.getOperand(1); 20529 SDValue CPTmpN11_0; 20530 SDValue CPTmpN11_1; 20531 SDValue CPTmpN11_2; 20532 SDValue CPTmpN11_3; 20533 SDValue CPTmpN11_4; 20534 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 20535 SDNode *Result = Emit_130(N, X86::PMULLDrm_int, MVT::v4i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 20536 return Result; 20537 } 20538 } 20539 } 20540 } 20541 } 20542 } 20543 } 20544 if ((Subtarget->hasSSE2())) { 20545 SDValue N0 = N.getOperand(0); 20546 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 20547 if (Tmp0) { 20548 int64_t CN1 = Tmp0->getSExtValue(); 20549 20550 // Pattern: (intrinsic_wo_chain:v4i32 572:iPTR, VR128:v4i32:$src1, (imm:i32):$src2) 20551 // Emits: (PSLLDri:v4i32 VR128:v4i32:$src1, (imm:i32):$src2) 20552 // Pattern complexity = 11 cost = 1 size = 3 20553 if (CN1 == INT64_C(572)) { 20554 SDValue N1 = N.getOperand(1); 20555 SDValue N2 = N.getOperand(2); 20556 if (N2.getOpcode() == ISD::Constant) { 20557 SDNode *Result = Emit_126(N, X86::PSLLDri, MVT::v4i32); 20558 return Result; 20559 } 20560 } 20561 20562 // Pattern: (intrinsic_wo_chain:v4i32 584:iPTR, VR128:v4i32:$src1, (imm:i32):$src2) 20563 // Emits: (PSRLDri:v4i32 VR128:v4i32:$src1, (imm:i32):$src2) 20564 // Pattern complexity = 11 cost = 1 size = 3 20565 if (CN1 == INT64_C(584)) { 20566 SDValue N1 = N.getOperand(1); 20567 SDValue N2 = N.getOperand(2); 20568 if (N2.getOpcode() == ISD::Constant) { 20569 SDNode *Result = Emit_126(N, X86::PSRLDri, MVT::v4i32); 20570 return Result; 20571 } 20572 } 20573 20574 // Pattern: (intrinsic_wo_chain:v4i32 577:iPTR, VR128:v4i32:$src1, (imm:i32):$src2) 20575 // Emits: (PSRADri:v4i32 VR128:v4i32:$src1, (imm:i32):$src2) 20576 // Pattern complexity = 11 cost = 1 size = 3 20577 if (CN1 == INT64_C(577)) { 20578 SDValue N1 = N.getOperand(1); 20579 SDValue N2 = N.getOperand(2); 20580 if (N2.getOpcode() == ISD::Constant) { 20581 SDNode *Result = Emit_126(N, X86::PSRADri, MVT::v4i32); 20582 return Result; 20583 } 20584 } 20585 20586 // Pattern: (intrinsic_wo_chain:v4i32 515:iPTR, VR128:v4f32:$src) 20587 // Emits: (Int_CVTPS2DQrr:v4i32 VR128:v4f32:$src) 20588 // Pattern complexity = 8 cost = 1 size = 3 20589 if (CN1 == INT64_C(515)) { 20590 SDNode *Result = Emit_106(N, X86::Int_CVTPS2DQrr, MVT::v4i32); 20591 return Result; 20592 } 20593 20594 // Pattern: (intrinsic_wo_chain:v4i32 524:iPTR, VR128:v4f32:$src) 20595 // Emits: (Int_CVTTPS2DQrr:v4i32 VR128:v4f32:$src) 20596 // Pattern complexity = 8 cost = 1 size = 3 20597 if (CN1 == INT64_C(524)) { 20598 SDNode *Result = Emit_106(N, X86::Int_CVTTPS2DQrr, MVT::v4i32); 20599 return Result; 20600 } 20601 20602 // Pattern: (intrinsic_wo_chain:v4i32 513:iPTR, VR128:v2f64:$src) 20603 // Emits: (Int_CVTPD2DQrr:v4i32 VR128:v2f64:$src) 20604 // Pattern complexity = 8 cost = 1 size = 3 20605 if (CN1 == INT64_C(513)) { 20606 SDNode *Result = Emit_106(N, X86::Int_CVTPD2DQrr, MVT::v4i32); 20607 return Result; 20608 } 20609 20610 // Pattern: (intrinsic_wo_chain:v4i32 523:iPTR, VR128:v2f64:$src) 20611 // Emits: (Int_CVTTPD2DQrr:v4i32 VR128:v2f64:$src) 20612 // Pattern complexity = 8 cost = 1 size = 3 20613 if (CN1 == INT64_C(523)) { 20614 SDNode *Result = Emit_106(N, X86::Int_CVTTPD2DQrr, MVT::v4i32); 20615 return Result; 20616 } 20617 20618 // Pattern: (intrinsic_wo_chain:v4i32 557:iPTR, VR128:v8i16:$src1, VR128:v8i16:$src2) 20619 // Emits: (PMADDWDrr:v4i32 VR128:v8i16:$src1, VR128:v8i16:$src2) 20620 // Pattern complexity = 8 cost = 1 size = 3 20621 if (CN1 == INT64_C(557)) { 20622 SDNode *Result = Emit_109(N, X86::PMADDWDrr, MVT::v4i32); 20623 return Result; 20624 } 20625 20626 // Pattern: (intrinsic_wo_chain:v4i32 567:iPTR, VR128:v4i32:$src1, VR128:v4i32:$src2) 20627 // Emits: (PSLLDrr:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 20628 // Pattern complexity = 8 cost = 1 size = 3 20629 if (CN1 == INT64_C(567)) { 20630 SDNode *Result = Emit_109(N, X86::PSLLDrr, MVT::v4i32); 20631 return Result; 20632 } 20633 20634 // Pattern: (intrinsic_wo_chain:v4i32 579:iPTR, VR128:v4i32:$src1, VR128:v4i32:$src2) 20635 // Emits: (PSRLDrr:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 20636 // Pattern complexity = 8 cost = 1 size = 3 20637 if (CN1 == INT64_C(579)) { 20638 SDNode *Result = Emit_109(N, X86::PSRLDrr, MVT::v4i32); 20639 return Result; 20640 } 20641 20642 // Pattern: (intrinsic_wo_chain:v4i32 575:iPTR, VR128:v4i32:$src1, VR128:v4i32:$src2) 20643 // Emits: (PSRADrr:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 20644 // Pattern complexity = 8 cost = 1 size = 3 20645 if (CN1 == INT64_C(575)) { 20646 SDNode *Result = Emit_109(N, X86::PSRADrr, MVT::v4i32); 20647 return Result; 20648 } 20649 20650 // Pattern: (intrinsic_wo_chain:v4i32 552:iPTR, VR128:v4i32:$src1, VR128:v4i32:$src2) 20651 // Emits: (PCMPEQDrr:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 20652 // Pattern complexity = 8 cost = 1 size = 3 20653 if (CN1 == INT64_C(552)) { 20654 SDNode *Result = Emit_109(N, X86::PCMPEQDrr, MVT::v4i32); 20655 return Result; 20656 } 20657 20658 // Pattern: (intrinsic_wo_chain:v4i32 555:iPTR, VR128:v4i32:$src1, VR128:v4i32:$src2) 20659 // Emits: (PCMPGTDrr:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 20660 // Pattern complexity = 8 cost = 1 size = 3 20661 if (CN1 == INT64_C(555)) { 20662 SDNode *Result = Emit_109(N, X86::PCMPGTDrr, MVT::v4i32); 20663 return Result; 20664 } 20665 20666 // Pattern: (intrinsic_wo_chain:v4i32 542:iPTR, VR128:v4i32:$src1, VR128:v4i32:$src2) 20667 // Emits: (PACKSSDWrr:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 20668 // Pattern complexity = 8 cost = 1 size = 3 20669 if (CN1 == INT64_C(542)) { 20670 SDNode *Result = Emit_109(N, X86::PACKSSDWrr, MVT::v4i32); 20671 return Result; 20672 } 20673 } 20674 } 20675 if ((Subtarget->hasSSSE3())) { 20676 SDValue N0 = N.getOperand(0); 20677 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 20678 if (Tmp0) { 20679 int64_t CN1 = Tmp0->getSExtValue(); 20680 20681 // Pattern: (intrinsic_wo_chain:v4i32 728:iPTR, VR128:v4i32:$src) 20682 // Emits: (PABSDrr128:v4i32 VR128:v4i32:$src) 20683 // Pattern complexity = 8 cost = 1 size = 3 20684 if (CN1 == INT64_C(728)) { 20685 SDNode *Result = Emit_106(N, X86::PABSDrr128, MVT::v4i32); 20686 return Result; 20687 } 20688 20689 // Pattern: (intrinsic_wo_chain:v4i32 734:iPTR, VR128:v4i32:$src1, VR128:v4i32:$src2) 20690 // Emits: (PHADDDrr128:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 20691 // Pattern complexity = 8 cost = 1 size = 3 20692 if (CN1 == INT64_C(734)) { 20693 SDNode *Result = Emit_109(N, X86::PHADDDrr128, MVT::v4i32); 20694 return Result; 20695 } 20696 20697 // Pattern: (intrinsic_wo_chain:v4i32 736:iPTR, VR128:v4i32:$src1, VR128:v4i32:$src2) 20698 // Emits: (PHADDSWrr128:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 20699 // Pattern complexity = 8 cost = 1 size = 3 20700 if (CN1 == INT64_C(736)) { 20701 SDNode *Result = Emit_109(N, X86::PHADDSWrr128, MVT::v4i32); 20702 return Result; 20703 } 20704 20705 // Pattern: (intrinsic_wo_chain:v4i32 740:iPTR, VR128:v4i32:$src1, VR128:v4i32:$src2) 20706 // Emits: (PHSUBDrr128:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 20707 // Pattern complexity = 8 cost = 1 size = 3 20708 if (CN1 == INT64_C(740)) { 20709 SDNode *Result = Emit_109(N, X86::PHSUBDrr128, MVT::v4i32); 20710 return Result; 20711 } 20712 20713 // Pattern: (intrinsic_wo_chain:v4i32 754:iPTR, VR128:v4i32:$src1, VR128:v4i32:$src2) 20714 // Emits: (PSIGNDrr128:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 20715 // Pattern complexity = 8 cost = 1 size = 3 20716 if (CN1 == INT64_C(754)) { 20717 SDNode *Result = Emit_109(N, X86::PSIGNDrr128, MVT::v4i32); 20718 return Result; 20719 } 20720 } 20721 } 20722 if ((Subtarget->hasSSE41())) { 20723 SDValue N0 = N.getOperand(0); 20724 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 20725 if (Tmp0) { 20726 int64_t CN1 = Tmp0->getSExtValue(); 20727 20728 // Pattern: (intrinsic_wo_chain:v4i32 635:iPTR, VR128:v4i32:$src1, VR128:v4i32:$src2) 20729 // Emits: (PMINSDrr:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 20730 // Pattern complexity = 8 cost = 1 size = 3 20731 if (CN1 == INT64_C(635)) { 20732 SDNode *Result = Emit_109(N, X86::PMINSDrr, MVT::v4i32); 20733 return Result; 20734 } 20735 20736 // Pattern: (intrinsic_wo_chain:v4i32 636:iPTR, VR128:v4i32:$src1, VR128:v4i32:$src2) 20737 // Emits: (PMINUDrr:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 20738 // Pattern complexity = 8 cost = 1 size = 3 20739 if (CN1 == INT64_C(636)) { 20740 SDNode *Result = Emit_109(N, X86::PMINUDrr, MVT::v4i32); 20741 return Result; 20742 } 20743 20744 // Pattern: (intrinsic_wo_chain:v4i32 631:iPTR, VR128:v4i32:$src1, VR128:v4i32:$src2) 20745 // Emits: (PMAXSDrr:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 20746 // Pattern complexity = 8 cost = 1 size = 3 20747 if (CN1 == INT64_C(631)) { 20748 SDNode *Result = Emit_109(N, X86::PMAXSDrr, MVT::v4i32); 20749 return Result; 20750 } 20751 20752 // Pattern: (intrinsic_wo_chain:v4i32 632:iPTR, VR128:v4i32:$src1, VR128:v4i32:$src2) 20753 // Emits: (PMAXUDrr:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 20754 // Pattern complexity = 8 cost = 1 size = 3 20755 if (CN1 == INT64_C(632)) { 20756 SDNode *Result = Emit_109(N, X86::PMAXUDrr, MVT::v4i32); 20757 return Result; 20758 } 20759 20760 // Pattern: (intrinsic_wo_chain:v4i32 651:iPTR, VR128:v4i32:$src1, VR128:v4i32:$src2) 20761 // Emits: (PMULLDrr_int:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 20762 // Pattern complexity = 8 cost = 1 size = 3 20763 if (CN1 == INT64_C(651)) { 20764 SDNode *Result = Emit_109(N, X86::PMULLDrr_int, MVT::v4i32); 20765 return Result; 20766 } 20767 20768 // Pattern: (intrinsic_wo_chain:v4i32 642:iPTR, VR128:v8i16:$src) 20769 // Emits: (PMOVSXWDrr:v4i32 VR128:v8i16:$src) 20770 // Pattern complexity = 8 cost = 1 size = 3 20771 if (CN1 == INT64_C(642)) { 20772 SDNode *Result = Emit_106(N, X86::PMOVSXWDrr, MVT::v4i32); 20773 return Result; 20774 } 20775 20776 // Pattern: (intrinsic_wo_chain:v4i32 648:iPTR, VR128:v8i16:$src) 20777 // Emits: (PMOVZXWDrr:v4i32 VR128:v8i16:$src) 20778 // Pattern complexity = 8 cost = 1 size = 3 20779 if (CN1 == INT64_C(648)) { 20780 SDNode *Result = Emit_106(N, X86::PMOVZXWDrr, MVT::v4i32); 20781 return Result; 20782 } 20783 20784 // Pattern: (intrinsic_wo_chain:v4i32 638:iPTR, VR128:v16i8:$src) 20785 // Emits: (PMOVSXBDrr:v4i32 VR128:v16i8:$src) 20786 // Pattern complexity = 8 cost = 1 size = 3 20787 if (CN1 == INT64_C(638)) { 20788 SDNode *Result = Emit_106(N, X86::PMOVSXBDrr, MVT::v4i32); 20789 return Result; 20790 } 20791 20792 // Pattern: (intrinsic_wo_chain:v4i32 644:iPTR, VR128:v16i8:$src) 20793 // Emits: (PMOVZXBDrr:v4i32 VR128:v16i8:$src) 20794 // Pattern complexity = 8 cost = 1 size = 3 20795 if (CN1 == INT64_C(644)) { 20796 SDNode *Result = Emit_106(N, X86::PMOVZXBDrr, MVT::v4i32); 20797 return Result; 20798 } 20799 } 20800 } 20801 20802 CannotYetSelectIntrinsic(N); 20803 return NULL; 20804 } 20805 20806 SDNode *Emit_131(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 20807 SDValue N0 = N.getOperand(0); 20808 SDValue N1 = N.getOperand(1); 20809 SDValue N2 = N.getOperand(2); 20810 SDValue N3 = N.getOperand(3); 20811 SDValue Tmp4 = CurDAG->getTargetConstant(((unsigned short) cast<ConstantSDNode>(N3)->getZExtValue()), MVT::i16); 20812 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N1, N2, Tmp4); 20813 } 20814 SDNode *Emit_132(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN201_0, SDValue &CPTmpN201_1, SDValue &CPTmpN201_2, SDValue &CPTmpN201_3, SDValue &CPTmpN201_4) DISABLE_INLINE { 20815 SDValue N0 = N.getOperand(0); 20816 SDValue N1 = N.getOperand(1); 20817 SDValue N2 = N.getOperand(2); 20818 SDValue N20 = N2.getOperand(0); 20819 SDValue Chain20 = N20.getOperand(0); 20820 SDValue N201 = N20.getOperand(1); 20821 SDValue N3 = N.getOperand(3); 20822 SDValue Tmp4 = CurDAG->getTargetConstant(((unsigned short) cast<ConstantSDNode>(N3)->getZExtValue()), MVT::i16); 20823 SDValue LSI_N20 = CurDAG->getMemOperand(cast<MemSDNode>(N20)->getMemOperand()); 20824 SDValue Ops0[] = { N1, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4, Tmp4, LSI_N20, Chain20 }; 20825 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 9); 20826 ReplaceUses(SDValue(N20.getNode(), 1), SDValue(ResNode, 1)); 20827 return ResNode; 20828 } 20829 SDNode *Select_ISD_INTRINSIC_WO_CHAIN_v1i64(const SDValue &N) { 20830 if (OptLevel != CodeGenOpt::None) { 20831 20832 // Pattern: (intrinsic_wo_chain:v1i64 731:iPTR, VR64:v1i64:$src1, (bitconvert:v1i64 (ld:v2i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop64>>), (imm:i16):$src3) 20833 // Emits: (PALIGNR64rm:v1i64 VR64:v1i64:$src1, addr:iPTR:$src2, (imm:i16):$src3) 20834 // Pattern complexity = 36 cost = 1 size = 3 20835 if ((Subtarget->hasSSSE3())) { 20836 SDValue N0 = N.getOperand(0); 20837 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 20838 if (Tmp0) { 20839 int64_t CN1 = Tmp0->getSExtValue(); 20840 if (CN1 == INT64_C(731)) { 20841 SDValue N1 = N.getOperand(1); 20842 SDValue N2 = N.getOperand(2); 20843 if (N2.getOpcode() == ISD::BIT_CONVERT && 20844 N2.hasOneUse()) { 20845 SDValue N20 = N2.getOperand(0); 20846 if (N20.getOpcode() == ISD::LOAD && 20847 N20.hasOneUse() && 20848 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 20849 SDValue Chain20 = N20.getOperand(0); 20850 if (Predicate_unindexedload(N20.getNode()) && 20851 Predicate_load(N20.getNode()) && 20852 Predicate_memop64(N20.getNode())) { 20853 SDValue N201 = N20.getOperand(1); 20854 SDValue CPTmpN201_0; 20855 SDValue CPTmpN201_1; 20856 SDValue CPTmpN201_2; 20857 SDValue CPTmpN201_3; 20858 SDValue CPTmpN201_4; 20859 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4)) { 20860 SDValue N3 = N.getOperand(3); 20861 if (N3.getOpcode() == ISD::Constant && 20862 N20.getNode()->getValueType(0) == MVT::v2i32) { 20863 SDNode *Result = Emit_132(N, X86::PALIGNR64rm, MVT::v1i64, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 20864 return Result; 20865 } 20866 } 20867 } 20868 } 20869 } 20870 } 20871 } 20872 } 20873 if ((Subtarget->hasMMX())) { 20874 SDValue N0 = N.getOperand(0); 20875 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 20876 if (Tmp0) { 20877 int64_t CN1 = Tmp0->getSExtValue(); 20878 20879 // Pattern: (intrinsic_wo_chain:v1i64 492:iPTR, VR64:v1i64:$src1, (bitconvert:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 20880 // Emits: (MMX_PSRLQrm:v1i64 VR64:v1i64:$src1, addr:iPTR:$src2) 20881 // Pattern complexity = 33 cost = 1 size = 3 20882 if (CN1 == INT64_C(492)) { 20883 SDValue N1 = N.getOperand(1); 20884 SDValue N2 = N.getOperand(2); 20885 if (N2.getOpcode() == ISD::BIT_CONVERT && 20886 N2.hasOneUse()) { 20887 SDValue N20 = N2.getOperand(0); 20888 if (N20.getOpcode() == ISD::LOAD && 20889 N20.hasOneUse() && 20890 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 20891 SDValue Chain20 = N20.getOperand(0); 20892 if (Predicate_unindexedload(N20.getNode()) && 20893 Predicate_load(N20.getNode())) { 20894 SDValue N201 = N20.getOperand(1); 20895 SDValue CPTmpN201_0; 20896 SDValue CPTmpN201_1; 20897 SDValue CPTmpN201_2; 20898 SDValue CPTmpN201_3; 20899 SDValue CPTmpN201_4; 20900 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 20901 N20.getNode()->getValueType(0) == MVT::v1i64) { 20902 SDNode *Result = Emit_115(N, X86::MMX_PSRLQrm, MVT::v1i64, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 20903 return Result; 20904 } 20905 } 20906 } 20907 } 20908 } 20909 20910 // Pattern: (intrinsic_wo_chain:v1i64 482:iPTR, VR64:v1i64:$src1, (bitconvert:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 20911 // Emits: (MMX_PSLLQrm:v1i64 VR64:v1i64:$src1, addr:iPTR:$src2) 20912 // Pattern complexity = 33 cost = 1 size = 3 20913 if (CN1 == INT64_C(482)) { 20914 SDValue N1 = N.getOperand(1); 20915 SDValue N2 = N.getOperand(2); 20916 if (N2.getOpcode() == ISD::BIT_CONVERT && 20917 N2.hasOneUse()) { 20918 SDValue N20 = N2.getOperand(0); 20919 if (N20.getOpcode() == ISD::LOAD && 20920 N20.hasOneUse() && 20921 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 20922 SDValue Chain20 = N20.getOperand(0); 20923 if (Predicate_unindexedload(N20.getNode()) && 20924 Predicate_load(N20.getNode())) { 20925 SDValue N201 = N20.getOperand(1); 20926 SDValue CPTmpN201_0; 20927 SDValue CPTmpN201_1; 20928 SDValue CPTmpN201_2; 20929 SDValue CPTmpN201_3; 20930 SDValue CPTmpN201_4; 20931 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 20932 N20.getNode()->getValueType(0) == MVT::v1i64) { 20933 SDNode *Result = Emit_115(N, X86::MMX_PSLLQrm, MVT::v1i64, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 20934 return Result; 20935 } 20936 } 20937 } 20938 } 20939 } 20940 } 20941 } 20942 } 20943 20944 // Pattern: (intrinsic_wo_chain:v1i64 731:iPTR, VR64:v1i64:$src1, VR64:v1i64:$src2, (imm:i16):$src3) 20945 // Emits: (PALIGNR64rr:v1i64 VR64:v1i64:$src1, VR64:v1i64:$src2, (imm:i16):$src3) 20946 // Pattern complexity = 11 cost = 1 size = 3 20947 if ((Subtarget->hasSSSE3())) { 20948 SDValue N0 = N.getOperand(0); 20949 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 20950 if (Tmp0) { 20951 int64_t CN1 = Tmp0->getSExtValue(); 20952 if (CN1 == INT64_C(731)) { 20953 SDValue N1 = N.getOperand(1); 20954 SDValue N2 = N.getOperand(2); 20955 SDValue N3 = N.getOperand(3); 20956 if (N3.getOpcode() == ISD::Constant) { 20957 SDNode *Result = Emit_131(N, X86::PALIGNR64rr, MVT::v1i64); 20958 return Result; 20959 } 20960 } 20961 } 20962 } 20963 if ((Subtarget->hasMMX())) { 20964 SDValue N0 = N.getOperand(0); 20965 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 20966 if (Tmp0) { 20967 int64_t CN1 = Tmp0->getSExtValue(); 20968 20969 // Pattern: (intrinsic_wo_chain:v1i64 495:iPTR, VR64:v1i64:$src1, (imm:i32):$src2) 20970 // Emits: (MMX_PSRLQri:v1i64 VR64:v1i64:$src1, (imm:i32):$src2) 20971 // Pattern complexity = 11 cost = 1 size = 3 20972 if (CN1 == INT64_C(495)) { 20973 SDValue N1 = N.getOperand(1); 20974 SDValue N2 = N.getOperand(2); 20975 if (N2.getOpcode() == ISD::Constant) { 20976 SDNode *Result = Emit_126(N, X86::MMX_PSRLQri, MVT::v1i64); 20977 return Result; 20978 } 20979 } 20980 20981 // Pattern: (intrinsic_wo_chain:v1i64 485:iPTR, VR64:v1i64:$src1, (imm:i32):$src2) 20982 // Emits: (MMX_PSLLQri:v1i64 VR64:v1i64:$src1, (imm:i32):$src2) 20983 // Pattern complexity = 11 cost = 1 size = 3 20984 if (CN1 == INT64_C(485)) { 20985 SDValue N1 = N.getOperand(1); 20986 SDValue N2 = N.getOperand(2); 20987 if (N2.getOpcode() == ISD::Constant) { 20988 SDNode *Result = Emit_126(N, X86::MMX_PSLLQri, MVT::v1i64); 20989 return Result; 20990 } 20991 } 20992 20993 // Pattern: (intrinsic_wo_chain:v1i64 492:iPTR, VR64:v1i64:$src1, VR64:v1i64:$src2) 20994 // Emits: (MMX_PSRLQrr:v1i64 VR64:v1i64:$src1, VR64:v1i64:$src2) 20995 // Pattern complexity = 8 cost = 1 size = 3 20996 if (CN1 == INT64_C(492)) { 20997 SDNode *Result = Emit_109(N, X86::MMX_PSRLQrr, MVT::v1i64); 20998 return Result; 20999 } 21000 21001 // Pattern: (intrinsic_wo_chain:v1i64 482:iPTR, VR64:v1i64:$src1, VR64:v1i64:$src2) 21002 // Emits: (MMX_PSLLQrr:v1i64 VR64:v1i64:$src1, VR64:v1i64:$src2) 21003 // Pattern complexity = 8 cost = 1 size = 3 21004 if (CN1 == INT64_C(482)) { 21005 SDNode *Result = Emit_109(N, X86::MMX_PSLLQrr, MVT::v1i64); 21006 return Result; 21007 } 21008 } 21009 } 21010 21011 CannotYetSelectIntrinsic(N); 21012 return NULL; 21013 } 21014 21015 SDNode *Emit_133(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 21016 SDValue N0 = N.getOperand(0); 21017 SDValue N1 = N.getOperand(1); 21018 SDValue N2 = N.getOperand(2); 21019 SDValue Tmp3 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N2)->getZExtValue()), MVT::i32); 21020 SDValue Tmp4 = Transform_PSxLDQ_imm(Tmp3.getNode()); 21021 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N1, Tmp4); 21022 } 21023 SDNode *Select_ISD_INTRINSIC_WO_CHAIN_v2i64(const SDValue &N) { 21024 if (OptLevel != CodeGenOpt::None) { 21025 if ((Subtarget->hasSSE41())) { 21026 SDValue N0 = N.getOperand(0); 21027 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 21028 if (Tmp0) { 21029 int64_t CN1 = Tmp0->getSExtValue(); 21030 21031 // Pattern: (intrinsic_wo_chain:v2i64 641:iPTR, (bitconvert:v4i32 (X86vzmovl:v2i64 (scalar_to_vector:v2i64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>)))) 21032 // Emits: (PMOVSXDQrm:v2i64 addr:iPTR:$src) 21033 // Pattern complexity = 39 cost = 1 size = 3 21034 if (CN1 == INT64_C(641)) { 21035 SDValue N1 = N.getOperand(1); 21036 if (N1.getOpcode() == ISD::BIT_CONVERT && 21037 N1.hasOneUse()) { 21038 SDValue N10 = N1.getOperand(0); 21039 if (N10.getOpcode() == X86ISD::VZEXT_MOVL && 21040 N10.hasOneUse()) { 21041 SDValue N100 = N10.getOperand(0); 21042 if (N100.getOpcode() == ISD::SCALAR_TO_VECTOR && 21043 N100.hasOneUse()) { 21044 SDValue N1000 = N100.getOperand(0); 21045 if (N1000.getOpcode() == ISD::LOAD && 21046 N1000.hasOneUse() && 21047 IsLegalAndProfitableToFold(N1000.getNode(), N100.getNode(), N.getNode())) { 21048 SDValue Chain1000 = N1000.getOperand(0); 21049 if (Predicate_unindexedload(N1000.getNode()) && 21050 Predicate_load(N1000.getNode()) && 21051 Predicate_loadi64(N1000.getNode())) { 21052 SDValue N10001 = N1000.getOperand(1); 21053 SDValue CPTmpN10001_0; 21054 SDValue CPTmpN10001_1; 21055 SDValue CPTmpN10001_2; 21056 SDValue CPTmpN10001_3; 21057 SDValue CPTmpN10001_4; 21058 if (SelectAddr(N, N10001, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4) && 21059 N10.getNode()->getValueType(0) == MVT::v2i64 && 21060 N1000.getNode()->getValueType(0) == MVT::i64) { 21061 SDNode *Result = Emit_128(N, X86::PMOVSXDQrm, MVT::v2i64, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4); 21062 return Result; 21063 } 21064 } 21065 } 21066 } 21067 } 21068 } 21069 } 21070 21071 // Pattern: (intrinsic_wo_chain:v2i64 647:iPTR, (bitconvert:v4i32 (X86vzmovl:v2i64 (scalar_to_vector:v2i64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>)))) 21072 // Emits: (PMOVZXDQrm:v2i64 addr:iPTR:$src) 21073 // Pattern complexity = 39 cost = 1 size = 3 21074 if (CN1 == INT64_C(647)) { 21075 SDValue N1 = N.getOperand(1); 21076 if (N1.getOpcode() == ISD::BIT_CONVERT && 21077 N1.hasOneUse()) { 21078 SDValue N10 = N1.getOperand(0); 21079 if (N10.getOpcode() == X86ISD::VZEXT_MOVL && 21080 N10.hasOneUse()) { 21081 SDValue N100 = N10.getOperand(0); 21082 if (N100.getOpcode() == ISD::SCALAR_TO_VECTOR && 21083 N100.hasOneUse()) { 21084 SDValue N1000 = N100.getOperand(0); 21085 if (N1000.getOpcode() == ISD::LOAD && 21086 N1000.hasOneUse() && 21087 IsLegalAndProfitableToFold(N1000.getNode(), N100.getNode(), N.getNode())) { 21088 SDValue Chain1000 = N1000.getOperand(0); 21089 if (Predicate_unindexedload(N1000.getNode()) && 21090 Predicate_load(N1000.getNode()) && 21091 Predicate_loadi64(N1000.getNode())) { 21092 SDValue N10001 = N1000.getOperand(1); 21093 SDValue CPTmpN10001_0; 21094 SDValue CPTmpN10001_1; 21095 SDValue CPTmpN10001_2; 21096 SDValue CPTmpN10001_3; 21097 SDValue CPTmpN10001_4; 21098 if (SelectAddr(N, N10001, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4) && 21099 N10.getNode()->getValueType(0) == MVT::v2i64 && 21100 N1000.getNode()->getValueType(0) == MVT::i64) { 21101 SDNode *Result = Emit_128(N, X86::PMOVZXDQrm, MVT::v2i64, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4); 21102 return Result; 21103 } 21104 } 21105 } 21106 } 21107 } 21108 } 21109 } 21110 21111 // Pattern: (intrinsic_wo_chain:v2i64 643:iPTR, (bitconvert:v8i16 (X86vzmovl:v4i32 (scalar_to_vector:v4i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>)))) 21112 // Emits: (PMOVSXWQrm:v2i64 addr:iPTR:$src) 21113 // Pattern complexity = 39 cost = 1 size = 3 21114 if (CN1 == INT64_C(643)) { 21115 SDValue N1 = N.getOperand(1); 21116 if (N1.getOpcode() == ISD::BIT_CONVERT && 21117 N1.hasOneUse()) { 21118 SDValue N10 = N1.getOperand(0); 21119 if (N10.getOpcode() == X86ISD::VZEXT_MOVL && 21120 N10.hasOneUse()) { 21121 SDValue N100 = N10.getOperand(0); 21122 if (N100.getOpcode() == ISD::SCALAR_TO_VECTOR && 21123 N100.hasOneUse()) { 21124 SDValue N1000 = N100.getOperand(0); 21125 if (N1000.getOpcode() == ISD::LOAD && 21126 N1000.hasOneUse() && 21127 IsLegalAndProfitableToFold(N1000.getNode(), N100.getNode(), N.getNode())) { 21128 SDValue Chain1000 = N1000.getOperand(0); 21129 if (Predicate_unindexedload(N1000.getNode()) && 21130 Predicate_loadi32(N1000.getNode())) { 21131 SDValue N10001 = N1000.getOperand(1); 21132 SDValue CPTmpN10001_0; 21133 SDValue CPTmpN10001_1; 21134 SDValue CPTmpN10001_2; 21135 SDValue CPTmpN10001_3; 21136 SDValue CPTmpN10001_4; 21137 if (SelectAddr(N, N10001, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4) && 21138 N10.getNode()->getValueType(0) == MVT::v4i32 && 21139 N1000.getNode()->getValueType(0) == MVT::i32) { 21140 SDNode *Result = Emit_128(N, X86::PMOVSXWQrm, MVT::v2i64, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4); 21141 return Result; 21142 } 21143 } 21144 } 21145 } 21146 } 21147 } 21148 } 21149 21150 // Pattern: (intrinsic_wo_chain:v2i64 649:iPTR, (bitconvert:v8i16 (X86vzmovl:v4i32 (scalar_to_vector:v4i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>)))) 21151 // Emits: (PMOVZXWQrm:v2i64 addr:iPTR:$src) 21152 // Pattern complexity = 39 cost = 1 size = 3 21153 if (CN1 == INT64_C(649)) { 21154 SDValue N1 = N.getOperand(1); 21155 if (N1.getOpcode() == ISD::BIT_CONVERT && 21156 N1.hasOneUse()) { 21157 SDValue N10 = N1.getOperand(0); 21158 if (N10.getOpcode() == X86ISD::VZEXT_MOVL && 21159 N10.hasOneUse()) { 21160 SDValue N100 = N10.getOperand(0); 21161 if (N100.getOpcode() == ISD::SCALAR_TO_VECTOR && 21162 N100.hasOneUse()) { 21163 SDValue N1000 = N100.getOperand(0); 21164 if (N1000.getOpcode() == ISD::LOAD && 21165 N1000.hasOneUse() && 21166 IsLegalAndProfitableToFold(N1000.getNode(), N100.getNode(), N.getNode())) { 21167 SDValue Chain1000 = N1000.getOperand(0); 21168 if (Predicate_unindexedload(N1000.getNode()) && 21169 Predicate_loadi32(N1000.getNode())) { 21170 SDValue N10001 = N1000.getOperand(1); 21171 SDValue CPTmpN10001_0; 21172 SDValue CPTmpN10001_1; 21173 SDValue CPTmpN10001_2; 21174 SDValue CPTmpN10001_3; 21175 SDValue CPTmpN10001_4; 21176 if (SelectAddr(N, N10001, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4) && 21177 N10.getNode()->getValueType(0) == MVT::v4i32 && 21178 N1000.getNode()->getValueType(0) == MVT::i32) { 21179 SDNode *Result = Emit_128(N, X86::PMOVZXWQrm, MVT::v2i64, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4); 21180 return Result; 21181 } 21182 } 21183 } 21184 } 21185 } 21186 } 21187 } 21188 21189 // Pattern: (intrinsic_wo_chain:v2i64 639:iPTR, (bitconvert:v16i8 (X86vzmovl:v4i32 (scalar_to_vector:v4i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>)))) 21190 // Emits: (PMOVSXBQrm:v2i64 addr:iPTR:$src) 21191 // Pattern complexity = 39 cost = 1 size = 3 21192 if (CN1 == INT64_C(639)) { 21193 SDValue N1 = N.getOperand(1); 21194 if (N1.getOpcode() == ISD::BIT_CONVERT && 21195 N1.hasOneUse()) { 21196 SDValue N10 = N1.getOperand(0); 21197 if (N10.getOpcode() == X86ISD::VZEXT_MOVL && 21198 N10.hasOneUse()) { 21199 SDValue N100 = N10.getOperand(0); 21200 if (N100.getOpcode() == ISD::SCALAR_TO_VECTOR && 21201 N100.hasOneUse()) { 21202 SDValue N1000 = N100.getOperand(0); 21203 if (N1000.getOpcode() == ISD::LOAD && 21204 N1000.hasOneUse() && 21205 IsLegalAndProfitableToFold(N1000.getNode(), N100.getNode(), N.getNode())) { 21206 SDValue Chain1000 = N1000.getOperand(0); 21207 if (Predicate_unindexedload(N1000.getNode()) && 21208 Predicate_loadi32(N1000.getNode())) { 21209 SDValue N10001 = N1000.getOperand(1); 21210 SDValue CPTmpN10001_0; 21211 SDValue CPTmpN10001_1; 21212 SDValue CPTmpN10001_2; 21213 SDValue CPTmpN10001_3; 21214 SDValue CPTmpN10001_4; 21215 if (SelectAddr(N, N10001, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4) && 21216 N10.getNode()->getValueType(0) == MVT::v4i32 && 21217 N1000.getNode()->getValueType(0) == MVT::i32) { 21218 SDNode *Result = Emit_128(N, X86::PMOVSXBQrm, MVT::v2i64, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4); 21219 return Result; 21220 } 21221 } 21222 } 21223 } 21224 } 21225 } 21226 } 21227 21228 // Pattern: (intrinsic_wo_chain:v2i64 645:iPTR, (bitconvert:v16i8 (X86vzmovl:v4i32 (scalar_to_vector:v4i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>)))) 21229 // Emits: (PMOVZXBQrm:v2i64 addr:iPTR:$src) 21230 // Pattern complexity = 39 cost = 1 size = 3 21231 if (CN1 == INT64_C(645)) { 21232 SDValue N1 = N.getOperand(1); 21233 if (N1.getOpcode() == ISD::BIT_CONVERT && 21234 N1.hasOneUse()) { 21235 SDValue N10 = N1.getOperand(0); 21236 if (N10.getOpcode() == X86ISD::VZEXT_MOVL && 21237 N10.hasOneUse()) { 21238 SDValue N100 = N10.getOperand(0); 21239 if (N100.getOpcode() == ISD::SCALAR_TO_VECTOR && 21240 N100.hasOneUse()) { 21241 SDValue N1000 = N100.getOperand(0); 21242 if (N1000.getOpcode() == ISD::LOAD && 21243 N1000.hasOneUse() && 21244 IsLegalAndProfitableToFold(N1000.getNode(), N100.getNode(), N.getNode())) { 21245 SDValue Chain1000 = N1000.getOperand(0); 21246 if (Predicate_unindexedload(N1000.getNode()) && 21247 Predicate_loadi32(N1000.getNode())) { 21248 SDValue N10001 = N1000.getOperand(1); 21249 SDValue CPTmpN10001_0; 21250 SDValue CPTmpN10001_1; 21251 SDValue CPTmpN10001_2; 21252 SDValue CPTmpN10001_3; 21253 SDValue CPTmpN10001_4; 21254 if (SelectAddr(N, N10001, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4) && 21255 N10.getNode()->getValueType(0) == MVT::v4i32 && 21256 N1000.getNode()->getValueType(0) == MVT::i32) { 21257 SDNode *Result = Emit_128(N, X86::PMOVZXBQrm, MVT::v2i64, CPTmpN10001_0, CPTmpN10001_1, CPTmpN10001_2, CPTmpN10001_3, CPTmpN10001_4); 21258 return Result; 21259 } 21260 } 21261 } 21262 } 21263 } 21264 } 21265 } 21266 } 21267 } 21268 21269 // Pattern: (intrinsic_wo_chain:v2i64 732:iPTR, VR128:v2i64:$src1, (bitconvert:v2i64 (ld:v4i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), (imm:i32):$src3) 21270 // Emits: (PALIGNR128rm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2, (imm:i32):$src3) 21271 // Pattern complexity = 36 cost = 1 size = 3 21272 if ((Subtarget->hasSSSE3())) { 21273 SDValue N0 = N.getOperand(0); 21274 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 21275 if (Tmp0) { 21276 int64_t CN1 = Tmp0->getSExtValue(); 21277 if (CN1 == INT64_C(732)) { 21278 SDValue N1 = N.getOperand(1); 21279 SDValue N2 = N.getOperand(2); 21280 if (N2.getOpcode() == ISD::BIT_CONVERT && 21281 N2.hasOneUse()) { 21282 SDValue N20 = N2.getOperand(0); 21283 if (N20.getOpcode() == ISD::LOAD && 21284 N20.hasOneUse() && 21285 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 21286 SDValue Chain20 = N20.getOperand(0); 21287 if (Predicate_unindexedload(N20.getNode()) && 21288 Predicate_load(N20.getNode()) && 21289 Predicate_memop(N20.getNode())) { 21290 SDValue N201 = N20.getOperand(1); 21291 SDValue CPTmpN201_0; 21292 SDValue CPTmpN201_1; 21293 SDValue CPTmpN201_2; 21294 SDValue CPTmpN201_3; 21295 SDValue CPTmpN201_4; 21296 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4)) { 21297 SDValue N3 = N.getOperand(3); 21298 if (N3.getOpcode() == ISD::Constant && 21299 N20.getNode()->getValueType(0) == MVT::v4i32) { 21300 SDNode *Result = Emit_118(N, X86::PALIGNR128rm, MVT::v2i64, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 21301 return Result; 21302 } 21303 } 21304 } 21305 } 21306 } 21307 } 21308 } 21309 } 21310 if ((Subtarget->hasSSE41())) { 21311 SDValue N0 = N.getOperand(0); 21312 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 21313 if (Tmp0) { 21314 int64_t CN1 = Tmp0->getSExtValue(); 21315 21316 // Pattern: (intrinsic_wo_chain:v2i64 641:iPTR, (bitconvert:v4i32 (scalar_to_vector:v2i64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>))) 21317 // Emits: (PMOVSXDQrm:v2i64 addr:iPTR:$src) 21318 // Pattern complexity = 36 cost = 1 size = 3 21319 if (CN1 == INT64_C(641)) { 21320 SDValue N1 = N.getOperand(1); 21321 if (N1.getOpcode() == ISD::BIT_CONVERT && 21322 N1.hasOneUse()) { 21323 SDValue N10 = N1.getOperand(0); 21324 if (N10.getOpcode() == ISD::SCALAR_TO_VECTOR && 21325 N10.hasOneUse()) { 21326 SDValue N100 = N10.getOperand(0); 21327 if (N100.getOpcode() == ISD::LOAD && 21328 N100.hasOneUse() && 21329 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode())) { 21330 SDValue Chain100 = N100.getOperand(0); 21331 if (Predicate_unindexedload(N100.getNode()) && 21332 Predicate_load(N100.getNode()) && 21333 Predicate_loadi64(N100.getNode())) { 21334 SDValue N1001 = N100.getOperand(1); 21335 SDValue CPTmpN1001_0; 21336 SDValue CPTmpN1001_1; 21337 SDValue CPTmpN1001_2; 21338 SDValue CPTmpN1001_3; 21339 SDValue CPTmpN1001_4; 21340 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4) && 21341 N10.getNode()->getValueType(0) == MVT::v2i64 && 21342 N100.getNode()->getValueType(0) == MVT::i64) { 21343 SDNode *Result = Emit_127(N, X86::PMOVSXDQrm, MVT::v2i64, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 21344 return Result; 21345 } 21346 } 21347 } 21348 } 21349 } 21350 } 21351 21352 // Pattern: (intrinsic_wo_chain:v2i64 647:iPTR, (bitconvert:v4i32 (scalar_to_vector:v2i64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>))) 21353 // Emits: (PMOVZXDQrm:v2i64 addr:iPTR:$src) 21354 // Pattern complexity = 36 cost = 1 size = 3 21355 if (CN1 == INT64_C(647)) { 21356 SDValue N1 = N.getOperand(1); 21357 if (N1.getOpcode() == ISD::BIT_CONVERT && 21358 N1.hasOneUse()) { 21359 SDValue N10 = N1.getOperand(0); 21360 if (N10.getOpcode() == ISD::SCALAR_TO_VECTOR && 21361 N10.hasOneUse()) { 21362 SDValue N100 = N10.getOperand(0); 21363 if (N100.getOpcode() == ISD::LOAD && 21364 N100.hasOneUse() && 21365 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode())) { 21366 SDValue Chain100 = N100.getOperand(0); 21367 if (Predicate_unindexedload(N100.getNode()) && 21368 Predicate_load(N100.getNode()) && 21369 Predicate_loadi64(N100.getNode())) { 21370 SDValue N1001 = N100.getOperand(1); 21371 SDValue CPTmpN1001_0; 21372 SDValue CPTmpN1001_1; 21373 SDValue CPTmpN1001_2; 21374 SDValue CPTmpN1001_3; 21375 SDValue CPTmpN1001_4; 21376 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4) && 21377 N10.getNode()->getValueType(0) == MVT::v2i64 && 21378 N100.getNode()->getValueType(0) == MVT::i64) { 21379 SDNode *Result = Emit_127(N, X86::PMOVZXDQrm, MVT::v2i64, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 21380 return Result; 21381 } 21382 } 21383 } 21384 } 21385 } 21386 } 21387 21388 // Pattern: (intrinsic_wo_chain:v2i64 643:iPTR, (bitconvert:v8i16 (scalar_to_vector:v4i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>))) 21389 // Emits: (PMOVSXWQrm:v2i64 addr:iPTR:$src) 21390 // Pattern complexity = 36 cost = 1 size = 3 21391 if (CN1 == INT64_C(643)) { 21392 SDValue N1 = N.getOperand(1); 21393 if (N1.getOpcode() == ISD::BIT_CONVERT && 21394 N1.hasOneUse()) { 21395 SDValue N10 = N1.getOperand(0); 21396 if (N10.getOpcode() == ISD::SCALAR_TO_VECTOR && 21397 N10.hasOneUse()) { 21398 SDValue N100 = N10.getOperand(0); 21399 if (N100.getOpcode() == ISD::LOAD && 21400 N100.hasOneUse() && 21401 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode())) { 21402 SDValue Chain100 = N100.getOperand(0); 21403 if (Predicate_unindexedload(N100.getNode()) && 21404 Predicate_loadi32(N100.getNode())) { 21405 SDValue N1001 = N100.getOperand(1); 21406 SDValue CPTmpN1001_0; 21407 SDValue CPTmpN1001_1; 21408 SDValue CPTmpN1001_2; 21409 SDValue CPTmpN1001_3; 21410 SDValue CPTmpN1001_4; 21411 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4) && 21412 N10.getNode()->getValueType(0) == MVT::v4i32 && 21413 N100.getNode()->getValueType(0) == MVT::i32) { 21414 SDNode *Result = Emit_127(N, X86::PMOVSXWQrm, MVT::v2i64, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 21415 return Result; 21416 } 21417 } 21418 } 21419 } 21420 } 21421 } 21422 21423 // Pattern: (intrinsic_wo_chain:v2i64 649:iPTR, (bitconvert:v8i16 (scalar_to_vector:v4i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>))) 21424 // Emits: (PMOVZXWQrm:v2i64 addr:iPTR:$src) 21425 // Pattern complexity = 36 cost = 1 size = 3 21426 if (CN1 == INT64_C(649)) { 21427 SDValue N1 = N.getOperand(1); 21428 if (N1.getOpcode() == ISD::BIT_CONVERT && 21429 N1.hasOneUse()) { 21430 SDValue N10 = N1.getOperand(0); 21431 if (N10.getOpcode() == ISD::SCALAR_TO_VECTOR && 21432 N10.hasOneUse()) { 21433 SDValue N100 = N10.getOperand(0); 21434 if (N100.getOpcode() == ISD::LOAD && 21435 N100.hasOneUse() && 21436 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode())) { 21437 SDValue Chain100 = N100.getOperand(0); 21438 if (Predicate_unindexedload(N100.getNode()) && 21439 Predicate_loadi32(N100.getNode())) { 21440 SDValue N1001 = N100.getOperand(1); 21441 SDValue CPTmpN1001_0; 21442 SDValue CPTmpN1001_1; 21443 SDValue CPTmpN1001_2; 21444 SDValue CPTmpN1001_3; 21445 SDValue CPTmpN1001_4; 21446 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4) && 21447 N10.getNode()->getValueType(0) == MVT::v4i32 && 21448 N100.getNode()->getValueType(0) == MVT::i32) { 21449 SDNode *Result = Emit_127(N, X86::PMOVZXWQrm, MVT::v2i64, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 21450 return Result; 21451 } 21452 } 21453 } 21454 } 21455 } 21456 } 21457 21458 // Pattern: (intrinsic_wo_chain:v2i64 639:iPTR, (bitconvert:v16i8 (scalar_to_vector:v4i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi16_anyext>>))) 21459 // Emits: (PMOVSXBQrm:v2i64 addr:iPTR:$src) 21460 // Pattern complexity = 36 cost = 1 size = 3 21461 if (CN1 == INT64_C(639)) { 21462 SDValue N1 = N.getOperand(1); 21463 if (N1.getOpcode() == ISD::BIT_CONVERT && 21464 N1.hasOneUse()) { 21465 SDValue N10 = N1.getOperand(0); 21466 if (N10.getOpcode() == ISD::SCALAR_TO_VECTOR && 21467 N10.hasOneUse()) { 21468 SDValue N100 = N10.getOperand(0); 21469 if (N100.getOpcode() == ISD::LOAD && 21470 N100.hasOneUse() && 21471 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode())) { 21472 SDValue Chain100 = N100.getOperand(0); 21473 if (Predicate_unindexedload(N100.getNode()) && 21474 Predicate_loadi16_anyext(N100.getNode())) { 21475 SDValue N1001 = N100.getOperand(1); 21476 SDValue CPTmpN1001_0; 21477 SDValue CPTmpN1001_1; 21478 SDValue CPTmpN1001_2; 21479 SDValue CPTmpN1001_3; 21480 SDValue CPTmpN1001_4; 21481 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4) && 21482 N10.getNode()->getValueType(0) == MVT::v4i32 && 21483 N100.getNode()->getValueType(0) == MVT::i32) { 21484 SDNode *Result = Emit_127(N, X86::PMOVSXBQrm, MVT::v2i64, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 21485 return Result; 21486 } 21487 } 21488 } 21489 } 21490 } 21491 } 21492 21493 // Pattern: (intrinsic_wo_chain:v2i64 645:iPTR, (bitconvert:v16i8 (scalar_to_vector:v4i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi16_anyext>>))) 21494 // Emits: (PMOVZXBQrm:v2i64 addr:iPTR:$src) 21495 // Pattern complexity = 36 cost = 1 size = 3 21496 if (CN1 == INT64_C(645)) { 21497 SDValue N1 = N.getOperand(1); 21498 if (N1.getOpcode() == ISD::BIT_CONVERT && 21499 N1.hasOneUse()) { 21500 SDValue N10 = N1.getOperand(0); 21501 if (N10.getOpcode() == ISD::SCALAR_TO_VECTOR && 21502 N10.hasOneUse()) { 21503 SDValue N100 = N10.getOperand(0); 21504 if (N100.getOpcode() == ISD::LOAD && 21505 N100.hasOneUse() && 21506 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode())) { 21507 SDValue Chain100 = N100.getOperand(0); 21508 if (Predicate_unindexedload(N100.getNode()) && 21509 Predicate_loadi16_anyext(N100.getNode())) { 21510 SDValue N1001 = N100.getOperand(1); 21511 SDValue CPTmpN1001_0; 21512 SDValue CPTmpN1001_1; 21513 SDValue CPTmpN1001_2; 21514 SDValue CPTmpN1001_3; 21515 SDValue CPTmpN1001_4; 21516 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4) && 21517 N10.getNode()->getValueType(0) == MVT::v4i32 && 21518 N100.getNode()->getValueType(0) == MVT::i32) { 21519 SDNode *Result = Emit_127(N, X86::PMOVZXBQrm, MVT::v2i64, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 21520 return Result; 21521 } 21522 } 21523 } 21524 } 21525 } 21526 } 21527 } 21528 } 21529 if ((Subtarget->hasSSE2())) { 21530 SDValue N0 = N.getOperand(0); 21531 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 21532 if (Tmp0) { 21533 int64_t CN1 = Tmp0->getSExtValue(); 21534 21535 // Pattern: (intrinsic_wo_chain:v2i64 565:iPTR, VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 21536 // Emits: (PMULUDQrm:v2i64 VR128:v4i32:$src1, addr:iPTR:$src2) 21537 // Pattern complexity = 33 cost = 1 size = 3 21538 if (CN1 == INT64_C(565)) { 21539 SDValue N1 = N.getOperand(1); 21540 SDValue N2 = N.getOperand(2); 21541 if (N2.getOpcode() == ISD::BIT_CONVERT && 21542 N2.hasOneUse()) { 21543 SDValue N20 = N2.getOperand(0); 21544 if (N20.getOpcode() == ISD::LOAD && 21545 N20.hasOneUse() && 21546 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 21547 SDValue Chain20 = N20.getOperand(0); 21548 if (Predicate_unindexedload(N20.getNode()) && 21549 Predicate_load(N20.getNode()) && 21550 Predicate_memop(N20.getNode())) { 21551 SDValue N201 = N20.getOperand(1); 21552 SDValue CPTmpN201_0; 21553 SDValue CPTmpN201_1; 21554 SDValue CPTmpN201_2; 21555 SDValue CPTmpN201_3; 21556 SDValue CPTmpN201_4; 21557 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 21558 N20.getNode()->getValueType(0) == MVT::v2i64) { 21559 SDNode *Result = Emit_115(N, X86::PMULUDQrm, MVT::v2i64, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 21560 return Result; 21561 } 21562 } 21563 } 21564 } 21565 } 21566 21567 // Pattern: (intrinsic_wo_chain:v2i64 566:iPTR, VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 21568 // Emits: (PSADBWrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 21569 // Pattern complexity = 33 cost = 1 size = 3 21570 if (CN1 == INT64_C(566)) { 21571 SDValue N1 = N.getOperand(1); 21572 SDValue N2 = N.getOperand(2); 21573 if (N2.getOpcode() == ISD::BIT_CONVERT && 21574 N2.hasOneUse()) { 21575 SDValue N20 = N2.getOperand(0); 21576 if (N20.getOpcode() == ISD::LOAD && 21577 N20.hasOneUse() && 21578 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 21579 SDValue Chain20 = N20.getOperand(0); 21580 if (Predicate_unindexedload(N20.getNode()) && 21581 Predicate_load(N20.getNode()) && 21582 Predicate_memop(N20.getNode())) { 21583 SDValue N201 = N20.getOperand(1); 21584 SDValue CPTmpN201_0; 21585 SDValue CPTmpN201_1; 21586 SDValue CPTmpN201_2; 21587 SDValue CPTmpN201_3; 21588 SDValue CPTmpN201_4; 21589 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 21590 N20.getNode()->getValueType(0) == MVT::v2i64) { 21591 SDNode *Result = Emit_115(N, X86::PSADBWrm, MVT::v2i64, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 21592 return Result; 21593 } 21594 } 21595 } 21596 } 21597 } 21598 21599 // Pattern: (intrinsic_wo_chain:v2i64 570:iPTR, VR128:v2i64:$src1, (bitconvert:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 21600 // Emits: (PSLLQrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 21601 // Pattern complexity = 33 cost = 1 size = 3 21602 if (CN1 == INT64_C(570)) { 21603 SDValue N1 = N.getOperand(1); 21604 SDValue N2 = N.getOperand(2); 21605 if (N2.getOpcode() == ISD::BIT_CONVERT && 21606 N2.hasOneUse()) { 21607 SDValue N20 = N2.getOperand(0); 21608 if (N20.getOpcode() == ISD::LOAD && 21609 N20.hasOneUse() && 21610 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 21611 SDValue Chain20 = N20.getOperand(0); 21612 if (Predicate_unindexedload(N20.getNode()) && 21613 Predicate_load(N20.getNode()) && 21614 Predicate_memop(N20.getNode())) { 21615 SDValue N201 = N20.getOperand(1); 21616 SDValue CPTmpN201_0; 21617 SDValue CPTmpN201_1; 21618 SDValue CPTmpN201_2; 21619 SDValue CPTmpN201_3; 21620 SDValue CPTmpN201_4; 21621 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 21622 N20.getNode()->getValueType(0) == MVT::v2i64) { 21623 SDNode *Result = Emit_115(N, X86::PSLLQrm, MVT::v2i64, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 21624 return Result; 21625 } 21626 } 21627 } 21628 } 21629 } 21630 21631 // Pattern: (intrinsic_wo_chain:v2i64 582:iPTR, VR128:v2i64:$src1, (bitconvert:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 21632 // Emits: (PSRLQrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 21633 // Pattern complexity = 33 cost = 1 size = 3 21634 if (CN1 == INT64_C(582)) { 21635 SDValue N1 = N.getOperand(1); 21636 SDValue N2 = N.getOperand(2); 21637 if (N2.getOpcode() == ISD::BIT_CONVERT && 21638 N2.hasOneUse()) { 21639 SDValue N20 = N2.getOperand(0); 21640 if (N20.getOpcode() == ISD::LOAD && 21641 N20.hasOneUse() && 21642 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 21643 SDValue Chain20 = N20.getOperand(0); 21644 if (Predicate_unindexedload(N20.getNode()) && 21645 Predicate_load(N20.getNode()) && 21646 Predicate_memop(N20.getNode())) { 21647 SDValue N201 = N20.getOperand(1); 21648 SDValue CPTmpN201_0; 21649 SDValue CPTmpN201_1; 21650 SDValue CPTmpN201_2; 21651 SDValue CPTmpN201_3; 21652 SDValue CPTmpN201_4; 21653 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 21654 N20.getNode()->getValueType(0) == MVT::v2i64) { 21655 SDNode *Result = Emit_115(N, X86::PSRLQrm, MVT::v2i64, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 21656 return Result; 21657 } 21658 } 21659 } 21660 } 21661 } 21662 } 21663 } 21664 if ((Subtarget->hasSSE41())) { 21665 SDValue N0 = N.getOperand(0); 21666 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 21667 if (Tmp0) { 21668 int64_t CN1 = Tmp0->getSExtValue(); 21669 21670 // Pattern: (intrinsic_wo_chain:v2i64 625:iPTR, VR128:v2i64:$src1, (bitconvert:v2i64 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 21671 // Emits: (PCMPEQQrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 21672 // Pattern complexity = 33 cost = 1 size = 3 21673 if (CN1 == INT64_C(625)) { 21674 SDValue N1 = N.getOperand(1); 21675 SDValue N2 = N.getOperand(2); 21676 if (N2.getOpcode() == ISD::BIT_CONVERT && 21677 N2.hasOneUse()) { 21678 SDValue N20 = N2.getOperand(0); 21679 if (N20.getOpcode() == ISD::LOAD && 21680 N20.hasOneUse() && 21681 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 21682 SDValue Chain20 = N20.getOperand(0); 21683 if (Predicate_unindexedload(N20.getNode()) && 21684 Predicate_load(N20.getNode()) && 21685 Predicate_memop(N20.getNode())) { 21686 SDValue N201 = N20.getOperand(1); 21687 SDValue CPTmpN201_0; 21688 SDValue CPTmpN201_1; 21689 SDValue CPTmpN201_2; 21690 SDValue CPTmpN201_3; 21691 SDValue CPTmpN201_4; 21692 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 21693 N20.getNode()->getValueType(0) == MVT::v16i8) { 21694 SDNode *Result = Emit_115(N, X86::PCMPEQQrm, MVT::v2i64, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 21695 return Result; 21696 } 21697 } 21698 } 21699 } 21700 } 21701 21702 // Pattern: (intrinsic_wo_chain:v2i64 650:iPTR, VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 21703 // Emits: (PMULDQrm:v2i64 VR128:v4i32:$src1, addr:iPTR:$src2) 21704 // Pattern complexity = 33 cost = 1 size = 3 21705 if (CN1 == INT64_C(650)) { 21706 SDValue N1 = N.getOperand(1); 21707 SDValue N2 = N.getOperand(2); 21708 if (N2.getOpcode() == ISD::BIT_CONVERT && 21709 N2.hasOneUse()) { 21710 SDValue N20 = N2.getOperand(0); 21711 if (N20.getOpcode() == ISD::LOAD && 21712 N20.hasOneUse() && 21713 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 21714 SDValue Chain20 = N20.getOperand(0); 21715 if (Predicate_unindexedload(N20.getNode()) && 21716 Predicate_load(N20.getNode()) && 21717 Predicate_memop(N20.getNode())) { 21718 SDValue N201 = N20.getOperand(1); 21719 SDValue CPTmpN201_0; 21720 SDValue CPTmpN201_1; 21721 SDValue CPTmpN201_2; 21722 SDValue CPTmpN201_3; 21723 SDValue CPTmpN201_4; 21724 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 21725 N20.getNode()->getValueType(0) == MVT::v16i8) { 21726 SDNode *Result = Emit_115(N, X86::PMULDQrm, MVT::v2i64, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 21727 return Result; 21728 } 21729 } 21730 } 21731 } 21732 } 21733 } 21734 } 21735 21736 // Pattern: (intrinsic_wo_chain:v2i64 670:iPTR, VR128:v2i64:$src1, (bitconvert:v2i64 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 21737 // Emits: (PCMPGTQrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 21738 // Pattern complexity = 33 cost = 1 size = 3 21739 if ((Subtarget->hasSSE42())) { 21740 SDValue N0 = N.getOperand(0); 21741 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 21742 if (Tmp0) { 21743 int64_t CN1 = Tmp0->getSExtValue(); 21744 if (CN1 == INT64_C(670)) { 21745 SDValue N1 = N.getOperand(1); 21746 SDValue N2 = N.getOperand(2); 21747 if (N2.getOpcode() == ISD::BIT_CONVERT && 21748 N2.hasOneUse()) { 21749 SDValue N20 = N2.getOperand(0); 21750 if (N20.getOpcode() == ISD::LOAD && 21751 N20.hasOneUse() && 21752 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 21753 SDValue Chain20 = N20.getOperand(0); 21754 if (Predicate_unindexedload(N20.getNode()) && 21755 Predicate_load(N20.getNode()) && 21756 Predicate_memop(N20.getNode())) { 21757 SDValue N201 = N20.getOperand(1); 21758 SDValue CPTmpN201_0; 21759 SDValue CPTmpN201_1; 21760 SDValue CPTmpN201_2; 21761 SDValue CPTmpN201_3; 21762 SDValue CPTmpN201_4; 21763 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4) && 21764 N20.getNode()->getValueType(0) == MVT::v16i8) { 21765 SDNode *Result = Emit_115(N, X86::PCMPGTQrm, MVT::v2i64, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 21766 return Result; 21767 } 21768 } 21769 } 21770 } 21771 } 21772 } 21773 } 21774 if ((Subtarget->hasSSE2())) { 21775 SDValue N0 = N.getOperand(0); 21776 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 21777 if (Tmp0) { 21778 int64_t CN1 = Tmp0->getSExtValue(); 21779 21780 // Pattern: (intrinsic_wo_chain:v2i64 565:iPTR, (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v4i32:$src1) 21781 // Emits: (PMULUDQrm:v2i64 VR128:v4i32:$src1, addr:iPTR:$src2) 21782 // Pattern complexity = 33 cost = 1 size = 3 21783 if (CN1 == INT64_C(565)) { 21784 SDValue N1 = N.getOperand(1); 21785 if (N1.getOpcode() == ISD::BIT_CONVERT && 21786 N1.hasOneUse()) { 21787 SDValue N10 = N1.getOperand(0); 21788 if (N10.getOpcode() == ISD::LOAD && 21789 N10.hasOneUse() && 21790 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 21791 SDValue Chain10 = N10.getOperand(0); 21792 if (Predicate_unindexedload(N10.getNode()) && 21793 Predicate_load(N10.getNode()) && 21794 Predicate_memop(N10.getNode())) { 21795 SDValue N101 = N10.getOperand(1); 21796 SDValue CPTmpN101_0; 21797 SDValue CPTmpN101_1; 21798 SDValue CPTmpN101_2; 21799 SDValue CPTmpN101_3; 21800 SDValue CPTmpN101_4; 21801 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 21802 SDValue N2 = N.getOperand(2); 21803 if (N10.getNode()->getValueType(0) == MVT::v2i64) { 21804 SDNode *Result = Emit_116(N, X86::PMULUDQrm, MVT::v2i64, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 21805 return Result; 21806 } 21807 } 21808 } 21809 } 21810 } 21811 } 21812 21813 // Pattern: (intrinsic_wo_chain:v2i64 566:iPTR, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v16i8:$src1) 21814 // Emits: (PSADBWrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 21815 // Pattern complexity = 33 cost = 1 size = 3 21816 if (CN1 == INT64_C(566)) { 21817 SDValue N1 = N.getOperand(1); 21818 if (N1.getOpcode() == ISD::BIT_CONVERT && 21819 N1.hasOneUse()) { 21820 SDValue N10 = N1.getOperand(0); 21821 if (N10.getOpcode() == ISD::LOAD && 21822 N10.hasOneUse() && 21823 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 21824 SDValue Chain10 = N10.getOperand(0); 21825 if (Predicate_unindexedload(N10.getNode()) && 21826 Predicate_load(N10.getNode()) && 21827 Predicate_memop(N10.getNode())) { 21828 SDValue N101 = N10.getOperand(1); 21829 SDValue CPTmpN101_0; 21830 SDValue CPTmpN101_1; 21831 SDValue CPTmpN101_2; 21832 SDValue CPTmpN101_3; 21833 SDValue CPTmpN101_4; 21834 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 21835 SDValue N2 = N.getOperand(2); 21836 if (N10.getNode()->getValueType(0) == MVT::v2i64) { 21837 SDNode *Result = Emit_116(N, X86::PSADBWrm, MVT::v2i64, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 21838 return Result; 21839 } 21840 } 21841 } 21842 } 21843 } 21844 } 21845 } 21846 } 21847 if ((Subtarget->hasSSE41())) { 21848 SDValue N0 = N.getOperand(0); 21849 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 21850 if (Tmp0) { 21851 int64_t CN1 = Tmp0->getSExtValue(); 21852 21853 // Pattern: (intrinsic_wo_chain:v2i64 625:iPTR, (bitconvert:v2i64 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v2i64:$src1) 21854 // Emits: (PCMPEQQrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 21855 // Pattern complexity = 33 cost = 1 size = 3 21856 if (CN1 == INT64_C(625)) { 21857 SDValue N1 = N.getOperand(1); 21858 if (N1.getOpcode() == ISD::BIT_CONVERT && 21859 N1.hasOneUse()) { 21860 SDValue N10 = N1.getOperand(0); 21861 if (N10.getOpcode() == ISD::LOAD && 21862 N10.hasOneUse() && 21863 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 21864 SDValue Chain10 = N10.getOperand(0); 21865 if (Predicate_unindexedload(N10.getNode()) && 21866 Predicate_load(N10.getNode()) && 21867 Predicate_memop(N10.getNode())) { 21868 SDValue N101 = N10.getOperand(1); 21869 SDValue CPTmpN101_0; 21870 SDValue CPTmpN101_1; 21871 SDValue CPTmpN101_2; 21872 SDValue CPTmpN101_3; 21873 SDValue CPTmpN101_4; 21874 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 21875 SDValue N2 = N.getOperand(2); 21876 if (N10.getNode()->getValueType(0) == MVT::v16i8) { 21877 SDNode *Result = Emit_116(N, X86::PCMPEQQrm, MVT::v2i64, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 21878 return Result; 21879 } 21880 } 21881 } 21882 } 21883 } 21884 } 21885 21886 // Pattern: (intrinsic_wo_chain:v2i64 650:iPTR, (bitconvert:v4i32 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v4i32:$src1) 21887 // Emits: (PMULDQrm:v2i64 VR128:v4i32:$src1, addr:iPTR:$src2) 21888 // Pattern complexity = 33 cost = 1 size = 3 21889 if (CN1 == INT64_C(650)) { 21890 SDValue N1 = N.getOperand(1); 21891 if (N1.getOpcode() == ISD::BIT_CONVERT && 21892 N1.hasOneUse()) { 21893 SDValue N10 = N1.getOperand(0); 21894 if (N10.getOpcode() == ISD::LOAD && 21895 N10.hasOneUse() && 21896 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 21897 SDValue Chain10 = N10.getOperand(0); 21898 if (Predicate_unindexedload(N10.getNode()) && 21899 Predicate_load(N10.getNode()) && 21900 Predicate_memop(N10.getNode())) { 21901 SDValue N101 = N10.getOperand(1); 21902 SDValue CPTmpN101_0; 21903 SDValue CPTmpN101_1; 21904 SDValue CPTmpN101_2; 21905 SDValue CPTmpN101_3; 21906 SDValue CPTmpN101_4; 21907 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 21908 SDValue N2 = N.getOperand(2); 21909 if (N10.getNode()->getValueType(0) == MVT::v16i8) { 21910 SDNode *Result = Emit_116(N, X86::PMULDQrm, MVT::v2i64, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 21911 return Result; 21912 } 21913 } 21914 } 21915 } 21916 } 21917 } 21918 21919 // Pattern: (intrinsic_wo_chain:v2i64 641:iPTR, (bitconvert:v4i32 (X86vzload:v2i64 addr:iPTR:$src))) 21920 // Emits: (PMOVSXDQrm:v2i64 addr:iPTR:$src) 21921 // Pattern complexity = 32 cost = 1 size = 3 21922 if (CN1 == INT64_C(641)) { 21923 SDValue N1 = N.getOperand(1); 21924 if (N1.getOpcode() == ISD::BIT_CONVERT && 21925 N1.hasOneUse()) { 21926 SDValue N10 = N1.getOperand(0); 21927 if (N10.getOpcode() == X86ISD::VZEXT_LOAD && 21928 N10.hasOneUse() && 21929 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 21930 SDValue Chain10 = N10.getOperand(0); 21931 SDValue N101 = N10.getOperand(1); 21932 SDValue CPTmpN101_0; 21933 SDValue CPTmpN101_1; 21934 SDValue CPTmpN101_2; 21935 SDValue CPTmpN101_3; 21936 SDValue CPTmpN101_4; 21937 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 21938 N10.getNode()->getValueType(0) == MVT::v2i64) { 21939 SDNode *Result = Emit_129(N, X86::PMOVSXDQrm, MVT::v2i64, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 21940 return Result; 21941 } 21942 } 21943 } 21944 } 21945 21946 // Pattern: (intrinsic_wo_chain:v2i64 647:iPTR, (bitconvert:v4i32 (X86vzload:v2i64 addr:iPTR:$src))) 21947 // Emits: (PMOVZXDQrm:v2i64 addr:iPTR:$src) 21948 // Pattern complexity = 32 cost = 1 size = 3 21949 if (CN1 == INT64_C(647)) { 21950 SDValue N1 = N.getOperand(1); 21951 if (N1.getOpcode() == ISD::BIT_CONVERT && 21952 N1.hasOneUse()) { 21953 SDValue N10 = N1.getOperand(0); 21954 if (N10.getOpcode() == X86ISD::VZEXT_LOAD && 21955 N10.hasOneUse() && 21956 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 21957 SDValue Chain10 = N10.getOperand(0); 21958 SDValue N101 = N10.getOperand(1); 21959 SDValue CPTmpN101_0; 21960 SDValue CPTmpN101_1; 21961 SDValue CPTmpN101_2; 21962 SDValue CPTmpN101_3; 21963 SDValue CPTmpN101_4; 21964 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 21965 N10.getNode()->getValueType(0) == MVT::v2i64) { 21966 SDNode *Result = Emit_129(N, X86::PMOVZXDQrm, MVT::v2i64, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 21967 return Result; 21968 } 21969 } 21970 } 21971 } 21972 } 21973 } 21974 } 21975 if ((Subtarget->hasSSE2())) { 21976 SDValue N0 = N.getOperand(0); 21977 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 21978 if (Tmp0) { 21979 int64_t CN1 = Tmp0->getSExtValue(); 21980 21981 // Pattern: (intrinsic_wo_chain:v2i64 573:iPTR, VR128:v2i64:$src1, (imm:i32):$src2) 21982 // Emits: (PSLLQri:v2i64 VR128:v2i64:$src1, (imm:i32):$src2) 21983 // Pattern complexity = 11 cost = 1 size = 3 21984 if (CN1 == INT64_C(573)) { 21985 SDValue N1 = N.getOperand(1); 21986 SDValue N2 = N.getOperand(2); 21987 if (N2.getOpcode() == ISD::Constant) { 21988 SDNode *Result = Emit_126(N, X86::PSLLQri, MVT::v2i64); 21989 return Result; 21990 } 21991 } 21992 21993 // Pattern: (intrinsic_wo_chain:v2i64 585:iPTR, VR128:v2i64:$src1, (imm:i32):$src2) 21994 // Emits: (PSRLQri:v2i64 VR128:v2i64:$src1, (imm:i32):$src2) 21995 // Pattern complexity = 11 cost = 1 size = 3 21996 if (CN1 == INT64_C(585)) { 21997 SDValue N1 = N.getOperand(1); 21998 SDValue N2 = N.getOperand(2); 21999 if (N2.getOpcode() == ISD::Constant) { 22000 SDNode *Result = Emit_126(N, X86::PSRLQri, MVT::v2i64); 22001 return Result; 22002 } 22003 } 22004 } 22005 } 22006 22007 // Pattern: (intrinsic_wo_chain:v2i64 732:iPTR, VR128:v2i64:$src1, VR128:v2i64:$src2, (imm:i32):$src3) 22008 // Emits: (PALIGNR128rr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2, (imm:i32):$src3) 22009 // Pattern complexity = 11 cost = 1 size = 3 22010 if ((Subtarget->hasSSSE3())) { 22011 SDValue N0 = N.getOperand(0); 22012 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 22013 if (Tmp0) { 22014 int64_t CN1 = Tmp0->getSExtValue(); 22015 if (CN1 == INT64_C(732)) { 22016 SDValue N1 = N.getOperand(1); 22017 SDValue N2 = N.getOperand(2); 22018 SDValue N3 = N.getOperand(3); 22019 if (N3.getOpcode() == ISD::Constant) { 22020 SDNode *Result = Emit_117(N, X86::PALIGNR128rr, MVT::v2i64); 22021 return Result; 22022 } 22023 } 22024 } 22025 } 22026 if ((Subtarget->hasSSE2())) { 22027 SDValue N0 = N.getOperand(0); 22028 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 22029 if (Tmp0) { 22030 int64_t CN1 = Tmp0->getSExtValue(); 22031 22032 // Pattern: (intrinsic_wo_chain:v2i64 568:iPTR, VR128:v2i64:$src1, (imm:i32):$src2) 22033 // Emits: (PSLLDQri:v2i64 VR128:v16i8:$src1, (PSxLDQ_imm:i32 (imm:i32):$src2)) 22034 // Pattern complexity = 11 cost = 1 size = 3 22035 if (CN1 == INT64_C(568)) { 22036 SDValue N1 = N.getOperand(1); 22037 SDValue N2 = N.getOperand(2); 22038 if (N2.getOpcode() == ISD::Constant) { 22039 SDNode *Result = Emit_133(N, X86::PSLLDQri, MVT::v2i64); 22040 return Result; 22041 } 22042 } 22043 22044 // Pattern: (intrinsic_wo_chain:v2i64 580:iPTR, VR128:v2i64:$src1, (imm:i32):$src2) 22045 // Emits: (PSRLDQri:v2i64 VR128:v16i8:$src1, (PSxLDQ_imm:i32 (imm:i32):$src2)) 22046 // Pattern complexity = 11 cost = 1 size = 3 22047 if (CN1 == INT64_C(580)) { 22048 SDValue N1 = N.getOperand(1); 22049 SDValue N2 = N.getOperand(2); 22050 if (N2.getOpcode() == ISD::Constant) { 22051 SDNode *Result = Emit_133(N, X86::PSRLDQri, MVT::v2i64); 22052 return Result; 22053 } 22054 } 22055 22056 // Pattern: (intrinsic_wo_chain:v2i64 569:iPTR, VR128:v2i64:$src1, (imm:i32):$src2) 22057 // Emits: (PSLLDQri:v2i64 VR128:v16i8:$src1, (imm:i32):$src2) 22058 // Pattern complexity = 11 cost = 1 size = 3 22059 if (CN1 == INT64_C(569)) { 22060 SDValue N1 = N.getOperand(1); 22061 SDValue N2 = N.getOperand(2); 22062 if (N2.getOpcode() == ISD::Constant) { 22063 SDNode *Result = Emit_126(N, X86::PSLLDQri, MVT::v2i64); 22064 return Result; 22065 } 22066 } 22067 22068 // Pattern: (intrinsic_wo_chain:v2i64 581:iPTR, VR128:v2i64:$src1, (imm:i32):$src2) 22069 // Emits: (PSRLDQri:v2i64 VR128:v16i8:$src1, (imm:i32):$src2) 22070 // Pattern complexity = 11 cost = 1 size = 3 22071 if (CN1 == INT64_C(581)) { 22072 SDValue N1 = N.getOperand(1); 22073 SDValue N2 = N.getOperand(2); 22074 if (N2.getOpcode() == ISD::Constant) { 22075 SDNode *Result = Emit_126(N, X86::PSRLDQri, MVT::v2i64); 22076 return Result; 22077 } 22078 } 22079 22080 // Pattern: (intrinsic_wo_chain:v2i64 565:iPTR, VR128:v4i32:$src1, VR128:v4i32:$src2) 22081 // Emits: (PMULUDQrr:v2i64 VR128:v4i32:$src1, VR128:v4i32:$src2) 22082 // Pattern complexity = 8 cost = 1 size = 3 22083 if (CN1 == INT64_C(565)) { 22084 SDNode *Result = Emit_109(N, X86::PMULUDQrr, MVT::v2i64); 22085 return Result; 22086 } 22087 22088 // Pattern: (intrinsic_wo_chain:v2i64 566:iPTR, VR128:v16i8:$src1, VR128:v16i8:$src2) 22089 // Emits: (PSADBWrr:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src2) 22090 // Pattern complexity = 8 cost = 1 size = 3 22091 if (CN1 == INT64_C(566)) { 22092 SDNode *Result = Emit_109(N, X86::PSADBWrr, MVT::v2i64); 22093 return Result; 22094 } 22095 22096 // Pattern: (intrinsic_wo_chain:v2i64 570:iPTR, VR128:v2i64:$src1, VR128:v2i64:$src2) 22097 // Emits: (PSLLQrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 22098 // Pattern complexity = 8 cost = 1 size = 3 22099 if (CN1 == INT64_C(570)) { 22100 SDNode *Result = Emit_109(N, X86::PSLLQrr, MVT::v2i64); 22101 return Result; 22102 } 22103 22104 // Pattern: (intrinsic_wo_chain:v2i64 582:iPTR, VR128:v2i64:$src1, VR128:v2i64:$src2) 22105 // Emits: (PSRLQrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 22106 // Pattern complexity = 8 cost = 1 size = 3 22107 if (CN1 == INT64_C(582)) { 22108 SDNode *Result = Emit_109(N, X86::PSRLQrr, MVT::v2i64); 22109 return Result; 22110 } 22111 } 22112 } 22113 if ((Subtarget->hasSSE41())) { 22114 SDValue N0 = N.getOperand(0); 22115 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 22116 if (Tmp0) { 22117 int64_t CN1 = Tmp0->getSExtValue(); 22118 22119 // Pattern: (intrinsic_wo_chain:v2i64 625:iPTR, VR128:v2i64:$src1, VR128:v2i64:$src2) 22120 // Emits: (PCMPEQQrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 22121 // Pattern complexity = 8 cost = 1 size = 3 22122 if (CN1 == INT64_C(625)) { 22123 SDNode *Result = Emit_109(N, X86::PCMPEQQrr, MVT::v2i64); 22124 return Result; 22125 } 22126 22127 // Pattern: (intrinsic_wo_chain:v2i64 650:iPTR, VR128:v4i32:$src1, VR128:v4i32:$src2) 22128 // Emits: (PMULDQrr:v2i64 VR128:v4i32:$src1, VR128:v4i32:$src2) 22129 // Pattern complexity = 8 cost = 1 size = 3 22130 if (CN1 == INT64_C(650)) { 22131 SDNode *Result = Emit_109(N, X86::PMULDQrr, MVT::v2i64); 22132 return Result; 22133 } 22134 22135 // Pattern: (intrinsic_wo_chain:v2i64 641:iPTR, VR128:v4i32:$src) 22136 // Emits: (PMOVSXDQrr:v2i64 VR128:v4i32:$src) 22137 // Pattern complexity = 8 cost = 1 size = 3 22138 if (CN1 == INT64_C(641)) { 22139 SDNode *Result = Emit_106(N, X86::PMOVSXDQrr, MVT::v2i64); 22140 return Result; 22141 } 22142 22143 // Pattern: (intrinsic_wo_chain:v2i64 647:iPTR, VR128:v4i32:$src) 22144 // Emits: (PMOVZXDQrr:v2i64 VR128:v4i32:$src) 22145 // Pattern complexity = 8 cost = 1 size = 3 22146 if (CN1 == INT64_C(647)) { 22147 SDNode *Result = Emit_106(N, X86::PMOVZXDQrr, MVT::v2i64); 22148 return Result; 22149 } 22150 22151 // Pattern: (intrinsic_wo_chain:v2i64 643:iPTR, VR128:v8i16:$src) 22152 // Emits: (PMOVSXWQrr:v2i64 VR128:v8i16:$src) 22153 // Pattern complexity = 8 cost = 1 size = 3 22154 if (CN1 == INT64_C(643)) { 22155 SDNode *Result = Emit_106(N, X86::PMOVSXWQrr, MVT::v2i64); 22156 return Result; 22157 } 22158 22159 // Pattern: (intrinsic_wo_chain:v2i64 649:iPTR, VR128:v8i16:$src) 22160 // Emits: (PMOVZXWQrr:v2i64 VR128:v8i16:$src) 22161 // Pattern complexity = 8 cost = 1 size = 3 22162 if (CN1 == INT64_C(649)) { 22163 SDNode *Result = Emit_106(N, X86::PMOVZXWQrr, MVT::v2i64); 22164 return Result; 22165 } 22166 22167 // Pattern: (intrinsic_wo_chain:v2i64 639:iPTR, VR128:v16i8:$src) 22168 // Emits: (PMOVSXBQrr:v2i64 VR128:v16i8:$src) 22169 // Pattern complexity = 8 cost = 1 size = 3 22170 if (CN1 == INT64_C(639)) { 22171 SDNode *Result = Emit_106(N, X86::PMOVSXBQrr, MVT::v2i64); 22172 return Result; 22173 } 22174 22175 // Pattern: (intrinsic_wo_chain:v2i64 645:iPTR, VR128:v16i8:$src) 22176 // Emits: (PMOVZXBQrr:v2i64 VR128:v16i8:$src) 22177 // Pattern complexity = 8 cost = 1 size = 3 22178 if (CN1 == INT64_C(645)) { 22179 SDNode *Result = Emit_106(N, X86::PMOVZXBQrr, MVT::v2i64); 22180 return Result; 22181 } 22182 } 22183 } 22184 22185 // Pattern: (intrinsic_wo_chain:v2i64 670:iPTR, VR128:v2i64:$src1, VR128:v2i64:$src2) 22186 // Emits: (PCMPGTQrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 22187 // Pattern complexity = 8 cost = 1 size = 3 22188 if ((Subtarget->hasSSE42())) { 22189 SDValue N0 = N.getOperand(0); 22190 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 22191 if (Tmp0) { 22192 int64_t CN1 = Tmp0->getSExtValue(); 22193 if (CN1 == INT64_C(670)) { 22194 SDNode *Result = Emit_109(N, X86::PCMPGTQrr, MVT::v2i64); 22195 return Result; 22196 } 22197 } 22198 } 22199 22200 CannotYetSelectIntrinsic(N); 22201 return NULL; 22202 } 22203 22204 SDNode *Emit_134(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPInChain, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4, SDValue &Chain2) DISABLE_INLINE { 22205 SDValue N0 = N.getOperand(0); 22206 SDValue N1 = N.getOperand(1); 22207 SDValue N2 = N.getOperand(2); 22208 SDValue Ops0[] = { N1, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Chain2 }; 22209 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 7); 22210 ReplaceUses(SDValue(CPInChain.getNode(), 1), SDValue(ResNode, 1)); 22211 return ResNode; 22212 } 22213 SDNode *Emit_135(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPInChain, SDValue &CPTmpN1_0, SDValue &CPTmpN1_1, SDValue &CPTmpN1_2, SDValue &CPTmpN1_3, SDValue &CPTmpN1_4, SDValue &Chain1) DISABLE_INLINE { 22214 SDValue N0 = N.getOperand(0); 22215 SDValue N1 = N.getOperand(1); 22216 SDValue Ops0[] = { CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, Chain1 }; 22217 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 6); 22218 ReplaceUses(SDValue(CPInChain.getNode(), 1), SDValue(ResNode, 1)); 22219 return ResNode; 22220 } 22221 SDNode *Emit_136(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 22222 SDValue N0 = N.getOperand(0); 22223 SDValue N1 = N.getOperand(1); 22224 SDValue Chain1 = N1.getOperand(0); 22225 SDValue N11 = N1.getOperand(1); 22226 SDValue N2 = N.getOperand(2); 22227 SDValue Tmp3 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N2)->getZExtValue()), MVT::i32); 22228 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 22229 SDValue Ops0[] = { CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, Tmp3, LSI_N1, Chain1 }; 22230 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 22231 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 22232 return ResNode; 22233 } 22234 SDNode *Emit_137(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPInChain, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4, SDValue &Chain2) DISABLE_INLINE { 22235 SDValue N0 = N.getOperand(0); 22236 SDValue N1 = N.getOperand(1); 22237 SDValue N2 = N.getOperand(2); 22238 SDValue N3 = N.getOperand(3); 22239 SDValue Tmp4 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N3)->getZExtValue()), MVT::i32); 22240 SDValue Ops0[] = { N1, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Tmp4, Chain2 }; 22241 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 22242 ReplaceUses(SDValue(CPInChain.getNode(), 1), SDValue(ResNode, 1)); 22243 return ResNode; 22244 } 22245 SDNode *Select_ISD_INTRINSIC_WO_CHAIN_v4f32(const SDValue &N) { 22246 if (OptLevel != CodeGenOpt::None) { 22247 if ((Subtarget->hasSSE41())) { 22248 SDValue N0 = N.getOperand(0); 22249 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 22250 if (Tmp0) { 22251 int64_t CN1 = Tmp0->getSExtValue(); 22252 22253 // Pattern: (intrinsic_wo_chain:v4f32 613:iPTR, VR128:v4f32:$src1, (bitconvert:v4f32 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), (imm:i32):$src3) 22254 // Emits: (BLENDPSrmi:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2, (imm:i32):$src3) 22255 // Pattern complexity = 36 cost = 1 size = 3 22256 if (CN1 == INT64_C(613)) { 22257 SDValue N1 = N.getOperand(1); 22258 SDValue N2 = N.getOperand(2); 22259 if (N2.getOpcode() == ISD::BIT_CONVERT && 22260 N2.hasOneUse()) { 22261 SDValue N20 = N2.getOperand(0); 22262 if (N20.getOpcode() == ISD::LOAD && 22263 N20.hasOneUse() && 22264 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 22265 SDValue Chain20 = N20.getOperand(0); 22266 if (Predicate_unindexedload(N20.getNode()) && 22267 Predicate_load(N20.getNode()) && 22268 Predicate_memop(N20.getNode())) { 22269 SDValue N201 = N20.getOperand(1); 22270 SDValue CPTmpN201_0; 22271 SDValue CPTmpN201_1; 22272 SDValue CPTmpN201_2; 22273 SDValue CPTmpN201_3; 22274 SDValue CPTmpN201_4; 22275 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4)) { 22276 SDValue N3 = N.getOperand(3); 22277 if (N3.getOpcode() == ISD::Constant && 22278 N20.getNode()->getValueType(0) == MVT::v16i8) { 22279 SDNode *Result = Emit_118(N, X86::BLENDPSrmi, MVT::v4f32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 22280 return Result; 22281 } 22282 } 22283 } 22284 } 22285 } 22286 } 22287 if (CN1 == INT64_C(617)) { 22288 SDValue N1 = N.getOperand(1); 22289 22290 // Pattern: (intrinsic_wo_chain:v4f32 617:iPTR, VR128:v4f32:$src1, (bitconvert:v4f32 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), (imm:i32):$src3) 22291 // Emits: (DPPSrmi:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2, (imm:i32):$src3) 22292 // Pattern complexity = 36 cost = 1 size = 3 22293 { 22294 SDValue N2 = N.getOperand(2); 22295 if (N2.getOpcode() == ISD::BIT_CONVERT && 22296 N2.hasOneUse()) { 22297 SDValue N20 = N2.getOperand(0); 22298 if (N20.getOpcode() == ISD::LOAD && 22299 N20.hasOneUse() && 22300 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 22301 SDValue Chain20 = N20.getOperand(0); 22302 if (Predicate_unindexedload(N20.getNode()) && 22303 Predicate_load(N20.getNode()) && 22304 Predicate_memop(N20.getNode())) { 22305 SDValue N201 = N20.getOperand(1); 22306 SDValue CPTmpN201_0; 22307 SDValue CPTmpN201_1; 22308 SDValue CPTmpN201_2; 22309 SDValue CPTmpN201_3; 22310 SDValue CPTmpN201_4; 22311 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4)) { 22312 SDValue N3 = N.getOperand(3); 22313 if (N3.getOpcode() == ISD::Constant && 22314 N20.getNode()->getValueType(0) == MVT::v16i8) { 22315 SDNode *Result = Emit_118(N, X86::DPPSrmi, MVT::v4f32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 22316 return Result; 22317 } 22318 } 22319 } 22320 } 22321 } 22322 } 22323 22324 // Pattern: (intrinsic_wo_chain:v4f32 617:iPTR, (bitconvert:v4f32 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v4f32:$src1, (imm:i32):$src3) 22325 // Emits: (DPPSrmi:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2, (imm:i32):$src3) 22326 // Pattern complexity = 36 cost = 1 size = 3 22327 if (N1.getOpcode() == ISD::BIT_CONVERT && 22328 N1.hasOneUse()) { 22329 SDValue N10 = N1.getOperand(0); 22330 if (N10.getOpcode() == ISD::LOAD && 22331 N10.hasOneUse() && 22332 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 22333 SDValue Chain10 = N10.getOperand(0); 22334 if (Predicate_unindexedload(N10.getNode()) && 22335 Predicate_load(N10.getNode()) && 22336 Predicate_memop(N10.getNode())) { 22337 SDValue N101 = N10.getOperand(1); 22338 SDValue CPTmpN101_0; 22339 SDValue CPTmpN101_1; 22340 SDValue CPTmpN101_2; 22341 SDValue CPTmpN101_3; 22342 SDValue CPTmpN101_4; 22343 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 22344 SDValue N2 = N.getOperand(2); 22345 SDValue N3 = N.getOperand(3); 22346 if (N3.getOpcode() == ISD::Constant && 22347 N10.getNode()->getValueType(0) == MVT::v16i8) { 22348 SDNode *Result = Emit_125(N, X86::DPPSrmi, MVT::v4f32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 22349 return Result; 22350 } 22351 } 22352 } 22353 } 22354 } 22355 } 22356 } 22357 } 22358 if ((Subtarget->hasSSE1())) { 22359 SDValue N0 = N.getOperand(0); 22360 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 22361 if (Tmp0) { 22362 int64_t CN1 = Tmp0->getSExtValue(); 22363 22364 // Pattern: (intrinsic_wo_chain:v4f32 680:iPTR, VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i8):$cc) 22365 // Emits: (Int_CMPSSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src, (imm:i8):$cc) 22366 // Pattern complexity = 33 cost = 1 size = 3 22367 if (CN1 == INT64_C(680)) { 22368 SDValue N1 = N.getOperand(1); 22369 SDValue N2 = N.getOperand(2); 22370 if (N2.getOpcode() == ISD::LOAD && 22371 N2.hasOneUse() && 22372 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 22373 SDValue Chain2 = N2.getOperand(0); 22374 if (Predicate_unindexedload(N2.getNode()) && 22375 Predicate_load(N2.getNode())) { 22376 SDValue N21 = N2.getOperand(1); 22377 SDValue CPTmpN21_0; 22378 SDValue CPTmpN21_1; 22379 SDValue CPTmpN21_2; 22380 SDValue CPTmpN21_3; 22381 SDValue CPTmpN21_4; 22382 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 22383 SDValue N3 = N.getOperand(3); 22384 if (N3.getOpcode() == ISD::Constant) { 22385 SDNode *Result = Emit_122(N, X86::Int_CMPSSrm, MVT::v4f32, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 22386 return Result; 22387 } 22388 } 22389 } 22390 } 22391 } 22392 22393 // Pattern: (intrinsic_wo_chain:v4f32 679:iPTR, VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (imm:i8):$cc) 22394 // Emits: (CMPPSrmi:v4f32 VR128:v4f32:$src1, addr:iPTR:$src, (imm:i8):$cc) 22395 // Pattern complexity = 33 cost = 1 size = 3 22396 if (CN1 == INT64_C(679)) { 22397 SDValue N1 = N.getOperand(1); 22398 SDValue N2 = N.getOperand(2); 22399 if (N2.getOpcode() == ISD::LOAD && 22400 N2.hasOneUse() && 22401 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 22402 SDValue Chain2 = N2.getOperand(0); 22403 if (Predicate_unindexedload(N2.getNode()) && 22404 Predicate_load(N2.getNode()) && 22405 Predicate_memop(N2.getNode())) { 22406 SDValue N21 = N2.getOperand(1); 22407 SDValue CPTmpN21_0; 22408 SDValue CPTmpN21_1; 22409 SDValue CPTmpN21_2; 22410 SDValue CPTmpN21_3; 22411 SDValue CPTmpN21_4; 22412 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 22413 SDValue N3 = N.getOperand(3); 22414 if (N3.getOpcode() == ISD::Constant) { 22415 SDNode *Result = Emit_122(N, X86::CMPPSrmi, MVT::v4f32, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 22416 return Result; 22417 } 22418 } 22419 } 22420 } 22421 } 22422 } 22423 } 22424 22425 // Pattern: (intrinsic_wo_chain:v4f32 512:iPTR, (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 22426 // Emits: (Int_CVTDQ2PSrm:v4f32 addr:iPTR:$src) 22427 // Pattern complexity = 33 cost = 1 size = 3 22428 if ((Subtarget->hasSSE2())) { 22429 SDValue N0 = N.getOperand(0); 22430 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 22431 if (Tmp0) { 22432 int64_t CN1 = Tmp0->getSExtValue(); 22433 if (CN1 == INT64_C(512)) { 22434 SDValue N1 = N.getOperand(1); 22435 if (N1.getOpcode() == ISD::BIT_CONVERT && 22436 N1.hasOneUse()) { 22437 SDValue N10 = N1.getOperand(0); 22438 if (N10.getOpcode() == ISD::LOAD && 22439 N10.hasOneUse() && 22440 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 22441 SDValue Chain10 = N10.getOperand(0); 22442 if (Predicate_unindexedload(N10.getNode()) && 22443 Predicate_load(N10.getNode()) && 22444 Predicate_memop(N10.getNode())) { 22445 SDValue N101 = N10.getOperand(1); 22446 SDValue CPTmpN101_0; 22447 SDValue CPTmpN101_1; 22448 SDValue CPTmpN101_2; 22449 SDValue CPTmpN101_3; 22450 SDValue CPTmpN101_4; 22451 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 22452 N10.getNode()->getValueType(0) == MVT::v2i64) { 22453 SDNode *Result = Emit_114(N, X86::Int_CVTDQ2PSrm, MVT::v4f32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 22454 return Result; 22455 } 22456 } 22457 } 22458 } 22459 } 22460 } 22461 } 22462 if ((Subtarget->hasSSE41())) { 22463 SDValue N0 = N.getOperand(0); 22464 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 22465 if (Tmp0) { 22466 int64_t CN1 = Tmp0->getSExtValue(); 22467 22468 // Pattern: (intrinsic_wo_chain:v4f32 656:iPTR, (ld:v4f32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (imm:i32):$src2) 22469 // Emits: (ROUNDPSm_Int:v4f32 addr:iPTR:$src1, (imm:i32):$src2) 22470 // Pattern complexity = 33 cost = 1 size = 3 22471 if (CN1 == INT64_C(656)) { 22472 SDValue N1 = N.getOperand(1); 22473 if (N1.getOpcode() == ISD::LOAD && 22474 N1.hasOneUse() && 22475 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 22476 SDValue Chain1 = N1.getOperand(0); 22477 if (Predicate_unindexedload(N1.getNode()) && 22478 Predicate_load(N1.getNode()) && 22479 Predicate_memop(N1.getNode())) { 22480 SDValue N11 = N1.getOperand(1); 22481 SDValue CPTmpN11_0; 22482 SDValue CPTmpN11_1; 22483 SDValue CPTmpN11_2; 22484 SDValue CPTmpN11_3; 22485 SDValue CPTmpN11_4; 22486 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 22487 SDValue N2 = N.getOperand(2); 22488 if (N2.getOpcode() == ISD::Constant) { 22489 SDNode *Result = Emit_136(N, X86::ROUNDPSm_Int, MVT::v4f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 22490 return Result; 22491 } 22492 } 22493 } 22494 } 22495 } 22496 22497 // Pattern: (intrinsic_wo_chain:v4f32 615:iPTR, VR128:v4f32:$src1, (bitconvert:v4f32 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), XMM0:v4f32) 22498 // Emits: (BLENDVPSrm0:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 22499 // Pattern complexity = 33 cost = 1 size = 3 22500 if (CN1 == INT64_C(615)) { 22501 SDValue N1 = N.getOperand(1); 22502 SDValue N2 = N.getOperand(2); 22503 if (N2.getOpcode() == ISD::BIT_CONVERT && 22504 N2.hasOneUse()) { 22505 SDValue N20 = N2.getOperand(0); 22506 if (N20.getOpcode() == ISD::LOAD && 22507 N20.hasOneUse() && 22508 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 22509 SDValue Chain20 = N20.getOperand(0); 22510 if (Predicate_unindexedload(N20.getNode()) && 22511 Predicate_load(N20.getNode()) && 22512 Predicate_memop(N20.getNode())) { 22513 SDValue N201 = N20.getOperand(1); 22514 SDValue CPTmpN201_0; 22515 SDValue CPTmpN201_1; 22516 SDValue CPTmpN201_2; 22517 SDValue CPTmpN201_3; 22518 SDValue CPTmpN201_4; 22519 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4)) { 22520 SDValue N3 = N.getOperand(3); 22521 if (N20.getNode()->getValueType(0) == MVT::v16i8) { 22522 SDNode *Result = Emit_120(N, X86::BLENDVPSrm0, MVT::v4f32, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 22523 return Result; 22524 } 22525 } 22526 } 22527 } 22528 } 22529 } 22530 } 22531 } 22532 if ((Subtarget->hasSSE1())) { 22533 SDValue N0 = N.getOperand(0); 22534 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 22535 if (Tmp0) { 22536 int64_t CN1 = Tmp0->getSExtValue(); 22537 22538 // Pattern: (intrinsic_wo_chain:v4f32 692:iPTR, VR128:v4f32:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>) 22539 // Emits: (Int_CVTSI2SS64rm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 22540 // Pattern complexity = 30 cost = 1 size = 3 22541 if (CN1 == INT64_C(692)) { 22542 SDValue N1 = N.getOperand(1); 22543 SDValue N2 = N.getOperand(2); 22544 if (N2.getOpcode() == ISD::LOAD && 22545 N2.hasOneUse() && 22546 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 22547 SDValue Chain2 = N2.getOperand(0); 22548 if (Predicate_unindexedload(N2.getNode()) && 22549 Predicate_load(N2.getNode()) && 22550 Predicate_loadi64(N2.getNode())) { 22551 SDValue N21 = N2.getOperand(1); 22552 SDValue CPTmpN21_0; 22553 SDValue CPTmpN21_1; 22554 SDValue CPTmpN21_2; 22555 SDValue CPTmpN21_3; 22556 SDValue CPTmpN21_4; 22557 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 22558 SDNode *Result = Emit_108(N, X86::Int_CVTSI2SS64rm, MVT::v4f32, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 22559 return Result; 22560 } 22561 } 22562 } 22563 } 22564 22565 // Pattern: (intrinsic_wo_chain:v4f32 689:iPTR, VR128:v4f32:$src1, (ld:v2i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 22566 // Emits: (Int_CVTPI2PSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 22567 // Pattern complexity = 30 cost = 1 size = 3 22568 if (CN1 == INT64_C(689)) { 22569 SDValue N1 = N.getOperand(1); 22570 SDValue N2 = N.getOperand(2); 22571 if (N2.getOpcode() == ISD::LOAD && 22572 N2.hasOneUse() && 22573 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 22574 SDValue Chain2 = N2.getOperand(0); 22575 if (Predicate_unindexedload(N2.getNode()) && 22576 Predicate_load(N2.getNode())) { 22577 SDValue N21 = N2.getOperand(1); 22578 SDValue CPTmpN21_0; 22579 SDValue CPTmpN21_1; 22580 SDValue CPTmpN21_2; 22581 SDValue CPTmpN21_3; 22582 SDValue CPTmpN21_4; 22583 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 22584 SDNode *Result = Emit_108(N, X86::Int_CVTPI2PSrm, MVT::v4f32, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 22585 return Result; 22586 } 22587 } 22588 } 22589 } 22590 22591 // Pattern: (intrinsic_wo_chain:v4f32 691:iPTR, VR128:v4f32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>) 22592 // Emits: (Int_CVTSI2SSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 22593 // Pattern complexity = 30 cost = 1 size = 3 22594 if (CN1 == INT64_C(691)) { 22595 SDValue N1 = N.getOperand(1); 22596 SDValue N2 = N.getOperand(2); 22597 if (N2.getOpcode() == ISD::LOAD && 22598 N2.hasOneUse() && 22599 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 22600 SDValue Chain2 = N2.getOperand(0); 22601 if (Predicate_unindexedload(N2.getNode()) && 22602 Predicate_loadi32(N2.getNode())) { 22603 SDValue N21 = N2.getOperand(1); 22604 SDValue CPTmpN21_0; 22605 SDValue CPTmpN21_1; 22606 SDValue CPTmpN21_2; 22607 SDValue CPTmpN21_3; 22608 SDValue CPTmpN21_4; 22609 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 22610 SDNode *Result = Emit_108(N, X86::Int_CVTSI2SSrm, MVT::v4f32, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 22611 return Result; 22612 } 22613 } 22614 } 22615 } 22616 22617 // Pattern: (intrinsic_wo_chain:v4f32 702:iPTR, VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 22618 // Emits: (MAXPSrm_Int:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 22619 // Pattern complexity = 30 cost = 1 size = 3 22620 if (CN1 == INT64_C(702)) { 22621 SDValue N1 = N.getOperand(1); 22622 SDValue N2 = N.getOperand(2); 22623 if (N2.getOpcode() == ISD::LOAD && 22624 N2.hasOneUse() && 22625 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 22626 SDValue Chain2 = N2.getOperand(0); 22627 if (Predicate_unindexedload(N2.getNode()) && 22628 Predicate_load(N2.getNode()) && 22629 Predicate_memop(N2.getNode())) { 22630 SDValue N21 = N2.getOperand(1); 22631 SDValue CPTmpN21_0; 22632 SDValue CPTmpN21_1; 22633 SDValue CPTmpN21_2; 22634 SDValue CPTmpN21_3; 22635 SDValue CPTmpN21_4; 22636 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 22637 SDNode *Result = Emit_108(N, X86::MAXPSrm_Int, MVT::v4f32, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 22638 return Result; 22639 } 22640 } 22641 } 22642 } 22643 22644 // Pattern: (intrinsic_wo_chain:v4f32 704:iPTR, VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 22645 // Emits: (MINPSrm_Int:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 22646 // Pattern complexity = 30 cost = 1 size = 3 22647 if (CN1 == INT64_C(704)) { 22648 SDValue N1 = N.getOperand(1); 22649 SDValue N2 = N.getOperand(2); 22650 if (N2.getOpcode() == ISD::LOAD && 22651 N2.hasOneUse() && 22652 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 22653 SDValue Chain2 = N2.getOperand(0); 22654 if (Predicate_unindexedload(N2.getNode()) && 22655 Predicate_load(N2.getNode()) && 22656 Predicate_memop(N2.getNode())) { 22657 SDValue N21 = N2.getOperand(1); 22658 SDValue CPTmpN21_0; 22659 SDValue CPTmpN21_1; 22660 SDValue CPTmpN21_2; 22661 SDValue CPTmpN21_3; 22662 SDValue CPTmpN21_4; 22663 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 22664 SDNode *Result = Emit_108(N, X86::MINPSrm_Int, MVT::v4f32, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 22665 return Result; 22666 } 22667 } 22668 } 22669 } 22670 22671 // Pattern: (intrinsic_wo_chain:v4f32 714:iPTR, (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 22672 // Emits: (SQRTPSm_Int:v4f32 addr:iPTR:$src) 22673 // Pattern complexity = 30 cost = 1 size = 3 22674 if (CN1 == INT64_C(714)) { 22675 SDValue N1 = N.getOperand(1); 22676 if (N1.getOpcode() == ISD::LOAD && 22677 N1.hasOneUse() && 22678 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 22679 SDValue Chain1 = N1.getOperand(0); 22680 if (Predicate_unindexedload(N1.getNode()) && 22681 Predicate_load(N1.getNode()) && 22682 Predicate_memop(N1.getNode())) { 22683 SDValue N11 = N1.getOperand(1); 22684 SDValue CPTmpN11_0; 22685 SDValue CPTmpN11_1; 22686 SDValue CPTmpN11_2; 22687 SDValue CPTmpN11_3; 22688 SDValue CPTmpN11_4; 22689 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 22690 SDNode *Result = Emit_107(N, X86::SQRTPSm_Int, MVT::v4f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 22691 return Result; 22692 } 22693 } 22694 } 22695 } 22696 22697 // Pattern: (intrinsic_wo_chain:v4f32 711:iPTR, (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 22698 // Emits: (RSQRTPSm_Int:v4f32 addr:iPTR:$src) 22699 // Pattern complexity = 30 cost = 1 size = 3 22700 if (CN1 == INT64_C(711)) { 22701 SDValue N1 = N.getOperand(1); 22702 if (N1.getOpcode() == ISD::LOAD && 22703 N1.hasOneUse() && 22704 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 22705 SDValue Chain1 = N1.getOperand(0); 22706 if (Predicate_unindexedload(N1.getNode()) && 22707 Predicate_load(N1.getNode()) && 22708 Predicate_memop(N1.getNode())) { 22709 SDValue N11 = N1.getOperand(1); 22710 SDValue CPTmpN11_0; 22711 SDValue CPTmpN11_1; 22712 SDValue CPTmpN11_2; 22713 SDValue CPTmpN11_3; 22714 SDValue CPTmpN11_4; 22715 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 22716 SDNode *Result = Emit_107(N, X86::RSQRTPSm_Int, MVT::v4f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 22717 return Result; 22718 } 22719 } 22720 } 22721 } 22722 22723 // Pattern: (intrinsic_wo_chain:v4f32 709:iPTR, (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 22724 // Emits: (RCPPSm_Int:v4f32 addr:iPTR:$src) 22725 // Pattern complexity = 30 cost = 1 size = 3 22726 if (CN1 == INT64_C(709)) { 22727 SDValue N1 = N.getOperand(1); 22728 if (N1.getOpcode() == ISD::LOAD && 22729 N1.hasOneUse() && 22730 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 22731 SDValue Chain1 = N1.getOperand(0); 22732 if (Predicate_unindexedload(N1.getNode()) && 22733 Predicate_load(N1.getNode()) && 22734 Predicate_memop(N1.getNode())) { 22735 SDValue N11 = N1.getOperand(1); 22736 SDValue CPTmpN11_0; 22737 SDValue CPTmpN11_1; 22738 SDValue CPTmpN11_2; 22739 SDValue CPTmpN11_3; 22740 SDValue CPTmpN11_4; 22741 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 22742 SDNode *Result = Emit_107(N, X86::RCPPSm_Int, MVT::v4f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 22743 return Result; 22744 } 22745 } 22746 } 22747 } 22748 } 22749 } 22750 if ((Subtarget->hasSSE2())) { 22751 SDValue N0 = N.getOperand(0); 22752 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 22753 if (Tmp0) { 22754 int64_t CN1 = Tmp0->getSExtValue(); 22755 22756 // Pattern: (intrinsic_wo_chain:v4f32 514:iPTR, (ld:v2f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 22757 // Emits: (Int_CVTPD2PSrm:v4f32 addr:iPTR:$src) 22758 // Pattern complexity = 30 cost = 1 size = 3 22759 if (CN1 == INT64_C(514)) { 22760 SDValue N1 = N.getOperand(1); 22761 if (N1.getOpcode() == ISD::LOAD && 22762 N1.hasOneUse() && 22763 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 22764 SDValue Chain1 = N1.getOperand(0); 22765 if (Predicate_unindexedload(N1.getNode()) && 22766 Predicate_load(N1.getNode()) && 22767 Predicate_memop(N1.getNode())) { 22768 SDValue N11 = N1.getOperand(1); 22769 SDValue CPTmpN11_0; 22770 SDValue CPTmpN11_1; 22771 SDValue CPTmpN11_2; 22772 SDValue CPTmpN11_3; 22773 SDValue CPTmpN11_4; 22774 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 22775 SDNode *Result = Emit_107(N, X86::Int_CVTPD2PSrm, MVT::v4f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 22776 return Result; 22777 } 22778 } 22779 } 22780 } 22781 22782 // Pattern: (intrinsic_wo_chain:v4f32 519:iPTR, VR128:v4f32:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 22783 // Emits: (Int_CVTSD2SSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 22784 // Pattern complexity = 30 cost = 1 size = 3 22785 if (CN1 == INT64_C(519)) { 22786 SDValue N1 = N.getOperand(1); 22787 SDValue N2 = N.getOperand(2); 22788 if (N2.getOpcode() == ISD::LOAD && 22789 N2.hasOneUse() && 22790 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 22791 SDValue Chain2 = N2.getOperand(0); 22792 if (Predicate_unindexedload(N2.getNode()) && 22793 Predicate_load(N2.getNode())) { 22794 SDValue N21 = N2.getOperand(1); 22795 SDValue CPTmpN21_0; 22796 SDValue CPTmpN21_1; 22797 SDValue CPTmpN21_2; 22798 SDValue CPTmpN21_3; 22799 SDValue CPTmpN21_4; 22800 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 22801 SDNode *Result = Emit_108(N, X86::Int_CVTSD2SSrm, MVT::v4f32, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 22802 return Result; 22803 } 22804 } 22805 } 22806 } 22807 } 22808 } 22809 if ((Subtarget->hasSSE3())) { 22810 SDValue N0 = N.getOperand(0); 22811 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 22812 if (Tmp0) { 22813 int64_t CN1 = Tmp0->getSExtValue(); 22814 22815 // Pattern: (intrinsic_wo_chain:v4f32 604:iPTR, VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 22816 // Emits: (ADDSUBPSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 22817 // Pattern complexity = 30 cost = 1 size = 3 22818 if (CN1 == INT64_C(604)) { 22819 SDValue N1 = N.getOperand(1); 22820 SDValue N2 = N.getOperand(2); 22821 if (N2.getOpcode() == ISD::LOAD && 22822 N2.hasOneUse() && 22823 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 22824 SDValue Chain2 = N2.getOperand(0); 22825 if (Predicate_unindexedload(N2.getNode()) && 22826 Predicate_load(N2.getNode()) && 22827 Predicate_memop(N2.getNode())) { 22828 SDValue N21 = N2.getOperand(1); 22829 SDValue CPTmpN21_0; 22830 SDValue CPTmpN21_1; 22831 SDValue CPTmpN21_2; 22832 SDValue CPTmpN21_3; 22833 SDValue CPTmpN21_4; 22834 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 22835 SDNode *Result = Emit_108(N, X86::ADDSUBPSrm, MVT::v4f32, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 22836 return Result; 22837 } 22838 } 22839 } 22840 } 22841 22842 // Pattern: (intrinsic_wo_chain:v4f32 606:iPTR, VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 22843 // Emits: (HADDPSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 22844 // Pattern complexity = 30 cost = 1 size = 3 22845 if (CN1 == INT64_C(606)) { 22846 SDValue N1 = N.getOperand(1); 22847 SDValue N2 = N.getOperand(2); 22848 if (N2.getOpcode() == ISD::LOAD && 22849 N2.hasOneUse() && 22850 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 22851 SDValue Chain2 = N2.getOperand(0); 22852 if (Predicate_unindexedload(N2.getNode()) && 22853 Predicate_load(N2.getNode()) && 22854 Predicate_memop(N2.getNode())) { 22855 SDValue N21 = N2.getOperand(1); 22856 SDValue CPTmpN21_0; 22857 SDValue CPTmpN21_1; 22858 SDValue CPTmpN21_2; 22859 SDValue CPTmpN21_3; 22860 SDValue CPTmpN21_4; 22861 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 22862 SDNode *Result = Emit_108(N, X86::HADDPSrm, MVT::v4f32, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 22863 return Result; 22864 } 22865 } 22866 } 22867 } 22868 22869 // Pattern: (intrinsic_wo_chain:v4f32 608:iPTR, VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 22870 // Emits: (HSUBPSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 22871 // Pattern complexity = 30 cost = 1 size = 3 22872 if (CN1 == INT64_C(608)) { 22873 SDValue N1 = N.getOperand(1); 22874 SDValue N2 = N.getOperand(2); 22875 if (N2.getOpcode() == ISD::LOAD && 22876 N2.hasOneUse() && 22877 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 22878 SDValue Chain2 = N2.getOperand(0); 22879 if (Predicate_unindexedload(N2.getNode()) && 22880 Predicate_load(N2.getNode()) && 22881 Predicate_memop(N2.getNode())) { 22882 SDValue N21 = N2.getOperand(1); 22883 SDValue CPTmpN21_0; 22884 SDValue CPTmpN21_1; 22885 SDValue CPTmpN21_2; 22886 SDValue CPTmpN21_3; 22887 SDValue CPTmpN21_4; 22888 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 22889 SDNode *Result = Emit_108(N, X86::HSUBPSrm, MVT::v4f32, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 22890 return Result; 22891 } 22892 } 22893 } 22894 } 22895 } 22896 } 22897 22898 // Pattern: (intrinsic_wo_chain:v4f32 658:iPTR, VR128:v4f32:$src1, sse_load_f32:v4f32:$src2, (imm:i32):$src3) 22899 // Emits: (ROUNDSSm_Int:v4f32 VR128:v4f32:$src1, sse_load_f32:v4f32:$src2, (imm:i32):$src3) 22900 // Pattern complexity = 29 cost = 1 size = 3 22901 if ((Subtarget->hasSSE41())) { 22902 SDValue N0 = N.getOperand(0); 22903 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 22904 if (Tmp0) { 22905 int64_t CN1 = Tmp0->getSExtValue(); 22906 if (CN1 == INT64_C(658)) { 22907 SDValue N1 = N.getOperand(1); 22908 SDValue N2 = N.getOperand(2); 22909 SDValue CPTmpN2_0; 22910 SDValue CPTmpN2_1; 22911 SDValue CPTmpN2_2; 22912 SDValue CPTmpN2_3; 22913 SDValue CPTmpN2_4; 22914 SDValue CPInChain; 22915 SDValue Chain2; 22916 if (SelectScalarSSELoad(N, N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, CPInChain, Chain2)) { 22917 SDValue N3 = N.getOperand(3); 22918 if (N3.getOpcode() == ISD::Constant) { 22919 SDNode *Result = Emit_137(N, X86::ROUNDSSm_Int, MVT::v4f32, CPInChain, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Chain2); 22920 return Result; 22921 } 22922 } 22923 } 22924 } 22925 } 22926 if ((Subtarget->hasSSE1())) { 22927 SDValue N0 = N.getOperand(0); 22928 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 22929 if (Tmp0) { 22930 int64_t CN1 = Tmp0->getSExtValue(); 22931 22932 // Pattern: (intrinsic_wo_chain:v4f32 678:iPTR, VR128:v4f32:$src1, sse_load_f32:v4f32:$src2) 22933 // Emits: (ADDSSrm_Int:v4f32 VR128:v4f32:$src1, sse_load_f32:v4f32:$src2) 22934 // Pattern complexity = 26 cost = 1 size = 3 22935 if (CN1 == INT64_C(678)) { 22936 SDValue N1 = N.getOperand(1); 22937 SDValue N2 = N.getOperand(2); 22938 SDValue CPTmpN2_0; 22939 SDValue CPTmpN2_1; 22940 SDValue CPTmpN2_2; 22941 SDValue CPTmpN2_3; 22942 SDValue CPTmpN2_4; 22943 SDValue CPInChain; 22944 SDValue Chain2; 22945 if (SelectScalarSSELoad(N, N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, CPInChain, Chain2)) { 22946 SDNode *Result = Emit_134(N, X86::ADDSSrm_Int, MVT::v4f32, CPInChain, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Chain2); 22947 return Result; 22948 } 22949 } 22950 22951 // Pattern: (intrinsic_wo_chain:v4f32 708:iPTR, VR128:v4f32:$src1, sse_load_f32:v4f32:$src2) 22952 // Emits: (MULSSrm_Int:v4f32 VR128:v4f32:$src1, sse_load_f32:v4f32:$src2) 22953 // Pattern complexity = 26 cost = 1 size = 3 22954 if (CN1 == INT64_C(708)) { 22955 SDValue N1 = N.getOperand(1); 22956 SDValue N2 = N.getOperand(2); 22957 SDValue CPTmpN2_0; 22958 SDValue CPTmpN2_1; 22959 SDValue CPTmpN2_2; 22960 SDValue CPTmpN2_3; 22961 SDValue CPTmpN2_4; 22962 SDValue CPInChain; 22963 SDValue Chain2; 22964 if (SelectScalarSSELoad(N, N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, CPInChain, Chain2)) { 22965 SDNode *Result = Emit_134(N, X86::MULSSrm_Int, MVT::v4f32, CPInChain, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Chain2); 22966 return Result; 22967 } 22968 } 22969 22970 // Pattern: (intrinsic_wo_chain:v4f32 718:iPTR, VR128:v4f32:$src1, sse_load_f32:v4f32:$src2) 22971 // Emits: (SUBSSrm_Int:v4f32 VR128:v4f32:$src1, sse_load_f32:v4f32:$src2) 22972 // Pattern complexity = 26 cost = 1 size = 3 22973 if (CN1 == INT64_C(718)) { 22974 SDValue N1 = N.getOperand(1); 22975 SDValue N2 = N.getOperand(2); 22976 SDValue CPTmpN2_0; 22977 SDValue CPTmpN2_1; 22978 SDValue CPTmpN2_2; 22979 SDValue CPTmpN2_3; 22980 SDValue CPTmpN2_4; 22981 SDValue CPInChain; 22982 SDValue Chain2; 22983 if (SelectScalarSSELoad(N, N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, CPInChain, Chain2)) { 22984 SDNode *Result = Emit_134(N, X86::SUBSSrm_Int, MVT::v4f32, CPInChain, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Chain2); 22985 return Result; 22986 } 22987 } 22988 22989 // Pattern: (intrinsic_wo_chain:v4f32 699:iPTR, VR128:v4f32:$src1, sse_load_f32:v4f32:$src2) 22990 // Emits: (DIVSSrm_Int:v4f32 VR128:v4f32:$src1, sse_load_f32:v4f32:$src2) 22991 // Pattern complexity = 26 cost = 1 size = 3 22992 if (CN1 == INT64_C(699)) { 22993 SDValue N1 = N.getOperand(1); 22994 SDValue N2 = N.getOperand(2); 22995 SDValue CPTmpN2_0; 22996 SDValue CPTmpN2_1; 22997 SDValue CPTmpN2_2; 22998 SDValue CPTmpN2_3; 22999 SDValue CPTmpN2_4; 23000 SDValue CPInChain; 23001 SDValue Chain2; 23002 if (SelectScalarSSELoad(N, N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, CPInChain, Chain2)) { 23003 SDNode *Result = Emit_134(N, X86::DIVSSrm_Int, MVT::v4f32, CPInChain, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Chain2); 23004 return Result; 23005 } 23006 } 23007 23008 // Pattern: (intrinsic_wo_chain:v4f32 703:iPTR, VR128:v4f32:$src1, sse_load_f32:v4f32:$src2) 23009 // Emits: (MAXSSrm_Int:v4f32 VR128:v4f32:$src1, sse_load_f32:v4f32:$src2) 23010 // Pattern complexity = 26 cost = 1 size = 3 23011 if (CN1 == INT64_C(703)) { 23012 SDValue N1 = N.getOperand(1); 23013 SDValue N2 = N.getOperand(2); 23014 SDValue CPTmpN2_0; 23015 SDValue CPTmpN2_1; 23016 SDValue CPTmpN2_2; 23017 SDValue CPTmpN2_3; 23018 SDValue CPTmpN2_4; 23019 SDValue CPInChain; 23020 SDValue Chain2; 23021 if (SelectScalarSSELoad(N, N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, CPInChain, Chain2)) { 23022 SDNode *Result = Emit_134(N, X86::MAXSSrm_Int, MVT::v4f32, CPInChain, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Chain2); 23023 return Result; 23024 } 23025 } 23026 23027 // Pattern: (intrinsic_wo_chain:v4f32 705:iPTR, VR128:v4f32:$src1, sse_load_f32:v4f32:$src2) 23028 // Emits: (MINSSrm_Int:v4f32 VR128:v4f32:$src1, sse_load_f32:v4f32:$src2) 23029 // Pattern complexity = 26 cost = 1 size = 3 23030 if (CN1 == INT64_C(705)) { 23031 SDValue N1 = N.getOperand(1); 23032 SDValue N2 = N.getOperand(2); 23033 SDValue CPTmpN2_0; 23034 SDValue CPTmpN2_1; 23035 SDValue CPTmpN2_2; 23036 SDValue CPTmpN2_3; 23037 SDValue CPTmpN2_4; 23038 SDValue CPInChain; 23039 SDValue Chain2; 23040 if (SelectScalarSSELoad(N, N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, CPInChain, Chain2)) { 23041 SDNode *Result = Emit_134(N, X86::MINSSrm_Int, MVT::v4f32, CPInChain, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Chain2); 23042 return Result; 23043 } 23044 } 23045 23046 // Pattern: (intrinsic_wo_chain:v4f32 715:iPTR, sse_load_f32:v4f32:$src) 23047 // Emits: (SQRTSSm_Int:v4f32 sse_load_f32:v4f32:$src) 23048 // Pattern complexity = 26 cost = 1 size = 3 23049 if (CN1 == INT64_C(715)) { 23050 SDValue N1 = N.getOperand(1); 23051 SDValue CPTmpN1_0; 23052 SDValue CPTmpN1_1; 23053 SDValue CPTmpN1_2; 23054 SDValue CPTmpN1_3; 23055 SDValue CPTmpN1_4; 23056 SDValue CPInChain; 23057 SDValue Chain1; 23058 if (SelectScalarSSELoad(N, N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, CPInChain, Chain1)) { 23059 SDNode *Result = Emit_135(N, X86::SQRTSSm_Int, MVT::v4f32, CPInChain, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, Chain1); 23060 return Result; 23061 } 23062 } 23063 23064 // Pattern: (intrinsic_wo_chain:v4f32 712:iPTR, sse_load_f32:v4f32:$src) 23065 // Emits: (RSQRTSSm_Int:v4f32 sse_load_f32:v4f32:$src) 23066 // Pattern complexity = 26 cost = 1 size = 3 23067 if (CN1 == INT64_C(712)) { 23068 SDValue N1 = N.getOperand(1); 23069 SDValue CPTmpN1_0; 23070 SDValue CPTmpN1_1; 23071 SDValue CPTmpN1_2; 23072 SDValue CPTmpN1_3; 23073 SDValue CPTmpN1_4; 23074 SDValue CPInChain; 23075 SDValue Chain1; 23076 if (SelectScalarSSELoad(N, N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, CPInChain, Chain1)) { 23077 SDNode *Result = Emit_135(N, X86::RSQRTSSm_Int, MVT::v4f32, CPInChain, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, Chain1); 23078 return Result; 23079 } 23080 } 23081 23082 // Pattern: (intrinsic_wo_chain:v4f32 710:iPTR, sse_load_f32:v4f32:$src) 23083 // Emits: (RCPSSm_Int:v4f32 sse_load_f32:v4f32:$src) 23084 // Pattern complexity = 26 cost = 1 size = 3 23085 if (CN1 == INT64_C(710)) { 23086 SDValue N1 = N.getOperand(1); 23087 SDValue CPTmpN1_0; 23088 SDValue CPTmpN1_1; 23089 SDValue CPTmpN1_2; 23090 SDValue CPTmpN1_3; 23091 SDValue CPTmpN1_4; 23092 SDValue CPInChain; 23093 SDValue Chain1; 23094 if (SelectScalarSSELoad(N, N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, CPInChain, Chain1)) { 23095 SDNode *Result = Emit_135(N, X86::RCPSSm_Int, MVT::v4f32, CPInChain, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, Chain1); 23096 return Result; 23097 } 23098 } 23099 } 23100 } 23101 } 23102 if ((Subtarget->hasSSE1())) { 23103 SDValue N0 = N.getOperand(0); 23104 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 23105 if (Tmp0) { 23106 int64_t CN1 = Tmp0->getSExtValue(); 23107 23108 // Pattern: (intrinsic_wo_chain:v4f32 680:iPTR, VR128:v4f32:$src1, VR128:v4f32:$src, (imm:i8):$cc) 23109 // Emits: (Int_CMPSSrr:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src, (imm:i8):$cc) 23110 // Pattern complexity = 11 cost = 1 size = 3 23111 if (CN1 == INT64_C(680)) { 23112 SDValue N1 = N.getOperand(1); 23113 SDValue N2 = N.getOperand(2); 23114 SDValue N3 = N.getOperand(3); 23115 if (N3.getOpcode() == ISD::Constant) { 23116 SDNode *Result = Emit_121(N, X86::Int_CMPSSrr, MVT::v4f32); 23117 return Result; 23118 } 23119 } 23120 23121 // Pattern: (intrinsic_wo_chain:v4f32 679:iPTR, VR128:v4f32:$src1, VR128:v4f32:$src, (imm:i8):$cc) 23122 // Emits: (CMPPSrri:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src, (imm:i8):$cc) 23123 // Pattern complexity = 11 cost = 1 size = 3 23124 if (CN1 == INT64_C(679)) { 23125 SDValue N1 = N.getOperand(1); 23126 SDValue N2 = N.getOperand(2); 23127 SDValue N3 = N.getOperand(3); 23128 if (N3.getOpcode() == ISD::Constant) { 23129 SDNode *Result = Emit_121(N, X86::CMPPSrri, MVT::v4f32); 23130 return Result; 23131 } 23132 } 23133 } 23134 } 23135 if ((Subtarget->hasSSE41())) { 23136 SDValue N0 = N.getOperand(0); 23137 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 23138 if (Tmp0) { 23139 int64_t CN1 = Tmp0->getSExtValue(); 23140 23141 // Pattern: (intrinsic_wo_chain:v4f32 656:iPTR, VR128:v4f32:$src1, (imm:i32):$src2) 23142 // Emits: (ROUNDPSr_Int:v4f32 VR128:v4f32:$src1, (imm:i32):$src2) 23143 // Pattern complexity = 11 cost = 1 size = 3 23144 if (CN1 == INT64_C(656)) { 23145 SDValue N1 = N.getOperand(1); 23146 SDValue N2 = N.getOperand(2); 23147 if (N2.getOpcode() == ISD::Constant) { 23148 SDNode *Result = Emit_126(N, X86::ROUNDPSr_Int, MVT::v4f32); 23149 return Result; 23150 } 23151 } 23152 23153 // Pattern: (intrinsic_wo_chain:v4f32 658:iPTR, VR128:v4f32:$src1, VR128:v4f32:$src2, (imm:i32):$src3) 23154 // Emits: (ROUNDSSr_Int:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2, (imm:i32):$src3) 23155 // Pattern complexity = 11 cost = 1 size = 3 23156 if (CN1 == INT64_C(658)) { 23157 SDValue N1 = N.getOperand(1); 23158 SDValue N2 = N.getOperand(2); 23159 SDValue N3 = N.getOperand(3); 23160 if (N3.getOpcode() == ISD::Constant) { 23161 SDNode *Result = Emit_117(N, X86::ROUNDSSr_Int, MVT::v4f32); 23162 return Result; 23163 } 23164 } 23165 23166 // Pattern: (intrinsic_wo_chain:v4f32 613:iPTR, VR128:v4f32:$src1, VR128:v4f32:$src2, (imm:i32):$src3) 23167 // Emits: (BLENDPSrri:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2, (imm:i32):$src3) 23168 // Pattern complexity = 11 cost = 1 size = 3 23169 if (CN1 == INT64_C(613)) { 23170 SDValue N1 = N.getOperand(1); 23171 SDValue N2 = N.getOperand(2); 23172 SDValue N3 = N.getOperand(3); 23173 if (N3.getOpcode() == ISD::Constant) { 23174 SDNode *Result = Emit_117(N, X86::BLENDPSrri, MVT::v4f32); 23175 return Result; 23176 } 23177 } 23178 23179 // Pattern: (intrinsic_wo_chain:v4f32 617:iPTR, VR128:v4f32:$src1, VR128:v4f32:$src2, (imm:i32):$src3) 23180 // Emits: (DPPSrri:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2, (imm:i32):$src3) 23181 // Pattern complexity = 11 cost = 1 size = 3 23182 if (CN1 == INT64_C(617)) { 23183 SDValue N1 = N.getOperand(1); 23184 SDValue N2 = N.getOperand(2); 23185 SDValue N3 = N.getOperand(3); 23186 if (N3.getOpcode() == ISD::Constant) { 23187 SDNode *Result = Emit_117(N, X86::DPPSrri, MVT::v4f32); 23188 return Result; 23189 } 23190 } 23191 } 23192 } 23193 23194 // Pattern: (intrinsic_wo_chain:v4f32 619:iPTR, VR128:v4f32:$src1, VR128:v4f32:$src2, (imm:i32):$src3) 23195 // Emits: (INSERTPSrr:v4f32 VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i32):$src3) 23196 // Pattern complexity = 11 cost = 1 size = 3 23197 { 23198 SDValue N0 = N.getOperand(0); 23199 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 23200 if (Tmp0) { 23201 int64_t CN1 = Tmp0->getSExtValue(); 23202 if (CN1 == INT64_C(619)) { 23203 SDValue N1 = N.getOperand(1); 23204 SDValue N2 = N.getOperand(2); 23205 SDValue N3 = N.getOperand(3); 23206 if (N3.getOpcode() == ISD::Constant) { 23207 SDNode *Result = Emit_117(N, X86::INSERTPSrr, MVT::v4f32); 23208 return Result; 23209 } 23210 } 23211 } 23212 } 23213 if ((Subtarget->hasSSE1())) { 23214 SDValue N0 = N.getOperand(0); 23215 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 23216 if (Tmp0) { 23217 int64_t CN1 = Tmp0->getSExtValue(); 23218 23219 // Pattern: (intrinsic_wo_chain:v4f32 692:iPTR, VR128:v4f32:$src1, GR64:i64:$src2) 23220 // Emits: (Int_CVTSI2SS64rr:v4f32 VR128:v4f32:$src1, GR64:i64:$src2) 23221 // Pattern complexity = 8 cost = 1 size = 3 23222 if (CN1 == INT64_C(692)) { 23223 SDNode *Result = Emit_109(N, X86::Int_CVTSI2SS64rr, MVT::v4f32); 23224 return Result; 23225 } 23226 23227 // Pattern: (intrinsic_wo_chain:v4f32 689:iPTR, VR128:v4f32:$src1, VR64:v2i32:$src2) 23228 // Emits: (Int_CVTPI2PSrr:v4f32 VR128:v4f32:$src1, VR64:v2i32:$src2) 23229 // Pattern complexity = 8 cost = 1 size = 3 23230 if (CN1 == INT64_C(689)) { 23231 SDNode *Result = Emit_109(N, X86::Int_CVTPI2PSrr, MVT::v4f32); 23232 return Result; 23233 } 23234 23235 // Pattern: (intrinsic_wo_chain:v4f32 691:iPTR, VR128:v4f32:$src1, GR32:i32:$src2) 23236 // Emits: (Int_CVTSI2SSrr:v4f32 VR128:v4f32:$src1, GR32:i32:$src2) 23237 // Pattern complexity = 8 cost = 1 size = 3 23238 if (CN1 == INT64_C(691)) { 23239 SDNode *Result = Emit_109(N, X86::Int_CVTSI2SSrr, MVT::v4f32); 23240 return Result; 23241 } 23242 23243 // Pattern: (intrinsic_wo_chain:v4f32 678:iPTR, VR128:v4f32:$src1, VR128:v4f32:$src2) 23244 // Emits: (ADDSSrr_Int:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 23245 // Pattern complexity = 8 cost = 1 size = 3 23246 if (CN1 == INT64_C(678)) { 23247 SDNode *Result = Emit_109(N, X86::ADDSSrr_Int, MVT::v4f32); 23248 return Result; 23249 } 23250 23251 // Pattern: (intrinsic_wo_chain:v4f32 708:iPTR, VR128:v4f32:$src1, VR128:v4f32:$src2) 23252 // Emits: (MULSSrr_Int:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 23253 // Pattern complexity = 8 cost = 1 size = 3 23254 if (CN1 == INT64_C(708)) { 23255 SDNode *Result = Emit_109(N, X86::MULSSrr_Int, MVT::v4f32); 23256 return Result; 23257 } 23258 23259 // Pattern: (intrinsic_wo_chain:v4f32 718:iPTR, VR128:v4f32:$src1, VR128:v4f32:$src2) 23260 // Emits: (SUBSSrr_Int:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 23261 // Pattern complexity = 8 cost = 1 size = 3 23262 if (CN1 == INT64_C(718)) { 23263 SDNode *Result = Emit_109(N, X86::SUBSSrr_Int, MVT::v4f32); 23264 return Result; 23265 } 23266 23267 // Pattern: (intrinsic_wo_chain:v4f32 699:iPTR, VR128:v4f32:$src1, VR128:v4f32:$src2) 23268 // Emits: (DIVSSrr_Int:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 23269 // Pattern complexity = 8 cost = 1 size = 3 23270 if (CN1 == INT64_C(699)) { 23271 SDNode *Result = Emit_109(N, X86::DIVSSrr_Int, MVT::v4f32); 23272 return Result; 23273 } 23274 23275 // Pattern: (intrinsic_wo_chain:v4f32 703:iPTR, VR128:v4f32:$src1, VR128:v4f32:$src2) 23276 // Emits: (MAXSSrr_Int:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 23277 // Pattern complexity = 8 cost = 1 size = 3 23278 if (CN1 == INT64_C(703)) { 23279 SDNode *Result = Emit_109(N, X86::MAXSSrr_Int, MVT::v4f32); 23280 return Result; 23281 } 23282 23283 // Pattern: (intrinsic_wo_chain:v4f32 702:iPTR, VR128:v4f32:$src1, VR128:v4f32:$src2) 23284 // Emits: (MAXPSrr_Int:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 23285 // Pattern complexity = 8 cost = 1 size = 3 23286 if (CN1 == INT64_C(702)) { 23287 SDNode *Result = Emit_109(N, X86::MAXPSrr_Int, MVT::v4f32); 23288 return Result; 23289 } 23290 23291 // Pattern: (intrinsic_wo_chain:v4f32 705:iPTR, VR128:v4f32:$src1, VR128:v4f32:$src2) 23292 // Emits: (MINSSrr_Int:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 23293 // Pattern complexity = 8 cost = 1 size = 3 23294 if (CN1 == INT64_C(705)) { 23295 SDNode *Result = Emit_109(N, X86::MINSSrr_Int, MVT::v4f32); 23296 return Result; 23297 } 23298 23299 // Pattern: (intrinsic_wo_chain:v4f32 704:iPTR, VR128:v4f32:$src1, VR128:v4f32:$src2) 23300 // Emits: (MINPSrr_Int:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 23301 // Pattern complexity = 8 cost = 1 size = 3 23302 if (CN1 == INT64_C(704)) { 23303 SDNode *Result = Emit_109(N, X86::MINPSrr_Int, MVT::v4f32); 23304 return Result; 23305 } 23306 23307 // Pattern: (intrinsic_wo_chain:v4f32 715:iPTR, VR128:v4f32:$src) 23308 // Emits: (SQRTSSr_Int:v4f32 VR128:v4f32:$src) 23309 // Pattern complexity = 8 cost = 1 size = 3 23310 if (CN1 == INT64_C(715)) { 23311 SDNode *Result = Emit_106(N, X86::SQRTSSr_Int, MVT::v4f32); 23312 return Result; 23313 } 23314 23315 // Pattern: (intrinsic_wo_chain:v4f32 714:iPTR, VR128:v4f32:$src) 23316 // Emits: (SQRTPSr_Int:v4f32 VR128:v4f32:$src) 23317 // Pattern complexity = 8 cost = 1 size = 3 23318 if (CN1 == INT64_C(714)) { 23319 SDNode *Result = Emit_106(N, X86::SQRTPSr_Int, MVT::v4f32); 23320 return Result; 23321 } 23322 23323 // Pattern: (intrinsic_wo_chain:v4f32 712:iPTR, VR128:v4f32:$src) 23324 // Emits: (RSQRTSSr_Int:v4f32 VR128:v4f32:$src) 23325 // Pattern complexity = 8 cost = 1 size = 3 23326 if (CN1 == INT64_C(712)) { 23327 SDNode *Result = Emit_106(N, X86::RSQRTSSr_Int, MVT::v4f32); 23328 return Result; 23329 } 23330 23331 // Pattern: (intrinsic_wo_chain:v4f32 711:iPTR, VR128:v4f32:$src) 23332 // Emits: (RSQRTPSr_Int:v4f32 VR128:v4f32:$src) 23333 // Pattern complexity = 8 cost = 1 size = 3 23334 if (CN1 == INT64_C(711)) { 23335 SDNode *Result = Emit_106(N, X86::RSQRTPSr_Int, MVT::v4f32); 23336 return Result; 23337 } 23338 23339 // Pattern: (intrinsic_wo_chain:v4f32 710:iPTR, VR128:v4f32:$src) 23340 // Emits: (RCPSSr_Int:v4f32 VR128:v4f32:$src) 23341 // Pattern complexity = 8 cost = 1 size = 3 23342 if (CN1 == INT64_C(710)) { 23343 SDNode *Result = Emit_106(N, X86::RCPSSr_Int, MVT::v4f32); 23344 return Result; 23345 } 23346 23347 // Pattern: (intrinsic_wo_chain:v4f32 709:iPTR, VR128:v4f32:$src) 23348 // Emits: (RCPPSr_Int:v4f32 VR128:v4f32:$src) 23349 // Pattern complexity = 8 cost = 1 size = 3 23350 if (CN1 == INT64_C(709)) { 23351 SDNode *Result = Emit_106(N, X86::RCPPSr_Int, MVT::v4f32); 23352 return Result; 23353 } 23354 } 23355 } 23356 if ((Subtarget->hasSSE2())) { 23357 SDValue N0 = N.getOperand(0); 23358 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 23359 if (Tmp0) { 23360 int64_t CN1 = Tmp0->getSExtValue(); 23361 23362 // Pattern: (intrinsic_wo_chain:v4f32 512:iPTR, VR128:v4i32:$src) 23363 // Emits: (Int_CVTDQ2PSrr:v4f32 VR128:v4i32:$src) 23364 // Pattern complexity = 8 cost = 1 size = 3 23365 if (CN1 == INT64_C(512)) { 23366 SDNode *Result = Emit_106(N, X86::Int_CVTDQ2PSrr, MVT::v4f32); 23367 return Result; 23368 } 23369 23370 // Pattern: (intrinsic_wo_chain:v4f32 514:iPTR, VR128:v2f64:$src) 23371 // Emits: (Int_CVTPD2PSrr:v4f32 VR128:v2f64:$src) 23372 // Pattern complexity = 8 cost = 1 size = 3 23373 if (CN1 == INT64_C(514)) { 23374 SDNode *Result = Emit_106(N, X86::Int_CVTPD2PSrr, MVT::v4f32); 23375 return Result; 23376 } 23377 23378 // Pattern: (intrinsic_wo_chain:v4f32 519:iPTR, VR128:v4f32:$src1, VR128:v2f64:$src2) 23379 // Emits: (Int_CVTSD2SSrr:v4f32 VR128:v4f32:$src1, VR128:v2f64:$src2) 23380 // Pattern complexity = 8 cost = 1 size = 3 23381 if (CN1 == INT64_C(519)) { 23382 SDNode *Result = Emit_109(N, X86::Int_CVTSD2SSrr, MVT::v4f32); 23383 return Result; 23384 } 23385 } 23386 } 23387 if ((Subtarget->hasSSE3())) { 23388 SDValue N0 = N.getOperand(0); 23389 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 23390 if (Tmp0) { 23391 int64_t CN1 = Tmp0->getSExtValue(); 23392 23393 // Pattern: (intrinsic_wo_chain:v4f32 604:iPTR, VR128:v4f32:$src1, VR128:v4f32:$src2) 23394 // Emits: (ADDSUBPSrr:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 23395 // Pattern complexity = 8 cost = 1 size = 3 23396 if (CN1 == INT64_C(604)) { 23397 SDNode *Result = Emit_109(N, X86::ADDSUBPSrr, MVT::v4f32); 23398 return Result; 23399 } 23400 23401 // Pattern: (intrinsic_wo_chain:v4f32 606:iPTR, VR128:v4f32:$src1, VR128:v4f32:$src2) 23402 // Emits: (HADDPSrr:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 23403 // Pattern complexity = 8 cost = 1 size = 3 23404 if (CN1 == INT64_C(606)) { 23405 SDNode *Result = Emit_109(N, X86::HADDPSrr, MVT::v4f32); 23406 return Result; 23407 } 23408 23409 // Pattern: (intrinsic_wo_chain:v4f32 608:iPTR, VR128:v4f32:$src1, VR128:v4f32:$src2) 23410 // Emits: (HSUBPSrr:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 23411 // Pattern complexity = 8 cost = 1 size = 3 23412 if (CN1 == INT64_C(608)) { 23413 SDNode *Result = Emit_109(N, X86::HSUBPSrr, MVT::v4f32); 23414 return Result; 23415 } 23416 } 23417 } 23418 23419 // Pattern: (intrinsic_wo_chain:v4f32 615:iPTR, VR128:v4f32:$src1, VR128:v4f32:$src2, XMM0:v4f32) 23420 // Emits: (BLENDVPSrr0:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 23421 // Pattern complexity = 8 cost = 1 size = 3 23422 if ((Subtarget->hasSSE41())) { 23423 SDValue N0 = N.getOperand(0); 23424 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 23425 if (Tmp0) { 23426 int64_t CN1 = Tmp0->getSExtValue(); 23427 if (CN1 == INT64_C(615)) { 23428 SDNode *Result = Emit_119(N, X86::BLENDVPSrr0, MVT::v4f32); 23429 return Result; 23430 } 23431 } 23432 } 23433 23434 CannotYetSelectIntrinsic(N); 23435 return NULL; 23436 } 23437 23438 SDNode *Select_ISD_INTRINSIC_WO_CHAIN_v2f64(const SDValue &N) { 23439 if (OptLevel != CodeGenOpt::None) { 23440 if ((Subtarget->hasSSE41())) { 23441 SDValue N0 = N.getOperand(0); 23442 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 23443 if (Tmp0) { 23444 int64_t CN1 = Tmp0->getSExtValue(); 23445 23446 // Pattern: (intrinsic_wo_chain:v2f64 612:iPTR, VR128:v2f64:$src1, (bitconvert:v2f64 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), (imm:i32):$src3) 23447 // Emits: (BLENDPDrmi:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2, (imm:i32):$src3) 23448 // Pattern complexity = 36 cost = 1 size = 3 23449 if (CN1 == INT64_C(612)) { 23450 SDValue N1 = N.getOperand(1); 23451 SDValue N2 = N.getOperand(2); 23452 if (N2.getOpcode() == ISD::BIT_CONVERT && 23453 N2.hasOneUse()) { 23454 SDValue N20 = N2.getOperand(0); 23455 if (N20.getOpcode() == ISD::LOAD && 23456 N20.hasOneUse() && 23457 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 23458 SDValue Chain20 = N20.getOperand(0); 23459 if (Predicate_unindexedload(N20.getNode()) && 23460 Predicate_load(N20.getNode()) && 23461 Predicate_memop(N20.getNode())) { 23462 SDValue N201 = N20.getOperand(1); 23463 SDValue CPTmpN201_0; 23464 SDValue CPTmpN201_1; 23465 SDValue CPTmpN201_2; 23466 SDValue CPTmpN201_3; 23467 SDValue CPTmpN201_4; 23468 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4)) { 23469 SDValue N3 = N.getOperand(3); 23470 if (N3.getOpcode() == ISD::Constant && 23471 N20.getNode()->getValueType(0) == MVT::v16i8) { 23472 SDNode *Result = Emit_118(N, X86::BLENDPDrmi, MVT::v2f64, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 23473 return Result; 23474 } 23475 } 23476 } 23477 } 23478 } 23479 } 23480 if (CN1 == INT64_C(616)) { 23481 SDValue N1 = N.getOperand(1); 23482 23483 // Pattern: (intrinsic_wo_chain:v2f64 616:iPTR, VR128:v2f64:$src1, (bitconvert:v2f64 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), (imm:i32):$src3) 23484 // Emits: (DPPDrmi:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2, (imm:i32):$src3) 23485 // Pattern complexity = 36 cost = 1 size = 3 23486 { 23487 SDValue N2 = N.getOperand(2); 23488 if (N2.getOpcode() == ISD::BIT_CONVERT && 23489 N2.hasOneUse()) { 23490 SDValue N20 = N2.getOperand(0); 23491 if (N20.getOpcode() == ISD::LOAD && 23492 N20.hasOneUse() && 23493 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 23494 SDValue Chain20 = N20.getOperand(0); 23495 if (Predicate_unindexedload(N20.getNode()) && 23496 Predicate_load(N20.getNode()) && 23497 Predicate_memop(N20.getNode())) { 23498 SDValue N201 = N20.getOperand(1); 23499 SDValue CPTmpN201_0; 23500 SDValue CPTmpN201_1; 23501 SDValue CPTmpN201_2; 23502 SDValue CPTmpN201_3; 23503 SDValue CPTmpN201_4; 23504 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4)) { 23505 SDValue N3 = N.getOperand(3); 23506 if (N3.getOpcode() == ISD::Constant && 23507 N20.getNode()->getValueType(0) == MVT::v16i8) { 23508 SDNode *Result = Emit_118(N, X86::DPPDrmi, MVT::v2f64, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 23509 return Result; 23510 } 23511 } 23512 } 23513 } 23514 } 23515 } 23516 23517 // Pattern: (intrinsic_wo_chain:v2f64 616:iPTR, (bitconvert:v2f64 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v2f64:$src1, (imm:i32):$src3) 23518 // Emits: (DPPDrmi:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2, (imm:i32):$src3) 23519 // Pattern complexity = 36 cost = 1 size = 3 23520 if (N1.getOpcode() == ISD::BIT_CONVERT && 23521 N1.hasOneUse()) { 23522 SDValue N10 = N1.getOperand(0); 23523 if (N10.getOpcode() == ISD::LOAD && 23524 N10.hasOneUse() && 23525 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 23526 SDValue Chain10 = N10.getOperand(0); 23527 if (Predicate_unindexedload(N10.getNode()) && 23528 Predicate_load(N10.getNode()) && 23529 Predicate_memop(N10.getNode())) { 23530 SDValue N101 = N10.getOperand(1); 23531 SDValue CPTmpN101_0; 23532 SDValue CPTmpN101_1; 23533 SDValue CPTmpN101_2; 23534 SDValue CPTmpN101_3; 23535 SDValue CPTmpN101_4; 23536 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 23537 SDValue N2 = N.getOperand(2); 23538 SDValue N3 = N.getOperand(3); 23539 if (N3.getOpcode() == ISD::Constant && 23540 N10.getNode()->getValueType(0) == MVT::v16i8) { 23541 SDNode *Result = Emit_125(N, X86::DPPDrmi, MVT::v2f64, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 23542 return Result; 23543 } 23544 } 23545 } 23546 } 23547 } 23548 } 23549 } 23550 } 23551 if ((Subtarget->hasSSE2())) { 23552 SDValue N0 = N.getOperand(0); 23553 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 23554 if (Tmp0) { 23555 int64_t CN1 = Tmp0->getSExtValue(); 23556 23557 // Pattern: (intrinsic_wo_chain:v2f64 504:iPTR, VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i8):$cc) 23558 // Emits: (Int_CMPSDrm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src, (imm:i8):$cc) 23559 // Pattern complexity = 33 cost = 1 size = 3 23560 if (CN1 == INT64_C(504)) { 23561 SDValue N1 = N.getOperand(1); 23562 SDValue N2 = N.getOperand(2); 23563 if (N2.getOpcode() == ISD::LOAD && 23564 N2.hasOneUse() && 23565 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 23566 SDValue Chain2 = N2.getOperand(0); 23567 if (Predicate_unindexedload(N2.getNode()) && 23568 Predicate_load(N2.getNode())) { 23569 SDValue N21 = N2.getOperand(1); 23570 SDValue CPTmpN21_0; 23571 SDValue CPTmpN21_1; 23572 SDValue CPTmpN21_2; 23573 SDValue CPTmpN21_3; 23574 SDValue CPTmpN21_4; 23575 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 23576 SDValue N3 = N.getOperand(3); 23577 if (N3.getOpcode() == ISD::Constant) { 23578 SDNode *Result = Emit_122(N, X86::Int_CMPSDrm, MVT::v2f64, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 23579 return Result; 23580 } 23581 } 23582 } 23583 } 23584 } 23585 23586 // Pattern: (intrinsic_wo_chain:v2f64 511:iPTR, (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 23587 // Emits: (Int_CVTDQ2PDrm:v2f64 addr:iPTR:$src) 23588 // Pattern complexity = 33 cost = 1 size = 3 23589 if (CN1 == INT64_C(511)) { 23590 SDValue N1 = N.getOperand(1); 23591 if (N1.getOpcode() == ISD::BIT_CONVERT && 23592 N1.hasOneUse()) { 23593 SDValue N10 = N1.getOperand(0); 23594 if (N10.getOpcode() == ISD::LOAD && 23595 N10.hasOneUse() && 23596 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 23597 SDValue Chain10 = N10.getOperand(0); 23598 if (Predicate_unindexedload(N10.getNode()) && 23599 Predicate_load(N10.getNode()) && 23600 Predicate_memop(N10.getNode())) { 23601 SDValue N101 = N10.getOperand(1); 23602 SDValue CPTmpN101_0; 23603 SDValue CPTmpN101_1; 23604 SDValue CPTmpN101_2; 23605 SDValue CPTmpN101_3; 23606 SDValue CPTmpN101_4; 23607 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 23608 N10.getNode()->getValueType(0) == MVT::v2i64) { 23609 SDNode *Result = Emit_114(N, X86::Int_CVTDQ2PDrm, MVT::v2f64, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 23610 return Result; 23611 } 23612 } 23613 } 23614 } 23615 } 23616 23617 // Pattern: (intrinsic_wo_chain:v2f64 503:iPTR, VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (imm:i8):$cc) 23618 // Emits: (CMPPDrmi:v2f64 VR128:v2f64:$src1, addr:iPTR:$src, (imm:i8):$cc) 23619 // Pattern complexity = 33 cost = 1 size = 3 23620 if (CN1 == INT64_C(503)) { 23621 SDValue N1 = N.getOperand(1); 23622 SDValue N2 = N.getOperand(2); 23623 if (N2.getOpcode() == ISD::LOAD && 23624 N2.hasOneUse() && 23625 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 23626 SDValue Chain2 = N2.getOperand(0); 23627 if (Predicate_unindexedload(N2.getNode()) && 23628 Predicate_load(N2.getNode()) && 23629 Predicate_memop(N2.getNode())) { 23630 SDValue N21 = N2.getOperand(1); 23631 SDValue CPTmpN21_0; 23632 SDValue CPTmpN21_1; 23633 SDValue CPTmpN21_2; 23634 SDValue CPTmpN21_3; 23635 SDValue CPTmpN21_4; 23636 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 23637 SDValue N3 = N.getOperand(3); 23638 if (N3.getOpcode() == ISD::Constant) { 23639 SDNode *Result = Emit_122(N, X86::CMPPDrmi, MVT::v2f64, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 23640 return Result; 23641 } 23642 } 23643 } 23644 } 23645 } 23646 } 23647 } 23648 if ((Subtarget->hasSSE41())) { 23649 SDValue N0 = N.getOperand(0); 23650 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 23651 if (Tmp0) { 23652 int64_t CN1 = Tmp0->getSExtValue(); 23653 23654 // Pattern: (intrinsic_wo_chain:v2f64 655:iPTR, (ld:v2f64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (imm:i32):$src2) 23655 // Emits: (ROUNDPDm_Int:v2f64 addr:iPTR:$src1, (imm:i32):$src2) 23656 // Pattern complexity = 33 cost = 1 size = 3 23657 if (CN1 == INT64_C(655)) { 23658 SDValue N1 = N.getOperand(1); 23659 if (N1.getOpcode() == ISD::LOAD && 23660 N1.hasOneUse() && 23661 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 23662 SDValue Chain1 = N1.getOperand(0); 23663 if (Predicate_unindexedload(N1.getNode()) && 23664 Predicate_load(N1.getNode()) && 23665 Predicate_memop(N1.getNode())) { 23666 SDValue N11 = N1.getOperand(1); 23667 SDValue CPTmpN11_0; 23668 SDValue CPTmpN11_1; 23669 SDValue CPTmpN11_2; 23670 SDValue CPTmpN11_3; 23671 SDValue CPTmpN11_4; 23672 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 23673 SDValue N2 = N.getOperand(2); 23674 if (N2.getOpcode() == ISD::Constant) { 23675 SDNode *Result = Emit_136(N, X86::ROUNDPDm_Int, MVT::v2f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 23676 return Result; 23677 } 23678 } 23679 } 23680 } 23681 } 23682 23683 // Pattern: (intrinsic_wo_chain:v2f64 614:iPTR, VR128:v2f64:$src1, (bitconvert:v2f64 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), XMM0:v2f64) 23684 // Emits: (BLENDVPDrm0:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 23685 // Pattern complexity = 33 cost = 1 size = 3 23686 if (CN1 == INT64_C(614)) { 23687 SDValue N1 = N.getOperand(1); 23688 SDValue N2 = N.getOperand(2); 23689 if (N2.getOpcode() == ISD::BIT_CONVERT && 23690 N2.hasOneUse()) { 23691 SDValue N20 = N2.getOperand(0); 23692 if (N20.getOpcode() == ISD::LOAD && 23693 N20.hasOneUse() && 23694 IsLegalAndProfitableToFold(N20.getNode(), N2.getNode(), N.getNode())) { 23695 SDValue Chain20 = N20.getOperand(0); 23696 if (Predicate_unindexedload(N20.getNode()) && 23697 Predicate_load(N20.getNode()) && 23698 Predicate_memop(N20.getNode())) { 23699 SDValue N201 = N20.getOperand(1); 23700 SDValue CPTmpN201_0; 23701 SDValue CPTmpN201_1; 23702 SDValue CPTmpN201_2; 23703 SDValue CPTmpN201_3; 23704 SDValue CPTmpN201_4; 23705 if (SelectAddr(N, N201, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4)) { 23706 SDValue N3 = N.getOperand(3); 23707 if (N20.getNode()->getValueType(0) == MVT::v16i8) { 23708 SDNode *Result = Emit_120(N, X86::BLENDVPDrm0, MVT::v2f64, CPTmpN201_0, CPTmpN201_1, CPTmpN201_2, CPTmpN201_3, CPTmpN201_4); 23709 return Result; 23710 } 23711 } 23712 } 23713 } 23714 } 23715 } 23716 } 23717 } 23718 if ((Subtarget->hasSSE2())) { 23719 SDValue N0 = N.getOperand(0); 23720 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 23721 if (Tmp0) { 23722 int64_t CN1 = Tmp0->getSExtValue(); 23723 23724 // Pattern: (intrinsic_wo_chain:v2f64 521:iPTR, VR128:v2f64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>) 23725 // Emits: (Int_CVTSI2SD64rm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 23726 // Pattern complexity = 30 cost = 1 size = 3 23727 if (CN1 == INT64_C(521)) { 23728 SDValue N1 = N.getOperand(1); 23729 SDValue N2 = N.getOperand(2); 23730 if (N2.getOpcode() == ISD::LOAD && 23731 N2.hasOneUse() && 23732 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 23733 SDValue Chain2 = N2.getOperand(0); 23734 if (Predicate_unindexedload(N2.getNode()) && 23735 Predicate_load(N2.getNode()) && 23736 Predicate_loadi64(N2.getNode())) { 23737 SDValue N21 = N2.getOperand(1); 23738 SDValue CPTmpN21_0; 23739 SDValue CPTmpN21_1; 23740 SDValue CPTmpN21_2; 23741 SDValue CPTmpN21_3; 23742 SDValue CPTmpN21_4; 23743 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 23744 SDNode *Result = Emit_108(N, X86::Int_CVTSI2SD64rm, MVT::v2f64, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 23745 return Result; 23746 } 23747 } 23748 } 23749 } 23750 23751 // Pattern: (intrinsic_wo_chain:v2f64 688:iPTR, (ld:v2i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 23752 // Emits: (Int_CVTPI2PDrm:v2f64 addr:iPTR:$src) 23753 // Pattern complexity = 30 cost = 1 size = 3 23754 if (CN1 == INT64_C(688)) { 23755 SDValue N1 = N.getOperand(1); 23756 if (N1.getOpcode() == ISD::LOAD && 23757 N1.hasOneUse() && 23758 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 23759 SDValue Chain1 = N1.getOperand(0); 23760 if (Predicate_unindexedload(N1.getNode()) && 23761 Predicate_load(N1.getNode())) { 23762 SDValue N11 = N1.getOperand(1); 23763 SDValue CPTmpN11_0; 23764 SDValue CPTmpN11_1; 23765 SDValue CPTmpN11_2; 23766 SDValue CPTmpN11_3; 23767 SDValue CPTmpN11_4; 23768 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 23769 SDNode *Result = Emit_107(N, X86::Int_CVTPI2PDrm, MVT::v2f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 23770 return Result; 23771 } 23772 } 23773 } 23774 } 23775 23776 // Pattern: (intrinsic_wo_chain:v2f64 532:iPTR, VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 23777 // Emits: (MAXPDrm_Int:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 23778 // Pattern complexity = 30 cost = 1 size = 3 23779 if (CN1 == INT64_C(532)) { 23780 SDValue N1 = N.getOperand(1); 23781 SDValue N2 = N.getOperand(2); 23782 if (N2.getOpcode() == ISD::LOAD && 23783 N2.hasOneUse() && 23784 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 23785 SDValue Chain2 = N2.getOperand(0); 23786 if (Predicate_unindexedload(N2.getNode()) && 23787 Predicate_load(N2.getNode()) && 23788 Predicate_memop(N2.getNode())) { 23789 SDValue N21 = N2.getOperand(1); 23790 SDValue CPTmpN21_0; 23791 SDValue CPTmpN21_1; 23792 SDValue CPTmpN21_2; 23793 SDValue CPTmpN21_3; 23794 SDValue CPTmpN21_4; 23795 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 23796 SDNode *Result = Emit_108(N, X86::MAXPDrm_Int, MVT::v2f64, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 23797 return Result; 23798 } 23799 } 23800 } 23801 } 23802 23803 // Pattern: (intrinsic_wo_chain:v2f64 535:iPTR, VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 23804 // Emits: (MINPDrm_Int:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 23805 // Pattern complexity = 30 cost = 1 size = 3 23806 if (CN1 == INT64_C(535)) { 23807 SDValue N1 = N.getOperand(1); 23808 SDValue N2 = N.getOperand(2); 23809 if (N2.getOpcode() == ISD::LOAD && 23810 N2.hasOneUse() && 23811 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 23812 SDValue Chain2 = N2.getOperand(0); 23813 if (Predicate_unindexedload(N2.getNode()) && 23814 Predicate_load(N2.getNode()) && 23815 Predicate_memop(N2.getNode())) { 23816 SDValue N21 = N2.getOperand(1); 23817 SDValue CPTmpN21_0; 23818 SDValue CPTmpN21_1; 23819 SDValue CPTmpN21_2; 23820 SDValue CPTmpN21_3; 23821 SDValue CPTmpN21_4; 23822 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 23823 SDNode *Result = Emit_108(N, X86::MINPDrm_Int, MVT::v2f64, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 23824 return Result; 23825 } 23826 } 23827 } 23828 } 23829 23830 // Pattern: (intrinsic_wo_chain:v2f64 516:iPTR, (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 23831 // Emits: (Int_CVTPS2PDrm:v2f64 addr:iPTR:$src) 23832 // Pattern complexity = 30 cost = 1 size = 3 23833 if (CN1 == INT64_C(516)) { 23834 SDValue N1 = N.getOperand(1); 23835 if (N1.getOpcode() == ISD::LOAD && 23836 N1.hasOneUse() && 23837 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 23838 SDValue Chain1 = N1.getOperand(0); 23839 if (Predicate_unindexedload(N1.getNode()) && 23840 Predicate_load(N1.getNode())) { 23841 SDValue N11 = N1.getOperand(1); 23842 SDValue CPTmpN11_0; 23843 SDValue CPTmpN11_1; 23844 SDValue CPTmpN11_2; 23845 SDValue CPTmpN11_3; 23846 SDValue CPTmpN11_4; 23847 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 23848 SDNode *Result = Emit_107(N, X86::Int_CVTPS2PDrm, MVT::v2f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 23849 return Result; 23850 } 23851 } 23852 } 23853 } 23854 23855 // Pattern: (intrinsic_wo_chain:v2f64 520:iPTR, VR128:v2f64:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>) 23856 // Emits: (Int_CVTSI2SDrm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 23857 // Pattern complexity = 30 cost = 1 size = 3 23858 if (CN1 == INT64_C(520)) { 23859 SDValue N1 = N.getOperand(1); 23860 SDValue N2 = N.getOperand(2); 23861 if (N2.getOpcode() == ISD::LOAD && 23862 N2.hasOneUse() && 23863 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 23864 SDValue Chain2 = N2.getOperand(0); 23865 if (Predicate_unindexedload(N2.getNode()) && 23866 Predicate_loadi32(N2.getNode())) { 23867 SDValue N21 = N2.getOperand(1); 23868 SDValue CPTmpN21_0; 23869 SDValue CPTmpN21_1; 23870 SDValue CPTmpN21_2; 23871 SDValue CPTmpN21_3; 23872 SDValue CPTmpN21_4; 23873 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 23874 SDNode *Result = Emit_108(N, X86::Int_CVTSI2SDrm, MVT::v2f64, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 23875 return Result; 23876 } 23877 } 23878 } 23879 } 23880 23881 // Pattern: (intrinsic_wo_chain:v2f64 522:iPTR, VR128:v2f64:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 23882 // Emits: (Int_CVTSS2SDrm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 23883 // Pattern complexity = 30 cost = 1 size = 3 23884 if (CN1 == INT64_C(522)) { 23885 SDValue N1 = N.getOperand(1); 23886 SDValue N2 = N.getOperand(2); 23887 if (N2.getOpcode() == ISD::LOAD && 23888 N2.hasOneUse() && 23889 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 23890 SDValue Chain2 = N2.getOperand(0); 23891 if (Predicate_unindexedload(N2.getNode()) && 23892 Predicate_load(N2.getNode())) { 23893 SDValue N21 = N2.getOperand(1); 23894 SDValue CPTmpN21_0; 23895 SDValue CPTmpN21_1; 23896 SDValue CPTmpN21_2; 23897 SDValue CPTmpN21_3; 23898 SDValue CPTmpN21_4; 23899 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 23900 SDNode *Result = Emit_108(N, X86::Int_CVTSS2SDrm, MVT::v2f64, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 23901 return Result; 23902 } 23903 } 23904 } 23905 } 23906 23907 // Pattern: (intrinsic_wo_chain:v2f64 591:iPTR, (ld:v2f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 23908 // Emits: (SQRTPDm_Int:v2f64 addr:iPTR:$src) 23909 // Pattern complexity = 30 cost = 1 size = 3 23910 if (CN1 == INT64_C(591)) { 23911 SDValue N1 = N.getOperand(1); 23912 if (N1.getOpcode() == ISD::LOAD && 23913 N1.hasOneUse() && 23914 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 23915 SDValue Chain1 = N1.getOperand(0); 23916 if (Predicate_unindexedload(N1.getNode()) && 23917 Predicate_load(N1.getNode()) && 23918 Predicate_memop(N1.getNode())) { 23919 SDValue N11 = N1.getOperand(1); 23920 SDValue CPTmpN11_0; 23921 SDValue CPTmpN11_1; 23922 SDValue CPTmpN11_2; 23923 SDValue CPTmpN11_3; 23924 SDValue CPTmpN11_4; 23925 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 23926 SDNode *Result = Emit_107(N, X86::SQRTPDm_Int, MVT::v2f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 23927 return Result; 23928 } 23929 } 23930 } 23931 } 23932 } 23933 } 23934 if ((Subtarget->hasSSE3())) { 23935 SDValue N0 = N.getOperand(0); 23936 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 23937 if (Tmp0) { 23938 int64_t CN1 = Tmp0->getSExtValue(); 23939 23940 // Pattern: (intrinsic_wo_chain:v2f64 603:iPTR, VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 23941 // Emits: (ADDSUBPDrm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 23942 // Pattern complexity = 30 cost = 1 size = 3 23943 if (CN1 == INT64_C(603)) { 23944 SDValue N1 = N.getOperand(1); 23945 SDValue N2 = N.getOperand(2); 23946 if (N2.getOpcode() == ISD::LOAD && 23947 N2.hasOneUse() && 23948 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 23949 SDValue Chain2 = N2.getOperand(0); 23950 if (Predicate_unindexedload(N2.getNode()) && 23951 Predicate_load(N2.getNode()) && 23952 Predicate_memop(N2.getNode())) { 23953 SDValue N21 = N2.getOperand(1); 23954 SDValue CPTmpN21_0; 23955 SDValue CPTmpN21_1; 23956 SDValue CPTmpN21_2; 23957 SDValue CPTmpN21_3; 23958 SDValue CPTmpN21_4; 23959 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 23960 SDNode *Result = Emit_108(N, X86::ADDSUBPDrm, MVT::v2f64, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 23961 return Result; 23962 } 23963 } 23964 } 23965 } 23966 23967 // Pattern: (intrinsic_wo_chain:v2f64 605:iPTR, VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 23968 // Emits: (HADDPDrm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 23969 // Pattern complexity = 30 cost = 1 size = 3 23970 if (CN1 == INT64_C(605)) { 23971 SDValue N1 = N.getOperand(1); 23972 SDValue N2 = N.getOperand(2); 23973 if (N2.getOpcode() == ISD::LOAD && 23974 N2.hasOneUse() && 23975 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 23976 SDValue Chain2 = N2.getOperand(0); 23977 if (Predicate_unindexedload(N2.getNode()) && 23978 Predicate_load(N2.getNode()) && 23979 Predicate_memop(N2.getNode())) { 23980 SDValue N21 = N2.getOperand(1); 23981 SDValue CPTmpN21_0; 23982 SDValue CPTmpN21_1; 23983 SDValue CPTmpN21_2; 23984 SDValue CPTmpN21_3; 23985 SDValue CPTmpN21_4; 23986 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 23987 SDNode *Result = Emit_108(N, X86::HADDPDrm, MVT::v2f64, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 23988 return Result; 23989 } 23990 } 23991 } 23992 } 23993 23994 // Pattern: (intrinsic_wo_chain:v2f64 607:iPTR, VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 23995 // Emits: (HSUBPDrm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 23996 // Pattern complexity = 30 cost = 1 size = 3 23997 if (CN1 == INT64_C(607)) { 23998 SDValue N1 = N.getOperand(1); 23999 SDValue N2 = N.getOperand(2); 24000 if (N2.getOpcode() == ISD::LOAD && 24001 N2.hasOneUse() && 24002 IsLegalAndProfitableToFold(N2.getNode(), N.getNode(), N.getNode())) { 24003 SDValue Chain2 = N2.getOperand(0); 24004 if (Predicate_unindexedload(N2.getNode()) && 24005 Predicate_load(N2.getNode()) && 24006 Predicate_memop(N2.getNode())) { 24007 SDValue N21 = N2.getOperand(1); 24008 SDValue CPTmpN21_0; 24009 SDValue CPTmpN21_1; 24010 SDValue CPTmpN21_2; 24011 SDValue CPTmpN21_3; 24012 SDValue CPTmpN21_4; 24013 if (SelectAddr(N, N21, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4)) { 24014 SDNode *Result = Emit_108(N, X86::HSUBPDrm, MVT::v2f64, CPTmpN21_0, CPTmpN21_1, CPTmpN21_2, CPTmpN21_3, CPTmpN21_4); 24015 return Result; 24016 } 24017 } 24018 } 24019 } 24020 } 24021 } 24022 24023 // Pattern: (intrinsic_wo_chain:v2f64 657:iPTR, VR128:v2f64:$src1, sse_load_f64:v2f64:$src2, (imm:i32):$src3) 24024 // Emits: (ROUNDSDm_Int:v2f64 VR128:v2f64:$src1, sse_load_f64:v2f64:$src2, (imm:i32):$src3) 24025 // Pattern complexity = 29 cost = 1 size = 3 24026 if ((Subtarget->hasSSE41())) { 24027 SDValue N0 = N.getOperand(0); 24028 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 24029 if (Tmp0) { 24030 int64_t CN1 = Tmp0->getSExtValue(); 24031 if (CN1 == INT64_C(657)) { 24032 SDValue N1 = N.getOperand(1); 24033 SDValue N2 = N.getOperand(2); 24034 SDValue CPTmpN2_0; 24035 SDValue CPTmpN2_1; 24036 SDValue CPTmpN2_2; 24037 SDValue CPTmpN2_3; 24038 SDValue CPTmpN2_4; 24039 SDValue CPInChain; 24040 SDValue Chain2; 24041 if (SelectScalarSSELoad(N, N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, CPInChain, Chain2)) { 24042 SDValue N3 = N.getOperand(3); 24043 if (N3.getOpcode() == ISD::Constant) { 24044 SDNode *Result = Emit_137(N, X86::ROUNDSDm_Int, MVT::v2f64, CPInChain, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Chain2); 24045 return Result; 24046 } 24047 } 24048 } 24049 } 24050 } 24051 if ((Subtarget->hasSSE2())) { 24052 SDValue N0 = N.getOperand(0); 24053 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 24054 if (Tmp0) { 24055 int64_t CN1 = Tmp0->getSExtValue(); 24056 24057 // Pattern: (intrinsic_wo_chain:v2f64 501:iPTR, VR128:v2f64:$src1, sse_load_f64:v2f64:$src2) 24058 // Emits: (ADDSDrm_Int:v2f64 VR128:v2f64:$src1, sse_load_f64:v2f64:$src2) 24059 // Pattern complexity = 26 cost = 1 size = 3 24060 if (CN1 == INT64_C(501)) { 24061 SDValue N1 = N.getOperand(1); 24062 SDValue N2 = N.getOperand(2); 24063 SDValue CPTmpN2_0; 24064 SDValue CPTmpN2_1; 24065 SDValue CPTmpN2_2; 24066 SDValue CPTmpN2_3; 24067 SDValue CPTmpN2_4; 24068 SDValue CPInChain; 24069 SDValue Chain2; 24070 if (SelectScalarSSELoad(N, N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, CPInChain, Chain2)) { 24071 SDNode *Result = Emit_134(N, X86::ADDSDrm_Int, MVT::v2f64, CPInChain, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Chain2); 24072 return Result; 24073 } 24074 } 24075 24076 // Pattern: (intrinsic_wo_chain:v2f64 541:iPTR, VR128:v2f64:$src1, sse_load_f64:v2f64:$src2) 24077 // Emits: (MULSDrm_Int:v2f64 VR128:v2f64:$src1, sse_load_f64:v2f64:$src2) 24078 // Pattern complexity = 26 cost = 1 size = 3 24079 if (CN1 == INT64_C(541)) { 24080 SDValue N1 = N.getOperand(1); 24081 SDValue N2 = N.getOperand(2); 24082 SDValue CPTmpN2_0; 24083 SDValue CPTmpN2_1; 24084 SDValue CPTmpN2_2; 24085 SDValue CPTmpN2_3; 24086 SDValue CPTmpN2_4; 24087 SDValue CPInChain; 24088 SDValue Chain2; 24089 if (SelectScalarSSELoad(N, N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, CPInChain, Chain2)) { 24090 SDNode *Result = Emit_134(N, X86::MULSDrm_Int, MVT::v2f64, CPInChain, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Chain2); 24091 return Result; 24092 } 24093 } 24094 24095 // Pattern: (intrinsic_wo_chain:v2f64 596:iPTR, VR128:v2f64:$src1, sse_load_f64:v2f64:$src2) 24096 // Emits: (SUBSDrm_Int:v2f64 VR128:v2f64:$src1, sse_load_f64:v2f64:$src2) 24097 // Pattern complexity = 26 cost = 1 size = 3 24098 if (CN1 == INT64_C(596)) { 24099 SDValue N1 = N.getOperand(1); 24100 SDValue N2 = N.getOperand(2); 24101 SDValue CPTmpN2_0; 24102 SDValue CPTmpN2_1; 24103 SDValue CPTmpN2_2; 24104 SDValue CPTmpN2_3; 24105 SDValue CPTmpN2_4; 24106 SDValue CPInChain; 24107 SDValue Chain2; 24108 if (SelectScalarSSELoad(N, N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, CPInChain, Chain2)) { 24109 SDNode *Result = Emit_134(N, X86::SUBSDrm_Int, MVT::v2f64, CPInChain, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Chain2); 24110 return Result; 24111 } 24112 } 24113 24114 // Pattern: (intrinsic_wo_chain:v2f64 527:iPTR, VR128:v2f64:$src1, sse_load_f64:v2f64:$src2) 24115 // Emits: (DIVSDrm_Int:v2f64 VR128:v2f64:$src1, sse_load_f64:v2f64:$src2) 24116 // Pattern complexity = 26 cost = 1 size = 3 24117 if (CN1 == INT64_C(527)) { 24118 SDValue N1 = N.getOperand(1); 24119 SDValue N2 = N.getOperand(2); 24120 SDValue CPTmpN2_0; 24121 SDValue CPTmpN2_1; 24122 SDValue CPTmpN2_2; 24123 SDValue CPTmpN2_3; 24124 SDValue CPTmpN2_4; 24125 SDValue CPInChain; 24126 SDValue Chain2; 24127 if (SelectScalarSSELoad(N, N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, CPInChain, Chain2)) { 24128 SDNode *Result = Emit_134(N, X86::DIVSDrm_Int, MVT::v2f64, CPInChain, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Chain2); 24129 return Result; 24130 } 24131 } 24132 24133 // Pattern: (intrinsic_wo_chain:v2f64 533:iPTR, VR128:v2f64:$src1, sse_load_f64:v2f64:$src2) 24134 // Emits: (MAXSDrm_Int:v2f64 VR128:v2f64:$src1, sse_load_f64:v2f64:$src2) 24135 // Pattern complexity = 26 cost = 1 size = 3 24136 if (CN1 == INT64_C(533)) { 24137 SDValue N1 = N.getOperand(1); 24138 SDValue N2 = N.getOperand(2); 24139 SDValue CPTmpN2_0; 24140 SDValue CPTmpN2_1; 24141 SDValue CPTmpN2_2; 24142 SDValue CPTmpN2_3; 24143 SDValue CPTmpN2_4; 24144 SDValue CPInChain; 24145 SDValue Chain2; 24146 if (SelectScalarSSELoad(N, N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, CPInChain, Chain2)) { 24147 SDNode *Result = Emit_134(N, X86::MAXSDrm_Int, MVT::v2f64, CPInChain, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Chain2); 24148 return Result; 24149 } 24150 } 24151 24152 // Pattern: (intrinsic_wo_chain:v2f64 536:iPTR, VR128:v2f64:$src1, sse_load_f64:v2f64:$src2) 24153 // Emits: (MINSDrm_Int:v2f64 VR128:v2f64:$src1, sse_load_f64:v2f64:$src2) 24154 // Pattern complexity = 26 cost = 1 size = 3 24155 if (CN1 == INT64_C(536)) { 24156 SDValue N1 = N.getOperand(1); 24157 SDValue N2 = N.getOperand(2); 24158 SDValue CPTmpN2_0; 24159 SDValue CPTmpN2_1; 24160 SDValue CPTmpN2_2; 24161 SDValue CPTmpN2_3; 24162 SDValue CPTmpN2_4; 24163 SDValue CPInChain; 24164 SDValue Chain2; 24165 if (SelectScalarSSELoad(N, N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, CPInChain, Chain2)) { 24166 SDNode *Result = Emit_134(N, X86::MINSDrm_Int, MVT::v2f64, CPInChain, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Chain2); 24167 return Result; 24168 } 24169 } 24170 24171 // Pattern: (intrinsic_wo_chain:v2f64 592:iPTR, sse_load_f64:v2f64:$src) 24172 // Emits: (SQRTSDm_Int:v2f64 sse_load_f64:v2f64:$src) 24173 // Pattern complexity = 26 cost = 1 size = 3 24174 if (CN1 == INT64_C(592)) { 24175 SDValue N1 = N.getOperand(1); 24176 SDValue CPTmpN1_0; 24177 SDValue CPTmpN1_1; 24178 SDValue CPTmpN1_2; 24179 SDValue CPTmpN1_3; 24180 SDValue CPTmpN1_4; 24181 SDValue CPInChain; 24182 SDValue Chain1; 24183 if (SelectScalarSSELoad(N, N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, CPInChain, Chain1)) { 24184 SDNode *Result = Emit_135(N, X86::SQRTSDm_Int, MVT::v2f64, CPInChain, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, Chain1); 24185 return Result; 24186 } 24187 } 24188 } 24189 } 24190 } 24191 if ((Subtarget->hasSSE2())) { 24192 SDValue N0 = N.getOperand(0); 24193 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 24194 if (Tmp0) { 24195 int64_t CN1 = Tmp0->getSExtValue(); 24196 24197 // Pattern: (intrinsic_wo_chain:v2f64 504:iPTR, VR128:v2f64:$src1, VR128:v2f64:$src, (imm:i8):$cc) 24198 // Emits: (Int_CMPSDrr:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src, (imm:i8):$cc) 24199 // Pattern complexity = 11 cost = 1 size = 3 24200 if (CN1 == INT64_C(504)) { 24201 SDValue N1 = N.getOperand(1); 24202 SDValue N2 = N.getOperand(2); 24203 SDValue N3 = N.getOperand(3); 24204 if (N3.getOpcode() == ISD::Constant) { 24205 SDNode *Result = Emit_121(N, X86::Int_CMPSDrr, MVT::v2f64); 24206 return Result; 24207 } 24208 } 24209 24210 // Pattern: (intrinsic_wo_chain:v2f64 503:iPTR, VR128:v2f64:$src1, VR128:v2f64:$src, (imm:i8):$cc) 24211 // Emits: (CMPPDrri:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src, (imm:i8):$cc) 24212 // Pattern complexity = 11 cost = 1 size = 3 24213 if (CN1 == INT64_C(503)) { 24214 SDValue N1 = N.getOperand(1); 24215 SDValue N2 = N.getOperand(2); 24216 SDValue N3 = N.getOperand(3); 24217 if (N3.getOpcode() == ISD::Constant) { 24218 SDNode *Result = Emit_121(N, X86::CMPPDrri, MVT::v2f64); 24219 return Result; 24220 } 24221 } 24222 } 24223 } 24224 if ((Subtarget->hasSSE41())) { 24225 SDValue N0 = N.getOperand(0); 24226 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 24227 if (Tmp0) { 24228 int64_t CN1 = Tmp0->getSExtValue(); 24229 24230 // Pattern: (intrinsic_wo_chain:v2f64 655:iPTR, VR128:v2f64:$src1, (imm:i32):$src2) 24231 // Emits: (ROUNDPDr_Int:v2f64 VR128:v2f64:$src1, (imm:i32):$src2) 24232 // Pattern complexity = 11 cost = 1 size = 3 24233 if (CN1 == INT64_C(655)) { 24234 SDValue N1 = N.getOperand(1); 24235 SDValue N2 = N.getOperand(2); 24236 if (N2.getOpcode() == ISD::Constant) { 24237 SDNode *Result = Emit_126(N, X86::ROUNDPDr_Int, MVT::v2f64); 24238 return Result; 24239 } 24240 } 24241 24242 // Pattern: (intrinsic_wo_chain:v2f64 657:iPTR, VR128:v2f64:$src1, VR128:v2f64:$src2, (imm:i32):$src3) 24243 // Emits: (ROUNDSDr_Int:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2, (imm:i32):$src3) 24244 // Pattern complexity = 11 cost = 1 size = 3 24245 if (CN1 == INT64_C(657)) { 24246 SDValue N1 = N.getOperand(1); 24247 SDValue N2 = N.getOperand(2); 24248 SDValue N3 = N.getOperand(3); 24249 if (N3.getOpcode() == ISD::Constant) { 24250 SDNode *Result = Emit_117(N, X86::ROUNDSDr_Int, MVT::v2f64); 24251 return Result; 24252 } 24253 } 24254 24255 // Pattern: (intrinsic_wo_chain:v2f64 612:iPTR, VR128:v2f64:$src1, VR128:v2f64:$src2, (imm:i32):$src3) 24256 // Emits: (BLENDPDrri:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2, (imm:i32):$src3) 24257 // Pattern complexity = 11 cost = 1 size = 3 24258 if (CN1 == INT64_C(612)) { 24259 SDValue N1 = N.getOperand(1); 24260 SDValue N2 = N.getOperand(2); 24261 SDValue N3 = N.getOperand(3); 24262 if (N3.getOpcode() == ISD::Constant) { 24263 SDNode *Result = Emit_117(N, X86::BLENDPDrri, MVT::v2f64); 24264 return Result; 24265 } 24266 } 24267 24268 // Pattern: (intrinsic_wo_chain:v2f64 616:iPTR, VR128:v2f64:$src1, VR128:v2f64:$src2, (imm:i32):$src3) 24269 // Emits: (DPPDrri:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2, (imm:i32):$src3) 24270 // Pattern complexity = 11 cost = 1 size = 3 24271 if (CN1 == INT64_C(616)) { 24272 SDValue N1 = N.getOperand(1); 24273 SDValue N2 = N.getOperand(2); 24274 SDValue N3 = N.getOperand(3); 24275 if (N3.getOpcode() == ISD::Constant) { 24276 SDNode *Result = Emit_117(N, X86::DPPDrri, MVT::v2f64); 24277 return Result; 24278 } 24279 } 24280 } 24281 } 24282 if ((Subtarget->hasSSE2())) { 24283 SDValue N0 = N.getOperand(0); 24284 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 24285 if (Tmp0) { 24286 int64_t CN1 = Tmp0->getSExtValue(); 24287 24288 // Pattern: (intrinsic_wo_chain:v2f64 521:iPTR, VR128:v2f64:$src1, GR64:i64:$src2) 24289 // Emits: (Int_CVTSI2SD64rr:v2f64 VR128:v2f64:$src1, GR64:i64:$src2) 24290 // Pattern complexity = 8 cost = 1 size = 3 24291 if (CN1 == INT64_C(521)) { 24292 SDNode *Result = Emit_109(N, X86::Int_CVTSI2SD64rr, MVT::v2f64); 24293 return Result; 24294 } 24295 24296 // Pattern: (intrinsic_wo_chain:v2f64 688:iPTR, VR64:v2i32:$src) 24297 // Emits: (Int_CVTPI2PDrr:v2f64 VR64:v2i32:$src) 24298 // Pattern complexity = 8 cost = 1 size = 3 24299 if (CN1 == INT64_C(688)) { 24300 SDNode *Result = Emit_106(N, X86::Int_CVTPI2PDrr, MVT::v2f64); 24301 return Result; 24302 } 24303 24304 // Pattern: (intrinsic_wo_chain:v2f64 501:iPTR, VR128:v2f64:$src1, VR128:v2f64:$src2) 24305 // Emits: (ADDSDrr_Int:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 24306 // Pattern complexity = 8 cost = 1 size = 3 24307 if (CN1 == INT64_C(501)) { 24308 SDNode *Result = Emit_109(N, X86::ADDSDrr_Int, MVT::v2f64); 24309 return Result; 24310 } 24311 24312 // Pattern: (intrinsic_wo_chain:v2f64 541:iPTR, VR128:v2f64:$src1, VR128:v2f64:$src2) 24313 // Emits: (MULSDrr_Int:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 24314 // Pattern complexity = 8 cost = 1 size = 3 24315 if (CN1 == INT64_C(541)) { 24316 SDNode *Result = Emit_109(N, X86::MULSDrr_Int, MVT::v2f64); 24317 return Result; 24318 } 24319 24320 // Pattern: (intrinsic_wo_chain:v2f64 596:iPTR, VR128:v2f64:$src1, VR128:v2f64:$src2) 24321 // Emits: (SUBSDrr_Int:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 24322 // Pattern complexity = 8 cost = 1 size = 3 24323 if (CN1 == INT64_C(596)) { 24324 SDNode *Result = Emit_109(N, X86::SUBSDrr_Int, MVT::v2f64); 24325 return Result; 24326 } 24327 24328 // Pattern: (intrinsic_wo_chain:v2f64 527:iPTR, VR128:v2f64:$src1, VR128:v2f64:$src2) 24329 // Emits: (DIVSDrr_Int:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 24330 // Pattern complexity = 8 cost = 1 size = 3 24331 if (CN1 == INT64_C(527)) { 24332 SDNode *Result = Emit_109(N, X86::DIVSDrr_Int, MVT::v2f64); 24333 return Result; 24334 } 24335 24336 // Pattern: (intrinsic_wo_chain:v2f64 533:iPTR, VR128:v2f64:$src1, VR128:v2f64:$src2) 24337 // Emits: (MAXSDrr_Int:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 24338 // Pattern complexity = 8 cost = 1 size = 3 24339 if (CN1 == INT64_C(533)) { 24340 SDNode *Result = Emit_109(N, X86::MAXSDrr_Int, MVT::v2f64); 24341 return Result; 24342 } 24343 24344 // Pattern: (intrinsic_wo_chain:v2f64 532:iPTR, VR128:v2f64:$src1, VR128:v2f64:$src2) 24345 // Emits: (MAXPDrr_Int:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 24346 // Pattern complexity = 8 cost = 1 size = 3 24347 if (CN1 == INT64_C(532)) { 24348 SDNode *Result = Emit_109(N, X86::MAXPDrr_Int, MVT::v2f64); 24349 return Result; 24350 } 24351 24352 // Pattern: (intrinsic_wo_chain:v2f64 536:iPTR, VR128:v2f64:$src1, VR128:v2f64:$src2) 24353 // Emits: (MINSDrr_Int:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 24354 // Pattern complexity = 8 cost = 1 size = 3 24355 if (CN1 == INT64_C(536)) { 24356 SDNode *Result = Emit_109(N, X86::MINSDrr_Int, MVT::v2f64); 24357 return Result; 24358 } 24359 24360 // Pattern: (intrinsic_wo_chain:v2f64 535:iPTR, VR128:v2f64:$src1, VR128:v2f64:$src2) 24361 // Emits: (MINPDrr_Int:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 24362 // Pattern complexity = 8 cost = 1 size = 3 24363 if (CN1 == INT64_C(535)) { 24364 SDNode *Result = Emit_109(N, X86::MINPDrr_Int, MVT::v2f64); 24365 return Result; 24366 } 24367 24368 // Pattern: (intrinsic_wo_chain:v2f64 511:iPTR, VR128:v4i32:$src) 24369 // Emits: (Int_CVTDQ2PDrr:v2f64 VR128:v4i32:$src) 24370 // Pattern complexity = 8 cost = 1 size = 3 24371 if (CN1 == INT64_C(511)) { 24372 SDNode *Result = Emit_106(N, X86::Int_CVTDQ2PDrr, MVT::v2f64); 24373 return Result; 24374 } 24375 24376 // Pattern: (intrinsic_wo_chain:v2f64 516:iPTR, VR128:v4f32:$src) 24377 // Emits: (Int_CVTPS2PDrr:v2f64 VR128:v4f32:$src) 24378 // Pattern complexity = 8 cost = 1 size = 3 24379 if (CN1 == INT64_C(516)) { 24380 SDNode *Result = Emit_106(N, X86::Int_CVTPS2PDrr, MVT::v2f64); 24381 return Result; 24382 } 24383 24384 // Pattern: (intrinsic_wo_chain:v2f64 520:iPTR, VR128:v2f64:$src1, GR32:i32:$src2) 24385 // Emits: (Int_CVTSI2SDrr:v2f64 VR128:v2f64:$src1, GR32:i32:$src2) 24386 // Pattern complexity = 8 cost = 1 size = 3 24387 if (CN1 == INT64_C(520)) { 24388 SDNode *Result = Emit_109(N, X86::Int_CVTSI2SDrr, MVT::v2f64); 24389 return Result; 24390 } 24391 24392 // Pattern: (intrinsic_wo_chain:v2f64 522:iPTR, VR128:v2f64:$src1, VR128:v4f32:$src2) 24393 // Emits: (Int_CVTSS2SDrr:v2f64 VR128:v2f64:$src1, VR128:v4f32:$src2) 24394 // Pattern complexity = 8 cost = 1 size = 3 24395 if (CN1 == INT64_C(522)) { 24396 SDNode *Result = Emit_109(N, X86::Int_CVTSS2SDrr, MVT::v2f64); 24397 return Result; 24398 } 24399 24400 // Pattern: (intrinsic_wo_chain:v2f64 592:iPTR, VR128:v2f64:$src) 24401 // Emits: (SQRTSDr_Int:v2f64 VR128:v2f64:$src) 24402 // Pattern complexity = 8 cost = 1 size = 3 24403 if (CN1 == INT64_C(592)) { 24404 SDNode *Result = Emit_106(N, X86::SQRTSDr_Int, MVT::v2f64); 24405 return Result; 24406 } 24407 24408 // Pattern: (intrinsic_wo_chain:v2f64 591:iPTR, VR128:v2f64:$src) 24409 // Emits: (SQRTPDr_Int:v2f64 VR128:v2f64:$src) 24410 // Pattern complexity = 8 cost = 1 size = 3 24411 if (CN1 == INT64_C(591)) { 24412 SDNode *Result = Emit_106(N, X86::SQRTPDr_Int, MVT::v2f64); 24413 return Result; 24414 } 24415 } 24416 } 24417 if ((Subtarget->hasSSE3())) { 24418 SDValue N0 = N.getOperand(0); 24419 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 24420 if (Tmp0) { 24421 int64_t CN1 = Tmp0->getSExtValue(); 24422 24423 // Pattern: (intrinsic_wo_chain:v2f64 603:iPTR, VR128:v2f64:$src1, VR128:v2f64:$src2) 24424 // Emits: (ADDSUBPDrr:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 24425 // Pattern complexity = 8 cost = 1 size = 3 24426 if (CN1 == INT64_C(603)) { 24427 SDNode *Result = Emit_109(N, X86::ADDSUBPDrr, MVT::v2f64); 24428 return Result; 24429 } 24430 24431 // Pattern: (intrinsic_wo_chain:v2f64 605:iPTR, VR128:v2f64:$src1, VR128:v2f64:$src2) 24432 // Emits: (HADDPDrr:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 24433 // Pattern complexity = 8 cost = 1 size = 3 24434 if (CN1 == INT64_C(605)) { 24435 SDNode *Result = Emit_109(N, X86::HADDPDrr, MVT::v2f64); 24436 return Result; 24437 } 24438 24439 // Pattern: (intrinsic_wo_chain:v2f64 607:iPTR, VR128:v2f64:$src1, VR128:v2f64:$src2) 24440 // Emits: (HSUBPDrr:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 24441 // Pattern complexity = 8 cost = 1 size = 3 24442 if (CN1 == INT64_C(607)) { 24443 SDNode *Result = Emit_109(N, X86::HSUBPDrr, MVT::v2f64); 24444 return Result; 24445 } 24446 } 24447 } 24448 24449 // Pattern: (intrinsic_wo_chain:v2f64 614:iPTR, VR128:v2f64:$src1, VR128:v2f64:$src2, XMM0:v2f64) 24450 // Emits: (BLENDVPDrr0:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 24451 // Pattern complexity = 8 cost = 1 size = 3 24452 if ((Subtarget->hasSSE41())) { 24453 SDValue N0 = N.getOperand(0); 24454 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 24455 if (Tmp0) { 24456 int64_t CN1 = Tmp0->getSExtValue(); 24457 if (CN1 == INT64_C(614)) { 24458 SDNode *Result = Emit_119(N, X86::BLENDVPDrr0, MVT::v2f64); 24459 return Result; 24460 } 24461 } 24462 } 24463 24464 CannotYetSelectIntrinsic(N); 24465 return NULL; 24466 } 24467 24468 SDNode *Emit_138(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 24469 SDValue Chain = N.getOperand(0); 24470 SDValue N1 = N.getOperand(1); 24471 SDValue N2 = N.getOperand(2); 24472 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Chain }; 24473 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 6); 24474 } 24475 SDNode *Select_ISD_INTRINSIC_W_CHAIN_v16i8(const SDValue &N) { 24476 24477 // Pattern: (intrinsic_w_chain:v16i8 529:iPTR, addr:iPTR:$src) 24478 // Emits: (MOVDQUrm_Int:v16i8 addr:iPTR:$src) 24479 // Pattern complexity = 26 cost = 1 size = 3 24480 if ((Subtarget->hasSSE2())) { 24481 SDValue Chain = N.getOperand(0); 24482 SDValue N1 = N.getOperand(1); 24483 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 24484 if (Tmp0) { 24485 int64_t CN1 = Tmp0->getSExtValue(); 24486 if (CN1 == INT64_C(529)) { 24487 SDValue N2 = N.getOperand(2); 24488 SDValue CPTmpN2_0; 24489 SDValue CPTmpN2_1; 24490 SDValue CPTmpN2_2; 24491 SDValue CPTmpN2_3; 24492 SDValue CPTmpN2_4; 24493 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 24494 SDNode *Result = Emit_138(N, X86::MOVDQUrm_Int, MVT::v16i8, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 24495 return Result; 24496 } 24497 } 24498 } 24499 } 24500 24501 // Pattern: (intrinsic_w_chain:v16i8 609:iPTR, addr:iPTR:$src) 24502 // Emits: (LDDQUrm:v16i8 addr:iPTR:$src) 24503 // Pattern complexity = 26 cost = 1 size = 3 24504 if ((Subtarget->hasSSE3())) { 24505 SDValue Chain = N.getOperand(0); 24506 SDValue N1 = N.getOperand(1); 24507 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 24508 if (Tmp0) { 24509 int64_t CN1 = Tmp0->getSExtValue(); 24510 if (CN1 == INT64_C(609)) { 24511 SDValue N2 = N.getOperand(2); 24512 SDValue CPTmpN2_0; 24513 SDValue CPTmpN2_1; 24514 SDValue CPTmpN2_2; 24515 SDValue CPTmpN2_3; 24516 SDValue CPTmpN2_4; 24517 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 24518 SDNode *Result = Emit_138(N, X86::LDDQUrm, MVT::v16i8, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 24519 return Result; 24520 } 24521 } 24522 } 24523 } 24524 24525 CannotYetSelectIntrinsic(N); 24526 return NULL; 24527 } 24528 24529 SDNode *Select_ISD_INTRINSIC_W_CHAIN_v2i64(const SDValue &N) { 24530 if ((Subtarget->hasSSE41())) { 24531 SDValue Chain = N.getOperand(0); 24532 SDValue N1 = N.getOperand(1); 24533 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 24534 if (Tmp0) { 24535 int64_t CN1 = Tmp0->getSExtValue(); 24536 if (CN1 == INT64_C(620)) { 24537 SDValue N2 = N.getOperand(2); 24538 SDValue CPTmpN2_0; 24539 SDValue CPTmpN2_1; 24540 SDValue CPTmpN2_2; 24541 SDValue CPTmpN2_3; 24542 SDValue CPTmpN2_4; 24543 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 24544 SDNode *Result = Emit_138(N, X86::MOVNTDQArm, MVT::v2i64, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 24545 return Result; 24546 } 24547 } 24548 } 24549 } 24550 24551 CannotYetSelectIntrinsic(N); 24552 return NULL; 24553 } 24554 24555 SDNode *Select_ISD_INTRINSIC_W_CHAIN_v4f32(const SDValue &N) { 24556 if ((Subtarget->hasSSE1())) { 24557 SDValue Chain = N.getOperand(0); 24558 SDValue N1 = N.getOperand(1); 24559 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 24560 if (Tmp0) { 24561 int64_t CN1 = Tmp0->getSExtValue(); 24562 if (CN1 == INT64_C(701)) { 24563 SDValue N2 = N.getOperand(2); 24564 SDValue CPTmpN2_0; 24565 SDValue CPTmpN2_1; 24566 SDValue CPTmpN2_2; 24567 SDValue CPTmpN2_3; 24568 SDValue CPTmpN2_4; 24569 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 24570 SDNode *Result = Emit_138(N, X86::MOVUPSrm_Int, MVT::v4f32, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 24571 return Result; 24572 } 24573 } 24574 } 24575 } 24576 24577 CannotYetSelectIntrinsic(N); 24578 return NULL; 24579 } 24580 24581 SDNode *Select_ISD_INTRINSIC_W_CHAIN_v2f64(const SDValue &N) { 24582 if ((Subtarget->hasSSE2())) { 24583 SDValue Chain = N.getOperand(0); 24584 SDValue N1 = N.getOperand(1); 24585 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 24586 if (Tmp0) { 24587 int64_t CN1 = Tmp0->getSExtValue(); 24588 if (CN1 == INT64_C(530)) { 24589 SDValue N2 = N.getOperand(2); 24590 SDValue CPTmpN2_0; 24591 SDValue CPTmpN2_1; 24592 SDValue CPTmpN2_2; 24593 SDValue CPTmpN2_3; 24594 SDValue CPTmpN2_4; 24595 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 24596 SDNode *Result = Emit_138(N, X86::MOVUPDrm_Int, MVT::v2f64, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 24597 return Result; 24598 } 24599 } 24600 } 24601 } 24602 24603 CannotYetSelectIntrinsic(N); 24604 return NULL; 24605 } 24606 24607 SDNode *Emit_139(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN1_0, SDValue &CPTmpN1_1, SDValue &CPTmpN1_2, SDValue &CPTmpN1_3, SDValue &CPTmpN1_4) DISABLE_INLINE { 24608 SDValue Chain = N.getOperand(0); 24609 SDValue N1 = N.getOperand(1); 24610 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 24611 SDValue Ops0[] = { CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, LSI_N, Chain }; 24612 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 7); 24613 } 24614 SDNode *Select_ISD_LOAD_i8(const SDValue &N) { 24615 SDValue Chain = N.getOperand(0); 24616 if (Predicate_unindexedload(N.getNode())) { 24617 24618 // Pattern: (ld:i8 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>> 24619 // Emits: (MOV8rm:i8 addr:iPTR:$src) 24620 // Pattern complexity = 22 cost = 1 size = 3 24621 if (Predicate_load(N.getNode()) && 24622 Predicate_loadi8(N.getNode())) { 24623 SDValue N1 = N.getOperand(1); 24624 SDValue CPTmpN1_0; 24625 SDValue CPTmpN1_1; 24626 SDValue CPTmpN1_2; 24627 SDValue CPTmpN1_3; 24628 SDValue CPTmpN1_4; 24629 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24630 SDNode *Result = Emit_139(N, X86::MOV8rm, MVT::i8, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24631 return Result; 24632 } 24633 } 24634 24635 // Pattern: (ld:i8 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi1>> 24636 // Emits: (MOV8rm:i8 addr:iPTR:$src) 24637 // Pattern complexity = 22 cost = 1 size = 3 24638 if (Predicate_zextload(N.getNode()) && 24639 Predicate_zextloadi1(N.getNode())) { 24640 SDValue N1 = N.getOperand(1); 24641 SDValue CPTmpN1_0; 24642 SDValue CPTmpN1_1; 24643 SDValue CPTmpN1_2; 24644 SDValue CPTmpN1_3; 24645 SDValue CPTmpN1_4; 24646 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24647 SDNode *Result = Emit_139(N, X86::MOV8rm, MVT::i8, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24648 return Result; 24649 } 24650 } 24651 24652 // Pattern: (ld:i8 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi1>> 24653 // Emits: (MOV8rm:i8 addr:iPTR:$src) 24654 // Pattern complexity = 22 cost = 1 size = 3 24655 if (Predicate_extload(N.getNode()) && 24656 Predicate_extloadi1(N.getNode())) { 24657 SDValue N1 = N.getOperand(1); 24658 SDValue CPTmpN1_0; 24659 SDValue CPTmpN1_1; 24660 SDValue CPTmpN1_2; 24661 SDValue CPTmpN1_3; 24662 SDValue CPTmpN1_4; 24663 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24664 SDNode *Result = Emit_139(N, X86::MOV8rm, MVT::i8, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24665 return Result; 24666 } 24667 } 24668 } 24669 24670 CannotYetSelect(N); 24671 return NULL; 24672 } 24673 24674 SDNode *Emit_140(const SDValue &N, unsigned Opc0, unsigned Opc1, unsigned Opc2, EVT VT0, EVT VT1, EVT VT2, SDValue &CPTmpN1_0, SDValue &CPTmpN1_1, SDValue &CPTmpN1_2, SDValue &CPTmpN1_3, SDValue &CPTmpN1_4) DISABLE_INLINE { 24675 SDValue Chain = N.getOperand(0); 24676 SDValue N1 = N.getOperand(1); 24677 SDValue Tmp0(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0), 0); 24678 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 24679 SDValue Ops1[] = { CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, LSI_N, Chain }; 24680 SDValue Tmp2(CurDAG->getTargetNode(Opc1, N.getDebugLoc(), VT1, MVT::Other, Ops1, 7), 0); 24681 Chain = SDValue(Tmp2.getNode(), 1); 24682 SDValue Tmp3 = CurDAG->getTargetConstant(0x1ULL, MVT::i32); 24683 SDValue Ops2[] = { Tmp0, Tmp2, Tmp3, Chain }; 24684 return CurDAG->SelectNodeTo(N.getNode(), Opc2, VT2, MVT::Other, Ops2, 4); 24685 } 24686 SDNode *Select_ISD_LOAD_i16(const SDValue &N) { 24687 { 24688 SDValue Chain = N.getOperand(0); 24689 if (Predicate_unindexedload(N.getNode())) { 24690 24691 // Pattern: (ld:i16 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>> 24692 // Emits: (MOV16rm:i16 addr:iPTR:$src) 24693 // Pattern complexity = 22 cost = 1 size = 3 24694 if (Predicate_loadi16(N.getNode())) { 24695 SDValue N1 = N.getOperand(1); 24696 SDValue CPTmpN1_0; 24697 SDValue CPTmpN1_1; 24698 SDValue CPTmpN1_2; 24699 SDValue CPTmpN1_3; 24700 SDValue CPTmpN1_4; 24701 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24702 SDNode *Result = Emit_139(N, X86::MOV16rm, MVT::i16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24703 return Result; 24704 } 24705 } 24706 24707 // Pattern: (ld:i16 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi8>> 24708 // Emits: (MOVSX16rm8:i16 addr:iPTR:$src) 24709 // Pattern complexity = 22 cost = 1 size = 3 24710 if (Predicate_sextload(N.getNode()) && 24711 Predicate_sextloadi8(N.getNode())) { 24712 SDValue N1 = N.getOperand(1); 24713 SDValue CPTmpN1_0; 24714 SDValue CPTmpN1_1; 24715 SDValue CPTmpN1_2; 24716 SDValue CPTmpN1_3; 24717 SDValue CPTmpN1_4; 24718 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24719 SDNode *Result = Emit_139(N, X86::MOVSX16rm8, MVT::i16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24720 return Result; 24721 } 24722 } 24723 if (Predicate_zextload(N.getNode())) { 24724 24725 // Pattern: (ld:i16 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi8>> 24726 // Emits: (MOVZX16rm8:i16 addr:iPTR:$src) 24727 // Pattern complexity = 22 cost = 1 size = 3 24728 if (Predicate_zextloadi8(N.getNode())) { 24729 SDValue N1 = N.getOperand(1); 24730 SDValue CPTmpN1_0; 24731 SDValue CPTmpN1_1; 24732 SDValue CPTmpN1_2; 24733 SDValue CPTmpN1_3; 24734 SDValue CPTmpN1_4; 24735 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24736 SDNode *Result = Emit_139(N, X86::MOVZX16rm8, MVT::i16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24737 return Result; 24738 } 24739 } 24740 24741 // Pattern: (ld:i16 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi1>> 24742 // Emits: (MOVZX16rm8:i16 addr:iPTR:$src) 24743 // Pattern complexity = 22 cost = 1 size = 3 24744 if (Predicate_zextloadi1(N.getNode())) { 24745 SDValue N1 = N.getOperand(1); 24746 SDValue CPTmpN1_0; 24747 SDValue CPTmpN1_1; 24748 SDValue CPTmpN1_2; 24749 SDValue CPTmpN1_3; 24750 SDValue CPTmpN1_4; 24751 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24752 SDNode *Result = Emit_139(N, X86::MOVZX16rm8, MVT::i16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24753 return Result; 24754 } 24755 } 24756 } 24757 } 24758 } 24759 if ((!Subtarget->is64Bit())) { 24760 SDValue Chain = N.getOperand(0); 24761 if (Predicate_unindexedload(N.getNode()) && 24762 Predicate_extload(N.getNode())) { 24763 24764 // Pattern: (ld:i16 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi1>> 24765 // Emits: (MOVZX16rm8:i16 addr:iPTR:$src) 24766 // Pattern complexity = 22 cost = 1 size = 3 24767 if (Predicate_extloadi1(N.getNode())) { 24768 SDValue N1 = N.getOperand(1); 24769 SDValue CPTmpN1_0; 24770 SDValue CPTmpN1_1; 24771 SDValue CPTmpN1_2; 24772 SDValue CPTmpN1_3; 24773 SDValue CPTmpN1_4; 24774 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24775 SDNode *Result = Emit_139(N, X86::MOVZX16rm8, MVT::i16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24776 return Result; 24777 } 24778 } 24779 24780 // Pattern: (ld:i16 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> 24781 // Emits: (MOVZX16rm8:i16 addr:iPTR:$src) 24782 // Pattern complexity = 22 cost = 1 size = 3 24783 if (Predicate_extloadi8(N.getNode())) { 24784 SDValue N1 = N.getOperand(1); 24785 SDValue CPTmpN1_0; 24786 SDValue CPTmpN1_1; 24787 SDValue CPTmpN1_2; 24788 SDValue CPTmpN1_3; 24789 SDValue CPTmpN1_4; 24790 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24791 SDNode *Result = Emit_139(N, X86::MOVZX16rm8, MVT::i16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24792 return Result; 24793 } 24794 } 24795 } 24796 } 24797 if ((Subtarget->is64Bit())) { 24798 SDValue Chain = N.getOperand(0); 24799 if (Predicate_unindexedload(N.getNode()) && 24800 Predicate_extload(N.getNode())) { 24801 24802 // Pattern: (ld:i16 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi1>> 24803 // Emits: (INSERT_SUBREG:i16 (IMPLICIT_DEF:i16), (MOV8rm:i8 addr:iPTR:$src), 1:i32) 24804 // Pattern complexity = 22 cost = 3 size = 3 24805 if (Predicate_extloadi1(N.getNode())) { 24806 SDValue N1 = N.getOperand(1); 24807 SDValue CPTmpN1_0; 24808 SDValue CPTmpN1_1; 24809 SDValue CPTmpN1_2; 24810 SDValue CPTmpN1_3; 24811 SDValue CPTmpN1_4; 24812 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24813 SDNode *Result = Emit_140(N, TargetInstrInfo::IMPLICIT_DEF, X86::MOV8rm, TargetInstrInfo::INSERT_SUBREG, MVT::i16, MVT::i8, MVT::i16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24814 return Result; 24815 } 24816 } 24817 24818 // Pattern: (ld:i16 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> 24819 // Emits: (INSERT_SUBREG:i16 (IMPLICIT_DEF:i16), (MOV8rm:i8 addr:iPTR:$src), 1:i32) 24820 // Pattern complexity = 22 cost = 3 size = 3 24821 if (Predicate_extloadi8(N.getNode())) { 24822 SDValue N1 = N.getOperand(1); 24823 SDValue CPTmpN1_0; 24824 SDValue CPTmpN1_1; 24825 SDValue CPTmpN1_2; 24826 SDValue CPTmpN1_3; 24827 SDValue CPTmpN1_4; 24828 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24829 SDNode *Result = Emit_140(N, TargetInstrInfo::IMPLICIT_DEF, X86::MOV8rm, TargetInstrInfo::INSERT_SUBREG, MVT::i16, MVT::i8, MVT::i16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24830 return Result; 24831 } 24832 } 24833 } 24834 } 24835 24836 CannotYetSelect(N); 24837 return NULL; 24838 } 24839 24840 SDNode *Select_ISD_LOAD_i32(const SDValue &N) { 24841 SDValue Chain = N.getOperand(0); 24842 if (Predicate_unindexedload(N.getNode())) { 24843 if (Predicate_load(N.getNode())) { 24844 24845 // Pattern: (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_gsload>> 24846 // Emits: (GS_MOV32rm:i32 addr:iPTR:$src) 24847 // Pattern complexity = 27 cost = 1 size = 3 24848 if (Predicate_gsload(N.getNode())) { 24849 SDValue N1 = N.getOperand(1); 24850 SDValue CPTmpN1_0; 24851 SDValue CPTmpN1_1; 24852 SDValue CPTmpN1_2; 24853 SDValue CPTmpN1_3; 24854 SDValue CPTmpN1_4; 24855 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24856 SDNode *Result = Emit_139(N, X86::GS_MOV32rm, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24857 return Result; 24858 } 24859 } 24860 24861 // Pattern: (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_fsload>> 24862 // Emits: (FS_MOV32rm:i32 addr:iPTR:$src) 24863 // Pattern complexity = 27 cost = 1 size = 3 24864 if (Predicate_fsload(N.getNode())) { 24865 SDValue N1 = N.getOperand(1); 24866 SDValue CPTmpN1_0; 24867 SDValue CPTmpN1_1; 24868 SDValue CPTmpN1_2; 24869 SDValue CPTmpN1_3; 24870 SDValue CPTmpN1_4; 24871 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24872 SDNode *Result = Emit_139(N, X86::FS_MOV32rm, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24873 return Result; 24874 } 24875 } 24876 } 24877 24878 // Pattern: (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>> 24879 // Emits: (MOV32rm:i32 addr:iPTR:$src) 24880 // Pattern complexity = 22 cost = 1 size = 3 24881 if (Predicate_loadi32(N.getNode())) { 24882 SDValue N1 = N.getOperand(1); 24883 SDValue CPTmpN1_0; 24884 SDValue CPTmpN1_1; 24885 SDValue CPTmpN1_2; 24886 SDValue CPTmpN1_3; 24887 SDValue CPTmpN1_4; 24888 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24889 SDNode *Result = Emit_139(N, X86::MOV32rm, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24890 return Result; 24891 } 24892 } 24893 if (Predicate_sextload(N.getNode())) { 24894 24895 // Pattern: (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi8>> 24896 // Emits: (MOVSX32rm8:i32 addr:iPTR:$src) 24897 // Pattern complexity = 22 cost = 1 size = 3 24898 if (Predicate_sextloadi8(N.getNode())) { 24899 SDValue N1 = N.getOperand(1); 24900 SDValue CPTmpN1_0; 24901 SDValue CPTmpN1_1; 24902 SDValue CPTmpN1_2; 24903 SDValue CPTmpN1_3; 24904 SDValue CPTmpN1_4; 24905 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24906 SDNode *Result = Emit_139(N, X86::MOVSX32rm8, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24907 return Result; 24908 } 24909 } 24910 24911 // Pattern: (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi16>> 24912 // Emits: (MOVSX32rm16:i32 addr:iPTR:$src) 24913 // Pattern complexity = 22 cost = 1 size = 3 24914 if (Predicate_sextloadi16(N.getNode())) { 24915 SDValue N1 = N.getOperand(1); 24916 SDValue CPTmpN1_0; 24917 SDValue CPTmpN1_1; 24918 SDValue CPTmpN1_2; 24919 SDValue CPTmpN1_3; 24920 SDValue CPTmpN1_4; 24921 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24922 SDNode *Result = Emit_139(N, X86::MOVSX32rm16, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24923 return Result; 24924 } 24925 } 24926 } 24927 if (Predicate_zextload(N.getNode())) { 24928 24929 // Pattern: (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi8>> 24930 // Emits: (MOVZX32rm8:i32 addr:iPTR:$src) 24931 // Pattern complexity = 22 cost = 1 size = 3 24932 if (Predicate_zextloadi8(N.getNode())) { 24933 SDValue N1 = N.getOperand(1); 24934 SDValue CPTmpN1_0; 24935 SDValue CPTmpN1_1; 24936 SDValue CPTmpN1_2; 24937 SDValue CPTmpN1_3; 24938 SDValue CPTmpN1_4; 24939 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24940 SDNode *Result = Emit_139(N, X86::MOVZX32rm8, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24941 return Result; 24942 } 24943 } 24944 24945 // Pattern: (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi16>> 24946 // Emits: (MOVZX32rm16:i32 addr:iPTR:$src) 24947 // Pattern complexity = 22 cost = 1 size = 3 24948 if (Predicate_zextloadi16(N.getNode())) { 24949 SDValue N1 = N.getOperand(1); 24950 SDValue CPTmpN1_0; 24951 SDValue CPTmpN1_1; 24952 SDValue CPTmpN1_2; 24953 SDValue CPTmpN1_3; 24954 SDValue CPTmpN1_4; 24955 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24956 SDNode *Result = Emit_139(N, X86::MOVZX32rm16, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24957 return Result; 24958 } 24959 } 24960 24961 // Pattern: (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi1>> 24962 // Emits: (MOVZX32rm8:i32 addr:iPTR:$src) 24963 // Pattern complexity = 22 cost = 1 size = 3 24964 if (Predicate_zextloadi1(N.getNode())) { 24965 SDValue N1 = N.getOperand(1); 24966 SDValue CPTmpN1_0; 24967 SDValue CPTmpN1_1; 24968 SDValue CPTmpN1_2; 24969 SDValue CPTmpN1_3; 24970 SDValue CPTmpN1_4; 24971 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24972 SDNode *Result = Emit_139(N, X86::MOVZX32rm8, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24973 return Result; 24974 } 24975 } 24976 } 24977 if (Predicate_extload(N.getNode())) { 24978 24979 // Pattern: (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi1>> 24980 // Emits: (MOVZX32rm8:i32 addr:iPTR:$src) 24981 // Pattern complexity = 22 cost = 1 size = 3 24982 if (Predicate_extloadi1(N.getNode())) { 24983 SDValue N1 = N.getOperand(1); 24984 SDValue CPTmpN1_0; 24985 SDValue CPTmpN1_1; 24986 SDValue CPTmpN1_2; 24987 SDValue CPTmpN1_3; 24988 SDValue CPTmpN1_4; 24989 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 24990 SDNode *Result = Emit_139(N, X86::MOVZX32rm8, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 24991 return Result; 24992 } 24993 } 24994 24995 // Pattern: (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> 24996 // Emits: (MOVZX32rm8:i32 addr:iPTR:$src) 24997 // Pattern complexity = 22 cost = 1 size = 3 24998 if (Predicate_extloadi8(N.getNode())) { 24999 SDValue N1 = N.getOperand(1); 25000 SDValue CPTmpN1_0; 25001 SDValue CPTmpN1_1; 25002 SDValue CPTmpN1_2; 25003 SDValue CPTmpN1_3; 25004 SDValue CPTmpN1_4; 25005 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25006 SDNode *Result = Emit_139(N, X86::MOVZX32rm8, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25007 return Result; 25008 } 25009 } 25010 25011 // Pattern: (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi16>> 25012 // Emits: (MOVZX32rm16:i32 addr:iPTR:$src) 25013 // Pattern complexity = 22 cost = 1 size = 3 25014 if (Predicate_extloadi16(N.getNode())) { 25015 SDValue N1 = N.getOperand(1); 25016 SDValue CPTmpN1_0; 25017 SDValue CPTmpN1_1; 25018 SDValue CPTmpN1_2; 25019 SDValue CPTmpN1_3; 25020 SDValue CPTmpN1_4; 25021 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25022 SDNode *Result = Emit_139(N, X86::MOVZX32rm16, MVT::i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25023 return Result; 25024 } 25025 } 25026 } 25027 } 25028 25029 CannotYetSelect(N); 25030 return NULL; 25031 } 25032 25033 SDNode *Emit_141(const SDValue &N, unsigned Opc0, unsigned Opc1, unsigned Opc2, EVT VT0, EVT VT1, EVT VT2, SDValue &CPTmpN1_0, SDValue &CPTmpN1_1, SDValue &CPTmpN1_2, SDValue &CPTmpN1_3, SDValue &CPTmpN1_4) DISABLE_INLINE { 25034 SDValue Chain = N.getOperand(0); 25035 SDValue N1 = N.getOperand(1); 25036 SDValue Tmp0(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0), 0); 25037 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 25038 SDValue Ops1[] = { CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, LSI_N, Chain }; 25039 SDValue Tmp2(CurDAG->getTargetNode(Opc1, N.getDebugLoc(), VT1, MVT::Other, Ops1, 7), 0); 25040 Chain = SDValue(Tmp2.getNode(), 1); 25041 SDValue Tmp3 = CurDAG->getTargetConstant(0x4ULL, MVT::i32); 25042 SDValue Ops2[] = { Tmp0, Tmp2, Tmp3, Chain }; 25043 return CurDAG->SelectNodeTo(N.getNode(), Opc2, VT2, MVT::Other, Ops2, 4); 25044 } 25045 SDNode *Select_ISD_LOAD_i64(const SDValue &N) { 25046 SDValue Chain = N.getOperand(0); 25047 if (Predicate_unindexedload(N.getNode())) { 25048 if (Predicate_load(N.getNode())) { 25049 25050 // Pattern: (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_gsload>> 25051 // Emits: (MOV64GSrm:i64 addr:iPTR:$src) 25052 // Pattern complexity = 27 cost = 1 size = 3 25053 if (Predicate_gsload(N.getNode())) { 25054 SDValue N1 = N.getOperand(1); 25055 SDValue CPTmpN1_0; 25056 SDValue CPTmpN1_1; 25057 SDValue CPTmpN1_2; 25058 SDValue CPTmpN1_3; 25059 SDValue CPTmpN1_4; 25060 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25061 SDNode *Result = Emit_139(N, X86::MOV64GSrm, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25062 return Result; 25063 } 25064 } 25065 25066 // Pattern: (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_fsload>> 25067 // Emits: (MOV64FSrm:i64 addr:iPTR:$src) 25068 // Pattern complexity = 27 cost = 1 size = 3 25069 if (Predicate_fsload(N.getNode())) { 25070 SDValue N1 = N.getOperand(1); 25071 SDValue CPTmpN1_0; 25072 SDValue CPTmpN1_1; 25073 SDValue CPTmpN1_2; 25074 SDValue CPTmpN1_3; 25075 SDValue CPTmpN1_4; 25076 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25077 SDNode *Result = Emit_139(N, X86::MOV64FSrm, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25078 return Result; 25079 } 25080 } 25081 25082 // Pattern: (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>> 25083 // Emits: (MOV64rm:i64 addr:iPTR:$src) 25084 // Pattern complexity = 22 cost = 1 size = 3 25085 SDValue N1 = N.getOperand(1); 25086 SDValue CPTmpN1_0; 25087 SDValue CPTmpN1_1; 25088 SDValue CPTmpN1_2; 25089 SDValue CPTmpN1_3; 25090 SDValue CPTmpN1_4; 25091 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25092 SDNode *Result = Emit_139(N, X86::MOV64rm, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25093 return Result; 25094 } 25095 } 25096 if (Predicate_sextload(N.getNode())) { 25097 25098 // Pattern: (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi8>> 25099 // Emits: (MOVSX64rm8:i64 addr:iPTR:$src) 25100 // Pattern complexity = 22 cost = 1 size = 3 25101 if (Predicate_sextloadi8(N.getNode())) { 25102 SDValue N1 = N.getOperand(1); 25103 SDValue CPTmpN1_0; 25104 SDValue CPTmpN1_1; 25105 SDValue CPTmpN1_2; 25106 SDValue CPTmpN1_3; 25107 SDValue CPTmpN1_4; 25108 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25109 SDNode *Result = Emit_139(N, X86::MOVSX64rm8, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25110 return Result; 25111 } 25112 } 25113 25114 // Pattern: (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi16>> 25115 // Emits: (MOVSX64rm16:i64 addr:iPTR:$src) 25116 // Pattern complexity = 22 cost = 1 size = 3 25117 if (Predicate_sextloadi16(N.getNode())) { 25118 SDValue N1 = N.getOperand(1); 25119 SDValue CPTmpN1_0; 25120 SDValue CPTmpN1_1; 25121 SDValue CPTmpN1_2; 25122 SDValue CPTmpN1_3; 25123 SDValue CPTmpN1_4; 25124 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25125 SDNode *Result = Emit_139(N, X86::MOVSX64rm16, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25126 return Result; 25127 } 25128 } 25129 25130 // Pattern: (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_sextload>><<P:Predicate_sextloadi32>> 25131 // Emits: (MOVSX64rm32:i64 addr:iPTR:$src) 25132 // Pattern complexity = 22 cost = 1 size = 3 25133 if (Predicate_sextloadi32(N.getNode())) { 25134 SDValue N1 = N.getOperand(1); 25135 SDValue CPTmpN1_0; 25136 SDValue CPTmpN1_1; 25137 SDValue CPTmpN1_2; 25138 SDValue CPTmpN1_3; 25139 SDValue CPTmpN1_4; 25140 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25141 SDNode *Result = Emit_139(N, X86::MOVSX64rm32, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25142 return Result; 25143 } 25144 } 25145 } 25146 if (Predicate_zextload(N.getNode())) { 25147 25148 // Pattern: (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi8>> 25149 // Emits: (MOVZX64rm8:i64 addr:iPTR:$src) 25150 // Pattern complexity = 22 cost = 1 size = 3 25151 if (Predicate_zextloadi8(N.getNode())) { 25152 SDValue N1 = N.getOperand(1); 25153 SDValue CPTmpN1_0; 25154 SDValue CPTmpN1_1; 25155 SDValue CPTmpN1_2; 25156 SDValue CPTmpN1_3; 25157 SDValue CPTmpN1_4; 25158 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25159 SDNode *Result = Emit_139(N, X86::MOVZX64rm8, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25160 return Result; 25161 } 25162 } 25163 25164 // Pattern: (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi16>> 25165 // Emits: (MOVZX64rm16:i64 addr:iPTR:$src) 25166 // Pattern complexity = 22 cost = 1 size = 3 25167 if (Predicate_zextloadi16(N.getNode())) { 25168 SDValue N1 = N.getOperand(1); 25169 SDValue CPTmpN1_0; 25170 SDValue CPTmpN1_1; 25171 SDValue CPTmpN1_2; 25172 SDValue CPTmpN1_3; 25173 SDValue CPTmpN1_4; 25174 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25175 SDNode *Result = Emit_139(N, X86::MOVZX64rm16, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25176 return Result; 25177 } 25178 } 25179 25180 // Pattern: (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi32>> 25181 // Emits: (MOVZX64rm32:i64 addr:iPTR:$src) 25182 // Pattern complexity = 22 cost = 1 size = 3 25183 if (Predicate_zextloadi32(N.getNode())) { 25184 SDValue N1 = N.getOperand(1); 25185 SDValue CPTmpN1_0; 25186 SDValue CPTmpN1_1; 25187 SDValue CPTmpN1_2; 25188 SDValue CPTmpN1_3; 25189 SDValue CPTmpN1_4; 25190 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25191 SDNode *Result = Emit_139(N, X86::MOVZX64rm32, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25192 return Result; 25193 } 25194 } 25195 25196 // Pattern: (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_zextload>><<P:Predicate_zextloadi1>> 25197 // Emits: (MOVZX64rm8:i64 addr:iPTR:$src) 25198 // Pattern complexity = 22 cost = 1 size = 3 25199 if (Predicate_zextloadi1(N.getNode())) { 25200 SDValue N1 = N.getOperand(1); 25201 SDValue CPTmpN1_0; 25202 SDValue CPTmpN1_1; 25203 SDValue CPTmpN1_2; 25204 SDValue CPTmpN1_3; 25205 SDValue CPTmpN1_4; 25206 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25207 SDNode *Result = Emit_139(N, X86::MOVZX64rm8, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25208 return Result; 25209 } 25210 } 25211 } 25212 if (Predicate_extload(N.getNode())) { 25213 25214 // Pattern: (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi1>> 25215 // Emits: (MOVZX64rm8:i64 addr:iPTR:$src) 25216 // Pattern complexity = 22 cost = 1 size = 3 25217 if (Predicate_extloadi1(N.getNode())) { 25218 SDValue N1 = N.getOperand(1); 25219 SDValue CPTmpN1_0; 25220 SDValue CPTmpN1_1; 25221 SDValue CPTmpN1_2; 25222 SDValue CPTmpN1_3; 25223 SDValue CPTmpN1_4; 25224 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25225 SDNode *Result = Emit_139(N, X86::MOVZX64rm8, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25226 return Result; 25227 } 25228 } 25229 25230 // Pattern: (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>> 25231 // Emits: (MOVZX64rm8:i64 addr:iPTR:$src) 25232 // Pattern complexity = 22 cost = 1 size = 3 25233 if (Predicate_extloadi8(N.getNode())) { 25234 SDValue N1 = N.getOperand(1); 25235 SDValue CPTmpN1_0; 25236 SDValue CPTmpN1_1; 25237 SDValue CPTmpN1_2; 25238 SDValue CPTmpN1_3; 25239 SDValue CPTmpN1_4; 25240 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25241 SDNode *Result = Emit_139(N, X86::MOVZX64rm8, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25242 return Result; 25243 } 25244 } 25245 25246 // Pattern: (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi16>> 25247 // Emits: (MOVZX64rm16:i64 addr:iPTR:$src) 25248 // Pattern complexity = 22 cost = 1 size = 3 25249 if (Predicate_extloadi16(N.getNode())) { 25250 SDValue N1 = N.getOperand(1); 25251 SDValue CPTmpN1_0; 25252 SDValue CPTmpN1_1; 25253 SDValue CPTmpN1_2; 25254 SDValue CPTmpN1_3; 25255 SDValue CPTmpN1_4; 25256 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25257 SDNode *Result = Emit_139(N, X86::MOVZX64rm16, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25258 return Result; 25259 } 25260 } 25261 25262 // Pattern: (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi32>> 25263 // Emits: (INSERT_SUBREG:i64 (IMPLICIT_DEF:i64), (MOV32rm:i32 addr:iPTR:$src), 4:i32) 25264 // Pattern complexity = 22 cost = 3 size = 3 25265 if (Predicate_extloadi32(N.getNode())) { 25266 SDValue N1 = N.getOperand(1); 25267 SDValue CPTmpN1_0; 25268 SDValue CPTmpN1_1; 25269 SDValue CPTmpN1_2; 25270 SDValue CPTmpN1_3; 25271 SDValue CPTmpN1_4; 25272 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25273 SDNode *Result = Emit_141(N, TargetInstrInfo::IMPLICIT_DEF, X86::MOV32rm, TargetInstrInfo::INSERT_SUBREG, MVT::i64, MVT::i32, MVT::i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25274 return Result; 25275 } 25276 } 25277 } 25278 } 25279 25280 CannotYetSelect(N); 25281 return NULL; 25282 } 25283 25284 SDNode *Select_ISD_LOAD_f32(const SDValue &N) { 25285 25286 // Pattern: (ld:f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf32>> 25287 // Emits: (LD_Fp32m:f32 addr:iPTR:$src) 25288 // Pattern complexity = 22 cost = 1 size = 0 25289 if ((!Subtarget->hasSSE1())) { 25290 SDValue Chain = N.getOperand(0); 25291 if (Predicate_unindexedload(N.getNode()) && 25292 Predicate_load(N.getNode()) && 25293 Predicate_loadf32(N.getNode())) { 25294 SDValue N1 = N.getOperand(1); 25295 SDValue CPTmpN1_0; 25296 SDValue CPTmpN1_1; 25297 SDValue CPTmpN1_2; 25298 SDValue CPTmpN1_3; 25299 SDValue CPTmpN1_4; 25300 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25301 SDNode *Result = Emit_139(N, X86::LD_Fp32m, MVT::f32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25302 return Result; 25303 } 25304 } 25305 } 25306 if ((Subtarget->hasSSE1())) { 25307 SDValue Chain = N.getOperand(0); 25308 if (Predicate_unindexedload(N.getNode()) && 25309 Predicate_load(N.getNode())) { 25310 25311 // Pattern: (ld:f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf32>> 25312 // Emits: (MOVSSrm:f32 addr:iPTR:$src) 25313 // Pattern complexity = 22 cost = 1 size = 3 25314 if (Predicate_loadf32(N.getNode())) { 25315 SDValue N1 = N.getOperand(1); 25316 SDValue CPTmpN1_0; 25317 SDValue CPTmpN1_1; 25318 SDValue CPTmpN1_2; 25319 SDValue CPTmpN1_3; 25320 SDValue CPTmpN1_4; 25321 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25322 SDNode *Result = Emit_139(N, X86::MOVSSrm, MVT::f32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25323 return Result; 25324 } 25325 } 25326 25327 // Pattern: (ld:f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_alignedload>> 25328 // Emits: (FsMOVAPSrm:f32 addr:iPTR:$src) 25329 // Pattern complexity = 22 cost = 1 size = 3 25330 if (Predicate_alignedload(N.getNode())) { 25331 SDValue N1 = N.getOperand(1); 25332 SDValue CPTmpN1_0; 25333 SDValue CPTmpN1_1; 25334 SDValue CPTmpN1_2; 25335 SDValue CPTmpN1_3; 25336 SDValue CPTmpN1_4; 25337 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25338 SDNode *Result = Emit_139(N, X86::FsMOVAPSrm, MVT::f32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25339 return Result; 25340 } 25341 } 25342 } 25343 } 25344 25345 CannotYetSelect(N); 25346 return NULL; 25347 } 25348 25349 SDNode *Select_ISD_LOAD_f64(const SDValue &N) { 25350 if ((!Subtarget->hasSSE2())) { 25351 SDValue Chain = N.getOperand(0); 25352 if (Predicate_unindexedload(N.getNode())) { 25353 25354 // Pattern: (ld:f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>> 25355 // Emits: (LD_Fp64m:f64 addr:iPTR:$src) 25356 // Pattern complexity = 22 cost = 1 size = 0 25357 if (Predicate_load(N.getNode()) && 25358 Predicate_loadf64(N.getNode())) { 25359 SDValue N1 = N.getOperand(1); 25360 SDValue CPTmpN1_0; 25361 SDValue CPTmpN1_1; 25362 SDValue CPTmpN1_2; 25363 SDValue CPTmpN1_3; 25364 SDValue CPTmpN1_4; 25365 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25366 SDNode *Result = Emit_139(N, X86::LD_Fp64m, MVT::f64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25367 return Result; 25368 } 25369 } 25370 25371 // Pattern: (ld:f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>> 25372 // Emits: (LD_Fp32m64:f64 addr:iPTR:$src) 25373 // Pattern complexity = 22 cost = 1 size = 0 25374 if (Predicate_extload(N.getNode()) && 25375 Predicate_extloadf32(N.getNode())) { 25376 SDValue N1 = N.getOperand(1); 25377 SDValue CPTmpN1_0; 25378 SDValue CPTmpN1_1; 25379 SDValue CPTmpN1_2; 25380 SDValue CPTmpN1_3; 25381 SDValue CPTmpN1_4; 25382 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25383 SDNode *Result = Emit_139(N, X86::LD_Fp32m64, MVT::f64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25384 return Result; 25385 } 25386 } 25387 } 25388 } 25389 if ((Subtarget->hasSSE2())) { 25390 SDValue Chain = N.getOperand(0); 25391 if (Predicate_unindexedload(N.getNode())) { 25392 25393 // Pattern: (ld:f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>> 25394 // Emits: (MOVSDrm:f64 addr:iPTR:$src) 25395 // Pattern complexity = 22 cost = 1 size = 3 25396 if (Predicate_load(N.getNode()) && 25397 Predicate_loadf64(N.getNode())) { 25398 SDValue N1 = N.getOperand(1); 25399 SDValue CPTmpN1_0; 25400 SDValue CPTmpN1_1; 25401 SDValue CPTmpN1_2; 25402 SDValue CPTmpN1_3; 25403 SDValue CPTmpN1_4; 25404 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25405 SDNode *Result = Emit_139(N, X86::MOVSDrm, MVT::f64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25406 return Result; 25407 } 25408 } 25409 25410 // Pattern: (ld:f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>> 25411 // Emits: (CVTSS2SDrm:f64 addr:iPTR:$src) 25412 // Pattern complexity = 22 cost = 1 size = 3 25413 if (Predicate_extload(N.getNode()) && 25414 Predicate_extloadf32(N.getNode())) { 25415 SDValue N1 = N.getOperand(1); 25416 SDValue CPTmpN1_0; 25417 SDValue CPTmpN1_1; 25418 SDValue CPTmpN1_2; 25419 SDValue CPTmpN1_3; 25420 SDValue CPTmpN1_4; 25421 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25422 SDNode *Result = Emit_139(N, X86::CVTSS2SDrm, MVT::f64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25423 return Result; 25424 } 25425 } 25426 25427 // Pattern: (ld:f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_alignedload>> 25428 // Emits: (FsMOVAPDrm:f64 addr:iPTR:$src) 25429 // Pattern complexity = 22 cost = 1 size = 3 25430 if (Predicate_load(N.getNode()) && 25431 Predicate_alignedload(N.getNode())) { 25432 SDValue N1 = N.getOperand(1); 25433 SDValue CPTmpN1_0; 25434 SDValue CPTmpN1_1; 25435 SDValue CPTmpN1_2; 25436 SDValue CPTmpN1_3; 25437 SDValue CPTmpN1_4; 25438 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25439 SDNode *Result = Emit_139(N, X86::FsMOVAPDrm, MVT::f64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25440 return Result; 25441 } 25442 } 25443 } 25444 } 25445 25446 CannotYetSelect(N); 25447 return NULL; 25448 } 25449 25450 SDNode *Select_ISD_LOAD_f80(const SDValue &N) { 25451 SDValue Chain = N.getOperand(0); 25452 if (Predicate_unindexedload(N.getNode())) { 25453 25454 // Pattern: (ld:f80 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf80>> 25455 // Emits: (LD_Fp80m:f80 addr:iPTR:$src) 25456 // Pattern complexity = 22 cost = 1 size = 0 25457 if (Predicate_load(N.getNode()) && 25458 Predicate_loadf80(N.getNode())) { 25459 SDValue N1 = N.getOperand(1); 25460 SDValue CPTmpN1_0; 25461 SDValue CPTmpN1_1; 25462 SDValue CPTmpN1_2; 25463 SDValue CPTmpN1_3; 25464 SDValue CPTmpN1_4; 25465 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25466 SDNode *Result = Emit_139(N, X86::LD_Fp80m, MVT::f80, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25467 return Result; 25468 } 25469 } 25470 if (Predicate_extload(N.getNode())) { 25471 25472 // Pattern: (ld:f80 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf64>> 25473 // Emits: (LD_Fp64m80:f80 addr:iPTR:$src) 25474 // Pattern complexity = 22 cost = 1 size = 0 25475 if (Predicate_extloadf64(N.getNode())) { 25476 SDValue N1 = N.getOperand(1); 25477 SDValue CPTmpN1_0; 25478 SDValue CPTmpN1_1; 25479 SDValue CPTmpN1_2; 25480 SDValue CPTmpN1_3; 25481 SDValue CPTmpN1_4; 25482 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25483 SDNode *Result = Emit_139(N, X86::LD_Fp64m80, MVT::f80, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25484 return Result; 25485 } 25486 } 25487 25488 // Pattern: (ld:f80 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadf32>> 25489 // Emits: (LD_Fp32m80:f80 addr:iPTR:$src) 25490 // Pattern complexity = 22 cost = 1 size = 0 25491 if (Predicate_extloadf32(N.getNode())) { 25492 SDValue N1 = N.getOperand(1); 25493 SDValue CPTmpN1_0; 25494 SDValue CPTmpN1_1; 25495 SDValue CPTmpN1_2; 25496 SDValue CPTmpN1_3; 25497 SDValue CPTmpN1_4; 25498 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25499 SDNode *Result = Emit_139(N, X86::LD_Fp32m80, MVT::f80, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25500 return Result; 25501 } 25502 } 25503 } 25504 } 25505 25506 CannotYetSelect(N); 25507 return NULL; 25508 } 25509 25510 SDNode *Select_ISD_LOAD_v4i32(const SDValue &N) { 25511 if ((Subtarget->hasSSE1())) { 25512 SDValue Chain = N.getOperand(0); 25513 if (Predicate_unindexedload(N.getNode()) && 25514 Predicate_load(N.getNode())) { 25515 25516 // Pattern: (ld:v4i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_alignedload>> 25517 // Emits: (MOVAPSrm:v4i32 addr:iPTR:$src) 25518 // Pattern complexity = 22 cost = 1 size = 3 25519 if (Predicate_alignedload(N.getNode())) { 25520 SDValue N1 = N.getOperand(1); 25521 SDValue CPTmpN1_0; 25522 SDValue CPTmpN1_1; 25523 SDValue CPTmpN1_2; 25524 SDValue CPTmpN1_3; 25525 SDValue CPTmpN1_4; 25526 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25527 SDNode *Result = Emit_139(N, X86::MOVAPSrm, MVT::v4i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25528 return Result; 25529 } 25530 } 25531 25532 // Pattern: (ld:v4i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>> 25533 // Emits: (MOVUPSrm:v4i32 addr:iPTR:$src) 25534 // Pattern complexity = 22 cost = 1 size = 3 25535 SDValue N1 = N.getOperand(1); 25536 SDValue CPTmpN1_0; 25537 SDValue CPTmpN1_1; 25538 SDValue CPTmpN1_2; 25539 SDValue CPTmpN1_3; 25540 SDValue CPTmpN1_4; 25541 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25542 SDNode *Result = Emit_139(N, X86::MOVUPSrm, MVT::v4i32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25543 return Result; 25544 } 25545 } 25546 } 25547 25548 CannotYetSelect(N); 25549 return NULL; 25550 } 25551 25552 SDNode *Select_ISD_LOAD_v1i64(const SDValue &N) { 25553 if ((Subtarget->hasMMX())) { 25554 SDValue Chain = N.getOperand(0); 25555 if (Predicate_unindexedload(N.getNode()) && 25556 Predicate_load(N.getNode())) { 25557 SDValue N1 = N.getOperand(1); 25558 SDValue CPTmpN1_0; 25559 SDValue CPTmpN1_1; 25560 SDValue CPTmpN1_2; 25561 SDValue CPTmpN1_3; 25562 SDValue CPTmpN1_4; 25563 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25564 SDNode *Result = Emit_139(N, X86::MMX_MOVQ64rm, MVT::v1i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25565 return Result; 25566 } 25567 } 25568 } 25569 25570 CannotYetSelect(N); 25571 return NULL; 25572 } 25573 25574 SDNode *Select_ISD_LOAD_v2i64(const SDValue &N) { 25575 if ((Subtarget->hasSSE2())) { 25576 SDValue Chain = N.getOperand(0); 25577 if (Predicate_unindexedload(N.getNode()) && 25578 Predicate_load(N.getNode())) { 25579 25580 // Pattern: (ld:v2i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_alignedload>> 25581 // Emits: (MOVAPSrm:v2i64 addr:iPTR:$src) 25582 // Pattern complexity = 22 cost = 1 size = 3 25583 if (Predicate_alignedload(N.getNode())) { 25584 SDValue N1 = N.getOperand(1); 25585 SDValue CPTmpN1_0; 25586 SDValue CPTmpN1_1; 25587 SDValue CPTmpN1_2; 25588 SDValue CPTmpN1_3; 25589 SDValue CPTmpN1_4; 25590 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25591 SDNode *Result = Emit_139(N, X86::MOVAPSrm, MVT::v2i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25592 return Result; 25593 } 25594 } 25595 25596 // Pattern: (ld:v2i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>> 25597 // Emits: (MOVUPSrm:v2i64 addr:iPTR:$src) 25598 // Pattern complexity = 22 cost = 1 size = 3 25599 SDValue N1 = N.getOperand(1); 25600 SDValue CPTmpN1_0; 25601 SDValue CPTmpN1_1; 25602 SDValue CPTmpN1_2; 25603 SDValue CPTmpN1_3; 25604 SDValue CPTmpN1_4; 25605 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25606 SDNode *Result = Emit_139(N, X86::MOVUPSrm, MVT::v2i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25607 return Result; 25608 } 25609 } 25610 } 25611 25612 CannotYetSelect(N); 25613 return NULL; 25614 } 25615 25616 SDNode *Select_ISD_LOAD_v4f32(const SDValue &N) { 25617 if ((Subtarget->hasSSE1())) { 25618 SDValue Chain = N.getOperand(0); 25619 if (Predicate_unindexedload(N.getNode()) && 25620 Predicate_load(N.getNode())) { 25621 25622 // Pattern: (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_alignedload>> 25623 // Emits: (MOVAPSrm:v4f32 addr:iPTR:$src) 25624 // Pattern complexity = 22 cost = 1 size = 3 25625 if (Predicate_alignedload(N.getNode())) { 25626 SDValue N1 = N.getOperand(1); 25627 SDValue CPTmpN1_0; 25628 SDValue CPTmpN1_1; 25629 SDValue CPTmpN1_2; 25630 SDValue CPTmpN1_3; 25631 SDValue CPTmpN1_4; 25632 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25633 SDNode *Result = Emit_139(N, X86::MOVAPSrm, MVT::v4f32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25634 return Result; 25635 } 25636 } 25637 25638 // Pattern: (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>> 25639 // Emits: (MOVUPSrm:v4f32 addr:iPTR:$src) 25640 // Pattern complexity = 22 cost = 1 size = 3 25641 SDValue N1 = N.getOperand(1); 25642 SDValue CPTmpN1_0; 25643 SDValue CPTmpN1_1; 25644 SDValue CPTmpN1_2; 25645 SDValue CPTmpN1_3; 25646 SDValue CPTmpN1_4; 25647 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25648 SDNode *Result = Emit_139(N, X86::MOVUPSrm, MVT::v4f32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25649 return Result; 25650 } 25651 } 25652 } 25653 25654 CannotYetSelect(N); 25655 return NULL; 25656 } 25657 25658 SDNode *Select_ISD_LOAD_v2f64(const SDValue &N) { 25659 if ((Subtarget->hasSSE2())) { 25660 SDValue Chain = N.getOperand(0); 25661 if (Predicate_unindexedload(N.getNode()) && 25662 Predicate_load(N.getNode())) { 25663 25664 // Pattern: (ld:v2f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_alignedload>> 25665 // Emits: (MOVAPDrm:v2f64 addr:iPTR:$src) 25666 // Pattern complexity = 22 cost = 1 size = 3 25667 if (Predicate_alignedload(N.getNode())) { 25668 SDValue N1 = N.getOperand(1); 25669 SDValue CPTmpN1_0; 25670 SDValue CPTmpN1_1; 25671 SDValue CPTmpN1_2; 25672 SDValue CPTmpN1_3; 25673 SDValue CPTmpN1_4; 25674 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25675 SDNode *Result = Emit_139(N, X86::MOVAPDrm, MVT::v2f64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25676 return Result; 25677 } 25678 } 25679 25680 // Pattern: (ld:v2f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>> 25681 // Emits: (MOVUPDrm:v2f64 addr:iPTR:$src) 25682 // Pattern complexity = 22 cost = 1 size = 3 25683 SDValue N1 = N.getOperand(1); 25684 SDValue CPTmpN1_0; 25685 SDValue CPTmpN1_1; 25686 SDValue CPTmpN1_2; 25687 SDValue CPTmpN1_3; 25688 SDValue CPTmpN1_4; 25689 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 25690 SDNode *Result = Emit_139(N, X86::MOVUPDrm, MVT::v2f64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 25691 return Result; 25692 } 25693 } 25694 } 25695 25696 CannotYetSelect(N); 25697 return NULL; 25698 } 25699 25700 SDNode *Emit_142(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 25701 SDValue Chain = N.getOperand(0); 25702 SDValue N1 = N.getOperand(1); 25703 SDValue N2 = N.getOperand(2); 25704 SDValue N3 = N.getOperand(3); 25705 SDValue N4 = N.getOperand(4); 25706 SDValue N5 = N.getOperand(5); 25707 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Chain); 25708 } 25709 SDNode *Select_ISD_MEMBARRIER(const SDValue &N) { 25710 SDValue Chain = N.getOperand(0); 25711 SDValue N1 = N.getOperand(1); 25712 { 25713 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 25714 if (Tmp0) { 25715 int64_t CN1 = Tmp0->getSExtValue(); 25716 25717 // Pattern: (membarrier:isVoid 0:i8, 0:i8, 0:i8, 1:i8, 1:i8) 25718 // Emits: (SFENCE:isVoid) 25719 // Pattern complexity = 28 cost = 1 size = 3 25720 if (CN1 == INT64_C(0)) { 25721 SDValue N2 = N.getOperand(2); 25722 ConstantSDNode *Tmp2 = dyn_cast<ConstantSDNode>(N2); 25723 if (Tmp2) { 25724 int64_t CN3 = Tmp2->getSExtValue(); 25725 if (CN3 == INT64_C(0)) { 25726 SDValue N3 = N.getOperand(3); 25727 ConstantSDNode *Tmp4 = dyn_cast<ConstantSDNode>(N3); 25728 if (Tmp4) { 25729 int64_t CN5 = Tmp4->getSExtValue(); 25730 if (CN5 == INT64_C(0)) { 25731 SDValue N4 = N.getOperand(4); 25732 ConstantSDNode *Tmp6 = dyn_cast<ConstantSDNode>(N4); 25733 if (Tmp6) { 25734 int64_t CN7 = Tmp6->getSExtValue(); 25735 if (CN7 == INT64_C(1)) { 25736 SDValue N5 = N.getOperand(5); 25737 ConstantSDNode *Tmp8 = dyn_cast<ConstantSDNode>(N5); 25738 if (Tmp8) { 25739 int64_t CN9 = Tmp8->getSExtValue(); 25740 if (CN9 == INT64_C(1) && 25741 N1.getNode()->getValueType(0) == MVT::i8) { 25742 SDNode *Result = Emit_142(N, X86::SFENCE); 25743 return Result; 25744 } 25745 } 25746 } 25747 } 25748 } 25749 } 25750 } 25751 } 25752 } 25753 25754 // Pattern: (membarrier:isVoid 1:i8, 0:i8, 0:i8, 0:i8, 1:i8) 25755 // Emits: (LFENCE:isVoid) 25756 // Pattern complexity = 28 cost = 1 size = 3 25757 if (CN1 == INT64_C(1)) { 25758 SDValue N2 = N.getOperand(2); 25759 ConstantSDNode *Tmp2 = dyn_cast<ConstantSDNode>(N2); 25760 if (Tmp2) { 25761 int64_t CN3 = Tmp2->getSExtValue(); 25762 if (CN3 == INT64_C(0)) { 25763 SDValue N3 = N.getOperand(3); 25764 ConstantSDNode *Tmp4 = dyn_cast<ConstantSDNode>(N3); 25765 if (Tmp4) { 25766 int64_t CN5 = Tmp4->getSExtValue(); 25767 if (CN5 == INT64_C(0)) { 25768 SDValue N4 = N.getOperand(4); 25769 ConstantSDNode *Tmp6 = dyn_cast<ConstantSDNode>(N4); 25770 if (Tmp6) { 25771 int64_t CN7 = Tmp6->getSExtValue(); 25772 if (CN7 == INT64_C(0)) { 25773 SDValue N5 = N.getOperand(5); 25774 ConstantSDNode *Tmp8 = dyn_cast<ConstantSDNode>(N5); 25775 if (Tmp8) { 25776 int64_t CN9 = Tmp8->getSExtValue(); 25777 if (CN9 == INT64_C(1) && 25778 N1.getNode()->getValueType(0) == MVT::i8) { 25779 SDNode *Result = Emit_142(N, X86::LFENCE); 25780 return Result; 25781 } 25782 } 25783 } 25784 } 25785 } 25786 } 25787 } 25788 } 25789 } 25790 } 25791 } 25792 if (N1.getOpcode() == ISD::Constant) { 25793 SDValue N2 = N.getOperand(2); 25794 if (N2.getOpcode() == ISD::Constant) { 25795 SDValue N3 = N.getOperand(3); 25796 if (N3.getOpcode() == ISD::Constant) { 25797 SDValue N4 = N.getOperand(4); 25798 if (N4.getOpcode() == ISD::Constant) { 25799 SDValue N5 = N.getOperand(5); 25800 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N5); 25801 if (Tmp0) { 25802 int64_t CN1 = Tmp0->getSExtValue(); 25803 25804 // Pattern: (membarrier:isVoid (imm:i8):$ll, (imm:i8):$ls, (imm:i8):$sl, (imm:i8):$ss, 0:i8) 25805 // Emits: (NOOP:isVoid) 25806 // Pattern complexity = 20 cost = 1 size = 3 25807 if (CN1 == INT64_C(0) && 25808 N1.getNode()->getValueType(0) == MVT::i8) { 25809 SDNode *Result = Emit_142(N, X86::NOOP); 25810 return Result; 25811 } 25812 25813 // Pattern: (membarrier:isVoid (imm:i8):$ll, (imm:i8):$ls, (imm:i8):$sl, (imm:i8):$ss, 1:i8) 25814 // Emits: (MFENCE:isVoid) 25815 // Pattern complexity = 20 cost = 1 size = 3 25816 if (CN1 == INT64_C(1) && 25817 N1.getNode()->getValueType(0) == MVT::i8) { 25818 SDNode *Result = Emit_142(N, X86::MFENCE); 25819 return Result; 25820 } 25821 } 25822 } 25823 } 25824 } 25825 } 25826 25827 CannotYetSelect(N); 25828 return NULL; 25829 } 25830 25831 SDNode *Emit_143(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 25832 SDValue N0 = N.getOperand(0); 25833 SDValue N1 = N.getOperand(1); 25834 SDValue Chain = CurDAG->getEntryNode(); 25835 SDValue InFlag(0, 0); 25836 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::AL, N0, InFlag).getNode(); 25837 Chain = SDValue(ResNode, 0); 25838 InFlag = SDValue(ResNode, 1); 25839 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i8, MVT::i32, N1, InFlag); 25840 } 25841 SDNode *Emit_144(const SDValue &N, unsigned Opc0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 25842 SDValue N0 = N.getOperand(0); 25843 SDValue N1 = N.getOperand(1); 25844 SDValue Chain1 = N1.getOperand(0); 25845 SDValue N11 = N1.getOperand(1); 25846 SDValue InFlag(0, 0); 25847 SDNode *ResNode = CurDAG->getCopyToReg(Chain1, N.getDebugLoc(), X86::AL, N0, InFlag).getNode(); 25848 Chain1 = SDValue(ResNode, 0); 25849 InFlag = SDValue(ResNode, 1); 25850 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 25851 SDValue Ops0[] = { CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1, InFlag }; 25852 ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i8, MVT::i32, MVT::Other, Ops0, 8); 25853 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 2)); 25854 return ResNode; 25855 } 25856 SDNode *Select_ISD_MUL_i8(const SDValue &N) { 25857 25858 // Pattern: (mul:i8 AL:i8, (ld:i8 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>) 25859 // Emits: (MUL8m:isVoid addr:iPTR:$src) 25860 // Pattern complexity = 25 cost = 1 size = 3 25861 if (OptLevel != CodeGenOpt::None) { 25862 SDValue N0 = N.getOperand(0); 25863 SDValue N1 = N.getOperand(1); 25864 if (N1.getOpcode() == ISD::LOAD && 25865 N1.hasOneUse() && 25866 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 25867 SDValue Chain1 = N1.getOperand(0); 25868 if (Predicate_unindexedload(N1.getNode()) && 25869 Predicate_load(N1.getNode()) && 25870 Predicate_loadi8(N1.getNode())) { 25871 SDValue N11 = N1.getOperand(1); 25872 SDValue CPTmpN11_0; 25873 SDValue CPTmpN11_1; 25874 SDValue CPTmpN11_2; 25875 SDValue CPTmpN11_3; 25876 SDValue CPTmpN11_4; 25877 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 25878 SDNode *Result = Emit_144(N, X86::MUL8m, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 25879 return Result; 25880 } 25881 } 25882 } 25883 } 25884 25885 // Pattern: (mul:i8 AL:i8, GR8:i8:$src) 25886 // Emits: (MUL8r:isVoid GR8:i8:$src) 25887 // Pattern complexity = 3 cost = 1 size = 3 25888 SDNode *Result = Emit_143(N, X86::MUL8r); 25889 return Result; 25890 } 25891 25892 SDNode *Emit_145(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 25893 SDValue N0 = N.getOperand(0); 25894 SDValue Chain0 = N0.getOperand(0); 25895 SDValue N01 = N0.getOperand(1); 25896 SDValue N1 = N.getOperand(1); 25897 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned short) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i16); 25898 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 25899 SDValue Ops0[] = { CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, Tmp1, LSI_N0, Chain0 }; 25900 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::i32, MVT::Other, Ops0, 8); 25901 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 2)); 25902 return ResNode; 25903 } 25904 SDNode *Select_ISD_MUL_i16(const SDValue &N) { 25905 if (OptLevel != CodeGenOpt::None) { 25906 SDValue N0 = N.getOperand(0); 25907 if (N0.getOpcode() == ISD::LOAD && 25908 N0.hasOneUse() && 25909 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 25910 SDValue Chain0 = N0.getOperand(0); 25911 if (Predicate_unindexedload(N0.getNode()) && 25912 Predicate_load(N0.getNode())) { 25913 SDValue N01 = N0.getOperand(1); 25914 SDValue CPTmpN01_0; 25915 SDValue CPTmpN01_1; 25916 SDValue CPTmpN01_2; 25917 SDValue CPTmpN01_3; 25918 SDValue CPTmpN01_4; 25919 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 25920 SDValue N1 = N.getOperand(1); 25921 if (N1.getOpcode() == ISD::Constant) { 25922 25923 // Pattern: (mul:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 25924 // Emits: (IMUL16rmi8:i16 addr:iPTR:$src1, (imm:i16):$src2) 25925 // Pattern complexity = 29 cost = 1 size = 3 25926 if (Predicate_i16immSExt8(N1.getNode())) { 25927 SDNode *Result = Emit_145(N, X86::IMUL16rmi8, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 25928 return Result; 25929 } 25930 25931 // Pattern: (mul:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i16):$src2) 25932 // Emits: (IMUL16rmi:i16 addr:iPTR:$src1, (imm:i16):$src2) 25933 // Pattern complexity = 28 cost = 1 size = 3 25934 SDNode *Result = Emit_145(N, X86::IMUL16rmi, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 25935 return Result; 25936 } 25937 } 25938 } 25939 } 25940 25941 // Pattern: (mul:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 25942 // Emits: (IMUL16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 25943 // Pattern complexity = 25 cost = 1 size = 3 25944 { 25945 SDValue N1 = N.getOperand(1); 25946 if (N1.getOpcode() == ISD::LOAD && 25947 N1.hasOneUse() && 25948 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 25949 SDValue Chain1 = N1.getOperand(0); 25950 if (Predicate_unindexedload(N1.getNode()) && 25951 Predicate_load(N1.getNode())) { 25952 SDValue N11 = N1.getOperand(1); 25953 SDValue CPTmpN11_0; 25954 SDValue CPTmpN11_1; 25955 SDValue CPTmpN11_2; 25956 SDValue CPTmpN11_3; 25957 SDValue CPTmpN11_4; 25958 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 25959 SDNode *Result = Emit_2(N, X86::IMUL16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 25960 return Result; 25961 } 25962 } 25963 } 25964 } 25965 25966 // Pattern: (mul:i16 (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR16:i16:$src1) 25967 // Emits: (IMUL16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 25968 // Pattern complexity = 25 cost = 1 size = 3 25969 if (N0.getOpcode() == ISD::LOAD && 25970 N0.hasOneUse() && 25971 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 25972 SDValue Chain0 = N0.getOperand(0); 25973 if (Predicate_unindexedload(N0.getNode()) && 25974 Predicate_load(N0.getNode())) { 25975 SDValue N01 = N0.getOperand(1); 25976 SDValue CPTmpN01_0; 25977 SDValue CPTmpN01_1; 25978 SDValue CPTmpN01_2; 25979 SDValue CPTmpN01_3; 25980 SDValue CPTmpN01_4; 25981 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 25982 SDNode *Result = Emit_4(N, X86::IMUL16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 25983 return Result; 25984 } 25985 } 25986 } 25987 } 25988 { 25989 SDValue N0 = N.getOperand(0); 25990 SDValue N1 = N.getOperand(1); 25991 if (N1.getOpcode() == ISD::Constant) { 25992 25993 // Pattern: (mul:i16 GR16:i16:$src1, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 25994 // Emits: (IMUL16rri8:i16 GR16:i16:$src1, (imm:i16):$src2) 25995 // Pattern complexity = 7 cost = 1 size = 3 25996 if (Predicate_i16immSExt8(N1.getNode())) { 25997 SDNode *Result = Emit_5(N, X86::IMUL16rri8, MVT::i16); 25998 return Result; 25999 } 26000 26001 // Pattern: (mul:i16 GR16:i16:$src1, (imm:i16):$src2) 26002 // Emits: (IMUL16rri:i16 GR16:i16:$src1, (imm:i16):$src2) 26003 // Pattern complexity = 6 cost = 1 size = 3 26004 SDNode *Result = Emit_5(N, X86::IMUL16rri, MVT::i16); 26005 return Result; 26006 } 26007 } 26008 26009 // Pattern: (mul:i16 GR16:i16:$src1, GR16:i16:$src2) 26010 // Emits: (IMUL16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 26011 // Pattern complexity = 3 cost = 1 size = 3 26012 SDNode *Result = Emit_1(N, X86::IMUL16rr, MVT::i16); 26013 return Result; 26014 } 26015 26016 SDNode *Emit_146(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 26017 SDValue N0 = N.getOperand(0); 26018 SDValue Chain0 = N0.getOperand(0); 26019 SDValue N01 = N0.getOperand(1); 26020 SDValue N1 = N.getOperand(1); 26021 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i32); 26022 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 26023 SDValue Ops0[] = { CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, Tmp1, LSI_N0, Chain0 }; 26024 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::i32, MVT::Other, Ops0, 8); 26025 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 2)); 26026 return ResNode; 26027 } 26028 SDNode *Select_ISD_MUL_i32(const SDValue &N) { 26029 if (OptLevel != CodeGenOpt::None) { 26030 SDValue N0 = N.getOperand(0); 26031 if (N0.getOpcode() == ISD::LOAD && 26032 N0.hasOneUse() && 26033 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 26034 SDValue Chain0 = N0.getOperand(0); 26035 if (Predicate_unindexedload(N0.getNode()) && 26036 Predicate_load(N0.getNode())) { 26037 SDValue N01 = N0.getOperand(1); 26038 SDValue CPTmpN01_0; 26039 SDValue CPTmpN01_1; 26040 SDValue CPTmpN01_2; 26041 SDValue CPTmpN01_3; 26042 SDValue CPTmpN01_4; 26043 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 26044 SDValue N1 = N.getOperand(1); 26045 if (N1.getOpcode() == ISD::Constant) { 26046 26047 // Pattern: (mul:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 26048 // Emits: (IMUL32rmi8:i32 addr:iPTR:$src1, (imm:i32):$src2) 26049 // Pattern complexity = 29 cost = 1 size = 3 26050 if (Predicate_i32immSExt8(N1.getNode())) { 26051 SDNode *Result = Emit_146(N, X86::IMUL32rmi8, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 26052 return Result; 26053 } 26054 26055 // Pattern: (mul:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i32):$src2) 26056 // Emits: (IMUL32rmi:i32 addr:iPTR:$src1, (imm:i32):$src2) 26057 // Pattern complexity = 28 cost = 1 size = 3 26058 SDNode *Result = Emit_146(N, X86::IMUL32rmi, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 26059 return Result; 26060 } 26061 } 26062 } 26063 } 26064 26065 // Pattern: (mul:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 26066 // Emits: (IMUL32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 26067 // Pattern complexity = 25 cost = 1 size = 3 26068 { 26069 SDValue N1 = N.getOperand(1); 26070 if (N1.getOpcode() == ISD::LOAD && 26071 N1.hasOneUse() && 26072 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 26073 SDValue Chain1 = N1.getOperand(0); 26074 if (Predicate_unindexedload(N1.getNode()) && 26075 Predicate_load(N1.getNode())) { 26076 SDValue N11 = N1.getOperand(1); 26077 SDValue CPTmpN11_0; 26078 SDValue CPTmpN11_1; 26079 SDValue CPTmpN11_2; 26080 SDValue CPTmpN11_3; 26081 SDValue CPTmpN11_4; 26082 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 26083 SDNode *Result = Emit_2(N, X86::IMUL32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 26084 return Result; 26085 } 26086 } 26087 } 26088 } 26089 26090 // Pattern: (mul:i32 (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR32:i32:$src1) 26091 // Emits: (IMUL32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 26092 // Pattern complexity = 25 cost = 1 size = 3 26093 if (N0.getOpcode() == ISD::LOAD && 26094 N0.hasOneUse() && 26095 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 26096 SDValue Chain0 = N0.getOperand(0); 26097 if (Predicate_unindexedload(N0.getNode()) && 26098 Predicate_load(N0.getNode())) { 26099 SDValue N01 = N0.getOperand(1); 26100 SDValue CPTmpN01_0; 26101 SDValue CPTmpN01_1; 26102 SDValue CPTmpN01_2; 26103 SDValue CPTmpN01_3; 26104 SDValue CPTmpN01_4; 26105 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 26106 SDNode *Result = Emit_4(N, X86::IMUL32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 26107 return Result; 26108 } 26109 } 26110 } 26111 } 26112 26113 // Pattern: lea32addr:i32:$src 26114 // Emits: (LEA64_32r:i32 lea32addr:i32:$src) 26115 // Pattern complexity = 15 cost = 1 size = 3 26116 if ((Subtarget->is64Bit())) { 26117 SDValue CPTmpN_0; 26118 SDValue CPTmpN_1; 26119 SDValue CPTmpN_2; 26120 SDValue CPTmpN_3; 26121 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 26122 SDNode *Result = Emit_7(N, X86::LEA64_32r, MVT::i32, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 26123 return Result; 26124 } 26125 } 26126 26127 // Pattern: lea32addr:i32:$src 26128 // Emits: (LEA32r:i32 lea32addr:i32:$src) 26129 // Pattern complexity = 15 cost = 1 size = 3 26130 if ((!Subtarget->is64Bit())) { 26131 SDValue CPTmpN_0; 26132 SDValue CPTmpN_1; 26133 SDValue CPTmpN_2; 26134 SDValue CPTmpN_3; 26135 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 26136 SDNode *Result = Emit_7(N, X86::LEA32r, MVT::i32, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 26137 return Result; 26138 } 26139 } 26140 { 26141 SDValue N0 = N.getOperand(0); 26142 SDValue N1 = N.getOperand(1); 26143 if (N1.getOpcode() == ISD::Constant) { 26144 26145 // Pattern: (mul:i32 GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 26146 // Emits: (IMUL32rri8:i32 GR32:i32:$src1, (imm:i32):$src2) 26147 // Pattern complexity = 7 cost = 1 size = 3 26148 if (Predicate_i32immSExt8(N1.getNode())) { 26149 SDNode *Result = Emit_8(N, X86::IMUL32rri8, MVT::i32); 26150 return Result; 26151 } 26152 26153 // Pattern: (mul:i32 GR32:i32:$src1, (imm:i32):$src2) 26154 // Emits: (IMUL32rri:i32 GR32:i32:$src1, (imm:i32):$src2) 26155 // Pattern complexity = 6 cost = 1 size = 3 26156 SDNode *Result = Emit_8(N, X86::IMUL32rri, MVT::i32); 26157 return Result; 26158 } 26159 } 26160 26161 // Pattern: (mul:i32 GR32:i32:$src1, GR32:i32:$src2) 26162 // Emits: (IMUL32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 26163 // Pattern complexity = 3 cost = 1 size = 3 26164 SDNode *Result = Emit_1(N, X86::IMUL32rr, MVT::i32); 26165 return Result; 26166 } 26167 26168 SDNode *Emit_147(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 26169 SDValue N0 = N.getOperand(0); 26170 SDValue Chain0 = N0.getOperand(0); 26171 SDValue N01 = N0.getOperand(1); 26172 SDValue N1 = N.getOperand(1); 26173 SDValue Tmp1 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i64); 26174 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 26175 SDValue Ops0[] = { CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, Tmp1, LSI_N0, Chain0 }; 26176 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::i32, MVT::Other, Ops0, 8); 26177 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 2)); 26178 return ResNode; 26179 } 26180 SDNode *Select_ISD_MUL_i64(const SDValue &N) { 26181 if (OptLevel != CodeGenOpt::None) { 26182 SDValue N0 = N.getOperand(0); 26183 if (N0.getOpcode() == ISD::LOAD && 26184 N0.hasOneUse() && 26185 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 26186 SDValue Chain0 = N0.getOperand(0); 26187 if (Predicate_unindexedload(N0.getNode()) && 26188 Predicate_load(N0.getNode())) { 26189 SDValue N01 = N0.getOperand(1); 26190 SDValue CPTmpN01_0; 26191 SDValue CPTmpN01_1; 26192 SDValue CPTmpN01_2; 26193 SDValue CPTmpN01_3; 26194 SDValue CPTmpN01_4; 26195 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 26196 SDValue N1 = N.getOperand(1); 26197 if (N1.getOpcode() == ISD::Constant) { 26198 26199 // Pattern: (mul:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 26200 // Emits: (IMUL64rmi8:i64 addr:iPTR:$src1, (imm:i64):$src2) 26201 // Pattern complexity = 29 cost = 1 size = 3 26202 if (Predicate_i64immSExt8(N1.getNode())) { 26203 SDNode *Result = Emit_147(N, X86::IMUL64rmi8, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 26204 return Result; 26205 } 26206 26207 // Pattern: (mul:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 26208 // Emits: (IMUL64rmi32:i64 addr:iPTR:$src1, (imm:i64):$src2) 26209 // Pattern complexity = 29 cost = 1 size = 3 26210 if (Predicate_i64immSExt32(N1.getNode())) { 26211 SDNode *Result = Emit_147(N, X86::IMUL64rmi32, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 26212 return Result; 26213 } 26214 } 26215 } 26216 } 26217 } 26218 26219 // Pattern: (mul:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 26220 // Emits: (IMUL64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 26221 // Pattern complexity = 25 cost = 1 size = 3 26222 { 26223 SDValue N1 = N.getOperand(1); 26224 if (N1.getOpcode() == ISD::LOAD && 26225 N1.hasOneUse() && 26226 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 26227 SDValue Chain1 = N1.getOperand(0); 26228 if (Predicate_unindexedload(N1.getNode()) && 26229 Predicate_load(N1.getNode())) { 26230 SDValue N11 = N1.getOperand(1); 26231 SDValue CPTmpN11_0; 26232 SDValue CPTmpN11_1; 26233 SDValue CPTmpN11_2; 26234 SDValue CPTmpN11_3; 26235 SDValue CPTmpN11_4; 26236 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 26237 SDNode *Result = Emit_2(N, X86::IMUL64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 26238 return Result; 26239 } 26240 } 26241 } 26242 } 26243 26244 // Pattern: (mul:i64 (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR64:i64:$src1) 26245 // Emits: (IMUL64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 26246 // Pattern complexity = 25 cost = 1 size = 3 26247 if (N0.getOpcode() == ISD::LOAD && 26248 N0.hasOneUse() && 26249 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 26250 SDValue Chain0 = N0.getOperand(0); 26251 if (Predicate_unindexedload(N0.getNode()) && 26252 Predicate_load(N0.getNode())) { 26253 SDValue N01 = N0.getOperand(1); 26254 SDValue CPTmpN01_0; 26255 SDValue CPTmpN01_1; 26256 SDValue CPTmpN01_2; 26257 SDValue CPTmpN01_3; 26258 SDValue CPTmpN01_4; 26259 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 26260 SDNode *Result = Emit_4(N, X86::IMUL64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 26261 return Result; 26262 } 26263 } 26264 } 26265 } 26266 26267 // Pattern: lea64addr:i64:$src 26268 // Emits: (LEA64r:i64 lea64addr:i64:$src) 26269 // Pattern complexity = 15 cost = 1 size = 3 26270 { 26271 SDValue CPTmpN_0; 26272 SDValue CPTmpN_1; 26273 SDValue CPTmpN_2; 26274 SDValue CPTmpN_3; 26275 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 26276 SDNode *Result = Emit_7(N, X86::LEA64r, MVT::i64, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 26277 return Result; 26278 } 26279 } 26280 { 26281 SDValue N0 = N.getOperand(0); 26282 SDValue N1 = N.getOperand(1); 26283 if (N1.getOpcode() == ISD::Constant) { 26284 26285 // Pattern: (mul:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 26286 // Emits: (IMUL64rri8:i64 GR64:i64:$src1, (imm:i64):$src2) 26287 // Pattern complexity = 7 cost = 1 size = 3 26288 if (Predicate_i64immSExt8(N1.getNode())) { 26289 SDNode *Result = Emit_12(N, X86::IMUL64rri8, MVT::i64); 26290 return Result; 26291 } 26292 26293 // Pattern: (mul:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 26294 // Emits: (IMUL64rri32:i64 GR64:i64:$src1, (imm:i64):$src2) 26295 // Pattern complexity = 7 cost = 1 size = 3 26296 if (Predicate_i64immSExt32(N1.getNode())) { 26297 SDNode *Result = Emit_12(N, X86::IMUL64rri32, MVT::i64); 26298 return Result; 26299 } 26300 } 26301 } 26302 26303 // Pattern: (mul:i64 GR64:i64:$src1, GR64:i64:$src2) 26304 // Emits: (IMUL64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 26305 // Pattern complexity = 3 cost = 1 size = 3 26306 SDNode *Result = Emit_1(N, X86::IMUL64rr, MVT::i64); 26307 return Result; 26308 } 26309 26310 SDNode *Select_ISD_MUL_v16i8(const SDValue &N) { 26311 if (OptLevel != CodeGenOpt::None && 26312 (Subtarget->hasSSE41())) { 26313 SDValue N0 = N.getOperand(0); 26314 26315 // Pattern: (mul:v16i8 VR128:v16i8:$src1, (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 26316 // Emits: (PMULLDrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 26317 // Pattern complexity = 25 cost = 1 size = 3 26318 { 26319 SDValue N1 = N.getOperand(1); 26320 if (N1.getOpcode() == ISD::LOAD && 26321 N1.hasOneUse() && 26322 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 26323 SDValue Chain1 = N1.getOperand(0); 26324 if (Predicate_unindexedload(N1.getNode()) && 26325 Predicate_load(N1.getNode()) && 26326 Predicate_memop(N1.getNode())) { 26327 SDValue N11 = N1.getOperand(1); 26328 SDValue CPTmpN11_0; 26329 SDValue CPTmpN11_1; 26330 SDValue CPTmpN11_2; 26331 SDValue CPTmpN11_3; 26332 SDValue CPTmpN11_4; 26333 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 26334 SDNode *Result = Emit_18(N, X86::PMULLDrm, MVT::v16i8, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 26335 return Result; 26336 } 26337 } 26338 } 26339 } 26340 26341 // Pattern: (mul:v16i8 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, VR128:v16i8:$src1) 26342 // Emits: (PMULLDrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 26343 // Pattern complexity = 25 cost = 1 size = 3 26344 if (N0.getOpcode() == ISD::LOAD && 26345 N0.hasOneUse() && 26346 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 26347 SDValue Chain0 = N0.getOperand(0); 26348 if (Predicate_unindexedload(N0.getNode()) && 26349 Predicate_load(N0.getNode()) && 26350 Predicate_memop(N0.getNode())) { 26351 SDValue N01 = N0.getOperand(1); 26352 SDValue CPTmpN01_0; 26353 SDValue CPTmpN01_1; 26354 SDValue CPTmpN01_2; 26355 SDValue CPTmpN01_3; 26356 SDValue CPTmpN01_4; 26357 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 26358 SDNode *Result = Emit_19(N, X86::PMULLDrm, MVT::v16i8, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 26359 return Result; 26360 } 26361 } 26362 } 26363 } 26364 26365 CannotYetSelect(N); 26366 return NULL; 26367 } 26368 26369 SDNode *Select_ISD_MUL_v4i16(const SDValue &N) { 26370 if (OptLevel != CodeGenOpt::None && 26371 (Subtarget->hasMMX())) { 26372 SDValue N0 = N.getOperand(0); 26373 26374 // Pattern: (mul:v4i16 VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 26375 // Emits: (MMX_PMULLWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 26376 // Pattern complexity = 28 cost = 1 size = 3 26377 { 26378 SDValue N1 = N.getOperand(1); 26379 if (N1.getOpcode() == ISD::BIT_CONVERT && 26380 N1.hasOneUse()) { 26381 SDValue N10 = N1.getOperand(0); 26382 if (N10.getOpcode() == ISD::LOAD && 26383 N10.hasOneUse() && 26384 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 26385 SDValue Chain10 = N10.getOperand(0); 26386 if (Predicate_unindexedload(N10.getNode()) && 26387 Predicate_load(N10.getNode())) { 26388 SDValue N101 = N10.getOperand(1); 26389 SDValue CPTmpN101_0; 26390 SDValue CPTmpN101_1; 26391 SDValue CPTmpN101_2; 26392 SDValue CPTmpN101_3; 26393 SDValue CPTmpN101_4; 26394 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 26395 N10.getNode()->getValueType(0) == MVT::v1i64) { 26396 SDNode *Result = Emit_16(N, X86::MMX_PMULLWrm, MVT::v4i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 26397 return Result; 26398 } 26399 } 26400 } 26401 } 26402 } 26403 26404 // Pattern: (mul:v4i16 (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v4i16:$src1) 26405 // Emits: (MMX_PMULLWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 26406 // Pattern complexity = 28 cost = 1 size = 3 26407 if (N0.getOpcode() == ISD::BIT_CONVERT && 26408 N0.hasOneUse()) { 26409 SDValue N00 = N0.getOperand(0); 26410 if (N00.getOpcode() == ISD::LOAD && 26411 N00.hasOneUse() && 26412 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 26413 SDValue Chain00 = N00.getOperand(0); 26414 if (Predicate_unindexedload(N00.getNode()) && 26415 Predicate_load(N00.getNode())) { 26416 SDValue N001 = N00.getOperand(1); 26417 SDValue CPTmpN001_0; 26418 SDValue CPTmpN001_1; 26419 SDValue CPTmpN001_2; 26420 SDValue CPTmpN001_3; 26421 SDValue CPTmpN001_4; 26422 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 26423 SDValue N1 = N.getOperand(1); 26424 if (N00.getNode()->getValueType(0) == MVT::v1i64) { 26425 SDNode *Result = Emit_17(N, X86::MMX_PMULLWrm, MVT::v4i16, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 26426 return Result; 26427 } 26428 } 26429 } 26430 } 26431 } 26432 } 26433 26434 // Pattern: (mul:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 26435 // Emits: (MMX_PMULLWrr:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 26436 // Pattern complexity = 3 cost = 1 size = 3 26437 if ((Subtarget->hasMMX())) { 26438 SDNode *Result = Emit_15(N, X86::MMX_PMULLWrr, MVT::v4i16); 26439 return Result; 26440 } 26441 26442 CannotYetSelect(N); 26443 return NULL; 26444 } 26445 26446 SDNode *Select_ISD_MUL_v8i16(const SDValue &N) { 26447 if (OptLevel != CodeGenOpt::None && 26448 (Subtarget->hasSSE2())) { 26449 SDValue N0 = N.getOperand(0); 26450 26451 // Pattern: (mul:v8i16 VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 26452 // Emits: (PMULLWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 26453 // Pattern complexity = 28 cost = 1 size = 3 26454 { 26455 SDValue N1 = N.getOperand(1); 26456 if (N1.getOpcode() == ISD::BIT_CONVERT && 26457 N1.hasOneUse()) { 26458 SDValue N10 = N1.getOperand(0); 26459 if (N10.getOpcode() == ISD::LOAD && 26460 N10.hasOneUse() && 26461 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 26462 SDValue Chain10 = N10.getOperand(0); 26463 if (Predicate_unindexedload(N10.getNode()) && 26464 Predicate_load(N10.getNode()) && 26465 Predicate_memop(N10.getNode())) { 26466 SDValue N101 = N10.getOperand(1); 26467 SDValue CPTmpN101_0; 26468 SDValue CPTmpN101_1; 26469 SDValue CPTmpN101_2; 26470 SDValue CPTmpN101_3; 26471 SDValue CPTmpN101_4; 26472 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 26473 N10.getNode()->getValueType(0) == MVT::v2i64) { 26474 SDNode *Result = Emit_16(N, X86::PMULLWrm, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 26475 return Result; 26476 } 26477 } 26478 } 26479 } 26480 } 26481 26482 // Pattern: (mul:v8i16 (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), VR128:v8i16:$src1) 26483 // Emits: (PMULLWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 26484 // Pattern complexity = 28 cost = 1 size = 3 26485 if (N0.getOpcode() == ISD::BIT_CONVERT && 26486 N0.hasOneUse()) { 26487 SDValue N00 = N0.getOperand(0); 26488 if (N00.getOpcode() == ISD::LOAD && 26489 N00.hasOneUse() && 26490 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 26491 SDValue Chain00 = N00.getOperand(0); 26492 if (Predicate_unindexedload(N00.getNode()) && 26493 Predicate_load(N00.getNode()) && 26494 Predicate_memop(N00.getNode())) { 26495 SDValue N001 = N00.getOperand(1); 26496 SDValue CPTmpN001_0; 26497 SDValue CPTmpN001_1; 26498 SDValue CPTmpN001_2; 26499 SDValue CPTmpN001_3; 26500 SDValue CPTmpN001_4; 26501 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 26502 SDValue N1 = N.getOperand(1); 26503 if (N00.getNode()->getValueType(0) == MVT::v2i64) { 26504 SDNode *Result = Emit_17(N, X86::PMULLWrm, MVT::v8i16, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 26505 return Result; 26506 } 26507 } 26508 } 26509 } 26510 } 26511 } 26512 26513 // Pattern: (mul:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 26514 // Emits: (PMULLWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 26515 // Pattern complexity = 3 cost = 1 size = 3 26516 if ((Subtarget->hasSSE2())) { 26517 SDNode *Result = Emit_15(N, X86::PMULLWrr, MVT::v8i16); 26518 return Result; 26519 } 26520 26521 CannotYetSelect(N); 26522 return NULL; 26523 } 26524 26525 SDNode *Select_ISD_MUL_v4i32(const SDValue &N) { 26526 if ((Subtarget->hasSSE41())) { 26527 SDNode *Result = Emit_15(N, X86::PMULLDrr, MVT::v4i32); 26528 return Result; 26529 } 26530 26531 CannotYetSelect(N); 26532 return NULL; 26533 } 26534 26535 SDNode *Select_ISD_OR_i8(const SDValue &N) { 26536 if (OptLevel != CodeGenOpt::None) { 26537 SDValue N0 = N.getOperand(0); 26538 26539 // Pattern: (or:i8 GR8:i8:$src1, (ld:i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 26540 // Emits: (OR8rm:i8 GR8:i8:$src1, addr:iPTR:$src2) 26541 // Pattern complexity = 25 cost = 1 size = 3 26542 { 26543 SDValue N1 = N.getOperand(1); 26544 if (N1.getOpcode() == ISD::LOAD && 26545 N1.hasOneUse() && 26546 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 26547 SDValue Chain1 = N1.getOperand(0); 26548 if (Predicate_unindexedload(N1.getNode()) && 26549 Predicate_load(N1.getNode())) { 26550 SDValue N11 = N1.getOperand(1); 26551 SDValue CPTmpN11_0; 26552 SDValue CPTmpN11_1; 26553 SDValue CPTmpN11_2; 26554 SDValue CPTmpN11_3; 26555 SDValue CPTmpN11_4; 26556 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 26557 SDNode *Result = Emit_2(N, X86::OR8rm, MVT::i8, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 26558 return Result; 26559 } 26560 } 26561 } 26562 } 26563 26564 // Pattern: (or:i8 (ld:i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR8:i8:$src1) 26565 // Emits: (OR8rm:i8 GR8:i8:$src1, addr:iPTR:$src2) 26566 // Pattern complexity = 25 cost = 1 size = 3 26567 if (N0.getOpcode() == ISD::LOAD && 26568 N0.hasOneUse() && 26569 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 26570 SDValue Chain0 = N0.getOperand(0); 26571 if (Predicate_unindexedload(N0.getNode()) && 26572 Predicate_load(N0.getNode())) { 26573 SDValue N01 = N0.getOperand(1); 26574 SDValue CPTmpN01_0; 26575 SDValue CPTmpN01_1; 26576 SDValue CPTmpN01_2; 26577 SDValue CPTmpN01_3; 26578 SDValue CPTmpN01_4; 26579 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 26580 SDNode *Result = Emit_4(N, X86::OR8rm, MVT::i8, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 26581 return Result; 26582 } 26583 } 26584 } 26585 } 26586 26587 // Pattern: (or:i8 GR8:i8:$src1, (imm:i8):$src2) 26588 // Emits: (OR8ri:i8 GR8:i8:$src1, (imm:i8):$src2) 26589 // Pattern complexity = 6 cost = 1 size = 3 26590 { 26591 SDValue N0 = N.getOperand(0); 26592 SDValue N1 = N.getOperand(1); 26593 if (N1.getOpcode() == ISD::Constant) { 26594 SDNode *Result = Emit_3(N, X86::OR8ri, MVT::i8); 26595 return Result; 26596 } 26597 } 26598 26599 // Pattern: (or:i8 GR8:i8:$src1, GR8:i8:$src2) 26600 // Emits: (OR8rr:i8 GR8:i8:$src1, GR8:i8:$src2) 26601 // Pattern complexity = 3 cost = 1 size = 3 26602 SDNode *Result = Emit_1(N, X86::OR8rr, MVT::i8); 26603 return Result; 26604 } 26605 26606 SDNode *Emit_148(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 26607 SDValue N0 = N.getOperand(0); 26608 SDValue N00 = N0.getOperand(0); 26609 SDValue N01 = N0.getOperand(1); 26610 SDValue N1 = N.getOperand(1); 26611 SDValue N10 = N1.getOperand(0); 26612 SDValue N11 = N1.getOperand(1); 26613 SDValue N110 = N11.getOperand(0); 26614 SDValue N111 = N11.getOperand(1); 26615 SDValue Chain = CurDAG->getEntryNode(); 26616 SDValue InFlag(0, 0); 26617 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N0.getDebugLoc(), X86::CL, N01, InFlag).getNode(); 26618 Chain = SDValue(ResNode, 0); 26619 InFlag = SDValue(ResNode, 1); 26620 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N00, N10, InFlag); 26621 } 26622 SDNode *Emit_149(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 26623 SDValue N0 = N.getOperand(0); 26624 SDValue N00 = N0.getOperand(0); 26625 SDValue N01 = N0.getOperand(1); 26626 SDValue N010 = N01.getOperand(0); 26627 SDValue N1 = N.getOperand(1); 26628 SDValue N10 = N1.getOperand(0); 26629 SDValue N11 = N1.getOperand(1); 26630 SDValue N110 = N11.getOperand(0); 26631 SDValue N1100 = N110.getOperand(0); 26632 SDValue N1101 = N110.getOperand(1); 26633 SDValue Chain = CurDAG->getEntryNode(); 26634 SDValue InFlag(0, 0); 26635 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N01.getDebugLoc(), X86::CX, N010, InFlag).getNode(); 26636 Chain = SDValue(ResNode, 0); 26637 InFlag = SDValue(ResNode, 1); 26638 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N00, N10, InFlag); 26639 } 26640 SDNode *Emit_150(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 26641 SDValue N0 = N.getOperand(0); 26642 SDValue N00 = N0.getOperand(0); 26643 SDValue N01 = N0.getOperand(1); 26644 SDValue N1 = N.getOperand(1); 26645 SDValue N10 = N1.getOperand(0); 26646 SDValue N11 = N1.getOperand(1); 26647 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N01)->getZExtValue()), MVT::i8); 26648 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N00, N10, Tmp2); 26649 } 26650 SDNode *Emit_151(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 26651 SDValue N0 = N.getOperand(0); 26652 SDValue N00 = N0.getOperand(0); 26653 SDValue N01 = N0.getOperand(1); 26654 SDValue N010 = N01.getOperand(0); 26655 SDValue N011 = N01.getOperand(1); 26656 SDValue N1 = N.getOperand(1); 26657 SDValue N10 = N1.getOperand(0); 26658 SDValue N11 = N1.getOperand(1); 26659 SDValue Chain = CurDAG->getEntryNode(); 26660 SDValue InFlag(0, 0); 26661 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N01.getDebugLoc(), X86::CL, N011, InFlag).getNode(); 26662 Chain = SDValue(ResNode, 0); 26663 InFlag = SDValue(ResNode, 1); 26664 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N10, N00, InFlag); 26665 } 26666 SDNode *Emit_152(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 26667 SDValue N0 = N.getOperand(0); 26668 SDValue N00 = N0.getOperand(0); 26669 SDValue N01 = N0.getOperand(1); 26670 SDValue N010 = N01.getOperand(0); 26671 SDValue N0100 = N010.getOperand(0); 26672 SDValue N0101 = N010.getOperand(1); 26673 SDValue N1 = N.getOperand(1); 26674 SDValue N10 = N1.getOperand(0); 26675 SDValue N11 = N1.getOperand(1); 26676 SDValue N110 = N11.getOperand(0); 26677 SDValue Chain = CurDAG->getEntryNode(); 26678 SDValue InFlag(0, 0); 26679 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N010.getDebugLoc(), X86::CX, N0101, InFlag).getNode(); 26680 Chain = SDValue(ResNode, 0); 26681 InFlag = SDValue(ResNode, 1); 26682 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N10, N00, InFlag); 26683 } 26684 SDNode *Emit_153(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 26685 SDValue N0 = N.getOperand(0); 26686 SDValue N00 = N0.getOperand(0); 26687 SDValue N01 = N0.getOperand(1); 26688 SDValue N1 = N.getOperand(1); 26689 SDValue N10 = N1.getOperand(0); 26690 SDValue N11 = N1.getOperand(1); 26691 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N11)->getZExtValue()), MVT::i8); 26692 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N10, N00, Tmp2); 26693 } 26694 SDNode *Select_ISD_OR_i16(const SDValue &N) { 26695 if (OptLevel != CodeGenOpt::None) { 26696 SDValue N0 = N.getOperand(0); 26697 26698 // Pattern: (or:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 26699 // Emits: (OR16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 26700 // Pattern complexity = 25 cost = 1 size = 3 26701 { 26702 SDValue N1 = N.getOperand(1); 26703 if (N1.getOpcode() == ISD::LOAD && 26704 N1.hasOneUse() && 26705 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 26706 SDValue Chain1 = N1.getOperand(0); 26707 if (Predicate_unindexedload(N1.getNode()) && 26708 Predicate_load(N1.getNode())) { 26709 SDValue N11 = N1.getOperand(1); 26710 SDValue CPTmpN11_0; 26711 SDValue CPTmpN11_1; 26712 SDValue CPTmpN11_2; 26713 SDValue CPTmpN11_3; 26714 SDValue CPTmpN11_4; 26715 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 26716 SDNode *Result = Emit_2(N, X86::OR16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 26717 return Result; 26718 } 26719 } 26720 } 26721 } 26722 26723 // Pattern: (or:i16 (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR16:i16:$src1) 26724 // Emits: (OR16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 26725 // Pattern complexity = 25 cost = 1 size = 3 26726 if (N0.getOpcode() == ISD::LOAD && 26727 N0.hasOneUse() && 26728 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 26729 SDValue Chain0 = N0.getOperand(0); 26730 if (Predicate_unindexedload(N0.getNode()) && 26731 Predicate_load(N0.getNode())) { 26732 SDValue N01 = N0.getOperand(1); 26733 SDValue CPTmpN01_0; 26734 SDValue CPTmpN01_1; 26735 SDValue CPTmpN01_2; 26736 SDValue CPTmpN01_3; 26737 SDValue CPTmpN01_4; 26738 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 26739 SDNode *Result = Emit_4(N, X86::OR16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 26740 return Result; 26741 } 26742 } 26743 } 26744 } 26745 { 26746 SDValue N0 = N.getOperand(0); 26747 26748 // Pattern: (or:i16 (srl:i16 GR16:i16:$src1, (trunc:i8 CX:i16:$amt)), (shl:i16 GR16:i16:$src2, (trunc:i8 (sub:i16 16:i16, CX:i16:$amt)))) 26749 // Emits: (SHRD16rrCL:i16 GR16:i16:$src1, GR16:i16:$src2) 26750 // Pattern complexity = 23 cost = 1 size = 3 26751 if (N0.getOpcode() == ISD::SRL) { 26752 SDValue N00 = N0.getOperand(0); 26753 SDValue N01 = N0.getOperand(1); 26754 if (N01.getOpcode() == ISD::TRUNCATE) { 26755 SDValue N010 = N01.getOperand(0); 26756 SDValue N1 = N.getOperand(1); 26757 if (N1.getOpcode() == ISD::SHL) { 26758 SDValue N10 = N1.getOperand(0); 26759 SDValue N11 = N1.getOperand(1); 26760 if (N11.getOpcode() == ISD::TRUNCATE) { 26761 SDValue N110 = N11.getOperand(0); 26762 if (N110.getOpcode() == ISD::SUB) { 26763 SDValue N1100 = N110.getOperand(0); 26764 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1100); 26765 if (Tmp0) { 26766 int64_t CN1 = Tmp0->getSExtValue(); 26767 if (CN1 == INT64_C(16)) { 26768 SDValue N1101 = N110.getOperand(1); 26769 if (N010 == N1101 && 26770 N01.getNode()->getValueType(0) == MVT::i8 && 26771 N010.getNode()->getValueType(0) == MVT::i16 && 26772 N11.getNode()->getValueType(0) == MVT::i8 && 26773 N110.getNode()->getValueType(0) == MVT::i16) { 26774 SDNode *Result = Emit_149(N, X86::SHRD16rrCL, MVT::i16); 26775 return Result; 26776 } 26777 } 26778 } 26779 } 26780 } 26781 } 26782 } 26783 } 26784 if (N0.getOpcode() == ISD::SHL) { 26785 SDValue N00 = N0.getOperand(0); 26786 SDValue N01 = N0.getOperand(1); 26787 if (N01.getOpcode() == ISD::TRUNCATE) { 26788 SDValue N010 = N01.getOperand(0); 26789 26790 // Pattern: (or:i16 (shl:i16 GR16:i16:$src1, (trunc:i8 CX:i16:$amt)), (srl:i16 GR16:i16:$src2, (trunc:i8 (sub:i16 16:i16, CX:i16:$amt)))) 26791 // Emits: (SHLD16rrCL:i16 GR16:i16:$src1, GR16:i16:$src2) 26792 // Pattern complexity = 23 cost = 1 size = 3 26793 { 26794 SDValue N1 = N.getOperand(1); 26795 if (N1.getOpcode() == ISD::SRL) { 26796 SDValue N10 = N1.getOperand(0); 26797 SDValue N11 = N1.getOperand(1); 26798 if (N11.getOpcode() == ISD::TRUNCATE) { 26799 SDValue N110 = N11.getOperand(0); 26800 if (N110.getOpcode() == ISD::SUB) { 26801 SDValue N1100 = N110.getOperand(0); 26802 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1100); 26803 if (Tmp0) { 26804 int64_t CN1 = Tmp0->getSExtValue(); 26805 if (CN1 == INT64_C(16)) { 26806 SDValue N1101 = N110.getOperand(1); 26807 if (N010 == N1101 && 26808 N01.getNode()->getValueType(0) == MVT::i8 && 26809 N010.getNode()->getValueType(0) == MVT::i16 && 26810 N11.getNode()->getValueType(0) == MVT::i8 && 26811 N110.getNode()->getValueType(0) == MVT::i16) { 26812 SDNode *Result = Emit_149(N, X86::SHLD16rrCL, MVT::i16); 26813 return Result; 26814 } 26815 } 26816 } 26817 } 26818 } 26819 } 26820 } 26821 26822 // Pattern: (or:i16 (shl:i16 GR16:i16:$src2, (trunc:i8 (sub:i16 16:i16, CX:i16:$amt))), (srl:i16 GR16:i16:$src1, (trunc:i8 CX:i16:$amt))) 26823 // Emits: (SHRD16rrCL:i16 GR16:i16:$src1, GR16:i16:$src2) 26824 // Pattern complexity = 23 cost = 1 size = 3 26825 if (N010.getOpcode() == ISD::SUB) { 26826 SDValue N0100 = N010.getOperand(0); 26827 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0100); 26828 if (Tmp0) { 26829 int64_t CN1 = Tmp0->getSExtValue(); 26830 if (CN1 == INT64_C(16)) { 26831 SDValue N0101 = N010.getOperand(1); 26832 SDValue N1 = N.getOperand(1); 26833 if (N1.getOpcode() == ISD::SRL) { 26834 SDValue N10 = N1.getOperand(0); 26835 SDValue N11 = N1.getOperand(1); 26836 if (N11.getOpcode() == ISD::TRUNCATE) { 26837 SDValue N110 = N11.getOperand(0); 26838 if (N0101 == N110 && 26839 N01.getNode()->getValueType(0) == MVT::i8 && 26840 N010.getNode()->getValueType(0) == MVT::i16 && 26841 N11.getNode()->getValueType(0) == MVT::i8 && 26842 N110.getNode()->getValueType(0) == MVT::i16) { 26843 SDNode *Result = Emit_152(N, X86::SHRD16rrCL, MVT::i16); 26844 return Result; 26845 } 26846 } 26847 } 26848 } 26849 } 26850 } 26851 } 26852 } 26853 if (N0.getOpcode() == ISD::SRL) { 26854 SDValue N00 = N0.getOperand(0); 26855 SDValue N01 = N0.getOperand(1); 26856 26857 // Pattern: (or:i16 (srl:i16 GR16:i16:$src2, (trunc:i8 (sub:i16 16:i16, CX:i16:$amt))), (shl:i16 GR16:i16:$src1, (trunc:i8 CX:i16:$amt))) 26858 // Emits: (SHLD16rrCL:i16 GR16:i16:$src1, GR16:i16:$src2) 26859 // Pattern complexity = 23 cost = 1 size = 3 26860 if (N01.getOpcode() == ISD::TRUNCATE) { 26861 SDValue N010 = N01.getOperand(0); 26862 if (N010.getOpcode() == ISD::SUB) { 26863 SDValue N0100 = N010.getOperand(0); 26864 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0100); 26865 if (Tmp0) { 26866 int64_t CN1 = Tmp0->getSExtValue(); 26867 if (CN1 == INT64_C(16)) { 26868 SDValue N0101 = N010.getOperand(1); 26869 SDValue N1 = N.getOperand(1); 26870 if (N1.getOpcode() == ISD::SHL) { 26871 SDValue N10 = N1.getOperand(0); 26872 SDValue N11 = N1.getOperand(1); 26873 if (N11.getOpcode() == ISD::TRUNCATE) { 26874 SDValue N110 = N11.getOperand(0); 26875 if (N0101 == N110 && 26876 N01.getNode()->getValueType(0) == MVT::i8 && 26877 N010.getNode()->getValueType(0) == MVT::i16 && 26878 N11.getNode()->getValueType(0) == MVT::i8 && 26879 N110.getNode()->getValueType(0) == MVT::i16) { 26880 SDNode *Result = Emit_152(N, X86::SHLD16rrCL, MVT::i16); 26881 return Result; 26882 } 26883 } 26884 } 26885 } 26886 } 26887 } 26888 } 26889 26890 // Pattern: (or:i16 (srl:i16 GR16:i16:$src1, CL:i8:$amt), (shl:i16 GR16:i16:$src2, (sub:i8 16:i8, CL:i8:$amt))) 26891 // Emits: (SHRD16rrCL:i16 GR16:i16:$src1, GR16:i16:$src2) 26892 // Pattern complexity = 17 cost = 1 size = 3 26893 SDValue N1 = N.getOperand(1); 26894 if (N1.getOpcode() == ISD::SHL) { 26895 SDValue N10 = N1.getOperand(0); 26896 SDValue N11 = N1.getOperand(1); 26897 if (N11.getOpcode() == ISD::SUB) { 26898 SDValue N110 = N11.getOperand(0); 26899 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N110); 26900 if (Tmp0) { 26901 int64_t CN1 = Tmp0->getSExtValue(); 26902 if (CN1 == INT64_C(16)) { 26903 SDValue N111 = N11.getOperand(1); 26904 if (N01 == N111 && 26905 N01.getNode()->getValueType(0) == MVT::i8 && 26906 N11.getNode()->getValueType(0) == MVT::i8) { 26907 SDNode *Result = Emit_148(N, X86::SHRD16rrCL, MVT::i16); 26908 return Result; 26909 } 26910 } 26911 } 26912 } 26913 } 26914 } 26915 if (N0.getOpcode() == ISD::SHL) { 26916 SDValue N00 = N0.getOperand(0); 26917 SDValue N01 = N0.getOperand(1); 26918 26919 // Pattern: (or:i16 (shl:i16 GR16:i16:$src1, CL:i8:$amt), (srl:i16 GR16:i16:$src2, (sub:i8 16:i8, CL:i8:$amt))) 26920 // Emits: (SHLD16rrCL:i16 GR16:i16:$src1, GR16:i16:$src2) 26921 // Pattern complexity = 17 cost = 1 size = 3 26922 { 26923 SDValue N1 = N.getOperand(1); 26924 if (N1.getOpcode() == ISD::SRL) { 26925 SDValue N10 = N1.getOperand(0); 26926 SDValue N11 = N1.getOperand(1); 26927 if (N11.getOpcode() == ISD::SUB) { 26928 SDValue N110 = N11.getOperand(0); 26929 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N110); 26930 if (Tmp0) { 26931 int64_t CN1 = Tmp0->getSExtValue(); 26932 if (CN1 == INT64_C(16)) { 26933 SDValue N111 = N11.getOperand(1); 26934 if (N01 == N111 && 26935 N01.getNode()->getValueType(0) == MVT::i8 && 26936 N11.getNode()->getValueType(0) == MVT::i8) { 26937 SDNode *Result = Emit_148(N, X86::SHLD16rrCL, MVT::i16); 26938 return Result; 26939 } 26940 } 26941 } 26942 } 26943 } 26944 } 26945 26946 // Pattern: (or:i16 (shl:i16 GR16:i16:$src2, (sub:i8 16:i8, CL:i8:$amt)), (srl:i16 GR16:i16:$src1, CL:i8:$amt)) 26947 // Emits: (SHRD16rrCL:i16 GR16:i16:$src1, GR16:i16:$src2) 26948 // Pattern complexity = 17 cost = 1 size = 3 26949 if (N01.getOpcode() == ISD::SUB) { 26950 SDValue N010 = N01.getOperand(0); 26951 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N010); 26952 if (Tmp0) { 26953 int64_t CN1 = Tmp0->getSExtValue(); 26954 if (CN1 == INT64_C(16)) { 26955 SDValue N011 = N01.getOperand(1); 26956 SDValue N1 = N.getOperand(1); 26957 if (N1.getOpcode() == ISD::SRL) { 26958 SDValue N10 = N1.getOperand(0); 26959 SDValue N11 = N1.getOperand(1); 26960 if (N011 == N11 && 26961 N01.getNode()->getValueType(0) == MVT::i8 && 26962 N11.getNode()->getValueType(0) == MVT::i8) { 26963 SDNode *Result = Emit_151(N, X86::SHRD16rrCL, MVT::i16); 26964 return Result; 26965 } 26966 } 26967 } 26968 } 26969 } 26970 } 26971 26972 // Pattern: (or:i16 (srl:i16 GR16:i16:$src2, (sub:i8 16:i8, CL:i8:$amt)), (shl:i16 GR16:i16:$src1, CL:i8:$amt)) 26973 // Emits: (SHLD16rrCL:i16 GR16:i16:$src1, GR16:i16:$src2) 26974 // Pattern complexity = 17 cost = 1 size = 3 26975 if (N0.getOpcode() == ISD::SRL) { 26976 SDValue N00 = N0.getOperand(0); 26977 SDValue N01 = N0.getOperand(1); 26978 if (N01.getOpcode() == ISD::SUB) { 26979 SDValue N010 = N01.getOperand(0); 26980 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N010); 26981 if (Tmp0) { 26982 int64_t CN1 = Tmp0->getSExtValue(); 26983 if (CN1 == INT64_C(16)) { 26984 SDValue N011 = N01.getOperand(1); 26985 SDValue N1 = N.getOperand(1); 26986 if (N1.getOpcode() == ISD::SHL) { 26987 SDValue N10 = N1.getOperand(0); 26988 SDValue N11 = N1.getOperand(1); 26989 if (N011 == N11 && 26990 N01.getNode()->getValueType(0) == MVT::i8 && 26991 N11.getNode()->getValueType(0) == MVT::i8) { 26992 SDNode *Result = Emit_151(N, X86::SHLD16rrCL, MVT::i16); 26993 return Result; 26994 } 26995 } 26996 } 26997 } 26998 } 26999 } 27000 } 27001 27002 // Pattern: (or:i16 (srl:i16 GR16:i16:$src1, (imm:i8):$amt1), (shl:i16 GR16:i16:$src2, (imm:i8):$amt2))<<P:Predicate_shrd>> 27003 // Emits: (SHRD16rri8:i16 GR16:i16:$src1, GR16:i16:$src2, (imm:i8):$amt1) 27004 // Pattern complexity = 16 cost = 1 size = 3 27005 if (Predicate_shrd(N.getNode())) { 27006 SDValue N0 = N.getOperand(0); 27007 if (N0.getOpcode() == ISD::SRL) { 27008 SDValue N00 = N0.getOperand(0); 27009 SDValue N01 = N0.getOperand(1); 27010 if (N01.getOpcode() == ISD::Constant) { 27011 SDValue N1 = N.getOperand(1); 27012 if (N1.getOpcode() == ISD::SHL) { 27013 SDValue N10 = N1.getOperand(0); 27014 SDValue N11 = N1.getOperand(1); 27015 if (N11.getOpcode() == ISD::Constant && 27016 N01.getNode()->getValueType(0) == MVT::i8 && 27017 N11.getNode()->getValueType(0) == MVT::i8) { 27018 SDNode *Result = Emit_150(N, X86::SHRD16rri8, MVT::i16); 27019 return Result; 27020 } 27021 } 27022 } 27023 } 27024 } 27025 27026 // Pattern: (or:i16 (shl:i16 GR16:i16:$src1, (imm:i8):$amt1), (srl:i16 GR16:i16:$src2, (imm:i8):$amt2))<<P:Predicate_shld>> 27027 // Emits: (SHLD16rri8:i16 GR16:i16:$src1, GR16:i16:$src2, (imm:i8):$amt1) 27028 // Pattern complexity = 16 cost = 1 size = 3 27029 if (Predicate_shld(N.getNode())) { 27030 SDValue N0 = N.getOperand(0); 27031 if (N0.getOpcode() == ISD::SHL) { 27032 SDValue N00 = N0.getOperand(0); 27033 SDValue N01 = N0.getOperand(1); 27034 if (N01.getOpcode() == ISD::Constant) { 27035 SDValue N1 = N.getOperand(1); 27036 if (N1.getOpcode() == ISD::SRL) { 27037 SDValue N10 = N1.getOperand(0); 27038 SDValue N11 = N1.getOperand(1); 27039 if (N11.getOpcode() == ISD::Constant && 27040 N01.getNode()->getValueType(0) == MVT::i8 && 27041 N11.getNode()->getValueType(0) == MVT::i8) { 27042 SDNode *Result = Emit_150(N, X86::SHLD16rri8, MVT::i16); 27043 return Result; 27044 } 27045 } 27046 } 27047 } 27048 } 27049 27050 // Pattern: (or:i16 (shl:i16 GR16:i16:$src2, (imm:i8):$amt2), (srl:i16 GR16:i16:$src1, (imm:i8):$amt1))<<P:Predicate_shrd>> 27051 // Emits: (SHRD16rri8:i16 GR16:i16:$src1, GR16:i16:$src2, (imm:i8):$amt1) 27052 // Pattern complexity = 16 cost = 1 size = 3 27053 if (Predicate_shrd(N.getNode())) { 27054 SDValue N0 = N.getOperand(0); 27055 if (N0.getOpcode() == ISD::SHL) { 27056 SDValue N00 = N0.getOperand(0); 27057 SDValue N01 = N0.getOperand(1); 27058 if (N01.getOpcode() == ISD::Constant) { 27059 SDValue N1 = N.getOperand(1); 27060 if (N1.getOpcode() == ISD::SRL) { 27061 SDValue N10 = N1.getOperand(0); 27062 SDValue N11 = N1.getOperand(1); 27063 if (N11.getOpcode() == ISD::Constant && 27064 N01.getNode()->getValueType(0) == MVT::i8 && 27065 N11.getNode()->getValueType(0) == MVT::i8) { 27066 SDNode *Result = Emit_153(N, X86::SHRD16rri8, MVT::i16); 27067 return Result; 27068 } 27069 } 27070 } 27071 } 27072 } 27073 27074 // Pattern: (or:i16 (srl:i16 GR16:i16:$src2, (imm:i8):$amt2), (shl:i16 GR16:i16:$src1, (imm:i8):$amt1))<<P:Predicate_shld>> 27075 // Emits: (SHLD16rri8:i16 GR16:i16:$src1, GR16:i16:$src2, (imm:i8):$amt1) 27076 // Pattern complexity = 16 cost = 1 size = 3 27077 if (Predicate_shld(N.getNode())) { 27078 SDValue N0 = N.getOperand(0); 27079 if (N0.getOpcode() == ISD::SRL) { 27080 SDValue N00 = N0.getOperand(0); 27081 SDValue N01 = N0.getOperand(1); 27082 if (N01.getOpcode() == ISD::Constant) { 27083 SDValue N1 = N.getOperand(1); 27084 if (N1.getOpcode() == ISD::SHL) { 27085 SDValue N10 = N1.getOperand(0); 27086 SDValue N11 = N1.getOperand(1); 27087 if (N11.getOpcode() == ISD::Constant && 27088 N01.getNode()->getValueType(0) == MVT::i8 && 27089 N11.getNode()->getValueType(0) == MVT::i8) { 27090 SDNode *Result = Emit_153(N, X86::SHLD16rri8, MVT::i16); 27091 return Result; 27092 } 27093 } 27094 } 27095 } 27096 } 27097 { 27098 SDValue N0 = N.getOperand(0); 27099 SDValue N1 = N.getOperand(1); 27100 if (N1.getOpcode() == ISD::Constant) { 27101 27102 // Pattern: (or:i16 GR16:i16:$src1, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 27103 // Emits: (OR16ri8:i16 GR16:i16:$src1, (imm:i16):$src2) 27104 // Pattern complexity = 7 cost = 1 size = 3 27105 if (Predicate_i16immSExt8(N1.getNode())) { 27106 SDNode *Result = Emit_5(N, X86::OR16ri8, MVT::i16); 27107 return Result; 27108 } 27109 27110 // Pattern: (or:i16 GR16:i16:$src1, (imm:i16):$src2) 27111 // Emits: (OR16ri:i16 GR16:i16:$src1, (imm:i16):$src2) 27112 // Pattern complexity = 6 cost = 1 size = 3 27113 SDNode *Result = Emit_5(N, X86::OR16ri, MVT::i16); 27114 return Result; 27115 } 27116 } 27117 27118 // Pattern: (or:i16 GR16:i16:$src1, GR16:i16:$src2) 27119 // Emits: (OR16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 27120 // Pattern complexity = 3 cost = 1 size = 3 27121 SDNode *Result = Emit_1(N, X86::OR16rr, MVT::i16); 27122 return Result; 27123 } 27124 27125 SDNode *Emit_154(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 27126 SDValue N0 = N.getOperand(0); 27127 SDValue N00 = N0.getOperand(0); 27128 SDValue N01 = N0.getOperand(1); 27129 SDValue N010 = N01.getOperand(0); 27130 SDValue N1 = N.getOperand(1); 27131 SDValue N10 = N1.getOperand(0); 27132 SDValue N11 = N1.getOperand(1); 27133 SDValue N110 = N11.getOperand(0); 27134 SDValue N1100 = N110.getOperand(0); 27135 SDValue N1101 = N110.getOperand(1); 27136 SDValue Chain = CurDAG->getEntryNode(); 27137 SDValue InFlag(0, 0); 27138 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N01.getDebugLoc(), X86::ECX, N010, InFlag).getNode(); 27139 Chain = SDValue(ResNode, 0); 27140 InFlag = SDValue(ResNode, 1); 27141 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N00, N10, InFlag); 27142 } 27143 SDNode *Emit_155(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 27144 SDValue N0 = N.getOperand(0); 27145 SDValue N00 = N0.getOperand(0); 27146 SDValue N01 = N0.getOperand(1); 27147 SDValue N010 = N01.getOperand(0); 27148 SDValue N0100 = N010.getOperand(0); 27149 SDValue N0101 = N010.getOperand(1); 27150 SDValue N1 = N.getOperand(1); 27151 SDValue N10 = N1.getOperand(0); 27152 SDValue N11 = N1.getOperand(1); 27153 SDValue N110 = N11.getOperand(0); 27154 SDValue Chain = CurDAG->getEntryNode(); 27155 SDValue InFlag(0, 0); 27156 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N010.getDebugLoc(), X86::ECX, N0101, InFlag).getNode(); 27157 Chain = SDValue(ResNode, 0); 27158 InFlag = SDValue(ResNode, 1); 27159 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N10, N00, InFlag); 27160 } 27161 SDNode *Select_ISD_OR_i32(const SDValue &N) { 27162 if (OptLevel != CodeGenOpt::None) { 27163 SDValue N0 = N.getOperand(0); 27164 27165 // Pattern: (or:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 27166 // Emits: (OR32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 27167 // Pattern complexity = 25 cost = 1 size = 3 27168 { 27169 SDValue N1 = N.getOperand(1); 27170 if (N1.getOpcode() == ISD::LOAD && 27171 N1.hasOneUse() && 27172 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 27173 SDValue Chain1 = N1.getOperand(0); 27174 if (Predicate_unindexedload(N1.getNode()) && 27175 Predicate_load(N1.getNode())) { 27176 SDValue N11 = N1.getOperand(1); 27177 SDValue CPTmpN11_0; 27178 SDValue CPTmpN11_1; 27179 SDValue CPTmpN11_2; 27180 SDValue CPTmpN11_3; 27181 SDValue CPTmpN11_4; 27182 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 27183 SDNode *Result = Emit_2(N, X86::OR32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 27184 return Result; 27185 } 27186 } 27187 } 27188 } 27189 27190 // Pattern: (or:i32 (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR32:i32:$src1) 27191 // Emits: (OR32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 27192 // Pattern complexity = 25 cost = 1 size = 3 27193 if (N0.getOpcode() == ISD::LOAD && 27194 N0.hasOneUse() && 27195 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 27196 SDValue Chain0 = N0.getOperand(0); 27197 if (Predicate_unindexedload(N0.getNode()) && 27198 Predicate_load(N0.getNode())) { 27199 SDValue N01 = N0.getOperand(1); 27200 SDValue CPTmpN01_0; 27201 SDValue CPTmpN01_1; 27202 SDValue CPTmpN01_2; 27203 SDValue CPTmpN01_3; 27204 SDValue CPTmpN01_4; 27205 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 27206 SDNode *Result = Emit_4(N, X86::OR32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 27207 return Result; 27208 } 27209 } 27210 } 27211 } 27212 { 27213 SDValue N0 = N.getOperand(0); 27214 27215 // Pattern: (or:i32 (srl:i32 GR32:i32:$src1, (trunc:i8 ECX:i32:$amt)), (shl:i32 GR32:i32:$src2, (trunc:i8 (sub:i32 32:i32, ECX:i32:$amt)))) 27216 // Emits: (SHRD32rrCL:i32 GR32:i32:$src1, GR32:i32:$src2) 27217 // Pattern complexity = 23 cost = 1 size = 3 27218 if (N0.getOpcode() == ISD::SRL) { 27219 SDValue N00 = N0.getOperand(0); 27220 SDValue N01 = N0.getOperand(1); 27221 if (N01.getOpcode() == ISD::TRUNCATE) { 27222 SDValue N010 = N01.getOperand(0); 27223 SDValue N1 = N.getOperand(1); 27224 if (N1.getOpcode() == ISD::SHL) { 27225 SDValue N10 = N1.getOperand(0); 27226 SDValue N11 = N1.getOperand(1); 27227 if (N11.getOpcode() == ISD::TRUNCATE) { 27228 SDValue N110 = N11.getOperand(0); 27229 if (N110.getOpcode() == ISD::SUB) { 27230 SDValue N1100 = N110.getOperand(0); 27231 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1100); 27232 if (Tmp0) { 27233 int64_t CN1 = Tmp0->getSExtValue(); 27234 if (CN1 == INT64_C(32)) { 27235 SDValue N1101 = N110.getOperand(1); 27236 if (N010 == N1101 && 27237 N01.getNode()->getValueType(0) == MVT::i8 && 27238 N010.getNode()->getValueType(0) == MVT::i32 && 27239 N11.getNode()->getValueType(0) == MVT::i8 && 27240 N110.getNode()->getValueType(0) == MVT::i32) { 27241 SDNode *Result = Emit_154(N, X86::SHRD32rrCL, MVT::i32); 27242 return Result; 27243 } 27244 } 27245 } 27246 } 27247 } 27248 } 27249 } 27250 } 27251 if (N0.getOpcode() == ISD::SHL) { 27252 SDValue N00 = N0.getOperand(0); 27253 SDValue N01 = N0.getOperand(1); 27254 if (N01.getOpcode() == ISD::TRUNCATE) { 27255 SDValue N010 = N01.getOperand(0); 27256 27257 // Pattern: (or:i32 (shl:i32 GR32:i32:$src1, (trunc:i8 ECX:i32:$amt)), (srl:i32 GR32:i32:$src2, (trunc:i8 (sub:i32 32:i32, ECX:i32:$amt)))) 27258 // Emits: (SHLD32rrCL:i32 GR32:i32:$src1, GR32:i32:$src2) 27259 // Pattern complexity = 23 cost = 1 size = 3 27260 { 27261 SDValue N1 = N.getOperand(1); 27262 if (N1.getOpcode() == ISD::SRL) { 27263 SDValue N10 = N1.getOperand(0); 27264 SDValue N11 = N1.getOperand(1); 27265 if (N11.getOpcode() == ISD::TRUNCATE) { 27266 SDValue N110 = N11.getOperand(0); 27267 if (N110.getOpcode() == ISD::SUB) { 27268 SDValue N1100 = N110.getOperand(0); 27269 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1100); 27270 if (Tmp0) { 27271 int64_t CN1 = Tmp0->getSExtValue(); 27272 if (CN1 == INT64_C(32)) { 27273 SDValue N1101 = N110.getOperand(1); 27274 if (N010 == N1101 && 27275 N01.getNode()->getValueType(0) == MVT::i8 && 27276 N010.getNode()->getValueType(0) == MVT::i32 && 27277 N11.getNode()->getValueType(0) == MVT::i8 && 27278 N110.getNode()->getValueType(0) == MVT::i32) { 27279 SDNode *Result = Emit_154(N, X86::SHLD32rrCL, MVT::i32); 27280 return Result; 27281 } 27282 } 27283 } 27284 } 27285 } 27286 } 27287 } 27288 27289 // Pattern: (or:i32 (shl:i32 GR32:i32:$src2, (trunc:i8 (sub:i32 32:i32, ECX:i32:$amt))), (srl:i32 GR32:i32:$src1, (trunc:i8 ECX:i32:$amt))) 27290 // Emits: (SHRD32rrCL:i32 GR32:i32:$src1, GR32:i32:$src2) 27291 // Pattern complexity = 23 cost = 1 size = 3 27292 if (N010.getOpcode() == ISD::SUB) { 27293 SDValue N0100 = N010.getOperand(0); 27294 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0100); 27295 if (Tmp0) { 27296 int64_t CN1 = Tmp0->getSExtValue(); 27297 if (CN1 == INT64_C(32)) { 27298 SDValue N0101 = N010.getOperand(1); 27299 SDValue N1 = N.getOperand(1); 27300 if (N1.getOpcode() == ISD::SRL) { 27301 SDValue N10 = N1.getOperand(0); 27302 SDValue N11 = N1.getOperand(1); 27303 if (N11.getOpcode() == ISD::TRUNCATE) { 27304 SDValue N110 = N11.getOperand(0); 27305 if (N0101 == N110 && 27306 N01.getNode()->getValueType(0) == MVT::i8 && 27307 N010.getNode()->getValueType(0) == MVT::i32 && 27308 N11.getNode()->getValueType(0) == MVT::i8 && 27309 N110.getNode()->getValueType(0) == MVT::i32) { 27310 SDNode *Result = Emit_155(N, X86::SHRD32rrCL, MVT::i32); 27311 return Result; 27312 } 27313 } 27314 } 27315 } 27316 } 27317 } 27318 } 27319 } 27320 if (N0.getOpcode() == ISD::SRL) { 27321 SDValue N00 = N0.getOperand(0); 27322 SDValue N01 = N0.getOperand(1); 27323 27324 // Pattern: (or:i32 (srl:i32 GR32:i32:$src2, (trunc:i8 (sub:i32 32:i32, ECX:i32:$amt))), (shl:i32 GR32:i32:$src1, (trunc:i8 ECX:i32:$amt))) 27325 // Emits: (SHLD32rrCL:i32 GR32:i32:$src1, GR32:i32:$src2) 27326 // Pattern complexity = 23 cost = 1 size = 3 27327 if (N01.getOpcode() == ISD::TRUNCATE) { 27328 SDValue N010 = N01.getOperand(0); 27329 if (N010.getOpcode() == ISD::SUB) { 27330 SDValue N0100 = N010.getOperand(0); 27331 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0100); 27332 if (Tmp0) { 27333 int64_t CN1 = Tmp0->getSExtValue(); 27334 if (CN1 == INT64_C(32)) { 27335 SDValue N0101 = N010.getOperand(1); 27336 SDValue N1 = N.getOperand(1); 27337 if (N1.getOpcode() == ISD::SHL) { 27338 SDValue N10 = N1.getOperand(0); 27339 SDValue N11 = N1.getOperand(1); 27340 if (N11.getOpcode() == ISD::TRUNCATE) { 27341 SDValue N110 = N11.getOperand(0); 27342 if (N0101 == N110 && 27343 N01.getNode()->getValueType(0) == MVT::i8 && 27344 N010.getNode()->getValueType(0) == MVT::i32 && 27345 N11.getNode()->getValueType(0) == MVT::i8 && 27346 N110.getNode()->getValueType(0) == MVT::i32) { 27347 SDNode *Result = Emit_155(N, X86::SHLD32rrCL, MVT::i32); 27348 return Result; 27349 } 27350 } 27351 } 27352 } 27353 } 27354 } 27355 } 27356 27357 // Pattern: (or:i32 (srl:i32 GR32:i32:$src1, CL:i8:$amt), (shl:i32 GR32:i32:$src2, (sub:i8 32:i8, CL:i8:$amt))) 27358 // Emits: (SHRD32rrCL:i32 GR32:i32:$src1, GR32:i32:$src2) 27359 // Pattern complexity = 17 cost = 1 size = 3 27360 SDValue N1 = N.getOperand(1); 27361 if (N1.getOpcode() == ISD::SHL) { 27362 SDValue N10 = N1.getOperand(0); 27363 SDValue N11 = N1.getOperand(1); 27364 if (N11.getOpcode() == ISD::SUB) { 27365 SDValue N110 = N11.getOperand(0); 27366 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N110); 27367 if (Tmp0) { 27368 int64_t CN1 = Tmp0->getSExtValue(); 27369 if (CN1 == INT64_C(32)) { 27370 SDValue N111 = N11.getOperand(1); 27371 if (N01 == N111 && 27372 N01.getNode()->getValueType(0) == MVT::i8 && 27373 N11.getNode()->getValueType(0) == MVT::i8) { 27374 SDNode *Result = Emit_148(N, X86::SHRD32rrCL, MVT::i32); 27375 return Result; 27376 } 27377 } 27378 } 27379 } 27380 } 27381 } 27382 if (N0.getOpcode() == ISD::SHL) { 27383 SDValue N00 = N0.getOperand(0); 27384 SDValue N01 = N0.getOperand(1); 27385 27386 // Pattern: (or:i32 (shl:i32 GR32:i32:$src1, CL:i8:$amt), (srl:i32 GR32:i32:$src2, (sub:i8 32:i8, CL:i8:$amt))) 27387 // Emits: (SHLD32rrCL:i32 GR32:i32:$src1, GR32:i32:$src2) 27388 // Pattern complexity = 17 cost = 1 size = 3 27389 { 27390 SDValue N1 = N.getOperand(1); 27391 if (N1.getOpcode() == ISD::SRL) { 27392 SDValue N10 = N1.getOperand(0); 27393 SDValue N11 = N1.getOperand(1); 27394 if (N11.getOpcode() == ISD::SUB) { 27395 SDValue N110 = N11.getOperand(0); 27396 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N110); 27397 if (Tmp0) { 27398 int64_t CN1 = Tmp0->getSExtValue(); 27399 if (CN1 == INT64_C(32)) { 27400 SDValue N111 = N11.getOperand(1); 27401 if (N01 == N111 && 27402 N01.getNode()->getValueType(0) == MVT::i8 && 27403 N11.getNode()->getValueType(0) == MVT::i8) { 27404 SDNode *Result = Emit_148(N, X86::SHLD32rrCL, MVT::i32); 27405 return Result; 27406 } 27407 } 27408 } 27409 } 27410 } 27411 } 27412 27413 // Pattern: (or:i32 (shl:i32 GR32:i32:$src2, (sub:i8 32:i8, CL:i8:$amt)), (srl:i32 GR32:i32:$src1, CL:i8:$amt)) 27414 // Emits: (SHRD32rrCL:i32 GR32:i32:$src1, GR32:i32:$src2) 27415 // Pattern complexity = 17 cost = 1 size = 3 27416 if (N01.getOpcode() == ISD::SUB) { 27417 SDValue N010 = N01.getOperand(0); 27418 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N010); 27419 if (Tmp0) { 27420 int64_t CN1 = Tmp0->getSExtValue(); 27421 if (CN1 == INT64_C(32)) { 27422 SDValue N011 = N01.getOperand(1); 27423 SDValue N1 = N.getOperand(1); 27424 if (N1.getOpcode() == ISD::SRL) { 27425 SDValue N10 = N1.getOperand(0); 27426 SDValue N11 = N1.getOperand(1); 27427 if (N011 == N11 && 27428 N01.getNode()->getValueType(0) == MVT::i8 && 27429 N11.getNode()->getValueType(0) == MVT::i8) { 27430 SDNode *Result = Emit_151(N, X86::SHRD32rrCL, MVT::i32); 27431 return Result; 27432 } 27433 } 27434 } 27435 } 27436 } 27437 } 27438 27439 // Pattern: (or:i32 (srl:i32 GR32:i32:$src2, (sub:i8 32:i8, CL:i8:$amt)), (shl:i32 GR32:i32:$src1, CL:i8:$amt)) 27440 // Emits: (SHLD32rrCL:i32 GR32:i32:$src1, GR32:i32:$src2) 27441 // Pattern complexity = 17 cost = 1 size = 3 27442 if (N0.getOpcode() == ISD::SRL) { 27443 SDValue N00 = N0.getOperand(0); 27444 SDValue N01 = N0.getOperand(1); 27445 if (N01.getOpcode() == ISD::SUB) { 27446 SDValue N010 = N01.getOperand(0); 27447 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N010); 27448 if (Tmp0) { 27449 int64_t CN1 = Tmp0->getSExtValue(); 27450 if (CN1 == INT64_C(32)) { 27451 SDValue N011 = N01.getOperand(1); 27452 SDValue N1 = N.getOperand(1); 27453 if (N1.getOpcode() == ISD::SHL) { 27454 SDValue N10 = N1.getOperand(0); 27455 SDValue N11 = N1.getOperand(1); 27456 if (N011 == N11 && 27457 N01.getNode()->getValueType(0) == MVT::i8 && 27458 N11.getNode()->getValueType(0) == MVT::i8) { 27459 SDNode *Result = Emit_151(N, X86::SHLD32rrCL, MVT::i32); 27460 return Result; 27461 } 27462 } 27463 } 27464 } 27465 } 27466 } 27467 } 27468 27469 // Pattern: (or:i32 (srl:i32 GR32:i32:$src1, (imm:i8):$amt1), (shl:i32 GR32:i32:$src2, (imm:i8):$amt2))<<P:Predicate_shrd>> 27470 // Emits: (SHRD32rri8:i32 GR32:i32:$src1, GR32:i32:$src2, (imm:i8):$amt1) 27471 // Pattern complexity = 16 cost = 1 size = 3 27472 if (Predicate_shrd(N.getNode())) { 27473 SDValue N0 = N.getOperand(0); 27474 if (N0.getOpcode() == ISD::SRL) { 27475 SDValue N00 = N0.getOperand(0); 27476 SDValue N01 = N0.getOperand(1); 27477 if (N01.getOpcode() == ISD::Constant) { 27478 SDValue N1 = N.getOperand(1); 27479 if (N1.getOpcode() == ISD::SHL) { 27480 SDValue N10 = N1.getOperand(0); 27481 SDValue N11 = N1.getOperand(1); 27482 if (N11.getOpcode() == ISD::Constant && 27483 N01.getNode()->getValueType(0) == MVT::i8 && 27484 N11.getNode()->getValueType(0) == MVT::i8) { 27485 SDNode *Result = Emit_150(N, X86::SHRD32rri8, MVT::i32); 27486 return Result; 27487 } 27488 } 27489 } 27490 } 27491 } 27492 27493 // Pattern: (or:i32 (shl:i32 GR32:i32:$src1, (imm:i8):$amt1), (srl:i32 GR32:i32:$src2, (imm:i8):$amt2))<<P:Predicate_shld>> 27494 // Emits: (SHLD32rri8:i32 GR32:i32:$src1, GR32:i32:$src2, (imm:i8):$amt1) 27495 // Pattern complexity = 16 cost = 1 size = 3 27496 if (Predicate_shld(N.getNode())) { 27497 SDValue N0 = N.getOperand(0); 27498 if (N0.getOpcode() == ISD::SHL) { 27499 SDValue N00 = N0.getOperand(0); 27500 SDValue N01 = N0.getOperand(1); 27501 if (N01.getOpcode() == ISD::Constant) { 27502 SDValue N1 = N.getOperand(1); 27503 if (N1.getOpcode() == ISD::SRL) { 27504 SDValue N10 = N1.getOperand(0); 27505 SDValue N11 = N1.getOperand(1); 27506 if (N11.getOpcode() == ISD::Constant && 27507 N01.getNode()->getValueType(0) == MVT::i8 && 27508 N11.getNode()->getValueType(0) == MVT::i8) { 27509 SDNode *Result = Emit_150(N, X86::SHLD32rri8, MVT::i32); 27510 return Result; 27511 } 27512 } 27513 } 27514 } 27515 } 27516 27517 // Pattern: (or:i32 (shl:i32 GR32:i32:$src2, (imm:i8):$amt2), (srl:i32 GR32:i32:$src1, (imm:i8):$amt1))<<P:Predicate_shrd>> 27518 // Emits: (SHRD32rri8:i32 GR32:i32:$src1, GR32:i32:$src2, (imm:i8):$amt1) 27519 // Pattern complexity = 16 cost = 1 size = 3 27520 if (Predicate_shrd(N.getNode())) { 27521 SDValue N0 = N.getOperand(0); 27522 if (N0.getOpcode() == ISD::SHL) { 27523 SDValue N00 = N0.getOperand(0); 27524 SDValue N01 = N0.getOperand(1); 27525 if (N01.getOpcode() == ISD::Constant) { 27526 SDValue N1 = N.getOperand(1); 27527 if (N1.getOpcode() == ISD::SRL) { 27528 SDValue N10 = N1.getOperand(0); 27529 SDValue N11 = N1.getOperand(1); 27530 if (N11.getOpcode() == ISD::Constant && 27531 N01.getNode()->getValueType(0) == MVT::i8 && 27532 N11.getNode()->getValueType(0) == MVT::i8) { 27533 SDNode *Result = Emit_153(N, X86::SHRD32rri8, MVT::i32); 27534 return Result; 27535 } 27536 } 27537 } 27538 } 27539 } 27540 27541 // Pattern: (or:i32 (srl:i32 GR32:i32:$src2, (imm:i8):$amt2), (shl:i32 GR32:i32:$src1, (imm:i8):$amt1))<<P:Predicate_shld>> 27542 // Emits: (SHLD32rri8:i32 GR32:i32:$src1, GR32:i32:$src2, (imm:i8):$amt1) 27543 // Pattern complexity = 16 cost = 1 size = 3 27544 if (Predicate_shld(N.getNode())) { 27545 SDValue N0 = N.getOperand(0); 27546 if (N0.getOpcode() == ISD::SRL) { 27547 SDValue N00 = N0.getOperand(0); 27548 SDValue N01 = N0.getOperand(1); 27549 if (N01.getOpcode() == ISD::Constant) { 27550 SDValue N1 = N.getOperand(1); 27551 if (N1.getOpcode() == ISD::SHL) { 27552 SDValue N10 = N1.getOperand(0); 27553 SDValue N11 = N1.getOperand(1); 27554 if (N11.getOpcode() == ISD::Constant && 27555 N01.getNode()->getValueType(0) == MVT::i8 && 27556 N11.getNode()->getValueType(0) == MVT::i8) { 27557 SDNode *Result = Emit_153(N, X86::SHLD32rri8, MVT::i32); 27558 return Result; 27559 } 27560 } 27561 } 27562 } 27563 } 27564 27565 // Pattern: lea32addr:i32:$src 27566 // Emits: (LEA64_32r:i32 lea32addr:i32:$src) 27567 // Pattern complexity = 15 cost = 1 size = 3 27568 if ((Subtarget->is64Bit())) { 27569 SDValue CPTmpN_0; 27570 SDValue CPTmpN_1; 27571 SDValue CPTmpN_2; 27572 SDValue CPTmpN_3; 27573 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 27574 SDNode *Result = Emit_7(N, X86::LEA64_32r, MVT::i32, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 27575 return Result; 27576 } 27577 } 27578 27579 // Pattern: lea32addr:i32:$src 27580 // Emits: (LEA32r:i32 lea32addr:i32:$src) 27581 // Pattern complexity = 15 cost = 1 size = 3 27582 if ((!Subtarget->is64Bit())) { 27583 SDValue CPTmpN_0; 27584 SDValue CPTmpN_1; 27585 SDValue CPTmpN_2; 27586 SDValue CPTmpN_3; 27587 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 27588 SDNode *Result = Emit_7(N, X86::LEA32r, MVT::i32, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 27589 return Result; 27590 } 27591 } 27592 { 27593 SDValue N0 = N.getOperand(0); 27594 SDValue N1 = N.getOperand(1); 27595 if (N1.getOpcode() == ISD::Constant) { 27596 27597 // Pattern: (or:i32 GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 27598 // Emits: (OR32ri8:i32 GR32:i32:$src1, (imm:i32):$src2) 27599 // Pattern complexity = 7 cost = 1 size = 3 27600 if (Predicate_i32immSExt8(N1.getNode())) { 27601 SDNode *Result = Emit_8(N, X86::OR32ri8, MVT::i32); 27602 return Result; 27603 } 27604 27605 // Pattern: (or:i32 GR32:i32:$src1, (imm:i32):$src2) 27606 // Emits: (OR32ri:i32 GR32:i32:$src1, (imm:i32):$src2) 27607 // Pattern complexity = 6 cost = 1 size = 3 27608 SDNode *Result = Emit_8(N, X86::OR32ri, MVT::i32); 27609 return Result; 27610 } 27611 } 27612 27613 // Pattern: (or:i32 GR32:i32:$src1, GR32:i32:$src2) 27614 // Emits: (OR32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 27615 // Pattern complexity = 3 cost = 1 size = 3 27616 SDNode *Result = Emit_1(N, X86::OR32rr, MVT::i32); 27617 return Result; 27618 } 27619 27620 SDNode *Emit_156(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 27621 SDValue N0 = N.getOperand(0); 27622 SDValue N00 = N0.getOperand(0); 27623 SDValue N01 = N0.getOperand(1); 27624 SDValue N010 = N01.getOperand(0); 27625 SDValue N1 = N.getOperand(1); 27626 SDValue N10 = N1.getOperand(0); 27627 SDValue N11 = N1.getOperand(1); 27628 SDValue N110 = N11.getOperand(0); 27629 SDValue N1100 = N110.getOperand(0); 27630 SDValue N1101 = N110.getOperand(1); 27631 SDValue Chain = CurDAG->getEntryNode(); 27632 SDValue InFlag(0, 0); 27633 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N01.getDebugLoc(), X86::RCX, N010, InFlag).getNode(); 27634 Chain = SDValue(ResNode, 0); 27635 InFlag = SDValue(ResNode, 1); 27636 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N00, N10, InFlag); 27637 } 27638 SDNode *Emit_157(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 27639 SDValue N0 = N.getOperand(0); 27640 SDValue N00 = N0.getOperand(0); 27641 SDValue N01 = N0.getOperand(1); 27642 SDValue N010 = N01.getOperand(0); 27643 SDValue N0100 = N010.getOperand(0); 27644 SDValue N0101 = N010.getOperand(1); 27645 SDValue N1 = N.getOperand(1); 27646 SDValue N10 = N1.getOperand(0); 27647 SDValue N11 = N1.getOperand(1); 27648 SDValue N110 = N11.getOperand(0); 27649 SDValue Chain = CurDAG->getEntryNode(); 27650 SDValue InFlag(0, 0); 27651 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N010.getDebugLoc(), X86::RCX, N0101, InFlag).getNode(); 27652 Chain = SDValue(ResNode, 0); 27653 InFlag = SDValue(ResNode, 1); 27654 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N10, N00, InFlag); 27655 } 27656 SDNode *Select_ISD_OR_i64(const SDValue &N) { 27657 if (OptLevel != CodeGenOpt::None) { 27658 SDValue N0 = N.getOperand(0); 27659 27660 // Pattern: (or:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 27661 // Emits: (OR64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 27662 // Pattern complexity = 25 cost = 1 size = 3 27663 { 27664 SDValue N1 = N.getOperand(1); 27665 if (N1.getOpcode() == ISD::LOAD && 27666 N1.hasOneUse() && 27667 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 27668 SDValue Chain1 = N1.getOperand(0); 27669 if (Predicate_unindexedload(N1.getNode()) && 27670 Predicate_load(N1.getNode())) { 27671 SDValue N11 = N1.getOperand(1); 27672 SDValue CPTmpN11_0; 27673 SDValue CPTmpN11_1; 27674 SDValue CPTmpN11_2; 27675 SDValue CPTmpN11_3; 27676 SDValue CPTmpN11_4; 27677 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 27678 SDNode *Result = Emit_2(N, X86::OR64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 27679 return Result; 27680 } 27681 } 27682 } 27683 } 27684 27685 // Pattern: (or:i64 (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR64:i64:$src1) 27686 // Emits: (OR64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 27687 // Pattern complexity = 25 cost = 1 size = 3 27688 if (N0.getOpcode() == ISD::LOAD && 27689 N0.hasOneUse() && 27690 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 27691 SDValue Chain0 = N0.getOperand(0); 27692 if (Predicate_unindexedload(N0.getNode()) && 27693 Predicate_load(N0.getNode())) { 27694 SDValue N01 = N0.getOperand(1); 27695 SDValue CPTmpN01_0; 27696 SDValue CPTmpN01_1; 27697 SDValue CPTmpN01_2; 27698 SDValue CPTmpN01_3; 27699 SDValue CPTmpN01_4; 27700 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 27701 SDNode *Result = Emit_4(N, X86::OR64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 27702 return Result; 27703 } 27704 } 27705 } 27706 } 27707 { 27708 SDValue N0 = N.getOperand(0); 27709 27710 // Pattern: (or:i64 (srl:i64 GR64:i64:$src1, (trunc:i8 RCX:i64:$amt)), (shl:i64 GR64:i64:$src2, (trunc:i8 (sub:i64 64:i64, RCX:i64:$amt)))) 27711 // Emits: (SHRD64rrCL:i64 GR64:i64:$src1, GR64:i64:$src2) 27712 // Pattern complexity = 23 cost = 1 size = 3 27713 if (N0.getOpcode() == ISD::SRL) { 27714 SDValue N00 = N0.getOperand(0); 27715 SDValue N01 = N0.getOperand(1); 27716 if (N01.getOpcode() == ISD::TRUNCATE) { 27717 SDValue N010 = N01.getOperand(0); 27718 SDValue N1 = N.getOperand(1); 27719 if (N1.getOpcode() == ISD::SHL) { 27720 SDValue N10 = N1.getOperand(0); 27721 SDValue N11 = N1.getOperand(1); 27722 if (N11.getOpcode() == ISD::TRUNCATE) { 27723 SDValue N110 = N11.getOperand(0); 27724 if (N110.getOpcode() == ISD::SUB) { 27725 SDValue N1100 = N110.getOperand(0); 27726 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1100); 27727 if (Tmp0) { 27728 int64_t CN1 = Tmp0->getSExtValue(); 27729 if (CN1 == INT64_C(64)) { 27730 SDValue N1101 = N110.getOperand(1); 27731 if (N010 == N1101 && 27732 N01.getNode()->getValueType(0) == MVT::i8 && 27733 N010.getNode()->getValueType(0) == MVT::i64 && 27734 N11.getNode()->getValueType(0) == MVT::i8 && 27735 N110.getNode()->getValueType(0) == MVT::i64) { 27736 SDNode *Result = Emit_156(N, X86::SHRD64rrCL, MVT::i64); 27737 return Result; 27738 } 27739 } 27740 } 27741 } 27742 } 27743 } 27744 } 27745 } 27746 if (N0.getOpcode() == ISD::SHL) { 27747 SDValue N00 = N0.getOperand(0); 27748 SDValue N01 = N0.getOperand(1); 27749 if (N01.getOpcode() == ISD::TRUNCATE) { 27750 SDValue N010 = N01.getOperand(0); 27751 27752 // Pattern: (or:i64 (shl:i64 GR64:i64:$src1, (trunc:i8 RCX:i64:$amt)), (srl:i64 GR64:i64:$src2, (trunc:i8 (sub:i64 64:i64, RCX:i64:$amt)))) 27753 // Emits: (SHLD64rrCL:i64 GR64:i64:$src1, GR64:i64:$src2) 27754 // Pattern complexity = 23 cost = 1 size = 3 27755 { 27756 SDValue N1 = N.getOperand(1); 27757 if (N1.getOpcode() == ISD::SRL) { 27758 SDValue N10 = N1.getOperand(0); 27759 SDValue N11 = N1.getOperand(1); 27760 if (N11.getOpcode() == ISD::TRUNCATE) { 27761 SDValue N110 = N11.getOperand(0); 27762 if (N110.getOpcode() == ISD::SUB) { 27763 SDValue N1100 = N110.getOperand(0); 27764 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1100); 27765 if (Tmp0) { 27766 int64_t CN1 = Tmp0->getSExtValue(); 27767 if (CN1 == INT64_C(64)) { 27768 SDValue N1101 = N110.getOperand(1); 27769 if (N010 == N1101 && 27770 N01.getNode()->getValueType(0) == MVT::i8 && 27771 N010.getNode()->getValueType(0) == MVT::i64 && 27772 N11.getNode()->getValueType(0) == MVT::i8 && 27773 N110.getNode()->getValueType(0) == MVT::i64) { 27774 SDNode *Result = Emit_156(N, X86::SHLD64rrCL, MVT::i64); 27775 return Result; 27776 } 27777 } 27778 } 27779 } 27780 } 27781 } 27782 } 27783 27784 // Pattern: (or:i64 (shl:i64 GR64:i64:$src2, (trunc:i8 (sub:i64 64:i64, RCX:i64:$amt))), (srl:i64 GR64:i64:$src1, (trunc:i8 RCX:i64:$amt))) 27785 // Emits: (SHRD64rrCL:i64 GR64:i64:$src1, GR64:i64:$src2) 27786 // Pattern complexity = 23 cost = 1 size = 3 27787 if (N010.getOpcode() == ISD::SUB) { 27788 SDValue N0100 = N010.getOperand(0); 27789 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0100); 27790 if (Tmp0) { 27791 int64_t CN1 = Tmp0->getSExtValue(); 27792 if (CN1 == INT64_C(64)) { 27793 SDValue N0101 = N010.getOperand(1); 27794 SDValue N1 = N.getOperand(1); 27795 if (N1.getOpcode() == ISD::SRL) { 27796 SDValue N10 = N1.getOperand(0); 27797 SDValue N11 = N1.getOperand(1); 27798 if (N11.getOpcode() == ISD::TRUNCATE) { 27799 SDValue N110 = N11.getOperand(0); 27800 if (N0101 == N110 && 27801 N01.getNode()->getValueType(0) == MVT::i8 && 27802 N010.getNode()->getValueType(0) == MVT::i64 && 27803 N11.getNode()->getValueType(0) == MVT::i8 && 27804 N110.getNode()->getValueType(0) == MVT::i64) { 27805 SDNode *Result = Emit_157(N, X86::SHRD64rrCL, MVT::i64); 27806 return Result; 27807 } 27808 } 27809 } 27810 } 27811 } 27812 } 27813 } 27814 } 27815 if (N0.getOpcode() == ISD::SRL) { 27816 SDValue N00 = N0.getOperand(0); 27817 SDValue N01 = N0.getOperand(1); 27818 27819 // Pattern: (or:i64 (srl:i64 GR64:i64:$src2, (trunc:i8 (sub:i64 64:i64, RCX:i64:$amt))), (shl:i64 GR64:i64:$src1, (trunc:i8 RCX:i64:$amt))) 27820 // Emits: (SHLD64rrCL:i64 GR64:i64:$src1, GR64:i64:$src2) 27821 // Pattern complexity = 23 cost = 1 size = 3 27822 if (N01.getOpcode() == ISD::TRUNCATE) { 27823 SDValue N010 = N01.getOperand(0); 27824 if (N010.getOpcode() == ISD::SUB) { 27825 SDValue N0100 = N010.getOperand(0); 27826 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0100); 27827 if (Tmp0) { 27828 int64_t CN1 = Tmp0->getSExtValue(); 27829 if (CN1 == INT64_C(64)) { 27830 SDValue N0101 = N010.getOperand(1); 27831 SDValue N1 = N.getOperand(1); 27832 if (N1.getOpcode() == ISD::SHL) { 27833 SDValue N10 = N1.getOperand(0); 27834 SDValue N11 = N1.getOperand(1); 27835 if (N11.getOpcode() == ISD::TRUNCATE) { 27836 SDValue N110 = N11.getOperand(0); 27837 if (N0101 == N110 && 27838 N01.getNode()->getValueType(0) == MVT::i8 && 27839 N010.getNode()->getValueType(0) == MVT::i64 && 27840 N11.getNode()->getValueType(0) == MVT::i8 && 27841 N110.getNode()->getValueType(0) == MVT::i64) { 27842 SDNode *Result = Emit_157(N, X86::SHLD64rrCL, MVT::i64); 27843 return Result; 27844 } 27845 } 27846 } 27847 } 27848 } 27849 } 27850 } 27851 27852 // Pattern: (or:i64 (srl:i64 GR64:i64:$src1, CL:i8:$amt), (shl:i64 GR64:i64:$src2, (sub:i8 64:i8, CL:i8:$amt))) 27853 // Emits: (SHRD64rrCL:i64 GR64:i64:$src1, GR64:i64:$src2) 27854 // Pattern complexity = 17 cost = 1 size = 3 27855 SDValue N1 = N.getOperand(1); 27856 if (N1.getOpcode() == ISD::SHL) { 27857 SDValue N10 = N1.getOperand(0); 27858 SDValue N11 = N1.getOperand(1); 27859 if (N11.getOpcode() == ISD::SUB) { 27860 SDValue N110 = N11.getOperand(0); 27861 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N110); 27862 if (Tmp0) { 27863 int64_t CN1 = Tmp0->getSExtValue(); 27864 if (CN1 == INT64_C(64)) { 27865 SDValue N111 = N11.getOperand(1); 27866 if (N01 == N111 && 27867 N01.getNode()->getValueType(0) == MVT::i8 && 27868 N11.getNode()->getValueType(0) == MVT::i8) { 27869 SDNode *Result = Emit_148(N, X86::SHRD64rrCL, MVT::i64); 27870 return Result; 27871 } 27872 } 27873 } 27874 } 27875 } 27876 } 27877 if (N0.getOpcode() == ISD::SHL) { 27878 SDValue N00 = N0.getOperand(0); 27879 SDValue N01 = N0.getOperand(1); 27880 27881 // Pattern: (or:i64 (shl:i64 GR64:i64:$src1, CL:i8:$amt), (srl:i64 GR64:i64:$src2, (sub:i8 64:i8, CL:i8:$amt))) 27882 // Emits: (SHLD64rrCL:i64 GR64:i64:$src1, GR64:i64:$src2) 27883 // Pattern complexity = 17 cost = 1 size = 3 27884 { 27885 SDValue N1 = N.getOperand(1); 27886 if (N1.getOpcode() == ISD::SRL) { 27887 SDValue N10 = N1.getOperand(0); 27888 SDValue N11 = N1.getOperand(1); 27889 if (N11.getOpcode() == ISD::SUB) { 27890 SDValue N110 = N11.getOperand(0); 27891 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N110); 27892 if (Tmp0) { 27893 int64_t CN1 = Tmp0->getSExtValue(); 27894 if (CN1 == INT64_C(64)) { 27895 SDValue N111 = N11.getOperand(1); 27896 if (N01 == N111 && 27897 N01.getNode()->getValueType(0) == MVT::i8 && 27898 N11.getNode()->getValueType(0) == MVT::i8) { 27899 SDNode *Result = Emit_148(N, X86::SHLD64rrCL, MVT::i64); 27900 return Result; 27901 } 27902 } 27903 } 27904 } 27905 } 27906 } 27907 27908 // Pattern: (or:i64 (shl:i64 GR64:i64:$src2, (sub:i8 64:i8, CL:i8:$amt)), (srl:i64 GR64:i64:$src1, CL:i8:$amt)) 27909 // Emits: (SHRD64rrCL:i64 GR64:i64:$src1, GR64:i64:$src2) 27910 // Pattern complexity = 17 cost = 1 size = 3 27911 if (N01.getOpcode() == ISD::SUB) { 27912 SDValue N010 = N01.getOperand(0); 27913 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N010); 27914 if (Tmp0) { 27915 int64_t CN1 = Tmp0->getSExtValue(); 27916 if (CN1 == INT64_C(64)) { 27917 SDValue N011 = N01.getOperand(1); 27918 SDValue N1 = N.getOperand(1); 27919 if (N1.getOpcode() == ISD::SRL) { 27920 SDValue N10 = N1.getOperand(0); 27921 SDValue N11 = N1.getOperand(1); 27922 if (N011 == N11 && 27923 N01.getNode()->getValueType(0) == MVT::i8 && 27924 N11.getNode()->getValueType(0) == MVT::i8) { 27925 SDNode *Result = Emit_151(N, X86::SHRD64rrCL, MVT::i64); 27926 return Result; 27927 } 27928 } 27929 } 27930 } 27931 } 27932 } 27933 27934 // Pattern: (or:i64 (srl:i64 GR64:i64:$src2, (sub:i8 64:i8, CL:i8:$amt)), (shl:i64 GR64:i64:$src1, CL:i8:$amt)) 27935 // Emits: (SHLD64rrCL:i64 GR64:i64:$src1, GR64:i64:$src2) 27936 // Pattern complexity = 17 cost = 1 size = 3 27937 if (N0.getOpcode() == ISD::SRL) { 27938 SDValue N00 = N0.getOperand(0); 27939 SDValue N01 = N0.getOperand(1); 27940 if (N01.getOpcode() == ISD::SUB) { 27941 SDValue N010 = N01.getOperand(0); 27942 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N010); 27943 if (Tmp0) { 27944 int64_t CN1 = Tmp0->getSExtValue(); 27945 if (CN1 == INT64_C(64)) { 27946 SDValue N011 = N01.getOperand(1); 27947 SDValue N1 = N.getOperand(1); 27948 if (N1.getOpcode() == ISD::SHL) { 27949 SDValue N10 = N1.getOperand(0); 27950 SDValue N11 = N1.getOperand(1); 27951 if (N011 == N11 && 27952 N01.getNode()->getValueType(0) == MVT::i8 && 27953 N11.getNode()->getValueType(0) == MVT::i8) { 27954 SDNode *Result = Emit_151(N, X86::SHLD64rrCL, MVT::i64); 27955 return Result; 27956 } 27957 } 27958 } 27959 } 27960 } 27961 } 27962 } 27963 27964 // Pattern: (or:i64 (srl:i64 GR64:i64:$src1, (imm:i8):$amt1), (shl:i64 GR64:i64:$src2, (imm:i8):$amt2))<<P:Predicate_shrd>> 27965 // Emits: (SHRD64rri8:i64 GR64:i64:$src1, GR64:i64:$src2, (imm:i8):$amt1) 27966 // Pattern complexity = 16 cost = 1 size = 3 27967 if (Predicate_shrd(N.getNode())) { 27968 SDValue N0 = N.getOperand(0); 27969 if (N0.getOpcode() == ISD::SRL) { 27970 SDValue N00 = N0.getOperand(0); 27971 SDValue N01 = N0.getOperand(1); 27972 if (N01.getOpcode() == ISD::Constant) { 27973 SDValue N1 = N.getOperand(1); 27974 if (N1.getOpcode() == ISD::SHL) { 27975 SDValue N10 = N1.getOperand(0); 27976 SDValue N11 = N1.getOperand(1); 27977 if (N11.getOpcode() == ISD::Constant && 27978 N01.getNode()->getValueType(0) == MVT::i8 && 27979 N11.getNode()->getValueType(0) == MVT::i8) { 27980 SDNode *Result = Emit_150(N, X86::SHRD64rri8, MVT::i64); 27981 return Result; 27982 } 27983 } 27984 } 27985 } 27986 } 27987 27988 // Pattern: (or:i64 (shl:i64 GR64:i64:$src1, (imm:i8):$amt1), (srl:i64 GR64:i64:$src2, (imm:i8):$amt2))<<P:Predicate_shld>> 27989 // Emits: (SHLD64rri8:i64 GR64:i64:$src1, GR64:i64:$src2, (imm:i8):$amt1) 27990 // Pattern complexity = 16 cost = 1 size = 3 27991 if (Predicate_shld(N.getNode())) { 27992 SDValue N0 = N.getOperand(0); 27993 if (N0.getOpcode() == ISD::SHL) { 27994 SDValue N00 = N0.getOperand(0); 27995 SDValue N01 = N0.getOperand(1); 27996 if (N01.getOpcode() == ISD::Constant) { 27997 SDValue N1 = N.getOperand(1); 27998 if (N1.getOpcode() == ISD::SRL) { 27999 SDValue N10 = N1.getOperand(0); 28000 SDValue N11 = N1.getOperand(1); 28001 if (N11.getOpcode() == ISD::Constant && 28002 N01.getNode()->getValueType(0) == MVT::i8 && 28003 N11.getNode()->getValueType(0) == MVT::i8) { 28004 SDNode *Result = Emit_150(N, X86::SHLD64rri8, MVT::i64); 28005 return Result; 28006 } 28007 } 28008 } 28009 } 28010 } 28011 28012 // Pattern: (or:i64 (shl:i64 GR64:i64:$src2, (imm:i8):$amt2), (srl:i64 GR64:i64:$src1, (imm:i8):$amt1))<<P:Predicate_shrd>> 28013 // Emits: (SHRD64rri8:i64 GR64:i64:$src1, GR64:i64:$src2, (imm:i8):$amt1) 28014 // Pattern complexity = 16 cost = 1 size = 3 28015 if (Predicate_shrd(N.getNode())) { 28016 SDValue N0 = N.getOperand(0); 28017 if (N0.getOpcode() == ISD::SHL) { 28018 SDValue N00 = N0.getOperand(0); 28019 SDValue N01 = N0.getOperand(1); 28020 if (N01.getOpcode() == ISD::Constant) { 28021 SDValue N1 = N.getOperand(1); 28022 if (N1.getOpcode() == ISD::SRL) { 28023 SDValue N10 = N1.getOperand(0); 28024 SDValue N11 = N1.getOperand(1); 28025 if (N11.getOpcode() == ISD::Constant && 28026 N01.getNode()->getValueType(0) == MVT::i8 && 28027 N11.getNode()->getValueType(0) == MVT::i8) { 28028 SDNode *Result = Emit_153(N, X86::SHRD64rri8, MVT::i64); 28029 return Result; 28030 } 28031 } 28032 } 28033 } 28034 } 28035 28036 // Pattern: (or:i64 (srl:i64 GR64:i64:$src2, (imm:i8):$amt2), (shl:i64 GR64:i64:$src1, (imm:i8):$amt1))<<P:Predicate_shld>> 28037 // Emits: (SHLD64rri8:i64 GR64:i64:$src1, GR64:i64:$src2, (imm:i8):$amt1) 28038 // Pattern complexity = 16 cost = 1 size = 3 28039 if (Predicate_shld(N.getNode())) { 28040 SDValue N0 = N.getOperand(0); 28041 if (N0.getOpcode() == ISD::SRL) { 28042 SDValue N00 = N0.getOperand(0); 28043 SDValue N01 = N0.getOperand(1); 28044 if (N01.getOpcode() == ISD::Constant) { 28045 SDValue N1 = N.getOperand(1); 28046 if (N1.getOpcode() == ISD::SHL) { 28047 SDValue N10 = N1.getOperand(0); 28048 SDValue N11 = N1.getOperand(1); 28049 if (N11.getOpcode() == ISD::Constant && 28050 N01.getNode()->getValueType(0) == MVT::i8 && 28051 N11.getNode()->getValueType(0) == MVT::i8) { 28052 SDNode *Result = Emit_153(N, X86::SHLD64rri8, MVT::i64); 28053 return Result; 28054 } 28055 } 28056 } 28057 } 28058 } 28059 28060 // Pattern: lea64addr:i64:$src 28061 // Emits: (LEA64r:i64 lea64addr:i64:$src) 28062 // Pattern complexity = 15 cost = 1 size = 3 28063 { 28064 SDValue CPTmpN_0; 28065 SDValue CPTmpN_1; 28066 SDValue CPTmpN_2; 28067 SDValue CPTmpN_3; 28068 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 28069 SDNode *Result = Emit_7(N, X86::LEA64r, MVT::i64, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 28070 return Result; 28071 } 28072 } 28073 { 28074 SDValue N0 = N.getOperand(0); 28075 SDValue N1 = N.getOperand(1); 28076 if (N1.getOpcode() == ISD::Constant) { 28077 28078 // Pattern: (or:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 28079 // Emits: (OR64ri8:i64 GR64:i64:$src1, (imm:i64):$src2) 28080 // Pattern complexity = 7 cost = 1 size = 3 28081 if (Predicate_i64immSExt8(N1.getNode())) { 28082 SDNode *Result = Emit_12(N, X86::OR64ri8, MVT::i64); 28083 return Result; 28084 } 28085 28086 // Pattern: (or:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 28087 // Emits: (OR64ri32:i64 GR64:i64:$src1, (imm:i64):$src2) 28088 // Pattern complexity = 7 cost = 1 size = 3 28089 if (Predicate_i64immSExt32(N1.getNode())) { 28090 SDNode *Result = Emit_12(N, X86::OR64ri32, MVT::i64); 28091 return Result; 28092 } 28093 } 28094 } 28095 28096 // Pattern: (or:i64 GR64:i64:$src1, GR64:i64:$src2) 28097 // Emits: (OR64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 28098 // Pattern complexity = 3 cost = 1 size = 3 28099 SDNode *Result = Emit_1(N, X86::OR64rr, MVT::i64); 28100 return Result; 28101 } 28102 28103 SDNode *Select_ISD_OR_v1i64(const SDValue &N) { 28104 if (OptLevel != CodeGenOpt::None && 28105 (Subtarget->hasMMX())) { 28106 SDValue N0 = N.getOperand(0); 28107 28108 // Pattern: (or:v1i64 VR64:v1i64:$src1, (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 28109 // Emits: (MMX_PORrm:v1i64 VR64:v1i64:$src1, addr:iPTR:$src2) 28110 // Pattern complexity = 25 cost = 1 size = 3 28111 { 28112 SDValue N1 = N.getOperand(1); 28113 if (N1.getOpcode() == ISD::LOAD && 28114 N1.hasOneUse() && 28115 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 28116 SDValue Chain1 = N1.getOperand(0); 28117 if (Predicate_unindexedload(N1.getNode()) && 28118 Predicate_load(N1.getNode())) { 28119 SDValue N11 = N1.getOperand(1); 28120 SDValue CPTmpN11_0; 28121 SDValue CPTmpN11_1; 28122 SDValue CPTmpN11_2; 28123 SDValue CPTmpN11_3; 28124 SDValue CPTmpN11_4; 28125 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 28126 SDNode *Result = Emit_18(N, X86::MMX_PORrm, MVT::v1i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 28127 return Result; 28128 } 28129 } 28130 } 28131 } 28132 28133 // Pattern: (or:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, VR64:v1i64:$src1) 28134 // Emits: (MMX_PORrm:v1i64 VR64:v1i64:$src1, addr:iPTR:$src2) 28135 // Pattern complexity = 25 cost = 1 size = 3 28136 if (N0.getOpcode() == ISD::LOAD && 28137 N0.hasOneUse() && 28138 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 28139 SDValue Chain0 = N0.getOperand(0); 28140 if (Predicate_unindexedload(N0.getNode()) && 28141 Predicate_load(N0.getNode())) { 28142 SDValue N01 = N0.getOperand(1); 28143 SDValue CPTmpN01_0; 28144 SDValue CPTmpN01_1; 28145 SDValue CPTmpN01_2; 28146 SDValue CPTmpN01_3; 28147 SDValue CPTmpN01_4; 28148 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 28149 SDNode *Result = Emit_19(N, X86::MMX_PORrm, MVT::v1i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 28150 return Result; 28151 } 28152 } 28153 } 28154 } 28155 28156 // Pattern: (or:v1i64 VR64:v1i64:$src1, VR64:v1i64:$src2) 28157 // Emits: (MMX_PORrr:v1i64 VR64:v1i64:$src1, VR64:v1i64:$src2) 28158 // Pattern complexity = 3 cost = 1 size = 3 28159 if ((Subtarget->hasMMX())) { 28160 SDNode *Result = Emit_15(N, X86::MMX_PORrr, MVT::v1i64); 28161 return Result; 28162 } 28163 28164 CannotYetSelect(N); 28165 return NULL; 28166 } 28167 28168 SDNode *Select_ISD_OR_v2i64(const SDValue &N) { 28169 if (OptLevel != CodeGenOpt::None) { 28170 28171 // Pattern: (or:v2i64 (bitconvert:v2i64 VR128:v4f32:$src1), (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 28172 // Emits: (ORPSrm:v2i64 VR128:v4f32:$src1, addr:iPTR:$src2) 28173 // Pattern complexity = 28 cost = 1 size = 3 28174 if ((Subtarget->hasSSE1())) { 28175 SDValue N0 = N.getOperand(0); 28176 if (N0.getOpcode() == ISD::BIT_CONVERT) { 28177 SDValue N00 = N0.getOperand(0); 28178 SDValue N1 = N.getOperand(1); 28179 if (N1.getOpcode() == ISD::LOAD && 28180 N1.hasOneUse() && 28181 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 28182 SDValue Chain1 = N1.getOperand(0); 28183 if (Predicate_unindexedload(N1.getNode()) && 28184 Predicate_load(N1.getNode()) && 28185 Predicate_memop(N1.getNode())) { 28186 SDValue N11 = N1.getOperand(1); 28187 SDValue CPTmpN11_0; 28188 SDValue CPTmpN11_1; 28189 SDValue CPTmpN11_2; 28190 SDValue CPTmpN11_3; 28191 SDValue CPTmpN11_4; 28192 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 28193 N00.getNode()->getValueType(0) == MVT::v4f32) { 28194 SDNode *Result = Emit_56(N, X86::ORPSrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 28195 return Result; 28196 } 28197 } 28198 } 28199 } 28200 } 28201 28202 // Pattern: (or:v2i64 (bitconvert:v2i64 VR128:v2f64:$src1), (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 28203 // Emits: (ORPDrm:v2i64 VR128:v2f64:$src1, addr:iPTR:$src2) 28204 // Pattern complexity = 28 cost = 1 size = 3 28205 if ((Subtarget->hasSSE2())) { 28206 SDValue N0 = N.getOperand(0); 28207 if (N0.getOpcode() == ISD::BIT_CONVERT) { 28208 SDValue N00 = N0.getOperand(0); 28209 SDValue N1 = N.getOperand(1); 28210 if (N1.getOpcode() == ISD::LOAD && 28211 N1.hasOneUse() && 28212 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 28213 SDValue Chain1 = N1.getOperand(0); 28214 if (Predicate_unindexedload(N1.getNode()) && 28215 Predicate_load(N1.getNode()) && 28216 Predicate_memop(N1.getNode())) { 28217 SDValue N11 = N1.getOperand(1); 28218 SDValue CPTmpN11_0; 28219 SDValue CPTmpN11_1; 28220 SDValue CPTmpN11_2; 28221 SDValue CPTmpN11_3; 28222 SDValue CPTmpN11_4; 28223 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 28224 N00.getNode()->getValueType(0) == MVT::v2f64) { 28225 SDNode *Result = Emit_56(N, X86::ORPDrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 28226 return Result; 28227 } 28228 } 28229 } 28230 } 28231 } 28232 28233 // Pattern: (or:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (bitconvert:v2i64 VR128:v4f32:$src1)) 28234 // Emits: (ORPSrm:v2i64 VR128:v4f32:$src1, addr:iPTR:$src2) 28235 // Pattern complexity = 28 cost = 1 size = 3 28236 if ((Subtarget->hasSSE1())) { 28237 SDValue N0 = N.getOperand(0); 28238 if (N0.getOpcode() == ISD::LOAD && 28239 N0.hasOneUse() && 28240 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 28241 SDValue Chain0 = N0.getOperand(0); 28242 if (Predicate_unindexedload(N0.getNode()) && 28243 Predicate_load(N0.getNode()) && 28244 Predicate_memop(N0.getNode())) { 28245 SDValue N01 = N0.getOperand(1); 28246 SDValue CPTmpN01_0; 28247 SDValue CPTmpN01_1; 28248 SDValue CPTmpN01_2; 28249 SDValue CPTmpN01_3; 28250 SDValue CPTmpN01_4; 28251 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 28252 SDValue N1 = N.getOperand(1); 28253 if (N1.getOpcode() == ISD::BIT_CONVERT) { 28254 SDValue N10 = N1.getOperand(0); 28255 if (N10.getNode()->getValueType(0) == MVT::v4f32) { 28256 SDNode *Result = Emit_61(N, X86::ORPSrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 28257 return Result; 28258 } 28259 } 28260 } 28261 } 28262 } 28263 } 28264 if ((Subtarget->hasSSE2())) { 28265 SDValue N0 = N.getOperand(0); 28266 28267 // Pattern: (or:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (bitconvert:v2i64 VR128:v2f64:$src1)) 28268 // Emits: (ORPDrm:v2i64 VR128:v2f64:$src1, addr:iPTR:$src2) 28269 // Pattern complexity = 28 cost = 1 size = 3 28270 if (N0.getOpcode() == ISD::LOAD && 28271 N0.hasOneUse() && 28272 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 28273 SDValue Chain0 = N0.getOperand(0); 28274 if (Predicate_unindexedload(N0.getNode()) && 28275 Predicate_load(N0.getNode()) && 28276 Predicate_memop(N0.getNode())) { 28277 SDValue N01 = N0.getOperand(1); 28278 SDValue CPTmpN01_0; 28279 SDValue CPTmpN01_1; 28280 SDValue CPTmpN01_2; 28281 SDValue CPTmpN01_3; 28282 SDValue CPTmpN01_4; 28283 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 28284 SDValue N1 = N.getOperand(1); 28285 if (N1.getOpcode() == ISD::BIT_CONVERT) { 28286 SDValue N10 = N1.getOperand(0); 28287 if (N10.getNode()->getValueType(0) == MVT::v2f64) { 28288 SDNode *Result = Emit_61(N, X86::ORPDrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 28289 return Result; 28290 } 28291 } 28292 } 28293 } 28294 } 28295 28296 // Pattern: (or:v2i64 VR128:v2i64:$src1, (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 28297 // Emits: (PORrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 28298 // Pattern complexity = 25 cost = 1 size = 3 28299 { 28300 SDValue N1 = N.getOperand(1); 28301 if (N1.getOpcode() == ISD::LOAD && 28302 N1.hasOneUse() && 28303 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 28304 SDValue Chain1 = N1.getOperand(0); 28305 if (Predicate_unindexedload(N1.getNode()) && 28306 Predicate_load(N1.getNode()) && 28307 Predicate_memop(N1.getNode())) { 28308 SDValue N11 = N1.getOperand(1); 28309 SDValue CPTmpN11_0; 28310 SDValue CPTmpN11_1; 28311 SDValue CPTmpN11_2; 28312 SDValue CPTmpN11_3; 28313 SDValue CPTmpN11_4; 28314 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 28315 SDNode *Result = Emit_18(N, X86::PORrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 28316 return Result; 28317 } 28318 } 28319 } 28320 } 28321 28322 // Pattern: (or:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, VR128:v2i64:$src1) 28323 // Emits: (PORrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 28324 // Pattern complexity = 25 cost = 1 size = 3 28325 if (N0.getOpcode() == ISD::LOAD && 28326 N0.hasOneUse() && 28327 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 28328 SDValue Chain0 = N0.getOperand(0); 28329 if (Predicate_unindexedload(N0.getNode()) && 28330 Predicate_load(N0.getNode()) && 28331 Predicate_memop(N0.getNode())) { 28332 SDValue N01 = N0.getOperand(1); 28333 SDValue CPTmpN01_0; 28334 SDValue CPTmpN01_1; 28335 SDValue CPTmpN01_2; 28336 SDValue CPTmpN01_3; 28337 SDValue CPTmpN01_4; 28338 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 28339 SDNode *Result = Emit_19(N, X86::PORrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 28340 return Result; 28341 } 28342 } 28343 } 28344 } 28345 } 28346 28347 // Pattern: (or:v2i64 (bitconvert:v2i64 VR128:v2f64:$src1), (bitconvert:v2i64 VR128:v2f64:$src2)) 28348 // Emits: (ORPDrr:v2i64 VR128:v2f64:$src1, VR128:v2f64:$src2) 28349 // Pattern complexity = 9 cost = 1 size = 3 28350 if ((Subtarget->hasSSE2())) { 28351 SDValue N0 = N.getOperand(0); 28352 if (N0.getOpcode() == ISD::BIT_CONVERT) { 28353 SDValue N00 = N0.getOperand(0); 28354 SDValue N1 = N.getOperand(1); 28355 if (N1.getOpcode() == ISD::BIT_CONVERT) { 28356 SDValue N10 = N1.getOperand(0); 28357 if (N00.getNode()->getValueType(0) == MVT::v2f64 && 28358 N10.getNode()->getValueType(0) == MVT::v2f64) { 28359 SDNode *Result = Emit_58(N, X86::ORPDrr, MVT::v2i64); 28360 return Result; 28361 } 28362 } 28363 } 28364 } 28365 28366 // Pattern: (or:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 28367 // Emits: (ORPSrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 28368 // Pattern complexity = 3 cost = 1 size = 3 28369 if ((Subtarget->hasSSE1())) { 28370 SDNode *Result = Emit_15(N, X86::ORPSrr, MVT::v2i64); 28371 return Result; 28372 } 28373 28374 // Pattern: (or:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 28375 // Emits: (PORrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 28376 // Pattern complexity = 3 cost = 1 size = 3 28377 if ((Subtarget->hasSSE2())) { 28378 SDNode *Result = Emit_15(N, X86::PORrr, MVT::v2i64); 28379 return Result; 28380 } 28381 28382 CannotYetSelect(N); 28383 return NULL; 28384 } 28385 28386 SDNode *Emit_158(const SDValue &N, unsigned Opc0, SDValue &CPTmpN1_0, SDValue &CPTmpN1_1, SDValue &CPTmpN1_2, SDValue &CPTmpN1_3, SDValue &CPTmpN1_4) DISABLE_INLINE { 28387 SDValue Chain = N.getOperand(0); 28388 SDValue N1 = N.getOperand(1); 28389 SDValue N2 = N.getOperand(2); 28390 SDValue N3 = N.getOperand(3); 28391 SDValue Ops0[] = { CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, Chain }; 28392 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 6); 28393 } 28394 SDNode *Select_ISD_PREFETCH(const SDValue &N) { 28395 if ((Subtarget->hasSSE1())) { 28396 SDValue Chain = N.getOperand(0); 28397 SDValue N1 = N.getOperand(1); 28398 SDValue CPTmpN1_0; 28399 SDValue CPTmpN1_1; 28400 SDValue CPTmpN1_2; 28401 SDValue CPTmpN1_3; 28402 SDValue CPTmpN1_4; 28403 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 28404 SDValue N2 = N.getOperand(2); 28405 if (N2.getOpcode() == ISD::Constant) { 28406 SDValue N3 = N.getOperand(3); 28407 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N3); 28408 if (Tmp0) { 28409 int64_t CN1 = Tmp0->getSExtValue(); 28410 28411 // Pattern: (prefetch:isVoid addr:iPTR:$src, (imm:i32), 3:i32) 28412 // Emits: (PREFETCHT0:isVoid addr:iPTR:$src) 28413 // Pattern complexity = 29 cost = 1 size = 3 28414 if (CN1 == INT64_C(3) && 28415 N2.getNode()->getValueType(0) == MVT::i32) { 28416 SDNode *Result = Emit_158(N, X86::PREFETCHT0, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 28417 return Result; 28418 } 28419 28420 // Pattern: (prefetch:isVoid addr:iPTR:$src, (imm:i32), 2:i32) 28421 // Emits: (PREFETCHT1:isVoid addr:iPTR:$src) 28422 // Pattern complexity = 29 cost = 1 size = 3 28423 if (CN1 == INT64_C(2) && 28424 N2.getNode()->getValueType(0) == MVT::i32) { 28425 SDNode *Result = Emit_158(N, X86::PREFETCHT1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 28426 return Result; 28427 } 28428 28429 // Pattern: (prefetch:isVoid addr:iPTR:$src, (imm:i32), 1:i32) 28430 // Emits: (PREFETCHT2:isVoid addr:iPTR:$src) 28431 // Pattern complexity = 29 cost = 1 size = 3 28432 if (CN1 == INT64_C(1) && 28433 N2.getNode()->getValueType(0) == MVT::i32) { 28434 SDNode *Result = Emit_158(N, X86::PREFETCHT2, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 28435 return Result; 28436 } 28437 28438 // Pattern: (prefetch:isVoid addr:iPTR:$src, (imm:i32), 0:i32) 28439 // Emits: (PREFETCHNTA:isVoid addr:iPTR:$src) 28440 // Pattern complexity = 29 cost = 1 size = 3 28441 if (CN1 == INT64_C(0) && 28442 N2.getNode()->getValueType(0) == MVT::i32) { 28443 SDNode *Result = Emit_158(N, X86::PREFETCHNTA, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 28444 return Result; 28445 } 28446 } 28447 } 28448 } 28449 } 28450 28451 CannotYetSelect(N); 28452 return NULL; 28453 } 28454 28455 SDNode *Emit_159(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 28456 SDValue N0 = N.getOperand(0); 28457 SDValue N1 = N.getOperand(1); 28458 SDValue Chain = CurDAG->getEntryNode(); 28459 SDValue InFlag(0, 0); 28460 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::CL, N1, InFlag).getNode(); 28461 Chain = SDValue(ResNode, 0); 28462 InFlag = SDValue(ResNode, 1); 28463 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, InFlag); 28464 } 28465 SDNode *Emit_160(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 28466 SDValue N0 = N.getOperand(0); 28467 SDValue N1 = N.getOperand(1); 28468 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i8); 28469 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, Tmp1); 28470 } 28471 SDNode *Select_ISD_ROTL_i8(const SDValue &N) { 28472 SDValue N0 = N.getOperand(0); 28473 SDValue N1 = N.getOperand(1); 28474 28475 // Pattern: (rotl:i8 GR8:i8:$src1, 1:i8) 28476 // Emits: (ROL8r1:i8 GR8:i8:$src1) 28477 // Pattern complexity = 8 cost = 1 size = 3 28478 { 28479 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 28480 if (Tmp0) { 28481 int64_t CN1 = Tmp0->getSExtValue(); 28482 if (CN1 == INT64_C(1) && 28483 N1.getNode()->getValueType(0) == MVT::i8) { 28484 SDNode *Result = Emit_92(N, X86::ROL8r1, MVT::i8); 28485 return Result; 28486 } 28487 } 28488 } 28489 28490 // Pattern: (rotl:i8 GR8:i8:$src1, (imm:i8):$src2) 28491 // Emits: (ROL8ri:i8 GR8:i8:$src1, (imm:i8):$src2) 28492 // Pattern complexity = 6 cost = 1 size = 3 28493 if (N1.getOpcode() == ISD::Constant && 28494 N1.getNode()->getValueType(0) == MVT::i8) { 28495 SDNode *Result = Emit_160(N, X86::ROL8ri, MVT::i8); 28496 return Result; 28497 } 28498 28499 // Pattern: (rotl:i8 GR8:i8:$src, CL:i8) 28500 // Emits: (ROL8rCL:i8 GR8:i8:$src) 28501 // Pattern complexity = 3 cost = 1 size = 3 28502 if (N1.getNode()->getValueType(0) == MVT::i8) { 28503 SDNode *Result = Emit_159(N, X86::ROL8rCL, MVT::i8); 28504 return Result; 28505 } 28506 28507 CannotYetSelect(N); 28508 return NULL; 28509 } 28510 28511 SDNode *Select_ISD_ROTL_i16(const SDValue &N) { 28512 SDValue N0 = N.getOperand(0); 28513 SDValue N1 = N.getOperand(1); 28514 28515 // Pattern: (rotl:i16 GR16:i16:$src1, 1:i8) 28516 // Emits: (ROL16r1:i16 GR16:i16:$src1) 28517 // Pattern complexity = 8 cost = 1 size = 3 28518 { 28519 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 28520 if (Tmp0) { 28521 int64_t CN1 = Tmp0->getSExtValue(); 28522 if (CN1 == INT64_C(1) && 28523 N1.getNode()->getValueType(0) == MVT::i8) { 28524 SDNode *Result = Emit_92(N, X86::ROL16r1, MVT::i16); 28525 return Result; 28526 } 28527 } 28528 } 28529 28530 // Pattern: (rotl:i16 GR16:i16:$src1, (imm:i8):$src2) 28531 // Emits: (ROL16ri:i16 GR16:i16:$src1, (imm:i8):$src2) 28532 // Pattern complexity = 6 cost = 1 size = 3 28533 if (N1.getOpcode() == ISD::Constant && 28534 N1.getNode()->getValueType(0) == MVT::i8) { 28535 SDNode *Result = Emit_160(N, X86::ROL16ri, MVT::i16); 28536 return Result; 28537 } 28538 28539 // Pattern: (rotl:i16 GR16:i16:$src, CL:i8) 28540 // Emits: (ROL16rCL:i16 GR16:i16:$src) 28541 // Pattern complexity = 3 cost = 1 size = 3 28542 if (N1.getNode()->getValueType(0) == MVT::i8) { 28543 SDNode *Result = Emit_159(N, X86::ROL16rCL, MVT::i16); 28544 return Result; 28545 } 28546 28547 CannotYetSelect(N); 28548 return NULL; 28549 } 28550 28551 SDNode *Select_ISD_ROTL_i32(const SDValue &N) { 28552 SDValue N0 = N.getOperand(0); 28553 SDValue N1 = N.getOperand(1); 28554 28555 // Pattern: (rotl:i32 GR32:i32:$src1, 1:i8) 28556 // Emits: (ROL32r1:i32 GR32:i32:$src1) 28557 // Pattern complexity = 8 cost = 1 size = 3 28558 { 28559 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 28560 if (Tmp0) { 28561 int64_t CN1 = Tmp0->getSExtValue(); 28562 if (CN1 == INT64_C(1) && 28563 N1.getNode()->getValueType(0) == MVT::i8) { 28564 SDNode *Result = Emit_92(N, X86::ROL32r1, MVT::i32); 28565 return Result; 28566 } 28567 } 28568 } 28569 28570 // Pattern: (rotl:i32 GR32:i32:$src1, (imm:i8):$src2) 28571 // Emits: (ROL32ri:i32 GR32:i32:$src1, (imm:i8):$src2) 28572 // Pattern complexity = 6 cost = 1 size = 3 28573 if (N1.getOpcode() == ISD::Constant && 28574 N1.getNode()->getValueType(0) == MVT::i8) { 28575 SDNode *Result = Emit_160(N, X86::ROL32ri, MVT::i32); 28576 return Result; 28577 } 28578 28579 // Pattern: (rotl:i32 GR32:i32:$src, CL:i8) 28580 // Emits: (ROL32rCL:i32 GR32:i32:$src) 28581 // Pattern complexity = 3 cost = 1 size = 3 28582 if (N1.getNode()->getValueType(0) == MVT::i8) { 28583 SDNode *Result = Emit_159(N, X86::ROL32rCL, MVT::i32); 28584 return Result; 28585 } 28586 28587 CannotYetSelect(N); 28588 return NULL; 28589 } 28590 28591 SDNode *Select_ISD_ROTL_i64(const SDValue &N) { 28592 SDValue N0 = N.getOperand(0); 28593 SDValue N1 = N.getOperand(1); 28594 28595 // Pattern: (rotl:i64 GR64:i64:$src1, 1:i8) 28596 // Emits: (ROL64r1:i64 GR64:i64:$src1) 28597 // Pattern complexity = 8 cost = 1 size = 3 28598 { 28599 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 28600 if (Tmp0) { 28601 int64_t CN1 = Tmp0->getSExtValue(); 28602 if (CN1 == INT64_C(1) && 28603 N1.getNode()->getValueType(0) == MVT::i8) { 28604 SDNode *Result = Emit_92(N, X86::ROL64r1, MVT::i64); 28605 return Result; 28606 } 28607 } 28608 } 28609 28610 // Pattern: (rotl:i64 GR64:i64:$src1, (imm:i8):$src2) 28611 // Emits: (ROL64ri:i64 GR64:i64:$src1, (imm:i8):$src2) 28612 // Pattern complexity = 6 cost = 1 size = 3 28613 if (N1.getOpcode() == ISD::Constant && 28614 N1.getNode()->getValueType(0) == MVT::i8) { 28615 SDNode *Result = Emit_160(N, X86::ROL64ri, MVT::i64); 28616 return Result; 28617 } 28618 28619 // Pattern: (rotl:i64 GR64:i64:$src, CL:i8) 28620 // Emits: (ROL64rCL:i64 GR64:i64:$src) 28621 // Pattern complexity = 3 cost = 1 size = 3 28622 if (N1.getNode()->getValueType(0) == MVT::i8) { 28623 SDNode *Result = Emit_159(N, X86::ROL64rCL, MVT::i64); 28624 return Result; 28625 } 28626 28627 CannotYetSelect(N); 28628 return NULL; 28629 } 28630 28631 SDNode *Select_ISD_ROTR_i8(const SDValue &N) { 28632 SDValue N0 = N.getOperand(0); 28633 SDValue N1 = N.getOperand(1); 28634 28635 // Pattern: (rotr:i8 GR8:i8:$src1, 1:i8) 28636 // Emits: (ROR8r1:i8 GR8:i8:$src1) 28637 // Pattern complexity = 8 cost = 1 size = 3 28638 { 28639 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 28640 if (Tmp0) { 28641 int64_t CN1 = Tmp0->getSExtValue(); 28642 if (CN1 == INT64_C(1) && 28643 N1.getNode()->getValueType(0) == MVT::i8) { 28644 SDNode *Result = Emit_92(N, X86::ROR8r1, MVT::i8); 28645 return Result; 28646 } 28647 } 28648 } 28649 28650 // Pattern: (rotr:i8 GR8:i8:$src1, (imm:i8):$src2) 28651 // Emits: (ROR8ri:i8 GR8:i8:$src1, (imm:i8):$src2) 28652 // Pattern complexity = 6 cost = 1 size = 3 28653 if (N1.getOpcode() == ISD::Constant && 28654 N1.getNode()->getValueType(0) == MVT::i8) { 28655 SDNode *Result = Emit_160(N, X86::ROR8ri, MVT::i8); 28656 return Result; 28657 } 28658 28659 // Pattern: (rotr:i8 GR8:i8:$src, CL:i8) 28660 // Emits: (ROR8rCL:i8 GR8:i8:$src) 28661 // Pattern complexity = 3 cost = 1 size = 3 28662 if (N1.getNode()->getValueType(0) == MVT::i8) { 28663 SDNode *Result = Emit_159(N, X86::ROR8rCL, MVT::i8); 28664 return Result; 28665 } 28666 28667 CannotYetSelect(N); 28668 return NULL; 28669 } 28670 28671 SDNode *Select_ISD_ROTR_i16(const SDValue &N) { 28672 SDValue N0 = N.getOperand(0); 28673 SDValue N1 = N.getOperand(1); 28674 28675 // Pattern: (rotr:i16 GR16:i16:$src1, 1:i8) 28676 // Emits: (ROR16r1:i16 GR16:i16:$src1) 28677 // Pattern complexity = 8 cost = 1 size = 3 28678 { 28679 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 28680 if (Tmp0) { 28681 int64_t CN1 = Tmp0->getSExtValue(); 28682 if (CN1 == INT64_C(1) && 28683 N1.getNode()->getValueType(0) == MVT::i8) { 28684 SDNode *Result = Emit_92(N, X86::ROR16r1, MVT::i16); 28685 return Result; 28686 } 28687 } 28688 } 28689 28690 // Pattern: (rotr:i16 GR16:i16:$src1, (imm:i8):$src2) 28691 // Emits: (ROR16ri:i16 GR16:i16:$src1, (imm:i8):$src2) 28692 // Pattern complexity = 6 cost = 1 size = 3 28693 if (N1.getOpcode() == ISD::Constant && 28694 N1.getNode()->getValueType(0) == MVT::i8) { 28695 SDNode *Result = Emit_160(N, X86::ROR16ri, MVT::i16); 28696 return Result; 28697 } 28698 28699 // Pattern: (rotr:i16 GR16:i16:$src, CL:i8) 28700 // Emits: (ROR16rCL:i16 GR16:i16:$src) 28701 // Pattern complexity = 3 cost = 1 size = 3 28702 if (N1.getNode()->getValueType(0) == MVT::i8) { 28703 SDNode *Result = Emit_159(N, X86::ROR16rCL, MVT::i16); 28704 return Result; 28705 } 28706 28707 CannotYetSelect(N); 28708 return NULL; 28709 } 28710 28711 SDNode *Select_ISD_ROTR_i32(const SDValue &N) { 28712 SDValue N0 = N.getOperand(0); 28713 SDValue N1 = N.getOperand(1); 28714 28715 // Pattern: (rotr:i32 GR32:i32:$src1, 1:i8) 28716 // Emits: (ROR32r1:i32 GR32:i32:$src1) 28717 // Pattern complexity = 8 cost = 1 size = 3 28718 { 28719 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 28720 if (Tmp0) { 28721 int64_t CN1 = Tmp0->getSExtValue(); 28722 if (CN1 == INT64_C(1) && 28723 N1.getNode()->getValueType(0) == MVT::i8) { 28724 SDNode *Result = Emit_92(N, X86::ROR32r1, MVT::i32); 28725 return Result; 28726 } 28727 } 28728 } 28729 28730 // Pattern: (rotr:i32 GR32:i32:$src1, (imm:i8):$src2) 28731 // Emits: (ROR32ri:i32 GR32:i32:$src1, (imm:i8):$src2) 28732 // Pattern complexity = 6 cost = 1 size = 3 28733 if (N1.getOpcode() == ISD::Constant && 28734 N1.getNode()->getValueType(0) == MVT::i8) { 28735 SDNode *Result = Emit_160(N, X86::ROR32ri, MVT::i32); 28736 return Result; 28737 } 28738 28739 // Pattern: (rotr:i32 GR32:i32:$src, CL:i8) 28740 // Emits: (ROR32rCL:i32 GR32:i32:$src) 28741 // Pattern complexity = 3 cost = 1 size = 3 28742 if (N1.getNode()->getValueType(0) == MVT::i8) { 28743 SDNode *Result = Emit_159(N, X86::ROR32rCL, MVT::i32); 28744 return Result; 28745 } 28746 28747 CannotYetSelect(N); 28748 return NULL; 28749 } 28750 28751 SDNode *Select_ISD_ROTR_i64(const SDValue &N) { 28752 SDValue N0 = N.getOperand(0); 28753 SDValue N1 = N.getOperand(1); 28754 28755 // Pattern: (rotr:i64 GR64:i64:$src1, 1:i8) 28756 // Emits: (ROR64r1:i64 GR64:i64:$src1) 28757 // Pattern complexity = 8 cost = 1 size = 3 28758 { 28759 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 28760 if (Tmp0) { 28761 int64_t CN1 = Tmp0->getSExtValue(); 28762 if (CN1 == INT64_C(1) && 28763 N1.getNode()->getValueType(0) == MVT::i8) { 28764 SDNode *Result = Emit_92(N, X86::ROR64r1, MVT::i64); 28765 return Result; 28766 } 28767 } 28768 } 28769 28770 // Pattern: (rotr:i64 GR64:i64:$src1, (imm:i8):$src2) 28771 // Emits: (ROR64ri:i64 GR64:i64:$src1, (imm:i8):$src2) 28772 // Pattern complexity = 6 cost = 1 size = 3 28773 if (N1.getOpcode() == ISD::Constant && 28774 N1.getNode()->getValueType(0) == MVT::i8) { 28775 SDNode *Result = Emit_160(N, X86::ROR64ri, MVT::i64); 28776 return Result; 28777 } 28778 28779 // Pattern: (rotr:i64 GR64:i64:$src, CL:i8) 28780 // Emits: (ROR64rCL:i64 GR64:i64:$src) 28781 // Pattern complexity = 3 cost = 1 size = 3 28782 if (N1.getNode()->getValueType(0) == MVT::i8) { 28783 SDNode *Result = Emit_159(N, X86::ROR64rCL, MVT::i64); 28784 return Result; 28785 } 28786 28787 CannotYetSelect(N); 28788 return NULL; 28789 } 28790 28791 SDNode *Select_ISD_SCALAR_TO_VECTOR_v2i32(const SDValue &N) { 28792 28793 // Pattern: (scalar_to_vector:v2i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>) 28794 // Emits: (MMX_MOVD64rm:v2i32 addr:iPTR:$src) 28795 // Pattern complexity = 25 cost = 1 size = 3 28796 if (OptLevel != CodeGenOpt::None && 28797 (Subtarget->hasMMX())) { 28798 SDValue N0 = N.getOperand(0); 28799 if (N0.getOpcode() == ISD::LOAD && 28800 N0.hasOneUse()) { 28801 SDValue Chain0 = N0.getOperand(0); 28802 if (Predicate_unindexedload(N0.getNode()) && 28803 Predicate_loadi32(N0.getNode())) { 28804 SDValue N01 = N0.getOperand(1); 28805 SDValue CPTmpN01_0; 28806 SDValue CPTmpN01_1; 28807 SDValue CPTmpN01_2; 28808 SDValue CPTmpN01_3; 28809 SDValue CPTmpN01_4; 28810 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4) && 28811 N0.getNode()->getValueType(0) == MVT::i32) { 28812 SDNode *Result = Emit_76(N, X86::MMX_MOVD64rm, MVT::v2i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 28813 return Result; 28814 } 28815 } 28816 } 28817 } 28818 28819 // Pattern: (scalar_to_vector:v2i32 GR32:i32:$src) 28820 // Emits: (MMX_MOVD64rr:v2i32 GR32:i32:$src) 28821 // Pattern complexity = 3 cost = 1 size = 3 28822 if ((Subtarget->hasMMX())) { 28823 SDValue N0 = N.getOperand(0); 28824 if (N0.getNode()->getValueType(0) == MVT::i32) { 28825 SDNode *Result = Emit_71(N, X86::MMX_MOVD64rr, MVT::v2i32); 28826 return Result; 28827 } 28828 } 28829 28830 CannotYetSelect(N); 28831 return NULL; 28832 } 28833 28834 SDNode *Select_ISD_SCALAR_TO_VECTOR_v4i32(const SDValue &N) { 28835 28836 // Pattern: (scalar_to_vector:v4i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>) 28837 // Emits: (MOVDI2PDIrm:v4i32 addr:iPTR:$src) 28838 // Pattern complexity = 25 cost = 1 size = 3 28839 if (OptLevel != CodeGenOpt::None && 28840 (Subtarget->hasSSE2())) { 28841 SDValue N0 = N.getOperand(0); 28842 if (N0.getOpcode() == ISD::LOAD && 28843 N0.hasOneUse()) { 28844 SDValue Chain0 = N0.getOperand(0); 28845 if (Predicate_unindexedload(N0.getNode()) && 28846 Predicate_loadi32(N0.getNode())) { 28847 SDValue N01 = N0.getOperand(1); 28848 SDValue CPTmpN01_0; 28849 SDValue CPTmpN01_1; 28850 SDValue CPTmpN01_2; 28851 SDValue CPTmpN01_3; 28852 SDValue CPTmpN01_4; 28853 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4) && 28854 N0.getNode()->getValueType(0) == MVT::i32) { 28855 SDNode *Result = Emit_76(N, X86::MOVDI2PDIrm, MVT::v4i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 28856 return Result; 28857 } 28858 } 28859 } 28860 } 28861 28862 // Pattern: (scalar_to_vector:v4i32 GR32:i32:$src) 28863 // Emits: (MOVDI2PDIrr:v4i32 GR32:i32:$src) 28864 // Pattern complexity = 3 cost = 1 size = 3 28865 if ((Subtarget->hasSSE2())) { 28866 SDValue N0 = N.getOperand(0); 28867 if (N0.getNode()->getValueType(0) == MVT::i32) { 28868 SDNode *Result = Emit_71(N, X86::MOVDI2PDIrr, MVT::v4i32); 28869 return Result; 28870 } 28871 } 28872 28873 CannotYetSelect(N); 28874 return NULL; 28875 } 28876 28877 SDNode *Select_ISD_SCALAR_TO_VECTOR_v1i64(const SDValue &N) { 28878 if ((Subtarget->hasMMX())) { 28879 SDValue N0 = N.getOperand(0); 28880 if (N0.getNode()->getValueType(0) == MVT::i64) { 28881 SDNode *Result = Emit_71(N, X86::MMX_MOVD64rrv164, MVT::v1i64); 28882 return Result; 28883 } 28884 } 28885 28886 CannotYetSelect(N); 28887 return NULL; 28888 } 28889 28890 SDNode *Emit_161(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 28891 SDValue N0 = N.getOperand(0); 28892 SDValue N00 = N0.getOperand(0); 28893 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N00); 28894 } 28895 SDNode *Select_ISD_SCALAR_TO_VECTOR_v2i64(const SDValue &N) { 28896 28897 // Pattern: (scalar_to_vector:v2i64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>) 28898 // Emits: (MOVQI2PQIrm:v2i64 addr:iPTR:$src) 28899 // Pattern complexity = 25 cost = 1 size = 3 28900 if (OptLevel != CodeGenOpt::None && 28901 (Subtarget->hasSSE2())) { 28902 SDValue N0 = N.getOperand(0); 28903 if (N0.getOpcode() == ISD::LOAD && 28904 N0.hasOneUse()) { 28905 SDValue Chain0 = N0.getOperand(0); 28906 if (Predicate_unindexedload(N0.getNode()) && 28907 Predicate_load(N0.getNode()) && 28908 Predicate_loadi64(N0.getNode())) { 28909 SDValue N01 = N0.getOperand(1); 28910 SDValue CPTmpN01_0; 28911 SDValue CPTmpN01_1; 28912 SDValue CPTmpN01_2; 28913 SDValue CPTmpN01_3; 28914 SDValue CPTmpN01_4; 28915 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4) && 28916 N0.getNode()->getValueType(0) == MVT::i64) { 28917 SDNode *Result = Emit_76(N, X86::MOVQI2PQIrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 28918 return Result; 28919 } 28920 } 28921 } 28922 } 28923 { 28924 SDValue N0 = N.getOperand(0); 28925 if (N0.getOpcode() == ISD::BIT_CONVERT) { 28926 SDValue N00 = N0.getOperand(0); 28927 if (N0.getNode()->getValueType(0) == MVT::i64) { 28928 28929 // Pattern: (scalar_to_vector:v2i64 (bitconvert:i64 VR64:v8i8:$src)) 28930 // Emits: (MMX_MOVQ2DQrr:v2i64 VR64:v8i8:$src) 28931 // Pattern complexity = 6 cost = 1 size = 3 28932 if (N00.getNode()->getValueType(0) == MVT::v8i8) { 28933 SDNode *Result = Emit_161(N, X86::MMX_MOVQ2DQrr, MVT::v2i64); 28934 return Result; 28935 } 28936 28937 // Pattern: (scalar_to_vector:v2i64 (bitconvert:i64 VR64:v4i16:$src)) 28938 // Emits: (MMX_MOVQ2DQrr:v2i64 VR64:v8i8:$src) 28939 // Pattern complexity = 6 cost = 1 size = 3 28940 if (N00.getNode()->getValueType(0) == MVT::v4i16) { 28941 SDNode *Result = Emit_161(N, X86::MMX_MOVQ2DQrr, MVT::v2i64); 28942 return Result; 28943 } 28944 28945 // Pattern: (scalar_to_vector:v2i64 (bitconvert:i64 VR64:v2i32:$src)) 28946 // Emits: (MMX_MOVQ2DQrr:v2i64 VR64:v8i8:$src) 28947 // Pattern complexity = 6 cost = 1 size = 3 28948 if (N00.getNode()->getValueType(0) == MVT::v2i32) { 28949 SDNode *Result = Emit_161(N, X86::MMX_MOVQ2DQrr, MVT::v2i64); 28950 return Result; 28951 } 28952 28953 // Pattern: (scalar_to_vector:v2i64 (bitconvert:i64 VR64:v1i64:$src)) 28954 // Emits: (MMX_MOVQ2DQrr:v2i64 VR64:v8i8:$src) 28955 // Pattern complexity = 6 cost = 1 size = 3 28956 if (N00.getNode()->getValueType(0) == MVT::v1i64) { 28957 SDNode *Result = Emit_161(N, X86::MMX_MOVQ2DQrr, MVT::v2i64); 28958 return Result; 28959 } 28960 } 28961 } 28962 } 28963 28964 // Pattern: (scalar_to_vector:v2i64 GR64:i64:$src) 28965 // Emits: (MOV64toPQIrr:v2i64 GR64:i64:$src) 28966 // Pattern complexity = 3 cost = 1 size = 3 28967 if ((Subtarget->hasSSE2())) { 28968 SDValue N0 = N.getOperand(0); 28969 if (N0.getNode()->getValueType(0) == MVT::i64) { 28970 SDNode *Result = Emit_71(N, X86::MOV64toPQIrr, MVT::v2i64); 28971 return Result; 28972 } 28973 } 28974 28975 CannotYetSelect(N); 28976 return NULL; 28977 } 28978 28979 SDNode *Select_ISD_SCALAR_TO_VECTOR_v4f32(const SDValue &N) { 28980 28981 // Pattern: (scalar_to_vector:v4f32 (ld:f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf32>>) 28982 // Emits: (MOVSS2PSrm:v4f32 addr:iPTR:$src) 28983 // Pattern complexity = 25 cost = 1 size = 3 28984 if (OptLevel != CodeGenOpt::None && 28985 (Subtarget->hasSSE1())) { 28986 SDValue N0 = N.getOperand(0); 28987 if (N0.getOpcode() == ISD::LOAD && 28988 N0.hasOneUse()) { 28989 SDValue Chain0 = N0.getOperand(0); 28990 if (Predicate_unindexedload(N0.getNode()) && 28991 Predicate_load(N0.getNode()) && 28992 Predicate_loadf32(N0.getNode())) { 28993 SDValue N01 = N0.getOperand(1); 28994 SDValue CPTmpN01_0; 28995 SDValue CPTmpN01_1; 28996 SDValue CPTmpN01_2; 28997 SDValue CPTmpN01_3; 28998 SDValue CPTmpN01_4; 28999 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4) && 29000 N0.getNode()->getValueType(0) == MVT::f32) { 29001 SDNode *Result = Emit_76(N, X86::MOVSS2PSrm, MVT::v4f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 29002 return Result; 29003 } 29004 } 29005 } 29006 } 29007 29008 // Pattern: (scalar_to_vector:v4f32 FR32:f32:$src) 29009 // Emits: (MOVSS2PSrr:v4f32 FR32:f32:$src) 29010 // Pattern complexity = 3 cost = 1 size = 3 29011 if ((Subtarget->hasSSE1())) { 29012 SDValue N0 = N.getOperand(0); 29013 if (N0.getNode()->getValueType(0) == MVT::f32) { 29014 SDNode *Result = Emit_71(N, X86::MOVSS2PSrr, MVT::v4f32); 29015 return Result; 29016 } 29017 } 29018 29019 CannotYetSelect(N); 29020 return NULL; 29021 } 29022 29023 SDNode *Select_ISD_SCALAR_TO_VECTOR_v2f64(const SDValue &N) { 29024 29025 // Pattern: (scalar_to_vector:v2f64 (ld:f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>) 29026 // Emits: (MOVSD2PDrm:v2f64 addr:iPTR:$src) 29027 // Pattern complexity = 25 cost = 1 size = 3 29028 if (OptLevel != CodeGenOpt::None && 29029 (Subtarget->hasSSE2())) { 29030 SDValue N0 = N.getOperand(0); 29031 if (N0.getOpcode() == ISD::LOAD && 29032 N0.hasOneUse()) { 29033 SDValue Chain0 = N0.getOperand(0); 29034 if (Predicate_unindexedload(N0.getNode()) && 29035 Predicate_load(N0.getNode()) && 29036 Predicate_loadf64(N0.getNode())) { 29037 SDValue N01 = N0.getOperand(1); 29038 SDValue CPTmpN01_0; 29039 SDValue CPTmpN01_1; 29040 SDValue CPTmpN01_2; 29041 SDValue CPTmpN01_3; 29042 SDValue CPTmpN01_4; 29043 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4) && 29044 N0.getNode()->getValueType(0) == MVT::f64) { 29045 SDNode *Result = Emit_76(N, X86::MOVSD2PDrm, MVT::v2f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 29046 return Result; 29047 } 29048 } 29049 } 29050 } 29051 29052 // Pattern: (scalar_to_vector:v2f64 FR64:f64:$src) 29053 // Emits: (MOVSD2PDrr:v2f64 FR64:f64:$src) 29054 // Pattern complexity = 3 cost = 1 size = 3 29055 if ((Subtarget->hasSSE2())) { 29056 SDValue N0 = N.getOperand(0); 29057 if (N0.getNode()->getValueType(0) == MVT::f64) { 29058 SDNode *Result = Emit_71(N, X86::MOVSD2PDrr, MVT::v2f64); 29059 return Result; 29060 } 29061 } 29062 29063 CannotYetSelect(N); 29064 return NULL; 29065 } 29066 29067 SDNode *Emit_162(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 29068 SDValue N0 = N.getOperand(0); 29069 SDValue N1 = N.getOperand(1); 29070 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, N0); 29071 } 29072 SDNode *Emit_163(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 29073 SDValue N0 = N.getOperand(0); 29074 SDValue N1 = N.getOperand(1); 29075 SDValue N10 = N1.getOperand(0); 29076 SDValue N11 = N1.getOperand(1); 29077 SDValue Chain = CurDAG->getEntryNode(); 29078 SDValue InFlag(0, 0); 29079 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N1.getDebugLoc(), X86::CL, N10, InFlag).getNode(); 29080 Chain = SDValue(ResNode, 0); 29081 InFlag = SDValue(ResNode, 1); 29082 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, InFlag); 29083 } 29084 SDNode *Select_ISD_SHL_i8(const SDValue &N) { 29085 SDValue N0 = N.getOperand(0); 29086 SDValue N1 = N.getOperand(1); 29087 29088 // Pattern: (shl:i8 GR8:i8:$src1, (and:i8 CL:i8:$amt, 31:i8)) 29089 // Emits: (SHL8rCL:i8 GR8:i8:$src1) 29090 // Pattern complexity = 11 cost = 1 size = 3 29091 if (N1.getOpcode() == ISD::AND) { 29092 SDValue N10 = N1.getOperand(0); 29093 SDValue N11 = N1.getOperand(1); 29094 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 29095 if (Tmp0 && 29096 CheckAndMask(N10, Tmp0, INT64_C(31)) && 29097 N1.getNode()->getValueType(0) == MVT::i8) { 29098 SDNode *Result = Emit_163(N, X86::SHL8rCL, MVT::i8); 29099 return Result; 29100 } 29101 } 29102 29103 // Pattern: (shl:i8 GR8:i8:$src1, 1:i8) 29104 // Emits: (ADD8rr:i8 GR8:i8:$src1, GR8:i8:$src1) 29105 // Pattern complexity = 8 cost = 1 size = 3 29106 { 29107 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 29108 if (Tmp0) { 29109 int64_t CN1 = Tmp0->getSExtValue(); 29110 if (CN1 == INT64_C(1) && 29111 N1.getNode()->getValueType(0) == MVT::i8) { 29112 SDNode *Result = Emit_162(N, X86::ADD8rr, MVT::i8); 29113 return Result; 29114 } 29115 } 29116 } 29117 29118 // Pattern: (shl:i8 GR8:i8:$src1, (imm:i8):$src2) 29119 // Emits: (SHL8ri:i8 GR8:i8:$src1, (imm:i8):$src2) 29120 // Pattern complexity = 6 cost = 1 size = 3 29121 if (N1.getOpcode() == ISD::Constant && 29122 N1.getNode()->getValueType(0) == MVT::i8) { 29123 SDNode *Result = Emit_160(N, X86::SHL8ri, MVT::i8); 29124 return Result; 29125 } 29126 29127 // Pattern: (shl:i8 GR8:i8:$src, CL:i8) 29128 // Emits: (SHL8rCL:i8 GR8:i8:$src) 29129 // Pattern complexity = 3 cost = 1 size = 3 29130 if (N1.getNode()->getValueType(0) == MVT::i8) { 29131 SDNode *Result = Emit_159(N, X86::SHL8rCL, MVT::i8); 29132 return Result; 29133 } 29134 29135 CannotYetSelect(N); 29136 return NULL; 29137 } 29138 29139 SDNode *Select_ISD_SHL_i16(const SDValue &N) { 29140 SDValue N0 = N.getOperand(0); 29141 SDValue N1 = N.getOperand(1); 29142 29143 // Pattern: (shl:i16 GR16:i16:$src1, (and:i8 CL:i8:$amt, 31:i8)) 29144 // Emits: (SHL16rCL:i16 GR16:i16:$src1) 29145 // Pattern complexity = 11 cost = 1 size = 3 29146 if (N1.getOpcode() == ISD::AND) { 29147 SDValue N10 = N1.getOperand(0); 29148 SDValue N11 = N1.getOperand(1); 29149 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 29150 if (Tmp0 && 29151 CheckAndMask(N10, Tmp0, INT64_C(31)) && 29152 N1.getNode()->getValueType(0) == MVT::i8) { 29153 SDNode *Result = Emit_163(N, X86::SHL16rCL, MVT::i16); 29154 return Result; 29155 } 29156 } 29157 29158 // Pattern: (shl:i16 GR16:i16:$src1, 1:i8) 29159 // Emits: (ADD16rr:i16 GR16:i16:$src1, GR16:i16:$src1) 29160 // Pattern complexity = 8 cost = 1 size = 3 29161 { 29162 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 29163 if (Tmp0) { 29164 int64_t CN1 = Tmp0->getSExtValue(); 29165 if (CN1 == INT64_C(1) && 29166 N1.getNode()->getValueType(0) == MVT::i8) { 29167 SDNode *Result = Emit_162(N, X86::ADD16rr, MVT::i16); 29168 return Result; 29169 } 29170 } 29171 } 29172 29173 // Pattern: (shl:i16 GR16:i16:$src1, (imm:i8):$src2) 29174 // Emits: (SHL16ri:i16 GR16:i16:$src1, (imm:i8):$src2) 29175 // Pattern complexity = 6 cost = 1 size = 3 29176 if (N1.getOpcode() == ISD::Constant && 29177 N1.getNode()->getValueType(0) == MVT::i8) { 29178 SDNode *Result = Emit_160(N, X86::SHL16ri, MVT::i16); 29179 return Result; 29180 } 29181 29182 // Pattern: (shl:i16 GR16:i16:$src, CL:i8) 29183 // Emits: (SHL16rCL:i16 GR16:i16:$src) 29184 // Pattern complexity = 3 cost = 1 size = 3 29185 if (N1.getNode()->getValueType(0) == MVT::i8) { 29186 SDNode *Result = Emit_159(N, X86::SHL16rCL, MVT::i16); 29187 return Result; 29188 } 29189 29190 CannotYetSelect(N); 29191 return NULL; 29192 } 29193 29194 SDNode *Select_ISD_SHL_i32(const SDValue &N) { 29195 29196 // Pattern: lea32addr:i32:$src 29197 // Emits: (LEA64_32r:i32 lea32addr:i32:$src) 29198 // Pattern complexity = 15 cost = 1 size = 3 29199 if ((Subtarget->is64Bit())) { 29200 SDValue CPTmpN_0; 29201 SDValue CPTmpN_1; 29202 SDValue CPTmpN_2; 29203 SDValue CPTmpN_3; 29204 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 29205 SDNode *Result = Emit_7(N, X86::LEA64_32r, MVT::i32, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 29206 return Result; 29207 } 29208 } 29209 29210 // Pattern: lea32addr:i32:$src 29211 // Emits: (LEA32r:i32 lea32addr:i32:$src) 29212 // Pattern complexity = 15 cost = 1 size = 3 29213 if ((!Subtarget->is64Bit())) { 29214 SDValue CPTmpN_0; 29215 SDValue CPTmpN_1; 29216 SDValue CPTmpN_2; 29217 SDValue CPTmpN_3; 29218 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 29219 SDNode *Result = Emit_7(N, X86::LEA32r, MVT::i32, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 29220 return Result; 29221 } 29222 } 29223 SDValue N0 = N.getOperand(0); 29224 SDValue N1 = N.getOperand(1); 29225 29226 // Pattern: (shl:i32 GR32:i32:$src1, (and:i8 CL:i8:$amt, 31:i8)) 29227 // Emits: (SHL32rCL:i32 GR32:i32:$src1) 29228 // Pattern complexity = 11 cost = 1 size = 3 29229 if (N1.getOpcode() == ISD::AND) { 29230 SDValue N10 = N1.getOperand(0); 29231 SDValue N11 = N1.getOperand(1); 29232 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 29233 if (Tmp0 && 29234 CheckAndMask(N10, Tmp0, INT64_C(31)) && 29235 N1.getNode()->getValueType(0) == MVT::i8) { 29236 SDNode *Result = Emit_163(N, X86::SHL32rCL, MVT::i32); 29237 return Result; 29238 } 29239 } 29240 29241 // Pattern: (shl:i32 GR32:i32:$src1, 1:i8) 29242 // Emits: (ADD32rr:i32 GR32:i32:$src1, GR32:i32:$src1) 29243 // Pattern complexity = 8 cost = 1 size = 3 29244 { 29245 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 29246 if (Tmp0) { 29247 int64_t CN1 = Tmp0->getSExtValue(); 29248 if (CN1 == INT64_C(1) && 29249 N1.getNode()->getValueType(0) == MVT::i8) { 29250 SDNode *Result = Emit_162(N, X86::ADD32rr, MVT::i32); 29251 return Result; 29252 } 29253 } 29254 } 29255 29256 // Pattern: (shl:i32 GR32:i32:$src1, (imm:i8):$src2) 29257 // Emits: (SHL32ri:i32 GR32:i32:$src1, (imm:i8):$src2) 29258 // Pattern complexity = 6 cost = 1 size = 3 29259 if (N1.getOpcode() == ISD::Constant && 29260 N1.getNode()->getValueType(0) == MVT::i8) { 29261 SDNode *Result = Emit_160(N, X86::SHL32ri, MVT::i32); 29262 return Result; 29263 } 29264 29265 // Pattern: (shl:i32 GR32:i32:$src, CL:i8) 29266 // Emits: (SHL32rCL:i32 GR32:i32:$src) 29267 // Pattern complexity = 3 cost = 1 size = 3 29268 if (N1.getNode()->getValueType(0) == MVT::i8) { 29269 SDNode *Result = Emit_159(N, X86::SHL32rCL, MVT::i32); 29270 return Result; 29271 } 29272 29273 CannotYetSelect(N); 29274 return NULL; 29275 } 29276 29277 SDNode *Select_ISD_SHL_i64(const SDValue &N) { 29278 29279 // Pattern: lea64addr:i64:$src 29280 // Emits: (LEA64r:i64 lea64addr:i64:$src) 29281 // Pattern complexity = 15 cost = 1 size = 3 29282 { 29283 SDValue CPTmpN_0; 29284 SDValue CPTmpN_1; 29285 SDValue CPTmpN_2; 29286 SDValue CPTmpN_3; 29287 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 29288 SDNode *Result = Emit_7(N, X86::LEA64r, MVT::i64, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 29289 return Result; 29290 } 29291 } 29292 SDValue N0 = N.getOperand(0); 29293 SDValue N1 = N.getOperand(1); 29294 29295 // Pattern: (shl:i64 GR64:i64:$src1, (and:i8 CL:i8:$amt, 63:i8)) 29296 // Emits: (SHL64rCL:i64 GR64:i64:$src1) 29297 // Pattern complexity = 11 cost = 1 size = 3 29298 if (N1.getOpcode() == ISD::AND) { 29299 SDValue N10 = N1.getOperand(0); 29300 SDValue N11 = N1.getOperand(1); 29301 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 29302 if (Tmp0 && 29303 CheckAndMask(N10, Tmp0, INT64_C(63)) && 29304 N1.getNode()->getValueType(0) == MVT::i8) { 29305 SDNode *Result = Emit_163(N, X86::SHL64rCL, MVT::i64); 29306 return Result; 29307 } 29308 } 29309 29310 // Pattern: (shl:i64 GR64:i64:$src1, 1:i8) 29311 // Emits: (ADD64rr:i64 GR64:i64:$src1, GR64:i64:$src1) 29312 // Pattern complexity = 8 cost = 1 size = 3 29313 { 29314 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 29315 if (Tmp0) { 29316 int64_t CN1 = Tmp0->getSExtValue(); 29317 if (CN1 == INT64_C(1) && 29318 N1.getNode()->getValueType(0) == MVT::i8) { 29319 SDNode *Result = Emit_162(N, X86::ADD64rr, MVT::i64); 29320 return Result; 29321 } 29322 } 29323 } 29324 29325 // Pattern: (shl:i64 GR64:i64:$src1, (imm:i8):$src2) 29326 // Emits: (SHL64ri:i64 GR64:i64:$src1, (imm:i8):$src2) 29327 // Pattern complexity = 6 cost = 1 size = 3 29328 if (N1.getOpcode() == ISD::Constant && 29329 N1.getNode()->getValueType(0) == MVT::i8) { 29330 SDNode *Result = Emit_160(N, X86::SHL64ri, MVT::i64); 29331 return Result; 29332 } 29333 29334 // Pattern: (shl:i64 GR64:i64:$src, CL:i8) 29335 // Emits: (SHL64rCL:i64 GR64:i64:$src) 29336 // Pattern complexity = 3 cost = 1 size = 3 29337 if (N1.getNode()->getValueType(0) == MVT::i8) { 29338 SDNode *Result = Emit_159(N, X86::SHL64rCL, MVT::i64); 29339 return Result; 29340 } 29341 29342 CannotYetSelect(N); 29343 return NULL; 29344 } 29345 29346 SDNode *Select_ISD_SIGN_EXTEND_i16(const SDValue &N) { 29347 SDValue N0 = N.getOperand(0); 29348 if (N0.getNode()->getValueType(0) == MVT::i8) { 29349 SDNode *Result = Emit_71(N, X86::MOVSX16rr8, MVT::i16); 29350 return Result; 29351 } 29352 29353 CannotYetSelect(N); 29354 return NULL; 29355 } 29356 29357 SDNode *Select_ISD_SIGN_EXTEND_i32(const SDValue &N) { 29358 SDValue N0 = N.getOperand(0); 29359 29360 // Pattern: (sext:i32 GR8:i8:$src) 29361 // Emits: (MOVSX32rr8:i32 GR8:i8:$src) 29362 // Pattern complexity = 3 cost = 1 size = 3 29363 if (N0.getNode()->getValueType(0) == MVT::i8) { 29364 SDNode *Result = Emit_71(N, X86::MOVSX32rr8, MVT::i32); 29365 return Result; 29366 } 29367 29368 // Pattern: (sext:i32 GR16:i16:$src) 29369 // Emits: (MOVSX32rr16:i32 GR16:i16:$src) 29370 // Pattern complexity = 3 cost = 1 size = 3 29371 if (N0.getNode()->getValueType(0) == MVT::i16) { 29372 SDNode *Result = Emit_71(N, X86::MOVSX32rr16, MVT::i32); 29373 return Result; 29374 } 29375 29376 CannotYetSelect(N); 29377 return NULL; 29378 } 29379 29380 SDNode *Select_ISD_SIGN_EXTEND_i64(const SDValue &N) { 29381 SDValue N0 = N.getOperand(0); 29382 29383 // Pattern: (sext:i64 GR8:i8:$src) 29384 // Emits: (MOVSX64rr8:i64 GR8:i8:$src) 29385 // Pattern complexity = 3 cost = 1 size = 3 29386 if (N0.getNode()->getValueType(0) == MVT::i8) { 29387 SDNode *Result = Emit_71(N, X86::MOVSX64rr8, MVT::i64); 29388 return Result; 29389 } 29390 29391 // Pattern: (sext:i64 GR16:i16:$src) 29392 // Emits: (MOVSX64rr16:i64 GR16:i16:$src) 29393 // Pattern complexity = 3 cost = 1 size = 3 29394 if (N0.getNode()->getValueType(0) == MVT::i16) { 29395 SDNode *Result = Emit_71(N, X86::MOVSX64rr16, MVT::i64); 29396 return Result; 29397 } 29398 29399 // Pattern: (sext:i64 GR32:i32:$src) 29400 // Emits: (MOVSX64rr32:i64 GR32:i32:$src) 29401 // Pattern complexity = 3 cost = 1 size = 3 29402 if (N0.getNode()->getValueType(0) == MVT::i32) { 29403 SDNode *Result = Emit_71(N, X86::MOVSX64rr32, MVT::i64); 29404 return Result; 29405 } 29406 29407 CannotYetSelect(N); 29408 return NULL; 29409 } 29410 29411 SDNode *Emit_164(const SDValue &N, unsigned Opc0, unsigned Opc1, unsigned Opc2, EVT VT0, EVT VT1, EVT VT2) DISABLE_INLINE { 29412 SDValue N0 = N.getOperand(0); 29413 SDValue N1 = N.getOperand(1); 29414 SDValue Tmp1 = CurDAG->getTargetConstant(X86::GR16_ABCDRegClassID, MVT::i32); 29415 SDValue Tmp2(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N0, Tmp1), 0); 29416 SDValue Tmp3 = CurDAG->getTargetConstant(0x1ULL, MVT::i32); 29417 SDValue Tmp4(CurDAG->getTargetNode(Opc1, N.getDebugLoc(), VT1, Tmp2, Tmp3), 0); 29418 return CurDAG->SelectNodeTo(N.getNode(), Opc2, VT2, Tmp4); 29419 } 29420 SDNode *Emit_165(const SDValue &N, unsigned Opc0, unsigned Opc1, EVT VT0, EVT VT1) DISABLE_INLINE { 29421 SDValue N0 = N.getOperand(0); 29422 SDValue N1 = N.getOperand(1); 29423 SDValue Tmp1 = CurDAG->getTargetConstant(0x1ULL, MVT::i32); 29424 SDValue Tmp2(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N0, Tmp1), 0); 29425 return CurDAG->SelectNodeTo(N.getNode(), Opc1, VT1, Tmp2); 29426 } 29427 SDNode *Select_ISD_SIGN_EXTEND_INREG_i16(const SDValue &N) { 29428 29429 // Pattern: (sext_inreg:i16 GR16:i16:$src, i8:Other) 29430 // Emits: (MOVSX16rr8:i16 (EXTRACT_SUBREG:i8 GR16:i16:$src, 1:i32)) 29431 // Pattern complexity = 3 cost = 2 size = 3 29432 if ((Subtarget->is64Bit())) { 29433 SDValue N0 = N.getOperand(0); 29434 SDValue N1 = N.getOperand(1); 29435 if (cast<VTSDNode>(N1)->getVT() == MVT::i8) { 29436 SDNode *Result = Emit_165(N, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVSX16rr8, MVT::i8, MVT::i16); 29437 return Result; 29438 } 29439 } 29440 29441 // Pattern: (sext_inreg:i16 GR16:i16:$src, i8:Other) 29442 // Emits: (MOVSX16rr8:i16 (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i16 GR16:i16:$src, GR16_ABCD:i16), 1:i32)) 29443 // Pattern complexity = 3 cost = 3 size = 3 29444 if ((!Subtarget->is64Bit())) { 29445 SDValue N0 = N.getOperand(0); 29446 SDValue N1 = N.getOperand(1); 29447 if (cast<VTSDNode>(N1)->getVT() == MVT::i8) { 29448 SDNode *Result = Emit_164(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVSX16rr8, MVT::i16, MVT::i8, MVT::i16); 29449 return Result; 29450 } 29451 } 29452 29453 CannotYetSelect(N); 29454 return NULL; 29455 } 29456 29457 SDNode *Emit_166(const SDValue &N, unsigned Opc0, unsigned Opc1, EVT VT0, EVT VT1) DISABLE_INLINE { 29458 SDValue N0 = N.getOperand(0); 29459 SDValue N1 = N.getOperand(1); 29460 SDValue Tmp1 = CurDAG->getTargetConstant(0x3ULL, MVT::i32); 29461 SDValue Tmp2(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N0, Tmp1), 0); 29462 return CurDAG->SelectNodeTo(N.getNode(), Opc1, VT1, Tmp2); 29463 } 29464 SDNode *Emit_167(const SDValue &N, unsigned Opc0, unsigned Opc1, unsigned Opc2, EVT VT0, EVT VT1, EVT VT2) DISABLE_INLINE { 29465 SDValue N0 = N.getOperand(0); 29466 SDValue N1 = N.getOperand(1); 29467 SDValue Tmp1 = CurDAG->getTargetConstant(X86::GR32_ABCDRegClassID, MVT::i32); 29468 SDValue Tmp2(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N0, Tmp1), 0); 29469 SDValue Tmp3 = CurDAG->getTargetConstant(0x1ULL, MVT::i32); 29470 SDValue Tmp4(CurDAG->getTargetNode(Opc1, N.getDebugLoc(), VT1, Tmp2, Tmp3), 0); 29471 return CurDAG->SelectNodeTo(N.getNode(), Opc2, VT2, Tmp4); 29472 } 29473 SDNode *Select_ISD_SIGN_EXTEND_INREG_i32(const SDValue &N) { 29474 29475 // Pattern: (sext_inreg:i32 GR32:i32:$src, i16:Other) 29476 // Emits: (MOVSX32rr16:i32 (EXTRACT_SUBREG:i16 GR32:i32:$src, 3:i32)) 29477 // Pattern complexity = 3 cost = 2 size = 3 29478 { 29479 SDValue N0 = N.getOperand(0); 29480 SDValue N1 = N.getOperand(1); 29481 if (cast<VTSDNode>(N1)->getVT() == MVT::i16) { 29482 SDNode *Result = Emit_166(N, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVSX32rr16, MVT::i16, MVT::i32); 29483 return Result; 29484 } 29485 } 29486 29487 // Pattern: (sext_inreg:i32 GR32:i32:$src, i8:Other) 29488 // Emits: (MOVSX32rr8:i32 (EXTRACT_SUBREG:i8 GR32:i32:$src, 1:i32)) 29489 // Pattern complexity = 3 cost = 2 size = 3 29490 if ((Subtarget->is64Bit())) { 29491 SDValue N0 = N.getOperand(0); 29492 SDValue N1 = N.getOperand(1); 29493 if (cast<VTSDNode>(N1)->getVT() == MVT::i8) { 29494 SDNode *Result = Emit_165(N, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVSX32rr8, MVT::i8, MVT::i32); 29495 return Result; 29496 } 29497 } 29498 29499 // Pattern: (sext_inreg:i32 GR32:i32:$src, i8:Other) 29500 // Emits: (MOVSX32rr8:i32 (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i32 GR32:i32:$src, GR32_ABCD:i32), 1:i32)) 29501 // Pattern complexity = 3 cost = 3 size = 3 29502 if ((!Subtarget->is64Bit())) { 29503 SDValue N0 = N.getOperand(0); 29504 SDValue N1 = N.getOperand(1); 29505 if (cast<VTSDNode>(N1)->getVT() == MVT::i8) { 29506 SDNode *Result = Emit_167(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVSX32rr8, MVT::i32, MVT::i8, MVT::i32); 29507 return Result; 29508 } 29509 } 29510 29511 CannotYetSelect(N); 29512 return NULL; 29513 } 29514 29515 SDNode *Emit_168(const SDValue &N, unsigned Opc0, unsigned Opc1, EVT VT0, EVT VT1) DISABLE_INLINE { 29516 SDValue N0 = N.getOperand(0); 29517 SDValue N1 = N.getOperand(1); 29518 SDValue Tmp1 = CurDAG->getTargetConstant(0x4ULL, MVT::i32); 29519 SDValue Tmp2(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N0, Tmp1), 0); 29520 return CurDAG->SelectNodeTo(N.getNode(), Opc1, VT1, Tmp2); 29521 } 29522 SDNode *Select_ISD_SIGN_EXTEND_INREG_i64(const SDValue &N) { 29523 SDValue N0 = N.getOperand(0); 29524 SDValue N1 = N.getOperand(1); 29525 29526 // Pattern: (sext_inreg:i64 GR64:i64:$src, i32:Other) 29527 // Emits: (MOVSX64rr32:i64 (EXTRACT_SUBREG:i32 GR64:i64:$src, 4:i32)) 29528 // Pattern complexity = 3 cost = 2 size = 3 29529 if (cast<VTSDNode>(N1)->getVT() == MVT::i32) { 29530 SDNode *Result = Emit_168(N, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVSX64rr32, MVT::i32, MVT::i64); 29531 return Result; 29532 } 29533 29534 // Pattern: (sext_inreg:i64 GR64:i64:$src, i16:Other) 29535 // Emits: (MOVSX64rr16:i64 (EXTRACT_SUBREG:i16 GR64:i64:$src, 3:i32)) 29536 // Pattern complexity = 3 cost = 2 size = 3 29537 if (cast<VTSDNode>(N1)->getVT() == MVT::i16) { 29538 SDNode *Result = Emit_166(N, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVSX64rr16, MVT::i16, MVT::i64); 29539 return Result; 29540 } 29541 29542 // Pattern: (sext_inreg:i64 GR64:i64:$src, i8:Other) 29543 // Emits: (MOVSX64rr8:i64 (EXTRACT_SUBREG:i8 GR64:i64:$src, 1:i32)) 29544 // Pattern complexity = 3 cost = 2 size = 3 29545 if (cast<VTSDNode>(N1)->getVT() == MVT::i8) { 29546 SDNode *Result = Emit_165(N, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVSX64rr8, MVT::i8, MVT::i64); 29547 return Result; 29548 } 29549 29550 CannotYetSelect(N); 29551 return NULL; 29552 } 29553 29554 SDNode *Select_ISD_SINT_TO_FP_f32(const SDValue &N) { 29555 if (OptLevel != CodeGenOpt::None && 29556 (Subtarget->hasSSE1())) { 29557 SDValue N0 = N.getOperand(0); 29558 if (N0.getOpcode() == ISD::LOAD && 29559 N0.hasOneUse()) { 29560 SDValue Chain0 = N0.getOperand(0); 29561 if (Predicate_unindexedload(N0.getNode())) { 29562 29563 // Pattern: (sint_to_fp:f32 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>) 29564 // Emits: (CVTSI2SS64rm:f32 addr:iPTR:$src) 29565 // Pattern complexity = 25 cost = 1 size = 3 29566 if (Predicate_load(N0.getNode()) && 29567 Predicate_loadi64(N0.getNode())) { 29568 SDValue N01 = N0.getOperand(1); 29569 SDValue CPTmpN01_0; 29570 SDValue CPTmpN01_1; 29571 SDValue CPTmpN01_2; 29572 SDValue CPTmpN01_3; 29573 SDValue CPTmpN01_4; 29574 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4) && 29575 N0.getNode()->getValueType(0) == MVT::i64) { 29576 SDNode *Result = Emit_76(N, X86::CVTSI2SS64rm, MVT::f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 29577 return Result; 29578 } 29579 } 29580 29581 // Pattern: (sint_to_fp:f32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>) 29582 // Emits: (CVTSI2SSrm:f32 addr:iPTR:$src) 29583 // Pattern complexity = 25 cost = 1 size = 3 29584 if (Predicate_loadi32(N0.getNode())) { 29585 SDValue N01 = N0.getOperand(1); 29586 SDValue CPTmpN01_0; 29587 SDValue CPTmpN01_1; 29588 SDValue CPTmpN01_2; 29589 SDValue CPTmpN01_3; 29590 SDValue CPTmpN01_4; 29591 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4) && 29592 N0.getNode()->getValueType(0) == MVT::i32) { 29593 SDNode *Result = Emit_76(N, X86::CVTSI2SSrm, MVT::f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 29594 return Result; 29595 } 29596 } 29597 } 29598 } 29599 } 29600 if ((Subtarget->hasSSE1())) { 29601 SDValue N0 = N.getOperand(0); 29602 29603 // Pattern: (sint_to_fp:f32 GR64:i64:$src) 29604 // Emits: (CVTSI2SS64rr:f32 GR64:i64:$src) 29605 // Pattern complexity = 3 cost = 1 size = 3 29606 if (N0.getNode()->getValueType(0) == MVT::i64) { 29607 SDNode *Result = Emit_71(N, X86::CVTSI2SS64rr, MVT::f32); 29608 return Result; 29609 } 29610 29611 // Pattern: (sint_to_fp:f32 GR32:i32:$src) 29612 // Emits: (CVTSI2SSrr:f32 GR32:i32:$src) 29613 // Pattern complexity = 3 cost = 1 size = 3 29614 if (N0.getNode()->getValueType(0) == MVT::i32) { 29615 SDNode *Result = Emit_71(N, X86::CVTSI2SSrr, MVT::f32); 29616 return Result; 29617 } 29618 } 29619 29620 CannotYetSelect(N); 29621 return NULL; 29622 } 29623 29624 SDNode *Select_ISD_SINT_TO_FP_f64(const SDValue &N) { 29625 if (OptLevel != CodeGenOpt::None && 29626 (Subtarget->hasSSE2())) { 29627 SDValue N0 = N.getOperand(0); 29628 if (N0.getOpcode() == ISD::LOAD && 29629 N0.hasOneUse()) { 29630 SDValue Chain0 = N0.getOperand(0); 29631 if (Predicate_unindexedload(N0.getNode())) { 29632 29633 // Pattern: (sint_to_fp:f64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>) 29634 // Emits: (CVTSI2SD64rm:f64 addr:iPTR:$src) 29635 // Pattern complexity = 25 cost = 1 size = 3 29636 if (Predicate_load(N0.getNode()) && 29637 Predicate_loadi64(N0.getNode())) { 29638 SDValue N01 = N0.getOperand(1); 29639 SDValue CPTmpN01_0; 29640 SDValue CPTmpN01_1; 29641 SDValue CPTmpN01_2; 29642 SDValue CPTmpN01_3; 29643 SDValue CPTmpN01_4; 29644 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4) && 29645 N0.getNode()->getValueType(0) == MVT::i64) { 29646 SDNode *Result = Emit_76(N, X86::CVTSI2SD64rm, MVT::f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 29647 return Result; 29648 } 29649 } 29650 29651 // Pattern: (sint_to_fp:f64 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>) 29652 // Emits: (CVTSI2SDrm:f64 addr:iPTR:$src) 29653 // Pattern complexity = 25 cost = 1 size = 3 29654 if (Predicate_loadi32(N0.getNode())) { 29655 SDValue N01 = N0.getOperand(1); 29656 SDValue CPTmpN01_0; 29657 SDValue CPTmpN01_1; 29658 SDValue CPTmpN01_2; 29659 SDValue CPTmpN01_3; 29660 SDValue CPTmpN01_4; 29661 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4) && 29662 N0.getNode()->getValueType(0) == MVT::i32) { 29663 SDNode *Result = Emit_76(N, X86::CVTSI2SDrm, MVT::f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 29664 return Result; 29665 } 29666 } 29667 } 29668 } 29669 } 29670 if ((Subtarget->hasSSE2())) { 29671 SDValue N0 = N.getOperand(0); 29672 29673 // Pattern: (sint_to_fp:f64 GR64:i64:$src) 29674 // Emits: (CVTSI2SD64rr:f64 GR64:i64:$src) 29675 // Pattern complexity = 3 cost = 1 size = 3 29676 if (N0.getNode()->getValueType(0) == MVT::i64) { 29677 SDNode *Result = Emit_71(N, X86::CVTSI2SD64rr, MVT::f64); 29678 return Result; 29679 } 29680 29681 // Pattern: (sint_to_fp:f64 GR32:i32:$src) 29682 // Emits: (CVTSI2SDrr:f64 GR32:i32:$src) 29683 // Pattern complexity = 3 cost = 1 size = 3 29684 if (N0.getNode()->getValueType(0) == MVT::i32) { 29685 SDNode *Result = Emit_71(N, X86::CVTSI2SDrr, MVT::f64); 29686 return Result; 29687 } 29688 } 29689 29690 CannotYetSelect(N); 29691 return NULL; 29692 } 29693 29694 SDNode *Select_ISD_SINT_TO_FP_v4f32(const SDValue &N) { 29695 if ((Subtarget->hasSSE2())) { 29696 SDValue N0 = N.getOperand(0); 29697 if (N0.getNode()->getValueType(0) == MVT::v4i32) { 29698 SDNode *Result = Emit_71(N, X86::Int_CVTDQ2PSrr, MVT::v4f32); 29699 return Result; 29700 } 29701 } 29702 29703 CannotYetSelect(N); 29704 return NULL; 29705 } 29706 29707 SDNode *Select_ISD_SINT_TO_FP_v2f64(const SDValue &N) { 29708 if ((Subtarget->hasSSE2())) { 29709 SDValue N0 = N.getOperand(0); 29710 if (N0.getNode()->getValueType(0) == MVT::v2i32) { 29711 SDNode *Result = Emit_71(N, X86::Int_CVTPI2PDrr, MVT::v2f64); 29712 return Result; 29713 } 29714 } 29715 29716 CannotYetSelect(N); 29717 return NULL; 29718 } 29719 29720 SDNode *Select_ISD_SRA_i8(const SDValue &N) { 29721 SDValue N0 = N.getOperand(0); 29722 SDValue N1 = N.getOperand(1); 29723 29724 // Pattern: (sra:i8 GR8:i8:$src1, (and:i8 CL:i8:$amt, 31:i8)) 29725 // Emits: (SAR8rCL:i8 GR8:i8:$src1) 29726 // Pattern complexity = 11 cost = 1 size = 3 29727 if (N1.getOpcode() == ISD::AND) { 29728 SDValue N10 = N1.getOperand(0); 29729 SDValue N11 = N1.getOperand(1); 29730 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 29731 if (Tmp0 && 29732 CheckAndMask(N10, Tmp0, INT64_C(31)) && 29733 N1.getNode()->getValueType(0) == MVT::i8) { 29734 SDNode *Result = Emit_163(N, X86::SAR8rCL, MVT::i8); 29735 return Result; 29736 } 29737 } 29738 29739 // Pattern: (sra:i8 GR8:i8:$src1, 1:i8) 29740 // Emits: (SAR8r1:i8 GR8:i8:$src1) 29741 // Pattern complexity = 8 cost = 1 size = 3 29742 { 29743 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 29744 if (Tmp0) { 29745 int64_t CN1 = Tmp0->getSExtValue(); 29746 if (CN1 == INT64_C(1) && 29747 N1.getNode()->getValueType(0) == MVT::i8) { 29748 SDNode *Result = Emit_92(N, X86::SAR8r1, MVT::i8); 29749 return Result; 29750 } 29751 } 29752 } 29753 29754 // Pattern: (sra:i8 GR8:i8:$src1, (imm:i8):$src2) 29755 // Emits: (SAR8ri:i8 GR8:i8:$src1, (imm:i8):$src2) 29756 // Pattern complexity = 6 cost = 1 size = 3 29757 if (N1.getOpcode() == ISD::Constant && 29758 N1.getNode()->getValueType(0) == MVT::i8) { 29759 SDNode *Result = Emit_160(N, X86::SAR8ri, MVT::i8); 29760 return Result; 29761 } 29762 29763 // Pattern: (sra:i8 GR8:i8:$src, CL:i8) 29764 // Emits: (SAR8rCL:i8 GR8:i8:$src) 29765 // Pattern complexity = 3 cost = 1 size = 3 29766 if (N1.getNode()->getValueType(0) == MVT::i8) { 29767 SDNode *Result = Emit_159(N, X86::SAR8rCL, MVT::i8); 29768 return Result; 29769 } 29770 29771 CannotYetSelect(N); 29772 return NULL; 29773 } 29774 29775 SDNode *Select_ISD_SRA_i16(const SDValue &N) { 29776 SDValue N0 = N.getOperand(0); 29777 SDValue N1 = N.getOperand(1); 29778 29779 // Pattern: (sra:i16 GR16:i16:$src1, (and:i8 CL:i8:$amt, 31:i8)) 29780 // Emits: (SAR16rCL:i16 GR16:i16:$src1) 29781 // Pattern complexity = 11 cost = 1 size = 3 29782 if (N1.getOpcode() == ISD::AND) { 29783 SDValue N10 = N1.getOperand(0); 29784 SDValue N11 = N1.getOperand(1); 29785 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 29786 if (Tmp0 && 29787 CheckAndMask(N10, Tmp0, INT64_C(31)) && 29788 N1.getNode()->getValueType(0) == MVT::i8) { 29789 SDNode *Result = Emit_163(N, X86::SAR16rCL, MVT::i16); 29790 return Result; 29791 } 29792 } 29793 29794 // Pattern: (sra:i16 GR16:i16:$src1, 1:i8) 29795 // Emits: (SAR16r1:i16 GR16:i16:$src1) 29796 // Pattern complexity = 8 cost = 1 size = 3 29797 { 29798 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 29799 if (Tmp0) { 29800 int64_t CN1 = Tmp0->getSExtValue(); 29801 if (CN1 == INT64_C(1) && 29802 N1.getNode()->getValueType(0) == MVT::i8) { 29803 SDNode *Result = Emit_92(N, X86::SAR16r1, MVT::i16); 29804 return Result; 29805 } 29806 } 29807 } 29808 29809 // Pattern: (sra:i16 GR16:i16:$src1, (imm:i8):$src2) 29810 // Emits: (SAR16ri:i16 GR16:i16:$src1, (imm:i8):$src2) 29811 // Pattern complexity = 6 cost = 1 size = 3 29812 if (N1.getOpcode() == ISD::Constant && 29813 N1.getNode()->getValueType(0) == MVT::i8) { 29814 SDNode *Result = Emit_160(N, X86::SAR16ri, MVT::i16); 29815 return Result; 29816 } 29817 29818 // Pattern: (sra:i16 GR16:i16:$src, CL:i8) 29819 // Emits: (SAR16rCL:i16 GR16:i16:$src) 29820 // Pattern complexity = 3 cost = 1 size = 3 29821 if (N1.getNode()->getValueType(0) == MVT::i8) { 29822 SDNode *Result = Emit_159(N, X86::SAR16rCL, MVT::i16); 29823 return Result; 29824 } 29825 29826 CannotYetSelect(N); 29827 return NULL; 29828 } 29829 29830 SDNode *Select_ISD_SRA_i32(const SDValue &N) { 29831 SDValue N0 = N.getOperand(0); 29832 SDValue N1 = N.getOperand(1); 29833 29834 // Pattern: (sra:i32 GR32:i32:$src1, (and:i8 CL:i8:$amt, 31:i8)) 29835 // Emits: (SAR32rCL:i32 GR32:i32:$src1) 29836 // Pattern complexity = 11 cost = 1 size = 3 29837 if (N1.getOpcode() == ISD::AND) { 29838 SDValue N10 = N1.getOperand(0); 29839 SDValue N11 = N1.getOperand(1); 29840 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 29841 if (Tmp0 && 29842 CheckAndMask(N10, Tmp0, INT64_C(31)) && 29843 N1.getNode()->getValueType(0) == MVT::i8) { 29844 SDNode *Result = Emit_163(N, X86::SAR32rCL, MVT::i32); 29845 return Result; 29846 } 29847 } 29848 29849 // Pattern: (sra:i32 GR32:i32:$src1, 1:i8) 29850 // Emits: (SAR32r1:i32 GR32:i32:$src1) 29851 // Pattern complexity = 8 cost = 1 size = 3 29852 { 29853 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 29854 if (Tmp0) { 29855 int64_t CN1 = Tmp0->getSExtValue(); 29856 if (CN1 == INT64_C(1) && 29857 N1.getNode()->getValueType(0) == MVT::i8) { 29858 SDNode *Result = Emit_92(N, X86::SAR32r1, MVT::i32); 29859 return Result; 29860 } 29861 } 29862 } 29863 29864 // Pattern: (sra:i32 GR32:i32:$src1, (imm:i8):$src2) 29865 // Emits: (SAR32ri:i32 GR32:i32:$src1, (imm:i8):$src2) 29866 // Pattern complexity = 6 cost = 1 size = 3 29867 if (N1.getOpcode() == ISD::Constant && 29868 N1.getNode()->getValueType(0) == MVT::i8) { 29869 SDNode *Result = Emit_160(N, X86::SAR32ri, MVT::i32); 29870 return Result; 29871 } 29872 29873 // Pattern: (sra:i32 GR32:i32:$src, CL:i8) 29874 // Emits: (SAR32rCL:i32 GR32:i32:$src) 29875 // Pattern complexity = 3 cost = 1 size = 3 29876 if (N1.getNode()->getValueType(0) == MVT::i8) { 29877 SDNode *Result = Emit_159(N, X86::SAR32rCL, MVT::i32); 29878 return Result; 29879 } 29880 29881 CannotYetSelect(N); 29882 return NULL; 29883 } 29884 29885 SDNode *Select_ISD_SRA_i64(const SDValue &N) { 29886 SDValue N0 = N.getOperand(0); 29887 SDValue N1 = N.getOperand(1); 29888 29889 // Pattern: (sra:i64 GR64:i64:$src1, (and:i8 CL:i8:$amt, 63:i8)) 29890 // Emits: (SAR64rCL:i64 GR64:i64:$src1) 29891 // Pattern complexity = 11 cost = 1 size = 3 29892 if (N1.getOpcode() == ISD::AND) { 29893 SDValue N10 = N1.getOperand(0); 29894 SDValue N11 = N1.getOperand(1); 29895 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 29896 if (Tmp0 && 29897 CheckAndMask(N10, Tmp0, INT64_C(63)) && 29898 N1.getNode()->getValueType(0) == MVT::i8) { 29899 SDNode *Result = Emit_163(N, X86::SAR64rCL, MVT::i64); 29900 return Result; 29901 } 29902 } 29903 29904 // Pattern: (sra:i64 GR64:i64:$src1, 1:i8) 29905 // Emits: (SAR64r1:i64 GR64:i64:$src1) 29906 // Pattern complexity = 8 cost = 1 size = 3 29907 { 29908 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 29909 if (Tmp0) { 29910 int64_t CN1 = Tmp0->getSExtValue(); 29911 if (CN1 == INT64_C(1) && 29912 N1.getNode()->getValueType(0) == MVT::i8) { 29913 SDNode *Result = Emit_92(N, X86::SAR64r1, MVT::i64); 29914 return Result; 29915 } 29916 } 29917 } 29918 29919 // Pattern: (sra:i64 GR64:i64:$src1, (imm:i8):$src2) 29920 // Emits: (SAR64ri:i64 GR64:i64:$src1, (imm:i8):$src2) 29921 // Pattern complexity = 6 cost = 1 size = 3 29922 if (N1.getOpcode() == ISD::Constant && 29923 N1.getNode()->getValueType(0) == MVT::i8) { 29924 SDNode *Result = Emit_160(N, X86::SAR64ri, MVT::i64); 29925 return Result; 29926 } 29927 29928 // Pattern: (sra:i64 GR64:i64:$src, CL:i8) 29929 // Emits: (SAR64rCL:i64 GR64:i64:$src) 29930 // Pattern complexity = 3 cost = 1 size = 3 29931 if (N1.getNode()->getValueType(0) == MVT::i8) { 29932 SDNode *Result = Emit_159(N, X86::SAR64rCL, MVT::i64); 29933 return Result; 29934 } 29935 29936 CannotYetSelect(N); 29937 return NULL; 29938 } 29939 29940 SDNode *Select_ISD_SRL_i8(const SDValue &N) { 29941 SDValue N0 = N.getOperand(0); 29942 SDValue N1 = N.getOperand(1); 29943 29944 // Pattern: (srl:i8 GR8:i8:$src1, (and:i8 CL:i8:$amt, 31:i8)) 29945 // Emits: (SHR8rCL:i8 GR8:i8:$src1) 29946 // Pattern complexity = 11 cost = 1 size = 3 29947 if (N1.getOpcode() == ISD::AND) { 29948 SDValue N10 = N1.getOperand(0); 29949 SDValue N11 = N1.getOperand(1); 29950 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 29951 if (Tmp0 && 29952 CheckAndMask(N10, Tmp0, INT64_C(31)) && 29953 N1.getNode()->getValueType(0) == MVT::i8) { 29954 SDNode *Result = Emit_163(N, X86::SHR8rCL, MVT::i8); 29955 return Result; 29956 } 29957 } 29958 29959 // Pattern: (srl:i8 GR8:i8:$src1, 1:i8) 29960 // Emits: (SHR8r1:i8 GR8:i8:$src1) 29961 // Pattern complexity = 8 cost = 1 size = 3 29962 { 29963 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 29964 if (Tmp0) { 29965 int64_t CN1 = Tmp0->getSExtValue(); 29966 if (CN1 == INT64_C(1) && 29967 N1.getNode()->getValueType(0) == MVT::i8) { 29968 SDNode *Result = Emit_92(N, X86::SHR8r1, MVT::i8); 29969 return Result; 29970 } 29971 } 29972 } 29973 29974 // Pattern: (srl:i8 GR8:i8:$src1, (imm:i8):$src2) 29975 // Emits: (SHR8ri:i8 GR8:i8:$src1, (imm:i8):$src2) 29976 // Pattern complexity = 6 cost = 1 size = 3 29977 if (N1.getOpcode() == ISD::Constant && 29978 N1.getNode()->getValueType(0) == MVT::i8) { 29979 SDNode *Result = Emit_160(N, X86::SHR8ri, MVT::i8); 29980 return Result; 29981 } 29982 29983 // Pattern: (srl:i8 GR8:i8:$src, CL:i8) 29984 // Emits: (SHR8rCL:i8 GR8:i8:$src) 29985 // Pattern complexity = 3 cost = 1 size = 3 29986 if (N1.getNode()->getValueType(0) == MVT::i8) { 29987 SDNode *Result = Emit_159(N, X86::SHR8rCL, MVT::i8); 29988 return Result; 29989 } 29990 29991 CannotYetSelect(N); 29992 return NULL; 29993 } 29994 29995 SDNode *Emit_169(const SDValue &N, unsigned Opc0, unsigned Opc1, unsigned Opc2, unsigned Opc3, EVT VT0, EVT VT1, EVT VT2, EVT VT3) DISABLE_INLINE { 29996 SDValue N0 = N.getOperand(0); 29997 SDValue N1 = N.getOperand(1); 29998 SDValue Tmp3 = CurDAG->getTargetConstant(X86::GR16_ABCDRegClassID, MVT::i32); 29999 SDValue Tmp4(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N0, Tmp3), 0); 30000 SDValue Tmp5 = CurDAG->getTargetConstant(0x2ULL, MVT::i32); 30001 SDValue Tmp6(CurDAG->getTargetNode(Opc1, N.getDebugLoc(), VT1, Tmp4, Tmp5), 0); 30002 SDValue Tmp7(CurDAG->getTargetNode(Opc2, N.getDebugLoc(), VT2, Tmp6), 0); 30003 SDValue Tmp8 = CurDAG->getTargetConstant(0x3ULL, MVT::i32); 30004 return CurDAG->SelectNodeTo(N.getNode(), Opc3, VT3, Tmp7, Tmp8); 30005 } 30006 SDNode *Select_ISD_SRL_i16(const SDValue &N) { 30007 30008 // Pattern: (srl:i16 GR16:i16:$src1, (and:i8 CL:i8:$amt, 31:i8)) 30009 // Emits: (SHR16rCL:i16 GR16:i16:$src1) 30010 // Pattern complexity = 11 cost = 1 size = 3 30011 { 30012 SDValue N0 = N.getOperand(0); 30013 SDValue N1 = N.getOperand(1); 30014 if (N1.getOpcode() == ISD::AND) { 30015 SDValue N10 = N1.getOperand(0); 30016 SDValue N11 = N1.getOperand(1); 30017 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 30018 if (Tmp0 && 30019 CheckAndMask(N10, Tmp0, INT64_C(31)) && 30020 N1.getNode()->getValueType(0) == MVT::i8) { 30021 SDNode *Result = Emit_163(N, X86::SHR16rCL, MVT::i16); 30022 return Result; 30023 } 30024 } 30025 } 30026 30027 // Pattern: (srl:i16 GR16:i16:$src, 8:i8)<<P:Predicate_srl_su>> 30028 // Emits: (EXTRACT_SUBREG:i16 (MOVZX32rr8:i32 (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i16 GR16:i16:$src, GR16_ABCD:i16), 2:i32)), 3:i32) 30029 // Pattern complexity = 9 cost = 4 size = 3 30030 if ((!Subtarget->is64Bit()) && 30031 Predicate_srl_su(N.getNode())) { 30032 SDValue N0 = N.getOperand(0); 30033 SDValue N1 = N.getOperand(1); 30034 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 30035 if (Tmp0) { 30036 int64_t CN1 = Tmp0->getSExtValue(); 30037 if (CN1 == INT64_C(8) && 30038 N1.getNode()->getValueType(0) == MVT::i8) { 30039 SDNode *Result = Emit_169(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVZX32rr8, TargetInstrInfo::EXTRACT_SUBREG, MVT::i16, MVT::i8, MVT::i32, MVT::i16); 30040 return Result; 30041 } 30042 } 30043 } 30044 30045 // Pattern: (srl:i16 GR16:i16:$src, 8:i8)<<P:Predicate_srl_su>> 30046 // Emits: (EXTRACT_SUBREG:i16 (MOVZX32_NOREXrr8:i32 (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i16 GR16:i16:$src, GR16_ABCD:i16), 2:i32)), 3:i32) 30047 // Pattern complexity = 9 cost = 4 size = 3 30048 if ((Subtarget->is64Bit()) && 30049 Predicate_srl_su(N.getNode())) { 30050 SDValue N0 = N.getOperand(0); 30051 SDValue N1 = N.getOperand(1); 30052 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 30053 if (Tmp0) { 30054 int64_t CN1 = Tmp0->getSExtValue(); 30055 if (CN1 == INT64_C(8) && 30056 N1.getNode()->getValueType(0) == MVT::i8) { 30057 SDNode *Result = Emit_169(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVZX32_NOREXrr8, TargetInstrInfo::EXTRACT_SUBREG, MVT::i16, MVT::i8, MVT::i32, MVT::i16); 30058 return Result; 30059 } 30060 } 30061 } 30062 SDValue N0 = N.getOperand(0); 30063 SDValue N1 = N.getOperand(1); 30064 30065 // Pattern: (srl:i16 GR16:i16:$src1, 1:i8) 30066 // Emits: (SHR16r1:i16 GR16:i16:$src1) 30067 // Pattern complexity = 8 cost = 1 size = 3 30068 { 30069 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 30070 if (Tmp0) { 30071 int64_t CN1 = Tmp0->getSExtValue(); 30072 if (CN1 == INT64_C(1) && 30073 N1.getNode()->getValueType(0) == MVT::i8) { 30074 SDNode *Result = Emit_92(N, X86::SHR16r1, MVT::i16); 30075 return Result; 30076 } 30077 } 30078 } 30079 30080 // Pattern: (srl:i16 GR16:i16:$src1, (imm:i8):$src2) 30081 // Emits: (SHR16ri:i16 GR16:i16:$src1, (imm:i8):$src2) 30082 // Pattern complexity = 6 cost = 1 size = 3 30083 if (N1.getOpcode() == ISD::Constant && 30084 N1.getNode()->getValueType(0) == MVT::i8) { 30085 SDNode *Result = Emit_160(N, X86::SHR16ri, MVT::i16); 30086 return Result; 30087 } 30088 30089 // Pattern: (srl:i16 GR16:i16:$src, CL:i8) 30090 // Emits: (SHR16rCL:i16 GR16:i16:$src) 30091 // Pattern complexity = 3 cost = 1 size = 3 30092 if (N1.getNode()->getValueType(0) == MVT::i8) { 30093 SDNode *Result = Emit_159(N, X86::SHR16rCL, MVT::i16); 30094 return Result; 30095 } 30096 30097 CannotYetSelect(N); 30098 return NULL; 30099 } 30100 30101 SDNode *Select_ISD_SRL_i32(const SDValue &N) { 30102 SDValue N0 = N.getOperand(0); 30103 SDValue N1 = N.getOperand(1); 30104 30105 // Pattern: (srl:i32 GR32:i32:$src1, (and:i8 CL:i8:$amt, 31:i8)) 30106 // Emits: (SHR32rCL:i32 GR32:i32:$src1) 30107 // Pattern complexity = 11 cost = 1 size = 3 30108 if (N1.getOpcode() == ISD::AND) { 30109 SDValue N10 = N1.getOperand(0); 30110 SDValue N11 = N1.getOperand(1); 30111 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 30112 if (Tmp0 && 30113 CheckAndMask(N10, Tmp0, INT64_C(31)) && 30114 N1.getNode()->getValueType(0) == MVT::i8) { 30115 SDNode *Result = Emit_163(N, X86::SHR32rCL, MVT::i32); 30116 return Result; 30117 } 30118 } 30119 30120 // Pattern: (srl:i32 GR32:i32:$src1, 1:i8) 30121 // Emits: (SHR32r1:i32 GR32:i32:$src1) 30122 // Pattern complexity = 8 cost = 1 size = 3 30123 { 30124 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 30125 if (Tmp0) { 30126 int64_t CN1 = Tmp0->getSExtValue(); 30127 if (CN1 == INT64_C(1) && 30128 N1.getNode()->getValueType(0) == MVT::i8) { 30129 SDNode *Result = Emit_92(N, X86::SHR32r1, MVT::i32); 30130 return Result; 30131 } 30132 } 30133 } 30134 30135 // Pattern: (srl:i32 GR32:i32:$src1, (imm:i8):$src2) 30136 // Emits: (SHR32ri:i32 GR32:i32:$src1, (imm:i8):$src2) 30137 // Pattern complexity = 6 cost = 1 size = 3 30138 if (N1.getOpcode() == ISD::Constant && 30139 N1.getNode()->getValueType(0) == MVT::i8) { 30140 SDNode *Result = Emit_160(N, X86::SHR32ri, MVT::i32); 30141 return Result; 30142 } 30143 30144 // Pattern: (srl:i32 GR32:i32:$src, CL:i8) 30145 // Emits: (SHR32rCL:i32 GR32:i32:$src) 30146 // Pattern complexity = 3 cost = 1 size = 3 30147 if (N1.getNode()->getValueType(0) == MVT::i8) { 30148 SDNode *Result = Emit_159(N, X86::SHR32rCL, MVT::i32); 30149 return Result; 30150 } 30151 30152 CannotYetSelect(N); 30153 return NULL; 30154 } 30155 30156 SDNode *Select_ISD_SRL_i64(const SDValue &N) { 30157 SDValue N0 = N.getOperand(0); 30158 SDValue N1 = N.getOperand(1); 30159 30160 // Pattern: (srl:i64 GR64:i64:$src1, (and:i8 CL:i8:$amt, 63:i8)) 30161 // Emits: (SHR64rCL:i64 GR64:i64:$src1) 30162 // Pattern complexity = 11 cost = 1 size = 3 30163 if (N1.getOpcode() == ISD::AND) { 30164 SDValue N10 = N1.getOperand(0); 30165 SDValue N11 = N1.getOperand(1); 30166 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 30167 if (Tmp0 && 30168 CheckAndMask(N10, Tmp0, INT64_C(63)) && 30169 N1.getNode()->getValueType(0) == MVT::i8) { 30170 SDNode *Result = Emit_163(N, X86::SHR64rCL, MVT::i64); 30171 return Result; 30172 } 30173 } 30174 30175 // Pattern: (srl:i64 GR64:i64:$src1, 1:i8) 30176 // Emits: (SHR64r1:i64 GR64:i64:$src1) 30177 // Pattern complexity = 8 cost = 1 size = 3 30178 { 30179 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 30180 if (Tmp0) { 30181 int64_t CN1 = Tmp0->getSExtValue(); 30182 if (CN1 == INT64_C(1) && 30183 N1.getNode()->getValueType(0) == MVT::i8) { 30184 SDNode *Result = Emit_92(N, X86::SHR64r1, MVT::i64); 30185 return Result; 30186 } 30187 } 30188 } 30189 30190 // Pattern: (srl:i64 GR64:i64:$src1, (imm:i8):$src2) 30191 // Emits: (SHR64ri:i64 GR64:i64:$src1, (imm:i8):$src2) 30192 // Pattern complexity = 6 cost = 1 size = 3 30193 if (N1.getOpcode() == ISD::Constant && 30194 N1.getNode()->getValueType(0) == MVT::i8) { 30195 SDNode *Result = Emit_160(N, X86::SHR64ri, MVT::i64); 30196 return Result; 30197 } 30198 30199 // Pattern: (srl:i64 GR64:i64:$src, CL:i8) 30200 // Emits: (SHR64rCL:i64 GR64:i64:$src) 30201 // Pattern complexity = 3 cost = 1 size = 3 30202 if (N1.getNode()->getValueType(0) == MVT::i8) { 30203 SDNode *Result = Emit_159(N, X86::SHR64rCL, MVT::i64); 30204 return Result; 30205 } 30206 30207 CannotYetSelect(N); 30208 return NULL; 30209 } 30210 30211 SDNode *Emit_170(const SDValue &N, unsigned Opc0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 30212 SDValue Chain = N.getOperand(0); 30213 SDValue N1 = N.getOperand(1); 30214 SDValue N2 = N.getOperand(2); 30215 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i8); 30216 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30217 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Tmp1, LSI_N, Chain }; 30218 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 8); 30219 } 30220 SDNode *Emit_171(const SDValue &N, unsigned Opc0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 30221 SDValue Chain = N.getOperand(0); 30222 SDValue N1 = N.getOperand(1); 30223 SDValue N2 = N.getOperand(2); 30224 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned short) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i16); 30225 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30226 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Tmp1, LSI_N, Chain }; 30227 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 8); 30228 } 30229 SDNode *Emit_172(const SDValue &N, unsigned Opc0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 30230 SDValue Chain = N.getOperand(0); 30231 SDValue N1 = N.getOperand(1); 30232 SDValue N2 = N.getOperand(2); 30233 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i32); 30234 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30235 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Tmp1, LSI_N, Chain }; 30236 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 8); 30237 } 30238 SDNode *Emit_173(const SDValue &N, unsigned Opc0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 30239 SDValue Chain = N.getOperand(0); 30240 SDValue N1 = N.getOperand(1); 30241 SDValue N2 = N.getOperand(2); 30242 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30243 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, N1, LSI_N, Chain }; 30244 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 8); 30245 } 30246 SDNode *Emit_174(const SDValue &N, unsigned Opc0, SDValue &CPTmpN111_0, SDValue &CPTmpN111_1, SDValue &CPTmpN111_2, SDValue &CPTmpN111_3, SDValue &CPTmpN111_4) DISABLE_INLINE { 30247 SDValue Chain = N.getOperand(0); 30248 SDValue N1 = N.getOperand(1); 30249 SDValue N10 = N1.getOperand(0); 30250 SDValue N11 = N1.getOperand(1); 30251 SDValue Chain11 = N11.getOperand(0); 30252 SDValue N111 = N11.getOperand(1); 30253 SDValue N2 = N.getOperand(2); 30254 SmallVector<SDValue, 8> InChains; 30255 if (Chain.getNode() != N11.getNode()) { 30256 InChains.push_back(Chain); 30257 } 30258 InChains.push_back(Chain11); 30259 Chain11 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30260 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30261 SDValue LSI_N11 = CurDAG->getMemOperand(cast<MemSDNode>(N11)->getMemOperand()); 30262 SDValue Ops0[] = { CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4, LSI_N, LSI_N11, Chain11 }; 30263 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 8); 30264 Chain11 = SDValue(ResNode, 1); 30265 const SDValue Froms[] = { 30266 SDValue(N11.getNode(), 1), 30267 SDValue(N.getNode(), 0) 30268 }; 30269 const SDValue Tos[] = { 30270 SDValue(ResNode, 1), 30271 SDValue(Chain11.getNode(), Chain11.getResNo()) 30272 }; 30273 ReplaceUses(Froms, Tos, 2); 30274 return ResNode; 30275 } 30276 SDNode *Emit_175(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30277 SDValue Chain = N.getOperand(0); 30278 SDValue N1 = N.getOperand(1); 30279 SDValue N10 = N1.getOperand(0); 30280 SDValue Chain10 = N10.getOperand(0); 30281 SDValue N101 = N10.getOperand(1); 30282 SDValue N11 = N1.getOperand(1); 30283 SDValue N2 = N.getOperand(2); 30284 SmallVector<SDValue, 8> InChains; 30285 if (Chain.getNode() != N10.getNode()) { 30286 InChains.push_back(Chain); 30287 } 30288 InChains.push_back(Chain10); 30289 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30290 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30291 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30292 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, LSI_N, LSI_N10, Chain10 }; 30293 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 8); 30294 Chain10 = SDValue(ResNode, 0); 30295 const SDValue Froms[] = { 30296 SDValue(N10.getNode(), 1), 30297 SDValue(N.getNode(), 0) 30298 }; 30299 const SDValue Tos[] = { 30300 SDValue(ResNode, 0), 30301 SDValue(Chain10.getNode(), Chain10.getResNo()) 30302 }; 30303 ReplaceUses(Froms, Tos, 2); 30304 return ResNode; 30305 } 30306 SDNode *Emit_176(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30307 SDValue Chain = N.getOperand(0); 30308 SDValue N1 = N.getOperand(1); 30309 SDValue N10 = N1.getOperand(0); 30310 SDValue Chain10 = N10.getOperand(0); 30311 SDValue N101 = N10.getOperand(1); 30312 SDValue N11 = N1.getOperand(1); 30313 SDValue N2 = N.getOperand(2); 30314 SmallVector<SDValue, 8> InChains; 30315 if (Chain.getNode() != N10.getNode()) { 30316 InChains.push_back(Chain); 30317 } 30318 InChains.push_back(Chain10); 30319 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30320 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30321 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30322 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, LSI_N, LSI_N10, Chain10 }; 30323 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 8); 30324 Chain10 = SDValue(ResNode, 1); 30325 const SDValue Froms[] = { 30326 SDValue(N10.getNode(), 1), 30327 SDValue(N.getNode(), 0) 30328 }; 30329 const SDValue Tos[] = { 30330 SDValue(ResNode, 1), 30331 SDValue(Chain10.getNode(), Chain10.getResNo()) 30332 }; 30333 ReplaceUses(Froms, Tos, 2); 30334 return ResNode; 30335 } 30336 SDNode *Emit_177(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30337 SDValue Chain = N.getOperand(0); 30338 SDValue N1 = N.getOperand(1); 30339 SDValue N10 = N1.getOperand(0); 30340 SDValue Chain10 = N10.getOperand(0); 30341 SDValue N101 = N10.getOperand(1); 30342 SDValue N11 = N1.getOperand(1); 30343 SDValue N2 = N.getOperand(2); 30344 SmallVector<SDValue, 8> InChains; 30345 if (Chain.getNode() != N10.getNode()) { 30346 InChains.push_back(Chain); 30347 } 30348 InChains.push_back(Chain10); 30349 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30350 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30351 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30352 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, N11, LSI_N, LSI_N10, Chain10 }; 30353 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 9); 30354 Chain10 = SDValue(ResNode, 1); 30355 const SDValue Froms[] = { 30356 SDValue(N10.getNode(), 1), 30357 SDValue(N.getNode(), 0) 30358 }; 30359 const SDValue Tos[] = { 30360 SDValue(ResNode, 1), 30361 SDValue(Chain10.getNode(), Chain10.getResNo()) 30362 }; 30363 ReplaceUses(Froms, Tos, 2); 30364 return ResNode; 30365 } 30366 SDNode *Emit_178(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30367 SDValue Chain = N.getOperand(0); 30368 SDValue N1 = N.getOperand(1); 30369 SDValue N10 = N1.getOperand(0); 30370 SDValue Chain10 = N10.getOperand(0); 30371 SDValue N101 = N10.getOperand(1); 30372 SDValue N11 = N1.getOperand(1); 30373 SDValue N2 = N.getOperand(2); 30374 SmallVector<SDValue, 8> InChains; 30375 if (Chain.getNode() != N10.getNode()) { 30376 InChains.push_back(Chain); 30377 } 30378 InChains.push_back(Chain10); 30379 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30380 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N11)->getZExtValue()), MVT::i8); 30381 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30382 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30383 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, Tmp1, LSI_N, LSI_N10, Chain10 }; 30384 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 9); 30385 Chain10 = SDValue(ResNode, 1); 30386 const SDValue Froms[] = { 30387 SDValue(N10.getNode(), 1), 30388 SDValue(N.getNode(), 0) 30389 }; 30390 const SDValue Tos[] = { 30391 SDValue(ResNode, 1), 30392 SDValue(Chain10.getNode(), Chain10.getResNo()) 30393 }; 30394 ReplaceUses(Froms, Tos, 2); 30395 return ResNode; 30396 } 30397 SDNode *Emit_179(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30398 SDValue Chain = N.getOperand(0); 30399 SDValue N1 = N.getOperand(1); 30400 SDValue N10 = N1.getOperand(0); 30401 SDValue Chain10 = N10.getOperand(0); 30402 SDValue N101 = N10.getOperand(1); 30403 SDValue N11 = N1.getOperand(1); 30404 SDValue N2 = N.getOperand(2); 30405 SmallVector<SDValue, 8> InChains; 30406 if (Chain.getNode() != N10.getNode()) { 30407 InChains.push_back(Chain); 30408 } 30409 InChains.push_back(Chain10); 30410 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30411 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned short) cast<ConstantSDNode>(N11)->getZExtValue()), MVT::i16); 30412 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30413 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30414 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, Tmp1, LSI_N, LSI_N10, Chain10 }; 30415 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 9); 30416 Chain10 = SDValue(ResNode, 1); 30417 const SDValue Froms[] = { 30418 SDValue(N10.getNode(), 1), 30419 SDValue(N.getNode(), 0) 30420 }; 30421 const SDValue Tos[] = { 30422 SDValue(ResNode, 1), 30423 SDValue(Chain10.getNode(), Chain10.getResNo()) 30424 }; 30425 ReplaceUses(Froms, Tos, 2); 30426 return ResNode; 30427 } 30428 SDNode *Emit_180(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30429 SDValue Chain = N.getOperand(0); 30430 SDValue N1 = N.getOperand(1); 30431 SDValue N10 = N1.getOperand(0); 30432 SDValue Chain10 = N10.getOperand(0); 30433 SDValue N101 = N10.getOperand(1); 30434 SDValue N11 = N1.getOperand(1); 30435 SDValue N2 = N.getOperand(2); 30436 SmallVector<SDValue, 8> InChains; 30437 if (Chain.getNode() != N10.getNode()) { 30438 InChains.push_back(Chain); 30439 } 30440 InChains.push_back(Chain10); 30441 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30442 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N11)->getZExtValue()), MVT::i32); 30443 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30444 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30445 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, Tmp1, LSI_N, LSI_N10, Chain10 }; 30446 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 9); 30447 Chain10 = SDValue(ResNode, 1); 30448 const SDValue Froms[] = { 30449 SDValue(N10.getNode(), 1), 30450 SDValue(N.getNode(), 0) 30451 }; 30452 const SDValue Tos[] = { 30453 SDValue(ResNode, 1), 30454 SDValue(Chain10.getNode(), Chain10.getResNo()) 30455 }; 30456 ReplaceUses(Froms, Tos, 2); 30457 return ResNode; 30458 } 30459 SDNode *Emit_181(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30460 SDValue Chain = N.getOperand(0); 30461 SDValue N1 = N.getOperand(1); 30462 SDValue N10 = N1.getOperand(0); 30463 SDValue Chain10 = N10.getOperand(0); 30464 SDValue N101 = N10.getOperand(1); 30465 SDValue N11 = N1.getOperand(1); 30466 SDValue N2 = N.getOperand(2); 30467 SmallVector<SDValue, 8> InChains; 30468 if (Chain.getNode() != N10.getNode()) { 30469 InChains.push_back(Chain); 30470 } 30471 InChains.push_back(Chain10); 30472 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30473 SDValue InFlag(0, 0); 30474 SDNode *ResNode = CurDAG->getCopyToReg(Chain10, N1.getDebugLoc(), X86::CL, N11, InFlag).getNode(); 30475 Chain10 = SDValue(ResNode, 0); 30476 InFlag = SDValue(ResNode, 1); 30477 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30478 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30479 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, LSI_N, LSI_N10, Chain10, InFlag }; 30480 ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 9); 30481 Chain10 = SDValue(ResNode, 0); 30482 const SDValue Froms[] = { 30483 SDValue(N10.getNode(), 1), 30484 SDValue(N.getNode(), 0) 30485 }; 30486 const SDValue Tos[] = { 30487 SDValue(ResNode, 0), 30488 SDValue(Chain10.getNode(), Chain10.getResNo()) 30489 }; 30490 ReplaceUses(Froms, Tos, 2); 30491 return ResNode; 30492 } 30493 SDNode *Emit_182(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30494 SDValue Chain = N.getOperand(0); 30495 SDValue N1 = N.getOperand(1); 30496 SDValue N10 = N1.getOperand(0); 30497 SDValue Chain10 = N10.getOperand(0); 30498 SDValue N101 = N10.getOperand(1); 30499 SDValue N11 = N1.getOperand(1); 30500 SDValue N2 = N.getOperand(2); 30501 SmallVector<SDValue, 8> InChains; 30502 if (Chain.getNode() != N10.getNode()) { 30503 InChains.push_back(Chain); 30504 } 30505 InChains.push_back(Chain10); 30506 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30507 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N11)->getZExtValue()), MVT::i8); 30508 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30509 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30510 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, Tmp1, LSI_N, LSI_N10, Chain10 }; 30511 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 9); 30512 Chain10 = SDValue(ResNode, 0); 30513 const SDValue Froms[] = { 30514 SDValue(N10.getNode(), 1), 30515 SDValue(N.getNode(), 0) 30516 }; 30517 const SDValue Tos[] = { 30518 SDValue(ResNode, 0), 30519 SDValue(Chain10.getNode(), Chain10.getResNo()) 30520 }; 30521 ReplaceUses(Froms, Tos, 2); 30522 return ResNode; 30523 } 30524 SDNode *Emit_183(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30525 SDValue Chain = N.getOperand(0); 30526 SDValue N1 = N.getOperand(1); 30527 SDValue N10 = N1.getOperand(0); 30528 SDValue Chain10 = N10.getOperand(0); 30529 SDValue N101 = N10.getOperand(1); 30530 SDValue N11 = N1.getOperand(1); 30531 SDValue N12 = N1.getOperand(2); 30532 SDValue N2 = N.getOperand(2); 30533 SmallVector<SDValue, 8> InChains; 30534 if (Chain.getNode() != N10.getNode()) { 30535 InChains.push_back(Chain); 30536 } 30537 InChains.push_back(Chain10); 30538 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30539 SDValue InFlag(0, 0); 30540 SDNode *ResNode = CurDAG->getCopyToReg(Chain10, N1.getDebugLoc(), X86::CL, N12, InFlag).getNode(); 30541 Chain10 = SDValue(ResNode, 0); 30542 InFlag = SDValue(ResNode, 1); 30543 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30544 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30545 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, N11, LSI_N, LSI_N10, Chain10, InFlag }; 30546 ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 10); 30547 Chain10 = SDValue(ResNode, 0); 30548 const SDValue Froms[] = { 30549 SDValue(N10.getNode(), 1), 30550 SDValue(N.getNode(), 0) 30551 }; 30552 const SDValue Tos[] = { 30553 SDValue(ResNode, 0), 30554 SDValue(Chain10.getNode(), Chain10.getResNo()) 30555 }; 30556 ReplaceUses(Froms, Tos, 2); 30557 return ResNode; 30558 } 30559 SDNode *Emit_184(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30560 SDValue Chain = N.getOperand(0); 30561 SDValue N1 = N.getOperand(1); 30562 SDValue N10 = N1.getOperand(0); 30563 SDValue Chain10 = N10.getOperand(0); 30564 SDValue N101 = N10.getOperand(1); 30565 SDValue N11 = N1.getOperand(1); 30566 SDValue N12 = N1.getOperand(2); 30567 SDValue N2 = N.getOperand(2); 30568 SmallVector<SDValue, 8> InChains; 30569 if (Chain.getNode() != N10.getNode()) { 30570 InChains.push_back(Chain); 30571 } 30572 InChains.push_back(Chain10); 30573 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30574 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N12)->getZExtValue()), MVT::i8); 30575 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30576 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30577 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, N11, Tmp2, LSI_N, LSI_N10, Chain10 }; 30578 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 10); 30579 Chain10 = SDValue(ResNode, 0); 30580 const SDValue Froms[] = { 30581 SDValue(N10.getNode(), 1), 30582 SDValue(N.getNode(), 0) 30583 }; 30584 const SDValue Tos[] = { 30585 SDValue(ResNode, 0), 30586 SDValue(Chain10.getNode(), Chain10.getResNo()) 30587 }; 30588 ReplaceUses(Froms, Tos, 2); 30589 return ResNode; 30590 } 30591 SDNode *Emit_185(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30592 SDValue Chain = N.getOperand(0); 30593 SDValue N1 = N.getOperand(1); 30594 SDValue N10 = N1.getOperand(0); 30595 SDValue Chain10 = N10.getOperand(0); 30596 SDValue N101 = N10.getOperand(1); 30597 SDValue N11 = N1.getOperand(1); 30598 SDValue N2 = N.getOperand(2); 30599 SmallVector<SDValue, 8> InChains; 30600 if (Chain.getNode() != N10.getNode()) { 30601 InChains.push_back(Chain); 30602 } 30603 InChains.push_back(Chain10); 30604 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30605 SDValue InFlag = N1.getOperand(2); 30606 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30607 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30608 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, N11, LSI_N, LSI_N10, Chain10, InFlag }; 30609 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, MVT::Flag, Ops0, 10); 30610 Chain10 = SDValue(ResNode, 0); 30611 InFlag = SDValue(ResNode, 1); 30612 const SDValue Froms[] = { 30613 SDValue(N10.getNode(), 1), 30614 SDValue(N1.getNode(), 1), 30615 SDValue(N.getNode(), 0) 30616 }; 30617 const SDValue Tos[] = { 30618 SDValue(ResNode, 0), 30619 InFlag, 30620 SDValue(Chain10.getNode(), Chain10.getResNo()) 30621 }; 30622 ReplaceUses(Froms, Tos, 3); 30623 return ResNode; 30624 } 30625 SDNode *Emit_186(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30626 SDValue Chain = N.getOperand(0); 30627 SDValue N1 = N.getOperand(1); 30628 SDValue N10 = N1.getOperand(0); 30629 SDValue Chain10 = N10.getOperand(0); 30630 SDValue N101 = N10.getOperand(1); 30631 SDValue N11 = N1.getOperand(1); 30632 SDValue N2 = N.getOperand(2); 30633 SmallVector<SDValue, 8> InChains; 30634 if (Chain.getNode() != N10.getNode()) { 30635 InChains.push_back(Chain); 30636 } 30637 InChains.push_back(Chain10); 30638 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30639 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N11)->getZExtValue()), MVT::i8); 30640 SDValue InFlag = N1.getOperand(2); 30641 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30642 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30643 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, Tmp1, LSI_N, LSI_N10, Chain10, InFlag }; 30644 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, MVT::Flag, Ops0, 10); 30645 Chain10 = SDValue(ResNode, 0); 30646 InFlag = SDValue(ResNode, 1); 30647 const SDValue Froms[] = { 30648 SDValue(N10.getNode(), 1), 30649 SDValue(N1.getNode(), 1), 30650 SDValue(N.getNode(), 0) 30651 }; 30652 const SDValue Tos[] = { 30653 SDValue(ResNode, 0), 30654 InFlag, 30655 SDValue(Chain10.getNode(), Chain10.getResNo()) 30656 }; 30657 ReplaceUses(Froms, Tos, 3); 30658 return ResNode; 30659 } 30660 SDNode *Emit_187(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30661 SDValue Chain = N.getOperand(0); 30662 SDValue N1 = N.getOperand(1); 30663 SDValue N10 = N1.getOperand(0); 30664 SDValue Chain10 = N10.getOperand(0); 30665 SDValue N101 = N10.getOperand(1); 30666 SDValue N11 = N1.getOperand(1); 30667 SDValue N2 = N.getOperand(2); 30668 SmallVector<SDValue, 8> InChains; 30669 if (Chain.getNode() != N10.getNode()) { 30670 InChains.push_back(Chain); 30671 } 30672 InChains.push_back(Chain10); 30673 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30674 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned short) cast<ConstantSDNode>(N11)->getZExtValue()), MVT::i16); 30675 SDValue InFlag = N1.getOperand(2); 30676 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30677 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30678 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, Tmp1, LSI_N, LSI_N10, Chain10, InFlag }; 30679 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, MVT::Flag, Ops0, 10); 30680 Chain10 = SDValue(ResNode, 0); 30681 InFlag = SDValue(ResNode, 1); 30682 const SDValue Froms[] = { 30683 SDValue(N10.getNode(), 1), 30684 SDValue(N1.getNode(), 1), 30685 SDValue(N.getNode(), 0) 30686 }; 30687 const SDValue Tos[] = { 30688 SDValue(ResNode, 0), 30689 InFlag, 30690 SDValue(Chain10.getNode(), Chain10.getResNo()) 30691 }; 30692 ReplaceUses(Froms, Tos, 3); 30693 return ResNode; 30694 } 30695 SDNode *Emit_188(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30696 SDValue Chain = N.getOperand(0); 30697 SDValue N1 = N.getOperand(1); 30698 SDValue N10 = N1.getOperand(0); 30699 SDValue Chain10 = N10.getOperand(0); 30700 SDValue N101 = N10.getOperand(1); 30701 SDValue N11 = N1.getOperand(1); 30702 SDValue N2 = N.getOperand(2); 30703 SmallVector<SDValue, 8> InChains; 30704 if (Chain.getNode() != N10.getNode()) { 30705 InChains.push_back(Chain); 30706 } 30707 InChains.push_back(Chain10); 30708 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30709 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N11)->getZExtValue()), MVT::i32); 30710 SDValue InFlag = N1.getOperand(2); 30711 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30712 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30713 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, Tmp1, LSI_N, LSI_N10, Chain10, InFlag }; 30714 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, MVT::Flag, Ops0, 10); 30715 Chain10 = SDValue(ResNode, 0); 30716 InFlag = SDValue(ResNode, 1); 30717 const SDValue Froms[] = { 30718 SDValue(N10.getNode(), 1), 30719 SDValue(N1.getNode(), 1), 30720 SDValue(N.getNode(), 0) 30721 }; 30722 const SDValue Tos[] = { 30723 SDValue(ResNode, 0), 30724 InFlag, 30725 SDValue(Chain10.getNode(), Chain10.getResNo()) 30726 }; 30727 ReplaceUses(Froms, Tos, 3); 30728 return ResNode; 30729 } 30730 SDNode *Emit_189(const SDValue &N, unsigned Opc0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 30731 SDValue Chain = N.getOperand(0); 30732 SDValue N1 = N.getOperand(1); 30733 SDValue N10 = N1.getOperand(0); 30734 SDValue N11 = N1.getOperand(1); 30735 SDValue N2 = N.getOperand(2); 30736 SDValue InFlag(0, 0); 30737 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N1.getDebugLoc(), X86::EFLAGS, N11, InFlag).getNode(); 30738 Chain = SDValue(ResNode, 0); 30739 InFlag = SDValue(ResNode, 1); 30740 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30741 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, LSI_N, Chain, InFlag }; 30742 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 8); 30743 } 30744 SDNode *Emit_190(const SDValue &N, unsigned Opc0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 30745 SDValue Chain = N.getOperand(0); 30746 SDValue N1 = N.getOperand(1); 30747 SDValue N2 = N.getOperand(2); 30748 SDValue Tmp1 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i64); 30749 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30750 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Tmp1, LSI_N, Chain }; 30751 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 8); 30752 } 30753 SDNode *Emit_191(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30754 SDValue Chain = N.getOperand(0); 30755 SDValue N1 = N.getOperand(1); 30756 SDValue N10 = N1.getOperand(0); 30757 SDValue Chain10 = N10.getOperand(0); 30758 SDValue N101 = N10.getOperand(1); 30759 SDValue N11 = N1.getOperand(1); 30760 SDValue N2 = N.getOperand(2); 30761 SmallVector<SDValue, 8> InChains; 30762 if (Chain.getNode() != N10.getNode()) { 30763 InChains.push_back(Chain); 30764 } 30765 InChains.push_back(Chain10); 30766 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30767 SDValue Tmp1 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N11)->getZExtValue()), MVT::i64); 30768 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30769 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30770 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, Tmp1, LSI_N, LSI_N10, Chain10 }; 30771 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 9); 30772 Chain10 = SDValue(ResNode, 1); 30773 const SDValue Froms[] = { 30774 SDValue(N10.getNode(), 1), 30775 SDValue(N.getNode(), 0) 30776 }; 30777 const SDValue Tos[] = { 30778 SDValue(ResNode, 1), 30779 SDValue(Chain10.getNode(), Chain10.getResNo()) 30780 }; 30781 ReplaceUses(Froms, Tos, 2); 30782 return ResNode; 30783 } 30784 SDNode *Emit_192(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30785 SDValue Chain = N.getOperand(0); 30786 SDValue N1 = N.getOperand(1); 30787 SDValue N10 = N1.getOperand(0); 30788 SDValue Chain10 = N10.getOperand(0); 30789 SDValue N101 = N10.getOperand(1); 30790 SDValue N11 = N1.getOperand(1); 30791 SDValue N2 = N.getOperand(2); 30792 SmallVector<SDValue, 8> InChains; 30793 if (Chain.getNode() != N10.getNode()) { 30794 InChains.push_back(Chain); 30795 } 30796 InChains.push_back(Chain10); 30797 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30798 SDValue Tmp1 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N11)->getZExtValue()), MVT::i64); 30799 SDValue InFlag = N1.getOperand(2); 30800 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30801 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30802 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, Tmp1, LSI_N, LSI_N10, Chain10, InFlag }; 30803 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, MVT::Flag, Ops0, 10); 30804 Chain10 = SDValue(ResNode, 0); 30805 InFlag = SDValue(ResNode, 1); 30806 const SDValue Froms[] = { 30807 SDValue(N10.getNode(), 1), 30808 SDValue(N1.getNode(), 1), 30809 SDValue(N.getNode(), 0) 30810 }; 30811 const SDValue Tos[] = { 30812 SDValue(ResNode, 0), 30813 InFlag, 30814 SDValue(Chain10.getNode(), Chain10.getResNo()) 30815 }; 30816 ReplaceUses(Froms, Tos, 3); 30817 return ResNode; 30818 } 30819 SDNode *Emit_193(const SDValue &N, unsigned Opc0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 30820 SDValue Chain = N.getOperand(0); 30821 SDValue N1 = N.getOperand(1); 30822 SDValue N10 = N1.getOperand(0); 30823 SDValue N2 = N.getOperand(2); 30824 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30825 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, N10, LSI_N, Chain }; 30826 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 8); 30827 } 30828 SDNode *Emit_194(const SDValue &N, unsigned Opc0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 30829 SDValue Chain = N.getOperand(0); 30830 SDValue N1 = N.getOperand(1); 30831 SDValue N10 = N1.getOperand(0); 30832 SDValue N11 = N1.getOperand(1); 30833 SDValue N2 = N.getOperand(2); 30834 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N11)->getZExtValue()), MVT::i32); 30835 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30836 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, N10, Tmp2, LSI_N, Chain }; 30837 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 9); 30838 } 30839 SDNode *Emit_195(const SDValue &N, unsigned Opc0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 30840 SDValue Chain = N.getOperand(0); 30841 SDValue N1 = N.getOperand(1); 30842 SDValue N10 = N1.getOperand(0); 30843 SDValue N100 = N10.getOperand(0); 30844 SDValue N11 = N1.getOperand(1); 30845 SDValue N2 = N.getOperand(2); 30846 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30847 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, N100, LSI_N, Chain }; 30848 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 8); 30849 } 30850 SDNode *Emit_196(const SDValue &N, unsigned Opc0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 30851 SDValue Chain = N.getOperand(0); 30852 SDValue N1 = N.getOperand(1); 30853 SDValue N10 = N1.getOperand(0); 30854 SDValue N100 = N10.getOperand(0); 30855 SDValue N1000 = N100.getOperand(0); 30856 SDValue N101 = N10.getOperand(1); 30857 SDValue N11 = N1.getOperand(1); 30858 SDValue N2 = N.getOperand(2); 30859 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30860 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, N1000, LSI_N, Chain }; 30861 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 8); 30862 } 30863 SDNode *Emit_197(const SDValue &N, unsigned Opc0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 30864 SDValue Chain = N.getOperand(0); 30865 SDValue N1 = N.getOperand(1); 30866 SDValue N10 = N1.getOperand(0); 30867 SDValue N11 = N1.getOperand(1); 30868 SDValue N2 = N.getOperand(2); 30869 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30870 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, N10, LSI_N, Chain }; 30871 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 8); 30872 } 30873 SDNode *Emit_198(const SDValue &N, unsigned Opc0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 30874 SDValue Chain = N.getOperand(0); 30875 SDValue N1 = N.getOperand(1); 30876 SDValue N10 = N1.getOperand(0); 30877 SDValue N100 = N10.getOperand(0); 30878 SDValue N101 = N10.getOperand(1); 30879 SDValue N11 = N1.getOperand(1); 30880 SDValue N2 = N.getOperand(2); 30881 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30882 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, N100, LSI_N, Chain }; 30883 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 8); 30884 } 30885 SDNode *Emit_199(const SDValue &N, unsigned Opc0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 30886 SDValue Chain = N.getOperand(0); 30887 SDValue N1 = N.getOperand(1); 30888 SDValue N10 = N1.getOperand(0); 30889 SDValue N100 = N10.getOperand(0); 30890 SDValue N11 = N1.getOperand(1); 30891 SDValue N2 = N.getOperand(2); 30892 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N11)->getZExtValue()), MVT::i32); 30893 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30894 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, N100, Tmp2, LSI_N, Chain }; 30895 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 9); 30896 } 30897 SDNode *Emit_200(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30898 SDValue Chain = N.getOperand(0); 30899 SDValue N1 = N.getOperand(1); 30900 SDValue N10 = N1.getOperand(0); 30901 SDValue Chain10 = N10.getOperand(0); 30902 SDValue N101 = N10.getOperand(1); 30903 SDValue N11 = N1.getOperand(1); 30904 SDValue N2 = N.getOperand(2); 30905 SmallVector<SDValue, 8> InChains; 30906 if (Chain.getNode() != N10.getNode()) { 30907 InChains.push_back(Chain); 30908 } 30909 InChains.push_back(Chain10); 30910 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30911 SDValue Tmp3 = CurDAG->getTargetConstant(0xFFFFFFFFFFFFFF80ULL, MVT::i16); 30912 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30913 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30914 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, Tmp3, LSI_N, LSI_N10, Chain10 }; 30915 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 9); 30916 Chain10 = SDValue(ResNode, 0); 30917 const SDValue Froms[] = { 30918 SDValue(N10.getNode(), 1), 30919 SDValue(N.getNode(), 0) 30920 }; 30921 const SDValue Tos[] = { 30922 SDValue(ResNode, 0), 30923 SDValue(Chain10.getNode(), Chain10.getResNo()) 30924 }; 30925 ReplaceUses(Froms, Tos, 2); 30926 return ResNode; 30927 } 30928 SDNode *Emit_201(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30929 SDValue Chain = N.getOperand(0); 30930 SDValue N1 = N.getOperand(1); 30931 SDValue N10 = N1.getOperand(0); 30932 SDValue Chain10 = N10.getOperand(0); 30933 SDValue N101 = N10.getOperand(1); 30934 SDValue N11 = N1.getOperand(1); 30935 SDValue N2 = N.getOperand(2); 30936 SmallVector<SDValue, 8> InChains; 30937 if (Chain.getNode() != N10.getNode()) { 30938 InChains.push_back(Chain); 30939 } 30940 InChains.push_back(Chain10); 30941 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30942 SDValue Tmp3 = CurDAG->getTargetConstant(0xFFFFFFFFFFFFFF80ULL, MVT::i32); 30943 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30944 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30945 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, Tmp3, LSI_N, LSI_N10, Chain10 }; 30946 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 9); 30947 Chain10 = SDValue(ResNode, 0); 30948 const SDValue Froms[] = { 30949 SDValue(N10.getNode(), 1), 30950 SDValue(N.getNode(), 0) 30951 }; 30952 const SDValue Tos[] = { 30953 SDValue(ResNode, 0), 30954 SDValue(Chain10.getNode(), Chain10.getResNo()) 30955 }; 30956 ReplaceUses(Froms, Tos, 2); 30957 return ResNode; 30958 } 30959 SDNode *Emit_202(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 30960 SDValue Chain = N.getOperand(0); 30961 SDValue N1 = N.getOperand(1); 30962 SDValue N10 = N1.getOperand(0); 30963 SDValue Chain10 = N10.getOperand(0); 30964 SDValue N101 = N10.getOperand(1); 30965 SDValue N11 = N1.getOperand(1); 30966 SDValue N110 = N11.getOperand(0); 30967 SDValue N111 = N11.getOperand(1); 30968 SDValue N2 = N.getOperand(2); 30969 SmallVector<SDValue, 8> InChains; 30970 if (Chain.getNode() != N10.getNode()) { 30971 InChains.push_back(Chain); 30972 } 30973 InChains.push_back(Chain10); 30974 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 30975 SDValue InFlag(0, 0); 30976 SDNode *ResNode = CurDAG->getCopyToReg(Chain10, N11.getDebugLoc(), X86::CL, N110, InFlag).getNode(); 30977 Chain10 = SDValue(ResNode, 0); 30978 InFlag = SDValue(ResNode, 1); 30979 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 30980 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 30981 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, LSI_N, LSI_N10, Chain10, InFlag }; 30982 ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 9); 30983 Chain10 = SDValue(ResNode, 0); 30984 const SDValue Froms[] = { 30985 SDValue(N10.getNode(), 1), 30986 SDValue(N.getNode(), 0) 30987 }; 30988 const SDValue Tos[] = { 30989 SDValue(ResNode, 0), 30990 SDValue(Chain10.getNode(), Chain10.getResNo()) 30991 }; 30992 ReplaceUses(Froms, Tos, 2); 30993 return ResNode; 30994 } 30995 SDNode *Emit_203(const SDValue &N, unsigned Opc0, SDValue &CPTmpN1001_0, SDValue &CPTmpN1001_1, SDValue &CPTmpN1001_2, SDValue &CPTmpN1001_3, SDValue &CPTmpN1001_4) DISABLE_INLINE { 30996 SDValue Chain = N.getOperand(0); 30997 SDValue N1 = N.getOperand(1); 30998 SDValue N10 = N1.getOperand(0); 30999 SDValue N100 = N10.getOperand(0); 31000 SDValue Chain100 = N100.getOperand(0); 31001 SDValue N1001 = N100.getOperand(1); 31002 SDValue N101 = N10.getOperand(1); 31003 SDValue N11 = N1.getOperand(1); 31004 SDValue N110 = N11.getOperand(0); 31005 SDValue N111 = N11.getOperand(1); 31006 SDValue N1110 = N111.getOperand(0); 31007 SDValue N1111 = N111.getOperand(1); 31008 SDValue N2 = N.getOperand(2); 31009 SmallVector<SDValue, 8> InChains; 31010 if (Chain.getNode() != N100.getNode()) { 31011 InChains.push_back(Chain); 31012 } 31013 InChains.push_back(Chain100); 31014 Chain100 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 31015 SDValue InFlag(0, 0); 31016 SDNode *ResNode = CurDAG->getCopyToReg(Chain100, N10.getDebugLoc(), X86::CL, N101, InFlag).getNode(); 31017 Chain100 = SDValue(ResNode, 0); 31018 InFlag = SDValue(ResNode, 1); 31019 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31020 SDValue LSI_N100 = CurDAG->getMemOperand(cast<MemSDNode>(N100)->getMemOperand()); 31021 SDValue Ops0[] = { CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4, N110, LSI_N, LSI_N100, Chain100, InFlag }; 31022 ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 10); 31023 Chain100 = SDValue(ResNode, 0); 31024 const SDValue Froms[] = { 31025 SDValue(N100.getNode(), 1), 31026 SDValue(N.getNode(), 0) 31027 }; 31028 const SDValue Tos[] = { 31029 SDValue(ResNode, 0), 31030 SDValue(Chain100.getNode(), Chain100.getResNo()) 31031 }; 31032 ReplaceUses(Froms, Tos, 2); 31033 return ResNode; 31034 } 31035 SDNode *Emit_204(const SDValue &N, unsigned Opc0, SDValue &CPTmpN1001_0, SDValue &CPTmpN1001_1, SDValue &CPTmpN1001_2, SDValue &CPTmpN1001_3, SDValue &CPTmpN1001_4) DISABLE_INLINE { 31036 SDValue Chain = N.getOperand(0); 31037 SDValue N1 = N.getOperand(1); 31038 SDValue N10 = N1.getOperand(0); 31039 SDValue N100 = N10.getOperand(0); 31040 SDValue Chain100 = N100.getOperand(0); 31041 SDValue N1001 = N100.getOperand(1); 31042 SDValue N101 = N10.getOperand(1); 31043 SDValue N1010 = N101.getOperand(0); 31044 SDValue N11 = N1.getOperand(1); 31045 SDValue N110 = N11.getOperand(0); 31046 SDValue N111 = N11.getOperand(1); 31047 SDValue N1110 = N111.getOperand(0); 31048 SDValue N11100 = N1110.getOperand(0); 31049 SDValue N11101 = N1110.getOperand(1); 31050 SDValue N2 = N.getOperand(2); 31051 SmallVector<SDValue, 8> InChains; 31052 if (Chain.getNode() != N100.getNode()) { 31053 InChains.push_back(Chain); 31054 } 31055 InChains.push_back(Chain100); 31056 Chain100 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 31057 SDValue InFlag(0, 0); 31058 SDNode *ResNode = CurDAG->getCopyToReg(Chain100, N101.getDebugLoc(), X86::ECX, N1010, InFlag).getNode(); 31059 Chain100 = SDValue(ResNode, 0); 31060 InFlag = SDValue(ResNode, 1); 31061 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31062 SDValue LSI_N100 = CurDAG->getMemOperand(cast<MemSDNode>(N100)->getMemOperand()); 31063 SDValue Ops0[] = { CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4, N110, LSI_N, LSI_N100, Chain100, InFlag }; 31064 ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 10); 31065 Chain100 = SDValue(ResNode, 0); 31066 const SDValue Froms[] = { 31067 SDValue(N100.getNode(), 1), 31068 SDValue(N.getNode(), 0) 31069 }; 31070 const SDValue Tos[] = { 31071 SDValue(ResNode, 0), 31072 SDValue(Chain100.getNode(), Chain100.getResNo()) 31073 }; 31074 ReplaceUses(Froms, Tos, 2); 31075 return ResNode; 31076 } 31077 SDNode *Emit_205(const SDValue &N, unsigned Opc0, SDValue &CPTmpN1001_0, SDValue &CPTmpN1001_1, SDValue &CPTmpN1001_2, SDValue &CPTmpN1001_3, SDValue &CPTmpN1001_4) DISABLE_INLINE { 31078 SDValue Chain = N.getOperand(0); 31079 SDValue N1 = N.getOperand(1); 31080 SDValue N10 = N1.getOperand(0); 31081 SDValue N100 = N10.getOperand(0); 31082 SDValue Chain100 = N100.getOperand(0); 31083 SDValue N1001 = N100.getOperand(1); 31084 SDValue N101 = N10.getOperand(1); 31085 SDValue N11 = N1.getOperand(1); 31086 SDValue N110 = N11.getOperand(0); 31087 SDValue N111 = N11.getOperand(1); 31088 SDValue N2 = N.getOperand(2); 31089 SmallVector<SDValue, 8> InChains; 31090 if (Chain.getNode() != N100.getNode()) { 31091 InChains.push_back(Chain); 31092 } 31093 InChains.push_back(Chain100); 31094 Chain100 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 31095 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N101)->getZExtValue()), MVT::i8); 31096 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31097 SDValue LSI_N100 = CurDAG->getMemOperand(cast<MemSDNode>(N100)->getMemOperand()); 31098 SDValue Ops0[] = { CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4, N110, Tmp2, LSI_N, LSI_N100, Chain100 }; 31099 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 10); 31100 Chain100 = SDValue(ResNode, 0); 31101 const SDValue Froms[] = { 31102 SDValue(N100.getNode(), 1), 31103 SDValue(N.getNode(), 0) 31104 }; 31105 const SDValue Tos[] = { 31106 SDValue(ResNode, 0), 31107 SDValue(Chain100.getNode(), Chain100.getResNo()) 31108 }; 31109 ReplaceUses(Froms, Tos, 2); 31110 return ResNode; 31111 } 31112 SDNode *Emit_206(const SDValue &N, unsigned Opc0, SDValue &CPTmpN1001_0, SDValue &CPTmpN1001_1, SDValue &CPTmpN1001_2, SDValue &CPTmpN1001_3, SDValue &CPTmpN1001_4) DISABLE_INLINE { 31113 SDValue Chain = N.getOperand(0); 31114 SDValue N1 = N.getOperand(1); 31115 SDValue N10 = N1.getOperand(0); 31116 SDValue N100 = N10.getOperand(0); 31117 SDValue Chain100 = N100.getOperand(0); 31118 SDValue N1001 = N100.getOperand(1); 31119 SDValue N101 = N10.getOperand(1); 31120 SDValue N1010 = N101.getOperand(0); 31121 SDValue N11 = N1.getOperand(1); 31122 SDValue N110 = N11.getOperand(0); 31123 SDValue N111 = N11.getOperand(1); 31124 SDValue N1110 = N111.getOperand(0); 31125 SDValue N11100 = N1110.getOperand(0); 31126 SDValue N11101 = N1110.getOperand(1); 31127 SDValue N2 = N.getOperand(2); 31128 SmallVector<SDValue, 8> InChains; 31129 if (Chain.getNode() != N100.getNode()) { 31130 InChains.push_back(Chain); 31131 } 31132 InChains.push_back(Chain100); 31133 Chain100 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 31134 SDValue InFlag(0, 0); 31135 SDNode *ResNode = CurDAG->getCopyToReg(Chain100, N101.getDebugLoc(), X86::CX, N1010, InFlag).getNode(); 31136 Chain100 = SDValue(ResNode, 0); 31137 InFlag = SDValue(ResNode, 1); 31138 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31139 SDValue LSI_N100 = CurDAG->getMemOperand(cast<MemSDNode>(N100)->getMemOperand()); 31140 SDValue Ops0[] = { CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4, N110, LSI_N, LSI_N100, Chain100, InFlag }; 31141 ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 10); 31142 Chain100 = SDValue(ResNode, 0); 31143 const SDValue Froms[] = { 31144 SDValue(N100.getNode(), 1), 31145 SDValue(N.getNode(), 0) 31146 }; 31147 const SDValue Tos[] = { 31148 SDValue(ResNode, 0), 31149 SDValue(Chain100.getNode(), Chain100.getResNo()) 31150 }; 31151 ReplaceUses(Froms, Tos, 2); 31152 return ResNode; 31153 } 31154 SDNode *Emit_207(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 31155 SDValue Chain = N.getOperand(0); 31156 SDValue N1 = N.getOperand(1); 31157 SDValue N10 = N1.getOperand(0); 31158 SDValue Chain10 = N10.getOperand(0); 31159 SDValue N101 = N10.getOperand(1); 31160 SDValue N2 = N.getOperand(2); 31161 SmallVector<SDValue, 8> InChains; 31162 if (Chain.getNode() != N10.getNode()) { 31163 InChains.push_back(Chain); 31164 } 31165 InChains.push_back(Chain10); 31166 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 31167 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31168 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 31169 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, LSI_N, LSI_N10, Chain10 }; 31170 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 8); 31171 Chain10 = SDValue(ResNode, 1); 31172 const SDValue Froms[] = { 31173 SDValue(N10.getNode(), 1), 31174 SDValue(N.getNode(), 0) 31175 }; 31176 const SDValue Tos[] = { 31177 SDValue(ResNode, 1), 31178 SDValue(Chain10.getNode(), Chain10.getResNo()) 31179 }; 31180 ReplaceUses(Froms, Tos, 2); 31181 return ResNode; 31182 } 31183 SDNode *Emit_208(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 31184 SDValue Chain = N.getOperand(0); 31185 SDValue N1 = N.getOperand(1); 31186 SDValue N10 = N1.getOperand(0); 31187 SDValue Chain10 = N10.getOperand(0); 31188 SDValue N101 = N10.getOperand(1); 31189 SDValue N11 = N1.getOperand(1); 31190 SDValue N2 = N.getOperand(2); 31191 SmallVector<SDValue, 8> InChains; 31192 if (Chain.getNode() != N10.getNode()) { 31193 InChains.push_back(Chain); 31194 } 31195 InChains.push_back(Chain10); 31196 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 31197 SDValue Tmp3 = CurDAG->getTargetConstant(0xFFFFFFFFFFFFFF80ULL, MVT::i64); 31198 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31199 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 31200 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, Tmp3, LSI_N, LSI_N10, Chain10 }; 31201 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 9); 31202 Chain10 = SDValue(ResNode, 0); 31203 const SDValue Froms[] = { 31204 SDValue(N10.getNode(), 1), 31205 SDValue(N.getNode(), 0) 31206 }; 31207 const SDValue Tos[] = { 31208 SDValue(ResNode, 0), 31209 SDValue(Chain10.getNode(), Chain10.getResNo()) 31210 }; 31211 ReplaceUses(Froms, Tos, 2); 31212 return ResNode; 31213 } 31214 SDNode *Emit_209(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 31215 SDValue Chain = N.getOperand(0); 31216 SDValue N1 = N.getOperand(1); 31217 SDValue N10 = N1.getOperand(0); 31218 SDValue Chain10 = N10.getOperand(0); 31219 SDValue N101 = N10.getOperand(1); 31220 SDValue N11 = N1.getOperand(1); 31221 SDValue N2 = N.getOperand(2); 31222 SmallVector<SDValue, 8> InChains; 31223 if (Chain.getNode() != N10.getNode()) { 31224 InChains.push_back(Chain); 31225 } 31226 InChains.push_back(Chain10); 31227 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 31228 SDValue Tmp3 = CurDAG->getTargetConstant(0xFFFFFFFF80000000ULL, MVT::i64); 31229 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31230 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 31231 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, Tmp3, LSI_N, LSI_N10, Chain10 }; 31232 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 9); 31233 Chain10 = SDValue(ResNode, 0); 31234 const SDValue Froms[] = { 31235 SDValue(N10.getNode(), 1), 31236 SDValue(N.getNode(), 0) 31237 }; 31238 const SDValue Tos[] = { 31239 SDValue(ResNode, 0), 31240 SDValue(Chain10.getNode(), Chain10.getResNo()) 31241 }; 31242 ReplaceUses(Froms, Tos, 2); 31243 return ResNode; 31244 } 31245 SDNode *Emit_210(const SDValue &N, unsigned Opc0, unsigned Opc1, unsigned Opc2, EVT VT0, EVT VT1, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 31246 SDValue Chain = N.getOperand(0); 31247 SDValue N1 = N.getOperand(1); 31248 SDValue N10 = N1.getOperand(0); 31249 SDValue N100 = N10.getOperand(0); 31250 SDValue N101 = N10.getOperand(1); 31251 SDValue N2 = N.getOperand(2); 31252 SDValue Tmp4 = CurDAG->getTargetConstant(X86::GR64_ABCDRegClassID, MVT::i32); 31253 SDValue Tmp5(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N100, Tmp4), 0); 31254 SDValue Tmp6 = CurDAG->getTargetConstant(0x2ULL, MVT::i32); 31255 SDValue Tmp7(CurDAG->getTargetNode(Opc1, N.getDebugLoc(), VT1, Tmp5, Tmp6), 0); 31256 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31257 SDValue Ops2[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Tmp7, LSI_N, Chain }; 31258 return CurDAG->SelectNodeTo(N.getNode(), Opc2, MVT::Other, Ops2, 8); 31259 } 31260 SDNode *Emit_211(const SDValue &N, unsigned Opc0, unsigned Opc1, unsigned Opc2, EVT VT0, EVT VT1, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 31261 SDValue Chain = N.getOperand(0); 31262 SDValue N1 = N.getOperand(1); 31263 SDValue N10 = N1.getOperand(0); 31264 SDValue N100 = N10.getOperand(0); 31265 SDValue N101 = N10.getOperand(1); 31266 SDValue N2 = N.getOperand(2); 31267 SDValue Tmp4 = CurDAG->getTargetConstant(X86::GR32_ABCDRegClassID, MVT::i32); 31268 SDValue Tmp5(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N100, Tmp4), 0); 31269 SDValue Tmp6 = CurDAG->getTargetConstant(0x2ULL, MVT::i32); 31270 SDValue Tmp7(CurDAG->getTargetNode(Opc1, N.getDebugLoc(), VT1, Tmp5, Tmp6), 0); 31271 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31272 SDValue Ops2[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Tmp7, LSI_N, Chain }; 31273 return CurDAG->SelectNodeTo(N.getNode(), Opc2, MVT::Other, Ops2, 8); 31274 } 31275 SDNode *Emit_212(const SDValue &N, unsigned Opc0, unsigned Opc1, unsigned Opc2, EVT VT0, EVT VT1, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 31276 SDValue Chain = N.getOperand(0); 31277 SDValue N1 = N.getOperand(1); 31278 SDValue N10 = N1.getOperand(0); 31279 SDValue N100 = N10.getOperand(0); 31280 SDValue N101 = N10.getOperand(1); 31281 SDValue N2 = N.getOperand(2); 31282 SDValue Tmp4 = CurDAG->getTargetConstant(X86::GR16_ABCDRegClassID, MVT::i32); 31283 SDValue Tmp5(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N100, Tmp4), 0); 31284 SDValue Tmp6 = CurDAG->getTargetConstant(0x2ULL, MVT::i32); 31285 SDValue Tmp7(CurDAG->getTargetNode(Opc1, N.getDebugLoc(), VT1, Tmp5, Tmp6), 0); 31286 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31287 SDValue Ops2[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, Tmp7, LSI_N, Chain }; 31288 return CurDAG->SelectNodeTo(N.getNode(), Opc2, MVT::Other, Ops2, 8); 31289 } 31290 SDNode *Emit_213(const SDValue &N, unsigned Opc0, SDValue &CPTmpN1001_0, SDValue &CPTmpN1001_1, SDValue &CPTmpN1001_2, SDValue &CPTmpN1001_3, SDValue &CPTmpN1001_4) DISABLE_INLINE { 31291 SDValue Chain = N.getOperand(0); 31292 SDValue N1 = N.getOperand(1); 31293 SDValue N10 = N1.getOperand(0); 31294 SDValue N100 = N10.getOperand(0); 31295 SDValue Chain100 = N100.getOperand(0); 31296 SDValue N1001 = N100.getOperand(1); 31297 SDValue N101 = N10.getOperand(1); 31298 SDValue N1010 = N101.getOperand(0); 31299 SDValue N11 = N1.getOperand(1); 31300 SDValue N110 = N11.getOperand(0); 31301 SDValue N111 = N11.getOperand(1); 31302 SDValue N1110 = N111.getOperand(0); 31303 SDValue N11100 = N1110.getOperand(0); 31304 SDValue N11101 = N1110.getOperand(1); 31305 SDValue N2 = N.getOperand(2); 31306 SmallVector<SDValue, 8> InChains; 31307 if (Chain.getNode() != N100.getNode()) { 31308 InChains.push_back(Chain); 31309 } 31310 InChains.push_back(Chain100); 31311 Chain100 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 31312 SDValue InFlag(0, 0); 31313 SDNode *ResNode = CurDAG->getCopyToReg(Chain100, N101.getDebugLoc(), X86::RCX, N1010, InFlag).getNode(); 31314 Chain100 = SDValue(ResNode, 0); 31315 InFlag = SDValue(ResNode, 1); 31316 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31317 SDValue LSI_N100 = CurDAG->getMemOperand(cast<MemSDNode>(N100)->getMemOperand()); 31318 SDValue Ops0[] = { CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4, N110, LSI_N, LSI_N100, Chain100, InFlag }; 31319 ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 10); 31320 Chain100 = SDValue(ResNode, 0); 31321 const SDValue Froms[] = { 31322 SDValue(N100.getNode(), 1), 31323 SDValue(N.getNode(), 0) 31324 }; 31325 const SDValue Tos[] = { 31326 SDValue(ResNode, 0), 31327 SDValue(Chain100.getNode(), Chain100.getResNo()) 31328 }; 31329 ReplaceUses(Froms, Tos, 2); 31330 return ResNode; 31331 } 31332 SDNode *Emit_214(const SDValue &N, unsigned Opc0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 31333 SDValue Chain = N.getOperand(0); 31334 SDValue N1 = N.getOperand(1); 31335 SDValue N10 = N1.getOperand(0); 31336 SDValue Chain10 = N10.getOperand(0); 31337 SDValue N101 = N10.getOperand(1); 31338 SDValue N11 = N1.getOperand(1); 31339 SDValue N2 = N.getOperand(2); 31340 SmallVector<SDValue, 8> InChains; 31341 if (Chain.getNode() != N10.getNode()) { 31342 InChains.push_back(Chain); 31343 } 31344 InChains.push_back(Chain10); 31345 Chain10 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 31346 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31347 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 31348 SDValue Ops0[] = { CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, N11, LSI_N, LSI_N10, Chain10 }; 31349 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 9); 31350 Chain10 = SDValue(ResNode, 0); 31351 const SDValue Froms[] = { 31352 SDValue(N10.getNode(), 1), 31353 SDValue(N.getNode(), 0) 31354 }; 31355 const SDValue Tos[] = { 31356 SDValue(ResNode, 0), 31357 SDValue(Chain10.getNode(), Chain10.getResNo()) 31358 }; 31359 ReplaceUses(Froms, Tos, 2); 31360 return ResNode; 31361 } 31362 SDNode *Emit_215(const SDValue &N, unsigned Opc0, SDValue &CPTmpN1001_0, SDValue &CPTmpN1001_1, SDValue &CPTmpN1001_2, SDValue &CPTmpN1001_3, SDValue &CPTmpN1001_4) DISABLE_INLINE { 31363 SDValue Chain = N.getOperand(0); 31364 SDValue N1 = N.getOperand(1); 31365 SDValue N10 = N1.getOperand(0); 31366 SDValue N100 = N10.getOperand(0); 31367 SDValue Chain100 = N100.getOperand(0); 31368 SDValue N1001 = N100.getOperand(1); 31369 SDValue N11 = N1.getOperand(1); 31370 SDValue N2 = N.getOperand(2); 31371 SmallVector<SDValue, 8> InChains; 31372 if (Chain.getNode() != N100.getNode()) { 31373 InChains.push_back(Chain); 31374 } 31375 InChains.push_back(Chain100); 31376 Chain100 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 31377 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31378 SDValue LSI_N100 = CurDAG->getMemOperand(cast<MemSDNode>(N100)->getMemOperand()); 31379 SDValue Ops0[] = { CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4, N11, LSI_N, LSI_N100, Chain100 }; 31380 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 9); 31381 Chain100 = SDValue(ResNode, 0); 31382 const SDValue Froms[] = { 31383 SDValue(N100.getNode(), 1), 31384 SDValue(N.getNode(), 0) 31385 }; 31386 const SDValue Tos[] = { 31387 SDValue(ResNode, 0), 31388 SDValue(Chain100.getNode(), Chain100.getResNo()) 31389 }; 31390 ReplaceUses(Froms, Tos, 2); 31391 return ResNode; 31392 } 31393 SDNode *Emit_216(const SDValue &N, unsigned Opc0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 31394 SDValue Chain = N.getOperand(0); 31395 SDValue N1 = N.getOperand(1); 31396 SDValue N10 = N1.getOperand(0); 31397 SDValue N100 = N10.getOperand(0); 31398 SDValue N1000 = N100.getOperand(0); 31399 SDValue N101 = N10.getOperand(1); 31400 SDValue N2 = N.getOperand(2); 31401 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N101)->getZExtValue()), MVT::i32); 31402 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31403 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, N1000, Tmp2, LSI_N, Chain }; 31404 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 9); 31405 } 31406 SDNode *Emit_217(const SDValue &N, unsigned Opc0, SDValue &CPTmpN111_0, SDValue &CPTmpN111_1, SDValue &CPTmpN111_2, SDValue &CPTmpN111_3, SDValue &CPTmpN111_4) DISABLE_INLINE { 31407 SDValue Chain = N.getOperand(0); 31408 SDValue N1 = N.getOperand(1); 31409 SDValue N10 = N1.getOperand(0); 31410 SDValue N11 = N1.getOperand(1); 31411 SDValue Chain11 = N11.getOperand(0); 31412 SDValue N111 = N11.getOperand(1); 31413 SDValue N2 = N.getOperand(2); 31414 SmallVector<SDValue, 8> InChains; 31415 if (Chain.getNode() != N11.getNode()) { 31416 InChains.push_back(Chain); 31417 } 31418 InChains.push_back(Chain11); 31419 Chain11 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 31420 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31421 SDValue LSI_N11 = CurDAG->getMemOperand(cast<MemSDNode>(N11)->getMemOperand()); 31422 SDValue Ops0[] = { CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4, N10, LSI_N, LSI_N11, Chain11 }; 31423 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 9); 31424 Chain11 = SDValue(ResNode, 1); 31425 const SDValue Froms[] = { 31426 SDValue(N11.getNode(), 1), 31427 SDValue(N.getNode(), 0) 31428 }; 31429 const SDValue Tos[] = { 31430 SDValue(ResNode, 1), 31431 SDValue(Chain11.getNode(), Chain11.getResNo()) 31432 }; 31433 ReplaceUses(Froms, Tos, 2); 31434 return ResNode; 31435 } 31436 SDNode *Emit_218(const SDValue &N, unsigned Opc0, SDValue &CPTmpN111_0, SDValue &CPTmpN111_1, SDValue &CPTmpN111_2, SDValue &CPTmpN111_3, SDValue &CPTmpN111_4) DISABLE_INLINE { 31437 SDValue Chain = N.getOperand(0); 31438 SDValue N1 = N.getOperand(1); 31439 SDValue N10 = N1.getOperand(0); 31440 SDValue N11 = N1.getOperand(1); 31441 SDValue Chain11 = N11.getOperand(0); 31442 SDValue N111 = N11.getOperand(1); 31443 SDValue N2 = N.getOperand(2); 31444 SmallVector<SDValue, 8> InChains; 31445 if (Chain.getNode() != N11.getNode()) { 31446 InChains.push_back(Chain); 31447 } 31448 InChains.push_back(Chain11); 31449 Chain11 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 31450 SDValue InFlag = N1.getOperand(2); 31451 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31452 SDValue LSI_N11 = CurDAG->getMemOperand(cast<MemSDNode>(N11)->getMemOperand()); 31453 SDValue Ops0[] = { CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4, N10, LSI_N, LSI_N11, Chain11, InFlag }; 31454 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, MVT::Flag, Ops0, 10); 31455 Chain11 = SDValue(ResNode, 0); 31456 InFlag = SDValue(ResNode, 1); 31457 const SDValue Froms[] = { 31458 SDValue(N11.getNode(), 1), 31459 SDValue(N1.getNode(), 1), 31460 SDValue(N.getNode(), 0) 31461 }; 31462 const SDValue Tos[] = { 31463 SDValue(ResNode, 0), 31464 InFlag, 31465 SDValue(Chain11.getNode(), Chain11.getResNo()) 31466 }; 31467 ReplaceUses(Froms, Tos, 3); 31468 return ResNode; 31469 } 31470 SDNode *Emit_219(const SDValue &N, unsigned Opc0, SDValue &CPTmpN1101_0, SDValue &CPTmpN1101_1, SDValue &CPTmpN1101_2, SDValue &CPTmpN1101_3, SDValue &CPTmpN1101_4) DISABLE_INLINE { 31471 SDValue Chain = N.getOperand(0); 31472 SDValue N1 = N.getOperand(1); 31473 SDValue N10 = N1.getOperand(0); 31474 SDValue N100 = N10.getOperand(0); 31475 SDValue N101 = N10.getOperand(1); 31476 SDValue N1010 = N101.getOperand(0); 31477 SDValue N1011 = N101.getOperand(1); 31478 SDValue N11 = N1.getOperand(1); 31479 SDValue N110 = N11.getOperand(0); 31480 SDValue Chain110 = N110.getOperand(0); 31481 SDValue N1101 = N110.getOperand(1); 31482 SDValue N111 = N11.getOperand(1); 31483 SDValue N2 = N.getOperand(2); 31484 SmallVector<SDValue, 8> InChains; 31485 if (Chain.getNode() != N110.getNode()) { 31486 InChains.push_back(Chain); 31487 } 31488 InChains.push_back(Chain110); 31489 Chain110 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 31490 SDValue InFlag(0, 0); 31491 SDNode *ResNode = CurDAG->getCopyToReg(Chain110, N101.getDebugLoc(), X86::CL, N1011, InFlag).getNode(); 31492 Chain110 = SDValue(ResNode, 0); 31493 InFlag = SDValue(ResNode, 1); 31494 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31495 SDValue LSI_N110 = CurDAG->getMemOperand(cast<MemSDNode>(N110)->getMemOperand()); 31496 SDValue Ops0[] = { CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4, N100, LSI_N, LSI_N110, Chain110, InFlag }; 31497 ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 10); 31498 Chain110 = SDValue(ResNode, 0); 31499 const SDValue Froms[] = { 31500 SDValue(N110.getNode(), 1), 31501 SDValue(N.getNode(), 0) 31502 }; 31503 const SDValue Tos[] = { 31504 SDValue(ResNode, 0), 31505 SDValue(Chain110.getNode(), Chain110.getResNo()) 31506 }; 31507 ReplaceUses(Froms, Tos, 2); 31508 return ResNode; 31509 } 31510 SDNode *Emit_220(const SDValue &N, unsigned Opc0, SDValue &CPTmpN1101_0, SDValue &CPTmpN1101_1, SDValue &CPTmpN1101_2, SDValue &CPTmpN1101_3, SDValue &CPTmpN1101_4) DISABLE_INLINE { 31511 SDValue Chain = N.getOperand(0); 31512 SDValue N1 = N.getOperand(1); 31513 SDValue N10 = N1.getOperand(0); 31514 SDValue N100 = N10.getOperand(0); 31515 SDValue N101 = N10.getOperand(1); 31516 SDValue N1010 = N101.getOperand(0); 31517 SDValue N10100 = N1010.getOperand(0); 31518 SDValue N10101 = N1010.getOperand(1); 31519 SDValue N11 = N1.getOperand(1); 31520 SDValue N110 = N11.getOperand(0); 31521 SDValue Chain110 = N110.getOperand(0); 31522 SDValue N1101 = N110.getOperand(1); 31523 SDValue N111 = N11.getOperand(1); 31524 SDValue N1110 = N111.getOperand(0); 31525 SDValue N2 = N.getOperand(2); 31526 SmallVector<SDValue, 8> InChains; 31527 if (Chain.getNode() != N110.getNode()) { 31528 InChains.push_back(Chain); 31529 } 31530 InChains.push_back(Chain110); 31531 Chain110 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 31532 SDValue InFlag(0, 0); 31533 SDNode *ResNode = CurDAG->getCopyToReg(Chain110, N1010.getDebugLoc(), X86::ECX, N10101, InFlag).getNode(); 31534 Chain110 = SDValue(ResNode, 0); 31535 InFlag = SDValue(ResNode, 1); 31536 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31537 SDValue LSI_N110 = CurDAG->getMemOperand(cast<MemSDNode>(N110)->getMemOperand()); 31538 SDValue Ops0[] = { CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4, N100, LSI_N, LSI_N110, Chain110, InFlag }; 31539 ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 10); 31540 Chain110 = SDValue(ResNode, 0); 31541 const SDValue Froms[] = { 31542 SDValue(N110.getNode(), 1), 31543 SDValue(N.getNode(), 0) 31544 }; 31545 const SDValue Tos[] = { 31546 SDValue(ResNode, 0), 31547 SDValue(Chain110.getNode(), Chain110.getResNo()) 31548 }; 31549 ReplaceUses(Froms, Tos, 2); 31550 return ResNode; 31551 } 31552 SDNode *Emit_221(const SDValue &N, unsigned Opc0, SDValue &CPTmpN1101_0, SDValue &CPTmpN1101_1, SDValue &CPTmpN1101_2, SDValue &CPTmpN1101_3, SDValue &CPTmpN1101_4) DISABLE_INLINE { 31553 SDValue Chain = N.getOperand(0); 31554 SDValue N1 = N.getOperand(1); 31555 SDValue N10 = N1.getOperand(0); 31556 SDValue N100 = N10.getOperand(0); 31557 SDValue N101 = N10.getOperand(1); 31558 SDValue N11 = N1.getOperand(1); 31559 SDValue N110 = N11.getOperand(0); 31560 SDValue Chain110 = N110.getOperand(0); 31561 SDValue N1101 = N110.getOperand(1); 31562 SDValue N111 = N11.getOperand(1); 31563 SDValue N2 = N.getOperand(2); 31564 SmallVector<SDValue, 8> InChains; 31565 if (Chain.getNode() != N110.getNode()) { 31566 InChains.push_back(Chain); 31567 } 31568 InChains.push_back(Chain110); 31569 Chain110 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 31570 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N111)->getZExtValue()), MVT::i8); 31571 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31572 SDValue LSI_N110 = CurDAG->getMemOperand(cast<MemSDNode>(N110)->getMemOperand()); 31573 SDValue Ops0[] = { CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4, N100, Tmp2, LSI_N, LSI_N110, Chain110 }; 31574 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 10); 31575 Chain110 = SDValue(ResNode, 0); 31576 const SDValue Froms[] = { 31577 SDValue(N110.getNode(), 1), 31578 SDValue(N.getNode(), 0) 31579 }; 31580 const SDValue Tos[] = { 31581 SDValue(ResNode, 0), 31582 SDValue(Chain110.getNode(), Chain110.getResNo()) 31583 }; 31584 ReplaceUses(Froms, Tos, 2); 31585 return ResNode; 31586 } 31587 SDNode *Emit_222(const SDValue &N, unsigned Opc0, SDValue &CPTmpN1101_0, SDValue &CPTmpN1101_1, SDValue &CPTmpN1101_2, SDValue &CPTmpN1101_3, SDValue &CPTmpN1101_4) DISABLE_INLINE { 31588 SDValue Chain = N.getOperand(0); 31589 SDValue N1 = N.getOperand(1); 31590 SDValue N10 = N1.getOperand(0); 31591 SDValue N100 = N10.getOperand(0); 31592 SDValue N101 = N10.getOperand(1); 31593 SDValue N1010 = N101.getOperand(0); 31594 SDValue N10100 = N1010.getOperand(0); 31595 SDValue N10101 = N1010.getOperand(1); 31596 SDValue N11 = N1.getOperand(1); 31597 SDValue N110 = N11.getOperand(0); 31598 SDValue Chain110 = N110.getOperand(0); 31599 SDValue N1101 = N110.getOperand(1); 31600 SDValue N111 = N11.getOperand(1); 31601 SDValue N1110 = N111.getOperand(0); 31602 SDValue N2 = N.getOperand(2); 31603 SmallVector<SDValue, 8> InChains; 31604 if (Chain.getNode() != N110.getNode()) { 31605 InChains.push_back(Chain); 31606 } 31607 InChains.push_back(Chain110); 31608 Chain110 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 31609 SDValue InFlag(0, 0); 31610 SDNode *ResNode = CurDAG->getCopyToReg(Chain110, N1010.getDebugLoc(), X86::CX, N10101, InFlag).getNode(); 31611 Chain110 = SDValue(ResNode, 0); 31612 InFlag = SDValue(ResNode, 1); 31613 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31614 SDValue LSI_N110 = CurDAG->getMemOperand(cast<MemSDNode>(N110)->getMemOperand()); 31615 SDValue Ops0[] = { CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4, N100, LSI_N, LSI_N110, Chain110, InFlag }; 31616 ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 10); 31617 Chain110 = SDValue(ResNode, 0); 31618 const SDValue Froms[] = { 31619 SDValue(N110.getNode(), 1), 31620 SDValue(N.getNode(), 0) 31621 }; 31622 const SDValue Tos[] = { 31623 SDValue(ResNode, 0), 31624 SDValue(Chain110.getNode(), Chain110.getResNo()) 31625 }; 31626 ReplaceUses(Froms, Tos, 2); 31627 return ResNode; 31628 } 31629 SDNode *Emit_223(const SDValue &N, unsigned Opc0, SDValue &CPTmpN1101_0, SDValue &CPTmpN1101_1, SDValue &CPTmpN1101_2, SDValue &CPTmpN1101_3, SDValue &CPTmpN1101_4) DISABLE_INLINE { 31630 SDValue Chain = N.getOperand(0); 31631 SDValue N1 = N.getOperand(1); 31632 SDValue N10 = N1.getOperand(0); 31633 SDValue N100 = N10.getOperand(0); 31634 SDValue N101 = N10.getOperand(1); 31635 SDValue N1010 = N101.getOperand(0); 31636 SDValue N10100 = N1010.getOperand(0); 31637 SDValue N10101 = N1010.getOperand(1); 31638 SDValue N11 = N1.getOperand(1); 31639 SDValue N110 = N11.getOperand(0); 31640 SDValue Chain110 = N110.getOperand(0); 31641 SDValue N1101 = N110.getOperand(1); 31642 SDValue N111 = N11.getOperand(1); 31643 SDValue N1110 = N111.getOperand(0); 31644 SDValue N2 = N.getOperand(2); 31645 SmallVector<SDValue, 8> InChains; 31646 if (Chain.getNode() != N110.getNode()) { 31647 InChains.push_back(Chain); 31648 } 31649 InChains.push_back(Chain110); 31650 Chain110 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 31651 SDValue InFlag(0, 0); 31652 SDNode *ResNode = CurDAG->getCopyToReg(Chain110, N1010.getDebugLoc(), X86::RCX, N10101, InFlag).getNode(); 31653 Chain110 = SDValue(ResNode, 0); 31654 InFlag = SDValue(ResNode, 1); 31655 SDValue LSI_N = CurDAG->getMemOperand(cast<MemSDNode>(N)->getMemOperand()); 31656 SDValue LSI_N110 = CurDAG->getMemOperand(cast<MemSDNode>(N110)->getMemOperand()); 31657 SDValue Ops0[] = { CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4, N100, LSI_N, LSI_N110, Chain110, InFlag }; 31658 ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 10); 31659 Chain110 = SDValue(ResNode, 0); 31660 const SDValue Froms[] = { 31661 SDValue(N110.getNode(), 1), 31662 SDValue(N.getNode(), 0) 31663 }; 31664 const SDValue Tos[] = { 31665 SDValue(ResNode, 0), 31666 SDValue(Chain110.getNode(), Chain110.getResNo()) 31667 }; 31668 ReplaceUses(Froms, Tos, 2); 31669 return ResNode; 31670 } 31671 SDNode *Select_ISD_STORE(const SDValue &N) { 31672 if (OptLevel != CodeGenOpt::None) { 31673 { 31674 SDValue Chain = N.getOperand(0); 31675 if (Predicate_unindexedstore(N.getNode()) && 31676 Predicate_store(N.getNode())) { 31677 SDValue N1 = N.getOperand(1); 31678 if (N1.getOpcode() == ISD::OR && 31679 N1.hasOneUse()) { 31680 { 31681 SDValue N10 = N1.getOperand(0); 31682 31683 // Pattern: (st:isVoid (or:i32 (srl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (trunc:i8 ECX:i32:$amt)), (shl:i32 GR32:i32:$src2, (trunc:i8 (sub:i32 32:i32, ECX:i32:$amt)))), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 31684 // Emits: (SHRD32mrCL:isVoid addr:iPTR:$dst, GR32:i32:$src2) 31685 // Pattern complexity = 67 cost = 1 size = 3 31686 if (N10.getOpcode() == ISD::SRL && 31687 N10.hasOneUse()) { 31688 SDValue N100 = N10.getOperand(0); 31689 if (N100.getOpcode() == ISD::LOAD && 31690 N100.hasOneUse() && 31691 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 31692 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 31693 SDValue Chain100 = N100.getOperand(0); 31694 if (Predicate_unindexedload(N100.getNode()) && 31695 Predicate_loadi32(N100.getNode())) { 31696 SDValue N1001 = N100.getOperand(1); 31697 SDValue CPTmpN1001_0; 31698 SDValue CPTmpN1001_1; 31699 SDValue CPTmpN1001_2; 31700 SDValue CPTmpN1001_3; 31701 SDValue CPTmpN1001_4; 31702 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 31703 SDValue N101 = N10.getOperand(1); 31704 if (N101.getOpcode() == ISD::TRUNCATE) { 31705 SDValue N1010 = N101.getOperand(0); 31706 SDValue N11 = N1.getOperand(1); 31707 if (N11.getOpcode() == ISD::SHL) { 31708 SDValue N110 = N11.getOperand(0); 31709 SDValue N111 = N11.getOperand(1); 31710 if (N111.getOpcode() == ISD::TRUNCATE) { 31711 SDValue N1110 = N111.getOperand(0); 31712 if (N1110.getOpcode() == ISD::SUB) { 31713 SDValue N11100 = N1110.getOperand(0); 31714 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11100); 31715 if (Tmp0) { 31716 int64_t CN1 = Tmp0->getSExtValue(); 31717 if (CN1 == INT64_C(32)) { 31718 SDValue N11101 = N1110.getOperand(1); 31719 if (N1010 == N11101) { 31720 SDValue N2 = N.getOperand(2); 31721 if (N1001 == N2 && 31722 N1.getNode()->getValueType(0) == MVT::i32 && 31723 N101.getNode()->getValueType(0) == MVT::i8 && 31724 N1010.getNode()->getValueType(0) == MVT::i32 && 31725 N111.getNode()->getValueType(0) == MVT::i8 && 31726 N1110.getNode()->getValueType(0) == MVT::i32) { 31727 SDNode *Result = Emit_204(N, X86::SHRD32mrCL, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 31728 return Result; 31729 } 31730 } 31731 } 31732 } 31733 } 31734 } 31735 } 31736 } 31737 } 31738 } 31739 } 31740 } 31741 31742 // Pattern: (st:isVoid (or:i32 (shl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (trunc:i8 ECX:i32:$amt)), (srl:i32 GR32:i32:$src2, (trunc:i8 (sub:i32 32:i32, ECX:i32:$amt)))), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 31743 // Emits: (SHLD32mrCL:isVoid addr:iPTR:$dst, GR32:i32:$src2) 31744 // Pattern complexity = 67 cost = 1 size = 3 31745 if (N10.getOpcode() == ISD::SHL && 31746 N10.hasOneUse()) { 31747 SDValue N100 = N10.getOperand(0); 31748 if (N100.getOpcode() == ISD::LOAD && 31749 N100.hasOneUse() && 31750 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 31751 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 31752 SDValue Chain100 = N100.getOperand(0); 31753 if (Predicate_unindexedload(N100.getNode()) && 31754 Predicate_loadi32(N100.getNode())) { 31755 SDValue N1001 = N100.getOperand(1); 31756 SDValue CPTmpN1001_0; 31757 SDValue CPTmpN1001_1; 31758 SDValue CPTmpN1001_2; 31759 SDValue CPTmpN1001_3; 31760 SDValue CPTmpN1001_4; 31761 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 31762 SDValue N101 = N10.getOperand(1); 31763 if (N101.getOpcode() == ISD::TRUNCATE) { 31764 SDValue N1010 = N101.getOperand(0); 31765 SDValue N11 = N1.getOperand(1); 31766 if (N11.getOpcode() == ISD::SRL) { 31767 SDValue N110 = N11.getOperand(0); 31768 SDValue N111 = N11.getOperand(1); 31769 if (N111.getOpcode() == ISD::TRUNCATE) { 31770 SDValue N1110 = N111.getOperand(0); 31771 if (N1110.getOpcode() == ISD::SUB) { 31772 SDValue N11100 = N1110.getOperand(0); 31773 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11100); 31774 if (Tmp0) { 31775 int64_t CN1 = Tmp0->getSExtValue(); 31776 if (CN1 == INT64_C(32)) { 31777 SDValue N11101 = N1110.getOperand(1); 31778 if (N1010 == N11101) { 31779 SDValue N2 = N.getOperand(2); 31780 if (N1001 == N2 && 31781 N1.getNode()->getValueType(0) == MVT::i32 && 31782 N101.getNode()->getValueType(0) == MVT::i8 && 31783 N1010.getNode()->getValueType(0) == MVT::i32 && 31784 N111.getNode()->getValueType(0) == MVT::i8 && 31785 N1110.getNode()->getValueType(0) == MVT::i32) { 31786 SDNode *Result = Emit_204(N, X86::SHLD32mrCL, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 31787 return Result; 31788 } 31789 } 31790 } 31791 } 31792 } 31793 } 31794 } 31795 } 31796 } 31797 } 31798 } 31799 } 31800 31801 // Pattern: (st:isVoid (or:i16 (srl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (trunc:i8 CX:i16:$amt)), (shl:i16 GR16:i16:$src2, (trunc:i8 (sub:i16 16:i16, CX:i16:$amt)))), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 31802 // Emits: (SHRD16mrCL:isVoid addr:iPTR:$dst, GR16:i16:$src2) 31803 // Pattern complexity = 67 cost = 1 size = 3 31804 if (N10.getOpcode() == ISD::SRL && 31805 N10.hasOneUse()) { 31806 SDValue N100 = N10.getOperand(0); 31807 if (N100.getOpcode() == ISD::LOAD && 31808 N100.hasOneUse() && 31809 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 31810 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 31811 SDValue Chain100 = N100.getOperand(0); 31812 if (Predicate_unindexedload(N100.getNode()) && 31813 Predicate_loadi16(N100.getNode())) { 31814 SDValue N1001 = N100.getOperand(1); 31815 SDValue CPTmpN1001_0; 31816 SDValue CPTmpN1001_1; 31817 SDValue CPTmpN1001_2; 31818 SDValue CPTmpN1001_3; 31819 SDValue CPTmpN1001_4; 31820 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 31821 SDValue N101 = N10.getOperand(1); 31822 if (N101.getOpcode() == ISD::TRUNCATE) { 31823 SDValue N1010 = N101.getOperand(0); 31824 SDValue N11 = N1.getOperand(1); 31825 if (N11.getOpcode() == ISD::SHL) { 31826 SDValue N110 = N11.getOperand(0); 31827 SDValue N111 = N11.getOperand(1); 31828 if (N111.getOpcode() == ISD::TRUNCATE) { 31829 SDValue N1110 = N111.getOperand(0); 31830 if (N1110.getOpcode() == ISD::SUB) { 31831 SDValue N11100 = N1110.getOperand(0); 31832 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11100); 31833 if (Tmp0) { 31834 int64_t CN1 = Tmp0->getSExtValue(); 31835 if (CN1 == INT64_C(16)) { 31836 SDValue N11101 = N1110.getOperand(1); 31837 if (N1010 == N11101) { 31838 SDValue N2 = N.getOperand(2); 31839 if (N1001 == N2 && 31840 N1.getNode()->getValueType(0) == MVT::i16 && 31841 N101.getNode()->getValueType(0) == MVT::i8 && 31842 N1010.getNode()->getValueType(0) == MVT::i16 && 31843 N111.getNode()->getValueType(0) == MVT::i8 && 31844 N1110.getNode()->getValueType(0) == MVT::i16) { 31845 SDNode *Result = Emit_206(N, X86::SHRD16mrCL, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 31846 return Result; 31847 } 31848 } 31849 } 31850 } 31851 } 31852 } 31853 } 31854 } 31855 } 31856 } 31857 } 31858 } 31859 31860 // Pattern: (st:isVoid (or:i16 (shl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (trunc:i8 CX:i16:$amt)), (srl:i16 GR16:i16:$src2, (trunc:i8 (sub:i16 16:i16, CX:i16:$amt)))), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 31861 // Emits: (SHLD16mrCL:isVoid addr:iPTR:$dst, GR16:i16:$src2) 31862 // Pattern complexity = 67 cost = 1 size = 3 31863 if (N10.getOpcode() == ISD::SHL && 31864 N10.hasOneUse()) { 31865 SDValue N100 = N10.getOperand(0); 31866 if (N100.getOpcode() == ISD::LOAD && 31867 N100.hasOneUse() && 31868 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 31869 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 31870 SDValue Chain100 = N100.getOperand(0); 31871 if (Predicate_unindexedload(N100.getNode()) && 31872 Predicate_loadi16(N100.getNode())) { 31873 SDValue N1001 = N100.getOperand(1); 31874 SDValue CPTmpN1001_0; 31875 SDValue CPTmpN1001_1; 31876 SDValue CPTmpN1001_2; 31877 SDValue CPTmpN1001_3; 31878 SDValue CPTmpN1001_4; 31879 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 31880 SDValue N101 = N10.getOperand(1); 31881 if (N101.getOpcode() == ISD::TRUNCATE) { 31882 SDValue N1010 = N101.getOperand(0); 31883 SDValue N11 = N1.getOperand(1); 31884 if (N11.getOpcode() == ISD::SRL) { 31885 SDValue N110 = N11.getOperand(0); 31886 SDValue N111 = N11.getOperand(1); 31887 if (N111.getOpcode() == ISD::TRUNCATE) { 31888 SDValue N1110 = N111.getOperand(0); 31889 if (N1110.getOpcode() == ISD::SUB) { 31890 SDValue N11100 = N1110.getOperand(0); 31891 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11100); 31892 if (Tmp0) { 31893 int64_t CN1 = Tmp0->getSExtValue(); 31894 if (CN1 == INT64_C(16)) { 31895 SDValue N11101 = N1110.getOperand(1); 31896 if (N1010 == N11101) { 31897 SDValue N2 = N.getOperand(2); 31898 if (N1001 == N2 && 31899 N1.getNode()->getValueType(0) == MVT::i16 && 31900 N101.getNode()->getValueType(0) == MVT::i8 && 31901 N1010.getNode()->getValueType(0) == MVT::i16 && 31902 N111.getNode()->getValueType(0) == MVT::i8 && 31903 N1110.getNode()->getValueType(0) == MVT::i16) { 31904 SDNode *Result = Emit_206(N, X86::SHLD16mrCL, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 31905 return Result; 31906 } 31907 } 31908 } 31909 } 31910 } 31911 } 31912 } 31913 } 31914 } 31915 } 31916 } 31917 } 31918 31919 // Pattern: (st:isVoid (or:i64 (srl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (trunc:i8 RCX:i64:$amt)), (shl:i64 GR64:i64:$src2, (trunc:i8 (sub:i64 64:i64, RCX:i64:$amt)))), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 31920 // Emits: (SHRD64mrCL:isVoid addr:iPTR:$dst, GR64:i64:$src2) 31921 // Pattern complexity = 67 cost = 1 size = 3 31922 if (N10.getOpcode() == ISD::SRL && 31923 N10.hasOneUse()) { 31924 SDValue N100 = N10.getOperand(0); 31925 if (N100.getOpcode() == ISD::LOAD && 31926 N100.hasOneUse() && 31927 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 31928 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 31929 SDValue Chain100 = N100.getOperand(0); 31930 if (Predicate_unindexedload(N100.getNode()) && 31931 Predicate_load(N100.getNode()) && 31932 Predicate_loadi64(N100.getNode())) { 31933 SDValue N1001 = N100.getOperand(1); 31934 SDValue CPTmpN1001_0; 31935 SDValue CPTmpN1001_1; 31936 SDValue CPTmpN1001_2; 31937 SDValue CPTmpN1001_3; 31938 SDValue CPTmpN1001_4; 31939 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 31940 SDValue N101 = N10.getOperand(1); 31941 if (N101.getOpcode() == ISD::TRUNCATE) { 31942 SDValue N1010 = N101.getOperand(0); 31943 SDValue N11 = N1.getOperand(1); 31944 if (N11.getOpcode() == ISD::SHL) { 31945 SDValue N110 = N11.getOperand(0); 31946 SDValue N111 = N11.getOperand(1); 31947 if (N111.getOpcode() == ISD::TRUNCATE) { 31948 SDValue N1110 = N111.getOperand(0); 31949 if (N1110.getOpcode() == ISD::SUB) { 31950 SDValue N11100 = N1110.getOperand(0); 31951 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11100); 31952 if (Tmp0) { 31953 int64_t CN1 = Tmp0->getSExtValue(); 31954 if (CN1 == INT64_C(64)) { 31955 SDValue N11101 = N1110.getOperand(1); 31956 if (N1010 == N11101) { 31957 SDValue N2 = N.getOperand(2); 31958 if (N1001 == N2 && 31959 N1.getNode()->getValueType(0) == MVT::i64 && 31960 N101.getNode()->getValueType(0) == MVT::i8 && 31961 N1010.getNode()->getValueType(0) == MVT::i64 && 31962 N111.getNode()->getValueType(0) == MVT::i8 && 31963 N1110.getNode()->getValueType(0) == MVT::i64) { 31964 SDNode *Result = Emit_213(N, X86::SHRD64mrCL, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 31965 return Result; 31966 } 31967 } 31968 } 31969 } 31970 } 31971 } 31972 } 31973 } 31974 } 31975 } 31976 } 31977 } 31978 if (N10.getOpcode() == ISD::SHL) { 31979 31980 // Pattern: (st:isVoid (or:i64 (shl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (trunc:i8 RCX:i64:$amt)), (srl:i64 GR64:i64:$src2, (trunc:i8 (sub:i64 64:i64, RCX:i64:$amt)))), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 31981 // Emits: (SHLD64mrCL:isVoid addr:iPTR:$dst, GR64:i64:$src2) 31982 // Pattern complexity = 67 cost = 1 size = 3 31983 if (N10.hasOneUse()) { 31984 SDValue N100 = N10.getOperand(0); 31985 if (N100.getOpcode() == ISD::LOAD && 31986 N100.hasOneUse() && 31987 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 31988 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 31989 SDValue Chain100 = N100.getOperand(0); 31990 if (Predicate_unindexedload(N100.getNode()) && 31991 Predicate_load(N100.getNode()) && 31992 Predicate_loadi64(N100.getNode())) { 31993 SDValue N1001 = N100.getOperand(1); 31994 SDValue CPTmpN1001_0; 31995 SDValue CPTmpN1001_1; 31996 SDValue CPTmpN1001_2; 31997 SDValue CPTmpN1001_3; 31998 SDValue CPTmpN1001_4; 31999 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 32000 SDValue N101 = N10.getOperand(1); 32001 if (N101.getOpcode() == ISD::TRUNCATE) { 32002 SDValue N1010 = N101.getOperand(0); 32003 SDValue N11 = N1.getOperand(1); 32004 if (N11.getOpcode() == ISD::SRL) { 32005 SDValue N110 = N11.getOperand(0); 32006 SDValue N111 = N11.getOperand(1); 32007 if (N111.getOpcode() == ISD::TRUNCATE) { 32008 SDValue N1110 = N111.getOperand(0); 32009 if (N1110.getOpcode() == ISD::SUB) { 32010 SDValue N11100 = N1110.getOperand(0); 32011 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11100); 32012 if (Tmp0) { 32013 int64_t CN1 = Tmp0->getSExtValue(); 32014 if (CN1 == INT64_C(64)) { 32015 SDValue N11101 = N1110.getOperand(1); 32016 if (N1010 == N11101) { 32017 SDValue N2 = N.getOperand(2); 32018 if (N1001 == N2 && 32019 N1.getNode()->getValueType(0) == MVT::i64 && 32020 N101.getNode()->getValueType(0) == MVT::i8 && 32021 N1010.getNode()->getValueType(0) == MVT::i64 && 32022 N111.getNode()->getValueType(0) == MVT::i8 && 32023 N1110.getNode()->getValueType(0) == MVT::i64) { 32024 SDNode *Result = Emit_213(N, X86::SHLD64mrCL, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 32025 return Result; 32026 } 32027 } 32028 } 32029 } 32030 } 32031 } 32032 } 32033 } 32034 } 32035 } 32036 } 32037 } 32038 32039 // Pattern: (st:isVoid (or:i32 (shl:i32 GR32:i32:$src2, (trunc:i8 (sub:i32 32:i32, ECX:i32:$amt))), (srl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (trunc:i8 ECX:i32:$amt))), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 32040 // Emits: (SHRD32mrCL:isVoid addr:iPTR:$dst, GR32:i32:$src2) 32041 // Pattern complexity = 67 cost = 1 size = 3 32042 SDValue N100 = N10.getOperand(0); 32043 SDValue N101 = N10.getOperand(1); 32044 if (N101.getOpcode() == ISD::TRUNCATE) { 32045 SDValue N1010 = N101.getOperand(0); 32046 if (N1010.getOpcode() == ISD::SUB) { 32047 SDValue N10100 = N1010.getOperand(0); 32048 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N10100); 32049 if (Tmp0) { 32050 int64_t CN1 = Tmp0->getSExtValue(); 32051 if (CN1 == INT64_C(32)) { 32052 SDValue N10101 = N1010.getOperand(1); 32053 SDValue N11 = N1.getOperand(1); 32054 if (N11.getOpcode() == ISD::SRL && 32055 N11.hasOneUse()) { 32056 SDValue N110 = N11.getOperand(0); 32057 if (N110.getOpcode() == ISD::LOAD && 32058 N110.hasOneUse() && 32059 IsLegalAndProfitableToFold(N110.getNode(), N11.getNode(), N.getNode()) && 32060 (Chain.getNode() == N110.getNode() || IsChainCompatible(Chain.getNode(), N110.getNode()))) { 32061 SDValue Chain110 = N110.getOperand(0); 32062 if (Predicate_unindexedload(N110.getNode()) && 32063 Predicate_loadi32(N110.getNode())) { 32064 SDValue N1101 = N110.getOperand(1); 32065 SDValue CPTmpN1101_0; 32066 SDValue CPTmpN1101_1; 32067 SDValue CPTmpN1101_2; 32068 SDValue CPTmpN1101_3; 32069 SDValue CPTmpN1101_4; 32070 if (SelectAddr(N, N1101, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4)) { 32071 SDValue N111 = N11.getOperand(1); 32072 if (N111.getOpcode() == ISD::TRUNCATE) { 32073 SDValue N1110 = N111.getOperand(0); 32074 if (N10101 == N1110) { 32075 SDValue N2 = N.getOperand(2); 32076 if (N1101 == N2 && 32077 N1.getNode()->getValueType(0) == MVT::i32 && 32078 N101.getNode()->getValueType(0) == MVT::i8 && 32079 N1010.getNode()->getValueType(0) == MVT::i32 && 32080 N111.getNode()->getValueType(0) == MVT::i8 && 32081 N1110.getNode()->getValueType(0) == MVT::i32) { 32082 SDNode *Result = Emit_220(N, X86::SHRD32mrCL, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4); 32083 return Result; 32084 } 32085 } 32086 } 32087 } 32088 } 32089 } 32090 } 32091 } 32092 } 32093 } 32094 } 32095 } 32096 32097 // Pattern: (st:isVoid (or:i32 (srl:i32 GR32:i32:$src2, (trunc:i8 (sub:i32 32:i32, ECX:i32:$amt))), (shl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (trunc:i8 ECX:i32:$amt))), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 32098 // Emits: (SHLD32mrCL:isVoid addr:iPTR:$dst, GR32:i32:$src2) 32099 // Pattern complexity = 67 cost = 1 size = 3 32100 if (N10.getOpcode() == ISD::SRL) { 32101 SDValue N100 = N10.getOperand(0); 32102 SDValue N101 = N10.getOperand(1); 32103 if (N101.getOpcode() == ISD::TRUNCATE) { 32104 SDValue N1010 = N101.getOperand(0); 32105 if (N1010.getOpcode() == ISD::SUB) { 32106 SDValue N10100 = N1010.getOperand(0); 32107 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N10100); 32108 if (Tmp0) { 32109 int64_t CN1 = Tmp0->getSExtValue(); 32110 if (CN1 == INT64_C(32)) { 32111 SDValue N10101 = N1010.getOperand(1); 32112 SDValue N11 = N1.getOperand(1); 32113 if (N11.getOpcode() == ISD::SHL && 32114 N11.hasOneUse()) { 32115 SDValue N110 = N11.getOperand(0); 32116 if (N110.getOpcode() == ISD::LOAD && 32117 N110.hasOneUse() && 32118 IsLegalAndProfitableToFold(N110.getNode(), N11.getNode(), N.getNode()) && 32119 (Chain.getNode() == N110.getNode() || IsChainCompatible(Chain.getNode(), N110.getNode()))) { 32120 SDValue Chain110 = N110.getOperand(0); 32121 if (Predicate_unindexedload(N110.getNode()) && 32122 Predicate_loadi32(N110.getNode())) { 32123 SDValue N1101 = N110.getOperand(1); 32124 SDValue CPTmpN1101_0; 32125 SDValue CPTmpN1101_1; 32126 SDValue CPTmpN1101_2; 32127 SDValue CPTmpN1101_3; 32128 SDValue CPTmpN1101_4; 32129 if (SelectAddr(N, N1101, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4)) { 32130 SDValue N111 = N11.getOperand(1); 32131 if (N111.getOpcode() == ISD::TRUNCATE) { 32132 SDValue N1110 = N111.getOperand(0); 32133 if (N10101 == N1110) { 32134 SDValue N2 = N.getOperand(2); 32135 if (N1101 == N2 && 32136 N1.getNode()->getValueType(0) == MVT::i32 && 32137 N101.getNode()->getValueType(0) == MVT::i8 && 32138 N1010.getNode()->getValueType(0) == MVT::i32 && 32139 N111.getNode()->getValueType(0) == MVT::i8 && 32140 N1110.getNode()->getValueType(0) == MVT::i32) { 32141 SDNode *Result = Emit_220(N, X86::SHLD32mrCL, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4); 32142 return Result; 32143 } 32144 } 32145 } 32146 } 32147 } 32148 } 32149 } 32150 } 32151 } 32152 } 32153 } 32154 } 32155 32156 // Pattern: (st:isVoid (or:i16 (shl:i16 GR16:i16:$src2, (trunc:i8 (sub:i16 16:i16, CX:i16:$amt))), (srl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (trunc:i8 CX:i16:$amt))), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 32157 // Emits: (SHRD16mrCL:isVoid addr:iPTR:$dst, GR16:i16:$src2) 32158 // Pattern complexity = 67 cost = 1 size = 3 32159 if (N10.getOpcode() == ISD::SHL) { 32160 SDValue N100 = N10.getOperand(0); 32161 SDValue N101 = N10.getOperand(1); 32162 if (N101.getOpcode() == ISD::TRUNCATE) { 32163 SDValue N1010 = N101.getOperand(0); 32164 if (N1010.getOpcode() == ISD::SUB) { 32165 SDValue N10100 = N1010.getOperand(0); 32166 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N10100); 32167 if (Tmp0) { 32168 int64_t CN1 = Tmp0->getSExtValue(); 32169 if (CN1 == INT64_C(16)) { 32170 SDValue N10101 = N1010.getOperand(1); 32171 SDValue N11 = N1.getOperand(1); 32172 if (N11.getOpcode() == ISD::SRL && 32173 N11.hasOneUse()) { 32174 SDValue N110 = N11.getOperand(0); 32175 if (N110.getOpcode() == ISD::LOAD && 32176 N110.hasOneUse() && 32177 IsLegalAndProfitableToFold(N110.getNode(), N11.getNode(), N.getNode()) && 32178 (Chain.getNode() == N110.getNode() || IsChainCompatible(Chain.getNode(), N110.getNode()))) { 32179 SDValue Chain110 = N110.getOperand(0); 32180 if (Predicate_unindexedload(N110.getNode()) && 32181 Predicate_loadi16(N110.getNode())) { 32182 SDValue N1101 = N110.getOperand(1); 32183 SDValue CPTmpN1101_0; 32184 SDValue CPTmpN1101_1; 32185 SDValue CPTmpN1101_2; 32186 SDValue CPTmpN1101_3; 32187 SDValue CPTmpN1101_4; 32188 if (SelectAddr(N, N1101, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4)) { 32189 SDValue N111 = N11.getOperand(1); 32190 if (N111.getOpcode() == ISD::TRUNCATE) { 32191 SDValue N1110 = N111.getOperand(0); 32192 if (N10101 == N1110) { 32193 SDValue N2 = N.getOperand(2); 32194 if (N1101 == N2 && 32195 N1.getNode()->getValueType(0) == MVT::i16 && 32196 N101.getNode()->getValueType(0) == MVT::i8 && 32197 N1010.getNode()->getValueType(0) == MVT::i16 && 32198 N111.getNode()->getValueType(0) == MVT::i8 && 32199 N1110.getNode()->getValueType(0) == MVT::i16) { 32200 SDNode *Result = Emit_222(N, X86::SHRD16mrCL, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4); 32201 return Result; 32202 } 32203 } 32204 } 32205 } 32206 } 32207 } 32208 } 32209 } 32210 } 32211 } 32212 } 32213 } 32214 32215 // Pattern: (st:isVoid (or:i16 (srl:i16 GR16:i16:$src2, (trunc:i8 (sub:i16 16:i16, CX:i16:$amt))), (shl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (trunc:i8 CX:i16:$amt))), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 32216 // Emits: (SHLD16mrCL:isVoid addr:iPTR:$dst, GR16:i16:$src2) 32217 // Pattern complexity = 67 cost = 1 size = 3 32218 if (N10.getOpcode() == ISD::SRL) { 32219 SDValue N100 = N10.getOperand(0); 32220 SDValue N101 = N10.getOperand(1); 32221 if (N101.getOpcode() == ISD::TRUNCATE) { 32222 SDValue N1010 = N101.getOperand(0); 32223 if (N1010.getOpcode() == ISD::SUB) { 32224 SDValue N10100 = N1010.getOperand(0); 32225 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N10100); 32226 if (Tmp0) { 32227 int64_t CN1 = Tmp0->getSExtValue(); 32228 if (CN1 == INT64_C(16)) { 32229 SDValue N10101 = N1010.getOperand(1); 32230 SDValue N11 = N1.getOperand(1); 32231 if (N11.getOpcode() == ISD::SHL && 32232 N11.hasOneUse()) { 32233 SDValue N110 = N11.getOperand(0); 32234 if (N110.getOpcode() == ISD::LOAD && 32235 N110.hasOneUse() && 32236 IsLegalAndProfitableToFold(N110.getNode(), N11.getNode(), N.getNode()) && 32237 (Chain.getNode() == N110.getNode() || IsChainCompatible(Chain.getNode(), N110.getNode()))) { 32238 SDValue Chain110 = N110.getOperand(0); 32239 if (Predicate_unindexedload(N110.getNode()) && 32240 Predicate_loadi16(N110.getNode())) { 32241 SDValue N1101 = N110.getOperand(1); 32242 SDValue CPTmpN1101_0; 32243 SDValue CPTmpN1101_1; 32244 SDValue CPTmpN1101_2; 32245 SDValue CPTmpN1101_3; 32246 SDValue CPTmpN1101_4; 32247 if (SelectAddr(N, N1101, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4)) { 32248 SDValue N111 = N11.getOperand(1); 32249 if (N111.getOpcode() == ISD::TRUNCATE) { 32250 SDValue N1110 = N111.getOperand(0); 32251 if (N10101 == N1110) { 32252 SDValue N2 = N.getOperand(2); 32253 if (N1101 == N2 && 32254 N1.getNode()->getValueType(0) == MVT::i16 && 32255 N101.getNode()->getValueType(0) == MVT::i8 && 32256 N1010.getNode()->getValueType(0) == MVT::i16 && 32257 N111.getNode()->getValueType(0) == MVT::i8 && 32258 N1110.getNode()->getValueType(0) == MVT::i16) { 32259 SDNode *Result = Emit_222(N, X86::SHLD16mrCL, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4); 32260 return Result; 32261 } 32262 } 32263 } 32264 } 32265 } 32266 } 32267 } 32268 } 32269 } 32270 } 32271 } 32272 } 32273 32274 // Pattern: (st:isVoid (or:i64 (shl:i64 GR64:i64:$src2, (trunc:i8 (sub:i64 64:i64, RCX:i64:$amt))), (srl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (trunc:i8 RCX:i64:$amt))), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 32275 // Emits: (SHRD64mrCL:isVoid addr:iPTR:$dst, GR64:i64:$src2) 32276 // Pattern complexity = 67 cost = 1 size = 3 32277 if (N10.getOpcode() == ISD::SHL) { 32278 SDValue N100 = N10.getOperand(0); 32279 SDValue N101 = N10.getOperand(1); 32280 if (N101.getOpcode() == ISD::TRUNCATE) { 32281 SDValue N1010 = N101.getOperand(0); 32282 if (N1010.getOpcode() == ISD::SUB) { 32283 SDValue N10100 = N1010.getOperand(0); 32284 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N10100); 32285 if (Tmp0) { 32286 int64_t CN1 = Tmp0->getSExtValue(); 32287 if (CN1 == INT64_C(64)) { 32288 SDValue N10101 = N1010.getOperand(1); 32289 SDValue N11 = N1.getOperand(1); 32290 if (N11.getOpcode() == ISD::SRL && 32291 N11.hasOneUse()) { 32292 SDValue N110 = N11.getOperand(0); 32293 if (N110.getOpcode() == ISD::LOAD && 32294 N110.hasOneUse() && 32295 IsLegalAndProfitableToFold(N110.getNode(), N11.getNode(), N.getNode()) && 32296 (Chain.getNode() == N110.getNode() || IsChainCompatible(Chain.getNode(), N110.getNode()))) { 32297 SDValue Chain110 = N110.getOperand(0); 32298 if (Predicate_unindexedload(N110.getNode()) && 32299 Predicate_load(N110.getNode()) && 32300 Predicate_loadi64(N110.getNode())) { 32301 SDValue N1101 = N110.getOperand(1); 32302 SDValue CPTmpN1101_0; 32303 SDValue CPTmpN1101_1; 32304 SDValue CPTmpN1101_2; 32305 SDValue CPTmpN1101_3; 32306 SDValue CPTmpN1101_4; 32307 if (SelectAddr(N, N1101, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4)) { 32308 SDValue N111 = N11.getOperand(1); 32309 if (N111.getOpcode() == ISD::TRUNCATE) { 32310 SDValue N1110 = N111.getOperand(0); 32311 if (N10101 == N1110) { 32312 SDValue N2 = N.getOperand(2); 32313 if (N1101 == N2 && 32314 N1.getNode()->getValueType(0) == MVT::i64 && 32315 N101.getNode()->getValueType(0) == MVT::i8 && 32316 N1010.getNode()->getValueType(0) == MVT::i64 && 32317 N111.getNode()->getValueType(0) == MVT::i8 && 32318 N1110.getNode()->getValueType(0) == MVT::i64) { 32319 SDNode *Result = Emit_223(N, X86::SHRD64mrCL, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4); 32320 return Result; 32321 } 32322 } 32323 } 32324 } 32325 } 32326 } 32327 } 32328 } 32329 } 32330 } 32331 } 32332 } 32333 if (N10.getOpcode() == ISD::SRL) { 32334 32335 // Pattern: (st:isVoid (or:i64 (srl:i64 GR64:i64:$src2, (trunc:i8 (sub:i64 64:i64, RCX:i64:$amt))), (shl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (trunc:i8 RCX:i64:$amt))), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 32336 // Emits: (SHLD64mrCL:isVoid addr:iPTR:$dst, GR64:i64:$src2) 32337 // Pattern complexity = 67 cost = 1 size = 3 32338 { 32339 SDValue N100 = N10.getOperand(0); 32340 SDValue N101 = N10.getOperand(1); 32341 if (N101.getOpcode() == ISD::TRUNCATE) { 32342 SDValue N1010 = N101.getOperand(0); 32343 if (N1010.getOpcode() == ISD::SUB) { 32344 SDValue N10100 = N1010.getOperand(0); 32345 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N10100); 32346 if (Tmp0) { 32347 int64_t CN1 = Tmp0->getSExtValue(); 32348 if (CN1 == INT64_C(64)) { 32349 SDValue N10101 = N1010.getOperand(1); 32350 SDValue N11 = N1.getOperand(1); 32351 if (N11.getOpcode() == ISD::SHL && 32352 N11.hasOneUse()) { 32353 SDValue N110 = N11.getOperand(0); 32354 if (N110.getOpcode() == ISD::LOAD && 32355 N110.hasOneUse() && 32356 IsLegalAndProfitableToFold(N110.getNode(), N11.getNode(), N.getNode()) && 32357 (Chain.getNode() == N110.getNode() || IsChainCompatible(Chain.getNode(), N110.getNode()))) { 32358 SDValue Chain110 = N110.getOperand(0); 32359 if (Predicate_unindexedload(N110.getNode()) && 32360 Predicate_load(N110.getNode()) && 32361 Predicate_loadi64(N110.getNode())) { 32362 SDValue N1101 = N110.getOperand(1); 32363 SDValue CPTmpN1101_0; 32364 SDValue CPTmpN1101_1; 32365 SDValue CPTmpN1101_2; 32366 SDValue CPTmpN1101_3; 32367 SDValue CPTmpN1101_4; 32368 if (SelectAddr(N, N1101, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4)) { 32369 SDValue N111 = N11.getOperand(1); 32370 if (N111.getOpcode() == ISD::TRUNCATE) { 32371 SDValue N1110 = N111.getOperand(0); 32372 if (N10101 == N1110) { 32373 SDValue N2 = N.getOperand(2); 32374 if (N1101 == N2 && 32375 N1.getNode()->getValueType(0) == MVT::i64 && 32376 N101.getNode()->getValueType(0) == MVT::i8 && 32377 N1010.getNode()->getValueType(0) == MVT::i64 && 32378 N111.getNode()->getValueType(0) == MVT::i8 && 32379 N1110.getNode()->getValueType(0) == MVT::i64) { 32380 SDNode *Result = Emit_223(N, X86::SHLD64mrCL, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4); 32381 return Result; 32382 } 32383 } 32384 } 32385 } 32386 } 32387 } 32388 } 32389 } 32390 } 32391 } 32392 } 32393 } 32394 32395 // Pattern: (st:isVoid (or:i32 (srl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, CL:i8:$amt), (shl:i32 GR32:i32:$src2, (sub:i8 32:i8, CL:i8:$amt))), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 32396 // Emits: (SHRD32mrCL:isVoid addr:iPTR:$dst, GR32:i32:$src2) 32397 // Pattern complexity = 61 cost = 1 size = 3 32398 if (N10.hasOneUse()) { 32399 SDValue N100 = N10.getOperand(0); 32400 if (N100.getOpcode() == ISD::LOAD && 32401 N100.hasOneUse() && 32402 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 32403 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 32404 SDValue Chain100 = N100.getOperand(0); 32405 if (Predicate_unindexedload(N100.getNode()) && 32406 Predicate_loadi32(N100.getNode())) { 32407 SDValue N1001 = N100.getOperand(1); 32408 SDValue CPTmpN1001_0; 32409 SDValue CPTmpN1001_1; 32410 SDValue CPTmpN1001_2; 32411 SDValue CPTmpN1001_3; 32412 SDValue CPTmpN1001_4; 32413 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 32414 SDValue N101 = N10.getOperand(1); 32415 SDValue N11 = N1.getOperand(1); 32416 if (N11.getOpcode() == ISD::SHL) { 32417 SDValue N110 = N11.getOperand(0); 32418 SDValue N111 = N11.getOperand(1); 32419 if (N111.getOpcode() == ISD::SUB) { 32420 SDValue N1110 = N111.getOperand(0); 32421 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1110); 32422 if (Tmp0) { 32423 int64_t CN1 = Tmp0->getSExtValue(); 32424 if (CN1 == INT64_C(32)) { 32425 SDValue N1111 = N111.getOperand(1); 32426 if (N101 == N1111) { 32427 SDValue N2 = N.getOperand(2); 32428 if (N1001 == N2 && 32429 N1.getNode()->getValueType(0) == MVT::i32 && 32430 N101.getNode()->getValueType(0) == MVT::i8 && 32431 N111.getNode()->getValueType(0) == MVT::i8) { 32432 SDNode *Result = Emit_203(N, X86::SHRD32mrCL, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 32433 return Result; 32434 } 32435 } 32436 } 32437 } 32438 } 32439 } 32440 } 32441 } 32442 } 32443 } 32444 } 32445 32446 // Pattern: (st:isVoid (or:i32 (shl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, CL:i8:$amt), (srl:i32 GR32:i32:$src2, (sub:i8 32:i8, CL:i8:$amt))), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 32447 // Emits: (SHLD32mrCL:isVoid addr:iPTR:$dst, GR32:i32:$src2) 32448 // Pattern complexity = 61 cost = 1 size = 3 32449 if (N10.getOpcode() == ISD::SHL && 32450 N10.hasOneUse()) { 32451 SDValue N100 = N10.getOperand(0); 32452 if (N100.getOpcode() == ISD::LOAD && 32453 N100.hasOneUse() && 32454 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 32455 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 32456 SDValue Chain100 = N100.getOperand(0); 32457 if (Predicate_unindexedload(N100.getNode()) && 32458 Predicate_loadi32(N100.getNode())) { 32459 SDValue N1001 = N100.getOperand(1); 32460 SDValue CPTmpN1001_0; 32461 SDValue CPTmpN1001_1; 32462 SDValue CPTmpN1001_2; 32463 SDValue CPTmpN1001_3; 32464 SDValue CPTmpN1001_4; 32465 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 32466 SDValue N101 = N10.getOperand(1); 32467 SDValue N11 = N1.getOperand(1); 32468 if (N11.getOpcode() == ISD::SRL) { 32469 SDValue N110 = N11.getOperand(0); 32470 SDValue N111 = N11.getOperand(1); 32471 if (N111.getOpcode() == ISD::SUB) { 32472 SDValue N1110 = N111.getOperand(0); 32473 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1110); 32474 if (Tmp0) { 32475 int64_t CN1 = Tmp0->getSExtValue(); 32476 if (CN1 == INT64_C(32)) { 32477 SDValue N1111 = N111.getOperand(1); 32478 if (N101 == N1111) { 32479 SDValue N2 = N.getOperand(2); 32480 if (N1001 == N2 && 32481 N1.getNode()->getValueType(0) == MVT::i32 && 32482 N101.getNode()->getValueType(0) == MVT::i8 && 32483 N111.getNode()->getValueType(0) == MVT::i8) { 32484 SDNode *Result = Emit_203(N, X86::SHLD32mrCL, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 32485 return Result; 32486 } 32487 } 32488 } 32489 } 32490 } 32491 } 32492 } 32493 } 32494 } 32495 } 32496 32497 // Pattern: (st:isVoid (or:i16 (srl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, CL:i8:$amt), (shl:i16 GR16:i16:$src2, (sub:i8 16:i8, CL:i8:$amt))), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 32498 // Emits: (SHRD16mrCL:isVoid addr:iPTR:$dst, GR16:i16:$src2) 32499 // Pattern complexity = 61 cost = 1 size = 3 32500 if (N10.getOpcode() == ISD::SRL && 32501 N10.hasOneUse()) { 32502 SDValue N100 = N10.getOperand(0); 32503 if (N100.getOpcode() == ISD::LOAD && 32504 N100.hasOneUse() && 32505 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 32506 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 32507 SDValue Chain100 = N100.getOperand(0); 32508 if (Predicate_unindexedload(N100.getNode()) && 32509 Predicate_loadi16(N100.getNode())) { 32510 SDValue N1001 = N100.getOperand(1); 32511 SDValue CPTmpN1001_0; 32512 SDValue CPTmpN1001_1; 32513 SDValue CPTmpN1001_2; 32514 SDValue CPTmpN1001_3; 32515 SDValue CPTmpN1001_4; 32516 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 32517 SDValue N101 = N10.getOperand(1); 32518 SDValue N11 = N1.getOperand(1); 32519 if (N11.getOpcode() == ISD::SHL) { 32520 SDValue N110 = N11.getOperand(0); 32521 SDValue N111 = N11.getOperand(1); 32522 if (N111.getOpcode() == ISD::SUB) { 32523 SDValue N1110 = N111.getOperand(0); 32524 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1110); 32525 if (Tmp0) { 32526 int64_t CN1 = Tmp0->getSExtValue(); 32527 if (CN1 == INT64_C(16)) { 32528 SDValue N1111 = N111.getOperand(1); 32529 if (N101 == N1111) { 32530 SDValue N2 = N.getOperand(2); 32531 if (N1001 == N2 && 32532 N1.getNode()->getValueType(0) == MVT::i16 && 32533 N101.getNode()->getValueType(0) == MVT::i8 && 32534 N111.getNode()->getValueType(0) == MVT::i8) { 32535 SDNode *Result = Emit_203(N, X86::SHRD16mrCL, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 32536 return Result; 32537 } 32538 } 32539 } 32540 } 32541 } 32542 } 32543 } 32544 } 32545 } 32546 } 32547 32548 // Pattern: (st:isVoid (or:i16 (shl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, CL:i8:$amt), (srl:i16 GR16:i16:$src2, (sub:i8 16:i8, CL:i8:$amt))), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 32549 // Emits: (SHLD16mrCL:isVoid addr:iPTR:$dst, GR16:i16:$src2) 32550 // Pattern complexity = 61 cost = 1 size = 3 32551 if (N10.getOpcode() == ISD::SHL && 32552 N10.hasOneUse()) { 32553 SDValue N100 = N10.getOperand(0); 32554 if (N100.getOpcode() == ISD::LOAD && 32555 N100.hasOneUse() && 32556 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 32557 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 32558 SDValue Chain100 = N100.getOperand(0); 32559 if (Predicate_unindexedload(N100.getNode()) && 32560 Predicate_loadi16(N100.getNode())) { 32561 SDValue N1001 = N100.getOperand(1); 32562 SDValue CPTmpN1001_0; 32563 SDValue CPTmpN1001_1; 32564 SDValue CPTmpN1001_2; 32565 SDValue CPTmpN1001_3; 32566 SDValue CPTmpN1001_4; 32567 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 32568 SDValue N101 = N10.getOperand(1); 32569 SDValue N11 = N1.getOperand(1); 32570 if (N11.getOpcode() == ISD::SRL) { 32571 SDValue N110 = N11.getOperand(0); 32572 SDValue N111 = N11.getOperand(1); 32573 if (N111.getOpcode() == ISD::SUB) { 32574 SDValue N1110 = N111.getOperand(0); 32575 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1110); 32576 if (Tmp0) { 32577 int64_t CN1 = Tmp0->getSExtValue(); 32578 if (CN1 == INT64_C(16)) { 32579 SDValue N1111 = N111.getOperand(1); 32580 if (N101 == N1111) { 32581 SDValue N2 = N.getOperand(2); 32582 if (N1001 == N2 && 32583 N1.getNode()->getValueType(0) == MVT::i16 && 32584 N101.getNode()->getValueType(0) == MVT::i8 && 32585 N111.getNode()->getValueType(0) == MVT::i8) { 32586 SDNode *Result = Emit_203(N, X86::SHLD16mrCL, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 32587 return Result; 32588 } 32589 } 32590 } 32591 } 32592 } 32593 } 32594 } 32595 } 32596 } 32597 } 32598 32599 // Pattern: (st:isVoid (or:i64 (srl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, CL:i8:$amt), (shl:i64 GR64:i64:$src2, (sub:i8 64:i8, CL:i8:$amt))), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 32600 // Emits: (SHRD64mrCL:isVoid addr:iPTR:$dst, GR64:i64:$src2) 32601 // Pattern complexity = 61 cost = 1 size = 3 32602 if (N10.getOpcode() == ISD::SRL && 32603 N10.hasOneUse()) { 32604 SDValue N100 = N10.getOperand(0); 32605 if (N100.getOpcode() == ISD::LOAD && 32606 N100.hasOneUse() && 32607 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 32608 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 32609 SDValue Chain100 = N100.getOperand(0); 32610 if (Predicate_unindexedload(N100.getNode()) && 32611 Predicate_load(N100.getNode()) && 32612 Predicate_loadi64(N100.getNode())) { 32613 SDValue N1001 = N100.getOperand(1); 32614 SDValue CPTmpN1001_0; 32615 SDValue CPTmpN1001_1; 32616 SDValue CPTmpN1001_2; 32617 SDValue CPTmpN1001_3; 32618 SDValue CPTmpN1001_4; 32619 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 32620 SDValue N101 = N10.getOperand(1); 32621 SDValue N11 = N1.getOperand(1); 32622 if (N11.getOpcode() == ISD::SHL) { 32623 SDValue N110 = N11.getOperand(0); 32624 SDValue N111 = N11.getOperand(1); 32625 if (N111.getOpcode() == ISD::SUB) { 32626 SDValue N1110 = N111.getOperand(0); 32627 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1110); 32628 if (Tmp0) { 32629 int64_t CN1 = Tmp0->getSExtValue(); 32630 if (CN1 == INT64_C(64)) { 32631 SDValue N1111 = N111.getOperand(1); 32632 if (N101 == N1111) { 32633 SDValue N2 = N.getOperand(2); 32634 if (N1001 == N2 && 32635 N1.getNode()->getValueType(0) == MVT::i64 && 32636 N101.getNode()->getValueType(0) == MVT::i8 && 32637 N111.getNode()->getValueType(0) == MVT::i8) { 32638 SDNode *Result = Emit_203(N, X86::SHRD64mrCL, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 32639 return Result; 32640 } 32641 } 32642 } 32643 } 32644 } 32645 } 32646 } 32647 } 32648 } 32649 } 32650 if (N10.getOpcode() == ISD::SHL) { 32651 32652 // Pattern: (st:isVoid (or:i64 (shl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, CL:i8:$amt), (srl:i64 GR64:i64:$src2, (sub:i8 64:i8, CL:i8:$amt))), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 32653 // Emits: (SHLD64mrCL:isVoid addr:iPTR:$dst, GR64:i64:$src2) 32654 // Pattern complexity = 61 cost = 1 size = 3 32655 if (N10.hasOneUse()) { 32656 SDValue N100 = N10.getOperand(0); 32657 if (N100.getOpcode() == ISD::LOAD && 32658 N100.hasOneUse() && 32659 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 32660 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 32661 SDValue Chain100 = N100.getOperand(0); 32662 if (Predicate_unindexedload(N100.getNode()) && 32663 Predicate_load(N100.getNode()) && 32664 Predicate_loadi64(N100.getNode())) { 32665 SDValue N1001 = N100.getOperand(1); 32666 SDValue CPTmpN1001_0; 32667 SDValue CPTmpN1001_1; 32668 SDValue CPTmpN1001_2; 32669 SDValue CPTmpN1001_3; 32670 SDValue CPTmpN1001_4; 32671 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 32672 SDValue N101 = N10.getOperand(1); 32673 SDValue N11 = N1.getOperand(1); 32674 if (N11.getOpcode() == ISD::SRL) { 32675 SDValue N110 = N11.getOperand(0); 32676 SDValue N111 = N11.getOperand(1); 32677 if (N111.getOpcode() == ISD::SUB) { 32678 SDValue N1110 = N111.getOperand(0); 32679 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1110); 32680 if (Tmp0) { 32681 int64_t CN1 = Tmp0->getSExtValue(); 32682 if (CN1 == INT64_C(64)) { 32683 SDValue N1111 = N111.getOperand(1); 32684 if (N101 == N1111) { 32685 SDValue N2 = N.getOperand(2); 32686 if (N1001 == N2 && 32687 N1.getNode()->getValueType(0) == MVT::i64 && 32688 N101.getNode()->getValueType(0) == MVT::i8 && 32689 N111.getNode()->getValueType(0) == MVT::i8) { 32690 SDNode *Result = Emit_203(N, X86::SHLD64mrCL, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 32691 return Result; 32692 } 32693 } 32694 } 32695 } 32696 } 32697 } 32698 } 32699 } 32700 } 32701 } 32702 32703 // Pattern: (st:isVoid (or:i32 (shl:i32 GR32:i32:$src2, (sub:i8 32:i8, CL:i8:$amt)), (srl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, CL:i8:$amt)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 32704 // Emits: (SHRD32mrCL:isVoid addr:iPTR:$dst, GR32:i32:$src2) 32705 // Pattern complexity = 61 cost = 1 size = 3 32706 SDValue N100 = N10.getOperand(0); 32707 SDValue N101 = N10.getOperand(1); 32708 if (N101.getOpcode() == ISD::SUB) { 32709 SDValue N1010 = N101.getOperand(0); 32710 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1010); 32711 if (Tmp0) { 32712 int64_t CN1 = Tmp0->getSExtValue(); 32713 if (CN1 == INT64_C(32)) { 32714 SDValue N1011 = N101.getOperand(1); 32715 SDValue N11 = N1.getOperand(1); 32716 if (N11.getOpcode() == ISD::SRL && 32717 N11.hasOneUse()) { 32718 SDValue N110 = N11.getOperand(0); 32719 if (N110.getOpcode() == ISD::LOAD && 32720 N110.hasOneUse() && 32721 IsLegalAndProfitableToFold(N110.getNode(), N11.getNode(), N.getNode()) && 32722 (Chain.getNode() == N110.getNode() || IsChainCompatible(Chain.getNode(), N110.getNode()))) { 32723 SDValue Chain110 = N110.getOperand(0); 32724 if (Predicate_unindexedload(N110.getNode()) && 32725 Predicate_loadi32(N110.getNode())) { 32726 SDValue N1101 = N110.getOperand(1); 32727 SDValue CPTmpN1101_0; 32728 SDValue CPTmpN1101_1; 32729 SDValue CPTmpN1101_2; 32730 SDValue CPTmpN1101_3; 32731 SDValue CPTmpN1101_4; 32732 if (SelectAddr(N, N1101, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4)) { 32733 SDValue N111 = N11.getOperand(1); 32734 if (N1011 == N111) { 32735 SDValue N2 = N.getOperand(2); 32736 if (N1101 == N2 && 32737 N1.getNode()->getValueType(0) == MVT::i32 && 32738 N101.getNode()->getValueType(0) == MVT::i8 && 32739 N111.getNode()->getValueType(0) == MVT::i8) { 32740 SDNode *Result = Emit_219(N, X86::SHRD32mrCL, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4); 32741 return Result; 32742 } 32743 } 32744 } 32745 } 32746 } 32747 } 32748 } 32749 } 32750 } 32751 } 32752 32753 // Pattern: (st:isVoid (or:i32 (srl:i32 GR32:i32:$src2, (sub:i8 32:i8, CL:i8:$amt)), (shl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, CL:i8:$amt)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 32754 // Emits: (SHLD32mrCL:isVoid addr:iPTR:$dst, GR32:i32:$src2) 32755 // Pattern complexity = 61 cost = 1 size = 3 32756 if (N10.getOpcode() == ISD::SRL) { 32757 SDValue N100 = N10.getOperand(0); 32758 SDValue N101 = N10.getOperand(1); 32759 if (N101.getOpcode() == ISD::SUB) { 32760 SDValue N1010 = N101.getOperand(0); 32761 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1010); 32762 if (Tmp0) { 32763 int64_t CN1 = Tmp0->getSExtValue(); 32764 if (CN1 == INT64_C(32)) { 32765 SDValue N1011 = N101.getOperand(1); 32766 SDValue N11 = N1.getOperand(1); 32767 if (N11.getOpcode() == ISD::SHL && 32768 N11.hasOneUse()) { 32769 SDValue N110 = N11.getOperand(0); 32770 if (N110.getOpcode() == ISD::LOAD && 32771 N110.hasOneUse() && 32772 IsLegalAndProfitableToFold(N110.getNode(), N11.getNode(), N.getNode()) && 32773 (Chain.getNode() == N110.getNode() || IsChainCompatible(Chain.getNode(), N110.getNode()))) { 32774 SDValue Chain110 = N110.getOperand(0); 32775 if (Predicate_unindexedload(N110.getNode()) && 32776 Predicate_loadi32(N110.getNode())) { 32777 SDValue N1101 = N110.getOperand(1); 32778 SDValue CPTmpN1101_0; 32779 SDValue CPTmpN1101_1; 32780 SDValue CPTmpN1101_2; 32781 SDValue CPTmpN1101_3; 32782 SDValue CPTmpN1101_4; 32783 if (SelectAddr(N, N1101, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4)) { 32784 SDValue N111 = N11.getOperand(1); 32785 if (N1011 == N111) { 32786 SDValue N2 = N.getOperand(2); 32787 if (N1101 == N2 && 32788 N1.getNode()->getValueType(0) == MVT::i32 && 32789 N101.getNode()->getValueType(0) == MVT::i8 && 32790 N111.getNode()->getValueType(0) == MVT::i8) { 32791 SDNode *Result = Emit_219(N, X86::SHLD32mrCL, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4); 32792 return Result; 32793 } 32794 } 32795 } 32796 } 32797 } 32798 } 32799 } 32800 } 32801 } 32802 } 32803 32804 // Pattern: (st:isVoid (or:i16 (shl:i16 GR16:i16:$src2, (sub:i8 16:i8, CL:i8:$amt)), (srl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, CL:i8:$amt)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 32805 // Emits: (SHRD16mrCL:isVoid addr:iPTR:$dst, GR16:i16:$src2) 32806 // Pattern complexity = 61 cost = 1 size = 3 32807 if (N10.getOpcode() == ISD::SHL) { 32808 SDValue N100 = N10.getOperand(0); 32809 SDValue N101 = N10.getOperand(1); 32810 if (N101.getOpcode() == ISD::SUB) { 32811 SDValue N1010 = N101.getOperand(0); 32812 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1010); 32813 if (Tmp0) { 32814 int64_t CN1 = Tmp0->getSExtValue(); 32815 if (CN1 == INT64_C(16)) { 32816 SDValue N1011 = N101.getOperand(1); 32817 SDValue N11 = N1.getOperand(1); 32818 if (N11.getOpcode() == ISD::SRL && 32819 N11.hasOneUse()) { 32820 SDValue N110 = N11.getOperand(0); 32821 if (N110.getOpcode() == ISD::LOAD && 32822 N110.hasOneUse() && 32823 IsLegalAndProfitableToFold(N110.getNode(), N11.getNode(), N.getNode()) && 32824 (Chain.getNode() == N110.getNode() || IsChainCompatible(Chain.getNode(), N110.getNode()))) { 32825 SDValue Chain110 = N110.getOperand(0); 32826 if (Predicate_unindexedload(N110.getNode()) && 32827 Predicate_loadi16(N110.getNode())) { 32828 SDValue N1101 = N110.getOperand(1); 32829 SDValue CPTmpN1101_0; 32830 SDValue CPTmpN1101_1; 32831 SDValue CPTmpN1101_2; 32832 SDValue CPTmpN1101_3; 32833 SDValue CPTmpN1101_4; 32834 if (SelectAddr(N, N1101, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4)) { 32835 SDValue N111 = N11.getOperand(1); 32836 if (N1011 == N111) { 32837 SDValue N2 = N.getOperand(2); 32838 if (N1101 == N2 && 32839 N1.getNode()->getValueType(0) == MVT::i16 && 32840 N101.getNode()->getValueType(0) == MVT::i8 && 32841 N111.getNode()->getValueType(0) == MVT::i8) { 32842 SDNode *Result = Emit_219(N, X86::SHRD16mrCL, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4); 32843 return Result; 32844 } 32845 } 32846 } 32847 } 32848 } 32849 } 32850 } 32851 } 32852 } 32853 } 32854 32855 // Pattern: (st:isVoid (or:i16 (srl:i16 GR16:i16:$src2, (sub:i8 16:i8, CL:i8:$amt)), (shl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, CL:i8:$amt)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 32856 // Emits: (SHLD16mrCL:isVoid addr:iPTR:$dst, GR16:i16:$src2) 32857 // Pattern complexity = 61 cost = 1 size = 3 32858 if (N10.getOpcode() == ISD::SRL) { 32859 SDValue N100 = N10.getOperand(0); 32860 SDValue N101 = N10.getOperand(1); 32861 if (N101.getOpcode() == ISD::SUB) { 32862 SDValue N1010 = N101.getOperand(0); 32863 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1010); 32864 if (Tmp0) { 32865 int64_t CN1 = Tmp0->getSExtValue(); 32866 if (CN1 == INT64_C(16)) { 32867 SDValue N1011 = N101.getOperand(1); 32868 SDValue N11 = N1.getOperand(1); 32869 if (N11.getOpcode() == ISD::SHL && 32870 N11.hasOneUse()) { 32871 SDValue N110 = N11.getOperand(0); 32872 if (N110.getOpcode() == ISD::LOAD && 32873 N110.hasOneUse() && 32874 IsLegalAndProfitableToFold(N110.getNode(), N11.getNode(), N.getNode()) && 32875 (Chain.getNode() == N110.getNode() || IsChainCompatible(Chain.getNode(), N110.getNode()))) { 32876 SDValue Chain110 = N110.getOperand(0); 32877 if (Predicate_unindexedload(N110.getNode()) && 32878 Predicate_loadi16(N110.getNode())) { 32879 SDValue N1101 = N110.getOperand(1); 32880 SDValue CPTmpN1101_0; 32881 SDValue CPTmpN1101_1; 32882 SDValue CPTmpN1101_2; 32883 SDValue CPTmpN1101_3; 32884 SDValue CPTmpN1101_4; 32885 if (SelectAddr(N, N1101, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4)) { 32886 SDValue N111 = N11.getOperand(1); 32887 if (N1011 == N111) { 32888 SDValue N2 = N.getOperand(2); 32889 if (N1101 == N2 && 32890 N1.getNode()->getValueType(0) == MVT::i16 && 32891 N101.getNode()->getValueType(0) == MVT::i8 && 32892 N111.getNode()->getValueType(0) == MVT::i8) { 32893 SDNode *Result = Emit_219(N, X86::SHLD16mrCL, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4); 32894 return Result; 32895 } 32896 } 32897 } 32898 } 32899 } 32900 } 32901 } 32902 } 32903 } 32904 } 32905 32906 // Pattern: (st:isVoid (or:i64 (shl:i64 GR64:i64:$src2, (sub:i8 64:i8, CL:i8:$amt)), (srl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, CL:i8:$amt)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 32907 // Emits: (SHRD64mrCL:isVoid addr:iPTR:$dst, GR64:i64:$src2) 32908 // Pattern complexity = 61 cost = 1 size = 3 32909 if (N10.getOpcode() == ISD::SHL) { 32910 SDValue N100 = N10.getOperand(0); 32911 SDValue N101 = N10.getOperand(1); 32912 if (N101.getOpcode() == ISD::SUB) { 32913 SDValue N1010 = N101.getOperand(0); 32914 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1010); 32915 if (Tmp0) { 32916 int64_t CN1 = Tmp0->getSExtValue(); 32917 if (CN1 == INT64_C(64)) { 32918 SDValue N1011 = N101.getOperand(1); 32919 SDValue N11 = N1.getOperand(1); 32920 if (N11.getOpcode() == ISD::SRL && 32921 N11.hasOneUse()) { 32922 SDValue N110 = N11.getOperand(0); 32923 if (N110.getOpcode() == ISD::LOAD && 32924 N110.hasOneUse() && 32925 IsLegalAndProfitableToFold(N110.getNode(), N11.getNode(), N.getNode()) && 32926 (Chain.getNode() == N110.getNode() || IsChainCompatible(Chain.getNode(), N110.getNode()))) { 32927 SDValue Chain110 = N110.getOperand(0); 32928 if (Predicate_unindexedload(N110.getNode()) && 32929 Predicate_load(N110.getNode()) && 32930 Predicate_loadi64(N110.getNode())) { 32931 SDValue N1101 = N110.getOperand(1); 32932 SDValue CPTmpN1101_0; 32933 SDValue CPTmpN1101_1; 32934 SDValue CPTmpN1101_2; 32935 SDValue CPTmpN1101_3; 32936 SDValue CPTmpN1101_4; 32937 if (SelectAddr(N, N1101, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4)) { 32938 SDValue N111 = N11.getOperand(1); 32939 if (N1011 == N111) { 32940 SDValue N2 = N.getOperand(2); 32941 if (N1101 == N2 && 32942 N1.getNode()->getValueType(0) == MVT::i64 && 32943 N101.getNode()->getValueType(0) == MVT::i8 && 32944 N111.getNode()->getValueType(0) == MVT::i8) { 32945 SDNode *Result = Emit_219(N, X86::SHRD64mrCL, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4); 32946 return Result; 32947 } 32948 } 32949 } 32950 } 32951 } 32952 } 32953 } 32954 } 32955 } 32956 } 32957 32958 // Pattern: (st:isVoid (or:i64 (srl:i64 GR64:i64:$src2, (sub:i8 64:i8, CL:i8:$amt)), (shl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, CL:i8:$amt)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 32959 // Emits: (SHLD64mrCL:isVoid addr:iPTR:$dst, GR64:i64:$src2) 32960 // Pattern complexity = 61 cost = 1 size = 3 32961 if (N10.getOpcode() == ISD::SRL) { 32962 SDValue N100 = N10.getOperand(0); 32963 SDValue N101 = N10.getOperand(1); 32964 if (N101.getOpcode() == ISD::SUB) { 32965 SDValue N1010 = N101.getOperand(0); 32966 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1010); 32967 if (Tmp0) { 32968 int64_t CN1 = Tmp0->getSExtValue(); 32969 if (CN1 == INT64_C(64)) { 32970 SDValue N1011 = N101.getOperand(1); 32971 SDValue N11 = N1.getOperand(1); 32972 if (N11.getOpcode() == ISD::SHL && 32973 N11.hasOneUse()) { 32974 SDValue N110 = N11.getOperand(0); 32975 if (N110.getOpcode() == ISD::LOAD && 32976 N110.hasOneUse() && 32977 IsLegalAndProfitableToFold(N110.getNode(), N11.getNode(), N.getNode()) && 32978 (Chain.getNode() == N110.getNode() || IsChainCompatible(Chain.getNode(), N110.getNode()))) { 32979 SDValue Chain110 = N110.getOperand(0); 32980 if (Predicate_unindexedload(N110.getNode()) && 32981 Predicate_load(N110.getNode()) && 32982 Predicate_loadi64(N110.getNode())) { 32983 SDValue N1101 = N110.getOperand(1); 32984 SDValue CPTmpN1101_0; 32985 SDValue CPTmpN1101_1; 32986 SDValue CPTmpN1101_2; 32987 SDValue CPTmpN1101_3; 32988 SDValue CPTmpN1101_4; 32989 if (SelectAddr(N, N1101, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4)) { 32990 SDValue N111 = N11.getOperand(1); 32991 if (N1011 == N111) { 32992 SDValue N2 = N.getOperand(2); 32993 if (N1101 == N2 && 32994 N1.getNode()->getValueType(0) == MVT::i64 && 32995 N101.getNode()->getValueType(0) == MVT::i8 && 32996 N111.getNode()->getValueType(0) == MVT::i8) { 32997 SDNode *Result = Emit_219(N, X86::SHLD64mrCL, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4); 32998 return Result; 32999 } 33000 } 33001 } 33002 } 33003 } 33004 } 33005 } 33006 } 33007 } 33008 } 33009 } 33010 33011 // Pattern: (st:isVoid (or:i32 (srl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i8):$amt1), (shl:i32 GR32:i32:$src2, (imm:i8):$amt2))<<P:Predicate_shrd>>, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33012 // Emits: (SHRD32mri8:isVoid addr:iPTR:$dst, GR32:i32:$src2, (imm:i8):$amt1) 33013 // Pattern complexity = 60 cost = 1 size = 3 33014 if (Predicate_shrd(N1.getNode())) { 33015 SDValue N10 = N1.getOperand(0); 33016 if (N10.getOpcode() == ISD::SRL && 33017 N10.hasOneUse()) { 33018 SDValue N100 = N10.getOperand(0); 33019 if (N100.getOpcode() == ISD::LOAD && 33020 N100.hasOneUse() && 33021 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 33022 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 33023 SDValue Chain100 = N100.getOperand(0); 33024 if (Predicate_unindexedload(N100.getNode()) && 33025 Predicate_loadi32(N100.getNode())) { 33026 SDValue N1001 = N100.getOperand(1); 33027 SDValue CPTmpN1001_0; 33028 SDValue CPTmpN1001_1; 33029 SDValue CPTmpN1001_2; 33030 SDValue CPTmpN1001_3; 33031 SDValue CPTmpN1001_4; 33032 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 33033 SDValue N101 = N10.getOperand(1); 33034 if (N101.getOpcode() == ISD::Constant) { 33035 SDValue N11 = N1.getOperand(1); 33036 if (N11.getOpcode() == ISD::SHL) { 33037 SDValue N110 = N11.getOperand(0); 33038 SDValue N111 = N11.getOperand(1); 33039 if (N111.getOpcode() == ISD::Constant) { 33040 SDValue N2 = N.getOperand(2); 33041 if (N1001 == N2 && 33042 N1.getNode()->getValueType(0) == MVT::i32 && 33043 N101.getNode()->getValueType(0) == MVT::i8 && 33044 N111.getNode()->getValueType(0) == MVT::i8) { 33045 SDNode *Result = Emit_205(N, X86::SHRD32mri8, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 33046 return Result; 33047 } 33048 } 33049 } 33050 } 33051 } 33052 } 33053 } 33054 } 33055 } 33056 33057 // Pattern: (st:isVoid (or:i32 (shl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i8):$amt1), (srl:i32 GR32:i32:$src2, (imm:i8):$amt2))<<P:Predicate_shld>>, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33058 // Emits: (SHLD32mri8:isVoid addr:iPTR:$dst, GR32:i32:$src2, (imm:i8):$amt1) 33059 // Pattern complexity = 60 cost = 1 size = 3 33060 if (Predicate_shld(N1.getNode())) { 33061 SDValue N10 = N1.getOperand(0); 33062 if (N10.getOpcode() == ISD::SHL && 33063 N10.hasOneUse()) { 33064 SDValue N100 = N10.getOperand(0); 33065 if (N100.getOpcode() == ISD::LOAD && 33066 N100.hasOneUse() && 33067 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 33068 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 33069 SDValue Chain100 = N100.getOperand(0); 33070 if (Predicate_unindexedload(N100.getNode()) && 33071 Predicate_loadi32(N100.getNode())) { 33072 SDValue N1001 = N100.getOperand(1); 33073 SDValue CPTmpN1001_0; 33074 SDValue CPTmpN1001_1; 33075 SDValue CPTmpN1001_2; 33076 SDValue CPTmpN1001_3; 33077 SDValue CPTmpN1001_4; 33078 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 33079 SDValue N101 = N10.getOperand(1); 33080 if (N101.getOpcode() == ISD::Constant) { 33081 SDValue N11 = N1.getOperand(1); 33082 if (N11.getOpcode() == ISD::SRL) { 33083 SDValue N110 = N11.getOperand(0); 33084 SDValue N111 = N11.getOperand(1); 33085 if (N111.getOpcode() == ISD::Constant) { 33086 SDValue N2 = N.getOperand(2); 33087 if (N1001 == N2 && 33088 N1.getNode()->getValueType(0) == MVT::i32 && 33089 N101.getNode()->getValueType(0) == MVT::i8 && 33090 N111.getNode()->getValueType(0) == MVT::i8) { 33091 SDNode *Result = Emit_205(N, X86::SHLD32mri8, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 33092 return Result; 33093 } 33094 } 33095 } 33096 } 33097 } 33098 } 33099 } 33100 } 33101 } 33102 33103 // Pattern: (st:isVoid (or:i16 (srl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i8):$amt1), (shl:i16 GR16:i16:$src2, (imm:i8):$amt2))<<P:Predicate_shrd>>, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33104 // Emits: (SHRD16mri8:isVoid addr:iPTR:$dst, GR16:i16:$src2, (imm:i8):$amt1) 33105 // Pattern complexity = 60 cost = 1 size = 3 33106 if (Predicate_shrd(N1.getNode())) { 33107 SDValue N10 = N1.getOperand(0); 33108 if (N10.getOpcode() == ISD::SRL && 33109 N10.hasOneUse()) { 33110 SDValue N100 = N10.getOperand(0); 33111 if (N100.getOpcode() == ISD::LOAD && 33112 N100.hasOneUse() && 33113 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 33114 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 33115 SDValue Chain100 = N100.getOperand(0); 33116 if (Predicate_unindexedload(N100.getNode()) && 33117 Predicate_loadi16(N100.getNode())) { 33118 SDValue N1001 = N100.getOperand(1); 33119 SDValue CPTmpN1001_0; 33120 SDValue CPTmpN1001_1; 33121 SDValue CPTmpN1001_2; 33122 SDValue CPTmpN1001_3; 33123 SDValue CPTmpN1001_4; 33124 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 33125 SDValue N101 = N10.getOperand(1); 33126 if (N101.getOpcode() == ISD::Constant) { 33127 SDValue N11 = N1.getOperand(1); 33128 if (N11.getOpcode() == ISD::SHL) { 33129 SDValue N110 = N11.getOperand(0); 33130 SDValue N111 = N11.getOperand(1); 33131 if (N111.getOpcode() == ISD::Constant) { 33132 SDValue N2 = N.getOperand(2); 33133 if (N1001 == N2 && 33134 N1.getNode()->getValueType(0) == MVT::i16 && 33135 N101.getNode()->getValueType(0) == MVT::i8 && 33136 N111.getNode()->getValueType(0) == MVT::i8) { 33137 SDNode *Result = Emit_205(N, X86::SHRD16mri8, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 33138 return Result; 33139 } 33140 } 33141 } 33142 } 33143 } 33144 } 33145 } 33146 } 33147 } 33148 33149 // Pattern: (st:isVoid (or:i16 (shl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i8):$amt1), (srl:i16 GR16:i16:$src2, (imm:i8):$amt2))<<P:Predicate_shld>>, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33150 // Emits: (SHLD16mri8:isVoid addr:iPTR:$dst, GR16:i16:$src2, (imm:i8):$amt1) 33151 // Pattern complexity = 60 cost = 1 size = 3 33152 if (Predicate_shld(N1.getNode())) { 33153 SDValue N10 = N1.getOperand(0); 33154 if (N10.getOpcode() == ISD::SHL && 33155 N10.hasOneUse()) { 33156 SDValue N100 = N10.getOperand(0); 33157 if (N100.getOpcode() == ISD::LOAD && 33158 N100.hasOneUse() && 33159 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 33160 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 33161 SDValue Chain100 = N100.getOperand(0); 33162 if (Predicate_unindexedload(N100.getNode()) && 33163 Predicate_loadi16(N100.getNode())) { 33164 SDValue N1001 = N100.getOperand(1); 33165 SDValue CPTmpN1001_0; 33166 SDValue CPTmpN1001_1; 33167 SDValue CPTmpN1001_2; 33168 SDValue CPTmpN1001_3; 33169 SDValue CPTmpN1001_4; 33170 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 33171 SDValue N101 = N10.getOperand(1); 33172 if (N101.getOpcode() == ISD::Constant) { 33173 SDValue N11 = N1.getOperand(1); 33174 if (N11.getOpcode() == ISD::SRL) { 33175 SDValue N110 = N11.getOperand(0); 33176 SDValue N111 = N11.getOperand(1); 33177 if (N111.getOpcode() == ISD::Constant) { 33178 SDValue N2 = N.getOperand(2); 33179 if (N1001 == N2 && 33180 N1.getNode()->getValueType(0) == MVT::i16 && 33181 N101.getNode()->getValueType(0) == MVT::i8 && 33182 N111.getNode()->getValueType(0) == MVT::i8) { 33183 SDNode *Result = Emit_205(N, X86::SHLD16mri8, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 33184 return Result; 33185 } 33186 } 33187 } 33188 } 33189 } 33190 } 33191 } 33192 } 33193 } 33194 33195 // Pattern: (st:isVoid (or:i64 (srl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i8):$amt1), (shl:i64 GR64:i64:$src2, (imm:i8):$amt2))<<P:Predicate_shrd>>, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33196 // Emits: (SHRD64mri8:isVoid addr:iPTR:$dst, GR64:i64:$src2, (imm:i8):$amt1) 33197 // Pattern complexity = 60 cost = 1 size = 3 33198 if (Predicate_shrd(N1.getNode())) { 33199 SDValue N10 = N1.getOperand(0); 33200 if (N10.getOpcode() == ISD::SRL && 33201 N10.hasOneUse()) { 33202 SDValue N100 = N10.getOperand(0); 33203 if (N100.getOpcode() == ISD::LOAD && 33204 N100.hasOneUse() && 33205 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 33206 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 33207 SDValue Chain100 = N100.getOperand(0); 33208 if (Predicate_unindexedload(N100.getNode()) && 33209 Predicate_load(N100.getNode()) && 33210 Predicate_loadi64(N100.getNode())) { 33211 SDValue N1001 = N100.getOperand(1); 33212 SDValue CPTmpN1001_0; 33213 SDValue CPTmpN1001_1; 33214 SDValue CPTmpN1001_2; 33215 SDValue CPTmpN1001_3; 33216 SDValue CPTmpN1001_4; 33217 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 33218 SDValue N101 = N10.getOperand(1); 33219 if (N101.getOpcode() == ISD::Constant) { 33220 SDValue N11 = N1.getOperand(1); 33221 if (N11.getOpcode() == ISD::SHL) { 33222 SDValue N110 = N11.getOperand(0); 33223 SDValue N111 = N11.getOperand(1); 33224 if (N111.getOpcode() == ISD::Constant) { 33225 SDValue N2 = N.getOperand(2); 33226 if (N1001 == N2 && 33227 N1.getNode()->getValueType(0) == MVT::i64 && 33228 N101.getNode()->getValueType(0) == MVT::i8 && 33229 N111.getNode()->getValueType(0) == MVT::i8) { 33230 SDNode *Result = Emit_205(N, X86::SHRD64mri8, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 33231 return Result; 33232 } 33233 } 33234 } 33235 } 33236 } 33237 } 33238 } 33239 } 33240 } 33241 33242 // Pattern: (st:isVoid (or:i64 (shl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i8):$amt1), (srl:i64 GR64:i64:$src2, (imm:i8):$amt2))<<P:Predicate_shld>>, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33243 // Emits: (SHLD64mri8:isVoid addr:iPTR:$dst, GR64:i64:$src2, (imm:i8):$amt1) 33244 // Pattern complexity = 60 cost = 1 size = 3 33245 if (Predicate_shld(N1.getNode())) { 33246 SDValue N10 = N1.getOperand(0); 33247 if (N10.getOpcode() == ISD::SHL && 33248 N10.hasOneUse()) { 33249 SDValue N100 = N10.getOperand(0); 33250 if (N100.getOpcode() == ISD::LOAD && 33251 N100.hasOneUse() && 33252 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 33253 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 33254 SDValue Chain100 = N100.getOperand(0); 33255 if (Predicate_unindexedload(N100.getNode()) && 33256 Predicate_load(N100.getNode()) && 33257 Predicate_loadi64(N100.getNode())) { 33258 SDValue N1001 = N100.getOperand(1); 33259 SDValue CPTmpN1001_0; 33260 SDValue CPTmpN1001_1; 33261 SDValue CPTmpN1001_2; 33262 SDValue CPTmpN1001_3; 33263 SDValue CPTmpN1001_4; 33264 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 33265 SDValue N101 = N10.getOperand(1); 33266 if (N101.getOpcode() == ISD::Constant) { 33267 SDValue N11 = N1.getOperand(1); 33268 if (N11.getOpcode() == ISD::SRL) { 33269 SDValue N110 = N11.getOperand(0); 33270 SDValue N111 = N11.getOperand(1); 33271 if (N111.getOpcode() == ISD::Constant) { 33272 SDValue N2 = N.getOperand(2); 33273 if (N1001 == N2 && 33274 N1.getNode()->getValueType(0) == MVT::i64 && 33275 N101.getNode()->getValueType(0) == MVT::i8 && 33276 N111.getNode()->getValueType(0) == MVT::i8) { 33277 SDNode *Result = Emit_205(N, X86::SHLD64mri8, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 33278 return Result; 33279 } 33280 } 33281 } 33282 } 33283 } 33284 } 33285 } 33286 } 33287 } 33288 33289 // Pattern: (st:isVoid (or:i32 (shl:i32 GR32:i32:$src2, (imm:i8):$amt2), (srl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i8):$amt1))<<P:Predicate_shrd>>, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33290 // Emits: (SHRD32mri8:isVoid addr:iPTR:$dst, GR32:i32:$src2, (imm:i8):$amt1) 33291 // Pattern complexity = 60 cost = 1 size = 3 33292 if (Predicate_shrd(N1.getNode())) { 33293 SDValue N10 = N1.getOperand(0); 33294 if (N10.getOpcode() == ISD::SHL) { 33295 SDValue N100 = N10.getOperand(0); 33296 SDValue N101 = N10.getOperand(1); 33297 if (N101.getOpcode() == ISD::Constant) { 33298 SDValue N11 = N1.getOperand(1); 33299 if (N11.getOpcode() == ISD::SRL && 33300 N11.hasOneUse()) { 33301 SDValue N110 = N11.getOperand(0); 33302 if (N110.getOpcode() == ISD::LOAD && 33303 N110.hasOneUse() && 33304 IsLegalAndProfitableToFold(N110.getNode(), N11.getNode(), N.getNode()) && 33305 (Chain.getNode() == N110.getNode() || IsChainCompatible(Chain.getNode(), N110.getNode()))) { 33306 SDValue Chain110 = N110.getOperand(0); 33307 if (Predicate_unindexedload(N110.getNode()) && 33308 Predicate_loadi32(N110.getNode())) { 33309 SDValue N1101 = N110.getOperand(1); 33310 SDValue CPTmpN1101_0; 33311 SDValue CPTmpN1101_1; 33312 SDValue CPTmpN1101_2; 33313 SDValue CPTmpN1101_3; 33314 SDValue CPTmpN1101_4; 33315 if (SelectAddr(N, N1101, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4)) { 33316 SDValue N111 = N11.getOperand(1); 33317 if (N111.getOpcode() == ISD::Constant) { 33318 SDValue N2 = N.getOperand(2); 33319 if (N1101 == N2 && 33320 N1.getNode()->getValueType(0) == MVT::i32 && 33321 N101.getNode()->getValueType(0) == MVT::i8 && 33322 N111.getNode()->getValueType(0) == MVT::i8) { 33323 SDNode *Result = Emit_221(N, X86::SHRD32mri8, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4); 33324 return Result; 33325 } 33326 } 33327 } 33328 } 33329 } 33330 } 33331 } 33332 } 33333 } 33334 33335 // Pattern: (st:isVoid (or:i32 (srl:i32 GR32:i32:$src2, (imm:i8):$amt2), (shl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i8):$amt1))<<P:Predicate_shld>>, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33336 // Emits: (SHLD32mri8:isVoid addr:iPTR:$dst, GR32:i32:$src2, (imm:i8):$amt1) 33337 // Pattern complexity = 60 cost = 1 size = 3 33338 if (Predicate_shld(N1.getNode())) { 33339 SDValue N10 = N1.getOperand(0); 33340 if (N10.getOpcode() == ISD::SRL) { 33341 SDValue N100 = N10.getOperand(0); 33342 SDValue N101 = N10.getOperand(1); 33343 if (N101.getOpcode() == ISD::Constant) { 33344 SDValue N11 = N1.getOperand(1); 33345 if (N11.getOpcode() == ISD::SHL && 33346 N11.hasOneUse()) { 33347 SDValue N110 = N11.getOperand(0); 33348 if (N110.getOpcode() == ISD::LOAD && 33349 N110.hasOneUse() && 33350 IsLegalAndProfitableToFold(N110.getNode(), N11.getNode(), N.getNode()) && 33351 (Chain.getNode() == N110.getNode() || IsChainCompatible(Chain.getNode(), N110.getNode()))) { 33352 SDValue Chain110 = N110.getOperand(0); 33353 if (Predicate_unindexedload(N110.getNode()) && 33354 Predicate_loadi32(N110.getNode())) { 33355 SDValue N1101 = N110.getOperand(1); 33356 SDValue CPTmpN1101_0; 33357 SDValue CPTmpN1101_1; 33358 SDValue CPTmpN1101_2; 33359 SDValue CPTmpN1101_3; 33360 SDValue CPTmpN1101_4; 33361 if (SelectAddr(N, N1101, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4)) { 33362 SDValue N111 = N11.getOperand(1); 33363 if (N111.getOpcode() == ISD::Constant) { 33364 SDValue N2 = N.getOperand(2); 33365 if (N1101 == N2 && 33366 N1.getNode()->getValueType(0) == MVT::i32 && 33367 N101.getNode()->getValueType(0) == MVT::i8 && 33368 N111.getNode()->getValueType(0) == MVT::i8) { 33369 SDNode *Result = Emit_221(N, X86::SHLD32mri8, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4); 33370 return Result; 33371 } 33372 } 33373 } 33374 } 33375 } 33376 } 33377 } 33378 } 33379 } 33380 33381 // Pattern: (st:isVoid (or:i16 (shl:i16 GR16:i16:$src2, (imm:i8):$amt2), (srl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i8):$amt1))<<P:Predicate_shrd>>, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33382 // Emits: (SHRD16mri8:isVoid addr:iPTR:$dst, GR16:i16:$src2, (imm:i8):$amt1) 33383 // Pattern complexity = 60 cost = 1 size = 3 33384 if (Predicate_shrd(N1.getNode())) { 33385 SDValue N10 = N1.getOperand(0); 33386 if (N10.getOpcode() == ISD::SHL) { 33387 SDValue N100 = N10.getOperand(0); 33388 SDValue N101 = N10.getOperand(1); 33389 if (N101.getOpcode() == ISD::Constant) { 33390 SDValue N11 = N1.getOperand(1); 33391 if (N11.getOpcode() == ISD::SRL && 33392 N11.hasOneUse()) { 33393 SDValue N110 = N11.getOperand(0); 33394 if (N110.getOpcode() == ISD::LOAD && 33395 N110.hasOneUse() && 33396 IsLegalAndProfitableToFold(N110.getNode(), N11.getNode(), N.getNode()) && 33397 (Chain.getNode() == N110.getNode() || IsChainCompatible(Chain.getNode(), N110.getNode()))) { 33398 SDValue Chain110 = N110.getOperand(0); 33399 if (Predicate_unindexedload(N110.getNode()) && 33400 Predicate_loadi16(N110.getNode())) { 33401 SDValue N1101 = N110.getOperand(1); 33402 SDValue CPTmpN1101_0; 33403 SDValue CPTmpN1101_1; 33404 SDValue CPTmpN1101_2; 33405 SDValue CPTmpN1101_3; 33406 SDValue CPTmpN1101_4; 33407 if (SelectAddr(N, N1101, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4)) { 33408 SDValue N111 = N11.getOperand(1); 33409 if (N111.getOpcode() == ISD::Constant) { 33410 SDValue N2 = N.getOperand(2); 33411 if (N1101 == N2 && 33412 N1.getNode()->getValueType(0) == MVT::i16 && 33413 N101.getNode()->getValueType(0) == MVT::i8 && 33414 N111.getNode()->getValueType(0) == MVT::i8) { 33415 SDNode *Result = Emit_221(N, X86::SHRD16mri8, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4); 33416 return Result; 33417 } 33418 } 33419 } 33420 } 33421 } 33422 } 33423 } 33424 } 33425 } 33426 33427 // Pattern: (st:isVoid (or:i16 (srl:i16 GR16:i16:$src2, (imm:i8):$amt2), (shl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i8):$amt1))<<P:Predicate_shld>>, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33428 // Emits: (SHLD16mri8:isVoid addr:iPTR:$dst, GR16:i16:$src2, (imm:i8):$amt1) 33429 // Pattern complexity = 60 cost = 1 size = 3 33430 if (Predicate_shld(N1.getNode())) { 33431 SDValue N10 = N1.getOperand(0); 33432 if (N10.getOpcode() == ISD::SRL) { 33433 SDValue N100 = N10.getOperand(0); 33434 SDValue N101 = N10.getOperand(1); 33435 if (N101.getOpcode() == ISD::Constant) { 33436 SDValue N11 = N1.getOperand(1); 33437 if (N11.getOpcode() == ISD::SHL && 33438 N11.hasOneUse()) { 33439 SDValue N110 = N11.getOperand(0); 33440 if (N110.getOpcode() == ISD::LOAD && 33441 N110.hasOneUse() && 33442 IsLegalAndProfitableToFold(N110.getNode(), N11.getNode(), N.getNode()) && 33443 (Chain.getNode() == N110.getNode() || IsChainCompatible(Chain.getNode(), N110.getNode()))) { 33444 SDValue Chain110 = N110.getOperand(0); 33445 if (Predicate_unindexedload(N110.getNode()) && 33446 Predicate_loadi16(N110.getNode())) { 33447 SDValue N1101 = N110.getOperand(1); 33448 SDValue CPTmpN1101_0; 33449 SDValue CPTmpN1101_1; 33450 SDValue CPTmpN1101_2; 33451 SDValue CPTmpN1101_3; 33452 SDValue CPTmpN1101_4; 33453 if (SelectAddr(N, N1101, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4)) { 33454 SDValue N111 = N11.getOperand(1); 33455 if (N111.getOpcode() == ISD::Constant) { 33456 SDValue N2 = N.getOperand(2); 33457 if (N1101 == N2 && 33458 N1.getNode()->getValueType(0) == MVT::i16 && 33459 N101.getNode()->getValueType(0) == MVT::i8 && 33460 N111.getNode()->getValueType(0) == MVT::i8) { 33461 SDNode *Result = Emit_221(N, X86::SHLD16mri8, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4); 33462 return Result; 33463 } 33464 } 33465 } 33466 } 33467 } 33468 } 33469 } 33470 } 33471 } 33472 33473 // Pattern: (st:isVoid (or:i64 (shl:i64 GR64:i64:$src2, (imm:i8):$amt2), (srl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i8):$amt1))<<P:Predicate_shrd>>, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33474 // Emits: (SHRD64mri8:isVoid addr:iPTR:$dst, GR64:i64:$src2, (imm:i8):$amt1) 33475 // Pattern complexity = 60 cost = 1 size = 3 33476 if (Predicate_shrd(N1.getNode())) { 33477 SDValue N10 = N1.getOperand(0); 33478 if (N10.getOpcode() == ISD::SHL) { 33479 SDValue N100 = N10.getOperand(0); 33480 SDValue N101 = N10.getOperand(1); 33481 if (N101.getOpcode() == ISD::Constant) { 33482 SDValue N11 = N1.getOperand(1); 33483 if (N11.getOpcode() == ISD::SRL && 33484 N11.hasOneUse()) { 33485 SDValue N110 = N11.getOperand(0); 33486 if (N110.getOpcode() == ISD::LOAD && 33487 N110.hasOneUse() && 33488 IsLegalAndProfitableToFold(N110.getNode(), N11.getNode(), N.getNode()) && 33489 (Chain.getNode() == N110.getNode() || IsChainCompatible(Chain.getNode(), N110.getNode()))) { 33490 SDValue Chain110 = N110.getOperand(0); 33491 if (Predicate_unindexedload(N110.getNode()) && 33492 Predicate_load(N110.getNode()) && 33493 Predicate_loadi64(N110.getNode())) { 33494 SDValue N1101 = N110.getOperand(1); 33495 SDValue CPTmpN1101_0; 33496 SDValue CPTmpN1101_1; 33497 SDValue CPTmpN1101_2; 33498 SDValue CPTmpN1101_3; 33499 SDValue CPTmpN1101_4; 33500 if (SelectAddr(N, N1101, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4)) { 33501 SDValue N111 = N11.getOperand(1); 33502 if (N111.getOpcode() == ISD::Constant) { 33503 SDValue N2 = N.getOperand(2); 33504 if (N1101 == N2 && 33505 N1.getNode()->getValueType(0) == MVT::i64 && 33506 N101.getNode()->getValueType(0) == MVT::i8 && 33507 N111.getNode()->getValueType(0) == MVT::i8) { 33508 SDNode *Result = Emit_221(N, X86::SHRD64mri8, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4); 33509 return Result; 33510 } 33511 } 33512 } 33513 } 33514 } 33515 } 33516 } 33517 } 33518 } 33519 33520 // Pattern: (st:isVoid (or:i64 (srl:i64 GR64:i64:$src2, (imm:i8):$amt2), (shl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i8):$amt1))<<P:Predicate_shld>>, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33521 // Emits: (SHLD64mri8:isVoid addr:iPTR:$dst, GR64:i64:$src2, (imm:i8):$amt1) 33522 // Pattern complexity = 60 cost = 1 size = 3 33523 if (Predicate_shld(N1.getNode())) { 33524 SDValue N10 = N1.getOperand(0); 33525 if (N10.getOpcode() == ISD::SRL) { 33526 SDValue N100 = N10.getOperand(0); 33527 SDValue N101 = N10.getOperand(1); 33528 if (N101.getOpcode() == ISD::Constant) { 33529 SDValue N11 = N1.getOperand(1); 33530 if (N11.getOpcode() == ISD::SHL && 33531 N11.hasOneUse()) { 33532 SDValue N110 = N11.getOperand(0); 33533 if (N110.getOpcode() == ISD::LOAD && 33534 N110.hasOneUse() && 33535 IsLegalAndProfitableToFold(N110.getNode(), N11.getNode(), N.getNode()) && 33536 (Chain.getNode() == N110.getNode() || IsChainCompatible(Chain.getNode(), N110.getNode()))) { 33537 SDValue Chain110 = N110.getOperand(0); 33538 if (Predicate_unindexedload(N110.getNode()) && 33539 Predicate_load(N110.getNode()) && 33540 Predicate_loadi64(N110.getNode())) { 33541 SDValue N1101 = N110.getOperand(1); 33542 SDValue CPTmpN1101_0; 33543 SDValue CPTmpN1101_1; 33544 SDValue CPTmpN1101_2; 33545 SDValue CPTmpN1101_3; 33546 SDValue CPTmpN1101_4; 33547 if (SelectAddr(N, N1101, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4)) { 33548 SDValue N111 = N11.getOperand(1); 33549 if (N111.getOpcode() == ISD::Constant) { 33550 SDValue N2 = N.getOperand(2); 33551 if (N1101 == N2 && 33552 N1.getNode()->getValueType(0) == MVT::i64 && 33553 N101.getNode()->getValueType(0) == MVT::i8 && 33554 N111.getNode()->getValueType(0) == MVT::i8) { 33555 SDNode *Result = Emit_221(N, X86::SHLD64mri8, CPTmpN1101_0, CPTmpN1101_1, CPTmpN1101_2, CPTmpN1101_3, CPTmpN1101_4); 33556 return Result; 33557 } 33558 } 33559 } 33560 } 33561 } 33562 } 33563 } 33564 } 33565 } 33566 } 33567 if (N1.getOpcode() == ISD::SHL && 33568 N1.hasOneUse()) { 33569 SDValue N10 = N1.getOperand(0); 33570 if (N10.getOpcode() == ISD::LOAD && 33571 N10.hasOneUse() && 33572 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 33573 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 33574 SDValue Chain10 = N10.getOperand(0); 33575 if (Predicate_unindexedload(N10.getNode())) { 33576 33577 // Pattern: (st:isVoid (shl:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (and:i8 CL:i8:$amt, 31:i8)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33578 // Emits: (SHL8mCL:isVoid addr:iPTR:$dst) 33579 // Pattern complexity = 55 cost = 1 size = 3 33580 if (Predicate_load(N10.getNode()) && 33581 Predicate_loadi8(N10.getNode())) { 33582 SDValue N101 = N10.getOperand(1); 33583 SDValue CPTmpN101_0; 33584 SDValue CPTmpN101_1; 33585 SDValue CPTmpN101_2; 33586 SDValue CPTmpN101_3; 33587 SDValue CPTmpN101_4; 33588 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 33589 SDValue N11 = N1.getOperand(1); 33590 if (N11.getOpcode() == ISD::AND) { 33591 SDValue N110 = N11.getOperand(0); 33592 SDValue N111 = N11.getOperand(1); 33593 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N111); 33594 if (Tmp0 && 33595 CheckAndMask(N110, Tmp0, INT64_C(31))) { 33596 SDValue N2 = N.getOperand(2); 33597 if (N101 == N2 && 33598 N1.getNode()->getValueType(0) == MVT::i8 && 33599 N11.getNode()->getValueType(0) == MVT::i8) { 33600 SDNode *Result = Emit_202(N, X86::SHL8mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 33601 return Result; 33602 } 33603 } 33604 } 33605 } 33606 } 33607 33608 // Pattern: (st:isVoid (shl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (and:i8 CL:i8:$amt, 31:i8)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33609 // Emits: (SHL16mCL:isVoid addr:iPTR:$dst) 33610 // Pattern complexity = 55 cost = 1 size = 3 33611 if (Predicate_loadi16(N10.getNode())) { 33612 SDValue N101 = N10.getOperand(1); 33613 SDValue CPTmpN101_0; 33614 SDValue CPTmpN101_1; 33615 SDValue CPTmpN101_2; 33616 SDValue CPTmpN101_3; 33617 SDValue CPTmpN101_4; 33618 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 33619 SDValue N11 = N1.getOperand(1); 33620 if (N11.getOpcode() == ISD::AND) { 33621 SDValue N110 = N11.getOperand(0); 33622 SDValue N111 = N11.getOperand(1); 33623 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N111); 33624 if (Tmp0 && 33625 CheckAndMask(N110, Tmp0, INT64_C(31))) { 33626 SDValue N2 = N.getOperand(2); 33627 if (N101 == N2 && 33628 N1.getNode()->getValueType(0) == MVT::i16 && 33629 N11.getNode()->getValueType(0) == MVT::i8) { 33630 SDNode *Result = Emit_202(N, X86::SHL16mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 33631 return Result; 33632 } 33633 } 33634 } 33635 } 33636 } 33637 33638 // Pattern: (st:isVoid (shl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (and:i8 CL:i8:$amt, 31:i8)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33639 // Emits: (SHL32mCL:isVoid addr:iPTR:$dst) 33640 // Pattern complexity = 55 cost = 1 size = 3 33641 if (Predicate_loadi32(N10.getNode())) { 33642 SDValue N101 = N10.getOperand(1); 33643 SDValue CPTmpN101_0; 33644 SDValue CPTmpN101_1; 33645 SDValue CPTmpN101_2; 33646 SDValue CPTmpN101_3; 33647 SDValue CPTmpN101_4; 33648 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 33649 SDValue N11 = N1.getOperand(1); 33650 if (N11.getOpcode() == ISD::AND) { 33651 SDValue N110 = N11.getOperand(0); 33652 SDValue N111 = N11.getOperand(1); 33653 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N111); 33654 if (Tmp0 && 33655 CheckAndMask(N110, Tmp0, INT64_C(31))) { 33656 SDValue N2 = N.getOperand(2); 33657 if (N101 == N2 && 33658 N1.getNode()->getValueType(0) == MVT::i32 && 33659 N11.getNode()->getValueType(0) == MVT::i8) { 33660 SDNode *Result = Emit_202(N, X86::SHL32mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 33661 return Result; 33662 } 33663 } 33664 } 33665 } 33666 } 33667 } 33668 } 33669 } 33670 if (N1.getOpcode() == ISD::SRL && 33671 N1.hasOneUse()) { 33672 SDValue N10 = N1.getOperand(0); 33673 if (N10.getOpcode() == ISD::LOAD && 33674 N10.hasOneUse() && 33675 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 33676 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 33677 SDValue Chain10 = N10.getOperand(0); 33678 if (Predicate_unindexedload(N10.getNode())) { 33679 33680 // Pattern: (st:isVoid (srl:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (and:i8 CL:i8:$amt, 31:i8)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33681 // Emits: (SHR8mCL:isVoid addr:iPTR:$dst) 33682 // Pattern complexity = 55 cost = 1 size = 3 33683 if (Predicate_load(N10.getNode()) && 33684 Predicate_loadi8(N10.getNode())) { 33685 SDValue N101 = N10.getOperand(1); 33686 SDValue CPTmpN101_0; 33687 SDValue CPTmpN101_1; 33688 SDValue CPTmpN101_2; 33689 SDValue CPTmpN101_3; 33690 SDValue CPTmpN101_4; 33691 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 33692 SDValue N11 = N1.getOperand(1); 33693 if (N11.getOpcode() == ISD::AND) { 33694 SDValue N110 = N11.getOperand(0); 33695 SDValue N111 = N11.getOperand(1); 33696 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N111); 33697 if (Tmp0 && 33698 CheckAndMask(N110, Tmp0, INT64_C(31))) { 33699 SDValue N2 = N.getOperand(2); 33700 if (N101 == N2 && 33701 N1.getNode()->getValueType(0) == MVT::i8 && 33702 N11.getNode()->getValueType(0) == MVT::i8) { 33703 SDNode *Result = Emit_202(N, X86::SHR8mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 33704 return Result; 33705 } 33706 } 33707 } 33708 } 33709 } 33710 33711 // Pattern: (st:isVoid (srl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (and:i8 CL:i8:$amt, 31:i8)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33712 // Emits: (SHR16mCL:isVoid addr:iPTR:$dst) 33713 // Pattern complexity = 55 cost = 1 size = 3 33714 if (Predicate_loadi16(N10.getNode())) { 33715 SDValue N101 = N10.getOperand(1); 33716 SDValue CPTmpN101_0; 33717 SDValue CPTmpN101_1; 33718 SDValue CPTmpN101_2; 33719 SDValue CPTmpN101_3; 33720 SDValue CPTmpN101_4; 33721 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 33722 SDValue N11 = N1.getOperand(1); 33723 if (N11.getOpcode() == ISD::AND) { 33724 SDValue N110 = N11.getOperand(0); 33725 SDValue N111 = N11.getOperand(1); 33726 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N111); 33727 if (Tmp0 && 33728 CheckAndMask(N110, Tmp0, INT64_C(31))) { 33729 SDValue N2 = N.getOperand(2); 33730 if (N101 == N2 && 33731 N1.getNode()->getValueType(0) == MVT::i16 && 33732 N11.getNode()->getValueType(0) == MVT::i8) { 33733 SDNode *Result = Emit_202(N, X86::SHR16mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 33734 return Result; 33735 } 33736 } 33737 } 33738 } 33739 } 33740 33741 // Pattern: (st:isVoid (srl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (and:i8 CL:i8:$amt, 31:i8)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33742 // Emits: (SHR32mCL:isVoid addr:iPTR:$dst) 33743 // Pattern complexity = 55 cost = 1 size = 3 33744 if (Predicate_loadi32(N10.getNode())) { 33745 SDValue N101 = N10.getOperand(1); 33746 SDValue CPTmpN101_0; 33747 SDValue CPTmpN101_1; 33748 SDValue CPTmpN101_2; 33749 SDValue CPTmpN101_3; 33750 SDValue CPTmpN101_4; 33751 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 33752 SDValue N11 = N1.getOperand(1); 33753 if (N11.getOpcode() == ISD::AND) { 33754 SDValue N110 = N11.getOperand(0); 33755 SDValue N111 = N11.getOperand(1); 33756 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N111); 33757 if (Tmp0 && 33758 CheckAndMask(N110, Tmp0, INT64_C(31))) { 33759 SDValue N2 = N.getOperand(2); 33760 if (N101 == N2 && 33761 N1.getNode()->getValueType(0) == MVT::i32 && 33762 N11.getNode()->getValueType(0) == MVT::i8) { 33763 SDNode *Result = Emit_202(N, X86::SHR32mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 33764 return Result; 33765 } 33766 } 33767 } 33768 } 33769 } 33770 } 33771 } 33772 } 33773 if (N1.getOpcode() == ISD::SRA && 33774 N1.hasOneUse()) { 33775 SDValue N10 = N1.getOperand(0); 33776 if (N10.getOpcode() == ISD::LOAD && 33777 N10.hasOneUse() && 33778 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 33779 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 33780 SDValue Chain10 = N10.getOperand(0); 33781 if (Predicate_unindexedload(N10.getNode())) { 33782 33783 // Pattern: (st:isVoid (sra:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (and:i8 CL:i8:$amt, 31:i8)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33784 // Emits: (SAR8mCL:isVoid addr:iPTR:$dst) 33785 // Pattern complexity = 55 cost = 1 size = 3 33786 if (Predicate_load(N10.getNode()) && 33787 Predicate_loadi8(N10.getNode())) { 33788 SDValue N101 = N10.getOperand(1); 33789 SDValue CPTmpN101_0; 33790 SDValue CPTmpN101_1; 33791 SDValue CPTmpN101_2; 33792 SDValue CPTmpN101_3; 33793 SDValue CPTmpN101_4; 33794 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 33795 SDValue N11 = N1.getOperand(1); 33796 if (N11.getOpcode() == ISD::AND) { 33797 SDValue N110 = N11.getOperand(0); 33798 SDValue N111 = N11.getOperand(1); 33799 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N111); 33800 if (Tmp0 && 33801 CheckAndMask(N110, Tmp0, INT64_C(31))) { 33802 SDValue N2 = N.getOperand(2); 33803 if (N101 == N2 && 33804 N1.getNode()->getValueType(0) == MVT::i8 && 33805 N11.getNode()->getValueType(0) == MVT::i8) { 33806 SDNode *Result = Emit_202(N, X86::SAR8mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 33807 return Result; 33808 } 33809 } 33810 } 33811 } 33812 } 33813 33814 // Pattern: (st:isVoid (sra:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (and:i8 CL:i8:$amt, 31:i8)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33815 // Emits: (SAR16mCL:isVoid addr:iPTR:$dst) 33816 // Pattern complexity = 55 cost = 1 size = 3 33817 if (Predicate_loadi16(N10.getNode())) { 33818 SDValue N101 = N10.getOperand(1); 33819 SDValue CPTmpN101_0; 33820 SDValue CPTmpN101_1; 33821 SDValue CPTmpN101_2; 33822 SDValue CPTmpN101_3; 33823 SDValue CPTmpN101_4; 33824 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 33825 SDValue N11 = N1.getOperand(1); 33826 if (N11.getOpcode() == ISD::AND) { 33827 SDValue N110 = N11.getOperand(0); 33828 SDValue N111 = N11.getOperand(1); 33829 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N111); 33830 if (Tmp0 && 33831 CheckAndMask(N110, Tmp0, INT64_C(31))) { 33832 SDValue N2 = N.getOperand(2); 33833 if (N101 == N2 && 33834 N1.getNode()->getValueType(0) == MVT::i16 && 33835 N11.getNode()->getValueType(0) == MVT::i8) { 33836 SDNode *Result = Emit_202(N, X86::SAR16mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 33837 return Result; 33838 } 33839 } 33840 } 33841 } 33842 } 33843 33844 // Pattern: (st:isVoid (sra:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (and:i8 CL:i8:$amt, 31:i8)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33845 // Emits: (SAR32mCL:isVoid addr:iPTR:$dst) 33846 // Pattern complexity = 55 cost = 1 size = 3 33847 if (Predicate_loadi32(N10.getNode())) { 33848 SDValue N101 = N10.getOperand(1); 33849 SDValue CPTmpN101_0; 33850 SDValue CPTmpN101_1; 33851 SDValue CPTmpN101_2; 33852 SDValue CPTmpN101_3; 33853 SDValue CPTmpN101_4; 33854 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 33855 SDValue N11 = N1.getOperand(1); 33856 if (N11.getOpcode() == ISD::AND) { 33857 SDValue N110 = N11.getOperand(0); 33858 SDValue N111 = N11.getOperand(1); 33859 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N111); 33860 if (Tmp0 && 33861 CheckAndMask(N110, Tmp0, INT64_C(31))) { 33862 SDValue N2 = N.getOperand(2); 33863 if (N101 == N2 && 33864 N1.getNode()->getValueType(0) == MVT::i32 && 33865 N11.getNode()->getValueType(0) == MVT::i8) { 33866 SDNode *Result = Emit_202(N, X86::SAR32mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 33867 return Result; 33868 } 33869 } 33870 } 33871 } 33872 } 33873 } 33874 } 33875 } 33876 33877 // Pattern: (st:isVoid (shl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (and:i8 CL:i8:$amt, 63:i8)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33878 // Emits: (SHL64mCL:isVoid addr:iPTR:$dst) 33879 // Pattern complexity = 55 cost = 1 size = 3 33880 if (N1.getOpcode() == ISD::SHL && 33881 N1.hasOneUse()) { 33882 SDValue N10 = N1.getOperand(0); 33883 if (N10.getOpcode() == ISD::LOAD && 33884 N10.hasOneUse() && 33885 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 33886 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 33887 SDValue Chain10 = N10.getOperand(0); 33888 if (Predicate_unindexedload(N10.getNode()) && 33889 Predicate_load(N10.getNode()) && 33890 Predicate_loadi64(N10.getNode())) { 33891 SDValue N101 = N10.getOperand(1); 33892 SDValue CPTmpN101_0; 33893 SDValue CPTmpN101_1; 33894 SDValue CPTmpN101_2; 33895 SDValue CPTmpN101_3; 33896 SDValue CPTmpN101_4; 33897 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 33898 SDValue N11 = N1.getOperand(1); 33899 if (N11.getOpcode() == ISD::AND) { 33900 SDValue N110 = N11.getOperand(0); 33901 SDValue N111 = N11.getOperand(1); 33902 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N111); 33903 if (Tmp0 && 33904 CheckAndMask(N110, Tmp0, INT64_C(63))) { 33905 SDValue N2 = N.getOperand(2); 33906 if (N101 == N2 && 33907 N1.getNode()->getValueType(0) == MVT::i64 && 33908 N11.getNode()->getValueType(0) == MVT::i8) { 33909 SDNode *Result = Emit_202(N, X86::SHL64mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 33910 return Result; 33911 } 33912 } 33913 } 33914 } 33915 } 33916 } 33917 } 33918 33919 // Pattern: (st:isVoid (srl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (and:i8 CL:i8:$amt, 63:i8)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33920 // Emits: (SHR64mCL:isVoid addr:iPTR:$dst) 33921 // Pattern complexity = 55 cost = 1 size = 3 33922 if (N1.getOpcode() == ISD::SRL && 33923 N1.hasOneUse()) { 33924 SDValue N10 = N1.getOperand(0); 33925 if (N10.getOpcode() == ISD::LOAD && 33926 N10.hasOneUse() && 33927 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 33928 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 33929 SDValue Chain10 = N10.getOperand(0); 33930 if (Predicate_unindexedload(N10.getNode()) && 33931 Predicate_load(N10.getNode()) && 33932 Predicate_loadi64(N10.getNode())) { 33933 SDValue N101 = N10.getOperand(1); 33934 SDValue CPTmpN101_0; 33935 SDValue CPTmpN101_1; 33936 SDValue CPTmpN101_2; 33937 SDValue CPTmpN101_3; 33938 SDValue CPTmpN101_4; 33939 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 33940 SDValue N11 = N1.getOperand(1); 33941 if (N11.getOpcode() == ISD::AND) { 33942 SDValue N110 = N11.getOperand(0); 33943 SDValue N111 = N11.getOperand(1); 33944 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N111); 33945 if (Tmp0 && 33946 CheckAndMask(N110, Tmp0, INT64_C(63))) { 33947 SDValue N2 = N.getOperand(2); 33948 if (N101 == N2 && 33949 N1.getNode()->getValueType(0) == MVT::i64 && 33950 N11.getNode()->getValueType(0) == MVT::i8) { 33951 SDNode *Result = Emit_202(N, X86::SHR64mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 33952 return Result; 33953 } 33954 } 33955 } 33956 } 33957 } 33958 } 33959 } 33960 33961 // Pattern: (st:isVoid (sra:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (and:i8 CL:i8:$amt, 63:i8)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 33962 // Emits: (SAR64mCL:isVoid addr:iPTR:$dst) 33963 // Pattern complexity = 55 cost = 1 size = 3 33964 if (N1.getOpcode() == ISD::SRA && 33965 N1.hasOneUse()) { 33966 SDValue N10 = N1.getOperand(0); 33967 if (N10.getOpcode() == ISD::LOAD && 33968 N10.hasOneUse() && 33969 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 33970 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 33971 SDValue Chain10 = N10.getOperand(0); 33972 if (Predicate_unindexedload(N10.getNode()) && 33973 Predicate_load(N10.getNode()) && 33974 Predicate_loadi64(N10.getNode())) { 33975 SDValue N101 = N10.getOperand(1); 33976 SDValue CPTmpN101_0; 33977 SDValue CPTmpN101_1; 33978 SDValue CPTmpN101_2; 33979 SDValue CPTmpN101_3; 33980 SDValue CPTmpN101_4; 33981 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 33982 SDValue N11 = N1.getOperand(1); 33983 if (N11.getOpcode() == ISD::AND) { 33984 SDValue N110 = N11.getOperand(0); 33985 SDValue N111 = N11.getOperand(1); 33986 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N111); 33987 if (Tmp0 && 33988 CheckAndMask(N110, Tmp0, INT64_C(63))) { 33989 SDValue N2 = N.getOperand(2); 33990 if (N101 == N2 && 33991 N1.getNode()->getValueType(0) == MVT::i64 && 33992 N11.getNode()->getValueType(0) == MVT::i8) { 33993 SDNode *Result = Emit_202(N, X86::SAR64mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 33994 return Result; 33995 } 33996 } 33997 } 33998 } 33999 } 34000 } 34001 } 34002 if (N1.getOpcode() == ISD::SUB && 34003 N1.hasOneUse()) { 34004 SDValue N10 = N1.getOperand(0); 34005 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N10); 34006 if (Tmp0) { 34007 int64_t CN1 = Tmp0->getSExtValue(); 34008 if (CN1 == INT64_C(0)) { 34009 SDValue N11 = N1.getOperand(1); 34010 if (N11.getOpcode() == ISD::LOAD && 34011 N11.hasOneUse() && 34012 IsLegalAndProfitableToFold(N11.getNode(), N1.getNode(), N.getNode()) && 34013 (Chain.getNode() == N11.getNode() || IsChainCompatible(Chain.getNode(), N11.getNode()))) { 34014 SDValue Chain11 = N11.getOperand(0); 34015 if (Predicate_unindexedload(N11.getNode())) { 34016 34017 // Pattern: (st:isVoid (sub:i8 0:i8, (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34018 // Emits: (NEG8m:isVoid addr:iPTR:$dst) 34019 // Pattern complexity = 52 cost = 1 size = 2 34020 if (Predicate_load(N11.getNode()) && 34021 Predicate_loadi8(N11.getNode())) { 34022 SDValue N111 = N11.getOperand(1); 34023 SDValue CPTmpN111_0; 34024 SDValue CPTmpN111_1; 34025 SDValue CPTmpN111_2; 34026 SDValue CPTmpN111_3; 34027 SDValue CPTmpN111_4; 34028 if (SelectAddr(N, N111, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4)) { 34029 SDValue N2 = N.getOperand(2); 34030 if (N111 == N2 && 34031 N1.getNode()->getValueType(0) == MVT::i8) { 34032 SDNode *Result = Emit_174(N, X86::NEG8m, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 34033 return Result; 34034 } 34035 } 34036 } 34037 34038 // Pattern: (st:isVoid (sub:i16 0:i16, (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34039 // Emits: (NEG16m:isVoid addr:iPTR:$dst) 34040 // Pattern complexity = 52 cost = 1 size = 2 34041 if (Predicate_loadi16(N11.getNode())) { 34042 SDValue N111 = N11.getOperand(1); 34043 SDValue CPTmpN111_0; 34044 SDValue CPTmpN111_1; 34045 SDValue CPTmpN111_2; 34046 SDValue CPTmpN111_3; 34047 SDValue CPTmpN111_4; 34048 if (SelectAddr(N, N111, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4)) { 34049 SDValue N2 = N.getOperand(2); 34050 if (N111 == N2 && 34051 N1.getNode()->getValueType(0) == MVT::i16) { 34052 SDNode *Result = Emit_174(N, X86::NEG16m, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 34053 return Result; 34054 } 34055 } 34056 } 34057 34058 // Pattern: (st:isVoid (sub:i32 0:i32, (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34059 // Emits: (NEG32m:isVoid addr:iPTR:$dst) 34060 // Pattern complexity = 52 cost = 1 size = 2 34061 if (Predicate_loadi32(N11.getNode())) { 34062 SDValue N111 = N11.getOperand(1); 34063 SDValue CPTmpN111_0; 34064 SDValue CPTmpN111_1; 34065 SDValue CPTmpN111_2; 34066 SDValue CPTmpN111_3; 34067 SDValue CPTmpN111_4; 34068 if (SelectAddr(N, N111, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4)) { 34069 SDValue N2 = N.getOperand(2); 34070 if (N111 == N2 && 34071 N1.getNode()->getValueType(0) == MVT::i32) { 34072 SDNode *Result = Emit_174(N, X86::NEG32m, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 34073 return Result; 34074 } 34075 } 34076 } 34077 } 34078 } 34079 } 34080 } 34081 } 34082 34083 // Pattern: (st:isVoid (add:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34084 // Emits: (INC8m:isVoid addr:iPTR:$dst) 34085 // Pattern complexity = 52 cost = 1 size = 2 34086 if (N1.getOpcode() == ISD::ADD && 34087 N1.hasOneUse()) { 34088 SDValue N10 = N1.getOperand(0); 34089 if (N10.getOpcode() == ISD::LOAD && 34090 N10.hasOneUse() && 34091 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 34092 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 34093 SDValue Chain10 = N10.getOperand(0); 34094 if (Predicate_unindexedload(N10.getNode()) && 34095 Predicate_load(N10.getNode()) && 34096 Predicate_loadi8(N10.getNode())) { 34097 SDValue N101 = N10.getOperand(1); 34098 SDValue CPTmpN101_0; 34099 SDValue CPTmpN101_1; 34100 SDValue CPTmpN101_2; 34101 SDValue CPTmpN101_3; 34102 SDValue CPTmpN101_4; 34103 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34104 SDValue N11 = N1.getOperand(1); 34105 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34106 if (Tmp0) { 34107 int64_t CN1 = Tmp0->getSExtValue(); 34108 if (CN1 == INT64_C(1)) { 34109 SDValue N2 = N.getOperand(2); 34110 if (N101 == N2 && 34111 N1.getNode()->getValueType(0) == MVT::i8) { 34112 SDNode *Result = Emit_176(N, X86::INC8m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34113 return Result; 34114 } 34115 } 34116 } 34117 } 34118 } 34119 } 34120 } 34121 } 34122 } 34123 if ((!Subtarget->is64Bit())) { 34124 SDValue Chain = N.getOperand(0); 34125 if (Predicate_unindexedstore(N.getNode()) && 34126 Predicate_store(N.getNode())) { 34127 SDValue N1 = N.getOperand(1); 34128 if (N1.getOpcode() == ISD::ADD && 34129 N1.hasOneUse()) { 34130 SDValue N10 = N1.getOperand(0); 34131 if (N10.getOpcode() == ISD::LOAD && 34132 N10.hasOneUse() && 34133 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 34134 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 34135 SDValue Chain10 = N10.getOperand(0); 34136 if (Predicate_unindexedload(N10.getNode())) { 34137 34138 // Pattern: (st:isVoid (add:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 1:i16), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34139 // Emits: (INC16m:isVoid addr:iPTR:$dst) 34140 // Pattern complexity = 52 cost = 1 size = 2 34141 if (Predicate_loadi16(N10.getNode())) { 34142 SDValue N101 = N10.getOperand(1); 34143 SDValue CPTmpN101_0; 34144 SDValue CPTmpN101_1; 34145 SDValue CPTmpN101_2; 34146 SDValue CPTmpN101_3; 34147 SDValue CPTmpN101_4; 34148 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34149 SDValue N11 = N1.getOperand(1); 34150 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34151 if (Tmp0) { 34152 int64_t CN1 = Tmp0->getSExtValue(); 34153 if (CN1 == INT64_C(1)) { 34154 SDValue N2 = N.getOperand(2); 34155 if (N101 == N2 && 34156 N1.getNode()->getValueType(0) == MVT::i16) { 34157 SDNode *Result = Emit_176(N, X86::INC16m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34158 return Result; 34159 } 34160 } 34161 } 34162 } 34163 } 34164 34165 // Pattern: (st:isVoid (add:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 1:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34166 // Emits: (INC32m:isVoid addr:iPTR:$dst) 34167 // Pattern complexity = 52 cost = 1 size = 2 34168 if (Predicate_loadi32(N10.getNode())) { 34169 SDValue N101 = N10.getOperand(1); 34170 SDValue CPTmpN101_0; 34171 SDValue CPTmpN101_1; 34172 SDValue CPTmpN101_2; 34173 SDValue CPTmpN101_3; 34174 SDValue CPTmpN101_4; 34175 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34176 SDValue N11 = N1.getOperand(1); 34177 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34178 if (Tmp0) { 34179 int64_t CN1 = Tmp0->getSExtValue(); 34180 if (CN1 == INT64_C(1)) { 34181 SDValue N2 = N.getOperand(2); 34182 if (N101 == N2 && 34183 N1.getNode()->getValueType(0) == MVT::i32) { 34184 SDNode *Result = Emit_176(N, X86::INC32m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34185 return Result; 34186 } 34187 } 34188 } 34189 } 34190 } 34191 } 34192 } 34193 } 34194 } 34195 } 34196 34197 // Pattern: (st:isVoid (add:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, -1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34198 // Emits: (DEC8m:isVoid addr:iPTR:$dst) 34199 // Pattern complexity = 52 cost = 1 size = 2 34200 { 34201 SDValue Chain = N.getOperand(0); 34202 if (Predicate_unindexedstore(N.getNode()) && 34203 Predicate_store(N.getNode())) { 34204 SDValue N1 = N.getOperand(1); 34205 if (N1.getOpcode() == ISD::ADD && 34206 N1.hasOneUse()) { 34207 SDValue N10 = N1.getOperand(0); 34208 if (N10.getOpcode() == ISD::LOAD && 34209 N10.hasOneUse() && 34210 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 34211 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 34212 SDValue Chain10 = N10.getOperand(0); 34213 if (Predicate_unindexedload(N10.getNode()) && 34214 Predicate_load(N10.getNode()) && 34215 Predicate_loadi8(N10.getNode())) { 34216 SDValue N101 = N10.getOperand(1); 34217 SDValue CPTmpN101_0; 34218 SDValue CPTmpN101_1; 34219 SDValue CPTmpN101_2; 34220 SDValue CPTmpN101_3; 34221 SDValue CPTmpN101_4; 34222 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34223 SDValue N11 = N1.getOperand(1); 34224 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34225 if (Tmp0) { 34226 int64_t CN1 = Tmp0->getSExtValue(); 34227 if (CN1 == INT64_C(-1)) { 34228 SDValue N2 = N.getOperand(2); 34229 if (N101 == N2 && 34230 N1.getNode()->getValueType(0) == MVT::i8) { 34231 SDNode *Result = Emit_176(N, X86::DEC8m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34232 return Result; 34233 } 34234 } 34235 } 34236 } 34237 } 34238 } 34239 } 34240 } 34241 } 34242 if ((!Subtarget->is64Bit())) { 34243 SDValue Chain = N.getOperand(0); 34244 if (Predicate_unindexedstore(N.getNode()) && 34245 Predicate_store(N.getNode())) { 34246 SDValue N1 = N.getOperand(1); 34247 if (N1.getOpcode() == ISD::ADD && 34248 N1.hasOneUse()) { 34249 SDValue N10 = N1.getOperand(0); 34250 if (N10.getOpcode() == ISD::LOAD && 34251 N10.hasOneUse() && 34252 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 34253 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 34254 SDValue Chain10 = N10.getOperand(0); 34255 if (Predicate_unindexedload(N10.getNode())) { 34256 34257 // Pattern: (st:isVoid (add:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, -1:i16), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34258 // Emits: (DEC16m:isVoid addr:iPTR:$dst) 34259 // Pattern complexity = 52 cost = 1 size = 2 34260 if (Predicate_loadi16(N10.getNode())) { 34261 SDValue N101 = N10.getOperand(1); 34262 SDValue CPTmpN101_0; 34263 SDValue CPTmpN101_1; 34264 SDValue CPTmpN101_2; 34265 SDValue CPTmpN101_3; 34266 SDValue CPTmpN101_4; 34267 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34268 SDValue N11 = N1.getOperand(1); 34269 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34270 if (Tmp0) { 34271 int64_t CN1 = Tmp0->getSExtValue(); 34272 if (CN1 == INT64_C(-1)) { 34273 SDValue N2 = N.getOperand(2); 34274 if (N101 == N2 && 34275 N1.getNode()->getValueType(0) == MVT::i16) { 34276 SDNode *Result = Emit_176(N, X86::DEC16m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34277 return Result; 34278 } 34279 } 34280 } 34281 } 34282 } 34283 34284 // Pattern: (st:isVoid (add:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, -1:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34285 // Emits: (DEC32m:isVoid addr:iPTR:$dst) 34286 // Pattern complexity = 52 cost = 1 size = 2 34287 if (Predicate_loadi32(N10.getNode())) { 34288 SDValue N101 = N10.getOperand(1); 34289 SDValue CPTmpN101_0; 34290 SDValue CPTmpN101_1; 34291 SDValue CPTmpN101_2; 34292 SDValue CPTmpN101_3; 34293 SDValue CPTmpN101_4; 34294 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34295 SDValue N11 = N1.getOperand(1); 34296 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34297 if (Tmp0) { 34298 int64_t CN1 = Tmp0->getSExtValue(); 34299 if (CN1 == INT64_C(-1)) { 34300 SDValue N2 = N.getOperand(2); 34301 if (N101 == N2 && 34302 N1.getNode()->getValueType(0) == MVT::i32) { 34303 SDNode *Result = Emit_176(N, X86::DEC32m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34304 return Result; 34305 } 34306 } 34307 } 34308 } 34309 } 34310 } 34311 } 34312 } 34313 } 34314 } 34315 { 34316 SDValue Chain = N.getOperand(0); 34317 if (Predicate_unindexedstore(N.getNode()) && 34318 Predicate_store(N.getNode())) { 34319 SDValue N1 = N.getOperand(1); 34320 34321 // Pattern: (st:isVoid (sub:i64 0:i64, (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34322 // Emits: (NEG64m:isVoid addr:iPTR:$dst) 34323 // Pattern complexity = 52 cost = 1 size = 2 34324 if (N1.getOpcode() == ISD::SUB && 34325 N1.hasOneUse()) { 34326 SDValue N10 = N1.getOperand(0); 34327 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N10); 34328 if (Tmp0) { 34329 int64_t CN1 = Tmp0->getSExtValue(); 34330 if (CN1 == INT64_C(0)) { 34331 SDValue N11 = N1.getOperand(1); 34332 if (N11.getOpcode() == ISD::LOAD && 34333 N11.hasOneUse() && 34334 IsLegalAndProfitableToFold(N11.getNode(), N1.getNode(), N.getNode()) && 34335 (Chain.getNode() == N11.getNode() || IsChainCompatible(Chain.getNode(), N11.getNode()))) { 34336 SDValue Chain11 = N11.getOperand(0); 34337 if (Predicate_unindexedload(N11.getNode()) && 34338 Predicate_load(N11.getNode()) && 34339 Predicate_loadi64(N11.getNode())) { 34340 SDValue N111 = N11.getOperand(1); 34341 SDValue CPTmpN111_0; 34342 SDValue CPTmpN111_1; 34343 SDValue CPTmpN111_2; 34344 SDValue CPTmpN111_3; 34345 SDValue CPTmpN111_4; 34346 if (SelectAddr(N, N111, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4)) { 34347 SDValue N2 = N.getOperand(2); 34348 if (N111 == N2 && 34349 N1.getNode()->getValueType(0) == MVT::i64) { 34350 SDNode *Result = Emit_174(N, X86::NEG64m, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 34351 return Result; 34352 } 34353 } 34354 } 34355 } 34356 } 34357 } 34358 } 34359 if (N1.getOpcode() == ISD::ADD && 34360 N1.hasOneUse()) { 34361 SDValue N10 = N1.getOperand(0); 34362 if (N10.getOpcode() == ISD::LOAD && 34363 N10.hasOneUse() && 34364 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 34365 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 34366 SDValue Chain10 = N10.getOperand(0); 34367 if (Predicate_unindexedload(N10.getNode()) && 34368 Predicate_load(N10.getNode()) && 34369 Predicate_loadi64(N10.getNode())) { 34370 SDValue N101 = N10.getOperand(1); 34371 SDValue CPTmpN101_0; 34372 SDValue CPTmpN101_1; 34373 SDValue CPTmpN101_2; 34374 SDValue CPTmpN101_3; 34375 SDValue CPTmpN101_4; 34376 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34377 SDValue N11 = N1.getOperand(1); 34378 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34379 if (Tmp0) { 34380 int64_t CN1 = Tmp0->getSExtValue(); 34381 34382 // Pattern: (st:isVoid (add:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 1:i64), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34383 // Emits: (INC64m:isVoid addr:iPTR:$dst) 34384 // Pattern complexity = 52 cost = 1 size = 2 34385 if (CN1 == INT64_C(1)) { 34386 SDValue N2 = N.getOperand(2); 34387 if (N101 == N2 && 34388 N1.getNode()->getValueType(0) == MVT::i64) { 34389 SDNode *Result = Emit_176(N, X86::INC64m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34390 return Result; 34391 } 34392 } 34393 34394 // Pattern: (st:isVoid (add:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, -1:i64), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34395 // Emits: (DEC64m:isVoid addr:iPTR:$dst) 34396 // Pattern complexity = 52 cost = 1 size = 2 34397 if (CN1 == INT64_C(-1)) { 34398 SDValue N2 = N.getOperand(2); 34399 if (N101 == N2 && 34400 N1.getNode()->getValueType(0) == MVT::i64) { 34401 SDNode *Result = Emit_176(N, X86::DEC64m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34402 return Result; 34403 } 34404 } 34405 } 34406 } 34407 } 34408 } 34409 } 34410 } 34411 } 34412 if ((Subtarget->is64Bit())) { 34413 SDValue Chain = N.getOperand(0); 34414 if (Predicate_unindexedstore(N.getNode()) && 34415 Predicate_store(N.getNode())) { 34416 SDValue N1 = N.getOperand(1); 34417 if (N1.getOpcode() == ISD::ADD && 34418 N1.hasOneUse()) { 34419 SDValue N10 = N1.getOperand(0); 34420 if (N10.getOpcode() == ISD::LOAD && 34421 N10.hasOneUse() && 34422 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 34423 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 34424 SDValue Chain10 = N10.getOperand(0); 34425 if (Predicate_unindexedload(N10.getNode())) { 34426 34427 // Pattern: (st:isVoid (add:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 1:i16), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34428 // Emits: (INC64_16m:isVoid addr:iPTR:$dst) 34429 // Pattern complexity = 52 cost = 1 size = 2 34430 if (Predicate_loadi16(N10.getNode())) { 34431 SDValue N101 = N10.getOperand(1); 34432 SDValue CPTmpN101_0; 34433 SDValue CPTmpN101_1; 34434 SDValue CPTmpN101_2; 34435 SDValue CPTmpN101_3; 34436 SDValue CPTmpN101_4; 34437 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34438 SDValue N11 = N1.getOperand(1); 34439 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34440 if (Tmp0) { 34441 int64_t CN1 = Tmp0->getSExtValue(); 34442 if (CN1 == INT64_C(1)) { 34443 SDValue N2 = N.getOperand(2); 34444 if (N101 == N2 && 34445 N1.getNode()->getValueType(0) == MVT::i16) { 34446 SDNode *Result = Emit_176(N, X86::INC64_16m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34447 return Result; 34448 } 34449 } 34450 } 34451 } 34452 } 34453 34454 // Pattern: (st:isVoid (add:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 1:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34455 // Emits: (INC64_32m:isVoid addr:iPTR:$dst) 34456 // Pattern complexity = 52 cost = 1 size = 2 34457 if (Predicate_loadi32(N10.getNode())) { 34458 SDValue N101 = N10.getOperand(1); 34459 SDValue CPTmpN101_0; 34460 SDValue CPTmpN101_1; 34461 SDValue CPTmpN101_2; 34462 SDValue CPTmpN101_3; 34463 SDValue CPTmpN101_4; 34464 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34465 SDValue N11 = N1.getOperand(1); 34466 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34467 if (Tmp0) { 34468 int64_t CN1 = Tmp0->getSExtValue(); 34469 if (CN1 == INT64_C(1)) { 34470 SDValue N2 = N.getOperand(2); 34471 if (N101 == N2 && 34472 N1.getNode()->getValueType(0) == MVT::i32) { 34473 SDNode *Result = Emit_176(N, X86::INC64_32m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34474 return Result; 34475 } 34476 } 34477 } 34478 } 34479 } 34480 34481 // Pattern: (st:isVoid (add:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, -1:i16), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34482 // Emits: (DEC64_16m:isVoid addr:iPTR:$dst) 34483 // Pattern complexity = 52 cost = 1 size = 2 34484 if (Predicate_loadi16(N10.getNode())) { 34485 SDValue N101 = N10.getOperand(1); 34486 SDValue CPTmpN101_0; 34487 SDValue CPTmpN101_1; 34488 SDValue CPTmpN101_2; 34489 SDValue CPTmpN101_3; 34490 SDValue CPTmpN101_4; 34491 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34492 SDValue N11 = N1.getOperand(1); 34493 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34494 if (Tmp0) { 34495 int64_t CN1 = Tmp0->getSExtValue(); 34496 if (CN1 == INT64_C(-1)) { 34497 SDValue N2 = N.getOperand(2); 34498 if (N101 == N2 && 34499 N1.getNode()->getValueType(0) == MVT::i16) { 34500 SDNode *Result = Emit_176(N, X86::DEC64_16m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34501 return Result; 34502 } 34503 } 34504 } 34505 } 34506 } 34507 34508 // Pattern: (st:isVoid (add:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, -1:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34509 // Emits: (DEC64_32m:isVoid addr:iPTR:$dst) 34510 // Pattern complexity = 52 cost = 1 size = 2 34511 if (Predicate_loadi32(N10.getNode())) { 34512 SDValue N101 = N10.getOperand(1); 34513 SDValue CPTmpN101_0; 34514 SDValue CPTmpN101_1; 34515 SDValue CPTmpN101_2; 34516 SDValue CPTmpN101_3; 34517 SDValue CPTmpN101_4; 34518 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34519 SDValue N11 = N1.getOperand(1); 34520 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34521 if (Tmp0) { 34522 int64_t CN1 = Tmp0->getSExtValue(); 34523 if (CN1 == INT64_C(-1)) { 34524 SDValue N2 = N.getOperand(2); 34525 if (N101 == N2 && 34526 N1.getNode()->getValueType(0) == MVT::i32) { 34527 SDNode *Result = Emit_176(N, X86::DEC64_32m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34528 return Result; 34529 } 34530 } 34531 } 34532 } 34533 } 34534 } 34535 } 34536 } 34537 } 34538 } 34539 { 34540 SDValue Chain = N.getOperand(0); 34541 if (Predicate_unindexedstore(N.getNode()) && 34542 Predicate_store(N.getNode())) { 34543 SDValue N1 = N.getOperand(1); 34544 if (N1.getOpcode() == ISD::SHL && 34545 N1.hasOneUse()) { 34546 SDValue N10 = N1.getOperand(0); 34547 if (N10.getOpcode() == ISD::LOAD && 34548 N10.hasOneUse() && 34549 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 34550 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 34551 SDValue Chain10 = N10.getOperand(0); 34552 if (Predicate_unindexedload(N10.getNode())) { 34553 34554 // Pattern: (st:isVoid (shl:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34555 // Emits: (SHL8m1:isVoid addr:iPTR:$dst) 34556 // Pattern complexity = 52 cost = 1 size = 3 34557 if (Predicate_load(N10.getNode()) && 34558 Predicate_loadi8(N10.getNode())) { 34559 SDValue N101 = N10.getOperand(1); 34560 SDValue CPTmpN101_0; 34561 SDValue CPTmpN101_1; 34562 SDValue CPTmpN101_2; 34563 SDValue CPTmpN101_3; 34564 SDValue CPTmpN101_4; 34565 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34566 SDValue N11 = N1.getOperand(1); 34567 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34568 if (Tmp0) { 34569 int64_t CN1 = Tmp0->getSExtValue(); 34570 if (CN1 == INT64_C(1)) { 34571 SDValue N2 = N.getOperand(2); 34572 if (N101 == N2 && 34573 N1.getNode()->getValueType(0) == MVT::i8 && 34574 N11.getNode()->getValueType(0) == MVT::i8) { 34575 SDNode *Result = Emit_175(N, X86::SHL8m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34576 return Result; 34577 } 34578 } 34579 } 34580 } 34581 } 34582 34583 // Pattern: (st:isVoid (shl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34584 // Emits: (SHL16m1:isVoid addr:iPTR:$dst) 34585 // Pattern complexity = 52 cost = 1 size = 3 34586 if (Predicate_loadi16(N10.getNode())) { 34587 SDValue N101 = N10.getOperand(1); 34588 SDValue CPTmpN101_0; 34589 SDValue CPTmpN101_1; 34590 SDValue CPTmpN101_2; 34591 SDValue CPTmpN101_3; 34592 SDValue CPTmpN101_4; 34593 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34594 SDValue N11 = N1.getOperand(1); 34595 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34596 if (Tmp0) { 34597 int64_t CN1 = Tmp0->getSExtValue(); 34598 if (CN1 == INT64_C(1)) { 34599 SDValue N2 = N.getOperand(2); 34600 if (N101 == N2 && 34601 N1.getNode()->getValueType(0) == MVT::i16 && 34602 N11.getNode()->getValueType(0) == MVT::i8) { 34603 SDNode *Result = Emit_175(N, X86::SHL16m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34604 return Result; 34605 } 34606 } 34607 } 34608 } 34609 } 34610 34611 // Pattern: (st:isVoid (shl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34612 // Emits: (SHL32m1:isVoid addr:iPTR:$dst) 34613 // Pattern complexity = 52 cost = 1 size = 3 34614 if (Predicate_loadi32(N10.getNode())) { 34615 SDValue N101 = N10.getOperand(1); 34616 SDValue CPTmpN101_0; 34617 SDValue CPTmpN101_1; 34618 SDValue CPTmpN101_2; 34619 SDValue CPTmpN101_3; 34620 SDValue CPTmpN101_4; 34621 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34622 SDValue N11 = N1.getOperand(1); 34623 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34624 if (Tmp0) { 34625 int64_t CN1 = Tmp0->getSExtValue(); 34626 if (CN1 == INT64_C(1)) { 34627 SDValue N2 = N.getOperand(2); 34628 if (N101 == N2 && 34629 N1.getNode()->getValueType(0) == MVT::i32 && 34630 N11.getNode()->getValueType(0) == MVT::i8) { 34631 SDNode *Result = Emit_175(N, X86::SHL32m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34632 return Result; 34633 } 34634 } 34635 } 34636 } 34637 } 34638 } 34639 } 34640 } 34641 if (N1.getOpcode() == ISD::SRL && 34642 N1.hasOneUse()) { 34643 SDValue N10 = N1.getOperand(0); 34644 if (N10.getOpcode() == ISD::LOAD && 34645 N10.hasOneUse() && 34646 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 34647 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 34648 SDValue Chain10 = N10.getOperand(0); 34649 if (Predicate_unindexedload(N10.getNode())) { 34650 34651 // Pattern: (st:isVoid (srl:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34652 // Emits: (SHR8m1:isVoid addr:iPTR:$dst) 34653 // Pattern complexity = 52 cost = 1 size = 3 34654 if (Predicate_load(N10.getNode()) && 34655 Predicate_loadi8(N10.getNode())) { 34656 SDValue N101 = N10.getOperand(1); 34657 SDValue CPTmpN101_0; 34658 SDValue CPTmpN101_1; 34659 SDValue CPTmpN101_2; 34660 SDValue CPTmpN101_3; 34661 SDValue CPTmpN101_4; 34662 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34663 SDValue N11 = N1.getOperand(1); 34664 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34665 if (Tmp0) { 34666 int64_t CN1 = Tmp0->getSExtValue(); 34667 if (CN1 == INT64_C(1)) { 34668 SDValue N2 = N.getOperand(2); 34669 if (N101 == N2 && 34670 N1.getNode()->getValueType(0) == MVT::i8 && 34671 N11.getNode()->getValueType(0) == MVT::i8) { 34672 SDNode *Result = Emit_175(N, X86::SHR8m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34673 return Result; 34674 } 34675 } 34676 } 34677 } 34678 } 34679 34680 // Pattern: (st:isVoid (srl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34681 // Emits: (SHR16m1:isVoid addr:iPTR:$dst) 34682 // Pattern complexity = 52 cost = 1 size = 3 34683 if (Predicate_loadi16(N10.getNode())) { 34684 SDValue N101 = N10.getOperand(1); 34685 SDValue CPTmpN101_0; 34686 SDValue CPTmpN101_1; 34687 SDValue CPTmpN101_2; 34688 SDValue CPTmpN101_3; 34689 SDValue CPTmpN101_4; 34690 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34691 SDValue N11 = N1.getOperand(1); 34692 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34693 if (Tmp0) { 34694 int64_t CN1 = Tmp0->getSExtValue(); 34695 if (CN1 == INT64_C(1)) { 34696 SDValue N2 = N.getOperand(2); 34697 if (N101 == N2 && 34698 N1.getNode()->getValueType(0) == MVT::i16 && 34699 N11.getNode()->getValueType(0) == MVT::i8) { 34700 SDNode *Result = Emit_175(N, X86::SHR16m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34701 return Result; 34702 } 34703 } 34704 } 34705 } 34706 } 34707 34708 // Pattern: (st:isVoid (srl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34709 // Emits: (SHR32m1:isVoid addr:iPTR:$dst) 34710 // Pattern complexity = 52 cost = 1 size = 3 34711 if (Predicate_loadi32(N10.getNode())) { 34712 SDValue N101 = N10.getOperand(1); 34713 SDValue CPTmpN101_0; 34714 SDValue CPTmpN101_1; 34715 SDValue CPTmpN101_2; 34716 SDValue CPTmpN101_3; 34717 SDValue CPTmpN101_4; 34718 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34719 SDValue N11 = N1.getOperand(1); 34720 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34721 if (Tmp0) { 34722 int64_t CN1 = Tmp0->getSExtValue(); 34723 if (CN1 == INT64_C(1)) { 34724 SDValue N2 = N.getOperand(2); 34725 if (N101 == N2 && 34726 N1.getNode()->getValueType(0) == MVT::i32 && 34727 N11.getNode()->getValueType(0) == MVT::i8) { 34728 SDNode *Result = Emit_175(N, X86::SHR32m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34729 return Result; 34730 } 34731 } 34732 } 34733 } 34734 } 34735 } 34736 } 34737 } 34738 if (N1.getOpcode() == ISD::SRA && 34739 N1.hasOneUse()) { 34740 SDValue N10 = N1.getOperand(0); 34741 if (N10.getOpcode() == ISD::LOAD && 34742 N10.hasOneUse() && 34743 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 34744 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 34745 SDValue Chain10 = N10.getOperand(0); 34746 if (Predicate_unindexedload(N10.getNode())) { 34747 34748 // Pattern: (st:isVoid (sra:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34749 // Emits: (SAR8m1:isVoid addr:iPTR:$dst) 34750 // Pattern complexity = 52 cost = 1 size = 3 34751 if (Predicate_load(N10.getNode()) && 34752 Predicate_loadi8(N10.getNode())) { 34753 SDValue N101 = N10.getOperand(1); 34754 SDValue CPTmpN101_0; 34755 SDValue CPTmpN101_1; 34756 SDValue CPTmpN101_2; 34757 SDValue CPTmpN101_3; 34758 SDValue CPTmpN101_4; 34759 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34760 SDValue N11 = N1.getOperand(1); 34761 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34762 if (Tmp0) { 34763 int64_t CN1 = Tmp0->getSExtValue(); 34764 if (CN1 == INT64_C(1)) { 34765 SDValue N2 = N.getOperand(2); 34766 if (N101 == N2 && 34767 N1.getNode()->getValueType(0) == MVT::i8 && 34768 N11.getNode()->getValueType(0) == MVT::i8) { 34769 SDNode *Result = Emit_175(N, X86::SAR8m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34770 return Result; 34771 } 34772 } 34773 } 34774 } 34775 } 34776 34777 // Pattern: (st:isVoid (sra:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34778 // Emits: (SAR16m1:isVoid addr:iPTR:$dst) 34779 // Pattern complexity = 52 cost = 1 size = 3 34780 if (Predicate_loadi16(N10.getNode())) { 34781 SDValue N101 = N10.getOperand(1); 34782 SDValue CPTmpN101_0; 34783 SDValue CPTmpN101_1; 34784 SDValue CPTmpN101_2; 34785 SDValue CPTmpN101_3; 34786 SDValue CPTmpN101_4; 34787 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34788 SDValue N11 = N1.getOperand(1); 34789 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34790 if (Tmp0) { 34791 int64_t CN1 = Tmp0->getSExtValue(); 34792 if (CN1 == INT64_C(1)) { 34793 SDValue N2 = N.getOperand(2); 34794 if (N101 == N2 && 34795 N1.getNode()->getValueType(0) == MVT::i16 && 34796 N11.getNode()->getValueType(0) == MVT::i8) { 34797 SDNode *Result = Emit_175(N, X86::SAR16m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34798 return Result; 34799 } 34800 } 34801 } 34802 } 34803 } 34804 34805 // Pattern: (st:isVoid (sra:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34806 // Emits: (SAR32m1:isVoid addr:iPTR:$dst) 34807 // Pattern complexity = 52 cost = 1 size = 3 34808 if (Predicate_loadi32(N10.getNode())) { 34809 SDValue N101 = N10.getOperand(1); 34810 SDValue CPTmpN101_0; 34811 SDValue CPTmpN101_1; 34812 SDValue CPTmpN101_2; 34813 SDValue CPTmpN101_3; 34814 SDValue CPTmpN101_4; 34815 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34816 SDValue N11 = N1.getOperand(1); 34817 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34818 if (Tmp0) { 34819 int64_t CN1 = Tmp0->getSExtValue(); 34820 if (CN1 == INT64_C(1)) { 34821 SDValue N2 = N.getOperand(2); 34822 if (N101 == N2 && 34823 N1.getNode()->getValueType(0) == MVT::i32 && 34824 N11.getNode()->getValueType(0) == MVT::i8) { 34825 SDNode *Result = Emit_175(N, X86::SAR32m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34826 return Result; 34827 } 34828 } 34829 } 34830 } 34831 } 34832 } 34833 } 34834 } 34835 if (N1.getOpcode() == ISD::ROTL && 34836 N1.hasOneUse()) { 34837 SDValue N10 = N1.getOperand(0); 34838 if (N10.getOpcode() == ISD::LOAD && 34839 N10.hasOneUse() && 34840 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 34841 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 34842 SDValue Chain10 = N10.getOperand(0); 34843 if (Predicate_unindexedload(N10.getNode())) { 34844 34845 // Pattern: (st:isVoid (rotl:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34846 // Emits: (ROL8m1:isVoid addr:iPTR:$dst) 34847 // Pattern complexity = 52 cost = 1 size = 3 34848 if (Predicate_load(N10.getNode()) && 34849 Predicate_loadi8(N10.getNode())) { 34850 SDValue N101 = N10.getOperand(1); 34851 SDValue CPTmpN101_0; 34852 SDValue CPTmpN101_1; 34853 SDValue CPTmpN101_2; 34854 SDValue CPTmpN101_3; 34855 SDValue CPTmpN101_4; 34856 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34857 SDValue N11 = N1.getOperand(1); 34858 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34859 if (Tmp0) { 34860 int64_t CN1 = Tmp0->getSExtValue(); 34861 if (CN1 == INT64_C(1)) { 34862 SDValue N2 = N.getOperand(2); 34863 if (N101 == N2 && 34864 N1.getNode()->getValueType(0) == MVT::i8 && 34865 N11.getNode()->getValueType(0) == MVT::i8) { 34866 SDNode *Result = Emit_175(N, X86::ROL8m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34867 return Result; 34868 } 34869 } 34870 } 34871 } 34872 } 34873 34874 // Pattern: (st:isVoid (rotl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34875 // Emits: (ROL16m1:isVoid addr:iPTR:$dst) 34876 // Pattern complexity = 52 cost = 1 size = 3 34877 if (Predicate_loadi16(N10.getNode())) { 34878 SDValue N101 = N10.getOperand(1); 34879 SDValue CPTmpN101_0; 34880 SDValue CPTmpN101_1; 34881 SDValue CPTmpN101_2; 34882 SDValue CPTmpN101_3; 34883 SDValue CPTmpN101_4; 34884 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34885 SDValue N11 = N1.getOperand(1); 34886 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34887 if (Tmp0) { 34888 int64_t CN1 = Tmp0->getSExtValue(); 34889 if (CN1 == INT64_C(1)) { 34890 SDValue N2 = N.getOperand(2); 34891 if (N101 == N2 && 34892 N1.getNode()->getValueType(0) == MVT::i16 && 34893 N11.getNode()->getValueType(0) == MVT::i8) { 34894 SDNode *Result = Emit_175(N, X86::ROL16m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34895 return Result; 34896 } 34897 } 34898 } 34899 } 34900 } 34901 34902 // Pattern: (st:isVoid (rotl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34903 // Emits: (ROL32m1:isVoid addr:iPTR:$dst) 34904 // Pattern complexity = 52 cost = 1 size = 3 34905 if (Predicate_loadi32(N10.getNode())) { 34906 SDValue N101 = N10.getOperand(1); 34907 SDValue CPTmpN101_0; 34908 SDValue CPTmpN101_1; 34909 SDValue CPTmpN101_2; 34910 SDValue CPTmpN101_3; 34911 SDValue CPTmpN101_4; 34912 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34913 SDValue N11 = N1.getOperand(1); 34914 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34915 if (Tmp0) { 34916 int64_t CN1 = Tmp0->getSExtValue(); 34917 if (CN1 == INT64_C(1)) { 34918 SDValue N2 = N.getOperand(2); 34919 if (N101 == N2 && 34920 N1.getNode()->getValueType(0) == MVT::i32 && 34921 N11.getNode()->getValueType(0) == MVT::i8) { 34922 SDNode *Result = Emit_175(N, X86::ROL32m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34923 return Result; 34924 } 34925 } 34926 } 34927 } 34928 } 34929 } 34930 } 34931 } 34932 if (N1.getOpcode() == ISD::ROTR && 34933 N1.hasOneUse()) { 34934 SDValue N10 = N1.getOperand(0); 34935 if (N10.getOpcode() == ISD::LOAD && 34936 N10.hasOneUse() && 34937 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 34938 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 34939 SDValue Chain10 = N10.getOperand(0); 34940 if (Predicate_unindexedload(N10.getNode())) { 34941 34942 // Pattern: (st:isVoid (rotr:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34943 // Emits: (ROR8m1:isVoid addr:iPTR:$dst) 34944 // Pattern complexity = 52 cost = 1 size = 3 34945 if (Predicate_load(N10.getNode()) && 34946 Predicate_loadi8(N10.getNode())) { 34947 SDValue N101 = N10.getOperand(1); 34948 SDValue CPTmpN101_0; 34949 SDValue CPTmpN101_1; 34950 SDValue CPTmpN101_2; 34951 SDValue CPTmpN101_3; 34952 SDValue CPTmpN101_4; 34953 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34954 SDValue N11 = N1.getOperand(1); 34955 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34956 if (Tmp0) { 34957 int64_t CN1 = Tmp0->getSExtValue(); 34958 if (CN1 == INT64_C(1)) { 34959 SDValue N2 = N.getOperand(2); 34960 if (N101 == N2 && 34961 N1.getNode()->getValueType(0) == MVT::i8 && 34962 N11.getNode()->getValueType(0) == MVT::i8) { 34963 SDNode *Result = Emit_175(N, X86::ROR8m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34964 return Result; 34965 } 34966 } 34967 } 34968 } 34969 } 34970 34971 // Pattern: (st:isVoid (rotr:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 34972 // Emits: (ROR16m1:isVoid addr:iPTR:$dst) 34973 // Pattern complexity = 52 cost = 1 size = 3 34974 if (Predicate_loadi16(N10.getNode())) { 34975 SDValue N101 = N10.getOperand(1); 34976 SDValue CPTmpN101_0; 34977 SDValue CPTmpN101_1; 34978 SDValue CPTmpN101_2; 34979 SDValue CPTmpN101_3; 34980 SDValue CPTmpN101_4; 34981 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 34982 SDValue N11 = N1.getOperand(1); 34983 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 34984 if (Tmp0) { 34985 int64_t CN1 = Tmp0->getSExtValue(); 34986 if (CN1 == INT64_C(1)) { 34987 SDValue N2 = N.getOperand(2); 34988 if (N101 == N2 && 34989 N1.getNode()->getValueType(0) == MVT::i16 && 34990 N11.getNode()->getValueType(0) == MVT::i8) { 34991 SDNode *Result = Emit_175(N, X86::ROR16m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 34992 return Result; 34993 } 34994 } 34995 } 34996 } 34997 } 34998 34999 // Pattern: (st:isVoid (rotr:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35000 // Emits: (ROR32m1:isVoid addr:iPTR:$dst) 35001 // Pattern complexity = 52 cost = 1 size = 3 35002 if (Predicate_loadi32(N10.getNode())) { 35003 SDValue N101 = N10.getOperand(1); 35004 SDValue CPTmpN101_0; 35005 SDValue CPTmpN101_1; 35006 SDValue CPTmpN101_2; 35007 SDValue CPTmpN101_3; 35008 SDValue CPTmpN101_4; 35009 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35010 SDValue N11 = N1.getOperand(1); 35011 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 35012 if (Tmp0) { 35013 int64_t CN1 = Tmp0->getSExtValue(); 35014 if (CN1 == INT64_C(1)) { 35015 SDValue N2 = N.getOperand(2); 35016 if (N101 == N2 && 35017 N1.getNode()->getValueType(0) == MVT::i32 && 35018 N11.getNode()->getValueType(0) == MVT::i8) { 35019 SDNode *Result = Emit_175(N, X86::ROR32m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35020 return Result; 35021 } 35022 } 35023 } 35024 } 35025 } 35026 } 35027 } 35028 } 35029 35030 // Pattern: (st:isVoid (shl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35031 // Emits: (SHL64m1:isVoid addr:iPTR:$dst) 35032 // Pattern complexity = 52 cost = 1 size = 3 35033 if (N1.getOpcode() == ISD::SHL && 35034 N1.hasOneUse()) { 35035 SDValue N10 = N1.getOperand(0); 35036 if (N10.getOpcode() == ISD::LOAD && 35037 N10.hasOneUse() && 35038 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35039 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35040 SDValue Chain10 = N10.getOperand(0); 35041 if (Predicate_unindexedload(N10.getNode()) && 35042 Predicate_load(N10.getNode()) && 35043 Predicate_loadi64(N10.getNode())) { 35044 SDValue N101 = N10.getOperand(1); 35045 SDValue CPTmpN101_0; 35046 SDValue CPTmpN101_1; 35047 SDValue CPTmpN101_2; 35048 SDValue CPTmpN101_3; 35049 SDValue CPTmpN101_4; 35050 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35051 SDValue N11 = N1.getOperand(1); 35052 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 35053 if (Tmp0) { 35054 int64_t CN1 = Tmp0->getSExtValue(); 35055 if (CN1 == INT64_C(1)) { 35056 SDValue N2 = N.getOperand(2); 35057 if (N101 == N2 && 35058 N1.getNode()->getValueType(0) == MVT::i64 && 35059 N11.getNode()->getValueType(0) == MVT::i8) { 35060 SDNode *Result = Emit_175(N, X86::SHL64m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35061 return Result; 35062 } 35063 } 35064 } 35065 } 35066 } 35067 } 35068 } 35069 35070 // Pattern: (st:isVoid (srl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35071 // Emits: (SHR64m1:isVoid addr:iPTR:$dst) 35072 // Pattern complexity = 52 cost = 1 size = 3 35073 if (N1.getOpcode() == ISD::SRL && 35074 N1.hasOneUse()) { 35075 SDValue N10 = N1.getOperand(0); 35076 if (N10.getOpcode() == ISD::LOAD && 35077 N10.hasOneUse() && 35078 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35079 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35080 SDValue Chain10 = N10.getOperand(0); 35081 if (Predicate_unindexedload(N10.getNode()) && 35082 Predicate_load(N10.getNode()) && 35083 Predicate_loadi64(N10.getNode())) { 35084 SDValue N101 = N10.getOperand(1); 35085 SDValue CPTmpN101_0; 35086 SDValue CPTmpN101_1; 35087 SDValue CPTmpN101_2; 35088 SDValue CPTmpN101_3; 35089 SDValue CPTmpN101_4; 35090 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35091 SDValue N11 = N1.getOperand(1); 35092 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 35093 if (Tmp0) { 35094 int64_t CN1 = Tmp0->getSExtValue(); 35095 if (CN1 == INT64_C(1)) { 35096 SDValue N2 = N.getOperand(2); 35097 if (N101 == N2 && 35098 N1.getNode()->getValueType(0) == MVT::i64 && 35099 N11.getNode()->getValueType(0) == MVT::i8) { 35100 SDNode *Result = Emit_175(N, X86::SHR64m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35101 return Result; 35102 } 35103 } 35104 } 35105 } 35106 } 35107 } 35108 } 35109 35110 // Pattern: (st:isVoid (sra:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35111 // Emits: (SAR64m1:isVoid addr:iPTR:$dst) 35112 // Pattern complexity = 52 cost = 1 size = 3 35113 if (N1.getOpcode() == ISD::SRA && 35114 N1.hasOneUse()) { 35115 SDValue N10 = N1.getOperand(0); 35116 if (N10.getOpcode() == ISD::LOAD && 35117 N10.hasOneUse() && 35118 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35119 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35120 SDValue Chain10 = N10.getOperand(0); 35121 if (Predicate_unindexedload(N10.getNode()) && 35122 Predicate_load(N10.getNode()) && 35123 Predicate_loadi64(N10.getNode())) { 35124 SDValue N101 = N10.getOperand(1); 35125 SDValue CPTmpN101_0; 35126 SDValue CPTmpN101_1; 35127 SDValue CPTmpN101_2; 35128 SDValue CPTmpN101_3; 35129 SDValue CPTmpN101_4; 35130 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35131 SDValue N11 = N1.getOperand(1); 35132 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 35133 if (Tmp0) { 35134 int64_t CN1 = Tmp0->getSExtValue(); 35135 if (CN1 == INT64_C(1)) { 35136 SDValue N2 = N.getOperand(2); 35137 if (N101 == N2 && 35138 N1.getNode()->getValueType(0) == MVT::i64 && 35139 N11.getNode()->getValueType(0) == MVT::i8) { 35140 SDNode *Result = Emit_175(N, X86::SAR64m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35141 return Result; 35142 } 35143 } 35144 } 35145 } 35146 } 35147 } 35148 } 35149 35150 // Pattern: (st:isVoid (rotl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35151 // Emits: (ROL64m1:isVoid addr:iPTR:$dst) 35152 // Pattern complexity = 52 cost = 1 size = 3 35153 if (N1.getOpcode() == ISD::ROTL && 35154 N1.hasOneUse()) { 35155 SDValue N10 = N1.getOperand(0); 35156 if (N10.getOpcode() == ISD::LOAD && 35157 N10.hasOneUse() && 35158 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35159 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35160 SDValue Chain10 = N10.getOperand(0); 35161 if (Predicate_unindexedload(N10.getNode()) && 35162 Predicate_load(N10.getNode()) && 35163 Predicate_loadi64(N10.getNode())) { 35164 SDValue N101 = N10.getOperand(1); 35165 SDValue CPTmpN101_0; 35166 SDValue CPTmpN101_1; 35167 SDValue CPTmpN101_2; 35168 SDValue CPTmpN101_3; 35169 SDValue CPTmpN101_4; 35170 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35171 SDValue N11 = N1.getOperand(1); 35172 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 35173 if (Tmp0) { 35174 int64_t CN1 = Tmp0->getSExtValue(); 35175 if (CN1 == INT64_C(1)) { 35176 SDValue N2 = N.getOperand(2); 35177 if (N101 == N2 && 35178 N1.getNode()->getValueType(0) == MVT::i64 && 35179 N11.getNode()->getValueType(0) == MVT::i8) { 35180 SDNode *Result = Emit_175(N, X86::ROL64m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35181 return Result; 35182 } 35183 } 35184 } 35185 } 35186 } 35187 } 35188 } 35189 35190 // Pattern: (st:isVoid (rotr:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 1:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35191 // Emits: (ROR64m1:isVoid addr:iPTR:$dst) 35192 // Pattern complexity = 52 cost = 1 size = 3 35193 if (N1.getOpcode() == ISD::ROTR && 35194 N1.hasOneUse()) { 35195 SDValue N10 = N1.getOperand(0); 35196 if (N10.getOpcode() == ISD::LOAD && 35197 N10.hasOneUse() && 35198 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35199 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35200 SDValue Chain10 = N10.getOperand(0); 35201 if (Predicate_unindexedload(N10.getNode()) && 35202 Predicate_load(N10.getNode()) && 35203 Predicate_loadi64(N10.getNode())) { 35204 SDValue N101 = N10.getOperand(1); 35205 SDValue CPTmpN101_0; 35206 SDValue CPTmpN101_1; 35207 SDValue CPTmpN101_2; 35208 SDValue CPTmpN101_3; 35209 SDValue CPTmpN101_4; 35210 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35211 SDValue N11 = N1.getOperand(1); 35212 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 35213 if (Tmp0) { 35214 int64_t CN1 = Tmp0->getSExtValue(); 35215 if (CN1 == INT64_C(1)) { 35216 SDValue N2 = N.getOperand(2); 35217 if (N101 == N2 && 35218 N1.getNode()->getValueType(0) == MVT::i64 && 35219 N11.getNode()->getValueType(0) == MVT::i8) { 35220 SDNode *Result = Emit_175(N, X86::ROR64m1, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35221 return Result; 35222 } 35223 } 35224 } 35225 } 35226 } 35227 } 35228 } 35229 if (N1.getOpcode() == ISD::ADD && 35230 N1.hasOneUse()) { 35231 SDValue N10 = N1.getOperand(0); 35232 if (N10.getOpcode() == ISD::LOAD && 35233 N10.hasOneUse() && 35234 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35235 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35236 SDValue Chain10 = N10.getOperand(0); 35237 if (Predicate_unindexedload(N10.getNode())) { 35238 35239 // Pattern: (st:isVoid (add:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 128:i16), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35240 // Emits: (SUB16mi8:isVoid addr:iPTR:$dst, -128:i16) 35241 // Pattern complexity = 52 cost = 1 size = 3 35242 if (Predicate_loadi16(N10.getNode())) { 35243 SDValue N101 = N10.getOperand(1); 35244 SDValue CPTmpN101_0; 35245 SDValue CPTmpN101_1; 35246 SDValue CPTmpN101_2; 35247 SDValue CPTmpN101_3; 35248 SDValue CPTmpN101_4; 35249 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35250 SDValue N11 = N1.getOperand(1); 35251 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 35252 if (Tmp0) { 35253 int64_t CN1 = Tmp0->getSExtValue(); 35254 if (CN1 == INT64_C(128)) { 35255 SDValue N2 = N.getOperand(2); 35256 if (N101 == N2 && 35257 N1.getNode()->getValueType(0) == MVT::i16) { 35258 SDNode *Result = Emit_200(N, X86::SUB16mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35259 return Result; 35260 } 35261 } 35262 } 35263 } 35264 } 35265 35266 // Pattern: (st:isVoid (add:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 128:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35267 // Emits: (SUB32mi8:isVoid addr:iPTR:$dst, -128:i32) 35268 // Pattern complexity = 52 cost = 1 size = 3 35269 if (Predicate_loadi32(N10.getNode())) { 35270 SDValue N101 = N10.getOperand(1); 35271 SDValue CPTmpN101_0; 35272 SDValue CPTmpN101_1; 35273 SDValue CPTmpN101_2; 35274 SDValue CPTmpN101_3; 35275 SDValue CPTmpN101_4; 35276 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35277 SDValue N11 = N1.getOperand(1); 35278 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 35279 if (Tmp0) { 35280 int64_t CN1 = Tmp0->getSExtValue(); 35281 if (CN1 == INT64_C(128)) { 35282 SDValue N2 = N.getOperand(2); 35283 if (N101 == N2 && 35284 N1.getNode()->getValueType(0) == MVT::i32) { 35285 SDNode *Result = Emit_201(N, X86::SUB32mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35286 return Result; 35287 } 35288 } 35289 } 35290 } 35291 } 35292 if (Predicate_load(N10.getNode()) && 35293 Predicate_loadi64(N10.getNode())) { 35294 SDValue N101 = N10.getOperand(1); 35295 SDValue CPTmpN101_0; 35296 SDValue CPTmpN101_1; 35297 SDValue CPTmpN101_2; 35298 SDValue CPTmpN101_3; 35299 SDValue CPTmpN101_4; 35300 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35301 SDValue N11 = N1.getOperand(1); 35302 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 35303 if (Tmp0) { 35304 int64_t CN1 = Tmp0->getSExtValue(); 35305 35306 // Pattern: (st:isVoid (add:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 128:i64), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35307 // Emits: (SUB64mi8:isVoid addr:iPTR:$dst, -128:i64) 35308 // Pattern complexity = 52 cost = 1 size = 3 35309 if (CN1 == INT64_C(128)) { 35310 SDValue N2 = N.getOperand(2); 35311 if (N101 == N2 && 35312 N1.getNode()->getValueType(0) == MVT::i64) { 35313 SDNode *Result = Emit_208(N, X86::SUB64mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35314 return Result; 35315 } 35316 } 35317 35318 // Pattern: (st:isVoid (add:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 34359738368:i64), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35319 // Emits: (SUB64mi32:isVoid addr:iPTR:$dst, -2147483648:i64) 35320 // Pattern complexity = 52 cost = 1 size = 3 35321 if (CN1 == INT64_C(34359738368)) { 35322 SDValue N2 = N.getOperand(2); 35323 if (N101 == N2 && 35324 N1.getNode()->getValueType(0) == MVT::i64) { 35325 SDNode *Result = Emit_209(N, X86::SUB64mi32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35326 return Result; 35327 } 35328 } 35329 } 35330 } 35331 } 35332 } 35333 } 35334 } 35335 if (N1.getOpcode() == ISD::XOR && 35336 N1.hasOneUse()) { 35337 SDValue N10 = N1.getOperand(0); 35338 if (N10.getOpcode() == ISD::LOAD && 35339 N10.hasOneUse() && 35340 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35341 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35342 SDValue Chain10 = N10.getOperand(0); 35343 if (Predicate_unindexedload(N10.getNode())) { 35344 35345 // Pattern: (st:isVoid (xor:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (imm:i8)<<P:Predicate_immAllOnes>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35346 // Emits: (NOT8m:isVoid addr:iPTR:$dst) 35347 // Pattern complexity = 51 cost = 1 size = 2 35348 if (Predicate_load(N10.getNode()) && 35349 Predicate_loadi8(N10.getNode())) { 35350 SDValue N101 = N10.getOperand(1); 35351 SDValue CPTmpN101_0; 35352 SDValue CPTmpN101_1; 35353 SDValue CPTmpN101_2; 35354 SDValue CPTmpN101_3; 35355 SDValue CPTmpN101_4; 35356 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35357 SDValue N11 = N1.getOperand(1); 35358 if (N11.getOpcode() == ISD::Constant && 35359 Predicate_immAllOnes(N11.getNode())) { 35360 SDValue N2 = N.getOperand(2); 35361 if (N101 == N2 && 35362 N1.getNode()->getValueType(0) == MVT::i8) { 35363 SDNode *Result = Emit_175(N, X86::NOT8m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35364 return Result; 35365 } 35366 } 35367 } 35368 } 35369 35370 // Pattern: (st:isVoid (xor:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i16)<<P:Predicate_immAllOnes>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35371 // Emits: (NOT16m:isVoid addr:iPTR:$dst) 35372 // Pattern complexity = 51 cost = 1 size = 2 35373 if (Predicate_loadi16(N10.getNode())) { 35374 SDValue N101 = N10.getOperand(1); 35375 SDValue CPTmpN101_0; 35376 SDValue CPTmpN101_1; 35377 SDValue CPTmpN101_2; 35378 SDValue CPTmpN101_3; 35379 SDValue CPTmpN101_4; 35380 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35381 SDValue N11 = N1.getOperand(1); 35382 if (N11.getOpcode() == ISD::Constant && 35383 Predicate_immAllOnes(N11.getNode())) { 35384 SDValue N2 = N.getOperand(2); 35385 if (N101 == N2 && 35386 N1.getNode()->getValueType(0) == MVT::i16) { 35387 SDNode *Result = Emit_175(N, X86::NOT16m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35388 return Result; 35389 } 35390 } 35391 } 35392 } 35393 35394 // Pattern: (st:isVoid (xor:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i32)<<P:Predicate_immAllOnes>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35395 // Emits: (NOT32m:isVoid addr:iPTR:$dst) 35396 // Pattern complexity = 51 cost = 1 size = 2 35397 if (Predicate_loadi32(N10.getNode())) { 35398 SDValue N101 = N10.getOperand(1); 35399 SDValue CPTmpN101_0; 35400 SDValue CPTmpN101_1; 35401 SDValue CPTmpN101_2; 35402 SDValue CPTmpN101_3; 35403 SDValue CPTmpN101_4; 35404 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35405 SDValue N11 = N1.getOperand(1); 35406 if (N11.getOpcode() == ISD::Constant && 35407 Predicate_immAllOnes(N11.getNode())) { 35408 SDValue N2 = N.getOperand(2); 35409 if (N101 == N2 && 35410 N1.getNode()->getValueType(0) == MVT::i32) { 35411 SDNode *Result = Emit_175(N, X86::NOT32m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35412 return Result; 35413 } 35414 } 35415 } 35416 } 35417 } 35418 } 35419 } 35420 if (N1.getOpcode() == ISD::AND && 35421 N1.hasOneUse()) { 35422 SDValue N10 = N1.getOperand(0); 35423 if (N10.getOpcode() == ISD::LOAD && 35424 N10.hasOneUse() && 35425 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35426 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35427 SDValue Chain10 = N10.getOperand(0); 35428 if (Predicate_unindexedload(N10.getNode()) && 35429 Predicate_load(N10.getNode())) { 35430 SDValue N101 = N10.getOperand(1); 35431 SDValue CPTmpN101_0; 35432 SDValue CPTmpN101_1; 35433 SDValue CPTmpN101_2; 35434 SDValue CPTmpN101_3; 35435 SDValue CPTmpN101_4; 35436 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35437 SDValue N11 = N1.getOperand(1); 35438 if (N11.getOpcode() == ISD::Constant) { 35439 35440 // Pattern: (st:isVoid (and:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i16)<<P:Predicate_i16immSExt8>>:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35441 // Emits: (AND16mi8:isVoid addr:iPTR:$dst, (imm:i16):$src) 35442 // Pattern complexity = 51 cost = 1 size = 3 35443 if (Predicate_i16immSExt8(N11.getNode())) { 35444 SDValue N2 = N.getOperand(2); 35445 if (N101 == N2 && 35446 N1.getNode()->getValueType(0) == MVT::i16) { 35447 SDNode *Result = Emit_179(N, X86::AND16mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35448 return Result; 35449 } 35450 } 35451 35452 // Pattern: (st:isVoid (and:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i32)<<P:Predicate_i32immSExt8>>:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35453 // Emits: (AND32mi8:isVoid addr:iPTR:$dst, (imm:i32):$src) 35454 // Pattern complexity = 51 cost = 1 size = 3 35455 if (Predicate_i32immSExt8(N11.getNode())) { 35456 SDValue N2 = N.getOperand(2); 35457 if (N101 == N2 && 35458 N1.getNode()->getValueType(0) == MVT::i32) { 35459 SDNode *Result = Emit_180(N, X86::AND32mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35460 return Result; 35461 } 35462 } 35463 } 35464 } 35465 } 35466 } 35467 } 35468 if (N1.getOpcode() == ISD::OR && 35469 N1.hasOneUse()) { 35470 SDValue N10 = N1.getOperand(0); 35471 if (N10.getOpcode() == ISD::LOAD && 35472 N10.hasOneUse() && 35473 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35474 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35475 SDValue Chain10 = N10.getOperand(0); 35476 if (Predicate_unindexedload(N10.getNode()) && 35477 Predicate_load(N10.getNode())) { 35478 SDValue N101 = N10.getOperand(1); 35479 SDValue CPTmpN101_0; 35480 SDValue CPTmpN101_1; 35481 SDValue CPTmpN101_2; 35482 SDValue CPTmpN101_3; 35483 SDValue CPTmpN101_4; 35484 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35485 SDValue N11 = N1.getOperand(1); 35486 if (N11.getOpcode() == ISD::Constant) { 35487 35488 // Pattern: (st:isVoid (or:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i16)<<P:Predicate_i16immSExt8>>:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35489 // Emits: (OR16mi8:isVoid addr:iPTR:$dst, (imm:i16):$src) 35490 // Pattern complexity = 51 cost = 1 size = 3 35491 if (Predicate_i16immSExt8(N11.getNode())) { 35492 SDValue N2 = N.getOperand(2); 35493 if (N101 == N2 && 35494 N1.getNode()->getValueType(0) == MVT::i16) { 35495 SDNode *Result = Emit_179(N, X86::OR16mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35496 return Result; 35497 } 35498 } 35499 35500 // Pattern: (st:isVoid (or:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i32)<<P:Predicate_i32immSExt8>>:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35501 // Emits: (OR32mi8:isVoid addr:iPTR:$dst, (imm:i32):$src) 35502 // Pattern complexity = 51 cost = 1 size = 3 35503 if (Predicate_i32immSExt8(N11.getNode())) { 35504 SDValue N2 = N.getOperand(2); 35505 if (N101 == N2 && 35506 N1.getNode()->getValueType(0) == MVT::i32) { 35507 SDNode *Result = Emit_180(N, X86::OR32mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35508 return Result; 35509 } 35510 } 35511 } 35512 } 35513 } 35514 } 35515 } 35516 if (N1.getOpcode() == ISD::XOR && 35517 N1.hasOneUse()) { 35518 SDValue N10 = N1.getOperand(0); 35519 if (N10.getOpcode() == ISD::LOAD && 35520 N10.hasOneUse() && 35521 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35522 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35523 SDValue Chain10 = N10.getOperand(0); 35524 if (Predicate_unindexedload(N10.getNode()) && 35525 Predicate_load(N10.getNode())) { 35526 SDValue N101 = N10.getOperand(1); 35527 SDValue CPTmpN101_0; 35528 SDValue CPTmpN101_1; 35529 SDValue CPTmpN101_2; 35530 SDValue CPTmpN101_3; 35531 SDValue CPTmpN101_4; 35532 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35533 SDValue N11 = N1.getOperand(1); 35534 if (N11.getOpcode() == ISD::Constant) { 35535 35536 // Pattern: (st:isVoid (xor:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i16)<<P:Predicate_i16immSExt8>>:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35537 // Emits: (XOR16mi8:isVoid addr:iPTR:$dst, (imm:i16):$src) 35538 // Pattern complexity = 51 cost = 1 size = 3 35539 if (Predicate_i16immSExt8(N11.getNode())) { 35540 SDValue N2 = N.getOperand(2); 35541 if (N101 == N2 && 35542 N1.getNode()->getValueType(0) == MVT::i16) { 35543 SDNode *Result = Emit_179(N, X86::XOR16mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35544 return Result; 35545 } 35546 } 35547 35548 // Pattern: (st:isVoid (xor:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i32)<<P:Predicate_i32immSExt8>>:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35549 // Emits: (XOR32mi8:isVoid addr:iPTR:$dst, (imm:i32):$src) 35550 // Pattern complexity = 51 cost = 1 size = 3 35551 if (Predicate_i32immSExt8(N11.getNode())) { 35552 SDValue N2 = N.getOperand(2); 35553 if (N101 == N2 && 35554 N1.getNode()->getValueType(0) == MVT::i32) { 35555 SDNode *Result = Emit_180(N, X86::XOR32mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35556 return Result; 35557 } 35558 } 35559 } 35560 } 35561 } 35562 } 35563 } 35564 if (N1.getOpcode() == ISD::ADD && 35565 N1.hasOneUse()) { 35566 SDValue N10 = N1.getOperand(0); 35567 if (N10.getOpcode() == ISD::LOAD && 35568 N10.hasOneUse() && 35569 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35570 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35571 SDValue Chain10 = N10.getOperand(0); 35572 if (Predicate_unindexedload(N10.getNode()) && 35573 Predicate_load(N10.getNode())) { 35574 SDValue N101 = N10.getOperand(1); 35575 SDValue CPTmpN101_0; 35576 SDValue CPTmpN101_1; 35577 SDValue CPTmpN101_2; 35578 SDValue CPTmpN101_3; 35579 SDValue CPTmpN101_4; 35580 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35581 SDValue N11 = N1.getOperand(1); 35582 if (N11.getOpcode() == ISD::Constant) { 35583 35584 // Pattern: (st:isVoid (add:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35585 // Emits: (ADD16mi8:isVoid addr:iPTR:$dst, (imm:i16):$src2) 35586 // Pattern complexity = 51 cost = 1 size = 3 35587 if (Predicate_i16immSExt8(N11.getNode())) { 35588 SDValue N2 = N.getOperand(2); 35589 if (N101 == N2 && 35590 N1.getNode()->getValueType(0) == MVT::i16) { 35591 SDNode *Result = Emit_179(N, X86::ADD16mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35592 return Result; 35593 } 35594 } 35595 35596 // Pattern: (st:isVoid (add:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35597 // Emits: (ADD32mi8:isVoid addr:iPTR:$dst, (imm:i32):$src2) 35598 // Pattern complexity = 51 cost = 1 size = 3 35599 if (Predicate_i32immSExt8(N11.getNode())) { 35600 SDValue N2 = N.getOperand(2); 35601 if (N101 == N2 && 35602 N1.getNode()->getValueType(0) == MVT::i32) { 35603 SDNode *Result = Emit_180(N, X86::ADD32mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35604 return Result; 35605 } 35606 } 35607 } 35608 } 35609 } 35610 } 35611 } 35612 if (N1.getOpcode() == ISD::ADDE && 35613 N1.hasOneUse()) { 35614 SDValue N10 = N1.getOperand(0); 35615 if (N10.getOpcode() == ISD::LOAD && 35616 N10.hasOneUse() && 35617 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35618 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35619 SDValue Chain10 = N10.getOperand(0); 35620 if (Predicate_unindexedload(N10.getNode()) && 35621 Predicate_load(N10.getNode())) { 35622 SDValue N101 = N10.getOperand(1); 35623 SDValue CPTmpN101_0; 35624 SDValue CPTmpN101_1; 35625 SDValue CPTmpN101_2; 35626 SDValue CPTmpN101_3; 35627 SDValue CPTmpN101_4; 35628 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35629 SDValue N11 = N1.getOperand(1); 35630 if (N11.getOpcode() == ISD::Constant) { 35631 35632 // Pattern: (st:isVoid (adde:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35633 // Emits: (ADC16mi8:isVoid addr:iPTR:$dst, (imm:i16):$src2) 35634 // Pattern complexity = 51 cost = 1 size = 3 35635 if (Predicate_i16immSExt8(N11.getNode())) { 35636 SDValue N2 = N.getOperand(2); 35637 if (N101 == N2 && 35638 N1.getNode()->getValueType(0) == MVT::i16) { 35639 SDNode *Result = Emit_187(N, X86::ADC16mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35640 return Result; 35641 } 35642 } 35643 35644 // Pattern: (st:isVoid (adde:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35645 // Emits: (ADC32mi8:isVoid addr:iPTR:$dst, (imm:i32):$src2) 35646 // Pattern complexity = 51 cost = 1 size = 3 35647 if (Predicate_i32immSExt8(N11.getNode())) { 35648 SDValue N2 = N.getOperand(2); 35649 if (N101 == N2 && 35650 N1.getNode()->getValueType(0) == MVT::i32) { 35651 SDNode *Result = Emit_188(N, X86::ADC32mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35652 return Result; 35653 } 35654 } 35655 } 35656 } 35657 } 35658 } 35659 } 35660 if (N1.getOpcode() == ISD::SUB && 35661 N1.hasOneUse()) { 35662 SDValue N10 = N1.getOperand(0); 35663 if (N10.getOpcode() == ISD::LOAD && 35664 N10.hasOneUse() && 35665 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35666 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35667 SDValue Chain10 = N10.getOperand(0); 35668 if (Predicate_unindexedload(N10.getNode()) && 35669 Predicate_load(N10.getNode())) { 35670 SDValue N101 = N10.getOperand(1); 35671 SDValue CPTmpN101_0; 35672 SDValue CPTmpN101_1; 35673 SDValue CPTmpN101_2; 35674 SDValue CPTmpN101_3; 35675 SDValue CPTmpN101_4; 35676 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35677 SDValue N11 = N1.getOperand(1); 35678 if (N11.getOpcode() == ISD::Constant) { 35679 35680 // Pattern: (st:isVoid (sub:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35681 // Emits: (SUB16mi8:isVoid addr:iPTR:$dst, (imm:i16):$src2) 35682 // Pattern complexity = 51 cost = 1 size = 3 35683 if (Predicate_i16immSExt8(N11.getNode())) { 35684 SDValue N2 = N.getOperand(2); 35685 if (N101 == N2 && 35686 N1.getNode()->getValueType(0) == MVT::i16) { 35687 SDNode *Result = Emit_179(N, X86::SUB16mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35688 return Result; 35689 } 35690 } 35691 35692 // Pattern: (st:isVoid (sub:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35693 // Emits: (SUB32mi8:isVoid addr:iPTR:$dst, (imm:i32):$src2) 35694 // Pattern complexity = 51 cost = 1 size = 3 35695 if (Predicate_i32immSExt8(N11.getNode())) { 35696 SDValue N2 = N.getOperand(2); 35697 if (N101 == N2 && 35698 N1.getNode()->getValueType(0) == MVT::i32) { 35699 SDNode *Result = Emit_180(N, X86::SUB32mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35700 return Result; 35701 } 35702 } 35703 } 35704 } 35705 } 35706 } 35707 } 35708 if (N1.getOpcode() == ISD::SUBE && 35709 N1.hasOneUse()) { 35710 SDValue N10 = N1.getOperand(0); 35711 if (N10.getOpcode() == ISD::LOAD && 35712 N10.hasOneUse() && 35713 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35714 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35715 SDValue Chain10 = N10.getOperand(0); 35716 if (Predicate_unindexedload(N10.getNode()) && 35717 Predicate_load(N10.getNode())) { 35718 SDValue N101 = N10.getOperand(1); 35719 SDValue CPTmpN101_0; 35720 SDValue CPTmpN101_1; 35721 SDValue CPTmpN101_2; 35722 SDValue CPTmpN101_3; 35723 SDValue CPTmpN101_4; 35724 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35725 SDValue N11 = N1.getOperand(1); 35726 if (N11.getOpcode() == ISD::Constant) { 35727 35728 // Pattern: (st:isVoid (sube:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35729 // Emits: (SBB16mi8:isVoid addr:iPTR:$dst, (imm:i16):$src2) 35730 // Pattern complexity = 51 cost = 1 size = 3 35731 if (Predicate_i16immSExt8(N11.getNode())) { 35732 SDValue N2 = N.getOperand(2); 35733 if (N101 == N2 && 35734 N1.getNode()->getValueType(0) == MVT::i16) { 35735 SDNode *Result = Emit_187(N, X86::SBB16mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35736 return Result; 35737 } 35738 } 35739 35740 // Pattern: (st:isVoid (sube:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35741 // Emits: (SBB32mi8:isVoid addr:iPTR:$dst, (imm:i32):$src2) 35742 // Pattern complexity = 51 cost = 1 size = 3 35743 if (Predicate_i32immSExt8(N11.getNode())) { 35744 SDValue N2 = N.getOperand(2); 35745 if (N101 == N2 && 35746 N1.getNode()->getValueType(0) == MVT::i32) { 35747 SDNode *Result = Emit_188(N, X86::SBB32mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35748 return Result; 35749 } 35750 } 35751 } 35752 } 35753 } 35754 } 35755 } 35756 if (N1.getOpcode() == ISD::ADD && 35757 N1.hasOneUse()) { 35758 SDValue N10 = N1.getOperand(0); 35759 if (N10.getOpcode() == ISD::LOAD && 35760 N10.hasOneUse() && 35761 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35762 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35763 SDValue Chain10 = N10.getOperand(0); 35764 if (Predicate_unindexedload(N10.getNode()) && 35765 Predicate_load(N10.getNode())) { 35766 SDValue N101 = N10.getOperand(1); 35767 SDValue CPTmpN101_0; 35768 SDValue CPTmpN101_1; 35769 SDValue CPTmpN101_2; 35770 SDValue CPTmpN101_3; 35771 SDValue CPTmpN101_4; 35772 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35773 SDValue N11 = N1.getOperand(1); 35774 if (N11.getOpcode() == ISD::Constant) { 35775 35776 // Pattern: (st:isVoid (add:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35777 // Emits: (ADD64mi8:isVoid addr:iPTR:$dst, (imm:i64):$src2) 35778 // Pattern complexity = 51 cost = 1 size = 3 35779 if (Predicate_i64immSExt8(N11.getNode())) { 35780 SDValue N2 = N.getOperand(2); 35781 if (N101 == N2 && 35782 N1.getNode()->getValueType(0) == MVT::i64) { 35783 SDNode *Result = Emit_191(N, X86::ADD64mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35784 return Result; 35785 } 35786 } 35787 35788 // Pattern: (st:isVoid (add:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35789 // Emits: (ADD64mi32:isVoid addr:iPTR:$dst, (imm:i64):$src2) 35790 // Pattern complexity = 51 cost = 1 size = 3 35791 if (Predicate_i64immSExt32(N11.getNode())) { 35792 SDValue N2 = N.getOperand(2); 35793 if (N101 == N2 && 35794 N1.getNode()->getValueType(0) == MVT::i64) { 35795 SDNode *Result = Emit_191(N, X86::ADD64mi32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35796 return Result; 35797 } 35798 } 35799 } 35800 } 35801 } 35802 } 35803 } 35804 if (N1.getOpcode() == ISD::ADDE && 35805 N1.hasOneUse()) { 35806 SDValue N10 = N1.getOperand(0); 35807 if (N10.getOpcode() == ISD::LOAD && 35808 N10.hasOneUse() && 35809 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35810 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35811 SDValue Chain10 = N10.getOperand(0); 35812 if (Predicate_unindexedload(N10.getNode()) && 35813 Predicate_load(N10.getNode())) { 35814 SDValue N101 = N10.getOperand(1); 35815 SDValue CPTmpN101_0; 35816 SDValue CPTmpN101_1; 35817 SDValue CPTmpN101_2; 35818 SDValue CPTmpN101_3; 35819 SDValue CPTmpN101_4; 35820 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35821 SDValue N11 = N1.getOperand(1); 35822 if (N11.getOpcode() == ISD::Constant && 35823 Predicate_i64immSExt8(N11.getNode())) { 35824 SDValue N2 = N.getOperand(2); 35825 if (N101 == N2 && 35826 N1.getNode()->getValueType(0) == MVT::i64) { 35827 35828 // Pattern: (st:isVoid (adde:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35829 // Emits: (ADC64mi8:isVoid addr:iPTR:$dst, (imm:i64):$src2) 35830 // Pattern complexity = 51 cost = 1 size = 3 35831 { 35832 SDNode *Result = Emit_192(N, X86::ADC64mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35833 return Result; 35834 } 35835 35836 // Pattern: (st:isVoid (adde:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35837 // Emits: (ADC64mi32:isVoid addr:iPTR:$dst, (imm:i64):$src2) 35838 // Pattern complexity = 51 cost = 1 size = 3 35839 SDNode *Result = Emit_192(N, X86::ADC64mi32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35840 return Result; 35841 } 35842 } 35843 } 35844 } 35845 } 35846 } 35847 if (N1.getOpcode() == ISD::SUB && 35848 N1.hasOneUse()) { 35849 SDValue N10 = N1.getOperand(0); 35850 if (N10.getOpcode() == ISD::LOAD && 35851 N10.hasOneUse() && 35852 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35853 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35854 SDValue Chain10 = N10.getOperand(0); 35855 if (Predicate_unindexedload(N10.getNode()) && 35856 Predicate_load(N10.getNode())) { 35857 SDValue N101 = N10.getOperand(1); 35858 SDValue CPTmpN101_0; 35859 SDValue CPTmpN101_1; 35860 SDValue CPTmpN101_2; 35861 SDValue CPTmpN101_3; 35862 SDValue CPTmpN101_4; 35863 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35864 SDValue N11 = N1.getOperand(1); 35865 if (N11.getOpcode() == ISD::Constant) { 35866 35867 // Pattern: (st:isVoid (sub:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35868 // Emits: (SUB64mi8:isVoid addr:iPTR:$dst, (imm:i64):$src2) 35869 // Pattern complexity = 51 cost = 1 size = 3 35870 if (Predicate_i64immSExt8(N11.getNode())) { 35871 SDValue N2 = N.getOperand(2); 35872 if (N101 == N2 && 35873 N1.getNode()->getValueType(0) == MVT::i64) { 35874 SDNode *Result = Emit_191(N, X86::SUB64mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35875 return Result; 35876 } 35877 } 35878 35879 // Pattern: (st:isVoid (sub:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35880 // Emits: (SUB64mi32:isVoid addr:iPTR:$dst, (imm:i64):$src2) 35881 // Pattern complexity = 51 cost = 1 size = 3 35882 if (Predicate_i64immSExt32(N11.getNode())) { 35883 SDValue N2 = N.getOperand(2); 35884 if (N101 == N2 && 35885 N1.getNode()->getValueType(0) == MVT::i64) { 35886 SDNode *Result = Emit_191(N, X86::SUB64mi32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35887 return Result; 35888 } 35889 } 35890 } 35891 } 35892 } 35893 } 35894 } 35895 if (N1.getOpcode() == ISD::SUBE && 35896 N1.hasOneUse()) { 35897 SDValue N10 = N1.getOperand(0); 35898 if (N10.getOpcode() == ISD::LOAD && 35899 N10.hasOneUse() && 35900 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35901 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35902 SDValue Chain10 = N10.getOperand(0); 35903 if (Predicate_unindexedload(N10.getNode()) && 35904 Predicate_load(N10.getNode())) { 35905 SDValue N101 = N10.getOperand(1); 35906 SDValue CPTmpN101_0; 35907 SDValue CPTmpN101_1; 35908 SDValue CPTmpN101_2; 35909 SDValue CPTmpN101_3; 35910 SDValue CPTmpN101_4; 35911 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35912 SDValue N11 = N1.getOperand(1); 35913 if (N11.getOpcode() == ISD::Constant) { 35914 35915 // Pattern: (st:isVoid (sube:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35916 // Emits: (SBB64mi8:isVoid addr:iPTR:$dst, (imm:i64):$src2) 35917 // Pattern complexity = 51 cost = 1 size = 3 35918 if (Predicate_i64immSExt8(N11.getNode())) { 35919 SDValue N2 = N.getOperand(2); 35920 if (N101 == N2 && 35921 N1.getNode()->getValueType(0) == MVT::i64) { 35922 SDNode *Result = Emit_192(N, X86::SBB64mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35923 return Result; 35924 } 35925 } 35926 35927 // Pattern: (st:isVoid (sube:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35928 // Emits: (SBB64mi32:isVoid addr:iPTR:$dst, (imm:i64):$src2) 35929 // Pattern complexity = 51 cost = 1 size = 3 35930 if (Predicate_i64immSExt32(N11.getNode())) { 35931 SDValue N2 = N.getOperand(2); 35932 if (N101 == N2 && 35933 N1.getNode()->getValueType(0) == MVT::i64) { 35934 SDNode *Result = Emit_192(N, X86::SBB64mi32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35935 return Result; 35936 } 35937 } 35938 } 35939 } 35940 } 35941 } 35942 } 35943 35944 // Pattern: (st:isVoid (xor:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i64)<<P:Predicate_immAllOnes>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35945 // Emits: (NOT64m:isVoid addr:iPTR:$dst) 35946 // Pattern complexity = 51 cost = 1 size = 3 35947 if (N1.getOpcode() == ISD::XOR && 35948 N1.hasOneUse()) { 35949 SDValue N10 = N1.getOperand(0); 35950 if (N10.getOpcode() == ISD::LOAD && 35951 N10.hasOneUse() && 35952 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35953 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35954 SDValue Chain10 = N10.getOperand(0); 35955 if (Predicate_unindexedload(N10.getNode()) && 35956 Predicate_load(N10.getNode()) && 35957 Predicate_loadi64(N10.getNode())) { 35958 SDValue N101 = N10.getOperand(1); 35959 SDValue CPTmpN101_0; 35960 SDValue CPTmpN101_1; 35961 SDValue CPTmpN101_2; 35962 SDValue CPTmpN101_3; 35963 SDValue CPTmpN101_4; 35964 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 35965 SDValue N11 = N1.getOperand(1); 35966 if (N11.getOpcode() == ISD::Constant && 35967 Predicate_immAllOnes(N11.getNode())) { 35968 SDValue N2 = N.getOperand(2); 35969 if (N101 == N2 && 35970 N1.getNode()->getValueType(0) == MVT::i64) { 35971 SDNode *Result = Emit_175(N, X86::NOT64m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 35972 return Result; 35973 } 35974 } 35975 } 35976 } 35977 } 35978 } 35979 if (N1.getOpcode() == ISD::AND && 35980 N1.hasOneUse()) { 35981 SDValue N10 = N1.getOperand(0); 35982 if (N10.getOpcode() == ISD::LOAD && 35983 N10.hasOneUse() && 35984 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 35985 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 35986 SDValue Chain10 = N10.getOperand(0); 35987 if (Predicate_unindexedload(N10.getNode()) && 35988 Predicate_load(N10.getNode())) { 35989 35990 // Pattern: (st:isVoid (and:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i64)<<P:Predicate_i64immSExt8>>:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 35991 // Emits: (AND64mi8:isVoid addr:iPTR:$dst, (imm:i64):$src) 35992 // Pattern complexity = 51 cost = 1 size = 3 35993 { 35994 SDValue N101 = N10.getOperand(1); 35995 SDValue CPTmpN101_0; 35996 SDValue CPTmpN101_1; 35997 SDValue CPTmpN101_2; 35998 SDValue CPTmpN101_3; 35999 SDValue CPTmpN101_4; 36000 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36001 SDValue N11 = N1.getOperand(1); 36002 if (N11.getOpcode() == ISD::Constant && 36003 Predicate_i64immSExt8(N11.getNode())) { 36004 SDValue N2 = N.getOperand(2); 36005 if (N101 == N2 && 36006 N1.getNode()->getValueType(0) == MVT::i64) { 36007 SDNode *Result = Emit_191(N, X86::AND64mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36008 return Result; 36009 } 36010 } 36011 } 36012 } 36013 36014 // Pattern: (st:isVoid (and:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i64)<<P:Predicate_i64immSExt32>>:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36015 // Emits: (AND64mi32:isVoid addr:iPTR:$dst, (imm:i64):$src) 36016 // Pattern complexity = 51 cost = 1 size = 3 36017 if (Predicate_loadi64(N10.getNode())) { 36018 SDValue N101 = N10.getOperand(1); 36019 SDValue CPTmpN101_0; 36020 SDValue CPTmpN101_1; 36021 SDValue CPTmpN101_2; 36022 SDValue CPTmpN101_3; 36023 SDValue CPTmpN101_4; 36024 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36025 SDValue N11 = N1.getOperand(1); 36026 if (N11.getOpcode() == ISD::Constant && 36027 Predicate_i64immSExt32(N11.getNode())) { 36028 SDValue N2 = N.getOperand(2); 36029 if (N101 == N2 && 36030 N1.getNode()->getValueType(0) == MVT::i64) { 36031 SDNode *Result = Emit_191(N, X86::AND64mi32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36032 return Result; 36033 } 36034 } 36035 } 36036 } 36037 } 36038 } 36039 } 36040 if (N1.getOpcode() == ISD::OR && 36041 N1.hasOneUse()) { 36042 SDValue N10 = N1.getOperand(0); 36043 if (N10.getOpcode() == ISD::LOAD && 36044 N10.hasOneUse() && 36045 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 36046 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 36047 SDValue Chain10 = N10.getOperand(0); 36048 if (Predicate_unindexedload(N10.getNode()) && 36049 Predicate_load(N10.getNode())) { 36050 36051 // Pattern: (st:isVoid (or:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i64)<<P:Predicate_i64immSExt8>>:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36052 // Emits: (OR64mi8:isVoid addr:iPTR:$dst, (imm:i64):$src) 36053 // Pattern complexity = 51 cost = 1 size = 3 36054 { 36055 SDValue N101 = N10.getOperand(1); 36056 SDValue CPTmpN101_0; 36057 SDValue CPTmpN101_1; 36058 SDValue CPTmpN101_2; 36059 SDValue CPTmpN101_3; 36060 SDValue CPTmpN101_4; 36061 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36062 SDValue N11 = N1.getOperand(1); 36063 if (N11.getOpcode() == ISD::Constant && 36064 Predicate_i64immSExt8(N11.getNode())) { 36065 SDValue N2 = N.getOperand(2); 36066 if (N101 == N2 && 36067 N1.getNode()->getValueType(0) == MVT::i64) { 36068 SDNode *Result = Emit_191(N, X86::OR64mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36069 return Result; 36070 } 36071 } 36072 } 36073 } 36074 36075 // Pattern: (st:isVoid (or:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i64)<<P:Predicate_i64immSExt32>>:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36076 // Emits: (OR64mi32:isVoid addr:iPTR:$dst, (imm:i64):$src) 36077 // Pattern complexity = 51 cost = 1 size = 3 36078 if (Predicate_loadi64(N10.getNode())) { 36079 SDValue N101 = N10.getOperand(1); 36080 SDValue CPTmpN101_0; 36081 SDValue CPTmpN101_1; 36082 SDValue CPTmpN101_2; 36083 SDValue CPTmpN101_3; 36084 SDValue CPTmpN101_4; 36085 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36086 SDValue N11 = N1.getOperand(1); 36087 if (N11.getOpcode() == ISD::Constant && 36088 Predicate_i64immSExt32(N11.getNode())) { 36089 SDValue N2 = N.getOperand(2); 36090 if (N101 == N2 && 36091 N1.getNode()->getValueType(0) == MVT::i64) { 36092 SDNode *Result = Emit_191(N, X86::OR64mi32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36093 return Result; 36094 } 36095 } 36096 } 36097 } 36098 } 36099 } 36100 } 36101 if (N1.getOpcode() == ISD::XOR && 36102 N1.hasOneUse()) { 36103 SDValue N10 = N1.getOperand(0); 36104 if (N10.getOpcode() == ISD::LOAD && 36105 N10.hasOneUse() && 36106 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 36107 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 36108 SDValue Chain10 = N10.getOperand(0); 36109 if (Predicate_unindexedload(N10.getNode()) && 36110 Predicate_load(N10.getNode())) { 36111 36112 // Pattern: (st:isVoid (xor:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, (imm:i64)<<P:Predicate_i64immSExt8>>:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36113 // Emits: (XOR64mi8:isVoid addr:iPTR:$dst, (imm:i64):$src) 36114 // Pattern complexity = 51 cost = 1 size = 3 36115 { 36116 SDValue N101 = N10.getOperand(1); 36117 SDValue CPTmpN101_0; 36118 SDValue CPTmpN101_1; 36119 SDValue CPTmpN101_2; 36120 SDValue CPTmpN101_3; 36121 SDValue CPTmpN101_4; 36122 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36123 SDValue N11 = N1.getOperand(1); 36124 if (N11.getOpcode() == ISD::Constant && 36125 Predicate_i64immSExt8(N11.getNode())) { 36126 SDValue N2 = N.getOperand(2); 36127 if (N101 == N2 && 36128 N1.getNode()->getValueType(0) == MVT::i64) { 36129 SDNode *Result = Emit_191(N, X86::XOR64mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36130 return Result; 36131 } 36132 } 36133 } 36134 } 36135 36136 // Pattern: (st:isVoid (xor:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i64)<<P:Predicate_i64immSExt32>>:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36137 // Emits: (XOR64mi32:isVoid addr:iPTR:$dst, (imm:i64):$src) 36138 // Pattern complexity = 51 cost = 1 size = 3 36139 if (Predicate_loadi64(N10.getNode())) { 36140 SDValue N101 = N10.getOperand(1); 36141 SDValue CPTmpN101_0; 36142 SDValue CPTmpN101_1; 36143 SDValue CPTmpN101_2; 36144 SDValue CPTmpN101_3; 36145 SDValue CPTmpN101_4; 36146 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36147 SDValue N11 = N1.getOperand(1); 36148 if (N11.getOpcode() == ISD::Constant && 36149 Predicate_i64immSExt32(N11.getNode())) { 36150 SDValue N2 = N.getOperand(2); 36151 if (N101 == N2 && 36152 N1.getNode()->getValueType(0) == MVT::i64) { 36153 SDNode *Result = Emit_191(N, X86::XOR64mi32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36154 return Result; 36155 } 36156 } 36157 } 36158 } 36159 } 36160 } 36161 } 36162 if (N1.getOpcode() == X86ISD::ADD && 36163 N1.hasOneUse()) { 36164 SDValue N10 = N1.getOperand(0); 36165 if (N10.getOpcode() == ISD::LOAD && 36166 N10.hasOneUse() && 36167 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 36168 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 36169 SDValue Chain10 = N10.getOperand(0); 36170 if (Predicate_unindexedload(N10.getNode())) { 36171 36172 // Pattern: (st:isVoid (X86add_flag:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36173 // Emits: (ADD16mi8:isVoid addr:iPTR:$dst, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 36174 // Pattern complexity = 51 cost = 1 size = 3 36175 if (Predicate_loadi16(N10.getNode())) { 36176 SDValue N101 = N10.getOperand(1); 36177 SDValue CPTmpN101_0; 36178 SDValue CPTmpN101_1; 36179 SDValue CPTmpN101_2; 36180 SDValue CPTmpN101_3; 36181 SDValue CPTmpN101_4; 36182 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36183 SDValue N11 = N1.getOperand(1); 36184 if (N11.getOpcode() == ISD::Constant && 36185 Predicate_i16immSExt8(N11.getNode())) { 36186 SDValue N2 = N.getOperand(2); 36187 if (N101 == N2 && 36188 N1.getNode()->getValueType(0) == MVT::i16) { 36189 SDNode *Result = Emit_179(N, X86::ADD16mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36190 return Result; 36191 } 36192 } 36193 } 36194 } 36195 36196 // Pattern: (st:isVoid (X86add_flag:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36197 // Emits: (ADD32mi8:isVoid addr:iPTR:$dst, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 36198 // Pattern complexity = 51 cost = 1 size = 3 36199 if (Predicate_loadi32(N10.getNode())) { 36200 SDValue N101 = N10.getOperand(1); 36201 SDValue CPTmpN101_0; 36202 SDValue CPTmpN101_1; 36203 SDValue CPTmpN101_2; 36204 SDValue CPTmpN101_3; 36205 SDValue CPTmpN101_4; 36206 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36207 SDValue N11 = N1.getOperand(1); 36208 if (N11.getOpcode() == ISD::Constant && 36209 Predicate_i32immSExt8(N11.getNode())) { 36210 SDValue N2 = N.getOperand(2); 36211 if (N101 == N2 && 36212 N1.getNode()->getValueType(0) == MVT::i32) { 36213 SDNode *Result = Emit_180(N, X86::ADD32mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36214 return Result; 36215 } 36216 } 36217 } 36218 } 36219 } 36220 } 36221 } 36222 if (N1.getOpcode() == X86ISD::SUB && 36223 N1.hasOneUse()) { 36224 SDValue N10 = N1.getOperand(0); 36225 if (N10.getOpcode() == ISD::LOAD && 36226 N10.hasOneUse() && 36227 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 36228 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 36229 SDValue Chain10 = N10.getOperand(0); 36230 if (Predicate_unindexedload(N10.getNode())) { 36231 36232 // Pattern: (st:isVoid (X86sub_flag:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36233 // Emits: (SUB16mi8:isVoid addr:iPTR:$dst, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 36234 // Pattern complexity = 51 cost = 1 size = 3 36235 if (Predicate_loadi16(N10.getNode())) { 36236 SDValue N101 = N10.getOperand(1); 36237 SDValue CPTmpN101_0; 36238 SDValue CPTmpN101_1; 36239 SDValue CPTmpN101_2; 36240 SDValue CPTmpN101_3; 36241 SDValue CPTmpN101_4; 36242 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36243 SDValue N11 = N1.getOperand(1); 36244 if (N11.getOpcode() == ISD::Constant && 36245 Predicate_i16immSExt8(N11.getNode())) { 36246 SDValue N2 = N.getOperand(2); 36247 if (N101 == N2 && 36248 N1.getNode()->getValueType(0) == MVT::i16) { 36249 SDNode *Result = Emit_179(N, X86::SUB16mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36250 return Result; 36251 } 36252 } 36253 } 36254 } 36255 36256 // Pattern: (st:isVoid (X86sub_flag:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36257 // Emits: (SUB32mi8:isVoid addr:iPTR:$dst, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 36258 // Pattern complexity = 51 cost = 1 size = 3 36259 if (Predicate_loadi32(N10.getNode())) { 36260 SDValue N101 = N10.getOperand(1); 36261 SDValue CPTmpN101_0; 36262 SDValue CPTmpN101_1; 36263 SDValue CPTmpN101_2; 36264 SDValue CPTmpN101_3; 36265 SDValue CPTmpN101_4; 36266 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36267 SDValue N11 = N1.getOperand(1); 36268 if (N11.getOpcode() == ISD::Constant && 36269 Predicate_i32immSExt8(N11.getNode())) { 36270 SDValue N2 = N.getOperand(2); 36271 if (N101 == N2 && 36272 N1.getNode()->getValueType(0) == MVT::i32) { 36273 SDNode *Result = Emit_180(N, X86::SUB32mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36274 return Result; 36275 } 36276 } 36277 } 36278 } 36279 } 36280 } 36281 } 36282 if (N1.getOpcode() == X86ISD::ADD && 36283 N1.hasOneUse()) { 36284 SDValue N10 = N1.getOperand(0); 36285 if (N10.getOpcode() == ISD::LOAD && 36286 N10.hasOneUse() && 36287 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 36288 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 36289 SDValue Chain10 = N10.getOperand(0); 36290 if (Predicate_unindexedload(N10.getNode()) && 36291 Predicate_load(N10.getNode()) && 36292 Predicate_loadi64(N10.getNode())) { 36293 SDValue N101 = N10.getOperand(1); 36294 SDValue CPTmpN101_0; 36295 SDValue CPTmpN101_1; 36296 SDValue CPTmpN101_2; 36297 SDValue CPTmpN101_3; 36298 SDValue CPTmpN101_4; 36299 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36300 SDValue N11 = N1.getOperand(1); 36301 if (N11.getOpcode() == ISD::Constant) { 36302 36303 // Pattern: (st:isVoid (X86add_flag:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36304 // Emits: (ADD64mi8:isVoid addr:iPTR:$dst, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 36305 // Pattern complexity = 51 cost = 1 size = 3 36306 if (Predicate_i64immSExt8(N11.getNode())) { 36307 SDValue N2 = N.getOperand(2); 36308 if (N101 == N2 && 36309 N1.getNode()->getValueType(0) == MVT::i64) { 36310 SDNode *Result = Emit_191(N, X86::ADD64mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36311 return Result; 36312 } 36313 } 36314 36315 // Pattern: (st:isVoid (X86add_flag:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36316 // Emits: (ADD64mi32:isVoid addr:iPTR:$dst, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 36317 // Pattern complexity = 51 cost = 1 size = 3 36318 if (Predicate_i64immSExt32(N11.getNode())) { 36319 SDValue N2 = N.getOperand(2); 36320 if (N101 == N2 && 36321 N1.getNode()->getValueType(0) == MVT::i64) { 36322 SDNode *Result = Emit_191(N, X86::ADD64mi32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36323 return Result; 36324 } 36325 } 36326 } 36327 } 36328 } 36329 } 36330 } 36331 if (N1.getOpcode() == X86ISD::SUB && 36332 N1.hasOneUse()) { 36333 SDValue N10 = N1.getOperand(0); 36334 if (N10.getOpcode() == ISD::LOAD && 36335 N10.hasOneUse() && 36336 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 36337 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 36338 SDValue Chain10 = N10.getOperand(0); 36339 if (Predicate_unindexedload(N10.getNode()) && 36340 Predicate_load(N10.getNode()) && 36341 Predicate_loadi64(N10.getNode())) { 36342 SDValue N101 = N10.getOperand(1); 36343 SDValue CPTmpN101_0; 36344 SDValue CPTmpN101_1; 36345 SDValue CPTmpN101_2; 36346 SDValue CPTmpN101_3; 36347 SDValue CPTmpN101_4; 36348 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36349 SDValue N11 = N1.getOperand(1); 36350 if (N11.getOpcode() == ISD::Constant) { 36351 36352 // Pattern: (st:isVoid (X86sub_flag:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36353 // Emits: (SUB64mi8:isVoid addr:iPTR:$dst, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 36354 // Pattern complexity = 51 cost = 1 size = 3 36355 if (Predicate_i64immSExt8(N11.getNode())) { 36356 SDValue N2 = N.getOperand(2); 36357 if (N101 == N2 && 36358 N1.getNode()->getValueType(0) == MVT::i64) { 36359 SDNode *Result = Emit_191(N, X86::SUB64mi8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36360 return Result; 36361 } 36362 } 36363 36364 // Pattern: (st:isVoid (X86sub_flag:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36365 // Emits: (SUB64mi32:isVoid addr:iPTR:$dst, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 36366 // Pattern complexity = 51 cost = 1 size = 3 36367 if (Predicate_i64immSExt32(N11.getNode())) { 36368 SDValue N2 = N.getOperand(2); 36369 if (N101 == N2 && 36370 N1.getNode()->getValueType(0) == MVT::i64) { 36371 SDNode *Result = Emit_191(N, X86::SUB64mi32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36372 return Result; 36373 } 36374 } 36375 } 36376 } 36377 } 36378 } 36379 } 36380 } 36381 } 36382 if ((Subtarget->hasSSE1())) { 36383 SDValue Chain = N.getOperand(0); 36384 if (Predicate_unindexedstore(N.getNode()) && 36385 Predicate_store(N.getNode())) { 36386 SDValue N1 = N.getOperand(1); 36387 if (N1.getOpcode() == ISD::VECTOR_SHUFFLE && 36388 N1.hasOneUse()) { 36389 36390 // Pattern: (st:isVoid (vector_shuffle:v4i32 (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR128:v4i32:$src2)<<P:Predicate_movlp>>, addr:iPTR:$src1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36391 // Emits: (MOVLPSmr:isVoid addr:iPTR:$src1, VR128:v16i8:$src2) 36392 // Pattern complexity = 51 cost = 1 size = 3 36393 if (Predicate_movlp(N1.getNode())) { 36394 SDValue N10 = N1.getOperand(0); 36395 if (N10.getOpcode() == ISD::BIT_CONVERT && 36396 N10.hasOneUse()) { 36397 SDValue N100 = N10.getOperand(0); 36398 if (N100.getOpcode() == ISD::LOAD && 36399 N100.hasOneUse() && 36400 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 36401 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 36402 SDValue Chain100 = N100.getOperand(0); 36403 if (Predicate_unindexedload(N100.getNode()) && 36404 Predicate_load(N100.getNode())) { 36405 SDValue N1001 = N100.getOperand(1); 36406 SDValue CPTmpN1001_0; 36407 SDValue CPTmpN1001_1; 36408 SDValue CPTmpN1001_2; 36409 SDValue CPTmpN1001_3; 36410 SDValue CPTmpN1001_4; 36411 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 36412 SDValue N11 = N1.getOperand(1); 36413 SDValue N2 = N.getOperand(2); 36414 if (N1001 == N2 && 36415 N1.getNode()->getValueType(0) == MVT::v4i32 && 36416 N100.getNode()->getValueType(0) == MVT::v2i64) { 36417 SDNode *Result = Emit_215(N, X86::MOVLPSmr, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 36418 return Result; 36419 } 36420 } 36421 } 36422 } 36423 } 36424 } 36425 36426 // Pattern: (st:isVoid (vector_shuffle:v4i32 (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR128:v4i32:$src2)<<P:Predicate_movhp>>, addr:iPTR:$src1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36427 // Emits: (MOVHPSmr:isVoid addr:iPTR:$src1, VR128:v16i8:$src2) 36428 // Pattern complexity = 51 cost = 1 size = 3 36429 if (Predicate_movhp(N1.getNode())) { 36430 SDValue N10 = N1.getOperand(0); 36431 if (N10.getOpcode() == ISD::BIT_CONVERT && 36432 N10.hasOneUse()) { 36433 SDValue N100 = N10.getOperand(0); 36434 if (N100.getOpcode() == ISD::LOAD && 36435 N100.hasOneUse() && 36436 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode()) && 36437 (Chain.getNode() == N100.getNode() || IsChainCompatible(Chain.getNode(), N100.getNode()))) { 36438 SDValue Chain100 = N100.getOperand(0); 36439 if (Predicate_unindexedload(N100.getNode()) && 36440 Predicate_load(N100.getNode())) { 36441 SDValue N1001 = N100.getOperand(1); 36442 SDValue CPTmpN1001_0; 36443 SDValue CPTmpN1001_1; 36444 SDValue CPTmpN1001_2; 36445 SDValue CPTmpN1001_3; 36446 SDValue CPTmpN1001_4; 36447 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4)) { 36448 SDValue N11 = N1.getOperand(1); 36449 SDValue N2 = N.getOperand(2); 36450 if (N1001 == N2 && 36451 N1.getNode()->getValueType(0) == MVT::v4i32 && 36452 N100.getNode()->getValueType(0) == MVT::v2i64) { 36453 SDNode *Result = Emit_215(N, X86::MOVHPSmr, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 36454 return Result; 36455 } 36456 } 36457 } 36458 } 36459 } 36460 } 36461 } 36462 } 36463 } 36464 { 36465 SDValue Chain = N.getOperand(0); 36466 if (Predicate_unindexedstore(N.getNode()) && 36467 Predicate_store(N.getNode())) { 36468 SDValue N1 = N.getOperand(1); 36469 if (N1.getOpcode() == ISD::AND && 36470 N1.hasOneUse()) { 36471 SDValue N10 = N1.getOperand(0); 36472 if (N10.getOpcode() == ISD::LOAD && 36473 N10.hasOneUse() && 36474 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 36475 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 36476 SDValue Chain10 = N10.getOperand(0); 36477 if (Predicate_unindexedload(N10.getNode())) { 36478 36479 // Pattern: (st:isVoid (and:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36480 // Emits: (AND8mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 36481 // Pattern complexity = 50 cost = 1 size = 3 36482 if (Predicate_load(N10.getNode()) && 36483 Predicate_loadi8(N10.getNode())) { 36484 SDValue N101 = N10.getOperand(1); 36485 SDValue CPTmpN101_0; 36486 SDValue CPTmpN101_1; 36487 SDValue CPTmpN101_2; 36488 SDValue CPTmpN101_3; 36489 SDValue CPTmpN101_4; 36490 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36491 SDValue N11 = N1.getOperand(1); 36492 if (N11.getOpcode() == ISD::Constant) { 36493 SDValue N2 = N.getOperand(2); 36494 if (N101 == N2 && 36495 N1.getNode()->getValueType(0) == MVT::i8) { 36496 SDNode *Result = Emit_178(N, X86::AND8mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36497 return Result; 36498 } 36499 } 36500 } 36501 } 36502 36503 // Pattern: (st:isVoid (and:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i16):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36504 // Emits: (AND16mi:isVoid addr:iPTR:$dst, (imm:i16):$src) 36505 // Pattern complexity = 50 cost = 1 size = 3 36506 if (Predicate_loadi16(N10.getNode())) { 36507 SDValue N101 = N10.getOperand(1); 36508 SDValue CPTmpN101_0; 36509 SDValue CPTmpN101_1; 36510 SDValue CPTmpN101_2; 36511 SDValue CPTmpN101_3; 36512 SDValue CPTmpN101_4; 36513 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36514 SDValue N11 = N1.getOperand(1); 36515 if (N11.getOpcode() == ISD::Constant) { 36516 SDValue N2 = N.getOperand(2); 36517 if (N101 == N2 && 36518 N1.getNode()->getValueType(0) == MVT::i16) { 36519 SDNode *Result = Emit_179(N, X86::AND16mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36520 return Result; 36521 } 36522 } 36523 } 36524 } 36525 36526 // Pattern: (st:isVoid (and:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i32):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36527 // Emits: (AND32mi:isVoid addr:iPTR:$dst, (imm:i32):$src) 36528 // Pattern complexity = 50 cost = 1 size = 3 36529 if (Predicate_loadi32(N10.getNode())) { 36530 SDValue N101 = N10.getOperand(1); 36531 SDValue CPTmpN101_0; 36532 SDValue CPTmpN101_1; 36533 SDValue CPTmpN101_2; 36534 SDValue CPTmpN101_3; 36535 SDValue CPTmpN101_4; 36536 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36537 SDValue N11 = N1.getOperand(1); 36538 if (N11.getOpcode() == ISD::Constant) { 36539 SDValue N2 = N.getOperand(2); 36540 if (N101 == N2 && 36541 N1.getNode()->getValueType(0) == MVT::i32) { 36542 SDNode *Result = Emit_180(N, X86::AND32mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36543 return Result; 36544 } 36545 } 36546 } 36547 } 36548 } 36549 } 36550 } 36551 if (N1.getOpcode() == ISD::OR && 36552 N1.hasOneUse()) { 36553 SDValue N10 = N1.getOperand(0); 36554 if (N10.getOpcode() == ISD::LOAD && 36555 N10.hasOneUse() && 36556 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 36557 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 36558 SDValue Chain10 = N10.getOperand(0); 36559 if (Predicate_unindexedload(N10.getNode())) { 36560 36561 // Pattern: (st:isVoid (or:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36562 // Emits: (OR8mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 36563 // Pattern complexity = 50 cost = 1 size = 3 36564 if (Predicate_load(N10.getNode()) && 36565 Predicate_loadi8(N10.getNode())) { 36566 SDValue N101 = N10.getOperand(1); 36567 SDValue CPTmpN101_0; 36568 SDValue CPTmpN101_1; 36569 SDValue CPTmpN101_2; 36570 SDValue CPTmpN101_3; 36571 SDValue CPTmpN101_4; 36572 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36573 SDValue N11 = N1.getOperand(1); 36574 if (N11.getOpcode() == ISD::Constant) { 36575 SDValue N2 = N.getOperand(2); 36576 if (N101 == N2 && 36577 N1.getNode()->getValueType(0) == MVT::i8) { 36578 SDNode *Result = Emit_178(N, X86::OR8mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36579 return Result; 36580 } 36581 } 36582 } 36583 } 36584 36585 // Pattern: (st:isVoid (or:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i16):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36586 // Emits: (OR16mi:isVoid addr:iPTR:$dst, (imm:i16):$src) 36587 // Pattern complexity = 50 cost = 1 size = 3 36588 if (Predicate_loadi16(N10.getNode())) { 36589 SDValue N101 = N10.getOperand(1); 36590 SDValue CPTmpN101_0; 36591 SDValue CPTmpN101_1; 36592 SDValue CPTmpN101_2; 36593 SDValue CPTmpN101_3; 36594 SDValue CPTmpN101_4; 36595 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36596 SDValue N11 = N1.getOperand(1); 36597 if (N11.getOpcode() == ISD::Constant) { 36598 SDValue N2 = N.getOperand(2); 36599 if (N101 == N2 && 36600 N1.getNode()->getValueType(0) == MVT::i16) { 36601 SDNode *Result = Emit_179(N, X86::OR16mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36602 return Result; 36603 } 36604 } 36605 } 36606 } 36607 36608 // Pattern: (st:isVoid (or:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i32):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36609 // Emits: (OR32mi:isVoid addr:iPTR:$dst, (imm:i32):$src) 36610 // Pattern complexity = 50 cost = 1 size = 3 36611 if (Predicate_loadi32(N10.getNode())) { 36612 SDValue N101 = N10.getOperand(1); 36613 SDValue CPTmpN101_0; 36614 SDValue CPTmpN101_1; 36615 SDValue CPTmpN101_2; 36616 SDValue CPTmpN101_3; 36617 SDValue CPTmpN101_4; 36618 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36619 SDValue N11 = N1.getOperand(1); 36620 if (N11.getOpcode() == ISD::Constant) { 36621 SDValue N2 = N.getOperand(2); 36622 if (N101 == N2 && 36623 N1.getNode()->getValueType(0) == MVT::i32) { 36624 SDNode *Result = Emit_180(N, X86::OR32mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36625 return Result; 36626 } 36627 } 36628 } 36629 } 36630 } 36631 } 36632 } 36633 if (N1.getOpcode() == ISD::XOR && 36634 N1.hasOneUse()) { 36635 SDValue N10 = N1.getOperand(0); 36636 if (N10.getOpcode() == ISD::LOAD && 36637 N10.hasOneUse() && 36638 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 36639 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 36640 SDValue Chain10 = N10.getOperand(0); 36641 if (Predicate_unindexedload(N10.getNode())) { 36642 36643 // Pattern: (st:isVoid (xor:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36644 // Emits: (XOR8mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 36645 // Pattern complexity = 50 cost = 1 size = 3 36646 if (Predicate_load(N10.getNode()) && 36647 Predicate_loadi8(N10.getNode())) { 36648 SDValue N101 = N10.getOperand(1); 36649 SDValue CPTmpN101_0; 36650 SDValue CPTmpN101_1; 36651 SDValue CPTmpN101_2; 36652 SDValue CPTmpN101_3; 36653 SDValue CPTmpN101_4; 36654 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36655 SDValue N11 = N1.getOperand(1); 36656 if (N11.getOpcode() == ISD::Constant) { 36657 SDValue N2 = N.getOperand(2); 36658 if (N101 == N2 && 36659 N1.getNode()->getValueType(0) == MVT::i8) { 36660 SDNode *Result = Emit_178(N, X86::XOR8mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36661 return Result; 36662 } 36663 } 36664 } 36665 } 36666 36667 // Pattern: (st:isVoid (xor:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i16):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36668 // Emits: (XOR16mi:isVoid addr:iPTR:$dst, (imm:i16):$src) 36669 // Pattern complexity = 50 cost = 1 size = 3 36670 if (Predicate_loadi16(N10.getNode())) { 36671 SDValue N101 = N10.getOperand(1); 36672 SDValue CPTmpN101_0; 36673 SDValue CPTmpN101_1; 36674 SDValue CPTmpN101_2; 36675 SDValue CPTmpN101_3; 36676 SDValue CPTmpN101_4; 36677 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36678 SDValue N11 = N1.getOperand(1); 36679 if (N11.getOpcode() == ISD::Constant) { 36680 SDValue N2 = N.getOperand(2); 36681 if (N101 == N2 && 36682 N1.getNode()->getValueType(0) == MVT::i16) { 36683 SDNode *Result = Emit_179(N, X86::XOR16mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36684 return Result; 36685 } 36686 } 36687 } 36688 } 36689 36690 // Pattern: (st:isVoid (xor:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i32):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36691 // Emits: (XOR32mi:isVoid addr:iPTR:$dst, (imm:i32):$src) 36692 // Pattern complexity = 50 cost = 1 size = 3 36693 if (Predicate_loadi32(N10.getNode())) { 36694 SDValue N101 = N10.getOperand(1); 36695 SDValue CPTmpN101_0; 36696 SDValue CPTmpN101_1; 36697 SDValue CPTmpN101_2; 36698 SDValue CPTmpN101_3; 36699 SDValue CPTmpN101_4; 36700 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36701 SDValue N11 = N1.getOperand(1); 36702 if (N11.getOpcode() == ISD::Constant) { 36703 SDValue N2 = N.getOperand(2); 36704 if (N101 == N2 && 36705 N1.getNode()->getValueType(0) == MVT::i32) { 36706 SDNode *Result = Emit_180(N, X86::XOR32mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36707 return Result; 36708 } 36709 } 36710 } 36711 } 36712 } 36713 } 36714 } 36715 if (N1.getOpcode() == ISD::SHL && 36716 N1.hasOneUse()) { 36717 SDValue N10 = N1.getOperand(0); 36718 if (N10.getOpcode() == ISD::LOAD && 36719 N10.hasOneUse() && 36720 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 36721 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 36722 SDValue Chain10 = N10.getOperand(0); 36723 if (Predicate_unindexedload(N10.getNode())) { 36724 36725 // Pattern: (st:isVoid (shl:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36726 // Emits: (SHL8mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 36727 // Pattern complexity = 50 cost = 1 size = 3 36728 if (Predicate_load(N10.getNode()) && 36729 Predicate_loadi8(N10.getNode())) { 36730 SDValue N101 = N10.getOperand(1); 36731 SDValue CPTmpN101_0; 36732 SDValue CPTmpN101_1; 36733 SDValue CPTmpN101_2; 36734 SDValue CPTmpN101_3; 36735 SDValue CPTmpN101_4; 36736 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36737 SDValue N11 = N1.getOperand(1); 36738 if (N11.getOpcode() == ISD::Constant) { 36739 SDValue N2 = N.getOperand(2); 36740 if (N101 == N2 && 36741 N1.getNode()->getValueType(0) == MVT::i8 && 36742 N11.getNode()->getValueType(0) == MVT::i8) { 36743 SDNode *Result = Emit_182(N, X86::SHL8mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36744 return Result; 36745 } 36746 } 36747 } 36748 } 36749 36750 // Pattern: (st:isVoid (shl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36751 // Emits: (SHL16mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 36752 // Pattern complexity = 50 cost = 1 size = 3 36753 if (Predicate_loadi16(N10.getNode())) { 36754 SDValue N101 = N10.getOperand(1); 36755 SDValue CPTmpN101_0; 36756 SDValue CPTmpN101_1; 36757 SDValue CPTmpN101_2; 36758 SDValue CPTmpN101_3; 36759 SDValue CPTmpN101_4; 36760 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36761 SDValue N11 = N1.getOperand(1); 36762 if (N11.getOpcode() == ISD::Constant) { 36763 SDValue N2 = N.getOperand(2); 36764 if (N101 == N2 && 36765 N1.getNode()->getValueType(0) == MVT::i16 && 36766 N11.getNode()->getValueType(0) == MVT::i8) { 36767 SDNode *Result = Emit_182(N, X86::SHL16mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36768 return Result; 36769 } 36770 } 36771 } 36772 } 36773 36774 // Pattern: (st:isVoid (shl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36775 // Emits: (SHL32mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 36776 // Pattern complexity = 50 cost = 1 size = 3 36777 if (Predicate_loadi32(N10.getNode())) { 36778 SDValue N101 = N10.getOperand(1); 36779 SDValue CPTmpN101_0; 36780 SDValue CPTmpN101_1; 36781 SDValue CPTmpN101_2; 36782 SDValue CPTmpN101_3; 36783 SDValue CPTmpN101_4; 36784 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36785 SDValue N11 = N1.getOperand(1); 36786 if (N11.getOpcode() == ISD::Constant) { 36787 SDValue N2 = N.getOperand(2); 36788 if (N101 == N2 && 36789 N1.getNode()->getValueType(0) == MVT::i32 && 36790 N11.getNode()->getValueType(0) == MVT::i8) { 36791 SDNode *Result = Emit_182(N, X86::SHL32mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36792 return Result; 36793 } 36794 } 36795 } 36796 } 36797 } 36798 } 36799 } 36800 if (N1.getOpcode() == ISD::SRL && 36801 N1.hasOneUse()) { 36802 SDValue N10 = N1.getOperand(0); 36803 if (N10.getOpcode() == ISD::LOAD && 36804 N10.hasOneUse() && 36805 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 36806 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 36807 SDValue Chain10 = N10.getOperand(0); 36808 if (Predicate_unindexedload(N10.getNode())) { 36809 36810 // Pattern: (st:isVoid (srl:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36811 // Emits: (SHR8mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 36812 // Pattern complexity = 50 cost = 1 size = 3 36813 if (Predicate_load(N10.getNode()) && 36814 Predicate_loadi8(N10.getNode())) { 36815 SDValue N101 = N10.getOperand(1); 36816 SDValue CPTmpN101_0; 36817 SDValue CPTmpN101_1; 36818 SDValue CPTmpN101_2; 36819 SDValue CPTmpN101_3; 36820 SDValue CPTmpN101_4; 36821 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36822 SDValue N11 = N1.getOperand(1); 36823 if (N11.getOpcode() == ISD::Constant) { 36824 SDValue N2 = N.getOperand(2); 36825 if (N101 == N2 && 36826 N1.getNode()->getValueType(0) == MVT::i8 && 36827 N11.getNode()->getValueType(0) == MVT::i8) { 36828 SDNode *Result = Emit_182(N, X86::SHR8mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36829 return Result; 36830 } 36831 } 36832 } 36833 } 36834 36835 // Pattern: (st:isVoid (srl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36836 // Emits: (SHR16mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 36837 // Pattern complexity = 50 cost = 1 size = 3 36838 if (Predicate_loadi16(N10.getNode())) { 36839 SDValue N101 = N10.getOperand(1); 36840 SDValue CPTmpN101_0; 36841 SDValue CPTmpN101_1; 36842 SDValue CPTmpN101_2; 36843 SDValue CPTmpN101_3; 36844 SDValue CPTmpN101_4; 36845 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36846 SDValue N11 = N1.getOperand(1); 36847 if (N11.getOpcode() == ISD::Constant) { 36848 SDValue N2 = N.getOperand(2); 36849 if (N101 == N2 && 36850 N1.getNode()->getValueType(0) == MVT::i16 && 36851 N11.getNode()->getValueType(0) == MVT::i8) { 36852 SDNode *Result = Emit_182(N, X86::SHR16mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36853 return Result; 36854 } 36855 } 36856 } 36857 } 36858 36859 // Pattern: (st:isVoid (srl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36860 // Emits: (SHR32mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 36861 // Pattern complexity = 50 cost = 1 size = 3 36862 if (Predicate_loadi32(N10.getNode())) { 36863 SDValue N101 = N10.getOperand(1); 36864 SDValue CPTmpN101_0; 36865 SDValue CPTmpN101_1; 36866 SDValue CPTmpN101_2; 36867 SDValue CPTmpN101_3; 36868 SDValue CPTmpN101_4; 36869 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36870 SDValue N11 = N1.getOperand(1); 36871 if (N11.getOpcode() == ISD::Constant) { 36872 SDValue N2 = N.getOperand(2); 36873 if (N101 == N2 && 36874 N1.getNode()->getValueType(0) == MVT::i32 && 36875 N11.getNode()->getValueType(0) == MVT::i8) { 36876 SDNode *Result = Emit_182(N, X86::SHR32mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36877 return Result; 36878 } 36879 } 36880 } 36881 } 36882 } 36883 } 36884 } 36885 if (N1.getOpcode() == ISD::SRA && 36886 N1.hasOneUse()) { 36887 SDValue N10 = N1.getOperand(0); 36888 if (N10.getOpcode() == ISD::LOAD && 36889 N10.hasOneUse() && 36890 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 36891 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 36892 SDValue Chain10 = N10.getOperand(0); 36893 if (Predicate_unindexedload(N10.getNode())) { 36894 36895 // Pattern: (st:isVoid (sra:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36896 // Emits: (SAR8mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 36897 // Pattern complexity = 50 cost = 1 size = 3 36898 if (Predicate_load(N10.getNode()) && 36899 Predicate_loadi8(N10.getNode())) { 36900 SDValue N101 = N10.getOperand(1); 36901 SDValue CPTmpN101_0; 36902 SDValue CPTmpN101_1; 36903 SDValue CPTmpN101_2; 36904 SDValue CPTmpN101_3; 36905 SDValue CPTmpN101_4; 36906 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36907 SDValue N11 = N1.getOperand(1); 36908 if (N11.getOpcode() == ISD::Constant) { 36909 SDValue N2 = N.getOperand(2); 36910 if (N101 == N2 && 36911 N1.getNode()->getValueType(0) == MVT::i8 && 36912 N11.getNode()->getValueType(0) == MVT::i8) { 36913 SDNode *Result = Emit_182(N, X86::SAR8mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36914 return Result; 36915 } 36916 } 36917 } 36918 } 36919 36920 // Pattern: (st:isVoid (sra:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36921 // Emits: (SAR16mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 36922 // Pattern complexity = 50 cost = 1 size = 3 36923 if (Predicate_loadi16(N10.getNode())) { 36924 SDValue N101 = N10.getOperand(1); 36925 SDValue CPTmpN101_0; 36926 SDValue CPTmpN101_1; 36927 SDValue CPTmpN101_2; 36928 SDValue CPTmpN101_3; 36929 SDValue CPTmpN101_4; 36930 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36931 SDValue N11 = N1.getOperand(1); 36932 if (N11.getOpcode() == ISD::Constant) { 36933 SDValue N2 = N.getOperand(2); 36934 if (N101 == N2 && 36935 N1.getNode()->getValueType(0) == MVT::i16 && 36936 N11.getNode()->getValueType(0) == MVT::i8) { 36937 SDNode *Result = Emit_182(N, X86::SAR16mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36938 return Result; 36939 } 36940 } 36941 } 36942 } 36943 36944 // Pattern: (st:isVoid (sra:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36945 // Emits: (SAR32mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 36946 // Pattern complexity = 50 cost = 1 size = 3 36947 if (Predicate_loadi32(N10.getNode())) { 36948 SDValue N101 = N10.getOperand(1); 36949 SDValue CPTmpN101_0; 36950 SDValue CPTmpN101_1; 36951 SDValue CPTmpN101_2; 36952 SDValue CPTmpN101_3; 36953 SDValue CPTmpN101_4; 36954 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36955 SDValue N11 = N1.getOperand(1); 36956 if (N11.getOpcode() == ISD::Constant) { 36957 SDValue N2 = N.getOperand(2); 36958 if (N101 == N2 && 36959 N1.getNode()->getValueType(0) == MVT::i32 && 36960 N11.getNode()->getValueType(0) == MVT::i8) { 36961 SDNode *Result = Emit_182(N, X86::SAR32mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36962 return Result; 36963 } 36964 } 36965 } 36966 } 36967 } 36968 } 36969 } 36970 if (N1.getOpcode() == ISD::ROTL && 36971 N1.hasOneUse()) { 36972 SDValue N10 = N1.getOperand(0); 36973 if (N10.getOpcode() == ISD::LOAD && 36974 N10.hasOneUse() && 36975 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 36976 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 36977 SDValue Chain10 = N10.getOperand(0); 36978 if (Predicate_unindexedload(N10.getNode())) { 36979 36980 // Pattern: (st:isVoid (rotl:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 36981 // Emits: (ROL8mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 36982 // Pattern complexity = 50 cost = 1 size = 3 36983 if (Predicate_load(N10.getNode()) && 36984 Predicate_loadi8(N10.getNode())) { 36985 SDValue N101 = N10.getOperand(1); 36986 SDValue CPTmpN101_0; 36987 SDValue CPTmpN101_1; 36988 SDValue CPTmpN101_2; 36989 SDValue CPTmpN101_3; 36990 SDValue CPTmpN101_4; 36991 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 36992 SDValue N11 = N1.getOperand(1); 36993 if (N11.getOpcode() == ISD::Constant) { 36994 SDValue N2 = N.getOperand(2); 36995 if (N101 == N2 && 36996 N1.getNode()->getValueType(0) == MVT::i8 && 36997 N11.getNode()->getValueType(0) == MVT::i8) { 36998 SDNode *Result = Emit_182(N, X86::ROL8mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 36999 return Result; 37000 } 37001 } 37002 } 37003 } 37004 37005 // Pattern: (st:isVoid (rotl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37006 // Emits: (ROL16mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 37007 // Pattern complexity = 50 cost = 1 size = 3 37008 if (Predicate_loadi16(N10.getNode())) { 37009 SDValue N101 = N10.getOperand(1); 37010 SDValue CPTmpN101_0; 37011 SDValue CPTmpN101_1; 37012 SDValue CPTmpN101_2; 37013 SDValue CPTmpN101_3; 37014 SDValue CPTmpN101_4; 37015 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37016 SDValue N11 = N1.getOperand(1); 37017 if (N11.getOpcode() == ISD::Constant) { 37018 SDValue N2 = N.getOperand(2); 37019 if (N101 == N2 && 37020 N1.getNode()->getValueType(0) == MVT::i16 && 37021 N11.getNode()->getValueType(0) == MVT::i8) { 37022 SDNode *Result = Emit_182(N, X86::ROL16mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37023 return Result; 37024 } 37025 } 37026 } 37027 } 37028 37029 // Pattern: (st:isVoid (rotl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37030 // Emits: (ROL32mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 37031 // Pattern complexity = 50 cost = 1 size = 3 37032 if (Predicate_loadi32(N10.getNode())) { 37033 SDValue N101 = N10.getOperand(1); 37034 SDValue CPTmpN101_0; 37035 SDValue CPTmpN101_1; 37036 SDValue CPTmpN101_2; 37037 SDValue CPTmpN101_3; 37038 SDValue CPTmpN101_4; 37039 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37040 SDValue N11 = N1.getOperand(1); 37041 if (N11.getOpcode() == ISD::Constant) { 37042 SDValue N2 = N.getOperand(2); 37043 if (N101 == N2 && 37044 N1.getNode()->getValueType(0) == MVT::i32 && 37045 N11.getNode()->getValueType(0) == MVT::i8) { 37046 SDNode *Result = Emit_182(N, X86::ROL32mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37047 return Result; 37048 } 37049 } 37050 } 37051 } 37052 } 37053 } 37054 } 37055 if (N1.getOpcode() == ISD::ROTR && 37056 N1.hasOneUse()) { 37057 SDValue N10 = N1.getOperand(0); 37058 if (N10.getOpcode() == ISD::LOAD && 37059 N10.hasOneUse() && 37060 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 37061 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 37062 SDValue Chain10 = N10.getOperand(0); 37063 if (Predicate_unindexedload(N10.getNode())) { 37064 37065 // Pattern: (st:isVoid (rotr:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37066 // Emits: (ROR8mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 37067 // Pattern complexity = 50 cost = 1 size = 3 37068 if (Predicate_load(N10.getNode()) && 37069 Predicate_loadi8(N10.getNode())) { 37070 SDValue N101 = N10.getOperand(1); 37071 SDValue CPTmpN101_0; 37072 SDValue CPTmpN101_1; 37073 SDValue CPTmpN101_2; 37074 SDValue CPTmpN101_3; 37075 SDValue CPTmpN101_4; 37076 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37077 SDValue N11 = N1.getOperand(1); 37078 if (N11.getOpcode() == ISD::Constant) { 37079 SDValue N2 = N.getOperand(2); 37080 if (N101 == N2 && 37081 N1.getNode()->getValueType(0) == MVT::i8 && 37082 N11.getNode()->getValueType(0) == MVT::i8) { 37083 SDNode *Result = Emit_182(N, X86::ROR8mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37084 return Result; 37085 } 37086 } 37087 } 37088 } 37089 37090 // Pattern: (st:isVoid (rotr:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37091 // Emits: (ROR16mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 37092 // Pattern complexity = 50 cost = 1 size = 3 37093 if (Predicate_loadi16(N10.getNode())) { 37094 SDValue N101 = N10.getOperand(1); 37095 SDValue CPTmpN101_0; 37096 SDValue CPTmpN101_1; 37097 SDValue CPTmpN101_2; 37098 SDValue CPTmpN101_3; 37099 SDValue CPTmpN101_4; 37100 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37101 SDValue N11 = N1.getOperand(1); 37102 if (N11.getOpcode() == ISD::Constant) { 37103 SDValue N2 = N.getOperand(2); 37104 if (N101 == N2 && 37105 N1.getNode()->getValueType(0) == MVT::i16 && 37106 N11.getNode()->getValueType(0) == MVT::i8) { 37107 SDNode *Result = Emit_182(N, X86::ROR16mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37108 return Result; 37109 } 37110 } 37111 } 37112 } 37113 37114 // Pattern: (st:isVoid (rotr:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37115 // Emits: (ROR32mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 37116 // Pattern complexity = 50 cost = 1 size = 3 37117 if (Predicate_loadi32(N10.getNode())) { 37118 SDValue N101 = N10.getOperand(1); 37119 SDValue CPTmpN101_0; 37120 SDValue CPTmpN101_1; 37121 SDValue CPTmpN101_2; 37122 SDValue CPTmpN101_3; 37123 SDValue CPTmpN101_4; 37124 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37125 SDValue N11 = N1.getOperand(1); 37126 if (N11.getOpcode() == ISD::Constant) { 37127 SDValue N2 = N.getOperand(2); 37128 if (N101 == N2 && 37129 N1.getNode()->getValueType(0) == MVT::i32 && 37130 N11.getNode()->getValueType(0) == MVT::i8) { 37131 SDNode *Result = Emit_182(N, X86::ROR32mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37132 return Result; 37133 } 37134 } 37135 } 37136 } 37137 } 37138 } 37139 } 37140 37141 // Pattern: (st:isVoid (X86shld:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, (imm:i8):$src3), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37142 // Emits: (SHLD32mri8:isVoid addr:iPTR:$dst, GR32:i32:$src2, (imm:i8):$src3) 37143 // Pattern complexity = 50 cost = 1 size = 3 37144 if (N1.getOpcode() == X86ISD::SHLD && 37145 N1.hasOneUse()) { 37146 SDValue N10 = N1.getOperand(0); 37147 if (N10.getOpcode() == ISD::LOAD && 37148 N10.hasOneUse() && 37149 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 37150 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 37151 SDValue Chain10 = N10.getOperand(0); 37152 if (Predicate_unindexedload(N10.getNode()) && 37153 Predicate_loadi32(N10.getNode())) { 37154 SDValue N101 = N10.getOperand(1); 37155 SDValue CPTmpN101_0; 37156 SDValue CPTmpN101_1; 37157 SDValue CPTmpN101_2; 37158 SDValue CPTmpN101_3; 37159 SDValue CPTmpN101_4; 37160 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37161 SDValue N11 = N1.getOperand(1); 37162 SDValue N12 = N1.getOperand(2); 37163 if (N12.getOpcode() == ISD::Constant) { 37164 SDValue N2 = N.getOperand(2); 37165 if (N101 == N2 && 37166 N1.getNode()->getValueType(0) == MVT::i32 && 37167 N12.getNode()->getValueType(0) == MVT::i8) { 37168 SDNode *Result = Emit_184(N, X86::SHLD32mri8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37169 return Result; 37170 } 37171 } 37172 } 37173 } 37174 } 37175 } 37176 37177 // Pattern: (st:isVoid (X86shrd:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, (imm:i8):$src3), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37178 // Emits: (SHRD32mri8:isVoid addr:iPTR:$dst, GR32:i32:$src2, (imm:i8):$src3) 37179 // Pattern complexity = 50 cost = 1 size = 3 37180 if (N1.getOpcode() == X86ISD::SHRD && 37181 N1.hasOneUse()) { 37182 SDValue N10 = N1.getOperand(0); 37183 if (N10.getOpcode() == ISD::LOAD && 37184 N10.hasOneUse() && 37185 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 37186 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 37187 SDValue Chain10 = N10.getOperand(0); 37188 if (Predicate_unindexedload(N10.getNode()) && 37189 Predicate_loadi32(N10.getNode())) { 37190 SDValue N101 = N10.getOperand(1); 37191 SDValue CPTmpN101_0; 37192 SDValue CPTmpN101_1; 37193 SDValue CPTmpN101_2; 37194 SDValue CPTmpN101_3; 37195 SDValue CPTmpN101_4; 37196 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37197 SDValue N11 = N1.getOperand(1); 37198 SDValue N12 = N1.getOperand(2); 37199 if (N12.getOpcode() == ISD::Constant) { 37200 SDValue N2 = N.getOperand(2); 37201 if (N101 == N2 && 37202 N1.getNode()->getValueType(0) == MVT::i32 && 37203 N12.getNode()->getValueType(0) == MVT::i8) { 37204 SDNode *Result = Emit_184(N, X86::SHRD32mri8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37205 return Result; 37206 } 37207 } 37208 } 37209 } 37210 } 37211 } 37212 37213 // Pattern: (st:isVoid (X86shld:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, (imm:i8):$src3), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37214 // Emits: (SHLD16mri8:isVoid addr:iPTR:$dst, GR16:i16:$src2, (imm:i8):$src3) 37215 // Pattern complexity = 50 cost = 1 size = 3 37216 if (N1.getOpcode() == X86ISD::SHLD && 37217 N1.hasOneUse()) { 37218 SDValue N10 = N1.getOperand(0); 37219 if (N10.getOpcode() == ISD::LOAD && 37220 N10.hasOneUse() && 37221 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 37222 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 37223 SDValue Chain10 = N10.getOperand(0); 37224 if (Predicate_unindexedload(N10.getNode()) && 37225 Predicate_loadi16(N10.getNode())) { 37226 SDValue N101 = N10.getOperand(1); 37227 SDValue CPTmpN101_0; 37228 SDValue CPTmpN101_1; 37229 SDValue CPTmpN101_2; 37230 SDValue CPTmpN101_3; 37231 SDValue CPTmpN101_4; 37232 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37233 SDValue N11 = N1.getOperand(1); 37234 SDValue N12 = N1.getOperand(2); 37235 if (N12.getOpcode() == ISD::Constant) { 37236 SDValue N2 = N.getOperand(2); 37237 if (N101 == N2 && 37238 N1.getNode()->getValueType(0) == MVT::i16 && 37239 N12.getNode()->getValueType(0) == MVT::i8) { 37240 SDNode *Result = Emit_184(N, X86::SHLD16mri8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37241 return Result; 37242 } 37243 } 37244 } 37245 } 37246 } 37247 } 37248 37249 // Pattern: (st:isVoid (X86shrd:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, (imm:i8):$src3), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37250 // Emits: (SHRD16mri8:isVoid addr:iPTR:$dst, GR16:i16:$src2, (imm:i8):$src3) 37251 // Pattern complexity = 50 cost = 1 size = 3 37252 if (N1.getOpcode() == X86ISD::SHRD && 37253 N1.hasOneUse()) { 37254 SDValue N10 = N1.getOperand(0); 37255 if (N10.getOpcode() == ISD::LOAD && 37256 N10.hasOneUse() && 37257 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 37258 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 37259 SDValue Chain10 = N10.getOperand(0); 37260 if (Predicate_unindexedload(N10.getNode()) && 37261 Predicate_loadi16(N10.getNode())) { 37262 SDValue N101 = N10.getOperand(1); 37263 SDValue CPTmpN101_0; 37264 SDValue CPTmpN101_1; 37265 SDValue CPTmpN101_2; 37266 SDValue CPTmpN101_3; 37267 SDValue CPTmpN101_4; 37268 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37269 SDValue N11 = N1.getOperand(1); 37270 SDValue N12 = N1.getOperand(2); 37271 if (N12.getOpcode() == ISD::Constant) { 37272 SDValue N2 = N.getOperand(2); 37273 if (N101 == N2 && 37274 N1.getNode()->getValueType(0) == MVT::i16 && 37275 N12.getNode()->getValueType(0) == MVT::i8) { 37276 SDNode *Result = Emit_184(N, X86::SHRD16mri8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37277 return Result; 37278 } 37279 } 37280 } 37281 } 37282 } 37283 } 37284 if (N1.getOpcode() == ISD::ADD && 37285 N1.hasOneUse()) { 37286 SDValue N10 = N1.getOperand(0); 37287 if (N10.getOpcode() == ISD::LOAD && 37288 N10.hasOneUse() && 37289 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 37290 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 37291 SDValue Chain10 = N10.getOperand(0); 37292 if (Predicate_unindexedload(N10.getNode())) { 37293 37294 // Pattern: (st:isVoid (add:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (imm:i8):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37295 // Emits: (ADD8mi:isVoid addr:iPTR:$dst, (imm:i8):$src2) 37296 // Pattern complexity = 50 cost = 1 size = 3 37297 if (Predicate_load(N10.getNode()) && 37298 Predicate_loadi8(N10.getNode())) { 37299 SDValue N101 = N10.getOperand(1); 37300 SDValue CPTmpN101_0; 37301 SDValue CPTmpN101_1; 37302 SDValue CPTmpN101_2; 37303 SDValue CPTmpN101_3; 37304 SDValue CPTmpN101_4; 37305 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37306 SDValue N11 = N1.getOperand(1); 37307 if (N11.getOpcode() == ISD::Constant) { 37308 SDValue N2 = N.getOperand(2); 37309 if (N101 == N2 && 37310 N1.getNode()->getValueType(0) == MVT::i8) { 37311 SDNode *Result = Emit_178(N, X86::ADD8mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37312 return Result; 37313 } 37314 } 37315 } 37316 } 37317 37318 // Pattern: (st:isVoid (add:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i16):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37319 // Emits: (ADD16mi:isVoid addr:iPTR:$dst, (imm:i16):$src2) 37320 // Pattern complexity = 50 cost = 1 size = 3 37321 if (Predicate_loadi16(N10.getNode())) { 37322 SDValue N101 = N10.getOperand(1); 37323 SDValue CPTmpN101_0; 37324 SDValue CPTmpN101_1; 37325 SDValue CPTmpN101_2; 37326 SDValue CPTmpN101_3; 37327 SDValue CPTmpN101_4; 37328 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37329 SDValue N11 = N1.getOperand(1); 37330 if (N11.getOpcode() == ISD::Constant) { 37331 SDValue N2 = N.getOperand(2); 37332 if (N101 == N2 && 37333 N1.getNode()->getValueType(0) == MVT::i16) { 37334 SDNode *Result = Emit_179(N, X86::ADD16mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37335 return Result; 37336 } 37337 } 37338 } 37339 } 37340 37341 // Pattern: (st:isVoid (add:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i32):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37342 // Emits: (ADD32mi:isVoid addr:iPTR:$dst, (imm:i32):$src2) 37343 // Pattern complexity = 50 cost = 1 size = 3 37344 if (Predicate_loadi32(N10.getNode())) { 37345 SDValue N101 = N10.getOperand(1); 37346 SDValue CPTmpN101_0; 37347 SDValue CPTmpN101_1; 37348 SDValue CPTmpN101_2; 37349 SDValue CPTmpN101_3; 37350 SDValue CPTmpN101_4; 37351 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37352 SDValue N11 = N1.getOperand(1); 37353 if (N11.getOpcode() == ISD::Constant) { 37354 SDValue N2 = N.getOperand(2); 37355 if (N101 == N2 && 37356 N1.getNode()->getValueType(0) == MVT::i32) { 37357 SDNode *Result = Emit_180(N, X86::ADD32mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37358 return Result; 37359 } 37360 } 37361 } 37362 } 37363 } 37364 } 37365 } 37366 if (N1.getOpcode() == ISD::ADDE && 37367 N1.hasOneUse()) { 37368 SDValue N10 = N1.getOperand(0); 37369 if (N10.getOpcode() == ISD::LOAD && 37370 N10.hasOneUse() && 37371 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 37372 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 37373 SDValue Chain10 = N10.getOperand(0); 37374 if (Predicate_unindexedload(N10.getNode())) { 37375 37376 // Pattern: (st:isVoid (adde:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (imm:i8):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37377 // Emits: (ADC8mi:isVoid addr:iPTR:$dst, (imm:i8):$src2) 37378 // Pattern complexity = 50 cost = 1 size = 3 37379 if (Predicate_load(N10.getNode()) && 37380 Predicate_loadi8(N10.getNode())) { 37381 SDValue N101 = N10.getOperand(1); 37382 SDValue CPTmpN101_0; 37383 SDValue CPTmpN101_1; 37384 SDValue CPTmpN101_2; 37385 SDValue CPTmpN101_3; 37386 SDValue CPTmpN101_4; 37387 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37388 SDValue N11 = N1.getOperand(1); 37389 if (N11.getOpcode() == ISD::Constant) { 37390 SDValue N2 = N.getOperand(2); 37391 if (N101 == N2 && 37392 N1.getNode()->getValueType(0) == MVT::i8) { 37393 SDNode *Result = Emit_186(N, X86::ADC8mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37394 return Result; 37395 } 37396 } 37397 } 37398 } 37399 37400 // Pattern: (st:isVoid (adde:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i16):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37401 // Emits: (ADC16mi:isVoid addr:iPTR:$dst, (imm:i16):$src2) 37402 // Pattern complexity = 50 cost = 1 size = 3 37403 if (Predicate_loadi16(N10.getNode())) { 37404 SDValue N101 = N10.getOperand(1); 37405 SDValue CPTmpN101_0; 37406 SDValue CPTmpN101_1; 37407 SDValue CPTmpN101_2; 37408 SDValue CPTmpN101_3; 37409 SDValue CPTmpN101_4; 37410 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37411 SDValue N11 = N1.getOperand(1); 37412 if (N11.getOpcode() == ISD::Constant) { 37413 SDValue N2 = N.getOperand(2); 37414 if (N101 == N2 && 37415 N1.getNode()->getValueType(0) == MVT::i16) { 37416 SDNode *Result = Emit_187(N, X86::ADC16mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37417 return Result; 37418 } 37419 } 37420 } 37421 } 37422 37423 // Pattern: (st:isVoid (adde:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i32):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37424 // Emits: (ADC32mi:isVoid addr:iPTR:$dst, (imm:i32):$src2) 37425 // Pattern complexity = 50 cost = 1 size = 3 37426 if (Predicate_loadi32(N10.getNode())) { 37427 SDValue N101 = N10.getOperand(1); 37428 SDValue CPTmpN101_0; 37429 SDValue CPTmpN101_1; 37430 SDValue CPTmpN101_2; 37431 SDValue CPTmpN101_3; 37432 SDValue CPTmpN101_4; 37433 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37434 SDValue N11 = N1.getOperand(1); 37435 if (N11.getOpcode() == ISD::Constant) { 37436 SDValue N2 = N.getOperand(2); 37437 if (N101 == N2 && 37438 N1.getNode()->getValueType(0) == MVT::i32) { 37439 SDNode *Result = Emit_188(N, X86::ADC32mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37440 return Result; 37441 } 37442 } 37443 } 37444 } 37445 } 37446 } 37447 } 37448 if (N1.getOpcode() == ISD::SUB && 37449 N1.hasOneUse()) { 37450 SDValue N10 = N1.getOperand(0); 37451 if (N10.getOpcode() == ISD::LOAD && 37452 N10.hasOneUse() && 37453 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 37454 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 37455 SDValue Chain10 = N10.getOperand(0); 37456 if (Predicate_unindexedload(N10.getNode())) { 37457 37458 // Pattern: (st:isVoid (sub:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (imm:i8):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37459 // Emits: (SUB8mi:isVoid addr:iPTR:$dst, (imm:i8):$src2) 37460 // Pattern complexity = 50 cost = 1 size = 3 37461 if (Predicate_load(N10.getNode()) && 37462 Predicate_loadi8(N10.getNode())) { 37463 SDValue N101 = N10.getOperand(1); 37464 SDValue CPTmpN101_0; 37465 SDValue CPTmpN101_1; 37466 SDValue CPTmpN101_2; 37467 SDValue CPTmpN101_3; 37468 SDValue CPTmpN101_4; 37469 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37470 SDValue N11 = N1.getOperand(1); 37471 if (N11.getOpcode() == ISD::Constant) { 37472 SDValue N2 = N.getOperand(2); 37473 if (N101 == N2 && 37474 N1.getNode()->getValueType(0) == MVT::i8) { 37475 SDNode *Result = Emit_178(N, X86::SUB8mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37476 return Result; 37477 } 37478 } 37479 } 37480 } 37481 37482 // Pattern: (st:isVoid (sub:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i16):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37483 // Emits: (SUB16mi:isVoid addr:iPTR:$dst, (imm:i16):$src2) 37484 // Pattern complexity = 50 cost = 1 size = 3 37485 if (Predicate_loadi16(N10.getNode())) { 37486 SDValue N101 = N10.getOperand(1); 37487 SDValue CPTmpN101_0; 37488 SDValue CPTmpN101_1; 37489 SDValue CPTmpN101_2; 37490 SDValue CPTmpN101_3; 37491 SDValue CPTmpN101_4; 37492 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37493 SDValue N11 = N1.getOperand(1); 37494 if (N11.getOpcode() == ISD::Constant) { 37495 SDValue N2 = N.getOperand(2); 37496 if (N101 == N2 && 37497 N1.getNode()->getValueType(0) == MVT::i16) { 37498 SDNode *Result = Emit_179(N, X86::SUB16mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37499 return Result; 37500 } 37501 } 37502 } 37503 } 37504 37505 // Pattern: (st:isVoid (sub:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i32):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37506 // Emits: (SUB32mi:isVoid addr:iPTR:$dst, (imm:i32):$src2) 37507 // Pattern complexity = 50 cost = 1 size = 3 37508 if (Predicate_loadi32(N10.getNode())) { 37509 SDValue N101 = N10.getOperand(1); 37510 SDValue CPTmpN101_0; 37511 SDValue CPTmpN101_1; 37512 SDValue CPTmpN101_2; 37513 SDValue CPTmpN101_3; 37514 SDValue CPTmpN101_4; 37515 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37516 SDValue N11 = N1.getOperand(1); 37517 if (N11.getOpcode() == ISD::Constant) { 37518 SDValue N2 = N.getOperand(2); 37519 if (N101 == N2 && 37520 N1.getNode()->getValueType(0) == MVT::i32) { 37521 SDNode *Result = Emit_180(N, X86::SUB32mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37522 return Result; 37523 } 37524 } 37525 } 37526 } 37527 } 37528 } 37529 } 37530 if (N1.getOpcode() == ISD::SUBE && 37531 N1.hasOneUse()) { 37532 SDValue N10 = N1.getOperand(0); 37533 if (N10.getOpcode() == ISD::LOAD && 37534 N10.hasOneUse() && 37535 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 37536 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 37537 SDValue Chain10 = N10.getOperand(0); 37538 if (Predicate_unindexedload(N10.getNode())) { 37539 37540 // Pattern: (st:isVoid (sube:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (imm:i8):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37541 // Emits: (SBB8mi:isVoid addr:iPTR:$dst, (imm:i8):$src2) 37542 // Pattern complexity = 50 cost = 1 size = 3 37543 if (Predicate_load(N10.getNode()) && 37544 Predicate_loadi8(N10.getNode())) { 37545 SDValue N101 = N10.getOperand(1); 37546 SDValue CPTmpN101_0; 37547 SDValue CPTmpN101_1; 37548 SDValue CPTmpN101_2; 37549 SDValue CPTmpN101_3; 37550 SDValue CPTmpN101_4; 37551 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37552 SDValue N11 = N1.getOperand(1); 37553 if (N11.getOpcode() == ISD::Constant) { 37554 SDValue N2 = N.getOperand(2); 37555 if (N101 == N2 && 37556 N1.getNode()->getValueType(0) == MVT::i8) { 37557 SDNode *Result = Emit_186(N, X86::SBB8mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37558 return Result; 37559 } 37560 } 37561 } 37562 } 37563 37564 // Pattern: (st:isVoid (sube:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i16):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37565 // Emits: (SBB16mi:isVoid addr:iPTR:$dst, (imm:i16):$src2) 37566 // Pattern complexity = 50 cost = 1 size = 3 37567 if (Predicate_loadi16(N10.getNode())) { 37568 SDValue N101 = N10.getOperand(1); 37569 SDValue CPTmpN101_0; 37570 SDValue CPTmpN101_1; 37571 SDValue CPTmpN101_2; 37572 SDValue CPTmpN101_3; 37573 SDValue CPTmpN101_4; 37574 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37575 SDValue N11 = N1.getOperand(1); 37576 if (N11.getOpcode() == ISD::Constant) { 37577 SDValue N2 = N.getOperand(2); 37578 if (N101 == N2 && 37579 N1.getNode()->getValueType(0) == MVT::i16) { 37580 SDNode *Result = Emit_187(N, X86::SBB16mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37581 return Result; 37582 } 37583 } 37584 } 37585 } 37586 37587 // Pattern: (st:isVoid (sube:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i32):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37588 // Emits: (SBB32mi:isVoid addr:iPTR:$dst, (imm:i32):$src2) 37589 // Pattern complexity = 50 cost = 1 size = 3 37590 if (Predicate_loadi32(N10.getNode())) { 37591 SDValue N101 = N10.getOperand(1); 37592 SDValue CPTmpN101_0; 37593 SDValue CPTmpN101_1; 37594 SDValue CPTmpN101_2; 37595 SDValue CPTmpN101_3; 37596 SDValue CPTmpN101_4; 37597 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37598 SDValue N11 = N1.getOperand(1); 37599 if (N11.getOpcode() == ISD::Constant) { 37600 SDValue N2 = N.getOperand(2); 37601 if (N101 == N2 && 37602 N1.getNode()->getValueType(0) == MVT::i32) { 37603 SDNode *Result = Emit_188(N, X86::SBB32mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37604 return Result; 37605 } 37606 } 37607 } 37608 } 37609 } 37610 } 37611 } 37612 37613 // Pattern: (st:isVoid (shl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37614 // Emits: (SHL64mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 37615 // Pattern complexity = 50 cost = 1 size = 3 37616 if (N1.getOpcode() == ISD::SHL && 37617 N1.hasOneUse()) { 37618 SDValue N10 = N1.getOperand(0); 37619 if (N10.getOpcode() == ISD::LOAD && 37620 N10.hasOneUse() && 37621 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 37622 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 37623 SDValue Chain10 = N10.getOperand(0); 37624 if (Predicate_unindexedload(N10.getNode()) && 37625 Predicate_load(N10.getNode()) && 37626 Predicate_loadi64(N10.getNode())) { 37627 SDValue N101 = N10.getOperand(1); 37628 SDValue CPTmpN101_0; 37629 SDValue CPTmpN101_1; 37630 SDValue CPTmpN101_2; 37631 SDValue CPTmpN101_3; 37632 SDValue CPTmpN101_4; 37633 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37634 SDValue N11 = N1.getOperand(1); 37635 if (N11.getOpcode() == ISD::Constant) { 37636 SDValue N2 = N.getOperand(2); 37637 if (N101 == N2 && 37638 N1.getNode()->getValueType(0) == MVT::i64 && 37639 N11.getNode()->getValueType(0) == MVT::i8) { 37640 SDNode *Result = Emit_182(N, X86::SHL64mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37641 return Result; 37642 } 37643 } 37644 } 37645 } 37646 } 37647 } 37648 37649 // Pattern: (st:isVoid (srl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37650 // Emits: (SHR64mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 37651 // Pattern complexity = 50 cost = 1 size = 3 37652 if (N1.getOpcode() == ISD::SRL && 37653 N1.hasOneUse()) { 37654 SDValue N10 = N1.getOperand(0); 37655 if (N10.getOpcode() == ISD::LOAD && 37656 N10.hasOneUse() && 37657 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 37658 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 37659 SDValue Chain10 = N10.getOperand(0); 37660 if (Predicate_unindexedload(N10.getNode()) && 37661 Predicate_load(N10.getNode()) && 37662 Predicate_loadi64(N10.getNode())) { 37663 SDValue N101 = N10.getOperand(1); 37664 SDValue CPTmpN101_0; 37665 SDValue CPTmpN101_1; 37666 SDValue CPTmpN101_2; 37667 SDValue CPTmpN101_3; 37668 SDValue CPTmpN101_4; 37669 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37670 SDValue N11 = N1.getOperand(1); 37671 if (N11.getOpcode() == ISD::Constant) { 37672 SDValue N2 = N.getOperand(2); 37673 if (N101 == N2 && 37674 N1.getNode()->getValueType(0) == MVT::i64 && 37675 N11.getNode()->getValueType(0) == MVT::i8) { 37676 SDNode *Result = Emit_182(N, X86::SHR64mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37677 return Result; 37678 } 37679 } 37680 } 37681 } 37682 } 37683 } 37684 37685 // Pattern: (st:isVoid (sra:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37686 // Emits: (SAR64mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 37687 // Pattern complexity = 50 cost = 1 size = 3 37688 if (N1.getOpcode() == ISD::SRA && 37689 N1.hasOneUse()) { 37690 SDValue N10 = N1.getOperand(0); 37691 if (N10.getOpcode() == ISD::LOAD && 37692 N10.hasOneUse() && 37693 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 37694 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 37695 SDValue Chain10 = N10.getOperand(0); 37696 if (Predicate_unindexedload(N10.getNode()) && 37697 Predicate_load(N10.getNode()) && 37698 Predicate_loadi64(N10.getNode())) { 37699 SDValue N101 = N10.getOperand(1); 37700 SDValue CPTmpN101_0; 37701 SDValue CPTmpN101_1; 37702 SDValue CPTmpN101_2; 37703 SDValue CPTmpN101_3; 37704 SDValue CPTmpN101_4; 37705 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37706 SDValue N11 = N1.getOperand(1); 37707 if (N11.getOpcode() == ISD::Constant) { 37708 SDValue N2 = N.getOperand(2); 37709 if (N101 == N2 && 37710 N1.getNode()->getValueType(0) == MVT::i64 && 37711 N11.getNode()->getValueType(0) == MVT::i8) { 37712 SDNode *Result = Emit_182(N, X86::SAR64mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37713 return Result; 37714 } 37715 } 37716 } 37717 } 37718 } 37719 } 37720 37721 // Pattern: (st:isVoid (rotl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37722 // Emits: (ROL64mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 37723 // Pattern complexity = 50 cost = 1 size = 3 37724 if (N1.getOpcode() == ISD::ROTL && 37725 N1.hasOneUse()) { 37726 SDValue N10 = N1.getOperand(0); 37727 if (N10.getOpcode() == ISD::LOAD && 37728 N10.hasOneUse() && 37729 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 37730 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 37731 SDValue Chain10 = N10.getOperand(0); 37732 if (Predicate_unindexedload(N10.getNode()) && 37733 Predicate_load(N10.getNode()) && 37734 Predicate_loadi64(N10.getNode())) { 37735 SDValue N101 = N10.getOperand(1); 37736 SDValue CPTmpN101_0; 37737 SDValue CPTmpN101_1; 37738 SDValue CPTmpN101_2; 37739 SDValue CPTmpN101_3; 37740 SDValue CPTmpN101_4; 37741 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37742 SDValue N11 = N1.getOperand(1); 37743 if (N11.getOpcode() == ISD::Constant) { 37744 SDValue N2 = N.getOperand(2); 37745 if (N101 == N2 && 37746 N1.getNode()->getValueType(0) == MVT::i64 && 37747 N11.getNode()->getValueType(0) == MVT::i8) { 37748 SDNode *Result = Emit_182(N, X86::ROL64mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37749 return Result; 37750 } 37751 } 37752 } 37753 } 37754 } 37755 } 37756 37757 // Pattern: (st:isVoid (rotr:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i8):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37758 // Emits: (ROR64mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 37759 // Pattern complexity = 50 cost = 1 size = 3 37760 if (N1.getOpcode() == ISD::ROTR && 37761 N1.hasOneUse()) { 37762 SDValue N10 = N1.getOperand(0); 37763 if (N10.getOpcode() == ISD::LOAD && 37764 N10.hasOneUse() && 37765 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 37766 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 37767 SDValue Chain10 = N10.getOperand(0); 37768 if (Predicate_unindexedload(N10.getNode()) && 37769 Predicate_load(N10.getNode()) && 37770 Predicate_loadi64(N10.getNode())) { 37771 SDValue N101 = N10.getOperand(1); 37772 SDValue CPTmpN101_0; 37773 SDValue CPTmpN101_1; 37774 SDValue CPTmpN101_2; 37775 SDValue CPTmpN101_3; 37776 SDValue CPTmpN101_4; 37777 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37778 SDValue N11 = N1.getOperand(1); 37779 if (N11.getOpcode() == ISD::Constant) { 37780 SDValue N2 = N.getOperand(2); 37781 if (N101 == N2 && 37782 N1.getNode()->getValueType(0) == MVT::i64 && 37783 N11.getNode()->getValueType(0) == MVT::i8) { 37784 SDNode *Result = Emit_182(N, X86::ROR64mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37785 return Result; 37786 } 37787 } 37788 } 37789 } 37790 } 37791 } 37792 37793 // Pattern: (st:isVoid (X86shld:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, (imm:i8):$src3), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37794 // Emits: (SHLD64mri8:isVoid addr:iPTR:$dst, GR64:i64:$src2, (imm:i8):$src3) 37795 // Pattern complexity = 50 cost = 1 size = 3 37796 if (N1.getOpcode() == X86ISD::SHLD && 37797 N1.hasOneUse()) { 37798 SDValue N10 = N1.getOperand(0); 37799 if (N10.getOpcode() == ISD::LOAD && 37800 N10.hasOneUse() && 37801 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 37802 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 37803 SDValue Chain10 = N10.getOperand(0); 37804 if (Predicate_unindexedload(N10.getNode()) && 37805 Predicate_load(N10.getNode()) && 37806 Predicate_loadi64(N10.getNode())) { 37807 SDValue N101 = N10.getOperand(1); 37808 SDValue CPTmpN101_0; 37809 SDValue CPTmpN101_1; 37810 SDValue CPTmpN101_2; 37811 SDValue CPTmpN101_3; 37812 SDValue CPTmpN101_4; 37813 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37814 SDValue N11 = N1.getOperand(1); 37815 SDValue N12 = N1.getOperand(2); 37816 if (N12.getOpcode() == ISD::Constant) { 37817 SDValue N2 = N.getOperand(2); 37818 if (N101 == N2 && 37819 N1.getNode()->getValueType(0) == MVT::i64 && 37820 N12.getNode()->getValueType(0) == MVT::i8) { 37821 SDNode *Result = Emit_184(N, X86::SHLD64mri8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37822 return Result; 37823 } 37824 } 37825 } 37826 } 37827 } 37828 } 37829 37830 // Pattern: (st:isVoid (X86shrd:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, (imm:i8):$src3), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37831 // Emits: (SHRD64mri8:isVoid addr:iPTR:$dst, GR64:i64:$src2, (imm:i8):$src3) 37832 // Pattern complexity = 50 cost = 1 size = 3 37833 if (N1.getOpcode() == X86ISD::SHRD && 37834 N1.hasOneUse()) { 37835 SDValue N10 = N1.getOperand(0); 37836 if (N10.getOpcode() == ISD::LOAD && 37837 N10.hasOneUse() && 37838 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 37839 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 37840 SDValue Chain10 = N10.getOperand(0); 37841 if (Predicate_unindexedload(N10.getNode()) && 37842 Predicate_load(N10.getNode()) && 37843 Predicate_loadi64(N10.getNode())) { 37844 SDValue N101 = N10.getOperand(1); 37845 SDValue CPTmpN101_0; 37846 SDValue CPTmpN101_1; 37847 SDValue CPTmpN101_2; 37848 SDValue CPTmpN101_3; 37849 SDValue CPTmpN101_4; 37850 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37851 SDValue N11 = N1.getOperand(1); 37852 SDValue N12 = N1.getOperand(2); 37853 if (N12.getOpcode() == ISD::Constant) { 37854 SDValue N2 = N.getOperand(2); 37855 if (N101 == N2 && 37856 N1.getNode()->getValueType(0) == MVT::i64 && 37857 N12.getNode()->getValueType(0) == MVT::i8) { 37858 SDNode *Result = Emit_184(N, X86::SHRD64mri8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37859 return Result; 37860 } 37861 } 37862 } 37863 } 37864 } 37865 } 37866 if (N1.getOpcode() == X86ISD::ADD && 37867 N1.hasOneUse()) { 37868 SDValue N10 = N1.getOperand(0); 37869 if (N10.getOpcode() == ISD::LOAD && 37870 N10.hasOneUse() && 37871 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 37872 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 37873 SDValue Chain10 = N10.getOperand(0); 37874 if (Predicate_unindexedload(N10.getNode())) { 37875 37876 // Pattern: (st:isVoid (X86add_flag:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (imm:i8):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37877 // Emits: (ADD8mi:isVoid addr:iPTR:$dst, (imm:i8):$src2) 37878 // Pattern complexity = 50 cost = 1 size = 3 37879 if (Predicate_load(N10.getNode()) && 37880 Predicate_loadi8(N10.getNode())) { 37881 SDValue N101 = N10.getOperand(1); 37882 SDValue CPTmpN101_0; 37883 SDValue CPTmpN101_1; 37884 SDValue CPTmpN101_2; 37885 SDValue CPTmpN101_3; 37886 SDValue CPTmpN101_4; 37887 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37888 SDValue N11 = N1.getOperand(1); 37889 if (N11.getOpcode() == ISD::Constant) { 37890 SDValue N2 = N.getOperand(2); 37891 if (N101 == N2 && 37892 N1.getNode()->getValueType(0) == MVT::i8) { 37893 SDNode *Result = Emit_178(N, X86::ADD8mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37894 return Result; 37895 } 37896 } 37897 } 37898 } 37899 37900 // Pattern: (st:isVoid (X86add_flag:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i16):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37901 // Emits: (ADD16mi:isVoid addr:iPTR:$dst, (imm:i16):$src2) 37902 // Pattern complexity = 50 cost = 1 size = 3 37903 if (Predicate_loadi16(N10.getNode())) { 37904 SDValue N101 = N10.getOperand(1); 37905 SDValue CPTmpN101_0; 37906 SDValue CPTmpN101_1; 37907 SDValue CPTmpN101_2; 37908 SDValue CPTmpN101_3; 37909 SDValue CPTmpN101_4; 37910 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37911 SDValue N11 = N1.getOperand(1); 37912 if (N11.getOpcode() == ISD::Constant) { 37913 SDValue N2 = N.getOperand(2); 37914 if (N101 == N2 && 37915 N1.getNode()->getValueType(0) == MVT::i16) { 37916 SDNode *Result = Emit_179(N, X86::ADD16mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37917 return Result; 37918 } 37919 } 37920 } 37921 } 37922 37923 // Pattern: (st:isVoid (X86add_flag:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i32):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37924 // Emits: (ADD32mi:isVoid addr:iPTR:$dst, (imm:i32):$src2) 37925 // Pattern complexity = 50 cost = 1 size = 3 37926 if (Predicate_loadi32(N10.getNode())) { 37927 SDValue N101 = N10.getOperand(1); 37928 SDValue CPTmpN101_0; 37929 SDValue CPTmpN101_1; 37930 SDValue CPTmpN101_2; 37931 SDValue CPTmpN101_3; 37932 SDValue CPTmpN101_4; 37933 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37934 SDValue N11 = N1.getOperand(1); 37935 if (N11.getOpcode() == ISD::Constant) { 37936 SDValue N2 = N.getOperand(2); 37937 if (N101 == N2 && 37938 N1.getNode()->getValueType(0) == MVT::i32) { 37939 SDNode *Result = Emit_180(N, X86::ADD32mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37940 return Result; 37941 } 37942 } 37943 } 37944 } 37945 } 37946 } 37947 } 37948 if (N1.getOpcode() == X86ISD::SUB && 37949 N1.hasOneUse()) { 37950 SDValue N10 = N1.getOperand(0); 37951 if (N10.getOpcode() == ISD::LOAD && 37952 N10.hasOneUse() && 37953 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 37954 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 37955 SDValue Chain10 = N10.getOperand(0); 37956 if (Predicate_unindexedload(N10.getNode())) { 37957 37958 // Pattern: (st:isVoid (X86sub_flag:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (imm:i8):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37959 // Emits: (SUB8mi:isVoid addr:iPTR:$dst, (imm:i8):$src2) 37960 // Pattern complexity = 50 cost = 1 size = 3 37961 if (Predicate_load(N10.getNode()) && 37962 Predicate_loadi8(N10.getNode())) { 37963 SDValue N101 = N10.getOperand(1); 37964 SDValue CPTmpN101_0; 37965 SDValue CPTmpN101_1; 37966 SDValue CPTmpN101_2; 37967 SDValue CPTmpN101_3; 37968 SDValue CPTmpN101_4; 37969 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37970 SDValue N11 = N1.getOperand(1); 37971 if (N11.getOpcode() == ISD::Constant) { 37972 SDValue N2 = N.getOperand(2); 37973 if (N101 == N2 && 37974 N1.getNode()->getValueType(0) == MVT::i8) { 37975 SDNode *Result = Emit_178(N, X86::SUB8mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37976 return Result; 37977 } 37978 } 37979 } 37980 } 37981 37982 // Pattern: (st:isVoid (X86sub_flag:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i16):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 37983 // Emits: (SUB16mi:isVoid addr:iPTR:$dst, (imm:i16):$src2) 37984 // Pattern complexity = 50 cost = 1 size = 3 37985 if (Predicate_loadi16(N10.getNode())) { 37986 SDValue N101 = N10.getOperand(1); 37987 SDValue CPTmpN101_0; 37988 SDValue CPTmpN101_1; 37989 SDValue CPTmpN101_2; 37990 SDValue CPTmpN101_3; 37991 SDValue CPTmpN101_4; 37992 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 37993 SDValue N11 = N1.getOperand(1); 37994 if (N11.getOpcode() == ISD::Constant) { 37995 SDValue N2 = N.getOperand(2); 37996 if (N101 == N2 && 37997 N1.getNode()->getValueType(0) == MVT::i16) { 37998 SDNode *Result = Emit_179(N, X86::SUB16mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 37999 return Result; 38000 } 38001 } 38002 } 38003 } 38004 38005 // Pattern: (st:isVoid (X86sub_flag:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i32):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38006 // Emits: (SUB32mi:isVoid addr:iPTR:$dst, (imm:i32):$src2) 38007 // Pattern complexity = 50 cost = 1 size = 3 38008 if (Predicate_loadi32(N10.getNode())) { 38009 SDValue N101 = N10.getOperand(1); 38010 SDValue CPTmpN101_0; 38011 SDValue CPTmpN101_1; 38012 SDValue CPTmpN101_2; 38013 SDValue CPTmpN101_3; 38014 SDValue CPTmpN101_4; 38015 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38016 SDValue N11 = N1.getOperand(1); 38017 if (N11.getOpcode() == ISD::Constant) { 38018 SDValue N2 = N.getOperand(2); 38019 if (N101 == N2 && 38020 N1.getNode()->getValueType(0) == MVT::i32) { 38021 SDNode *Result = Emit_180(N, X86::SUB32mi, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38022 return Result; 38023 } 38024 } 38025 } 38026 } 38027 } 38028 } 38029 } 38030 } 38031 } 38032 38033 // Pattern: (st:isVoid (vector_shuffle:v4f32 (ld:v4f32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>>, VR128:v4f32:$src2)<<P:Predicate_movlp>>, addr:iPTR:$src1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38034 // Emits: (MOVLPSmr:isVoid addr:iPTR:$src1, VR128:v16i8:$src2) 38035 // Pattern complexity = 48 cost = 1 size = 3 38036 if ((Subtarget->hasSSE1())) { 38037 SDValue Chain = N.getOperand(0); 38038 if (Predicate_unindexedstore(N.getNode()) && 38039 Predicate_store(N.getNode())) { 38040 SDValue N1 = N.getOperand(1); 38041 if (N1.getOpcode() == ISD::VECTOR_SHUFFLE && 38042 N1.hasOneUse() && 38043 Predicate_movlp(N1.getNode())) { 38044 SDValue N10 = N1.getOperand(0); 38045 if (N10.getOpcode() == ISD::LOAD && 38046 N10.hasOneUse() && 38047 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38048 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38049 SDValue Chain10 = N10.getOperand(0); 38050 if (Predicate_unindexedload(N10.getNode()) && 38051 Predicate_load(N10.getNode())) { 38052 SDValue N101 = N10.getOperand(1); 38053 SDValue CPTmpN101_0; 38054 SDValue CPTmpN101_1; 38055 SDValue CPTmpN101_2; 38056 SDValue CPTmpN101_3; 38057 SDValue CPTmpN101_4; 38058 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38059 SDValue N11 = N1.getOperand(1); 38060 SDValue N2 = N.getOperand(2); 38061 if (N101 == N2 && 38062 N1.getNode()->getValueType(0) == MVT::v4f32) { 38063 SDNode *Result = Emit_214(N, X86::MOVLPSmr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38064 return Result; 38065 } 38066 } 38067 } 38068 } 38069 } 38070 } 38071 } 38072 38073 // Pattern: (st:isVoid (vector_shuffle:v2f64 (ld:v2f64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>>, VR128:v2f64:$src2)<<P:Predicate_movlp>>, addr:iPTR:$src1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38074 // Emits: (MOVLPDmr:isVoid addr:iPTR:$src1, VR128:v16i8:$src2) 38075 // Pattern complexity = 48 cost = 1 size = 3 38076 if ((Subtarget->hasSSE2())) { 38077 SDValue Chain = N.getOperand(0); 38078 if (Predicate_unindexedstore(N.getNode()) && 38079 Predicate_store(N.getNode())) { 38080 SDValue N1 = N.getOperand(1); 38081 if (N1.getOpcode() == ISD::VECTOR_SHUFFLE && 38082 N1.hasOneUse() && 38083 Predicate_movlp(N1.getNode())) { 38084 SDValue N10 = N1.getOperand(0); 38085 if (N10.getOpcode() == ISD::LOAD && 38086 N10.hasOneUse() && 38087 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38088 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38089 SDValue Chain10 = N10.getOperand(0); 38090 if (Predicate_unindexedload(N10.getNode()) && 38091 Predicate_load(N10.getNode())) { 38092 SDValue N101 = N10.getOperand(1); 38093 SDValue CPTmpN101_0; 38094 SDValue CPTmpN101_1; 38095 SDValue CPTmpN101_2; 38096 SDValue CPTmpN101_3; 38097 SDValue CPTmpN101_4; 38098 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38099 SDValue N11 = N1.getOperand(1); 38100 SDValue N2 = N.getOperand(2); 38101 if (N101 == N2 && 38102 N1.getNode()->getValueType(0) == MVT::v2f64) { 38103 SDNode *Result = Emit_214(N, X86::MOVLPDmr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38104 return Result; 38105 } 38106 } 38107 } 38108 } 38109 } 38110 } 38111 } 38112 38113 // Pattern: (st:isVoid (vector_shuffle:v4f32 (ld:v4f32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>>, VR128:v4f32:$src2)<<P:Predicate_movhp>>, addr:iPTR:$src1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38114 // Emits: (MOVHPSmr:isVoid addr:iPTR:$src1, VR128:v16i8:$src2) 38115 // Pattern complexity = 48 cost = 1 size = 3 38116 if ((Subtarget->hasSSE1())) { 38117 SDValue Chain = N.getOperand(0); 38118 if (Predicate_unindexedstore(N.getNode()) && 38119 Predicate_store(N.getNode())) { 38120 SDValue N1 = N.getOperand(1); 38121 if (N1.getOpcode() == ISD::VECTOR_SHUFFLE && 38122 N1.hasOneUse() && 38123 Predicate_movhp(N1.getNode())) { 38124 SDValue N10 = N1.getOperand(0); 38125 if (N10.getOpcode() == ISD::LOAD && 38126 N10.hasOneUse() && 38127 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38128 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38129 SDValue Chain10 = N10.getOperand(0); 38130 if (Predicate_unindexedload(N10.getNode()) && 38131 Predicate_load(N10.getNode())) { 38132 SDValue N101 = N10.getOperand(1); 38133 SDValue CPTmpN101_0; 38134 SDValue CPTmpN101_1; 38135 SDValue CPTmpN101_2; 38136 SDValue CPTmpN101_3; 38137 SDValue CPTmpN101_4; 38138 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38139 SDValue N11 = N1.getOperand(1); 38140 SDValue N2 = N.getOperand(2); 38141 if (N101 == N2 && 38142 N1.getNode()->getValueType(0) == MVT::v4f32) { 38143 SDNode *Result = Emit_214(N, X86::MOVHPSmr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38144 return Result; 38145 } 38146 } 38147 } 38148 } 38149 } 38150 } 38151 } 38152 if ((Subtarget->hasSSE2())) { 38153 SDValue Chain = N.getOperand(0); 38154 if (Predicate_unindexedstore(N.getNode()) && 38155 Predicate_store(N.getNode())) { 38156 SDValue N1 = N.getOperand(1); 38157 if (N1.getOpcode() == ISD::VECTOR_SHUFFLE && 38158 N1.hasOneUse()) { 38159 38160 // Pattern: (st:isVoid (vector_shuffle:v2f64 (ld:v2f64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>>, VR128:v2f64:$src2)<<P:Predicate_movhp>>, addr:iPTR:$src1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38161 // Emits: (MOVHPDmr:isVoid addr:iPTR:$src1, VR128:v16i8:$src2) 38162 // Pattern complexity = 48 cost = 1 size = 3 38163 if (Predicate_movhp(N1.getNode())) { 38164 SDValue N10 = N1.getOperand(0); 38165 if (N10.getOpcode() == ISD::LOAD && 38166 N10.hasOneUse() && 38167 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38168 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38169 SDValue Chain10 = N10.getOperand(0); 38170 if (Predicate_unindexedload(N10.getNode()) && 38171 Predicate_load(N10.getNode())) { 38172 SDValue N101 = N10.getOperand(1); 38173 SDValue CPTmpN101_0; 38174 SDValue CPTmpN101_1; 38175 SDValue CPTmpN101_2; 38176 SDValue CPTmpN101_3; 38177 SDValue CPTmpN101_4; 38178 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38179 SDValue N11 = N1.getOperand(1); 38180 SDValue N2 = N.getOperand(2); 38181 if (N101 == N2 && 38182 N1.getNode()->getValueType(0) == MVT::v2f64) { 38183 SDNode *Result = Emit_214(N, X86::MOVHPDmr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38184 return Result; 38185 } 38186 } 38187 } 38188 } 38189 } 38190 38191 // Pattern: (st:isVoid (vector_shuffle:v2i64 (ld:v2i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>>, VR128:v2i64:$src2)<<P:Predicate_movlp>>, addr:iPTR:$src1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38192 // Emits: (MOVLPDmr:isVoid addr:iPTR:$src1, VR128:v16i8:$src2) 38193 // Pattern complexity = 48 cost = 1 size = 3 38194 if (Predicate_movlp(N1.getNode())) { 38195 SDValue N10 = N1.getOperand(0); 38196 if (N10.getOpcode() == ISD::LOAD && 38197 N10.hasOneUse() && 38198 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38199 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38200 SDValue Chain10 = N10.getOperand(0); 38201 if (Predicate_unindexedload(N10.getNode()) && 38202 Predicate_load(N10.getNode())) { 38203 SDValue N101 = N10.getOperand(1); 38204 SDValue CPTmpN101_0; 38205 SDValue CPTmpN101_1; 38206 SDValue CPTmpN101_2; 38207 SDValue CPTmpN101_3; 38208 SDValue CPTmpN101_4; 38209 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38210 SDValue N11 = N1.getOperand(1); 38211 SDValue N2 = N.getOperand(2); 38212 if (N101 == N2 && 38213 N1.getNode()->getValueType(0) == MVT::v2i64) { 38214 SDNode *Result = Emit_214(N, X86::MOVLPDmr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38215 return Result; 38216 } 38217 } 38218 } 38219 } 38220 } 38221 38222 // Pattern: (st:isVoid (vector_shuffle:v2i64 (ld:v2i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>>, VR128:v2i64:$src2)<<P:Predicate_movhp>>, addr:iPTR:$src1)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38223 // Emits: (MOVHPDmr:isVoid addr:iPTR:$src1, VR128:v16i8:$src2) 38224 // Pattern complexity = 48 cost = 1 size = 3 38225 if (Predicate_movhp(N1.getNode())) { 38226 SDValue N10 = N1.getOperand(0); 38227 if (N10.getOpcode() == ISD::LOAD && 38228 N10.hasOneUse() && 38229 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38230 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38231 SDValue Chain10 = N10.getOperand(0); 38232 if (Predicate_unindexedload(N10.getNode()) && 38233 Predicate_load(N10.getNode())) { 38234 SDValue N101 = N10.getOperand(1); 38235 SDValue CPTmpN101_0; 38236 SDValue CPTmpN101_1; 38237 SDValue CPTmpN101_2; 38238 SDValue CPTmpN101_3; 38239 SDValue CPTmpN101_4; 38240 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38241 SDValue N11 = N1.getOperand(1); 38242 SDValue N2 = N.getOperand(2); 38243 if (N101 == N2 && 38244 N1.getNode()->getValueType(0) == MVT::v2i64) { 38245 SDNode *Result = Emit_214(N, X86::MOVHPDmr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38246 return Result; 38247 } 38248 } 38249 } 38250 } 38251 } 38252 } 38253 } 38254 } 38255 { 38256 SDValue Chain = N.getOperand(0); 38257 if (Predicate_unindexedstore(N.getNode()) && 38258 Predicate_store(N.getNode())) { 38259 SDValue N1 = N.getOperand(1); 38260 38261 // Pattern: (st:isVoid (X86inc_flag:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38262 // Emits: (INC8m:isVoid addr:iPTR:$dst) 38263 // Pattern complexity = 47 cost = 1 size = 2 38264 if (N1.getOpcode() == X86ISD::INC && 38265 N1.hasOneUse()) { 38266 SDValue N10 = N1.getOperand(0); 38267 if (N10.getOpcode() == ISD::LOAD && 38268 N10.hasOneUse() && 38269 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38270 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38271 SDValue Chain10 = N10.getOperand(0); 38272 if (Predicate_unindexedload(N10.getNode()) && 38273 Predicate_load(N10.getNode()) && 38274 Predicate_loadi8(N10.getNode())) { 38275 SDValue N101 = N10.getOperand(1); 38276 SDValue CPTmpN101_0; 38277 SDValue CPTmpN101_1; 38278 SDValue CPTmpN101_2; 38279 SDValue CPTmpN101_3; 38280 SDValue CPTmpN101_4; 38281 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38282 SDValue N2 = N.getOperand(2); 38283 if (N101 == N2 && 38284 N1.getNode()->getValueType(0) == MVT::i8 && 38285 N10.getNode()->getValueType(0) == MVT::i8) { 38286 SDNode *Result = Emit_207(N, X86::INC8m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38287 return Result; 38288 } 38289 } 38290 } 38291 } 38292 } 38293 38294 // Pattern: (st:isVoid (X86dec_flag:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38295 // Emits: (DEC8m:isVoid addr:iPTR:$dst) 38296 // Pattern complexity = 47 cost = 1 size = 2 38297 if (N1.getOpcode() == X86ISD::DEC && 38298 N1.hasOneUse()) { 38299 SDValue N10 = N1.getOperand(0); 38300 if (N10.getOpcode() == ISD::LOAD && 38301 N10.hasOneUse() && 38302 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38303 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38304 SDValue Chain10 = N10.getOperand(0); 38305 if (Predicate_unindexedload(N10.getNode()) && 38306 Predicate_load(N10.getNode()) && 38307 Predicate_loadi8(N10.getNode())) { 38308 SDValue N101 = N10.getOperand(1); 38309 SDValue CPTmpN101_0; 38310 SDValue CPTmpN101_1; 38311 SDValue CPTmpN101_2; 38312 SDValue CPTmpN101_3; 38313 SDValue CPTmpN101_4; 38314 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38315 SDValue N2 = N.getOperand(2); 38316 if (N101 == N2 && 38317 N1.getNode()->getValueType(0) == MVT::i8 && 38318 N10.getNode()->getValueType(0) == MVT::i8) { 38319 SDNode *Result = Emit_207(N, X86::DEC8m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38320 return Result; 38321 } 38322 } 38323 } 38324 } 38325 } 38326 } 38327 } 38328 if ((!Subtarget->is64Bit())) { 38329 SDValue Chain = N.getOperand(0); 38330 if (Predicate_unindexedstore(N.getNode()) && 38331 Predicate_store(N.getNode())) { 38332 SDValue N1 = N.getOperand(1); 38333 38334 // Pattern: (st:isVoid (X86inc_flag:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38335 // Emits: (INC16m:isVoid addr:iPTR:$dst) 38336 // Pattern complexity = 47 cost = 1 size = 2 38337 if (N1.getOpcode() == X86ISD::INC && 38338 N1.hasOneUse()) { 38339 SDValue N10 = N1.getOperand(0); 38340 if (N10.getOpcode() == ISD::LOAD && 38341 N10.hasOneUse() && 38342 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38343 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38344 SDValue Chain10 = N10.getOperand(0); 38345 if (Predicate_unindexedload(N10.getNode()) && 38346 Predicate_loadi16(N10.getNode())) { 38347 SDValue N101 = N10.getOperand(1); 38348 SDValue CPTmpN101_0; 38349 SDValue CPTmpN101_1; 38350 SDValue CPTmpN101_2; 38351 SDValue CPTmpN101_3; 38352 SDValue CPTmpN101_4; 38353 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38354 SDValue N2 = N.getOperand(2); 38355 if (N101 == N2 && 38356 N1.getNode()->getValueType(0) == MVT::i16 && 38357 N10.getNode()->getValueType(0) == MVT::i16) { 38358 SDNode *Result = Emit_207(N, X86::INC16m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38359 return Result; 38360 } 38361 } 38362 } 38363 } 38364 } 38365 38366 // Pattern: (st:isVoid (X86dec_flag:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38367 // Emits: (DEC16m:isVoid addr:iPTR:$dst) 38368 // Pattern complexity = 47 cost = 1 size = 2 38369 if (N1.getOpcode() == X86ISD::DEC && 38370 N1.hasOneUse()) { 38371 SDValue N10 = N1.getOperand(0); 38372 if (N10.getOpcode() == ISD::LOAD && 38373 N10.hasOneUse() && 38374 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38375 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38376 SDValue Chain10 = N10.getOperand(0); 38377 if (Predicate_unindexedload(N10.getNode()) && 38378 Predicate_loadi16(N10.getNode())) { 38379 SDValue N101 = N10.getOperand(1); 38380 SDValue CPTmpN101_0; 38381 SDValue CPTmpN101_1; 38382 SDValue CPTmpN101_2; 38383 SDValue CPTmpN101_3; 38384 SDValue CPTmpN101_4; 38385 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38386 SDValue N2 = N.getOperand(2); 38387 if (N101 == N2 && 38388 N1.getNode()->getValueType(0) == MVT::i16 && 38389 N10.getNode()->getValueType(0) == MVT::i16) { 38390 SDNode *Result = Emit_207(N, X86::DEC16m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38391 return Result; 38392 } 38393 } 38394 } 38395 } 38396 } 38397 38398 // Pattern: (st:isVoid (X86inc_flag:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38399 // Emits: (INC32m:isVoid addr:iPTR:$dst) 38400 // Pattern complexity = 47 cost = 1 size = 2 38401 if (N1.getOpcode() == X86ISD::INC && 38402 N1.hasOneUse()) { 38403 SDValue N10 = N1.getOperand(0); 38404 if (N10.getOpcode() == ISD::LOAD && 38405 N10.hasOneUse() && 38406 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38407 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38408 SDValue Chain10 = N10.getOperand(0); 38409 if (Predicate_unindexedload(N10.getNode()) && 38410 Predicate_loadi32(N10.getNode())) { 38411 SDValue N101 = N10.getOperand(1); 38412 SDValue CPTmpN101_0; 38413 SDValue CPTmpN101_1; 38414 SDValue CPTmpN101_2; 38415 SDValue CPTmpN101_3; 38416 SDValue CPTmpN101_4; 38417 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38418 SDValue N2 = N.getOperand(2); 38419 if (N101 == N2 && 38420 N1.getNode()->getValueType(0) == MVT::i32 && 38421 N10.getNode()->getValueType(0) == MVT::i32) { 38422 SDNode *Result = Emit_207(N, X86::INC32m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38423 return Result; 38424 } 38425 } 38426 } 38427 } 38428 } 38429 38430 // Pattern: (st:isVoid (X86dec_flag:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38431 // Emits: (DEC32m:isVoid addr:iPTR:$dst) 38432 // Pattern complexity = 47 cost = 1 size = 2 38433 if (N1.getOpcode() == X86ISD::DEC && 38434 N1.hasOneUse()) { 38435 SDValue N10 = N1.getOperand(0); 38436 if (N10.getOpcode() == ISD::LOAD && 38437 N10.hasOneUse() && 38438 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38439 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38440 SDValue Chain10 = N10.getOperand(0); 38441 if (Predicate_unindexedload(N10.getNode()) && 38442 Predicate_loadi32(N10.getNode())) { 38443 SDValue N101 = N10.getOperand(1); 38444 SDValue CPTmpN101_0; 38445 SDValue CPTmpN101_1; 38446 SDValue CPTmpN101_2; 38447 SDValue CPTmpN101_3; 38448 SDValue CPTmpN101_4; 38449 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38450 SDValue N2 = N.getOperand(2); 38451 if (N101 == N2 && 38452 N1.getNode()->getValueType(0) == MVT::i32 && 38453 N10.getNode()->getValueType(0) == MVT::i32) { 38454 SDNode *Result = Emit_207(N, X86::DEC32m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38455 return Result; 38456 } 38457 } 38458 } 38459 } 38460 } 38461 } 38462 } 38463 if ((Subtarget->is64Bit())) { 38464 SDValue Chain = N.getOperand(0); 38465 if (Predicate_unindexedstore(N.getNode()) && 38466 Predicate_store(N.getNode())) { 38467 SDValue N1 = N.getOperand(1); 38468 38469 // Pattern: (st:isVoid (X86inc_flag:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38470 // Emits: (INC64_16m:isVoid addr:iPTR:$dst) 38471 // Pattern complexity = 47 cost = 1 size = 2 38472 if (N1.getOpcode() == X86ISD::INC && 38473 N1.hasOneUse()) { 38474 SDValue N10 = N1.getOperand(0); 38475 if (N10.getOpcode() == ISD::LOAD && 38476 N10.hasOneUse() && 38477 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38478 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38479 SDValue Chain10 = N10.getOperand(0); 38480 if (Predicate_unindexedload(N10.getNode()) && 38481 Predicate_loadi16(N10.getNode())) { 38482 SDValue N101 = N10.getOperand(1); 38483 SDValue CPTmpN101_0; 38484 SDValue CPTmpN101_1; 38485 SDValue CPTmpN101_2; 38486 SDValue CPTmpN101_3; 38487 SDValue CPTmpN101_4; 38488 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38489 SDValue N2 = N.getOperand(2); 38490 if (N101 == N2 && 38491 N1.getNode()->getValueType(0) == MVT::i16 && 38492 N10.getNode()->getValueType(0) == MVT::i16) { 38493 SDNode *Result = Emit_207(N, X86::INC64_16m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38494 return Result; 38495 } 38496 } 38497 } 38498 } 38499 } 38500 38501 // Pattern: (st:isVoid (X86dec_flag:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38502 // Emits: (DEC64_16m:isVoid addr:iPTR:$dst) 38503 // Pattern complexity = 47 cost = 1 size = 2 38504 if (N1.getOpcode() == X86ISD::DEC && 38505 N1.hasOneUse()) { 38506 SDValue N10 = N1.getOperand(0); 38507 if (N10.getOpcode() == ISD::LOAD && 38508 N10.hasOneUse() && 38509 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38510 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38511 SDValue Chain10 = N10.getOperand(0); 38512 if (Predicate_unindexedload(N10.getNode()) && 38513 Predicate_loadi16(N10.getNode())) { 38514 SDValue N101 = N10.getOperand(1); 38515 SDValue CPTmpN101_0; 38516 SDValue CPTmpN101_1; 38517 SDValue CPTmpN101_2; 38518 SDValue CPTmpN101_3; 38519 SDValue CPTmpN101_4; 38520 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38521 SDValue N2 = N.getOperand(2); 38522 if (N101 == N2 && 38523 N1.getNode()->getValueType(0) == MVT::i16 && 38524 N10.getNode()->getValueType(0) == MVT::i16) { 38525 SDNode *Result = Emit_207(N, X86::DEC64_16m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38526 return Result; 38527 } 38528 } 38529 } 38530 } 38531 } 38532 38533 // Pattern: (st:isVoid (X86inc_flag:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38534 // Emits: (INC64_32m:isVoid addr:iPTR:$dst) 38535 // Pattern complexity = 47 cost = 1 size = 2 38536 if (N1.getOpcode() == X86ISD::INC && 38537 N1.hasOneUse()) { 38538 SDValue N10 = N1.getOperand(0); 38539 if (N10.getOpcode() == ISD::LOAD && 38540 N10.hasOneUse() && 38541 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38542 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38543 SDValue Chain10 = N10.getOperand(0); 38544 if (Predicate_unindexedload(N10.getNode()) && 38545 Predicate_loadi32(N10.getNode())) { 38546 SDValue N101 = N10.getOperand(1); 38547 SDValue CPTmpN101_0; 38548 SDValue CPTmpN101_1; 38549 SDValue CPTmpN101_2; 38550 SDValue CPTmpN101_3; 38551 SDValue CPTmpN101_4; 38552 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38553 SDValue N2 = N.getOperand(2); 38554 if (N101 == N2 && 38555 N1.getNode()->getValueType(0) == MVT::i32 && 38556 N10.getNode()->getValueType(0) == MVT::i32) { 38557 SDNode *Result = Emit_207(N, X86::INC64_32m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38558 return Result; 38559 } 38560 } 38561 } 38562 } 38563 } 38564 38565 // Pattern: (st:isVoid (X86dec_flag:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38566 // Emits: (DEC64_32m:isVoid addr:iPTR:$dst) 38567 // Pattern complexity = 47 cost = 1 size = 2 38568 if (N1.getOpcode() == X86ISD::DEC && 38569 N1.hasOneUse()) { 38570 SDValue N10 = N1.getOperand(0); 38571 if (N10.getOpcode() == ISD::LOAD && 38572 N10.hasOneUse() && 38573 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38574 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38575 SDValue Chain10 = N10.getOperand(0); 38576 if (Predicate_unindexedload(N10.getNode()) && 38577 Predicate_loadi32(N10.getNode())) { 38578 SDValue N101 = N10.getOperand(1); 38579 SDValue CPTmpN101_0; 38580 SDValue CPTmpN101_1; 38581 SDValue CPTmpN101_2; 38582 SDValue CPTmpN101_3; 38583 SDValue CPTmpN101_4; 38584 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38585 SDValue N2 = N.getOperand(2); 38586 if (N101 == N2 && 38587 N1.getNode()->getValueType(0) == MVT::i32 && 38588 N10.getNode()->getValueType(0) == MVT::i32) { 38589 SDNode *Result = Emit_207(N, X86::DEC64_32m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38590 return Result; 38591 } 38592 } 38593 } 38594 } 38595 } 38596 } 38597 } 38598 SDValue Chain = N.getOperand(0); 38599 if (Predicate_unindexedstore(N.getNode()) && 38600 Predicate_store(N.getNode())) { 38601 SDValue N1 = N.getOperand(1); 38602 38603 // Pattern: (st:isVoid (X86inc_flag:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38604 // Emits: (INC64m:isVoid addr:iPTR:$dst) 38605 // Pattern complexity = 47 cost = 1 size = 2 38606 if (N1.getOpcode() == X86ISD::INC && 38607 N1.hasOneUse()) { 38608 SDValue N10 = N1.getOperand(0); 38609 if (N10.getOpcode() == ISD::LOAD && 38610 N10.hasOneUse() && 38611 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38612 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38613 SDValue Chain10 = N10.getOperand(0); 38614 if (Predicate_unindexedload(N10.getNode()) && 38615 Predicate_load(N10.getNode()) && 38616 Predicate_loadi64(N10.getNode())) { 38617 SDValue N101 = N10.getOperand(1); 38618 SDValue CPTmpN101_0; 38619 SDValue CPTmpN101_1; 38620 SDValue CPTmpN101_2; 38621 SDValue CPTmpN101_3; 38622 SDValue CPTmpN101_4; 38623 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38624 SDValue N2 = N.getOperand(2); 38625 if (N101 == N2 && 38626 N1.getNode()->getValueType(0) == MVT::i64 && 38627 N10.getNode()->getValueType(0) == MVT::i64) { 38628 SDNode *Result = Emit_207(N, X86::INC64m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38629 return Result; 38630 } 38631 } 38632 } 38633 } 38634 } 38635 38636 // Pattern: (st:isVoid (X86dec_flag:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38637 // Emits: (DEC64m:isVoid addr:iPTR:$dst) 38638 // Pattern complexity = 47 cost = 1 size = 2 38639 if (N1.getOpcode() == X86ISD::DEC && 38640 N1.hasOneUse()) { 38641 SDValue N10 = N1.getOperand(0); 38642 if (N10.getOpcode() == ISD::LOAD && 38643 N10.hasOneUse() && 38644 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38645 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38646 SDValue Chain10 = N10.getOperand(0); 38647 if (Predicate_unindexedload(N10.getNode()) && 38648 Predicate_load(N10.getNode()) && 38649 Predicate_loadi64(N10.getNode())) { 38650 SDValue N101 = N10.getOperand(1); 38651 SDValue CPTmpN101_0; 38652 SDValue CPTmpN101_1; 38653 SDValue CPTmpN101_2; 38654 SDValue CPTmpN101_3; 38655 SDValue CPTmpN101_4; 38656 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38657 SDValue N2 = N.getOperand(2); 38658 if (N101 == N2 && 38659 N1.getNode()->getValueType(0) == MVT::i64 && 38660 N10.getNode()->getValueType(0) == MVT::i64) { 38661 SDNode *Result = Emit_207(N, X86::DEC64m, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38662 return Result; 38663 } 38664 } 38665 } 38666 } 38667 } 38668 if (N1.getOpcode() == ISD::AND && 38669 N1.hasOneUse()) { 38670 SDValue N10 = N1.getOperand(0); 38671 if (N10.getOpcode() == ISD::LOAD && 38672 N10.hasOneUse() && 38673 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38674 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38675 SDValue Chain10 = N10.getOperand(0); 38676 if (Predicate_unindexedload(N10.getNode()) && 38677 Predicate_load(N10.getNode())) { 38678 SDValue N101 = N10.getOperand(1); 38679 SDValue CPTmpN101_0; 38680 SDValue CPTmpN101_1; 38681 SDValue CPTmpN101_2; 38682 SDValue CPTmpN101_3; 38683 SDValue CPTmpN101_4; 38684 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38685 SDValue N11 = N1.getOperand(1); 38686 SDValue N2 = N.getOperand(2); 38687 if (N101 == N2) { 38688 38689 // Pattern: (st:isVoid (and:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR8:i8:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38690 // Emits: (AND8mr:isVoid addr:iPTR:$dst, GR8:i8:$src) 38691 // Pattern complexity = 47 cost = 1 size = 3 38692 if (N1.getNode()->getValueType(0) == MVT::i8) { 38693 SDNode *Result = Emit_177(N, X86::AND8mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38694 return Result; 38695 } 38696 38697 // Pattern: (st:isVoid (and:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR16:i16:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38698 // Emits: (AND16mr:isVoid addr:iPTR:$dst, GR16:i16:$src) 38699 // Pattern complexity = 47 cost = 1 size = 3 38700 if (N1.getNode()->getValueType(0) == MVT::i16) { 38701 SDNode *Result = Emit_177(N, X86::AND16mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38702 return Result; 38703 } 38704 38705 // Pattern: (st:isVoid (and:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR32:i32:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38706 // Emits: (AND32mr:isVoid addr:iPTR:$dst, GR32:i32:$src) 38707 // Pattern complexity = 47 cost = 1 size = 3 38708 if (N1.getNode()->getValueType(0) == MVT::i32) { 38709 SDNode *Result = Emit_177(N, X86::AND32mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38710 return Result; 38711 } 38712 } 38713 } 38714 } 38715 } 38716 } 38717 if (N1.getOpcode() == ISD::OR && 38718 N1.hasOneUse()) { 38719 SDValue N10 = N1.getOperand(0); 38720 if (N10.getOpcode() == ISD::LOAD && 38721 N10.hasOneUse() && 38722 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38723 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38724 SDValue Chain10 = N10.getOperand(0); 38725 if (Predicate_unindexedload(N10.getNode()) && 38726 Predicate_load(N10.getNode())) { 38727 SDValue N101 = N10.getOperand(1); 38728 SDValue CPTmpN101_0; 38729 SDValue CPTmpN101_1; 38730 SDValue CPTmpN101_2; 38731 SDValue CPTmpN101_3; 38732 SDValue CPTmpN101_4; 38733 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38734 SDValue N11 = N1.getOperand(1); 38735 SDValue N2 = N.getOperand(2); 38736 if (N101 == N2) { 38737 38738 // Pattern: (st:isVoid (or:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR8:i8:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38739 // Emits: (OR8mr:isVoid addr:iPTR:$dst, GR8:i8:$src) 38740 // Pattern complexity = 47 cost = 1 size = 3 38741 if (N1.getNode()->getValueType(0) == MVT::i8) { 38742 SDNode *Result = Emit_177(N, X86::OR8mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38743 return Result; 38744 } 38745 38746 // Pattern: (st:isVoid (or:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR16:i16:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38747 // Emits: (OR16mr:isVoid addr:iPTR:$dst, GR16:i16:$src) 38748 // Pattern complexity = 47 cost = 1 size = 3 38749 if (N1.getNode()->getValueType(0) == MVT::i16) { 38750 SDNode *Result = Emit_177(N, X86::OR16mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38751 return Result; 38752 } 38753 38754 // Pattern: (st:isVoid (or:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR32:i32:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38755 // Emits: (OR32mr:isVoid addr:iPTR:$dst, GR32:i32:$src) 38756 // Pattern complexity = 47 cost = 1 size = 3 38757 if (N1.getNode()->getValueType(0) == MVT::i32) { 38758 SDNode *Result = Emit_177(N, X86::OR32mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38759 return Result; 38760 } 38761 } 38762 } 38763 } 38764 } 38765 } 38766 if (N1.getOpcode() == ISD::XOR && 38767 N1.hasOneUse()) { 38768 SDValue N10 = N1.getOperand(0); 38769 if (N10.getOpcode() == ISD::LOAD && 38770 N10.hasOneUse() && 38771 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38772 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38773 SDValue Chain10 = N10.getOperand(0); 38774 if (Predicate_unindexedload(N10.getNode()) && 38775 Predicate_load(N10.getNode())) { 38776 SDValue N101 = N10.getOperand(1); 38777 SDValue CPTmpN101_0; 38778 SDValue CPTmpN101_1; 38779 SDValue CPTmpN101_2; 38780 SDValue CPTmpN101_3; 38781 SDValue CPTmpN101_4; 38782 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38783 SDValue N11 = N1.getOperand(1); 38784 SDValue N2 = N.getOperand(2); 38785 if (N101 == N2) { 38786 38787 // Pattern: (st:isVoid (xor:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR8:i8:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38788 // Emits: (XOR8mr:isVoid addr:iPTR:$dst, GR8:i8:$src) 38789 // Pattern complexity = 47 cost = 1 size = 3 38790 if (N1.getNode()->getValueType(0) == MVT::i8) { 38791 SDNode *Result = Emit_177(N, X86::XOR8mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38792 return Result; 38793 } 38794 38795 // Pattern: (st:isVoid (xor:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR16:i16:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38796 // Emits: (XOR16mr:isVoid addr:iPTR:$dst, GR16:i16:$src) 38797 // Pattern complexity = 47 cost = 1 size = 3 38798 if (N1.getNode()->getValueType(0) == MVT::i16) { 38799 SDNode *Result = Emit_177(N, X86::XOR16mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38800 return Result; 38801 } 38802 38803 // Pattern: (st:isVoid (xor:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR32:i32:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38804 // Emits: (XOR32mr:isVoid addr:iPTR:$dst, GR32:i32:$src) 38805 // Pattern complexity = 47 cost = 1 size = 3 38806 if (N1.getNode()->getValueType(0) == MVT::i32) { 38807 SDNode *Result = Emit_177(N, X86::XOR32mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38808 return Result; 38809 } 38810 } 38811 } 38812 } 38813 } 38814 } 38815 if (N1.getOpcode() == ISD::SHL && 38816 N1.hasOneUse()) { 38817 SDValue N10 = N1.getOperand(0); 38818 if (N10.getOpcode() == ISD::LOAD && 38819 N10.hasOneUse() && 38820 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38821 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38822 SDValue Chain10 = N10.getOperand(0); 38823 if (Predicate_unindexedload(N10.getNode())) { 38824 38825 // Pattern: (st:isVoid (shl:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38826 // Emits: (SHL8mCL:isVoid addr:iPTR:$dst) 38827 // Pattern complexity = 47 cost = 1 size = 3 38828 if (Predicate_load(N10.getNode()) && 38829 Predicate_loadi8(N10.getNode())) { 38830 SDValue N101 = N10.getOperand(1); 38831 SDValue CPTmpN101_0; 38832 SDValue CPTmpN101_1; 38833 SDValue CPTmpN101_2; 38834 SDValue CPTmpN101_3; 38835 SDValue CPTmpN101_4; 38836 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38837 SDValue N11 = N1.getOperand(1); 38838 SDValue N2 = N.getOperand(2); 38839 if (N101 == N2 && 38840 N1.getNode()->getValueType(0) == MVT::i8 && 38841 N11.getNode()->getValueType(0) == MVT::i8) { 38842 SDNode *Result = Emit_181(N, X86::SHL8mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38843 return Result; 38844 } 38845 } 38846 } 38847 38848 // Pattern: (st:isVoid (shl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38849 // Emits: (SHL16mCL:isVoid addr:iPTR:$dst) 38850 // Pattern complexity = 47 cost = 1 size = 3 38851 if (Predicate_loadi16(N10.getNode())) { 38852 SDValue N101 = N10.getOperand(1); 38853 SDValue CPTmpN101_0; 38854 SDValue CPTmpN101_1; 38855 SDValue CPTmpN101_2; 38856 SDValue CPTmpN101_3; 38857 SDValue CPTmpN101_4; 38858 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38859 SDValue N11 = N1.getOperand(1); 38860 SDValue N2 = N.getOperand(2); 38861 if (N101 == N2 && 38862 N1.getNode()->getValueType(0) == MVT::i16 && 38863 N11.getNode()->getValueType(0) == MVT::i8) { 38864 SDNode *Result = Emit_181(N, X86::SHL16mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38865 return Result; 38866 } 38867 } 38868 } 38869 38870 // Pattern: (st:isVoid (shl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38871 // Emits: (SHL32mCL:isVoid addr:iPTR:$dst) 38872 // Pattern complexity = 47 cost = 1 size = 3 38873 if (Predicate_loadi32(N10.getNode())) { 38874 SDValue N101 = N10.getOperand(1); 38875 SDValue CPTmpN101_0; 38876 SDValue CPTmpN101_1; 38877 SDValue CPTmpN101_2; 38878 SDValue CPTmpN101_3; 38879 SDValue CPTmpN101_4; 38880 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38881 SDValue N11 = N1.getOperand(1); 38882 SDValue N2 = N.getOperand(2); 38883 if (N101 == N2 && 38884 N1.getNode()->getValueType(0) == MVT::i32 && 38885 N11.getNode()->getValueType(0) == MVT::i8) { 38886 SDNode *Result = Emit_181(N, X86::SHL32mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38887 return Result; 38888 } 38889 } 38890 } 38891 } 38892 } 38893 } 38894 if (N1.getOpcode() == ISD::SRL && 38895 N1.hasOneUse()) { 38896 SDValue N10 = N1.getOperand(0); 38897 if (N10.getOpcode() == ISD::LOAD && 38898 N10.hasOneUse() && 38899 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38900 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38901 SDValue Chain10 = N10.getOperand(0); 38902 if (Predicate_unindexedload(N10.getNode())) { 38903 38904 // Pattern: (st:isVoid (srl:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38905 // Emits: (SHR8mCL:isVoid addr:iPTR:$dst) 38906 // Pattern complexity = 47 cost = 1 size = 3 38907 if (Predicate_load(N10.getNode()) && 38908 Predicate_loadi8(N10.getNode())) { 38909 SDValue N101 = N10.getOperand(1); 38910 SDValue CPTmpN101_0; 38911 SDValue CPTmpN101_1; 38912 SDValue CPTmpN101_2; 38913 SDValue CPTmpN101_3; 38914 SDValue CPTmpN101_4; 38915 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38916 SDValue N11 = N1.getOperand(1); 38917 SDValue N2 = N.getOperand(2); 38918 if (N101 == N2 && 38919 N1.getNode()->getValueType(0) == MVT::i8 && 38920 N11.getNode()->getValueType(0) == MVT::i8) { 38921 SDNode *Result = Emit_181(N, X86::SHR8mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38922 return Result; 38923 } 38924 } 38925 } 38926 38927 // Pattern: (st:isVoid (srl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38928 // Emits: (SHR16mCL:isVoid addr:iPTR:$dst) 38929 // Pattern complexity = 47 cost = 1 size = 3 38930 if (Predicate_loadi16(N10.getNode())) { 38931 SDValue N101 = N10.getOperand(1); 38932 SDValue CPTmpN101_0; 38933 SDValue CPTmpN101_1; 38934 SDValue CPTmpN101_2; 38935 SDValue CPTmpN101_3; 38936 SDValue CPTmpN101_4; 38937 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38938 SDValue N11 = N1.getOperand(1); 38939 SDValue N2 = N.getOperand(2); 38940 if (N101 == N2 && 38941 N1.getNode()->getValueType(0) == MVT::i16 && 38942 N11.getNode()->getValueType(0) == MVT::i8) { 38943 SDNode *Result = Emit_181(N, X86::SHR16mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38944 return Result; 38945 } 38946 } 38947 } 38948 38949 // Pattern: (st:isVoid (srl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38950 // Emits: (SHR32mCL:isVoid addr:iPTR:$dst) 38951 // Pattern complexity = 47 cost = 1 size = 3 38952 if (Predicate_loadi32(N10.getNode())) { 38953 SDValue N101 = N10.getOperand(1); 38954 SDValue CPTmpN101_0; 38955 SDValue CPTmpN101_1; 38956 SDValue CPTmpN101_2; 38957 SDValue CPTmpN101_3; 38958 SDValue CPTmpN101_4; 38959 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38960 SDValue N11 = N1.getOperand(1); 38961 SDValue N2 = N.getOperand(2); 38962 if (N101 == N2 && 38963 N1.getNode()->getValueType(0) == MVT::i32 && 38964 N11.getNode()->getValueType(0) == MVT::i8) { 38965 SDNode *Result = Emit_181(N, X86::SHR32mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 38966 return Result; 38967 } 38968 } 38969 } 38970 } 38971 } 38972 } 38973 if (N1.getOpcode() == ISD::SRA && 38974 N1.hasOneUse()) { 38975 SDValue N10 = N1.getOperand(0); 38976 if (N10.getOpcode() == ISD::LOAD && 38977 N10.hasOneUse() && 38978 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 38979 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 38980 SDValue Chain10 = N10.getOperand(0); 38981 if (Predicate_unindexedload(N10.getNode())) { 38982 38983 // Pattern: (st:isVoid (sra:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 38984 // Emits: (SAR8mCL:isVoid addr:iPTR:$dst) 38985 // Pattern complexity = 47 cost = 1 size = 3 38986 if (Predicate_load(N10.getNode()) && 38987 Predicate_loadi8(N10.getNode())) { 38988 SDValue N101 = N10.getOperand(1); 38989 SDValue CPTmpN101_0; 38990 SDValue CPTmpN101_1; 38991 SDValue CPTmpN101_2; 38992 SDValue CPTmpN101_3; 38993 SDValue CPTmpN101_4; 38994 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 38995 SDValue N11 = N1.getOperand(1); 38996 SDValue N2 = N.getOperand(2); 38997 if (N101 == N2 && 38998 N1.getNode()->getValueType(0) == MVT::i8 && 38999 N11.getNode()->getValueType(0) == MVT::i8) { 39000 SDNode *Result = Emit_181(N, X86::SAR8mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39001 return Result; 39002 } 39003 } 39004 } 39005 39006 // Pattern: (st:isVoid (sra:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39007 // Emits: (SAR16mCL:isVoid addr:iPTR:$dst) 39008 // Pattern complexity = 47 cost = 1 size = 3 39009 if (Predicate_loadi16(N10.getNode())) { 39010 SDValue N101 = N10.getOperand(1); 39011 SDValue CPTmpN101_0; 39012 SDValue CPTmpN101_1; 39013 SDValue CPTmpN101_2; 39014 SDValue CPTmpN101_3; 39015 SDValue CPTmpN101_4; 39016 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39017 SDValue N11 = N1.getOperand(1); 39018 SDValue N2 = N.getOperand(2); 39019 if (N101 == N2 && 39020 N1.getNode()->getValueType(0) == MVT::i16 && 39021 N11.getNode()->getValueType(0) == MVT::i8) { 39022 SDNode *Result = Emit_181(N, X86::SAR16mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39023 return Result; 39024 } 39025 } 39026 } 39027 39028 // Pattern: (st:isVoid (sra:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39029 // Emits: (SAR32mCL:isVoid addr:iPTR:$dst) 39030 // Pattern complexity = 47 cost = 1 size = 3 39031 if (Predicate_loadi32(N10.getNode())) { 39032 SDValue N101 = N10.getOperand(1); 39033 SDValue CPTmpN101_0; 39034 SDValue CPTmpN101_1; 39035 SDValue CPTmpN101_2; 39036 SDValue CPTmpN101_3; 39037 SDValue CPTmpN101_4; 39038 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39039 SDValue N11 = N1.getOperand(1); 39040 SDValue N2 = N.getOperand(2); 39041 if (N101 == N2 && 39042 N1.getNode()->getValueType(0) == MVT::i32 && 39043 N11.getNode()->getValueType(0) == MVT::i8) { 39044 SDNode *Result = Emit_181(N, X86::SAR32mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39045 return Result; 39046 } 39047 } 39048 } 39049 } 39050 } 39051 } 39052 if (N1.getOpcode() == ISD::ROTL && 39053 N1.hasOneUse()) { 39054 SDValue N10 = N1.getOperand(0); 39055 if (N10.getOpcode() == ISD::LOAD && 39056 N10.hasOneUse() && 39057 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39058 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39059 SDValue Chain10 = N10.getOperand(0); 39060 if (Predicate_unindexedload(N10.getNode())) { 39061 39062 // Pattern: (st:isVoid (rotl:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39063 // Emits: (ROL8mCL:isVoid addr:iPTR:$dst) 39064 // Pattern complexity = 47 cost = 1 size = 3 39065 if (Predicate_load(N10.getNode()) && 39066 Predicate_loadi8(N10.getNode())) { 39067 SDValue N101 = N10.getOperand(1); 39068 SDValue CPTmpN101_0; 39069 SDValue CPTmpN101_1; 39070 SDValue CPTmpN101_2; 39071 SDValue CPTmpN101_3; 39072 SDValue CPTmpN101_4; 39073 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39074 SDValue N11 = N1.getOperand(1); 39075 SDValue N2 = N.getOperand(2); 39076 if (N101 == N2 && 39077 N1.getNode()->getValueType(0) == MVT::i8 && 39078 N11.getNode()->getValueType(0) == MVT::i8) { 39079 SDNode *Result = Emit_181(N, X86::ROL8mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39080 return Result; 39081 } 39082 } 39083 } 39084 39085 // Pattern: (st:isVoid (rotl:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39086 // Emits: (ROL16mCL:isVoid addr:iPTR:$dst) 39087 // Pattern complexity = 47 cost = 1 size = 3 39088 if (Predicate_loadi16(N10.getNode())) { 39089 SDValue N101 = N10.getOperand(1); 39090 SDValue CPTmpN101_0; 39091 SDValue CPTmpN101_1; 39092 SDValue CPTmpN101_2; 39093 SDValue CPTmpN101_3; 39094 SDValue CPTmpN101_4; 39095 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39096 SDValue N11 = N1.getOperand(1); 39097 SDValue N2 = N.getOperand(2); 39098 if (N101 == N2 && 39099 N1.getNode()->getValueType(0) == MVT::i16 && 39100 N11.getNode()->getValueType(0) == MVT::i8) { 39101 SDNode *Result = Emit_181(N, X86::ROL16mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39102 return Result; 39103 } 39104 } 39105 } 39106 39107 // Pattern: (st:isVoid (rotl:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39108 // Emits: (ROL32mCL:isVoid addr:iPTR:$dst) 39109 // Pattern complexity = 47 cost = 1 size = 3 39110 if (Predicate_loadi32(N10.getNode())) { 39111 SDValue N101 = N10.getOperand(1); 39112 SDValue CPTmpN101_0; 39113 SDValue CPTmpN101_1; 39114 SDValue CPTmpN101_2; 39115 SDValue CPTmpN101_3; 39116 SDValue CPTmpN101_4; 39117 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39118 SDValue N11 = N1.getOperand(1); 39119 SDValue N2 = N.getOperand(2); 39120 if (N101 == N2 && 39121 N1.getNode()->getValueType(0) == MVT::i32 && 39122 N11.getNode()->getValueType(0) == MVT::i8) { 39123 SDNode *Result = Emit_181(N, X86::ROL32mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39124 return Result; 39125 } 39126 } 39127 } 39128 } 39129 } 39130 } 39131 if (N1.getOpcode() == ISD::ROTR && 39132 N1.hasOneUse()) { 39133 SDValue N10 = N1.getOperand(0); 39134 if (N10.getOpcode() == ISD::LOAD && 39135 N10.hasOneUse() && 39136 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39137 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39138 SDValue Chain10 = N10.getOperand(0); 39139 if (Predicate_unindexedload(N10.getNode())) { 39140 39141 // Pattern: (st:isVoid (rotr:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39142 // Emits: (ROR8mCL:isVoid addr:iPTR:$dst) 39143 // Pattern complexity = 47 cost = 1 size = 3 39144 if (Predicate_load(N10.getNode()) && 39145 Predicate_loadi8(N10.getNode())) { 39146 SDValue N101 = N10.getOperand(1); 39147 SDValue CPTmpN101_0; 39148 SDValue CPTmpN101_1; 39149 SDValue CPTmpN101_2; 39150 SDValue CPTmpN101_3; 39151 SDValue CPTmpN101_4; 39152 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39153 SDValue N11 = N1.getOperand(1); 39154 SDValue N2 = N.getOperand(2); 39155 if (N101 == N2 && 39156 N1.getNode()->getValueType(0) == MVT::i8 && 39157 N11.getNode()->getValueType(0) == MVT::i8) { 39158 SDNode *Result = Emit_181(N, X86::ROR8mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39159 return Result; 39160 } 39161 } 39162 } 39163 39164 // Pattern: (st:isVoid (rotr:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39165 // Emits: (ROR16mCL:isVoid addr:iPTR:$dst) 39166 // Pattern complexity = 47 cost = 1 size = 3 39167 if (Predicate_loadi16(N10.getNode())) { 39168 SDValue N101 = N10.getOperand(1); 39169 SDValue CPTmpN101_0; 39170 SDValue CPTmpN101_1; 39171 SDValue CPTmpN101_2; 39172 SDValue CPTmpN101_3; 39173 SDValue CPTmpN101_4; 39174 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39175 SDValue N11 = N1.getOperand(1); 39176 SDValue N2 = N.getOperand(2); 39177 if (N101 == N2 && 39178 N1.getNode()->getValueType(0) == MVT::i16 && 39179 N11.getNode()->getValueType(0) == MVT::i8) { 39180 SDNode *Result = Emit_181(N, X86::ROR16mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39181 return Result; 39182 } 39183 } 39184 } 39185 39186 // Pattern: (st:isVoid (rotr:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39187 // Emits: (ROR32mCL:isVoid addr:iPTR:$dst) 39188 // Pattern complexity = 47 cost = 1 size = 3 39189 if (Predicate_loadi32(N10.getNode())) { 39190 SDValue N101 = N10.getOperand(1); 39191 SDValue CPTmpN101_0; 39192 SDValue CPTmpN101_1; 39193 SDValue CPTmpN101_2; 39194 SDValue CPTmpN101_3; 39195 SDValue CPTmpN101_4; 39196 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39197 SDValue N11 = N1.getOperand(1); 39198 SDValue N2 = N.getOperand(2); 39199 if (N101 == N2 && 39200 N1.getNode()->getValueType(0) == MVT::i32 && 39201 N11.getNode()->getValueType(0) == MVT::i8) { 39202 SDNode *Result = Emit_181(N, X86::ROR32mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39203 return Result; 39204 } 39205 } 39206 } 39207 } 39208 } 39209 } 39210 39211 // Pattern: (st:isVoid (X86shld:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39212 // Emits: (SHLD32mrCL:isVoid addr:iPTR:$dst, GR32:i32:$src2) 39213 // Pattern complexity = 47 cost = 1 size = 3 39214 if (N1.getOpcode() == X86ISD::SHLD && 39215 N1.hasOneUse()) { 39216 SDValue N10 = N1.getOperand(0); 39217 if (N10.getOpcode() == ISD::LOAD && 39218 N10.hasOneUse() && 39219 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39220 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39221 SDValue Chain10 = N10.getOperand(0); 39222 if (Predicate_unindexedload(N10.getNode()) && 39223 Predicate_loadi32(N10.getNode())) { 39224 SDValue N101 = N10.getOperand(1); 39225 SDValue CPTmpN101_0; 39226 SDValue CPTmpN101_1; 39227 SDValue CPTmpN101_2; 39228 SDValue CPTmpN101_3; 39229 SDValue CPTmpN101_4; 39230 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39231 SDValue N11 = N1.getOperand(1); 39232 SDValue N12 = N1.getOperand(2); 39233 SDValue N2 = N.getOperand(2); 39234 if (N101 == N2 && 39235 N1.getNode()->getValueType(0) == MVT::i32 && 39236 N12.getNode()->getValueType(0) == MVT::i8) { 39237 SDNode *Result = Emit_183(N, X86::SHLD32mrCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39238 return Result; 39239 } 39240 } 39241 } 39242 } 39243 } 39244 39245 // Pattern: (st:isVoid (X86shrd:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39246 // Emits: (SHRD32mrCL:isVoid addr:iPTR:$dst, GR32:i32:$src2) 39247 // Pattern complexity = 47 cost = 1 size = 3 39248 if (N1.getOpcode() == X86ISD::SHRD && 39249 N1.hasOneUse()) { 39250 SDValue N10 = N1.getOperand(0); 39251 if (N10.getOpcode() == ISD::LOAD && 39252 N10.hasOneUse() && 39253 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39254 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39255 SDValue Chain10 = N10.getOperand(0); 39256 if (Predicate_unindexedload(N10.getNode()) && 39257 Predicate_loadi32(N10.getNode())) { 39258 SDValue N101 = N10.getOperand(1); 39259 SDValue CPTmpN101_0; 39260 SDValue CPTmpN101_1; 39261 SDValue CPTmpN101_2; 39262 SDValue CPTmpN101_3; 39263 SDValue CPTmpN101_4; 39264 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39265 SDValue N11 = N1.getOperand(1); 39266 SDValue N12 = N1.getOperand(2); 39267 SDValue N2 = N.getOperand(2); 39268 if (N101 == N2 && 39269 N1.getNode()->getValueType(0) == MVT::i32 && 39270 N12.getNode()->getValueType(0) == MVT::i8) { 39271 SDNode *Result = Emit_183(N, X86::SHRD32mrCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39272 return Result; 39273 } 39274 } 39275 } 39276 } 39277 } 39278 39279 // Pattern: (st:isVoid (X86shld:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39280 // Emits: (SHLD16mrCL:isVoid addr:iPTR:$dst, GR16:i16:$src2) 39281 // Pattern complexity = 47 cost = 1 size = 3 39282 if (N1.getOpcode() == X86ISD::SHLD && 39283 N1.hasOneUse()) { 39284 SDValue N10 = N1.getOperand(0); 39285 if (N10.getOpcode() == ISD::LOAD && 39286 N10.hasOneUse() && 39287 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39288 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39289 SDValue Chain10 = N10.getOperand(0); 39290 if (Predicate_unindexedload(N10.getNode()) && 39291 Predicate_loadi16(N10.getNode())) { 39292 SDValue N101 = N10.getOperand(1); 39293 SDValue CPTmpN101_0; 39294 SDValue CPTmpN101_1; 39295 SDValue CPTmpN101_2; 39296 SDValue CPTmpN101_3; 39297 SDValue CPTmpN101_4; 39298 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39299 SDValue N11 = N1.getOperand(1); 39300 SDValue N12 = N1.getOperand(2); 39301 SDValue N2 = N.getOperand(2); 39302 if (N101 == N2 && 39303 N1.getNode()->getValueType(0) == MVT::i16 && 39304 N12.getNode()->getValueType(0) == MVT::i8) { 39305 SDNode *Result = Emit_183(N, X86::SHLD16mrCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39306 return Result; 39307 } 39308 } 39309 } 39310 } 39311 } 39312 39313 // Pattern: (st:isVoid (X86shrd:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39314 // Emits: (SHRD16mrCL:isVoid addr:iPTR:$dst, GR16:i16:$src2) 39315 // Pattern complexity = 47 cost = 1 size = 3 39316 if (N1.getOpcode() == X86ISD::SHRD && 39317 N1.hasOneUse()) { 39318 SDValue N10 = N1.getOperand(0); 39319 if (N10.getOpcode() == ISD::LOAD && 39320 N10.hasOneUse() && 39321 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39322 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39323 SDValue Chain10 = N10.getOperand(0); 39324 if (Predicate_unindexedload(N10.getNode()) && 39325 Predicate_loadi16(N10.getNode())) { 39326 SDValue N101 = N10.getOperand(1); 39327 SDValue CPTmpN101_0; 39328 SDValue CPTmpN101_1; 39329 SDValue CPTmpN101_2; 39330 SDValue CPTmpN101_3; 39331 SDValue CPTmpN101_4; 39332 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39333 SDValue N11 = N1.getOperand(1); 39334 SDValue N12 = N1.getOperand(2); 39335 SDValue N2 = N.getOperand(2); 39336 if (N101 == N2 && 39337 N1.getNode()->getValueType(0) == MVT::i16 && 39338 N12.getNode()->getValueType(0) == MVT::i8) { 39339 SDNode *Result = Emit_183(N, X86::SHRD16mrCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39340 return Result; 39341 } 39342 } 39343 } 39344 } 39345 } 39346 if (N1.getOpcode() == ISD::ADD && 39347 N1.hasOneUse()) { 39348 SDValue N10 = N1.getOperand(0); 39349 if (N10.getOpcode() == ISD::LOAD && 39350 N10.hasOneUse() && 39351 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39352 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39353 SDValue Chain10 = N10.getOperand(0); 39354 if (Predicate_unindexedload(N10.getNode()) && 39355 Predicate_load(N10.getNode())) { 39356 SDValue N101 = N10.getOperand(1); 39357 SDValue CPTmpN101_0; 39358 SDValue CPTmpN101_1; 39359 SDValue CPTmpN101_2; 39360 SDValue CPTmpN101_3; 39361 SDValue CPTmpN101_4; 39362 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39363 SDValue N11 = N1.getOperand(1); 39364 SDValue N2 = N.getOperand(2); 39365 if (N101 == N2) { 39366 39367 // Pattern: (st:isVoid (add:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR8:i8:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39368 // Emits: (ADD8mr:isVoid addr:iPTR:$dst, GR8:i8:$src2) 39369 // Pattern complexity = 47 cost = 1 size = 3 39370 if (N1.getNode()->getValueType(0) == MVT::i8) { 39371 SDNode *Result = Emit_177(N, X86::ADD8mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39372 return Result; 39373 } 39374 39375 // Pattern: (st:isVoid (add:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR16:i16:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39376 // Emits: (ADD16mr:isVoid addr:iPTR:$dst, GR16:i16:$src2) 39377 // Pattern complexity = 47 cost = 1 size = 3 39378 if (N1.getNode()->getValueType(0) == MVT::i16) { 39379 SDNode *Result = Emit_177(N, X86::ADD16mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39380 return Result; 39381 } 39382 39383 // Pattern: (st:isVoid (add:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR32:i32:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39384 // Emits: (ADD32mr:isVoid addr:iPTR:$dst, GR32:i32:$src2) 39385 // Pattern complexity = 47 cost = 1 size = 3 39386 if (N1.getNode()->getValueType(0) == MVT::i32) { 39387 SDNode *Result = Emit_177(N, X86::ADD32mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39388 return Result; 39389 } 39390 } 39391 } 39392 } 39393 } 39394 } 39395 if (N1.getOpcode() == ISD::ADDE && 39396 N1.hasOneUse()) { 39397 SDValue N10 = N1.getOperand(0); 39398 if (N10.getOpcode() == ISD::LOAD && 39399 N10.hasOneUse() && 39400 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39401 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39402 SDValue Chain10 = N10.getOperand(0); 39403 if (Predicate_unindexedload(N10.getNode()) && 39404 Predicate_load(N10.getNode())) { 39405 SDValue N101 = N10.getOperand(1); 39406 SDValue CPTmpN101_0; 39407 SDValue CPTmpN101_1; 39408 SDValue CPTmpN101_2; 39409 SDValue CPTmpN101_3; 39410 SDValue CPTmpN101_4; 39411 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39412 SDValue N11 = N1.getOperand(1); 39413 SDValue N2 = N.getOperand(2); 39414 if (N101 == N2) { 39415 39416 // Pattern: (st:isVoid (adde:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR8:i8:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39417 // Emits: (ADC8mr:isVoid addr:iPTR:$dst, GR8:i8:$src2) 39418 // Pattern complexity = 47 cost = 1 size = 3 39419 if (N1.getNode()->getValueType(0) == MVT::i8) { 39420 SDNode *Result = Emit_185(N, X86::ADC8mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39421 return Result; 39422 } 39423 39424 // Pattern: (st:isVoid (adde:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR16:i16:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39425 // Emits: (ADC16mr:isVoid addr:iPTR:$dst, GR16:i16:$src2) 39426 // Pattern complexity = 47 cost = 1 size = 3 39427 if (N1.getNode()->getValueType(0) == MVT::i16) { 39428 SDNode *Result = Emit_185(N, X86::ADC16mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39429 return Result; 39430 } 39431 39432 // Pattern: (st:isVoid (adde:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR32:i32:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39433 // Emits: (ADC32mr:isVoid addr:iPTR:$dst, GR32:i32:$src2) 39434 // Pattern complexity = 47 cost = 1 size = 3 39435 if (N1.getNode()->getValueType(0) == MVT::i32) { 39436 SDNode *Result = Emit_185(N, X86::ADC32mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39437 return Result; 39438 } 39439 } 39440 } 39441 } 39442 } 39443 } 39444 if (N1.getOpcode() == ISD::SUB && 39445 N1.hasOneUse()) { 39446 SDValue N10 = N1.getOperand(0); 39447 if (N10.getOpcode() == ISD::LOAD && 39448 N10.hasOneUse() && 39449 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39450 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39451 SDValue Chain10 = N10.getOperand(0); 39452 if (Predicate_unindexedload(N10.getNode()) && 39453 Predicate_load(N10.getNode())) { 39454 SDValue N101 = N10.getOperand(1); 39455 SDValue CPTmpN101_0; 39456 SDValue CPTmpN101_1; 39457 SDValue CPTmpN101_2; 39458 SDValue CPTmpN101_3; 39459 SDValue CPTmpN101_4; 39460 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39461 SDValue N11 = N1.getOperand(1); 39462 SDValue N2 = N.getOperand(2); 39463 if (N101 == N2) { 39464 39465 // Pattern: (st:isVoid (sub:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR8:i8:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39466 // Emits: (SUB8mr:isVoid addr:iPTR:$dst, GR8:i8:$src2) 39467 // Pattern complexity = 47 cost = 1 size = 3 39468 if (N1.getNode()->getValueType(0) == MVT::i8) { 39469 SDNode *Result = Emit_177(N, X86::SUB8mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39470 return Result; 39471 } 39472 39473 // Pattern: (st:isVoid (sub:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR16:i16:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39474 // Emits: (SUB16mr:isVoid addr:iPTR:$dst, GR16:i16:$src2) 39475 // Pattern complexity = 47 cost = 1 size = 3 39476 if (N1.getNode()->getValueType(0) == MVT::i16) { 39477 SDNode *Result = Emit_177(N, X86::SUB16mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39478 return Result; 39479 } 39480 39481 // Pattern: (st:isVoid (sub:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR32:i32:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39482 // Emits: (SUB32mr:isVoid addr:iPTR:$dst, GR32:i32:$src2) 39483 // Pattern complexity = 47 cost = 1 size = 3 39484 if (N1.getNode()->getValueType(0) == MVT::i32) { 39485 SDNode *Result = Emit_177(N, X86::SUB32mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39486 return Result; 39487 } 39488 } 39489 } 39490 } 39491 } 39492 } 39493 if (N1.getOpcode() == ISD::SUBE && 39494 N1.hasOneUse()) { 39495 SDValue N10 = N1.getOperand(0); 39496 if (N10.getOpcode() == ISD::LOAD && 39497 N10.hasOneUse() && 39498 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39499 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39500 SDValue Chain10 = N10.getOperand(0); 39501 if (Predicate_unindexedload(N10.getNode()) && 39502 Predicate_load(N10.getNode())) { 39503 SDValue N101 = N10.getOperand(1); 39504 SDValue CPTmpN101_0; 39505 SDValue CPTmpN101_1; 39506 SDValue CPTmpN101_2; 39507 SDValue CPTmpN101_3; 39508 SDValue CPTmpN101_4; 39509 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39510 SDValue N11 = N1.getOperand(1); 39511 SDValue N2 = N.getOperand(2); 39512 if (N101 == N2) { 39513 39514 // Pattern: (st:isVoid (sube:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR8:i8:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39515 // Emits: (SBB8mr:isVoid addr:iPTR:$dst, GR8:i8:$src2) 39516 // Pattern complexity = 47 cost = 1 size = 3 39517 if (N1.getNode()->getValueType(0) == MVT::i8) { 39518 SDNode *Result = Emit_185(N, X86::SBB8mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39519 return Result; 39520 } 39521 39522 // Pattern: (st:isVoid (sube:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR16:i16:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39523 // Emits: (SBB16mr:isVoid addr:iPTR:$dst, GR16:i16:$src2) 39524 // Pattern complexity = 47 cost = 1 size = 3 39525 if (N1.getNode()->getValueType(0) == MVT::i16) { 39526 SDNode *Result = Emit_185(N, X86::SBB16mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39527 return Result; 39528 } 39529 39530 // Pattern: (st:isVoid (sube:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR32:i32:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39531 // Emits: (SBB32mr:isVoid addr:iPTR:$dst, GR32:i32:$src2) 39532 // Pattern complexity = 47 cost = 1 size = 3 39533 if (N1.getNode()->getValueType(0) == MVT::i32) { 39534 SDNode *Result = Emit_185(N, X86::SBB32mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39535 return Result; 39536 } 39537 } 39538 } 39539 } 39540 } 39541 } 39542 39543 // Pattern: (st:isVoid (add:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR64:i64:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39544 // Emits: (ADD64mr:isVoid addr:iPTR:$dst, GR64:i64:$src2) 39545 // Pattern complexity = 47 cost = 1 size = 3 39546 if (N1.getOpcode() == ISD::ADD && 39547 N1.hasOneUse()) { 39548 SDValue N10 = N1.getOperand(0); 39549 if (N10.getOpcode() == ISD::LOAD && 39550 N10.hasOneUse() && 39551 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39552 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39553 SDValue Chain10 = N10.getOperand(0); 39554 if (Predicate_unindexedload(N10.getNode()) && 39555 Predicate_load(N10.getNode())) { 39556 SDValue N101 = N10.getOperand(1); 39557 SDValue CPTmpN101_0; 39558 SDValue CPTmpN101_1; 39559 SDValue CPTmpN101_2; 39560 SDValue CPTmpN101_3; 39561 SDValue CPTmpN101_4; 39562 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39563 SDValue N11 = N1.getOperand(1); 39564 SDValue N2 = N.getOperand(2); 39565 if (N101 == N2 && 39566 N1.getNode()->getValueType(0) == MVT::i64) { 39567 SDNode *Result = Emit_177(N, X86::ADD64mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39568 return Result; 39569 } 39570 } 39571 } 39572 } 39573 } 39574 39575 // Pattern: (st:isVoid (adde:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR64:i64:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39576 // Emits: (ADC64mr:isVoid addr:iPTR:$dst, GR64:i64:$src2) 39577 // Pattern complexity = 47 cost = 1 size = 3 39578 if (N1.getOpcode() == ISD::ADDE && 39579 N1.hasOneUse()) { 39580 SDValue N10 = N1.getOperand(0); 39581 if (N10.getOpcode() == ISD::LOAD && 39582 N10.hasOneUse() && 39583 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39584 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39585 SDValue Chain10 = N10.getOperand(0); 39586 if (Predicate_unindexedload(N10.getNode()) && 39587 Predicate_load(N10.getNode())) { 39588 SDValue N101 = N10.getOperand(1); 39589 SDValue CPTmpN101_0; 39590 SDValue CPTmpN101_1; 39591 SDValue CPTmpN101_2; 39592 SDValue CPTmpN101_3; 39593 SDValue CPTmpN101_4; 39594 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39595 SDValue N11 = N1.getOperand(1); 39596 SDValue N2 = N.getOperand(2); 39597 if (N101 == N2 && 39598 N1.getNode()->getValueType(0) == MVT::i64) { 39599 SDNode *Result = Emit_185(N, X86::ADC64mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39600 return Result; 39601 } 39602 } 39603 } 39604 } 39605 } 39606 39607 // Pattern: (st:isVoid (sub:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR64:i64:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39608 // Emits: (SUB64mr:isVoid addr:iPTR:$dst, GR64:i64:$src2) 39609 // Pattern complexity = 47 cost = 1 size = 3 39610 if (N1.getOpcode() == ISD::SUB && 39611 N1.hasOneUse()) { 39612 SDValue N10 = N1.getOperand(0); 39613 if (N10.getOpcode() == ISD::LOAD && 39614 N10.hasOneUse() && 39615 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39616 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39617 SDValue Chain10 = N10.getOperand(0); 39618 if (Predicate_unindexedload(N10.getNode()) && 39619 Predicate_load(N10.getNode())) { 39620 SDValue N101 = N10.getOperand(1); 39621 SDValue CPTmpN101_0; 39622 SDValue CPTmpN101_1; 39623 SDValue CPTmpN101_2; 39624 SDValue CPTmpN101_3; 39625 SDValue CPTmpN101_4; 39626 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39627 SDValue N11 = N1.getOperand(1); 39628 SDValue N2 = N.getOperand(2); 39629 if (N101 == N2 && 39630 N1.getNode()->getValueType(0) == MVT::i64) { 39631 SDNode *Result = Emit_177(N, X86::SUB64mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39632 return Result; 39633 } 39634 } 39635 } 39636 } 39637 } 39638 39639 // Pattern: (st:isVoid (sube:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR64:i64:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39640 // Emits: (SBB64mr:isVoid addr:iPTR:$dst, GR64:i64:$src2) 39641 // Pattern complexity = 47 cost = 1 size = 3 39642 if (N1.getOpcode() == ISD::SUBE && 39643 N1.hasOneUse()) { 39644 SDValue N10 = N1.getOperand(0); 39645 if (N10.getOpcode() == ISD::LOAD && 39646 N10.hasOneUse() && 39647 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39648 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39649 SDValue Chain10 = N10.getOperand(0); 39650 if (Predicate_unindexedload(N10.getNode()) && 39651 Predicate_load(N10.getNode())) { 39652 SDValue N101 = N10.getOperand(1); 39653 SDValue CPTmpN101_0; 39654 SDValue CPTmpN101_1; 39655 SDValue CPTmpN101_2; 39656 SDValue CPTmpN101_3; 39657 SDValue CPTmpN101_4; 39658 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39659 SDValue N11 = N1.getOperand(1); 39660 SDValue N2 = N.getOperand(2); 39661 if (N101 == N2 && 39662 N1.getNode()->getValueType(0) == MVT::i64) { 39663 SDNode *Result = Emit_185(N, X86::SBB64mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39664 return Result; 39665 } 39666 } 39667 } 39668 } 39669 } 39670 39671 // Pattern: (st:isVoid (shl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39672 // Emits: (SHL64mCL:isVoid addr:iPTR:$dst) 39673 // Pattern complexity = 47 cost = 1 size = 3 39674 if (N1.getOpcode() == ISD::SHL && 39675 N1.hasOneUse()) { 39676 SDValue N10 = N1.getOperand(0); 39677 if (N10.getOpcode() == ISD::LOAD && 39678 N10.hasOneUse() && 39679 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39680 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39681 SDValue Chain10 = N10.getOperand(0); 39682 if (Predicate_unindexedload(N10.getNode()) && 39683 Predicate_load(N10.getNode()) && 39684 Predicate_loadi64(N10.getNode())) { 39685 SDValue N101 = N10.getOperand(1); 39686 SDValue CPTmpN101_0; 39687 SDValue CPTmpN101_1; 39688 SDValue CPTmpN101_2; 39689 SDValue CPTmpN101_3; 39690 SDValue CPTmpN101_4; 39691 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39692 SDValue N11 = N1.getOperand(1); 39693 SDValue N2 = N.getOperand(2); 39694 if (N101 == N2 && 39695 N1.getNode()->getValueType(0) == MVT::i64 && 39696 N11.getNode()->getValueType(0) == MVT::i8) { 39697 SDNode *Result = Emit_181(N, X86::SHL64mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39698 return Result; 39699 } 39700 } 39701 } 39702 } 39703 } 39704 39705 // Pattern: (st:isVoid (srl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39706 // Emits: (SHR64mCL:isVoid addr:iPTR:$dst) 39707 // Pattern complexity = 47 cost = 1 size = 3 39708 if (N1.getOpcode() == ISD::SRL && 39709 N1.hasOneUse()) { 39710 SDValue N10 = N1.getOperand(0); 39711 if (N10.getOpcode() == ISD::LOAD && 39712 N10.hasOneUse() && 39713 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39714 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39715 SDValue Chain10 = N10.getOperand(0); 39716 if (Predicate_unindexedload(N10.getNode()) && 39717 Predicate_load(N10.getNode()) && 39718 Predicate_loadi64(N10.getNode())) { 39719 SDValue N101 = N10.getOperand(1); 39720 SDValue CPTmpN101_0; 39721 SDValue CPTmpN101_1; 39722 SDValue CPTmpN101_2; 39723 SDValue CPTmpN101_3; 39724 SDValue CPTmpN101_4; 39725 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39726 SDValue N11 = N1.getOperand(1); 39727 SDValue N2 = N.getOperand(2); 39728 if (N101 == N2 && 39729 N1.getNode()->getValueType(0) == MVT::i64 && 39730 N11.getNode()->getValueType(0) == MVT::i8) { 39731 SDNode *Result = Emit_181(N, X86::SHR64mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39732 return Result; 39733 } 39734 } 39735 } 39736 } 39737 } 39738 39739 // Pattern: (st:isVoid (sra:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39740 // Emits: (SAR64mCL:isVoid addr:iPTR:$dst) 39741 // Pattern complexity = 47 cost = 1 size = 3 39742 if (N1.getOpcode() == ISD::SRA && 39743 N1.hasOneUse()) { 39744 SDValue N10 = N1.getOperand(0); 39745 if (N10.getOpcode() == ISD::LOAD && 39746 N10.hasOneUse() && 39747 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39748 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39749 SDValue Chain10 = N10.getOperand(0); 39750 if (Predicate_unindexedload(N10.getNode()) && 39751 Predicate_load(N10.getNode()) && 39752 Predicate_loadi64(N10.getNode())) { 39753 SDValue N101 = N10.getOperand(1); 39754 SDValue CPTmpN101_0; 39755 SDValue CPTmpN101_1; 39756 SDValue CPTmpN101_2; 39757 SDValue CPTmpN101_3; 39758 SDValue CPTmpN101_4; 39759 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39760 SDValue N11 = N1.getOperand(1); 39761 SDValue N2 = N.getOperand(2); 39762 if (N101 == N2 && 39763 N1.getNode()->getValueType(0) == MVT::i64 && 39764 N11.getNode()->getValueType(0) == MVT::i8) { 39765 SDNode *Result = Emit_181(N, X86::SAR64mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39766 return Result; 39767 } 39768 } 39769 } 39770 } 39771 } 39772 39773 // Pattern: (st:isVoid (rotl:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39774 // Emits: (ROL64mCL:isVoid addr:iPTR:$dst) 39775 // Pattern complexity = 47 cost = 1 size = 3 39776 if (N1.getOpcode() == ISD::ROTL && 39777 N1.hasOneUse()) { 39778 SDValue N10 = N1.getOperand(0); 39779 if (N10.getOpcode() == ISD::LOAD && 39780 N10.hasOneUse() && 39781 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39782 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39783 SDValue Chain10 = N10.getOperand(0); 39784 if (Predicate_unindexedload(N10.getNode()) && 39785 Predicate_load(N10.getNode()) && 39786 Predicate_loadi64(N10.getNode())) { 39787 SDValue N101 = N10.getOperand(1); 39788 SDValue CPTmpN101_0; 39789 SDValue CPTmpN101_1; 39790 SDValue CPTmpN101_2; 39791 SDValue CPTmpN101_3; 39792 SDValue CPTmpN101_4; 39793 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39794 SDValue N11 = N1.getOperand(1); 39795 SDValue N2 = N.getOperand(2); 39796 if (N101 == N2 && 39797 N1.getNode()->getValueType(0) == MVT::i64 && 39798 N11.getNode()->getValueType(0) == MVT::i8) { 39799 SDNode *Result = Emit_181(N, X86::ROL64mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39800 return Result; 39801 } 39802 } 39803 } 39804 } 39805 } 39806 39807 // Pattern: (st:isVoid (rotr:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39808 // Emits: (ROR64mCL:isVoid addr:iPTR:$dst) 39809 // Pattern complexity = 47 cost = 1 size = 3 39810 if (N1.getOpcode() == ISD::ROTR && 39811 N1.hasOneUse()) { 39812 SDValue N10 = N1.getOperand(0); 39813 if (N10.getOpcode() == ISD::LOAD && 39814 N10.hasOneUse() && 39815 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39816 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39817 SDValue Chain10 = N10.getOperand(0); 39818 if (Predicate_unindexedload(N10.getNode()) && 39819 Predicate_load(N10.getNode()) && 39820 Predicate_loadi64(N10.getNode())) { 39821 SDValue N101 = N10.getOperand(1); 39822 SDValue CPTmpN101_0; 39823 SDValue CPTmpN101_1; 39824 SDValue CPTmpN101_2; 39825 SDValue CPTmpN101_3; 39826 SDValue CPTmpN101_4; 39827 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39828 SDValue N11 = N1.getOperand(1); 39829 SDValue N2 = N.getOperand(2); 39830 if (N101 == N2 && 39831 N1.getNode()->getValueType(0) == MVT::i64 && 39832 N11.getNode()->getValueType(0) == MVT::i8) { 39833 SDNode *Result = Emit_181(N, X86::ROR64mCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39834 return Result; 39835 } 39836 } 39837 } 39838 } 39839 } 39840 39841 // Pattern: (st:isVoid (X86shld:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39842 // Emits: (SHLD64mrCL:isVoid addr:iPTR:$dst, GR64:i64:$src2) 39843 // Pattern complexity = 47 cost = 1 size = 3 39844 if (N1.getOpcode() == X86ISD::SHLD && 39845 N1.hasOneUse()) { 39846 SDValue N10 = N1.getOperand(0); 39847 if (N10.getOpcode() == ISD::LOAD && 39848 N10.hasOneUse() && 39849 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39850 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39851 SDValue Chain10 = N10.getOperand(0); 39852 if (Predicate_unindexedload(N10.getNode()) && 39853 Predicate_load(N10.getNode()) && 39854 Predicate_loadi64(N10.getNode())) { 39855 SDValue N101 = N10.getOperand(1); 39856 SDValue CPTmpN101_0; 39857 SDValue CPTmpN101_1; 39858 SDValue CPTmpN101_2; 39859 SDValue CPTmpN101_3; 39860 SDValue CPTmpN101_4; 39861 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39862 SDValue N11 = N1.getOperand(1); 39863 SDValue N12 = N1.getOperand(2); 39864 SDValue N2 = N.getOperand(2); 39865 if (N101 == N2 && 39866 N1.getNode()->getValueType(0) == MVT::i64 && 39867 N12.getNode()->getValueType(0) == MVT::i8) { 39868 SDNode *Result = Emit_183(N, X86::SHLD64mrCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39869 return Result; 39870 } 39871 } 39872 } 39873 } 39874 } 39875 39876 // Pattern: (st:isVoid (X86shrd:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, CL:i8), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39877 // Emits: (SHRD64mrCL:isVoid addr:iPTR:$dst, GR64:i64:$src2) 39878 // Pattern complexity = 47 cost = 1 size = 3 39879 if (N1.getOpcode() == X86ISD::SHRD && 39880 N1.hasOneUse()) { 39881 SDValue N10 = N1.getOperand(0); 39882 if (N10.getOpcode() == ISD::LOAD && 39883 N10.hasOneUse() && 39884 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39885 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39886 SDValue Chain10 = N10.getOperand(0); 39887 if (Predicate_unindexedload(N10.getNode()) && 39888 Predicate_load(N10.getNode()) && 39889 Predicate_loadi64(N10.getNode())) { 39890 SDValue N101 = N10.getOperand(1); 39891 SDValue CPTmpN101_0; 39892 SDValue CPTmpN101_1; 39893 SDValue CPTmpN101_2; 39894 SDValue CPTmpN101_3; 39895 SDValue CPTmpN101_4; 39896 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39897 SDValue N11 = N1.getOperand(1); 39898 SDValue N12 = N1.getOperand(2); 39899 SDValue N2 = N.getOperand(2); 39900 if (N101 == N2 && 39901 N1.getNode()->getValueType(0) == MVT::i64 && 39902 N12.getNode()->getValueType(0) == MVT::i8) { 39903 SDNode *Result = Emit_183(N, X86::SHRD64mrCL, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39904 return Result; 39905 } 39906 } 39907 } 39908 } 39909 } 39910 39911 // Pattern: (st:isVoid (and:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR64:i64:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39912 // Emits: (AND64mr:isVoid addr:iPTR:$dst, GR64:i64:$src) 39913 // Pattern complexity = 47 cost = 1 size = 3 39914 if (N1.getOpcode() == ISD::AND && 39915 N1.hasOneUse()) { 39916 SDValue N10 = N1.getOperand(0); 39917 if (N10.getOpcode() == ISD::LOAD && 39918 N10.hasOneUse() && 39919 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39920 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39921 SDValue Chain10 = N10.getOperand(0); 39922 if (Predicate_unindexedload(N10.getNode()) && 39923 Predicate_load(N10.getNode())) { 39924 SDValue N101 = N10.getOperand(1); 39925 SDValue CPTmpN101_0; 39926 SDValue CPTmpN101_1; 39927 SDValue CPTmpN101_2; 39928 SDValue CPTmpN101_3; 39929 SDValue CPTmpN101_4; 39930 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39931 SDValue N11 = N1.getOperand(1); 39932 SDValue N2 = N.getOperand(2); 39933 if (N101 == N2 && 39934 N1.getNode()->getValueType(0) == MVT::i64) { 39935 SDNode *Result = Emit_177(N, X86::AND64mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39936 return Result; 39937 } 39938 } 39939 } 39940 } 39941 } 39942 39943 // Pattern: (st:isVoid (or:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR64:i64:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39944 // Emits: (OR64mr:isVoid addr:iPTR:$dst, GR64:i64:$src) 39945 // Pattern complexity = 47 cost = 1 size = 3 39946 if (N1.getOpcode() == ISD::OR && 39947 N1.hasOneUse()) { 39948 SDValue N10 = N1.getOperand(0); 39949 if (N10.getOpcode() == ISD::LOAD && 39950 N10.hasOneUse() && 39951 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39952 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39953 SDValue Chain10 = N10.getOperand(0); 39954 if (Predicate_unindexedload(N10.getNode()) && 39955 Predicate_load(N10.getNode())) { 39956 SDValue N101 = N10.getOperand(1); 39957 SDValue CPTmpN101_0; 39958 SDValue CPTmpN101_1; 39959 SDValue CPTmpN101_2; 39960 SDValue CPTmpN101_3; 39961 SDValue CPTmpN101_4; 39962 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39963 SDValue N11 = N1.getOperand(1); 39964 SDValue N2 = N.getOperand(2); 39965 if (N101 == N2 && 39966 N1.getNode()->getValueType(0) == MVT::i64) { 39967 SDNode *Result = Emit_177(N, X86::OR64mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 39968 return Result; 39969 } 39970 } 39971 } 39972 } 39973 } 39974 39975 // Pattern: (st:isVoid (xor:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR64:i64:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 39976 // Emits: (XOR64mr:isVoid addr:iPTR:$dst, GR64:i64:$src) 39977 // Pattern complexity = 47 cost = 1 size = 3 39978 if (N1.getOpcode() == ISD::XOR && 39979 N1.hasOneUse()) { 39980 SDValue N10 = N1.getOperand(0); 39981 if (N10.getOpcode() == ISD::LOAD && 39982 N10.hasOneUse() && 39983 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 39984 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 39985 SDValue Chain10 = N10.getOperand(0); 39986 if (Predicate_unindexedload(N10.getNode()) && 39987 Predicate_load(N10.getNode())) { 39988 SDValue N101 = N10.getOperand(1); 39989 SDValue CPTmpN101_0; 39990 SDValue CPTmpN101_1; 39991 SDValue CPTmpN101_2; 39992 SDValue CPTmpN101_3; 39993 SDValue CPTmpN101_4; 39994 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 39995 SDValue N11 = N1.getOperand(1); 39996 SDValue N2 = N.getOperand(2); 39997 if (N101 == N2 && 39998 N1.getNode()->getValueType(0) == MVT::i64) { 39999 SDNode *Result = Emit_177(N, X86::XOR64mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 40000 return Result; 40001 } 40002 } 40003 } 40004 } 40005 } 40006 if (N1.getOpcode() == X86ISD::ADD && 40007 N1.hasOneUse()) { 40008 SDValue N10 = N1.getOperand(0); 40009 if (N10.getOpcode() == ISD::LOAD && 40010 N10.hasOneUse() && 40011 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 40012 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 40013 SDValue Chain10 = N10.getOperand(0); 40014 if (Predicate_unindexedload(N10.getNode())) { 40015 40016 // Pattern: (st:isVoid (X86add_flag:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, GR8:i8:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40017 // Emits: (ADD8mr:isVoid addr:iPTR:$dst, GR8:i8:$src2) 40018 // Pattern complexity = 47 cost = 1 size = 3 40019 if (Predicate_load(N10.getNode()) && 40020 Predicate_loadi8(N10.getNode())) { 40021 SDValue N101 = N10.getOperand(1); 40022 SDValue CPTmpN101_0; 40023 SDValue CPTmpN101_1; 40024 SDValue CPTmpN101_2; 40025 SDValue CPTmpN101_3; 40026 SDValue CPTmpN101_4; 40027 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 40028 SDValue N11 = N1.getOperand(1); 40029 SDValue N2 = N.getOperand(2); 40030 if (N101 == N2 && 40031 N1.getNode()->getValueType(0) == MVT::i8) { 40032 SDNode *Result = Emit_177(N, X86::ADD8mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 40033 return Result; 40034 } 40035 } 40036 } 40037 40038 // Pattern: (st:isVoid (X86add_flag:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40039 // Emits: (ADD16mr:isVoid addr:iPTR:$dst, GR16:i16:$src2) 40040 // Pattern complexity = 47 cost = 1 size = 3 40041 if (Predicate_loadi16(N10.getNode())) { 40042 SDValue N101 = N10.getOperand(1); 40043 SDValue CPTmpN101_0; 40044 SDValue CPTmpN101_1; 40045 SDValue CPTmpN101_2; 40046 SDValue CPTmpN101_3; 40047 SDValue CPTmpN101_4; 40048 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 40049 SDValue N11 = N1.getOperand(1); 40050 SDValue N2 = N.getOperand(2); 40051 if (N101 == N2 && 40052 N1.getNode()->getValueType(0) == MVT::i16) { 40053 SDNode *Result = Emit_177(N, X86::ADD16mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 40054 return Result; 40055 } 40056 } 40057 } 40058 40059 // Pattern: (st:isVoid (X86add_flag:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40060 // Emits: (ADD32mr:isVoid addr:iPTR:$dst, GR32:i32:$src2) 40061 // Pattern complexity = 47 cost = 1 size = 3 40062 if (Predicate_loadi32(N10.getNode())) { 40063 SDValue N101 = N10.getOperand(1); 40064 SDValue CPTmpN101_0; 40065 SDValue CPTmpN101_1; 40066 SDValue CPTmpN101_2; 40067 SDValue CPTmpN101_3; 40068 SDValue CPTmpN101_4; 40069 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 40070 SDValue N11 = N1.getOperand(1); 40071 SDValue N2 = N.getOperand(2); 40072 if (N101 == N2 && 40073 N1.getNode()->getValueType(0) == MVT::i32) { 40074 SDNode *Result = Emit_177(N, X86::ADD32mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 40075 return Result; 40076 } 40077 } 40078 } 40079 } 40080 } 40081 } 40082 if (N1.getOpcode() == X86ISD::SUB && 40083 N1.hasOneUse()) { 40084 SDValue N10 = N1.getOperand(0); 40085 if (N10.getOpcode() == ISD::LOAD && 40086 N10.hasOneUse() && 40087 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 40088 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 40089 SDValue Chain10 = N10.getOperand(0); 40090 if (Predicate_unindexedload(N10.getNode())) { 40091 40092 // Pattern: (st:isVoid (X86sub_flag:i8 (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, GR8:i8:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40093 // Emits: (SUB8mr:isVoid addr:iPTR:$dst, GR8:i8:$src2) 40094 // Pattern complexity = 47 cost = 1 size = 3 40095 if (Predicate_load(N10.getNode()) && 40096 Predicate_loadi8(N10.getNode())) { 40097 SDValue N101 = N10.getOperand(1); 40098 SDValue CPTmpN101_0; 40099 SDValue CPTmpN101_1; 40100 SDValue CPTmpN101_2; 40101 SDValue CPTmpN101_3; 40102 SDValue CPTmpN101_4; 40103 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 40104 SDValue N11 = N1.getOperand(1); 40105 SDValue N2 = N.getOperand(2); 40106 if (N101 == N2 && 40107 N1.getNode()->getValueType(0) == MVT::i8) { 40108 SDNode *Result = Emit_177(N, X86::SUB8mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 40109 return Result; 40110 } 40111 } 40112 } 40113 40114 // Pattern: (st:isVoid (X86sub_flag:i16 (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40115 // Emits: (SUB16mr:isVoid addr:iPTR:$dst, GR16:i16:$src2) 40116 // Pattern complexity = 47 cost = 1 size = 3 40117 if (Predicate_loadi16(N10.getNode())) { 40118 SDValue N101 = N10.getOperand(1); 40119 SDValue CPTmpN101_0; 40120 SDValue CPTmpN101_1; 40121 SDValue CPTmpN101_2; 40122 SDValue CPTmpN101_3; 40123 SDValue CPTmpN101_4; 40124 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 40125 SDValue N11 = N1.getOperand(1); 40126 SDValue N2 = N.getOperand(2); 40127 if (N101 == N2 && 40128 N1.getNode()->getValueType(0) == MVT::i16) { 40129 SDNode *Result = Emit_177(N, X86::SUB16mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 40130 return Result; 40131 } 40132 } 40133 } 40134 40135 // Pattern: (st:isVoid (X86sub_flag:i32 (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40136 // Emits: (SUB32mr:isVoid addr:iPTR:$dst, GR32:i32:$src2) 40137 // Pattern complexity = 47 cost = 1 size = 3 40138 if (Predicate_loadi32(N10.getNode())) { 40139 SDValue N101 = N10.getOperand(1); 40140 SDValue CPTmpN101_0; 40141 SDValue CPTmpN101_1; 40142 SDValue CPTmpN101_2; 40143 SDValue CPTmpN101_3; 40144 SDValue CPTmpN101_4; 40145 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 40146 SDValue N11 = N1.getOperand(1); 40147 SDValue N2 = N.getOperand(2); 40148 if (N101 == N2 && 40149 N1.getNode()->getValueType(0) == MVT::i32) { 40150 SDNode *Result = Emit_177(N, X86::SUB32mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 40151 return Result; 40152 } 40153 } 40154 } 40155 } 40156 } 40157 } 40158 40159 // Pattern: (st:isVoid (X86add_flag:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40160 // Emits: (ADD64mr:isVoid addr:iPTR:$dst, GR64:i64:$src2) 40161 // Pattern complexity = 47 cost = 1 size = 3 40162 if (N1.getOpcode() == X86ISD::ADD && 40163 N1.hasOneUse()) { 40164 SDValue N10 = N1.getOperand(0); 40165 if (N10.getOpcode() == ISD::LOAD && 40166 N10.hasOneUse() && 40167 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 40168 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 40169 SDValue Chain10 = N10.getOperand(0); 40170 if (Predicate_unindexedload(N10.getNode()) && 40171 Predicate_load(N10.getNode()) && 40172 Predicate_loadi64(N10.getNode())) { 40173 SDValue N101 = N10.getOperand(1); 40174 SDValue CPTmpN101_0; 40175 SDValue CPTmpN101_1; 40176 SDValue CPTmpN101_2; 40177 SDValue CPTmpN101_3; 40178 SDValue CPTmpN101_4; 40179 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 40180 SDValue N11 = N1.getOperand(1); 40181 SDValue N2 = N.getOperand(2); 40182 if (N101 == N2 && 40183 N1.getNode()->getValueType(0) == MVT::i64) { 40184 SDNode *Result = Emit_177(N, X86::ADD64mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 40185 return Result; 40186 } 40187 } 40188 } 40189 } 40190 } 40191 40192 // Pattern: (st:isVoid (X86sub_flag:i64 (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40193 // Emits: (SUB64mr:isVoid addr:iPTR:$dst, GR64:i64:$src2) 40194 // Pattern complexity = 47 cost = 1 size = 3 40195 if (N1.getOpcode() == X86ISD::SUB && 40196 N1.hasOneUse()) { 40197 SDValue N10 = N1.getOperand(0); 40198 if (N10.getOpcode() == ISD::LOAD && 40199 N10.hasOneUse() && 40200 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode()) && 40201 (Chain.getNode() == N10.getNode() || IsChainCompatible(Chain.getNode(), N10.getNode()))) { 40202 SDValue Chain10 = N10.getOperand(0); 40203 if (Predicate_unindexedload(N10.getNode()) && 40204 Predicate_load(N10.getNode()) && 40205 Predicate_loadi64(N10.getNode())) { 40206 SDValue N101 = N10.getOperand(1); 40207 SDValue CPTmpN101_0; 40208 SDValue CPTmpN101_1; 40209 SDValue CPTmpN101_2; 40210 SDValue CPTmpN101_3; 40211 SDValue CPTmpN101_4; 40212 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 40213 SDValue N11 = N1.getOperand(1); 40214 SDValue N2 = N.getOperand(2); 40215 if (N101 == N2 && 40216 N1.getNode()->getValueType(0) == MVT::i64) { 40217 SDNode *Result = Emit_177(N, X86::SUB64mr, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 40218 return Result; 40219 } 40220 } 40221 } 40222 } 40223 } 40224 if (N1.getOpcode() == ISD::AND && 40225 N1.hasOneUse()) { 40226 SDValue N10 = N1.getOperand(0); 40227 SDValue N11 = N1.getOperand(1); 40228 if (N11.getOpcode() == ISD::LOAD && 40229 N11.hasOneUse() && 40230 IsLegalAndProfitableToFold(N11.getNode(), N1.getNode(), N.getNode()) && 40231 (Chain.getNode() == N11.getNode() || IsChainCompatible(Chain.getNode(), N11.getNode()))) { 40232 SDValue Chain11 = N11.getOperand(0); 40233 if (Predicate_unindexedload(N11.getNode()) && 40234 Predicate_load(N11.getNode())) { 40235 SDValue N111 = N11.getOperand(1); 40236 SDValue CPTmpN111_0; 40237 SDValue CPTmpN111_1; 40238 SDValue CPTmpN111_2; 40239 SDValue CPTmpN111_3; 40240 SDValue CPTmpN111_4; 40241 if (SelectAddr(N, N111, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4)) { 40242 SDValue N2 = N.getOperand(2); 40243 if (N111 == N2) { 40244 40245 // Pattern: (st:isVoid (and:i8 GR8:i8:$src, (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40246 // Emits: (AND8mr:isVoid addr:iPTR:$dst, GR8:i8:$src) 40247 // Pattern complexity = 47 cost = 1 size = 3 40248 if (N1.getNode()->getValueType(0) == MVT::i8) { 40249 SDNode *Result = Emit_217(N, X86::AND8mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40250 return Result; 40251 } 40252 40253 // Pattern: (st:isVoid (and:i16 GR16:i16:$src, (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40254 // Emits: (AND16mr:isVoid addr:iPTR:$dst, GR16:i16:$src) 40255 // Pattern complexity = 47 cost = 1 size = 3 40256 if (N1.getNode()->getValueType(0) == MVT::i16) { 40257 SDNode *Result = Emit_217(N, X86::AND16mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40258 return Result; 40259 } 40260 40261 // Pattern: (st:isVoid (and:i32 GR32:i32:$src, (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40262 // Emits: (AND32mr:isVoid addr:iPTR:$dst, GR32:i32:$src) 40263 // Pattern complexity = 47 cost = 1 size = 3 40264 if (N1.getNode()->getValueType(0) == MVT::i32) { 40265 SDNode *Result = Emit_217(N, X86::AND32mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40266 return Result; 40267 } 40268 } 40269 } 40270 } 40271 } 40272 } 40273 if (N1.getOpcode() == ISD::OR && 40274 N1.hasOneUse()) { 40275 SDValue N10 = N1.getOperand(0); 40276 SDValue N11 = N1.getOperand(1); 40277 if (N11.getOpcode() == ISD::LOAD && 40278 N11.hasOneUse() && 40279 IsLegalAndProfitableToFold(N11.getNode(), N1.getNode(), N.getNode()) && 40280 (Chain.getNode() == N11.getNode() || IsChainCompatible(Chain.getNode(), N11.getNode()))) { 40281 SDValue Chain11 = N11.getOperand(0); 40282 if (Predicate_unindexedload(N11.getNode()) && 40283 Predicate_load(N11.getNode())) { 40284 SDValue N111 = N11.getOperand(1); 40285 SDValue CPTmpN111_0; 40286 SDValue CPTmpN111_1; 40287 SDValue CPTmpN111_2; 40288 SDValue CPTmpN111_3; 40289 SDValue CPTmpN111_4; 40290 if (SelectAddr(N, N111, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4)) { 40291 SDValue N2 = N.getOperand(2); 40292 if (N111 == N2) { 40293 40294 // Pattern: (st:isVoid (or:i8 GR8:i8:$src, (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40295 // Emits: (OR8mr:isVoid addr:iPTR:$dst, GR8:i8:$src) 40296 // Pattern complexity = 47 cost = 1 size = 3 40297 if (N1.getNode()->getValueType(0) == MVT::i8) { 40298 SDNode *Result = Emit_217(N, X86::OR8mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40299 return Result; 40300 } 40301 40302 // Pattern: (st:isVoid (or:i16 GR16:i16:$src, (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40303 // Emits: (OR16mr:isVoid addr:iPTR:$dst, GR16:i16:$src) 40304 // Pattern complexity = 47 cost = 1 size = 3 40305 if (N1.getNode()->getValueType(0) == MVT::i16) { 40306 SDNode *Result = Emit_217(N, X86::OR16mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40307 return Result; 40308 } 40309 40310 // Pattern: (st:isVoid (or:i32 GR32:i32:$src, (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40311 // Emits: (OR32mr:isVoid addr:iPTR:$dst, GR32:i32:$src) 40312 // Pattern complexity = 47 cost = 1 size = 3 40313 if (N1.getNode()->getValueType(0) == MVT::i32) { 40314 SDNode *Result = Emit_217(N, X86::OR32mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40315 return Result; 40316 } 40317 } 40318 } 40319 } 40320 } 40321 } 40322 if (N1.getOpcode() == ISD::XOR && 40323 N1.hasOneUse()) { 40324 SDValue N10 = N1.getOperand(0); 40325 SDValue N11 = N1.getOperand(1); 40326 if (N11.getOpcode() == ISD::LOAD && 40327 N11.hasOneUse() && 40328 IsLegalAndProfitableToFold(N11.getNode(), N1.getNode(), N.getNode()) && 40329 (Chain.getNode() == N11.getNode() || IsChainCompatible(Chain.getNode(), N11.getNode()))) { 40330 SDValue Chain11 = N11.getOperand(0); 40331 if (Predicate_unindexedload(N11.getNode()) && 40332 Predicate_load(N11.getNode())) { 40333 SDValue N111 = N11.getOperand(1); 40334 SDValue CPTmpN111_0; 40335 SDValue CPTmpN111_1; 40336 SDValue CPTmpN111_2; 40337 SDValue CPTmpN111_3; 40338 SDValue CPTmpN111_4; 40339 if (SelectAddr(N, N111, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4)) { 40340 SDValue N2 = N.getOperand(2); 40341 if (N111 == N2) { 40342 40343 // Pattern: (st:isVoid (xor:i8 GR8:i8:$src, (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40344 // Emits: (XOR8mr:isVoid addr:iPTR:$dst, GR8:i8:$src) 40345 // Pattern complexity = 47 cost = 1 size = 3 40346 if (N1.getNode()->getValueType(0) == MVT::i8) { 40347 SDNode *Result = Emit_217(N, X86::XOR8mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40348 return Result; 40349 } 40350 40351 // Pattern: (st:isVoid (xor:i16 GR16:i16:$src, (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40352 // Emits: (XOR16mr:isVoid addr:iPTR:$dst, GR16:i16:$src) 40353 // Pattern complexity = 47 cost = 1 size = 3 40354 if (N1.getNode()->getValueType(0) == MVT::i16) { 40355 SDNode *Result = Emit_217(N, X86::XOR16mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40356 return Result; 40357 } 40358 40359 // Pattern: (st:isVoid (xor:i32 GR32:i32:$src, (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40360 // Emits: (XOR32mr:isVoid addr:iPTR:$dst, GR32:i32:$src) 40361 // Pattern complexity = 47 cost = 1 size = 3 40362 if (N1.getNode()->getValueType(0) == MVT::i32) { 40363 SDNode *Result = Emit_217(N, X86::XOR32mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40364 return Result; 40365 } 40366 } 40367 } 40368 } 40369 } 40370 } 40371 if (N1.getOpcode() == ISD::ADD && 40372 N1.hasOneUse()) { 40373 SDValue N10 = N1.getOperand(0); 40374 SDValue N11 = N1.getOperand(1); 40375 if (N11.getOpcode() == ISD::LOAD && 40376 N11.hasOneUse() && 40377 IsLegalAndProfitableToFold(N11.getNode(), N1.getNode(), N.getNode()) && 40378 (Chain.getNode() == N11.getNode() || IsChainCompatible(Chain.getNode(), N11.getNode()))) { 40379 SDValue Chain11 = N11.getOperand(0); 40380 if (Predicate_unindexedload(N11.getNode()) && 40381 Predicate_load(N11.getNode())) { 40382 SDValue N111 = N11.getOperand(1); 40383 SDValue CPTmpN111_0; 40384 SDValue CPTmpN111_1; 40385 SDValue CPTmpN111_2; 40386 SDValue CPTmpN111_3; 40387 SDValue CPTmpN111_4; 40388 if (SelectAddr(N, N111, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4)) { 40389 SDValue N2 = N.getOperand(2); 40390 if (N111 == N2) { 40391 40392 // Pattern: (st:isVoid (add:i8 GR8:i8:$src2, (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40393 // Emits: (ADD8mr:isVoid addr:iPTR:$dst, GR8:i8:$src2) 40394 // Pattern complexity = 47 cost = 1 size = 3 40395 if (N1.getNode()->getValueType(0) == MVT::i8) { 40396 SDNode *Result = Emit_217(N, X86::ADD8mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40397 return Result; 40398 } 40399 40400 // Pattern: (st:isVoid (add:i16 GR16:i16:$src2, (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40401 // Emits: (ADD16mr:isVoid addr:iPTR:$dst, GR16:i16:$src2) 40402 // Pattern complexity = 47 cost = 1 size = 3 40403 if (N1.getNode()->getValueType(0) == MVT::i16) { 40404 SDNode *Result = Emit_217(N, X86::ADD16mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40405 return Result; 40406 } 40407 40408 // Pattern: (st:isVoid (add:i32 GR32:i32:$src2, (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40409 // Emits: (ADD32mr:isVoid addr:iPTR:$dst, GR32:i32:$src2) 40410 // Pattern complexity = 47 cost = 1 size = 3 40411 if (N1.getNode()->getValueType(0) == MVT::i32) { 40412 SDNode *Result = Emit_217(N, X86::ADD32mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40413 return Result; 40414 } 40415 } 40416 } 40417 } 40418 } 40419 } 40420 if (N1.getOpcode() == ISD::ADDE && 40421 N1.hasOneUse()) { 40422 SDValue N10 = N1.getOperand(0); 40423 SDValue N11 = N1.getOperand(1); 40424 if (N11.getOpcode() == ISD::LOAD && 40425 N11.hasOneUse() && 40426 IsLegalAndProfitableToFold(N11.getNode(), N1.getNode(), N.getNode()) && 40427 (Chain.getNode() == N11.getNode() || IsChainCompatible(Chain.getNode(), N11.getNode()))) { 40428 SDValue Chain11 = N11.getOperand(0); 40429 if (Predicate_unindexedload(N11.getNode()) && 40430 Predicate_load(N11.getNode())) { 40431 SDValue N111 = N11.getOperand(1); 40432 SDValue CPTmpN111_0; 40433 SDValue CPTmpN111_1; 40434 SDValue CPTmpN111_2; 40435 SDValue CPTmpN111_3; 40436 SDValue CPTmpN111_4; 40437 if (SelectAddr(N, N111, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4)) { 40438 SDValue N2 = N.getOperand(2); 40439 if (N111 == N2) { 40440 40441 // Pattern: (st:isVoid (adde:i8 GR8:i8:$src2, (ld:i8 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40442 // Emits: (ADC8mr:isVoid addr:iPTR:$dst, GR8:i8:$src2) 40443 // Pattern complexity = 47 cost = 1 size = 3 40444 if (N1.getNode()->getValueType(0) == MVT::i8) { 40445 SDNode *Result = Emit_218(N, X86::ADC8mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40446 return Result; 40447 } 40448 40449 // Pattern: (st:isVoid (adde:i16 GR16:i16:$src2, (ld:i16 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40450 // Emits: (ADC16mr:isVoid addr:iPTR:$dst, GR16:i16:$src2) 40451 // Pattern complexity = 47 cost = 1 size = 3 40452 if (N1.getNode()->getValueType(0) == MVT::i16) { 40453 SDNode *Result = Emit_218(N, X86::ADC16mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40454 return Result; 40455 } 40456 40457 // Pattern: (st:isVoid (adde:i32 GR32:i32:$src2, (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40458 // Emits: (ADC32mr:isVoid addr:iPTR:$dst, GR32:i32:$src2) 40459 // Pattern complexity = 47 cost = 1 size = 3 40460 if (N1.getNode()->getValueType(0) == MVT::i32) { 40461 SDNode *Result = Emit_218(N, X86::ADC32mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40462 return Result; 40463 } 40464 } 40465 } 40466 } 40467 } 40468 } 40469 40470 // Pattern: (st:isVoid (add:i64 GR64:i64:$src2, (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40471 // Emits: (ADD64mr:isVoid addr:iPTR:$dst, GR64:i64:$src2) 40472 // Pattern complexity = 47 cost = 1 size = 3 40473 if (N1.getOpcode() == ISD::ADD && 40474 N1.hasOneUse()) { 40475 SDValue N10 = N1.getOperand(0); 40476 SDValue N11 = N1.getOperand(1); 40477 if (N11.getOpcode() == ISD::LOAD && 40478 N11.hasOneUse() && 40479 IsLegalAndProfitableToFold(N11.getNode(), N1.getNode(), N.getNode()) && 40480 (Chain.getNode() == N11.getNode() || IsChainCompatible(Chain.getNode(), N11.getNode()))) { 40481 SDValue Chain11 = N11.getOperand(0); 40482 if (Predicate_unindexedload(N11.getNode()) && 40483 Predicate_load(N11.getNode())) { 40484 SDValue N111 = N11.getOperand(1); 40485 SDValue CPTmpN111_0; 40486 SDValue CPTmpN111_1; 40487 SDValue CPTmpN111_2; 40488 SDValue CPTmpN111_3; 40489 SDValue CPTmpN111_4; 40490 if (SelectAddr(N, N111, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4)) { 40491 SDValue N2 = N.getOperand(2); 40492 if (N111 == N2 && 40493 N1.getNode()->getValueType(0) == MVT::i64) { 40494 SDNode *Result = Emit_217(N, X86::ADD64mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40495 return Result; 40496 } 40497 } 40498 } 40499 } 40500 } 40501 40502 // Pattern: (st:isVoid (adde:i64 GR64:i64:$src2, (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40503 // Emits: (ADC64mr:isVoid addr:iPTR:$dst, GR64:i64:$src2) 40504 // Pattern complexity = 47 cost = 1 size = 3 40505 if (N1.getOpcode() == ISD::ADDE && 40506 N1.hasOneUse()) { 40507 SDValue N10 = N1.getOperand(0); 40508 SDValue N11 = N1.getOperand(1); 40509 if (N11.getOpcode() == ISD::LOAD && 40510 N11.hasOneUse() && 40511 IsLegalAndProfitableToFold(N11.getNode(), N1.getNode(), N.getNode()) && 40512 (Chain.getNode() == N11.getNode() || IsChainCompatible(Chain.getNode(), N11.getNode()))) { 40513 SDValue Chain11 = N11.getOperand(0); 40514 if (Predicate_unindexedload(N11.getNode()) && 40515 Predicate_load(N11.getNode())) { 40516 SDValue N111 = N11.getOperand(1); 40517 SDValue CPTmpN111_0; 40518 SDValue CPTmpN111_1; 40519 SDValue CPTmpN111_2; 40520 SDValue CPTmpN111_3; 40521 SDValue CPTmpN111_4; 40522 if (SelectAddr(N, N111, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4)) { 40523 SDValue N2 = N.getOperand(2); 40524 if (N111 == N2 && 40525 N1.getNode()->getValueType(0) == MVT::i64) { 40526 SDNode *Result = Emit_218(N, X86::ADC64mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40527 return Result; 40528 } 40529 } 40530 } 40531 } 40532 } 40533 40534 // Pattern: (st:isVoid (and:i64 GR64:i64:$src, (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40535 // Emits: (AND64mr:isVoid addr:iPTR:$dst, GR64:i64:$src) 40536 // Pattern complexity = 47 cost = 1 size = 3 40537 if (N1.getOpcode() == ISD::AND && 40538 N1.hasOneUse()) { 40539 SDValue N10 = N1.getOperand(0); 40540 SDValue N11 = N1.getOperand(1); 40541 if (N11.getOpcode() == ISD::LOAD && 40542 N11.hasOneUse() && 40543 IsLegalAndProfitableToFold(N11.getNode(), N1.getNode(), N.getNode()) && 40544 (Chain.getNode() == N11.getNode() || IsChainCompatible(Chain.getNode(), N11.getNode()))) { 40545 SDValue Chain11 = N11.getOperand(0); 40546 if (Predicate_unindexedload(N11.getNode()) && 40547 Predicate_load(N11.getNode())) { 40548 SDValue N111 = N11.getOperand(1); 40549 SDValue CPTmpN111_0; 40550 SDValue CPTmpN111_1; 40551 SDValue CPTmpN111_2; 40552 SDValue CPTmpN111_3; 40553 SDValue CPTmpN111_4; 40554 if (SelectAddr(N, N111, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4)) { 40555 SDValue N2 = N.getOperand(2); 40556 if (N111 == N2 && 40557 N1.getNode()->getValueType(0) == MVT::i64) { 40558 SDNode *Result = Emit_217(N, X86::AND64mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40559 return Result; 40560 } 40561 } 40562 } 40563 } 40564 } 40565 40566 // Pattern: (st:isVoid (or:i64 GR64:i64:$src, (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40567 // Emits: (OR64mr:isVoid addr:iPTR:$dst, GR64:i64:$src) 40568 // Pattern complexity = 47 cost = 1 size = 3 40569 if (N1.getOpcode() == ISD::OR && 40570 N1.hasOneUse()) { 40571 SDValue N10 = N1.getOperand(0); 40572 SDValue N11 = N1.getOperand(1); 40573 if (N11.getOpcode() == ISD::LOAD && 40574 N11.hasOneUse() && 40575 IsLegalAndProfitableToFold(N11.getNode(), N1.getNode(), N.getNode()) && 40576 (Chain.getNode() == N11.getNode() || IsChainCompatible(Chain.getNode(), N11.getNode()))) { 40577 SDValue Chain11 = N11.getOperand(0); 40578 if (Predicate_unindexedload(N11.getNode()) && 40579 Predicate_load(N11.getNode())) { 40580 SDValue N111 = N11.getOperand(1); 40581 SDValue CPTmpN111_0; 40582 SDValue CPTmpN111_1; 40583 SDValue CPTmpN111_2; 40584 SDValue CPTmpN111_3; 40585 SDValue CPTmpN111_4; 40586 if (SelectAddr(N, N111, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4)) { 40587 SDValue N2 = N.getOperand(2); 40588 if (N111 == N2 && 40589 N1.getNode()->getValueType(0) == MVT::i64) { 40590 SDNode *Result = Emit_217(N, X86::OR64mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40591 return Result; 40592 } 40593 } 40594 } 40595 } 40596 } 40597 40598 // Pattern: (st:isVoid (xor:i64 GR64:i64:$src, (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>>), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40599 // Emits: (XOR64mr:isVoid addr:iPTR:$dst, GR64:i64:$src) 40600 // Pattern complexity = 47 cost = 1 size = 3 40601 if (N1.getOpcode() == ISD::XOR && 40602 N1.hasOneUse()) { 40603 SDValue N10 = N1.getOperand(0); 40604 SDValue N11 = N1.getOperand(1); 40605 if (N11.getOpcode() == ISD::LOAD && 40606 N11.hasOneUse() && 40607 IsLegalAndProfitableToFold(N11.getNode(), N1.getNode(), N.getNode()) && 40608 (Chain.getNode() == N11.getNode() || IsChainCompatible(Chain.getNode(), N11.getNode()))) { 40609 SDValue Chain11 = N11.getOperand(0); 40610 if (Predicate_unindexedload(N11.getNode()) && 40611 Predicate_load(N11.getNode())) { 40612 SDValue N111 = N11.getOperand(1); 40613 SDValue CPTmpN111_0; 40614 SDValue CPTmpN111_1; 40615 SDValue CPTmpN111_2; 40616 SDValue CPTmpN111_3; 40617 SDValue CPTmpN111_4; 40618 if (SelectAddr(N, N111, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4)) { 40619 SDValue N2 = N.getOperand(2); 40620 if (N111 == N2 && 40621 N1.getNode()->getValueType(0) == MVT::i64) { 40622 SDNode *Result = Emit_217(N, X86::XOR64mr, CPTmpN111_0, CPTmpN111_1, CPTmpN111_2, CPTmpN111_3, CPTmpN111_4); 40623 return Result; 40624 } 40625 } 40626 } 40627 } 40628 } 40629 } 40630 } 40631 40632 // Pattern: (st:isVoid (vector_extract:f64 (vector_shuffle:v2f64 (bitconvert:v2f64 VR128:v4f32:$src), (undef:v2f64))<<P:Predicate_unpckh>>, 0:iPTR), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40633 // Emits: (MOVHPSmr:isVoid addr:iPTR:$dst, VR128:v4f32:$src) 40634 // Pattern complexity = 40 cost = 1 size = 3 40635 if ((Subtarget->hasSSE1())) { 40636 SDValue Chain = N.getOperand(0); 40637 if (Predicate_unindexedstore(N.getNode()) && 40638 Predicate_store(N.getNode())) { 40639 SDValue N1 = N.getOperand(1); 40640 if (N1.getOpcode() == ISD::EXTRACT_VECTOR_ELT) { 40641 SDValue N10 = N1.getOperand(0); 40642 if (N10.getOpcode() == ISD::VECTOR_SHUFFLE && 40643 Predicate_unpckh(N10.getNode())) { 40644 SDValue N100 = N10.getOperand(0); 40645 if (N100.getOpcode() == ISD::BIT_CONVERT) { 40646 SDValue N1000 = N100.getOperand(0); 40647 SDValue N101 = N10.getOperand(1); 40648 if (N101.getOpcode() == ISD::UNDEF) { 40649 SDValue N11 = N1.getOperand(1); 40650 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 40651 if (Tmp0) { 40652 int64_t CN1 = Tmp0->getSExtValue(); 40653 if (CN1 == INT64_C(0)) { 40654 SDValue N2 = N.getOperand(2); 40655 SDValue CPTmpN2_0; 40656 SDValue CPTmpN2_1; 40657 SDValue CPTmpN2_2; 40658 SDValue CPTmpN2_3; 40659 SDValue CPTmpN2_4; 40660 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 40661 N1.getNode()->getValueType(0) == MVT::f64 && 40662 N10.getNode()->getValueType(0) == MVT::v2f64 && 40663 N1000.getNode()->getValueType(0) == MVT::v4f32) { 40664 SDNode *Result = Emit_196(N, X86::MOVHPSmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 40665 return Result; 40666 } 40667 } 40668 } 40669 } 40670 } 40671 } 40672 } 40673 } 40674 } 40675 40676 // Pattern: (st:isVoid (vector_extract:f64 (vector_shuffle:v2f64 VR128:v2f64:$src, (undef:v2f64))<<P:Predicate_unpckh>>, 0:iPTR), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40677 // Emits: (MOVHPDmr:isVoid addr:iPTR:$dst, VR128:v2f64:$src) 40678 // Pattern complexity = 37 cost = 1 size = 3 40679 if ((Subtarget->hasSSE2())) { 40680 SDValue Chain = N.getOperand(0); 40681 if (Predicate_unindexedstore(N.getNode()) && 40682 Predicate_store(N.getNode())) { 40683 SDValue N1 = N.getOperand(1); 40684 if (N1.getOpcode() == ISD::EXTRACT_VECTOR_ELT) { 40685 SDValue N10 = N1.getOperand(0); 40686 if (N10.getOpcode() == ISD::VECTOR_SHUFFLE && 40687 Predicate_unpckh(N10.getNode())) { 40688 SDValue N100 = N10.getOperand(0); 40689 SDValue N101 = N10.getOperand(1); 40690 if (N101.getOpcode() == ISD::UNDEF) { 40691 SDValue N11 = N1.getOperand(1); 40692 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 40693 if (Tmp0) { 40694 int64_t CN1 = Tmp0->getSExtValue(); 40695 if (CN1 == INT64_C(0)) { 40696 SDValue N2 = N.getOperand(2); 40697 SDValue CPTmpN2_0; 40698 SDValue CPTmpN2_1; 40699 SDValue CPTmpN2_2; 40700 SDValue CPTmpN2_3; 40701 SDValue CPTmpN2_4; 40702 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 40703 N1.getNode()->getValueType(0) == MVT::f64 && 40704 N10.getNode()->getValueType(0) == MVT::v2f64) { 40705 SDNode *Result = Emit_198(N, X86::MOVHPDmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 40706 return Result; 40707 } 40708 } 40709 } 40710 } 40711 } 40712 } 40713 } 40714 } 40715 40716 // Pattern: (st:isVoid (trunc:i8 (srl:i64 GR64:i64:$src, 8:i8)<<P:Predicate_srl_su>>)<<P:Predicate_trunc_su>>, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40717 // Emits: (MOV8mr_NOREX:isVoid addr:i64:$dst, (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i64 GR64:i64:$src, GR64_ABCD:i64), 2:i32)) 40718 // Pattern complexity = 35 cost = 3 size = 3 40719 { 40720 SDValue Chain = N.getOperand(0); 40721 if (Predicate_unindexedstore(N.getNode()) && 40722 Predicate_store(N.getNode())) { 40723 SDValue N1 = N.getOperand(1); 40724 if (N1.getOpcode() == ISD::TRUNCATE && 40725 Predicate_trunc_su(N1.getNode())) { 40726 SDValue N10 = N1.getOperand(0); 40727 if (N10.getOpcode() == ISD::SRL && 40728 Predicate_srl_su(N10.getNode())) { 40729 SDValue N100 = N10.getOperand(0); 40730 SDValue N101 = N10.getOperand(1); 40731 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N101); 40732 if (Tmp0) { 40733 int64_t CN1 = Tmp0->getSExtValue(); 40734 if (CN1 == INT64_C(8)) { 40735 SDValue N2 = N.getOperand(2); 40736 SDValue CPTmpN2_0; 40737 SDValue CPTmpN2_1; 40738 SDValue CPTmpN2_2; 40739 SDValue CPTmpN2_3; 40740 SDValue CPTmpN2_4; 40741 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 40742 N1.getNode()->getValueType(0) == MVT::i8 && 40743 N10.getNode()->getValueType(0) == MVT::i64 && 40744 N101.getNode()->getValueType(0) == MVT::i8) { 40745 SDNode *Result = Emit_210(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, X86::MOV8mr_NOREX, MVT::i64, MVT::i8, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 40746 return Result; 40747 } 40748 } 40749 } 40750 } 40751 } 40752 } 40753 } 40754 if ((Subtarget->is64Bit())) { 40755 SDValue Chain = N.getOperand(0); 40756 if (Predicate_unindexedstore(N.getNode()) && 40757 Predicate_store(N.getNode())) { 40758 SDValue N1 = N.getOperand(1); 40759 if (N1.getOpcode() == ISD::TRUNCATE && 40760 Predicate_trunc_su(N1.getNode())) { 40761 SDValue N10 = N1.getOperand(0); 40762 if (N10.getOpcode() == ISD::SRL && 40763 Predicate_srl_su(N10.getNode())) { 40764 SDValue N100 = N10.getOperand(0); 40765 SDValue N101 = N10.getOperand(1); 40766 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N101); 40767 if (Tmp0) { 40768 int64_t CN1 = Tmp0->getSExtValue(); 40769 if (CN1 == INT64_C(8)) { 40770 SDValue N2 = N.getOperand(2); 40771 SDValue CPTmpN2_0; 40772 SDValue CPTmpN2_1; 40773 SDValue CPTmpN2_2; 40774 SDValue CPTmpN2_3; 40775 SDValue CPTmpN2_4; 40776 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 40777 N1.getNode()->getValueType(0) == MVT::i8) { 40778 40779 // Pattern: (st:isVoid (trunc:i8 (srl:i32 GR32:i32:$src, 8:i8)<<P:Predicate_srl_su>>)<<P:Predicate_trunc_su>>, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40780 // Emits: (MOV8mr_NOREX:isVoid addr:i64:$dst, (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i32 GR32:i32:$src, GR32_ABCD:i32), 2:i32)) 40781 // Pattern complexity = 35 cost = 3 size = 3 40782 if (N10.getNode()->getValueType(0) == MVT::i32 && 40783 N101.getNode()->getValueType(0) == MVT::i8) { 40784 SDNode *Result = Emit_211(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, X86::MOV8mr_NOREX, MVT::i32, MVT::i8, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 40785 return Result; 40786 } 40787 40788 // Pattern: (st:isVoid (trunc:i8 (srl:i16 GR16:i16:$src, 8:i8)<<P:Predicate_srl_su>>)<<P:Predicate_trunc_su>>, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40789 // Emits: (MOV8mr_NOREX:isVoid addr:i64:$dst, (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i16 GR16:i16:$src, GR16_ABCD:i16), 2:i32)) 40790 // Pattern complexity = 35 cost = 3 size = 3 40791 if (N10.getNode()->getValueType(0) == MVT::i16 && 40792 N101.getNode()->getValueType(0) == MVT::i8) { 40793 SDNode *Result = Emit_212(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, X86::MOV8mr_NOREX, MVT::i16, MVT::i8, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 40794 return Result; 40795 } 40796 } 40797 } 40798 } 40799 } 40800 } 40801 } 40802 } 40803 40804 // Pattern: (st:isVoid (bitconvert:f32 (extractelt:i32 (bitconvert:v4i32 VR128:v4f32:$src1), (imm:iPTR):$src2)), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40805 // Emits: (EXTRACTPSmr:isVoid addr:iPTR:$dst, VR128:v16i8:$src1, (imm:i32):$src2) 40806 // Pattern complexity = 34 cost = 1 size = 3 40807 if ((Subtarget->hasSSE41())) { 40808 SDValue Chain = N.getOperand(0); 40809 if (Predicate_unindexedstore(N.getNode()) && 40810 Predicate_store(N.getNode())) { 40811 SDValue N1 = N.getOperand(1); 40812 if (N1.getOpcode() == ISD::BIT_CONVERT) { 40813 SDValue N10 = N1.getOperand(0); 40814 if (N10.getOpcode() == ISD::EXTRACT_VECTOR_ELT) { 40815 SDValue N100 = N10.getOperand(0); 40816 if (N100.getOpcode() == ISD::BIT_CONVERT) { 40817 SDValue N1000 = N100.getOperand(0); 40818 SDValue N101 = N10.getOperand(1); 40819 if (N101.getOpcode() == ISD::Constant) { 40820 SDValue N2 = N.getOperand(2); 40821 SDValue CPTmpN2_0; 40822 SDValue CPTmpN2_1; 40823 SDValue CPTmpN2_2; 40824 SDValue CPTmpN2_3; 40825 SDValue CPTmpN2_4; 40826 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 40827 N1.getNode()->getValueType(0) == MVT::f32 && 40828 N10.getNode()->getValueType(0) == MVT::i32 && 40829 N100.getNode()->getValueType(0) == MVT::v4i32 && 40830 N1000.getNode()->getValueType(0) == MVT::v4f32) { 40831 SDNode *Result = Emit_216(N, X86::EXTRACTPSmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 40832 return Result; 40833 } 40834 } 40835 } 40836 } 40837 } 40838 } 40839 } 40840 40841 // Pattern: (st:isVoid (vector_extract:f64 (bitconvert:v2f64 VR128:v4f32:$src), 0:iPTR), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40842 // Emits: (MOVLPSmr:isVoid addr:iPTR:$dst, VR128:v4f32:$src) 40843 // Pattern complexity = 33 cost = 1 size = 3 40844 if ((Subtarget->hasSSE1())) { 40845 SDValue Chain = N.getOperand(0); 40846 if (Predicate_unindexedstore(N.getNode()) && 40847 Predicate_store(N.getNode())) { 40848 SDValue N1 = N.getOperand(1); 40849 if (N1.getOpcode() == ISD::EXTRACT_VECTOR_ELT) { 40850 SDValue N10 = N1.getOperand(0); 40851 if (N10.getOpcode() == ISD::BIT_CONVERT) { 40852 SDValue N100 = N10.getOperand(0); 40853 SDValue N11 = N1.getOperand(1); 40854 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 40855 if (Tmp0) { 40856 int64_t CN1 = Tmp0->getSExtValue(); 40857 if (CN1 == INT64_C(0)) { 40858 SDValue N2 = N.getOperand(2); 40859 SDValue CPTmpN2_0; 40860 SDValue CPTmpN2_1; 40861 SDValue CPTmpN2_2; 40862 SDValue CPTmpN2_3; 40863 SDValue CPTmpN2_4; 40864 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 40865 N1.getNode()->getValueType(0) == MVT::f64 && 40866 N10.getNode()->getValueType(0) == MVT::v2f64 && 40867 N100.getNode()->getValueType(0) == MVT::v4f32) { 40868 SDNode *Result = Emit_195(N, X86::MOVLPSmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 40869 return Result; 40870 } 40871 } 40872 } 40873 } 40874 } 40875 } 40876 } 40877 40878 // Pattern: (st:isVoid (extractelt:i32 (bitconvert:v4i32 VR128:v4f32:$src1), (imm:iPTR):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40879 // Emits: (EXTRACTPSmr:isVoid addr:iPTR:$dst, VR128:v4f32:$src1, (imm:i32):$src2) 40880 // Pattern complexity = 31 cost = 1 size = 3 40881 if ((Subtarget->hasSSE41())) { 40882 SDValue Chain = N.getOperand(0); 40883 if (Predicate_unindexedstore(N.getNode()) && 40884 Predicate_store(N.getNode())) { 40885 SDValue N1 = N.getOperand(1); 40886 if (N1.getOpcode() == ISD::EXTRACT_VECTOR_ELT) { 40887 SDValue N10 = N1.getOperand(0); 40888 if (N10.getOpcode() == ISD::BIT_CONVERT) { 40889 SDValue N100 = N10.getOperand(0); 40890 SDValue N11 = N1.getOperand(1); 40891 if (N11.getOpcode() == ISD::Constant) { 40892 SDValue N2 = N.getOperand(2); 40893 SDValue CPTmpN2_0; 40894 SDValue CPTmpN2_1; 40895 SDValue CPTmpN2_2; 40896 SDValue CPTmpN2_3; 40897 SDValue CPTmpN2_4; 40898 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 40899 N1.getNode()->getValueType(0) == MVT::i32 && 40900 N10.getNode()->getValueType(0) == MVT::v4i32 && 40901 N100.getNode()->getValueType(0) == MVT::v4f32) { 40902 SDNode *Result = Emit_199(N, X86::EXTRACTPSmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 40903 return Result; 40904 } 40905 } 40906 } 40907 } 40908 } 40909 } 40910 { 40911 SDValue Chain = N.getOperand(0); 40912 if (Predicate_unindexedstore(N.getNode()) && 40913 Predicate_store(N.getNode())) { 40914 SDValue N1 = N.getOperand(1); 40915 if (N1.getOpcode() == X86ISD::SETCC) { 40916 SDValue N10 = N1.getOperand(0); 40917 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N10); 40918 if (Tmp0) { 40919 int64_t CN1 = Tmp0->getSExtValue(); 40920 40921 // Pattern: (st:isVoid (X86setcc:i8 4:i8, EFLAGS:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40922 // Emits: (SETEm:isVoid addr:iPTR:$dst) 40923 // Pattern complexity = 30 cost = 1 size = 3 40924 if (CN1 == INT64_C(4)) { 40925 SDValue N11 = N1.getOperand(1); 40926 SDValue N2 = N.getOperand(2); 40927 SDValue CPTmpN2_0; 40928 SDValue CPTmpN2_1; 40929 SDValue CPTmpN2_2; 40930 SDValue CPTmpN2_3; 40931 SDValue CPTmpN2_4; 40932 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 40933 SDNode *Result = Emit_189(N, X86::SETEm, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 40934 return Result; 40935 } 40936 } 40937 40938 // Pattern: (st:isVoid (X86setcc:i8 9:i8, EFLAGS:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40939 // Emits: (SETNEm:isVoid addr:iPTR:$dst) 40940 // Pattern complexity = 30 cost = 1 size = 3 40941 if (CN1 == INT64_C(9)) { 40942 SDValue N11 = N1.getOperand(1); 40943 SDValue N2 = N.getOperand(2); 40944 SDValue CPTmpN2_0; 40945 SDValue CPTmpN2_1; 40946 SDValue CPTmpN2_2; 40947 SDValue CPTmpN2_3; 40948 SDValue CPTmpN2_4; 40949 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 40950 SDNode *Result = Emit_189(N, X86::SETNEm, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 40951 return Result; 40952 } 40953 } 40954 40955 // Pattern: (st:isVoid (X86setcc:i8 7:i8, EFLAGS:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40956 // Emits: (SETLm:isVoid addr:iPTR:$dst) 40957 // Pattern complexity = 30 cost = 1 size = 3 40958 if (CN1 == INT64_C(7)) { 40959 SDValue N11 = N1.getOperand(1); 40960 SDValue N2 = N.getOperand(2); 40961 SDValue CPTmpN2_0; 40962 SDValue CPTmpN2_1; 40963 SDValue CPTmpN2_2; 40964 SDValue CPTmpN2_3; 40965 SDValue CPTmpN2_4; 40966 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 40967 SDNode *Result = Emit_189(N, X86::SETLm, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 40968 return Result; 40969 } 40970 } 40971 40972 // Pattern: (st:isVoid (X86setcc:i8 6:i8, EFLAGS:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40973 // Emits: (SETGEm:isVoid addr:iPTR:$dst) 40974 // Pattern complexity = 30 cost = 1 size = 3 40975 if (CN1 == INT64_C(6)) { 40976 SDValue N11 = N1.getOperand(1); 40977 SDValue N2 = N.getOperand(2); 40978 SDValue CPTmpN2_0; 40979 SDValue CPTmpN2_1; 40980 SDValue CPTmpN2_2; 40981 SDValue CPTmpN2_3; 40982 SDValue CPTmpN2_4; 40983 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 40984 SDNode *Result = Emit_189(N, X86::SETGEm, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 40985 return Result; 40986 } 40987 } 40988 40989 // Pattern: (st:isVoid (X86setcc:i8 8:i8, EFLAGS:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 40990 // Emits: (SETLEm:isVoid addr:iPTR:$dst) 40991 // Pattern complexity = 30 cost = 1 size = 3 40992 if (CN1 == INT64_C(8)) { 40993 SDValue N11 = N1.getOperand(1); 40994 SDValue N2 = N.getOperand(2); 40995 SDValue CPTmpN2_0; 40996 SDValue CPTmpN2_1; 40997 SDValue CPTmpN2_2; 40998 SDValue CPTmpN2_3; 40999 SDValue CPTmpN2_4; 41000 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41001 SDNode *Result = Emit_189(N, X86::SETLEm, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41002 return Result; 41003 } 41004 } 41005 41006 // Pattern: (st:isVoid (X86setcc:i8 5:i8, EFLAGS:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41007 // Emits: (SETGm:isVoid addr:iPTR:$dst) 41008 // Pattern complexity = 30 cost = 1 size = 3 41009 if (CN1 == INT64_C(5)) { 41010 SDValue N11 = N1.getOperand(1); 41011 SDValue N2 = N.getOperand(2); 41012 SDValue CPTmpN2_0; 41013 SDValue CPTmpN2_1; 41014 SDValue CPTmpN2_2; 41015 SDValue CPTmpN2_3; 41016 SDValue CPTmpN2_4; 41017 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41018 SDNode *Result = Emit_189(N, X86::SETGm, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41019 return Result; 41020 } 41021 } 41022 41023 // Pattern: (st:isVoid (X86setcc:i8 2:i8, EFLAGS:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41024 // Emits: (SETBm:isVoid addr:iPTR:$dst) 41025 // Pattern complexity = 30 cost = 1 size = 3 41026 if (CN1 == INT64_C(2)) { 41027 SDValue N11 = N1.getOperand(1); 41028 SDValue N2 = N.getOperand(2); 41029 SDValue CPTmpN2_0; 41030 SDValue CPTmpN2_1; 41031 SDValue CPTmpN2_2; 41032 SDValue CPTmpN2_3; 41033 SDValue CPTmpN2_4; 41034 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41035 SDNode *Result = Emit_189(N, X86::SETBm, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41036 return Result; 41037 } 41038 } 41039 41040 // Pattern: (st:isVoid (X86setcc:i8 1:i8, EFLAGS:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41041 // Emits: (SETAEm:isVoid addr:iPTR:$dst) 41042 // Pattern complexity = 30 cost = 1 size = 3 41043 if (CN1 == INT64_C(1)) { 41044 SDValue N11 = N1.getOperand(1); 41045 SDValue N2 = N.getOperand(2); 41046 SDValue CPTmpN2_0; 41047 SDValue CPTmpN2_1; 41048 SDValue CPTmpN2_2; 41049 SDValue CPTmpN2_3; 41050 SDValue CPTmpN2_4; 41051 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41052 SDNode *Result = Emit_189(N, X86::SETAEm, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41053 return Result; 41054 } 41055 } 41056 41057 // Pattern: (st:isVoid (X86setcc:i8 3:i8, EFLAGS:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41058 // Emits: (SETBEm:isVoid addr:iPTR:$dst) 41059 // Pattern complexity = 30 cost = 1 size = 3 41060 if (CN1 == INT64_C(3)) { 41061 SDValue N11 = N1.getOperand(1); 41062 SDValue N2 = N.getOperand(2); 41063 SDValue CPTmpN2_0; 41064 SDValue CPTmpN2_1; 41065 SDValue CPTmpN2_2; 41066 SDValue CPTmpN2_3; 41067 SDValue CPTmpN2_4; 41068 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41069 SDNode *Result = Emit_189(N, X86::SETBEm, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41070 return Result; 41071 } 41072 } 41073 41074 // Pattern: (st:isVoid (X86setcc:i8 0:i8, EFLAGS:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41075 // Emits: (SETAm:isVoid addr:iPTR:$dst) 41076 // Pattern complexity = 30 cost = 1 size = 3 41077 if (CN1 == INT64_C(0)) { 41078 SDValue N11 = N1.getOperand(1); 41079 SDValue N2 = N.getOperand(2); 41080 SDValue CPTmpN2_0; 41081 SDValue CPTmpN2_1; 41082 SDValue CPTmpN2_2; 41083 SDValue CPTmpN2_3; 41084 SDValue CPTmpN2_4; 41085 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41086 SDNode *Result = Emit_189(N, X86::SETAm, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41087 return Result; 41088 } 41089 } 41090 41091 // Pattern: (st:isVoid (X86setcc:i8 15:i8, EFLAGS:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41092 // Emits: (SETSm:isVoid addr:iPTR:$dst) 41093 // Pattern complexity = 30 cost = 1 size = 3 41094 if (CN1 == INT64_C(15)) { 41095 SDValue N11 = N1.getOperand(1); 41096 SDValue N2 = N.getOperand(2); 41097 SDValue CPTmpN2_0; 41098 SDValue CPTmpN2_1; 41099 SDValue CPTmpN2_2; 41100 SDValue CPTmpN2_3; 41101 SDValue CPTmpN2_4; 41102 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41103 SDNode *Result = Emit_189(N, X86::SETSm, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41104 return Result; 41105 } 41106 } 41107 41108 // Pattern: (st:isVoid (X86setcc:i8 12:i8, EFLAGS:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41109 // Emits: (SETNSm:isVoid addr:iPTR:$dst) 41110 // Pattern complexity = 30 cost = 1 size = 3 41111 if (CN1 == INT64_C(12)) { 41112 SDValue N11 = N1.getOperand(1); 41113 SDValue N2 = N.getOperand(2); 41114 SDValue CPTmpN2_0; 41115 SDValue CPTmpN2_1; 41116 SDValue CPTmpN2_2; 41117 SDValue CPTmpN2_3; 41118 SDValue CPTmpN2_4; 41119 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41120 SDNode *Result = Emit_189(N, X86::SETNSm, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41121 return Result; 41122 } 41123 } 41124 41125 // Pattern: (st:isVoid (X86setcc:i8 14:i8, EFLAGS:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41126 // Emits: (SETPm:isVoid addr:iPTR:$dst) 41127 // Pattern complexity = 30 cost = 1 size = 3 41128 if (CN1 == INT64_C(14)) { 41129 SDValue N11 = N1.getOperand(1); 41130 SDValue N2 = N.getOperand(2); 41131 SDValue CPTmpN2_0; 41132 SDValue CPTmpN2_1; 41133 SDValue CPTmpN2_2; 41134 SDValue CPTmpN2_3; 41135 SDValue CPTmpN2_4; 41136 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41137 SDNode *Result = Emit_189(N, X86::SETPm, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41138 return Result; 41139 } 41140 } 41141 41142 // Pattern: (st:isVoid (X86setcc:i8 11:i8, EFLAGS:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41143 // Emits: (SETNPm:isVoid addr:iPTR:$dst) 41144 // Pattern complexity = 30 cost = 1 size = 3 41145 if (CN1 == INT64_C(11)) { 41146 SDValue N11 = N1.getOperand(1); 41147 SDValue N2 = N.getOperand(2); 41148 SDValue CPTmpN2_0; 41149 SDValue CPTmpN2_1; 41150 SDValue CPTmpN2_2; 41151 SDValue CPTmpN2_3; 41152 SDValue CPTmpN2_4; 41153 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41154 SDNode *Result = Emit_189(N, X86::SETNPm, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41155 return Result; 41156 } 41157 } 41158 41159 // Pattern: (st:isVoid (X86setcc:i8 13:i8, EFLAGS:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41160 // Emits: (SETOm:isVoid addr:iPTR:$dst) 41161 // Pattern complexity = 30 cost = 1 size = 3 41162 if (CN1 == INT64_C(13)) { 41163 SDValue N11 = N1.getOperand(1); 41164 SDValue N2 = N.getOperand(2); 41165 SDValue CPTmpN2_0; 41166 SDValue CPTmpN2_1; 41167 SDValue CPTmpN2_2; 41168 SDValue CPTmpN2_3; 41169 SDValue CPTmpN2_4; 41170 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41171 SDNode *Result = Emit_189(N, X86::SETOm, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41172 return Result; 41173 } 41174 } 41175 41176 // Pattern: (st:isVoid (X86setcc:i8 10:i8, EFLAGS:i32), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41177 // Emits: (SETNOm:isVoid addr:iPTR:$dst) 41178 // Pattern complexity = 30 cost = 1 size = 3 41179 if (CN1 == INT64_C(10)) { 41180 SDValue N11 = N1.getOperand(1); 41181 SDValue N2 = N.getOperand(2); 41182 SDValue CPTmpN2_0; 41183 SDValue CPTmpN2_1; 41184 SDValue CPTmpN2_2; 41185 SDValue CPTmpN2_3; 41186 SDValue CPTmpN2_4; 41187 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41188 SDNode *Result = Emit_189(N, X86::SETNOm, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41189 return Result; 41190 } 41191 } 41192 } 41193 } 41194 } 41195 } 41196 41197 // Pattern: (st:isVoid (vector_extract:f32 VR128:v4f32:$src, 0:iPTR), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41198 // Emits: (MOVPS2SSmr:isVoid addr:iPTR:$dst, VR128:v4f32:$src) 41199 // Pattern complexity = 30 cost = 1 size = 3 41200 if ((Subtarget->hasSSE1())) { 41201 SDValue Chain = N.getOperand(0); 41202 if (Predicate_unindexedstore(N.getNode()) && 41203 Predicate_store(N.getNode())) { 41204 SDValue N1 = N.getOperand(1); 41205 if (N1.getOpcode() == ISD::EXTRACT_VECTOR_ELT) { 41206 SDValue N10 = N1.getOperand(0); 41207 SDValue N11 = N1.getOperand(1); 41208 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 41209 if (Tmp0) { 41210 int64_t CN1 = Tmp0->getSExtValue(); 41211 if (CN1 == INT64_C(0)) { 41212 SDValue N2 = N.getOperand(2); 41213 SDValue CPTmpN2_0; 41214 SDValue CPTmpN2_1; 41215 SDValue CPTmpN2_2; 41216 SDValue CPTmpN2_3; 41217 SDValue CPTmpN2_4; 41218 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41219 N1.getNode()->getValueType(0) == MVT::f32 && 41220 N10.getNode()->getValueType(0) == MVT::v4f32) { 41221 SDNode *Result = Emit_197(N, X86::MOVPS2SSmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41222 return Result; 41223 } 41224 } 41225 } 41226 } 41227 } 41228 } 41229 if ((Subtarget->hasSSE2())) { 41230 SDValue Chain = N.getOperand(0); 41231 if (Predicate_unindexedstore(N.getNode()) && 41232 Predicate_store(N.getNode())) { 41233 SDValue N1 = N.getOperand(1); 41234 if (N1.getOpcode() == ISD::EXTRACT_VECTOR_ELT) { 41235 SDValue N10 = N1.getOperand(0); 41236 SDValue N11 = N1.getOperand(1); 41237 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N11); 41238 if (Tmp0) { 41239 int64_t CN1 = Tmp0->getSExtValue(); 41240 if (CN1 == INT64_C(0)) { 41241 SDValue N2 = N.getOperand(2); 41242 SDValue CPTmpN2_0; 41243 SDValue CPTmpN2_1; 41244 SDValue CPTmpN2_2; 41245 SDValue CPTmpN2_3; 41246 SDValue CPTmpN2_4; 41247 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41248 41249 // Pattern: (st:isVoid (vector_extract:f64 VR128:v2f64:$src, 0:iPTR), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41250 // Emits: (MOVLPDmr:isVoid addr:iPTR:$dst, VR128:v2f64:$src) 41251 // Pattern complexity = 30 cost = 1 size = 3 41252 if (N1.getNode()->getValueType(0) == MVT::f64 && 41253 N10.getNode()->getValueType(0) == MVT::v2f64) { 41254 SDNode *Result = Emit_197(N, X86::MOVLPDmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41255 return Result; 41256 } 41257 41258 // Pattern: (st:isVoid (vector_extract:i64 VR128:v2i64:$src, 0:iPTR), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41259 // Emits: (MOVPQI2QImr:isVoid addr:iPTR:$dst, VR128:v2i64:$src) 41260 // Pattern complexity = 30 cost = 1 size = 3 41261 if (N1.getNode()->getValueType(0) == MVT::i64 && 41262 N10.getNode()->getValueType(0) == MVT::v2i64) { 41263 SDNode *Result = Emit_197(N, X86::MOVPQI2QImr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41264 return Result; 41265 } 41266 41267 // Pattern: (st:isVoid (vector_extract:f64 VR128:v2f64:$src, 0:iPTR), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41268 // Emits: (MOVPD2SDmr:isVoid addr:iPTR:$dst, VR128:v2f64:$src) 41269 // Pattern complexity = 30 cost = 1 size = 3 41270 if (N1.getNode()->getValueType(0) == MVT::f64 && 41271 N10.getNode()->getValueType(0) == MVT::v2f64) { 41272 SDNode *Result = Emit_197(N, X86::MOVPD2SDmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41273 return Result; 41274 } 41275 41276 // Pattern: (st:isVoid (vector_extract:i32 VR128:v4i32:$src, 0:iPTR), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41277 // Emits: (MOVPDI2DImr:isVoid addr:iPTR:$dst, VR128:v4i32:$src) 41278 // Pattern complexity = 30 cost = 1 size = 3 41279 if (N1.getNode()->getValueType(0) == MVT::i32 && 41280 N10.getNode()->getValueType(0) == MVT::v4i32) { 41281 SDNode *Result = Emit_197(N, X86::MOVPDI2DImr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41282 return Result; 41283 } 41284 } 41285 } 41286 } 41287 } 41288 } 41289 } 41290 if ((Subtarget->hasSSE41())) { 41291 SDValue Chain = N.getOperand(0); 41292 if (Predicate_unindexedstore(N.getNode()) && 41293 Predicate_store(N.getNode())) { 41294 SDValue N1 = N.getOperand(1); 41295 if (N1.getOpcode() == ISD::EXTRACT_VECTOR_ELT) { 41296 SDValue N10 = N1.getOperand(0); 41297 SDValue N11 = N1.getOperand(1); 41298 if (N11.getOpcode() == ISD::Constant) { 41299 SDValue N2 = N.getOperand(2); 41300 SDValue CPTmpN2_0; 41301 SDValue CPTmpN2_1; 41302 SDValue CPTmpN2_2; 41303 SDValue CPTmpN2_3; 41304 SDValue CPTmpN2_4; 41305 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41306 41307 // Pattern: (st:isVoid (extractelt:i64 VR128:v2i64:$src1, (imm:iPTR):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41308 // Emits: (PEXTRQmr:isVoid addr:iPTR:$dst, VR128:v2i64:$src1, (imm:i32):$src2) 41309 // Pattern complexity = 28 cost = 1 size = 3 41310 if (N1.getNode()->getValueType(0) == MVT::i64 && 41311 N10.getNode()->getValueType(0) == MVT::v2i64) { 41312 SDNode *Result = Emit_194(N, X86::PEXTRQmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41313 return Result; 41314 } 41315 41316 // Pattern: (st:isVoid (extractelt:i32 VR128:v4i32:$src1, (imm:iPTR):$src2), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41317 // Emits: (PEXTRDmr:isVoid addr:iPTR:$dst, VR128:v4i32:$src1, (imm:i32):$src2) 41318 // Pattern complexity = 28 cost = 1 size = 3 41319 if (N1.getNode()->getValueType(0) == MVT::i32 && 41320 N10.getNode()->getValueType(0) == MVT::v4i32) { 41321 SDNode *Result = Emit_194(N, X86::PEXTRDmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41322 return Result; 41323 } 41324 } 41325 } 41326 } 41327 } 41328 } 41329 if ((TM.getCodeModel() == CodeModel::Small ||TM.getCodeModel() == CodeModel::Kernel) && (TM.getRelocationModel() == Reloc::Static)) { 41330 SDValue Chain = N.getOperand(0); 41331 if (Predicate_unindexedstore(N.getNode()) && 41332 Predicate_store(N.getNode())) { 41333 SDValue N1 = N.getOperand(1); 41334 if (N1.getOpcode() == X86ISD::Wrapper) { 41335 SDValue N10 = N1.getOperand(0); 41336 41337 // Pattern: (st:isVoid (X86Wrapper:i64 (tconstpool:i64):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41338 // Emits: (MOV64mi32:isVoid addr:iPTR:$dst, (tconstpool:i64):$src) 41339 // Pattern complexity = 28 cost = 1 size = 3 41340 if (N10.getOpcode() == ISD::TargetConstantPool) { 41341 SDValue N2 = N.getOperand(2); 41342 SDValue CPTmpN2_0; 41343 SDValue CPTmpN2_1; 41344 SDValue CPTmpN2_2; 41345 SDValue CPTmpN2_3; 41346 SDValue CPTmpN2_4; 41347 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41348 N1.getNode()->getValueType(0) == MVT::i64) { 41349 SDNode *Result = Emit_193(N, X86::MOV64mi32, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41350 return Result; 41351 } 41352 } 41353 41354 // Pattern: (st:isVoid (X86Wrapper:i64 (tjumptable:i64):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41355 // Emits: (MOV64mi32:isVoid addr:iPTR:$dst, (tjumptable:i64):$src) 41356 // Pattern complexity = 28 cost = 1 size = 3 41357 if (N10.getOpcode() == ISD::TargetJumpTable) { 41358 SDValue N2 = N.getOperand(2); 41359 SDValue CPTmpN2_0; 41360 SDValue CPTmpN2_1; 41361 SDValue CPTmpN2_2; 41362 SDValue CPTmpN2_3; 41363 SDValue CPTmpN2_4; 41364 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41365 N1.getNode()->getValueType(0) == MVT::i64) { 41366 SDNode *Result = Emit_193(N, X86::MOV64mi32, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41367 return Result; 41368 } 41369 } 41370 41371 // Pattern: (st:isVoid (X86Wrapper:i64 (tglobaladdr:i64):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41372 // Emits: (MOV64mi32:isVoid addr:iPTR:$dst, (tglobaladdr:i64):$src) 41373 // Pattern complexity = 28 cost = 1 size = 3 41374 if (N10.getOpcode() == ISD::TargetGlobalAddress) { 41375 SDValue N2 = N.getOperand(2); 41376 SDValue CPTmpN2_0; 41377 SDValue CPTmpN2_1; 41378 SDValue CPTmpN2_2; 41379 SDValue CPTmpN2_3; 41380 SDValue CPTmpN2_4; 41381 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41382 N1.getNode()->getValueType(0) == MVT::i64) { 41383 SDNode *Result = Emit_193(N, X86::MOV64mi32, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41384 return Result; 41385 } 41386 } 41387 41388 // Pattern: (st:isVoid (X86Wrapper:i64 (texternalsym:i64):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41389 // Emits: (MOV64mi32:isVoid addr:iPTR:$dst, (texternalsym:i64):$src) 41390 // Pattern complexity = 28 cost = 1 size = 3 41391 if (N10.getOpcode() == ISD::TargetExternalSymbol) { 41392 SDValue N2 = N.getOperand(2); 41393 SDValue CPTmpN2_0; 41394 SDValue CPTmpN2_1; 41395 SDValue CPTmpN2_2; 41396 SDValue CPTmpN2_3; 41397 SDValue CPTmpN2_4; 41398 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41399 N1.getNode()->getValueType(0) == MVT::i64) { 41400 SDNode *Result = Emit_193(N, X86::MOV64mi32, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41401 return Result; 41402 } 41403 } 41404 } 41405 } 41406 } 41407 { 41408 SDValue Chain = N.getOperand(0); 41409 if (Predicate_unindexedstore(N.getNode()) && 41410 Predicate_store(N.getNode())) { 41411 SDValue N1 = N.getOperand(1); 41412 if (N1.getOpcode() == X86ISD::Wrapper) { 41413 SDValue N10 = N1.getOperand(0); 41414 41415 // Pattern: (st:isVoid (X86Wrapper:i32 (tglobaladdr:i32):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41416 // Emits: (MOV32mi:isVoid addr:iPTR:$dst, (tglobaladdr:i32):$src) 41417 // Pattern complexity = 28 cost = 1 size = 3 41418 if (N10.getOpcode() == ISD::TargetGlobalAddress) { 41419 SDValue N2 = N.getOperand(2); 41420 SDValue CPTmpN2_0; 41421 SDValue CPTmpN2_1; 41422 SDValue CPTmpN2_2; 41423 SDValue CPTmpN2_3; 41424 SDValue CPTmpN2_4; 41425 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41426 N1.getNode()->getValueType(0) == MVT::i32) { 41427 SDNode *Result = Emit_193(N, X86::MOV32mi, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41428 return Result; 41429 } 41430 } 41431 41432 // Pattern: (st:isVoid (X86Wrapper:i32 (texternalsym:i32):$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41433 // Emits: (MOV32mi:isVoid addr:iPTR:$dst, (texternalsym:i32):$src) 41434 // Pattern complexity = 28 cost = 1 size = 3 41435 if (N10.getOpcode() == ISD::TargetExternalSymbol) { 41436 SDValue N2 = N.getOperand(2); 41437 SDValue CPTmpN2_0; 41438 SDValue CPTmpN2_1; 41439 SDValue CPTmpN2_2; 41440 SDValue CPTmpN2_3; 41441 SDValue CPTmpN2_4; 41442 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41443 N1.getNode()->getValueType(0) == MVT::i32) { 41444 SDNode *Result = Emit_193(N, X86::MOV32mi, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41445 return Result; 41446 } 41447 } 41448 } 41449 if (N1.getOpcode() == ISD::Constant) { 41450 41451 // Pattern: (st:isVoid (imm:i64)<<P:Predicate_i64immSExt32>>:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41452 // Emits: (MOV64mi32:isVoid addr:iPTR:$dst, (imm:i64):$src) 41453 // Pattern complexity = 26 cost = 1 size = 3 41454 if (Predicate_i64immSExt32(N1.getNode())) { 41455 SDValue N2 = N.getOperand(2); 41456 SDValue CPTmpN2_0; 41457 SDValue CPTmpN2_1; 41458 SDValue CPTmpN2_2; 41459 SDValue CPTmpN2_3; 41460 SDValue CPTmpN2_4; 41461 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41462 N1.getNode()->getValueType(0) == MVT::i64) { 41463 SDNode *Result = Emit_190(N, X86::MOV64mi32, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41464 return Result; 41465 } 41466 } 41467 SDValue N2 = N.getOperand(2); 41468 SDValue CPTmpN2_0; 41469 SDValue CPTmpN2_1; 41470 SDValue CPTmpN2_2; 41471 SDValue CPTmpN2_3; 41472 SDValue CPTmpN2_4; 41473 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41474 41475 // Pattern: (st:isVoid (imm:i8):$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41476 // Emits: (MOV8mi:isVoid addr:iPTR:$dst, (imm:i8):$src) 41477 // Pattern complexity = 25 cost = 1 size = 3 41478 if (N1.getNode()->getValueType(0) == MVT::i8) { 41479 SDNode *Result = Emit_170(N, X86::MOV8mi, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41480 return Result; 41481 } 41482 41483 // Pattern: (st:isVoid (imm:i16):$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41484 // Emits: (MOV16mi:isVoid addr:iPTR:$dst, (imm:i16):$src) 41485 // Pattern complexity = 25 cost = 1 size = 3 41486 if (N1.getNode()->getValueType(0) == MVT::i16) { 41487 SDNode *Result = Emit_171(N, X86::MOV16mi, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41488 return Result; 41489 } 41490 41491 // Pattern: (st:isVoid (imm:i32):$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41492 // Emits: (MOV32mi:isVoid addr:iPTR:$dst, (imm:i32):$src) 41493 // Pattern complexity = 25 cost = 1 size = 3 41494 if (N1.getNode()->getValueType(0) == MVT::i32) { 41495 SDNode *Result = Emit_172(N, X86::MOV32mi, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41496 return Result; 41497 } 41498 } 41499 } 41500 } 41501 } 41502 if ((Subtarget->hasSSE2())) { 41503 SDValue Chain = N.getOperand(0); 41504 if (Predicate_unindexedstore(N.getNode()) && 41505 Predicate_store(N.getNode())) { 41506 SDValue N1 = N.getOperand(1); 41507 if (N1.getOpcode() == ISD::BIT_CONVERT) { 41508 SDValue N10 = N1.getOperand(0); 41509 SDValue N2 = N.getOperand(2); 41510 SDValue CPTmpN2_0; 41511 SDValue CPTmpN2_1; 41512 SDValue CPTmpN2_2; 41513 SDValue CPTmpN2_3; 41514 SDValue CPTmpN2_4; 41515 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41516 41517 // Pattern: (st:isVoid (bitconvert:i64 FR64:f64:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41518 // Emits: (MOVSDto64mr:isVoid addr:iPTR:$dst, FR64:f64:$src) 41519 // Pattern complexity = 25 cost = 1 size = 3 41520 if (N1.getNode()->getValueType(0) == MVT::i64 && 41521 N10.getNode()->getValueType(0) == MVT::f64) { 41522 SDNode *Result = Emit_193(N, X86::MOVSDto64mr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41523 return Result; 41524 } 41525 41526 // Pattern: (st:isVoid (bitconvert:i32 FR32:f32:$src), addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41527 // Emits: (MOVSS2DImr:isVoid addr:iPTR:$dst, FR32:f32:$src) 41528 // Pattern complexity = 25 cost = 1 size = 3 41529 if (N1.getNode()->getValueType(0) == MVT::i32 && 41530 N10.getNode()->getValueType(0) == MVT::f32) { 41531 SDNode *Result = Emit_193(N, X86::MOVSS2DImr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41532 return Result; 41533 } 41534 } 41535 } 41536 } 41537 } 41538 41539 // Pattern: (st:isVoid RFP32:f32:$src, addr:iPTR:$op)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41540 // Emits: (ST_Fp32m:isVoid addr:iPTR:$op, RFP32:f32:$src) 41541 // Pattern complexity = 22 cost = 1 size = 0 41542 if ((!Subtarget->hasSSE1())) { 41543 SDValue Chain = N.getOperand(0); 41544 if (Predicate_unindexedstore(N.getNode()) && 41545 Predicate_store(N.getNode())) { 41546 SDValue N1 = N.getOperand(1); 41547 SDValue N2 = N.getOperand(2); 41548 SDValue CPTmpN2_0; 41549 SDValue CPTmpN2_1; 41550 SDValue CPTmpN2_2; 41551 SDValue CPTmpN2_3; 41552 SDValue CPTmpN2_4; 41553 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41554 N1.getNode()->getValueType(0) == MVT::f32) { 41555 SDNode *Result = Emit_173(N, X86::ST_Fp32m, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41556 return Result; 41557 } 41558 } 41559 } 41560 if ((!Subtarget->hasSSE2())) { 41561 SDValue Chain = N.getOperand(0); 41562 if (Predicate_unindexedstore(N.getNode())) { 41563 41564 // Pattern: (st:isVoid RFP64:f64:$src, addr:iPTR:$op)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstoref32>> 41565 // Emits: (ST_Fp64m32:isVoid addr:iPTR:$op, RFP64:f64:$src) 41566 // Pattern complexity = 22 cost = 1 size = 0 41567 if (Predicate_truncstore(N.getNode()) && 41568 Predicate_truncstoref32(N.getNode())) { 41569 SDValue N1 = N.getOperand(1); 41570 SDValue N2 = N.getOperand(2); 41571 SDValue CPTmpN2_0; 41572 SDValue CPTmpN2_1; 41573 SDValue CPTmpN2_2; 41574 SDValue CPTmpN2_3; 41575 SDValue CPTmpN2_4; 41576 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41577 N1.getNode()->getValueType(0) == MVT::f64) { 41578 SDNode *Result = Emit_173(N, X86::ST_Fp64m32, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41579 return Result; 41580 } 41581 } 41582 41583 // Pattern: (st:isVoid RFP64:f64:$src, addr:iPTR:$op)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41584 // Emits: (ST_Fp64m:isVoid addr:iPTR:$op, RFP64:f64:$src) 41585 // Pattern complexity = 22 cost = 1 size = 0 41586 if (Predicate_store(N.getNode())) { 41587 SDValue N1 = N.getOperand(1); 41588 SDValue N2 = N.getOperand(2); 41589 SDValue CPTmpN2_0; 41590 SDValue CPTmpN2_1; 41591 SDValue CPTmpN2_2; 41592 SDValue CPTmpN2_3; 41593 SDValue CPTmpN2_4; 41594 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41595 N1.getNode()->getValueType(0) == MVT::f64) { 41596 SDNode *Result = Emit_173(N, X86::ST_Fp64m, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41597 return Result; 41598 } 41599 } 41600 } 41601 } 41602 { 41603 SDValue Chain = N.getOperand(0); 41604 if (Predicate_unindexedstore(N.getNode())) { 41605 if (Predicate_truncstore(N.getNode())) { 41606 41607 // Pattern: (st:isVoid RFP80:f80:$src, addr:iPTR:$op)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstoref32>> 41608 // Emits: (ST_Fp80m32:isVoid addr:iPTR:$op, RFP80:f80:$src) 41609 // Pattern complexity = 22 cost = 1 size = 0 41610 if (Predicate_truncstoref32(N.getNode())) { 41611 SDValue N1 = N.getOperand(1); 41612 SDValue N2 = N.getOperand(2); 41613 SDValue CPTmpN2_0; 41614 SDValue CPTmpN2_1; 41615 SDValue CPTmpN2_2; 41616 SDValue CPTmpN2_3; 41617 SDValue CPTmpN2_4; 41618 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41619 N1.getNode()->getValueType(0) == MVT::f80) { 41620 SDNode *Result = Emit_173(N, X86::ST_Fp80m32, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41621 return Result; 41622 } 41623 } 41624 41625 // Pattern: (st:isVoid RFP80:f80:$src, addr:iPTR:$op)<<P:Predicate_unindexedstore>><<P:Predicate_truncstore>><<P:Predicate_truncstoref64>> 41626 // Emits: (ST_Fp80m64:isVoid addr:iPTR:$op, RFP80:f80:$src) 41627 // Pattern complexity = 22 cost = 1 size = 0 41628 if (Predicate_truncstoref64(N.getNode())) { 41629 SDValue N1 = N.getOperand(1); 41630 SDValue N2 = N.getOperand(2); 41631 SDValue CPTmpN2_0; 41632 SDValue CPTmpN2_1; 41633 SDValue CPTmpN2_2; 41634 SDValue CPTmpN2_3; 41635 SDValue CPTmpN2_4; 41636 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41637 N1.getNode()->getValueType(0) == MVT::f80) { 41638 SDNode *Result = Emit_173(N, X86::ST_Fp80m64, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41639 return Result; 41640 } 41641 } 41642 } 41643 if (Predicate_store(N.getNode())) { 41644 SDValue N1 = N.getOperand(1); 41645 SDValue N2 = N.getOperand(2); 41646 SDValue CPTmpN2_0; 41647 SDValue CPTmpN2_1; 41648 SDValue CPTmpN2_2; 41649 SDValue CPTmpN2_3; 41650 SDValue CPTmpN2_4; 41651 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41652 41653 // Pattern: (st:isVoid RFP80:f80:$src, addr:iPTR:$op)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41654 // Emits: (ST_FpP80m:isVoid addr:iPTR:$op, RFP80:f80:$src) 41655 // Pattern complexity = 22 cost = 1 size = 0 41656 if (N1.getNode()->getValueType(0) == MVT::f80) { 41657 SDNode *Result = Emit_173(N, X86::ST_FpP80m, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41658 return Result; 41659 } 41660 41661 // Pattern: (st:isVoid GR8:i8:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41662 // Emits: (MOV8mr:isVoid addr:iPTR:$dst, GR8:i8:$src) 41663 // Pattern complexity = 22 cost = 1 size = 3 41664 if (N1.getNode()->getValueType(0) == MVT::i8) { 41665 SDNode *Result = Emit_173(N, X86::MOV8mr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41666 return Result; 41667 } 41668 41669 // Pattern: (st:isVoid GR16:i16:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41670 // Emits: (MOV16mr:isVoid addr:iPTR:$dst, GR16:i16:$src) 41671 // Pattern complexity = 22 cost = 1 size = 3 41672 if (N1.getNode()->getValueType(0) == MVT::i16) { 41673 SDNode *Result = Emit_173(N, X86::MOV16mr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41674 return Result; 41675 } 41676 41677 // Pattern: (st:isVoid GR32:i32:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41678 // Emits: (MOV32mr:isVoid addr:iPTR:$dst, GR32:i32:$src) 41679 // Pattern complexity = 22 cost = 1 size = 3 41680 if (N1.getNode()->getValueType(0) == MVT::i32) { 41681 SDNode *Result = Emit_173(N, X86::MOV32mr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41682 return Result; 41683 } 41684 41685 // Pattern: (st:isVoid GR64:i64:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41686 // Emits: (MOV64mr:isVoid addr:iPTR:$dst, GR64:i64:$src) 41687 // Pattern complexity = 22 cost = 1 size = 3 41688 if (N1.getNode()->getValueType(0) == MVT::i64) { 41689 SDNode *Result = Emit_173(N, X86::MOV64mr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41690 return Result; 41691 } 41692 } 41693 } 41694 } 41695 } 41696 if ((Subtarget->hasSSE1())) { 41697 SDValue Chain = N.getOperand(0); 41698 if (Predicate_unindexedstore(N.getNode()) && 41699 Predicate_store(N.getNode())) { 41700 41701 // Pattern: (st:isVoid FR32:f32:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41702 // Emits: (MOVSSmr:isVoid addr:iPTR:$dst, FR32:f32:$src) 41703 // Pattern complexity = 22 cost = 1 size = 3 41704 { 41705 SDValue N1 = N.getOperand(1); 41706 SDValue N2 = N.getOperand(2); 41707 SDValue CPTmpN2_0; 41708 SDValue CPTmpN2_1; 41709 SDValue CPTmpN2_2; 41710 SDValue CPTmpN2_3; 41711 SDValue CPTmpN2_4; 41712 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41713 N1.getNode()->getValueType(0) == MVT::f32) { 41714 SDNode *Result = Emit_173(N, X86::MOVSSmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41715 return Result; 41716 } 41717 } 41718 41719 // Pattern: (st:isVoid VR128:v4f32:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>><<P:Predicate_alignedstore>> 41720 // Emits: (MOVAPSmr:isVoid addr:iPTR:$dst, VR128:v4f32:$src) 41721 // Pattern complexity = 22 cost = 1 size = 3 41722 if (Predicate_alignedstore(N.getNode())) { 41723 SDValue N1 = N.getOperand(1); 41724 SDValue N2 = N.getOperand(2); 41725 SDValue CPTmpN2_0; 41726 SDValue CPTmpN2_1; 41727 SDValue CPTmpN2_2; 41728 SDValue CPTmpN2_3; 41729 SDValue CPTmpN2_4; 41730 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41731 N1.getNode()->getValueType(0) == MVT::v4f32) { 41732 SDNode *Result = Emit_173(N, X86::MOVAPSmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41733 return Result; 41734 } 41735 } 41736 41737 // Pattern: (st:isVoid VR128:v4f32:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41738 // Emits: (MOVUPSmr:isVoid addr:iPTR:$dst, VR128:v4f32:$src) 41739 // Pattern complexity = 22 cost = 1 size = 3 41740 SDValue N1 = N.getOperand(1); 41741 SDValue N2 = N.getOperand(2); 41742 SDValue CPTmpN2_0; 41743 SDValue CPTmpN2_1; 41744 SDValue CPTmpN2_2; 41745 SDValue CPTmpN2_3; 41746 SDValue CPTmpN2_4; 41747 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41748 N1.getNode()->getValueType(0) == MVT::v4f32) { 41749 SDNode *Result = Emit_173(N, X86::MOVUPSmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41750 return Result; 41751 } 41752 } 41753 } 41754 if ((Subtarget->hasSSE2())) { 41755 SDValue Chain = N.getOperand(0); 41756 if (Predicate_unindexedstore(N.getNode()) && 41757 Predicate_store(N.getNode())) { 41758 41759 // Pattern: (st:isVoid FR64:f64:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41760 // Emits: (MOVSDmr:isVoid addr:iPTR:$dst, FR64:f64:$src) 41761 // Pattern complexity = 22 cost = 1 size = 3 41762 { 41763 SDValue N1 = N.getOperand(1); 41764 SDValue N2 = N.getOperand(2); 41765 SDValue CPTmpN2_0; 41766 SDValue CPTmpN2_1; 41767 SDValue CPTmpN2_2; 41768 SDValue CPTmpN2_3; 41769 SDValue CPTmpN2_4; 41770 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41771 N1.getNode()->getValueType(0) == MVT::f64) { 41772 SDNode *Result = Emit_173(N, X86::MOVSDmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41773 return Result; 41774 } 41775 } 41776 41777 // Pattern: (st:isVoid VR128:v2f64:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>><<P:Predicate_alignedstore>> 41778 // Emits: (MOVAPDmr:isVoid addr:iPTR:$dst, VR128:v2f64:$src) 41779 // Pattern complexity = 22 cost = 1 size = 3 41780 if (Predicate_alignedstore(N.getNode())) { 41781 SDValue N1 = N.getOperand(1); 41782 SDValue N2 = N.getOperand(2); 41783 SDValue CPTmpN2_0; 41784 SDValue CPTmpN2_1; 41785 SDValue CPTmpN2_2; 41786 SDValue CPTmpN2_3; 41787 SDValue CPTmpN2_4; 41788 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41789 N1.getNode()->getValueType(0) == MVT::v2f64) { 41790 SDNode *Result = Emit_173(N, X86::MOVAPDmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41791 return Result; 41792 } 41793 } 41794 41795 // Pattern: (st:isVoid VR128:v2f64:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41796 // Emits: (MOVUPDmr:isVoid addr:iPTR:$dst, VR128:v2f64:$src) 41797 // Pattern complexity = 22 cost = 1 size = 3 41798 SDValue N1 = N.getOperand(1); 41799 SDValue N2 = N.getOperand(2); 41800 SDValue CPTmpN2_0; 41801 SDValue CPTmpN2_1; 41802 SDValue CPTmpN2_2; 41803 SDValue CPTmpN2_3; 41804 SDValue CPTmpN2_4; 41805 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41806 N1.getNode()->getValueType(0) == MVT::v2f64) { 41807 SDNode *Result = Emit_173(N, X86::MOVUPDmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41808 return Result; 41809 } 41810 } 41811 } 41812 41813 // Pattern: (st:isVoid VR64:v1i64:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41814 // Emits: (MMX_MOVQ64mr:isVoid addr:iPTR:$dst, VR64:v1i64:$src) 41815 // Pattern complexity = 22 cost = 1 size = 3 41816 if ((Subtarget->hasMMX())) { 41817 SDValue Chain = N.getOperand(0); 41818 if (Predicate_unindexedstore(N.getNode()) && 41819 Predicate_store(N.getNode())) { 41820 SDValue N1 = N.getOperand(1); 41821 SDValue N2 = N.getOperand(2); 41822 SDValue CPTmpN2_0; 41823 SDValue CPTmpN2_1; 41824 SDValue CPTmpN2_2; 41825 SDValue CPTmpN2_3; 41826 SDValue CPTmpN2_4; 41827 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4) && 41828 N1.getNode()->getValueType(0) == MVT::v1i64) { 41829 SDNode *Result = Emit_173(N, X86::MMX_MOVQ64mr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41830 return Result; 41831 } 41832 } 41833 } 41834 if ((Subtarget->hasSSE2())) { 41835 SDValue Chain = N.getOperand(0); 41836 if (Predicate_unindexedstore(N.getNode()) && 41837 Predicate_store(N.getNode())) { 41838 if (Predicate_alignedstore(N.getNode())) { 41839 SDValue N1 = N.getOperand(1); 41840 SDValue N2 = N.getOperand(2); 41841 SDValue CPTmpN2_0; 41842 SDValue CPTmpN2_1; 41843 SDValue CPTmpN2_2; 41844 SDValue CPTmpN2_3; 41845 SDValue CPTmpN2_4; 41846 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41847 41848 // Pattern: (st:isVoid VR128:v2i64:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>><<P:Predicate_alignedstore>> 41849 // Emits: (MOVAPSmr:isVoid addr:iPTR:$dst, VR128:v16i8:$src) 41850 // Pattern complexity = 22 cost = 1 size = 3 41851 if (N1.getNode()->getValueType(0) == MVT::v2i64) { 41852 SDNode *Result = Emit_173(N, X86::MOVAPSmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41853 return Result; 41854 } 41855 41856 // Pattern: (st:isVoid VR128:v4i32:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>><<P:Predicate_alignedstore>> 41857 // Emits: (MOVAPSmr:isVoid addr:iPTR:$dst, VR128:v16i8:$src) 41858 // Pattern complexity = 22 cost = 1 size = 3 41859 if (N1.getNode()->getValueType(0) == MVT::v4i32) { 41860 SDNode *Result = Emit_173(N, X86::MOVAPSmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41861 return Result; 41862 } 41863 41864 // Pattern: (st:isVoid VR128:v8i16:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>><<P:Predicate_alignedstore>> 41865 // Emits: (MOVAPSmr:isVoid addr:iPTR:$dst, VR128:v16i8:$src) 41866 // Pattern complexity = 22 cost = 1 size = 3 41867 if (N1.getNode()->getValueType(0) == MVT::v8i16) { 41868 SDNode *Result = Emit_173(N, X86::MOVAPSmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41869 return Result; 41870 } 41871 41872 // Pattern: (st:isVoid VR128:v16i8:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>><<P:Predicate_alignedstore>> 41873 // Emits: (MOVAPSmr:isVoid addr:iPTR:$dst, VR128:v16i8:$src) 41874 // Pattern complexity = 22 cost = 1 size = 3 41875 if (N1.getNode()->getValueType(0) == MVT::v16i8) { 41876 SDNode *Result = Emit_173(N, X86::MOVAPSmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41877 return Result; 41878 } 41879 } 41880 } 41881 SDValue N1 = N.getOperand(1); 41882 SDValue N2 = N.getOperand(2); 41883 SDValue CPTmpN2_0; 41884 SDValue CPTmpN2_1; 41885 SDValue CPTmpN2_2; 41886 SDValue CPTmpN2_3; 41887 SDValue CPTmpN2_4; 41888 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41889 41890 // Pattern: (st:isVoid VR128:v2i64:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41891 // Emits: (MOVUPSmr:isVoid addr:iPTR:$dst, VR128:v16i8:$src) 41892 // Pattern complexity = 22 cost = 1 size = 3 41893 if (N1.getNode()->getValueType(0) == MVT::v2i64) { 41894 SDNode *Result = Emit_173(N, X86::MOVUPSmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41895 return Result; 41896 } 41897 41898 // Pattern: (st:isVoid VR128:v4i32:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41899 // Emits: (MOVUPSmr:isVoid addr:iPTR:$dst, VR128:v16i8:$src) 41900 // Pattern complexity = 22 cost = 1 size = 3 41901 if (N1.getNode()->getValueType(0) == MVT::v4i32) { 41902 SDNode *Result = Emit_173(N, X86::MOVUPSmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41903 return Result; 41904 } 41905 41906 // Pattern: (st:isVoid VR128:v8i16:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41907 // Emits: (MOVUPSmr:isVoid addr:iPTR:$dst, VR128:v16i8:$src) 41908 // Pattern complexity = 22 cost = 1 size = 3 41909 if (N1.getNode()->getValueType(0) == MVT::v8i16) { 41910 SDNode *Result = Emit_173(N, X86::MOVUPSmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41911 return Result; 41912 } 41913 41914 // Pattern: (st:isVoid VR128:v16i8:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41915 // Emits: (MOVUPSmr:isVoid addr:iPTR:$dst, VR128:v16i8:$src) 41916 // Pattern complexity = 22 cost = 1 size = 3 41917 if (N1.getNode()->getValueType(0) == MVT::v16i8) { 41918 SDNode *Result = Emit_173(N, X86::MOVUPSmr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41919 return Result; 41920 } 41921 } 41922 } 41923 } 41924 SDValue Chain = N.getOperand(0); 41925 if (Predicate_unindexedstore(N.getNode()) && 41926 Predicate_store(N.getNode())) { 41927 SDValue N1 = N.getOperand(1); 41928 SDValue N2 = N.getOperand(2); 41929 SDValue CPTmpN2_0; 41930 SDValue CPTmpN2_1; 41931 SDValue CPTmpN2_2; 41932 SDValue CPTmpN2_3; 41933 SDValue CPTmpN2_4; 41934 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 41935 41936 // Pattern: (st:isVoid VR64:v8i8:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41937 // Emits: (MMX_MOVQ64mr:isVoid addr:iPTR:$dst, VR64:v8i8:$src) 41938 // Pattern complexity = 22 cost = 1 size = 3 41939 if (N1.getNode()->getValueType(0) == MVT::v8i8) { 41940 SDNode *Result = Emit_173(N, X86::MMX_MOVQ64mr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41941 return Result; 41942 } 41943 41944 // Pattern: (st:isVoid VR64:v4i16:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41945 // Emits: (MMX_MOVQ64mr:isVoid addr:iPTR:$dst, VR64:v8i8:$src) 41946 // Pattern complexity = 22 cost = 1 size = 3 41947 if (N1.getNode()->getValueType(0) == MVT::v4i16) { 41948 SDNode *Result = Emit_173(N, X86::MMX_MOVQ64mr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41949 return Result; 41950 } 41951 41952 // Pattern: (st:isVoid VR64:v2i32:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41953 // Emits: (MMX_MOVQ64mr:isVoid addr:iPTR:$dst, VR64:v8i8:$src) 41954 // Pattern complexity = 22 cost = 1 size = 3 41955 if (N1.getNode()->getValueType(0) == MVT::v2i32) { 41956 SDNode *Result = Emit_173(N, X86::MMX_MOVQ64mr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41957 return Result; 41958 } 41959 41960 // Pattern: (st:isVoid VR64:v2f32:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41961 // Emits: (MMX_MOVQ64mr:isVoid addr:iPTR:$dst, VR64:v8i8:$src) 41962 // Pattern complexity = 22 cost = 1 size = 3 41963 if (N1.getNode()->getValueType(0) == MVT::v2f32) { 41964 SDNode *Result = Emit_173(N, X86::MMX_MOVQ64mr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41965 return Result; 41966 } 41967 41968 // Pattern: (st:isVoid VR64:v1i64:$src, addr:iPTR:$dst)<<P:Predicate_unindexedstore>><<P:Predicate_store>> 41969 // Emits: (MMX_MOVQ64mr:isVoid addr:iPTR:$dst, VR64:v8i8:$src) 41970 // Pattern complexity = 22 cost = 1 size = 3 41971 if (N1.getNode()->getValueType(0) == MVT::v1i64) { 41972 SDNode *Result = Emit_173(N, X86::MMX_MOVQ64mr, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 41973 return Result; 41974 } 41975 } 41976 } 41977 41978 CannotYetSelect(N); 41979 return NULL; 41980 } 41981 41982 SDNode *Emit_224(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 41983 SDValue N0 = N.getOperand(0); 41984 SDValue N1 = N.getOperand(1); 41985 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::i32, N1); 41986 } 41987 SDNode *Select_ISD_SUB_i8(const SDValue &N) { 41988 41989 // Pattern: (sub:i8 GR8:i8:$src1, (ld:i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 41990 // Emits: (SUB8rm:i8 GR8:i8:$src1, addr:iPTR:$src2) 41991 // Pattern complexity = 25 cost = 1 size = 3 41992 if (OptLevel != CodeGenOpt::None) { 41993 SDValue N0 = N.getOperand(0); 41994 SDValue N1 = N.getOperand(1); 41995 if (N1.getOpcode() == ISD::LOAD && 41996 N1.hasOneUse() && 41997 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 41998 SDValue Chain1 = N1.getOperand(0); 41999 if (Predicate_unindexedload(N1.getNode()) && 42000 Predicate_load(N1.getNode())) { 42001 SDValue N11 = N1.getOperand(1); 42002 SDValue CPTmpN11_0; 42003 SDValue CPTmpN11_1; 42004 SDValue CPTmpN11_2; 42005 SDValue CPTmpN11_3; 42006 SDValue CPTmpN11_4; 42007 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 42008 SDNode *Result = Emit_2(N, X86::SUB8rm, MVT::i8, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 42009 return Result; 42010 } 42011 } 42012 } 42013 } 42014 { 42015 SDValue N0 = N.getOperand(0); 42016 42017 // Pattern: (sub:i8 0:i8, GR8:i8:$src) 42018 // Emits: (NEG8r:i8 GR8:i8:$src) 42019 // Pattern complexity = 8 cost = 1 size = 2 42020 { 42021 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 42022 if (Tmp0) { 42023 int64_t CN1 = Tmp0->getSExtValue(); 42024 if (CN1 == INT64_C(0)) { 42025 SDNode *Result = Emit_224(N, X86::NEG8r, MVT::i8); 42026 return Result; 42027 } 42028 } 42029 } 42030 42031 // Pattern: (sub:i8 GR8:i8:$src1, (imm:i8):$src2) 42032 // Emits: (SUB8ri:i8 GR8:i8:$src1, (imm:i8):$src2) 42033 // Pattern complexity = 6 cost = 1 size = 3 42034 SDValue N1 = N.getOperand(1); 42035 if (N1.getOpcode() == ISD::Constant) { 42036 SDNode *Result = Emit_3(N, X86::SUB8ri, MVT::i8); 42037 return Result; 42038 } 42039 } 42040 42041 // Pattern: (sub:i8 GR8:i8:$src1, GR8:i8:$src2) 42042 // Emits: (SUB8rr:i8 GR8:i8:$src1, GR8:i8:$src2) 42043 // Pattern complexity = 3 cost = 1 size = 3 42044 SDNode *Result = Emit_1(N, X86::SUB8rr, MVT::i8); 42045 return Result; 42046 } 42047 42048 SDNode *Select_ISD_SUB_i16(const SDValue &N) { 42049 42050 // Pattern: (sub:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 42051 // Emits: (SUB16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 42052 // Pattern complexity = 25 cost = 1 size = 3 42053 if (OptLevel != CodeGenOpt::None) { 42054 SDValue N0 = N.getOperand(0); 42055 SDValue N1 = N.getOperand(1); 42056 if (N1.getOpcode() == ISD::LOAD && 42057 N1.hasOneUse() && 42058 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 42059 SDValue Chain1 = N1.getOperand(0); 42060 if (Predicate_unindexedload(N1.getNode()) && 42061 Predicate_load(N1.getNode())) { 42062 SDValue N11 = N1.getOperand(1); 42063 SDValue CPTmpN11_0; 42064 SDValue CPTmpN11_1; 42065 SDValue CPTmpN11_2; 42066 SDValue CPTmpN11_3; 42067 SDValue CPTmpN11_4; 42068 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 42069 SDNode *Result = Emit_2(N, X86::SUB16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 42070 return Result; 42071 } 42072 } 42073 } 42074 } 42075 { 42076 SDValue N0 = N.getOperand(0); 42077 42078 // Pattern: (sub:i16 0:i16, GR16:i16:$src) 42079 // Emits: (NEG16r:i16 GR16:i16:$src) 42080 // Pattern complexity = 8 cost = 1 size = 2 42081 { 42082 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 42083 if (Tmp0) { 42084 int64_t CN1 = Tmp0->getSExtValue(); 42085 if (CN1 == INT64_C(0)) { 42086 SDNode *Result = Emit_224(N, X86::NEG16r, MVT::i16); 42087 return Result; 42088 } 42089 } 42090 } 42091 SDValue N1 = N.getOperand(1); 42092 if (N1.getOpcode() == ISD::Constant) { 42093 42094 // Pattern: (sub:i16 GR16:i16:$src1, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 42095 // Emits: (SUB16ri8:i16 GR16:i16:$src1, (imm:i16):$src2) 42096 // Pattern complexity = 7 cost = 1 size = 3 42097 if (Predicate_i16immSExt8(N1.getNode())) { 42098 SDNode *Result = Emit_5(N, X86::SUB16ri8, MVT::i16); 42099 return Result; 42100 } 42101 42102 // Pattern: (sub:i16 GR16:i16:$src1, (imm:i16):$src2) 42103 // Emits: (SUB16ri:i16 GR16:i16:$src1, (imm:i16):$src2) 42104 // Pattern complexity = 6 cost = 1 size = 3 42105 SDNode *Result = Emit_5(N, X86::SUB16ri, MVT::i16); 42106 return Result; 42107 } 42108 } 42109 42110 // Pattern: (sub:i16 GR16:i16:$src1, GR16:i16:$src2) 42111 // Emits: (SUB16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 42112 // Pattern complexity = 3 cost = 1 size = 3 42113 SDNode *Result = Emit_1(N, X86::SUB16rr, MVT::i16); 42114 return Result; 42115 } 42116 42117 SDNode *Select_ISD_SUB_i32(const SDValue &N) { 42118 42119 // Pattern: (sub:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 42120 // Emits: (SUB32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 42121 // Pattern complexity = 25 cost = 1 size = 3 42122 if (OptLevel != CodeGenOpt::None) { 42123 SDValue N0 = N.getOperand(0); 42124 SDValue N1 = N.getOperand(1); 42125 if (N1.getOpcode() == ISD::LOAD && 42126 N1.hasOneUse() && 42127 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 42128 SDValue Chain1 = N1.getOperand(0); 42129 if (Predicate_unindexedload(N1.getNode()) && 42130 Predicate_load(N1.getNode())) { 42131 SDValue N11 = N1.getOperand(1); 42132 SDValue CPTmpN11_0; 42133 SDValue CPTmpN11_1; 42134 SDValue CPTmpN11_2; 42135 SDValue CPTmpN11_3; 42136 SDValue CPTmpN11_4; 42137 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 42138 SDNode *Result = Emit_2(N, X86::SUB32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 42139 return Result; 42140 } 42141 } 42142 } 42143 } 42144 42145 // Pattern: lea32addr:i32:$src 42146 // Emits: (LEA64_32r:i32 lea32addr:i32:$src) 42147 // Pattern complexity = 15 cost = 1 size = 3 42148 if ((Subtarget->is64Bit())) { 42149 SDValue CPTmpN_0; 42150 SDValue CPTmpN_1; 42151 SDValue CPTmpN_2; 42152 SDValue CPTmpN_3; 42153 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 42154 SDNode *Result = Emit_7(N, X86::LEA64_32r, MVT::i32, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 42155 return Result; 42156 } 42157 } 42158 42159 // Pattern: lea32addr:i32:$src 42160 // Emits: (LEA32r:i32 lea32addr:i32:$src) 42161 // Pattern complexity = 15 cost = 1 size = 3 42162 if ((!Subtarget->is64Bit())) { 42163 SDValue CPTmpN_0; 42164 SDValue CPTmpN_1; 42165 SDValue CPTmpN_2; 42166 SDValue CPTmpN_3; 42167 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 42168 SDNode *Result = Emit_7(N, X86::LEA32r, MVT::i32, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 42169 return Result; 42170 } 42171 } 42172 { 42173 SDValue N0 = N.getOperand(0); 42174 42175 // Pattern: (sub:i32 0:i32, GR32:i32:$src) 42176 // Emits: (NEG32r:i32 GR32:i32:$src) 42177 // Pattern complexity = 8 cost = 1 size = 2 42178 { 42179 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 42180 if (Tmp0) { 42181 int64_t CN1 = Tmp0->getSExtValue(); 42182 if (CN1 == INT64_C(0)) { 42183 SDNode *Result = Emit_224(N, X86::NEG32r, MVT::i32); 42184 return Result; 42185 } 42186 } 42187 } 42188 SDValue N1 = N.getOperand(1); 42189 if (N1.getOpcode() == ISD::Constant) { 42190 42191 // Pattern: (sub:i32 GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 42192 // Emits: (SUB32ri8:i32 GR32:i32:$src1, (imm:i32):$src2) 42193 // Pattern complexity = 7 cost = 1 size = 3 42194 if (Predicate_i32immSExt8(N1.getNode())) { 42195 SDNode *Result = Emit_8(N, X86::SUB32ri8, MVT::i32); 42196 return Result; 42197 } 42198 42199 // Pattern: (sub:i32 GR32:i32:$src1, (imm:i32):$src2) 42200 // Emits: (SUB32ri:i32 GR32:i32:$src1, (imm:i32):$src2) 42201 // Pattern complexity = 6 cost = 1 size = 3 42202 SDNode *Result = Emit_8(N, X86::SUB32ri, MVT::i32); 42203 return Result; 42204 } 42205 } 42206 42207 // Pattern: (sub:i32 GR32:i32:$src1, GR32:i32:$src2) 42208 // Emits: (SUB32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 42209 // Pattern complexity = 3 cost = 1 size = 3 42210 SDNode *Result = Emit_1(N, X86::SUB32rr, MVT::i32); 42211 return Result; 42212 } 42213 42214 SDNode *Select_ISD_SUB_i64(const SDValue &N) { 42215 42216 // Pattern: (sub:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 42217 // Emits: (SUB64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 42218 // Pattern complexity = 25 cost = 1 size = 3 42219 if (OptLevel != CodeGenOpt::None) { 42220 SDValue N0 = N.getOperand(0); 42221 SDValue N1 = N.getOperand(1); 42222 if (N1.getOpcode() == ISD::LOAD && 42223 N1.hasOneUse() && 42224 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 42225 SDValue Chain1 = N1.getOperand(0); 42226 if (Predicate_unindexedload(N1.getNode()) && 42227 Predicate_load(N1.getNode())) { 42228 SDValue N11 = N1.getOperand(1); 42229 SDValue CPTmpN11_0; 42230 SDValue CPTmpN11_1; 42231 SDValue CPTmpN11_2; 42232 SDValue CPTmpN11_3; 42233 SDValue CPTmpN11_4; 42234 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 42235 SDNode *Result = Emit_2(N, X86::SUB64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 42236 return Result; 42237 } 42238 } 42239 } 42240 } 42241 42242 // Pattern: lea64addr:i64:$src 42243 // Emits: (LEA64r:i64 lea64addr:i64:$src) 42244 // Pattern complexity = 15 cost = 1 size = 3 42245 { 42246 SDValue CPTmpN_0; 42247 SDValue CPTmpN_1; 42248 SDValue CPTmpN_2; 42249 SDValue CPTmpN_3; 42250 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 42251 SDNode *Result = Emit_7(N, X86::LEA64r, MVT::i64, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 42252 return Result; 42253 } 42254 } 42255 { 42256 SDValue N0 = N.getOperand(0); 42257 42258 // Pattern: (sub:i64 0:i64, GR64:i64:$src) 42259 // Emits: (NEG64r:i64 GR64:i64:$src) 42260 // Pattern complexity = 8 cost = 1 size = 2 42261 { 42262 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 42263 if (Tmp0) { 42264 int64_t CN1 = Tmp0->getSExtValue(); 42265 if (CN1 == INT64_C(0)) { 42266 SDNode *Result = Emit_224(N, X86::NEG64r, MVT::i64); 42267 return Result; 42268 } 42269 } 42270 } 42271 SDValue N1 = N.getOperand(1); 42272 if (N1.getOpcode() == ISD::Constant) { 42273 42274 // Pattern: (sub:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 42275 // Emits: (SUB64ri8:i64 GR64:i64:$src1, (imm:i64):$src2) 42276 // Pattern complexity = 7 cost = 1 size = 3 42277 if (Predicate_i64immSExt8(N1.getNode())) { 42278 SDNode *Result = Emit_12(N, X86::SUB64ri8, MVT::i64); 42279 return Result; 42280 } 42281 42282 // Pattern: (sub:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 42283 // Emits: (SUB64ri32:i64 GR64:i64:$src1, (imm:i64):$src2) 42284 // Pattern complexity = 7 cost = 1 size = 3 42285 if (Predicate_i64immSExt32(N1.getNode())) { 42286 SDNode *Result = Emit_12(N, X86::SUB64ri32, MVT::i64); 42287 return Result; 42288 } 42289 } 42290 } 42291 42292 // Pattern: (sub:i64 GR64:i64:$src1, GR64:i64:$src2) 42293 // Emits: (SUB64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 42294 // Pattern complexity = 3 cost = 1 size = 3 42295 SDNode *Result = Emit_1(N, X86::SUB64rr, MVT::i64); 42296 return Result; 42297 } 42298 42299 SDNode *Select_ISD_SUB_v8i8(const SDValue &N) { 42300 42301 // Pattern: (sub:v8i8 VR64:v8i8:$src1, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 42302 // Emits: (MMX_PSUBBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 42303 // Pattern complexity = 28 cost = 1 size = 3 42304 if (OptLevel != CodeGenOpt::None && 42305 (Subtarget->hasMMX())) { 42306 SDValue N0 = N.getOperand(0); 42307 SDValue N1 = N.getOperand(1); 42308 if (N1.getOpcode() == ISD::BIT_CONVERT && 42309 N1.hasOneUse()) { 42310 SDValue N10 = N1.getOperand(0); 42311 if (N10.getOpcode() == ISD::LOAD && 42312 N10.hasOneUse() && 42313 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 42314 SDValue Chain10 = N10.getOperand(0); 42315 if (Predicate_unindexedload(N10.getNode()) && 42316 Predicate_load(N10.getNode())) { 42317 SDValue N101 = N10.getOperand(1); 42318 SDValue CPTmpN101_0; 42319 SDValue CPTmpN101_1; 42320 SDValue CPTmpN101_2; 42321 SDValue CPTmpN101_3; 42322 SDValue CPTmpN101_4; 42323 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 42324 N10.getNode()->getValueType(0) == MVT::v1i64) { 42325 SDNode *Result = Emit_16(N, X86::MMX_PSUBBrm, MVT::v8i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 42326 return Result; 42327 } 42328 } 42329 } 42330 } 42331 } 42332 42333 // Pattern: (sub:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 42334 // Emits: (MMX_PSUBBrr:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 42335 // Pattern complexity = 3 cost = 1 size = 3 42336 if ((Subtarget->hasMMX())) { 42337 SDNode *Result = Emit_15(N, X86::MMX_PSUBBrr, MVT::v8i8); 42338 return Result; 42339 } 42340 42341 CannotYetSelect(N); 42342 return NULL; 42343 } 42344 42345 SDNode *Select_ISD_SUB_v16i8(const SDValue &N) { 42346 42347 // Pattern: (sub:v16i8 VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 42348 // Emits: (PSUBBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 42349 // Pattern complexity = 28 cost = 1 size = 3 42350 if (OptLevel != CodeGenOpt::None && 42351 (Subtarget->hasSSE2())) { 42352 SDValue N0 = N.getOperand(0); 42353 SDValue N1 = N.getOperand(1); 42354 if (N1.getOpcode() == ISD::BIT_CONVERT && 42355 N1.hasOneUse()) { 42356 SDValue N10 = N1.getOperand(0); 42357 if (N10.getOpcode() == ISD::LOAD && 42358 N10.hasOneUse() && 42359 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 42360 SDValue Chain10 = N10.getOperand(0); 42361 if (Predicate_unindexedload(N10.getNode()) && 42362 Predicate_load(N10.getNode()) && 42363 Predicate_memop(N10.getNode())) { 42364 SDValue N101 = N10.getOperand(1); 42365 SDValue CPTmpN101_0; 42366 SDValue CPTmpN101_1; 42367 SDValue CPTmpN101_2; 42368 SDValue CPTmpN101_3; 42369 SDValue CPTmpN101_4; 42370 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 42371 N10.getNode()->getValueType(0) == MVT::v2i64) { 42372 SDNode *Result = Emit_16(N, X86::PSUBBrm, MVT::v16i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 42373 return Result; 42374 } 42375 } 42376 } 42377 } 42378 } 42379 42380 // Pattern: (sub:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 42381 // Emits: (PSUBBrr:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 42382 // Pattern complexity = 3 cost = 1 size = 3 42383 if ((Subtarget->hasSSE2())) { 42384 SDNode *Result = Emit_15(N, X86::PSUBBrr, MVT::v16i8); 42385 return Result; 42386 } 42387 42388 CannotYetSelect(N); 42389 return NULL; 42390 } 42391 42392 SDNode *Select_ISD_SUB_v4i16(const SDValue &N) { 42393 42394 // Pattern: (sub:v4i16 VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 42395 // Emits: (MMX_PSUBWrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 42396 // Pattern complexity = 28 cost = 1 size = 3 42397 if (OptLevel != CodeGenOpt::None && 42398 (Subtarget->hasMMX())) { 42399 SDValue N0 = N.getOperand(0); 42400 SDValue N1 = N.getOperand(1); 42401 if (N1.getOpcode() == ISD::BIT_CONVERT && 42402 N1.hasOneUse()) { 42403 SDValue N10 = N1.getOperand(0); 42404 if (N10.getOpcode() == ISD::LOAD && 42405 N10.hasOneUse() && 42406 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 42407 SDValue Chain10 = N10.getOperand(0); 42408 if (Predicate_unindexedload(N10.getNode()) && 42409 Predicate_load(N10.getNode())) { 42410 SDValue N101 = N10.getOperand(1); 42411 SDValue CPTmpN101_0; 42412 SDValue CPTmpN101_1; 42413 SDValue CPTmpN101_2; 42414 SDValue CPTmpN101_3; 42415 SDValue CPTmpN101_4; 42416 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 42417 N10.getNode()->getValueType(0) == MVT::v1i64) { 42418 SDNode *Result = Emit_16(N, X86::MMX_PSUBWrm, MVT::v4i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 42419 return Result; 42420 } 42421 } 42422 } 42423 } 42424 } 42425 42426 // Pattern: (sub:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 42427 // Emits: (MMX_PSUBWrr:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 42428 // Pattern complexity = 3 cost = 1 size = 3 42429 if ((Subtarget->hasMMX())) { 42430 SDNode *Result = Emit_15(N, X86::MMX_PSUBWrr, MVT::v4i16); 42431 return Result; 42432 } 42433 42434 CannotYetSelect(N); 42435 return NULL; 42436 } 42437 42438 SDNode *Select_ISD_SUB_v8i16(const SDValue &N) { 42439 42440 // Pattern: (sub:v8i16 VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 42441 // Emits: (PSUBWrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 42442 // Pattern complexity = 28 cost = 1 size = 3 42443 if (OptLevel != CodeGenOpt::None && 42444 (Subtarget->hasSSE2())) { 42445 SDValue N0 = N.getOperand(0); 42446 SDValue N1 = N.getOperand(1); 42447 if (N1.getOpcode() == ISD::BIT_CONVERT && 42448 N1.hasOneUse()) { 42449 SDValue N10 = N1.getOperand(0); 42450 if (N10.getOpcode() == ISD::LOAD && 42451 N10.hasOneUse() && 42452 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 42453 SDValue Chain10 = N10.getOperand(0); 42454 if (Predicate_unindexedload(N10.getNode()) && 42455 Predicate_load(N10.getNode()) && 42456 Predicate_memop(N10.getNode())) { 42457 SDValue N101 = N10.getOperand(1); 42458 SDValue CPTmpN101_0; 42459 SDValue CPTmpN101_1; 42460 SDValue CPTmpN101_2; 42461 SDValue CPTmpN101_3; 42462 SDValue CPTmpN101_4; 42463 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 42464 N10.getNode()->getValueType(0) == MVT::v2i64) { 42465 SDNode *Result = Emit_16(N, X86::PSUBWrm, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 42466 return Result; 42467 } 42468 } 42469 } 42470 } 42471 } 42472 42473 // Pattern: (sub:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 42474 // Emits: (PSUBWrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 42475 // Pattern complexity = 3 cost = 1 size = 3 42476 if ((Subtarget->hasSSE2())) { 42477 SDNode *Result = Emit_15(N, X86::PSUBWrr, MVT::v8i16); 42478 return Result; 42479 } 42480 42481 CannotYetSelect(N); 42482 return NULL; 42483 } 42484 42485 SDNode *Select_ISD_SUB_v2i32(const SDValue &N) { 42486 42487 // Pattern: (sub:v2i32 VR64:v2i32:$src1, (bitconvert:v2i32 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 42488 // Emits: (MMX_PSUBDrm:v2i32 VR64:v2i32:$src1, addr:iPTR:$src2) 42489 // Pattern complexity = 28 cost = 1 size = 3 42490 if (OptLevel != CodeGenOpt::None && 42491 (Subtarget->hasMMX())) { 42492 SDValue N0 = N.getOperand(0); 42493 SDValue N1 = N.getOperand(1); 42494 if (N1.getOpcode() == ISD::BIT_CONVERT && 42495 N1.hasOneUse()) { 42496 SDValue N10 = N1.getOperand(0); 42497 if (N10.getOpcode() == ISD::LOAD && 42498 N10.hasOneUse() && 42499 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 42500 SDValue Chain10 = N10.getOperand(0); 42501 if (Predicate_unindexedload(N10.getNode()) && 42502 Predicate_load(N10.getNode())) { 42503 SDValue N101 = N10.getOperand(1); 42504 SDValue CPTmpN101_0; 42505 SDValue CPTmpN101_1; 42506 SDValue CPTmpN101_2; 42507 SDValue CPTmpN101_3; 42508 SDValue CPTmpN101_4; 42509 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 42510 N10.getNode()->getValueType(0) == MVT::v1i64) { 42511 SDNode *Result = Emit_16(N, X86::MMX_PSUBDrm, MVT::v2i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 42512 return Result; 42513 } 42514 } 42515 } 42516 } 42517 } 42518 42519 // Pattern: (sub:v2i32 VR64:v2i32:$src1, VR64:v2i32:$src2) 42520 // Emits: (MMX_PSUBDrr:v2i32 VR64:v2i32:$src1, VR64:v2i32:$src2) 42521 // Pattern complexity = 3 cost = 1 size = 3 42522 if ((Subtarget->hasMMX())) { 42523 SDNode *Result = Emit_15(N, X86::MMX_PSUBDrr, MVT::v2i32); 42524 return Result; 42525 } 42526 42527 CannotYetSelect(N); 42528 return NULL; 42529 } 42530 42531 SDNode *Select_ISD_SUB_v4i32(const SDValue &N) { 42532 42533 // Pattern: (sub:v4i32 VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 42534 // Emits: (PSUBDrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 42535 // Pattern complexity = 28 cost = 1 size = 3 42536 if (OptLevel != CodeGenOpt::None && 42537 (Subtarget->hasSSE2())) { 42538 SDValue N0 = N.getOperand(0); 42539 SDValue N1 = N.getOperand(1); 42540 if (N1.getOpcode() == ISD::BIT_CONVERT && 42541 N1.hasOneUse()) { 42542 SDValue N10 = N1.getOperand(0); 42543 if (N10.getOpcode() == ISD::LOAD && 42544 N10.hasOneUse() && 42545 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 42546 SDValue Chain10 = N10.getOperand(0); 42547 if (Predicate_unindexedload(N10.getNode()) && 42548 Predicate_load(N10.getNode()) && 42549 Predicate_memop(N10.getNode())) { 42550 SDValue N101 = N10.getOperand(1); 42551 SDValue CPTmpN101_0; 42552 SDValue CPTmpN101_1; 42553 SDValue CPTmpN101_2; 42554 SDValue CPTmpN101_3; 42555 SDValue CPTmpN101_4; 42556 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 42557 N10.getNode()->getValueType(0) == MVT::v2i64) { 42558 SDNode *Result = Emit_16(N, X86::PSUBDrm, MVT::v4i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 42559 return Result; 42560 } 42561 } 42562 } 42563 } 42564 } 42565 42566 // Pattern: (sub:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 42567 // Emits: (PSUBDrr:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 42568 // Pattern complexity = 3 cost = 1 size = 3 42569 if ((Subtarget->hasSSE2())) { 42570 SDNode *Result = Emit_15(N, X86::PSUBDrr, MVT::v4i32); 42571 return Result; 42572 } 42573 42574 CannotYetSelect(N); 42575 return NULL; 42576 } 42577 42578 SDNode *Select_ISD_SUB_v1i64(const SDValue &N) { 42579 42580 // Pattern: (sub:v1i64 VR64:v1i64:$src1, (bitconvert:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 42581 // Emits: (MMX_PSUBQrm:v1i64 VR64:v1i64:$src1, addr:iPTR:$src2) 42582 // Pattern complexity = 28 cost = 1 size = 3 42583 if (OptLevel != CodeGenOpt::None && 42584 (Subtarget->hasMMX())) { 42585 SDValue N0 = N.getOperand(0); 42586 SDValue N1 = N.getOperand(1); 42587 if (N1.getOpcode() == ISD::BIT_CONVERT && 42588 N1.hasOneUse()) { 42589 SDValue N10 = N1.getOperand(0); 42590 if (N10.getOpcode() == ISD::LOAD && 42591 N10.hasOneUse() && 42592 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 42593 SDValue Chain10 = N10.getOperand(0); 42594 if (Predicate_unindexedload(N10.getNode()) && 42595 Predicate_load(N10.getNode())) { 42596 SDValue N101 = N10.getOperand(1); 42597 SDValue CPTmpN101_0; 42598 SDValue CPTmpN101_1; 42599 SDValue CPTmpN101_2; 42600 SDValue CPTmpN101_3; 42601 SDValue CPTmpN101_4; 42602 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 42603 N10.getNode()->getValueType(0) == MVT::v1i64) { 42604 SDNode *Result = Emit_16(N, X86::MMX_PSUBQrm, MVT::v1i64, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 42605 return Result; 42606 } 42607 } 42608 } 42609 } 42610 } 42611 42612 // Pattern: (sub:v1i64 VR64:v1i64:$src1, VR64:v1i64:$src2) 42613 // Emits: (MMX_PSUBQrr:v1i64 VR64:v1i64:$src1, VR64:v1i64:$src2) 42614 // Pattern complexity = 3 cost = 1 size = 3 42615 if ((Subtarget->hasMMX())) { 42616 SDNode *Result = Emit_15(N, X86::MMX_PSUBQrr, MVT::v1i64); 42617 return Result; 42618 } 42619 42620 CannotYetSelect(N); 42621 return NULL; 42622 } 42623 42624 SDNode *Select_ISD_SUB_v2i64(const SDValue &N) { 42625 42626 // Pattern: (sub:v2i64 VR128:v2i64:$src1, (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 42627 // Emits: (PSUBQrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 42628 // Pattern complexity = 25 cost = 1 size = 3 42629 if (OptLevel != CodeGenOpt::None && 42630 (Subtarget->hasSSE2())) { 42631 SDValue N0 = N.getOperand(0); 42632 SDValue N1 = N.getOperand(1); 42633 if (N1.getOpcode() == ISD::LOAD && 42634 N1.hasOneUse() && 42635 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 42636 SDValue Chain1 = N1.getOperand(0); 42637 if (Predicate_unindexedload(N1.getNode()) && 42638 Predicate_load(N1.getNode()) && 42639 Predicate_memop(N1.getNode())) { 42640 SDValue N11 = N1.getOperand(1); 42641 SDValue CPTmpN11_0; 42642 SDValue CPTmpN11_1; 42643 SDValue CPTmpN11_2; 42644 SDValue CPTmpN11_3; 42645 SDValue CPTmpN11_4; 42646 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 42647 SDNode *Result = Emit_18(N, X86::PSUBQrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 42648 return Result; 42649 } 42650 } 42651 } 42652 } 42653 42654 // Pattern: (sub:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 42655 // Emits: (PSUBQrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 42656 // Pattern complexity = 3 cost = 1 size = 3 42657 if ((Subtarget->hasSSE2())) { 42658 SDNode *Result = Emit_15(N, X86::PSUBQrr, MVT::v2i64); 42659 return Result; 42660 } 42661 42662 CannotYetSelect(N); 42663 return NULL; 42664 } 42665 42666 SDNode *Select_ISD_SUBC_i32(const SDValue &N) { 42667 42668 // Pattern: (subc:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 42669 // Emits: (SUB32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 42670 // Pattern complexity = 25 cost = 1 size = 3 42671 if (OptLevel != CodeGenOpt::None) { 42672 SDValue N0 = N.getOperand(0); 42673 SDValue N1 = N.getOperand(1); 42674 if (N1.getOpcode() == ISD::LOAD && 42675 N1.hasOneUse() && 42676 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 42677 SDValue Chain1 = N1.getOperand(0); 42678 if (Predicate_unindexedload(N1.getNode()) && 42679 Predicate_load(N1.getNode())) { 42680 SDValue N11 = N1.getOperand(1); 42681 SDValue CPTmpN11_0; 42682 SDValue CPTmpN11_1; 42683 SDValue CPTmpN11_2; 42684 SDValue CPTmpN11_3; 42685 SDValue CPTmpN11_4; 42686 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 42687 SDNode *Result = Emit_21(N, X86::SUB32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 42688 return Result; 42689 } 42690 } 42691 } 42692 } 42693 { 42694 SDValue N0 = N.getOperand(0); 42695 SDValue N1 = N.getOperand(1); 42696 if (N1.getOpcode() == ISD::Constant) { 42697 42698 // Pattern: (subc:i32 GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 42699 // Emits: (SUB32ri8:i32 GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 42700 // Pattern complexity = 7 cost = 1 size = 3 42701 if (Predicate_i32immSExt8(N1.getNode())) { 42702 SDNode *Result = Emit_22(N, X86::SUB32ri8, MVT::i32); 42703 return Result; 42704 } 42705 42706 // Pattern: (subc:i32 GR32:i32:$src1, (imm:i32):$src2) 42707 // Emits: (SUB32ri:i32 GR32:i32:$src1, (imm:i32):$src2) 42708 // Pattern complexity = 6 cost = 1 size = 3 42709 SDNode *Result = Emit_22(N, X86::SUB32ri, MVT::i32); 42710 return Result; 42711 } 42712 } 42713 42714 // Pattern: (subc:i32 GR32:i32:$src1, GR32:i32:$src2) 42715 // Emits: (SUB32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 42716 // Pattern complexity = 3 cost = 1 size = 3 42717 SDNode *Result = Emit_20(N, X86::SUB32rr, MVT::i32); 42718 return Result; 42719 } 42720 42721 SDNode *Select_ISD_SUBC_i64(const SDValue &N) { 42722 42723 // Pattern: (subc:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 42724 // Emits: (SUB64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 42725 // Pattern complexity = 25 cost = 1 size = 3 42726 if (OptLevel != CodeGenOpt::None) { 42727 SDValue N0 = N.getOperand(0); 42728 SDValue N1 = N.getOperand(1); 42729 if (N1.getOpcode() == ISD::LOAD && 42730 N1.hasOneUse() && 42731 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 42732 SDValue Chain1 = N1.getOperand(0); 42733 if (Predicate_unindexedload(N1.getNode()) && 42734 Predicate_load(N1.getNode())) { 42735 SDValue N11 = N1.getOperand(1); 42736 SDValue CPTmpN11_0; 42737 SDValue CPTmpN11_1; 42738 SDValue CPTmpN11_2; 42739 SDValue CPTmpN11_3; 42740 SDValue CPTmpN11_4; 42741 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 42742 SDNode *Result = Emit_21(N, X86::SUB64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 42743 return Result; 42744 } 42745 } 42746 } 42747 } 42748 { 42749 SDValue N0 = N.getOperand(0); 42750 SDValue N1 = N.getOperand(1); 42751 if (N1.getOpcode() == ISD::Constant) { 42752 42753 // Pattern: (subc:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 42754 // Emits: (SUB64ri8:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 42755 // Pattern complexity = 7 cost = 1 size = 3 42756 if (Predicate_i64immSExt8(N1.getNode())) { 42757 SDNode *Result = Emit_24(N, X86::SUB64ri8, MVT::i64); 42758 return Result; 42759 } 42760 42761 // Pattern: (subc:i64 GR64:i64:$src1, (imm:i64):$src2) 42762 // Emits: (SUB64ri32:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 42763 // Pattern complexity = 6 cost = 1 size = 3 42764 SDNode *Result = Emit_24(N, X86::SUB64ri32, MVT::i64); 42765 return Result; 42766 } 42767 } 42768 42769 // Pattern: (subc:i64 GR64:i64:$src1, GR64:i64:$src2) 42770 // Emits: (SUB64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 42771 // Pattern complexity = 3 cost = 1 size = 3 42772 SDNode *Result = Emit_20(N, X86::SUB64rr, MVT::i64); 42773 return Result; 42774 } 42775 42776 SDNode *Select_ISD_SUBE_i8(const SDValue &N) { 42777 42778 // Pattern: (sube:i8 GR8:i8:$src1, (ld:i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 42779 // Emits: (SBB8rm:i8 GR8:i8:$src1, addr:iPTR:$src2) 42780 // Pattern complexity = 25 cost = 1 size = 3 42781 if (OptLevel != CodeGenOpt::None) { 42782 SDValue N0 = N.getOperand(0); 42783 SDValue N1 = N.getOperand(1); 42784 if (N1.getOpcode() == ISD::LOAD && 42785 N1.hasOneUse() && 42786 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 42787 SDValue Chain1 = N1.getOperand(0); 42788 if (Predicate_unindexedload(N1.getNode()) && 42789 Predicate_load(N1.getNode())) { 42790 SDValue N11 = N1.getOperand(1); 42791 SDValue CPTmpN11_0; 42792 SDValue CPTmpN11_1; 42793 SDValue CPTmpN11_2; 42794 SDValue CPTmpN11_3; 42795 SDValue CPTmpN11_4; 42796 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 42797 SDNode *Result = Emit_26(N, X86::SBB8rm, MVT::i8, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 42798 return Result; 42799 } 42800 } 42801 } 42802 } 42803 42804 // Pattern: (sube:i8 GR8:i8:$src1, (imm:i8):$src2) 42805 // Emits: (SBB8ri:i8 GR8:i8:$src1, (imm:i8):$src2) 42806 // Pattern complexity = 6 cost = 1 size = 3 42807 { 42808 SDValue N0 = N.getOperand(0); 42809 SDValue N1 = N.getOperand(1); 42810 if (N1.getOpcode() == ISD::Constant) { 42811 SDNode *Result = Emit_27(N, X86::SBB8ri, MVT::i8); 42812 return Result; 42813 } 42814 } 42815 42816 // Pattern: (sube:i8 GR8:i8:$src1, GR8:i8:$src2) 42817 // Emits: (SBB8rr:i8 GR8:i8:$src1, GR8:i8:$src2) 42818 // Pattern complexity = 3 cost = 1 size = 3 42819 SDNode *Result = Emit_25(N, X86::SBB8rr, MVT::i8); 42820 return Result; 42821 } 42822 42823 SDNode *Select_ISD_SUBE_i16(const SDValue &N) { 42824 42825 // Pattern: (sube:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 42826 // Emits: (SBB16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 42827 // Pattern complexity = 25 cost = 1 size = 3 42828 if (OptLevel != CodeGenOpt::None) { 42829 SDValue N0 = N.getOperand(0); 42830 SDValue N1 = N.getOperand(1); 42831 if (N1.getOpcode() == ISD::LOAD && 42832 N1.hasOneUse() && 42833 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 42834 SDValue Chain1 = N1.getOperand(0); 42835 if (Predicate_unindexedload(N1.getNode()) && 42836 Predicate_load(N1.getNode())) { 42837 SDValue N11 = N1.getOperand(1); 42838 SDValue CPTmpN11_0; 42839 SDValue CPTmpN11_1; 42840 SDValue CPTmpN11_2; 42841 SDValue CPTmpN11_3; 42842 SDValue CPTmpN11_4; 42843 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 42844 SDNode *Result = Emit_26(N, X86::SBB16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 42845 return Result; 42846 } 42847 } 42848 } 42849 } 42850 { 42851 SDValue N0 = N.getOperand(0); 42852 SDValue N1 = N.getOperand(1); 42853 if (N1.getOpcode() == ISD::Constant) { 42854 42855 // Pattern: (sube:i16 GR16:i16:$src1, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 42856 // Emits: (SBB16ri8:i16 GR16:i16:$src1, (imm:i16):$src2) 42857 // Pattern complexity = 7 cost = 1 size = 3 42858 if (Predicate_i16immSExt8(N1.getNode())) { 42859 SDNode *Result = Emit_29(N, X86::SBB16ri8, MVT::i16); 42860 return Result; 42861 } 42862 42863 // Pattern: (sube:i16 GR16:i16:$src1, (imm:i16):$src2) 42864 // Emits: (SBB16ri:i16 GR16:i16:$src1, (imm:i16):$src2) 42865 // Pattern complexity = 6 cost = 1 size = 3 42866 SDNode *Result = Emit_29(N, X86::SBB16ri, MVT::i16); 42867 return Result; 42868 } 42869 } 42870 42871 // Pattern: (sube:i16 GR16:i16:$src1, GR16:i16:$src2) 42872 // Emits: (SBB16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 42873 // Pattern complexity = 3 cost = 1 size = 3 42874 SDNode *Result = Emit_25(N, X86::SBB16rr, MVT::i16); 42875 return Result; 42876 } 42877 42878 SDNode *Select_ISD_SUBE_i32(const SDValue &N) { 42879 42880 // Pattern: (sube:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 42881 // Emits: (SBB32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 42882 // Pattern complexity = 25 cost = 1 size = 3 42883 if (OptLevel != CodeGenOpt::None) { 42884 SDValue N0 = N.getOperand(0); 42885 SDValue N1 = N.getOperand(1); 42886 if (N1.getOpcode() == ISD::LOAD && 42887 N1.hasOneUse() && 42888 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 42889 SDValue Chain1 = N1.getOperand(0); 42890 if (Predicate_unindexedload(N1.getNode()) && 42891 Predicate_load(N1.getNode())) { 42892 SDValue N11 = N1.getOperand(1); 42893 SDValue CPTmpN11_0; 42894 SDValue CPTmpN11_1; 42895 SDValue CPTmpN11_2; 42896 SDValue CPTmpN11_3; 42897 SDValue CPTmpN11_4; 42898 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 42899 SDNode *Result = Emit_26(N, X86::SBB32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 42900 return Result; 42901 } 42902 } 42903 } 42904 } 42905 { 42906 SDValue N0 = N.getOperand(0); 42907 SDValue N1 = N.getOperand(1); 42908 if (N1.getOpcode() == ISD::Constant) { 42909 42910 // Pattern: (sube:i32 GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 42911 // Emits: (SBB32ri8:i32 GR32:i32:$src1, (imm:i32):$src2) 42912 // Pattern complexity = 7 cost = 1 size = 3 42913 if (Predicate_i32immSExt8(N1.getNode())) { 42914 SDNode *Result = Emit_30(N, X86::SBB32ri8, MVT::i32); 42915 return Result; 42916 } 42917 42918 // Pattern: (sube:i32 GR32:i32:$src1, (imm:i32):$src2) 42919 // Emits: (SBB32ri:i32 GR32:i32:$src1, (imm:i32):$src2) 42920 // Pattern complexity = 6 cost = 1 size = 3 42921 SDNode *Result = Emit_30(N, X86::SBB32ri, MVT::i32); 42922 return Result; 42923 } 42924 } 42925 42926 // Pattern: (sube:i32 GR32:i32:$src1, GR32:i32:$src2) 42927 // Emits: (SBB32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 42928 // Pattern complexity = 3 cost = 1 size = 3 42929 SDNode *Result = Emit_25(N, X86::SBB32rr, MVT::i32); 42930 return Result; 42931 } 42932 42933 SDNode *Select_ISD_SUBE_i64(const SDValue &N) { 42934 42935 // Pattern: (sube:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 42936 // Emits: (SBB64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 42937 // Pattern complexity = 25 cost = 1 size = 3 42938 if (OptLevel != CodeGenOpt::None) { 42939 SDValue N0 = N.getOperand(0); 42940 SDValue N1 = N.getOperand(1); 42941 if (N1.getOpcode() == ISD::LOAD && 42942 N1.hasOneUse() && 42943 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 42944 SDValue Chain1 = N1.getOperand(0); 42945 if (Predicate_unindexedload(N1.getNode()) && 42946 Predicate_load(N1.getNode())) { 42947 SDValue N11 = N1.getOperand(1); 42948 SDValue CPTmpN11_0; 42949 SDValue CPTmpN11_1; 42950 SDValue CPTmpN11_2; 42951 SDValue CPTmpN11_3; 42952 SDValue CPTmpN11_4; 42953 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 42954 SDNode *Result = Emit_26(N, X86::SBB64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 42955 return Result; 42956 } 42957 } 42958 } 42959 } 42960 { 42961 SDValue N0 = N.getOperand(0); 42962 SDValue N1 = N.getOperand(1); 42963 if (N1.getOpcode() == ISD::Constant) { 42964 42965 // Pattern: (sube:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 42966 // Emits: (SBB64ri8:i64 GR64:i64:$src1, (imm:i64):$src2) 42967 // Pattern complexity = 7 cost = 1 size = 3 42968 if (Predicate_i64immSExt8(N1.getNode())) { 42969 SDNode *Result = Emit_31(N, X86::SBB64ri8, MVT::i64); 42970 return Result; 42971 } 42972 42973 // Pattern: (sube:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 42974 // Emits: (SBB64ri32:i64 GR64:i64:$src1, (imm:i64):$src2) 42975 // Pattern complexity = 7 cost = 1 size = 3 42976 if (Predicate_i64immSExt32(N1.getNode())) { 42977 SDNode *Result = Emit_31(N, X86::SBB64ri32, MVT::i64); 42978 return Result; 42979 } 42980 } 42981 } 42982 42983 // Pattern: (sube:i64 GR64:i64:$src1, GR64:i64:$src2) 42984 // Emits: (SBB64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 42985 // Pattern complexity = 3 cost = 1 size = 3 42986 SDNode *Result = Emit_25(N, X86::SBB64rr, MVT::i64); 42987 return Result; 42988 } 42989 42990 SDNode *Emit_225(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 42991 SDValue Chain = N.getOperand(0); 42992 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Chain); 42993 } 42994 SDNode *Select_ISD_TRAP(const SDValue &N) { 42995 SDNode *Result = Emit_225(N, X86::TRAP); 42996 return Result; 42997 } 42998 42999 SDNode *Emit_226(const SDValue &N, unsigned Opc0, unsigned Opc1, EVT VT0, EVT VT1) DISABLE_INLINE { 43000 SDValue N0 = N.getOperand(0); 43001 SDValue Tmp1 = CurDAG->getTargetConstant(X86::GR32_ABCDRegClassID, MVT::i32); 43002 SDValue Tmp2(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N0, Tmp1), 0); 43003 SDValue Tmp3 = CurDAG->getTargetConstant(0x1ULL, MVT::i32); 43004 return CurDAG->SelectNodeTo(N.getNode(), Opc1, VT1, Tmp2, Tmp3); 43005 } 43006 SDNode *Emit_227(const SDValue &N, unsigned Opc0, unsigned Opc1, EVT VT0, EVT VT1) DISABLE_INLINE { 43007 SDValue N0 = N.getOperand(0); 43008 SDValue Tmp1 = CurDAG->getTargetConstant(X86::GR16_ABCDRegClassID, MVT::i32); 43009 SDValue Tmp2(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N0, Tmp1), 0); 43010 SDValue Tmp3 = CurDAG->getTargetConstant(0x1ULL, MVT::i32); 43011 return CurDAG->SelectNodeTo(N.getNode(), Opc1, VT1, Tmp2, Tmp3); 43012 } 43013 SDNode *Emit_228(const SDValue &N, unsigned Opc0, unsigned Opc1, EVT VT0, EVT VT1) DISABLE_INLINE { 43014 SDValue N0 = N.getOperand(0); 43015 SDValue N00 = N0.getOperand(0); 43016 SDValue N01 = N0.getOperand(1); 43017 SDValue Tmp3 = CurDAG->getTargetConstant(X86::GR16_ABCDRegClassID, MVT::i32); 43018 SDValue Tmp4(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N00, Tmp3), 0); 43019 SDValue Tmp5 = CurDAG->getTargetConstant(0x2ULL, MVT::i32); 43020 return CurDAG->SelectNodeTo(N.getNode(), Opc1, VT1, Tmp4, Tmp5); 43021 } 43022 SDNode *Emit_229(const SDValue &N, unsigned Opc0, unsigned Opc1, EVT VT0, EVT VT1) DISABLE_INLINE { 43023 SDValue N0 = N.getOperand(0); 43024 SDValue N00 = N0.getOperand(0); 43025 SDValue N01 = N0.getOperand(1); 43026 SDValue Tmp3 = CurDAG->getTargetConstant(X86::GR32_ABCDRegClassID, MVT::i32); 43027 SDValue Tmp4(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N00, Tmp3), 0); 43028 SDValue Tmp5 = CurDAG->getTargetConstant(0x2ULL, MVT::i32); 43029 return CurDAG->SelectNodeTo(N.getNode(), Opc1, VT1, Tmp4, Tmp5); 43030 } 43031 SDNode *Emit_230(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 43032 SDValue N0 = N.getOperand(0); 43033 SDValue Tmp1 = CurDAG->getTargetConstant(0x1ULL, MVT::i32); 43034 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, Tmp1); 43035 } 43036 SDNode *Select_ISD_TRUNCATE_i8(const SDValue &N) { 43037 if ((!Subtarget->is64Bit())) { 43038 SDValue N0 = N.getOperand(0); 43039 if (N0.getOpcode() == ISD::SRL && 43040 Predicate_srl_su(N0.getNode())) { 43041 SDValue N00 = N0.getOperand(0); 43042 SDValue N01 = N0.getOperand(1); 43043 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N01); 43044 if (Tmp0) { 43045 int64_t CN1 = Tmp0->getSExtValue(); 43046 if (CN1 == INT64_C(8)) { 43047 43048 // Pattern: (trunc:i8 (srl:i16 GR16:i16:$src, 8:i8)<<P:Predicate_srl_su>>) 43049 // Emits: (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i16 GR16:i16:$src, GR16_ABCD:i16), 2:i32) 43050 // Pattern complexity = 12 cost = 2 size = 0 43051 if (N0.getNode()->getValueType(0) == MVT::i16 && 43052 N01.getNode()->getValueType(0) == MVT::i8) { 43053 SDNode *Result = Emit_228(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, MVT::i16, MVT::i8); 43054 return Result; 43055 } 43056 43057 // Pattern: (trunc:i8 (srl:i32 GR32:i32:$src, 8:i8)<<P:Predicate_srl_su>>) 43058 // Emits: (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i32 GR32:i32:$src, GR32_ABCD:i32), 2:i32) 43059 // Pattern complexity = 12 cost = 2 size = 0 43060 if (N0.getNode()->getValueType(0) == MVT::i32 && 43061 N01.getNode()->getValueType(0) == MVT::i8) { 43062 SDNode *Result = Emit_229(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, MVT::i32, MVT::i8); 43063 return Result; 43064 } 43065 } 43066 } 43067 } 43068 } 43069 43070 // Pattern: (trunc:i8 GR64:i64:$src) 43071 // Emits: (EXTRACT_SUBREG:i8 GR64:i64:$src, 1:i32) 43072 // Pattern complexity = 3 cost = 1 size = 0 43073 { 43074 SDValue N0 = N.getOperand(0); 43075 if (N0.getNode()->getValueType(0) == MVT::i64) { 43076 SDNode *Result = Emit_230(N, TargetInstrInfo::EXTRACT_SUBREG, MVT::i8); 43077 return Result; 43078 } 43079 } 43080 if ((Subtarget->is64Bit())) { 43081 SDValue N0 = N.getOperand(0); 43082 43083 // Pattern: (trunc:i8 GR32:i32:$src) 43084 // Emits: (EXTRACT_SUBREG:i8 GR32:i32:$src, 1:i32) 43085 // Pattern complexity = 3 cost = 1 size = 0 43086 if (N0.getNode()->getValueType(0) == MVT::i32) { 43087 SDNode *Result = Emit_230(N, TargetInstrInfo::EXTRACT_SUBREG, MVT::i8); 43088 return Result; 43089 } 43090 43091 // Pattern: (trunc:i8 GR16:i16:$src) 43092 // Emits: (EXTRACT_SUBREG:i8 GR16:i16:$src, 1:i32) 43093 // Pattern complexity = 3 cost = 1 size = 0 43094 if (N0.getNode()->getValueType(0) == MVT::i16) { 43095 SDNode *Result = Emit_230(N, TargetInstrInfo::EXTRACT_SUBREG, MVT::i8); 43096 return Result; 43097 } 43098 } 43099 if ((!Subtarget->is64Bit())) { 43100 SDValue N0 = N.getOperand(0); 43101 43102 // Pattern: (trunc:i8 GR32:i32:$src) 43103 // Emits: (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i32 GR32:i32:$src, GR32_ABCD:i32), 1:i32) 43104 // Pattern complexity = 3 cost = 2 size = 0 43105 if (N0.getNode()->getValueType(0) == MVT::i32) { 43106 SDNode *Result = Emit_226(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, MVT::i32, MVT::i8); 43107 return Result; 43108 } 43109 43110 // Pattern: (trunc:i8 GR16:i16:$src) 43111 // Emits: (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i16 GR16:i16:$src, GR16_ABCD:i16), 1:i32) 43112 // Pattern complexity = 3 cost = 2 size = 0 43113 if (N0.getNode()->getValueType(0) == MVT::i16) { 43114 SDNode *Result = Emit_227(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, MVT::i16, MVT::i8); 43115 return Result; 43116 } 43117 } 43118 43119 CannotYetSelect(N); 43120 return NULL; 43121 } 43122 43123 SDNode *Emit_231(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 43124 SDValue N0 = N.getOperand(0); 43125 SDValue Tmp1 = CurDAG->getTargetConstant(0x3ULL, MVT::i32); 43126 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, Tmp1); 43127 } 43128 SDNode *Select_ISD_TRUNCATE_i16(const SDValue &N) { 43129 SDValue N0 = N.getOperand(0); 43130 43131 // Pattern: (trunc:i16 GR32:i32:$src) 43132 // Emits: (EXTRACT_SUBREG:i16 GR32:i32:$src, 3:i32) 43133 // Pattern complexity = 3 cost = 1 size = 0 43134 if (N0.getNode()->getValueType(0) == MVT::i32) { 43135 SDNode *Result = Emit_231(N, TargetInstrInfo::EXTRACT_SUBREG, MVT::i16); 43136 return Result; 43137 } 43138 43139 // Pattern: (trunc:i16 GR64:i64:$src) 43140 // Emits: (EXTRACT_SUBREG:i16 GR64:i64:$src, 3:i32) 43141 // Pattern complexity = 3 cost = 1 size = 0 43142 if (N0.getNode()->getValueType(0) == MVT::i64) { 43143 SDNode *Result = Emit_231(N, TargetInstrInfo::EXTRACT_SUBREG, MVT::i16); 43144 return Result; 43145 } 43146 43147 CannotYetSelect(N); 43148 return NULL; 43149 } 43150 43151 SDNode *Emit_232(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 43152 SDValue N0 = N.getOperand(0); 43153 SDValue Tmp1 = CurDAG->getTargetConstant(0x4ULL, MVT::i32); 43154 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, Tmp1); 43155 } 43156 SDNode *Select_ISD_TRUNCATE_i32(const SDValue &N) { 43157 SDValue N0 = N.getOperand(0); 43158 if (N0.getNode()->getValueType(0) == MVT::i64) { 43159 SDNode *Result = Emit_232(N, TargetInstrInfo::EXTRACT_SUBREG, MVT::i32); 43160 return Result; 43161 } 43162 43163 CannotYetSelect(N); 43164 return NULL; 43165 } 43166 43167 SDNode *Select_ISD_VECTOR_SHUFFLE_v8i8(const SDValue &N) { 43168 if (OptLevel != CodeGenOpt::None && 43169 (Subtarget->hasMMX())) { 43170 43171 // Pattern: (vector_shuffle:v8i8 VR64:v8i8:$src1, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>))<<P:Predicate_mmx_unpckh>> 43172 // Emits: (MMX_PUNPCKHBWrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 43173 // Pattern complexity = 29 cost = 1 size = 3 43174 if (Predicate_mmx_unpckh(N.getNode())) { 43175 SDValue N0 = N.getOperand(0); 43176 SDValue N1 = N.getOperand(1); 43177 if (N1.getOpcode() == ISD::BIT_CONVERT && 43178 N1.hasOneUse()) { 43179 SDValue N10 = N1.getOperand(0); 43180 if (N10.getOpcode() == ISD::LOAD && 43181 N10.hasOneUse() && 43182 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 43183 SDValue Chain10 = N10.getOperand(0); 43184 if (Predicate_unindexedload(N10.getNode()) && 43185 Predicate_load(N10.getNode())) { 43186 SDValue N101 = N10.getOperand(1); 43187 SDValue CPTmpN101_0; 43188 SDValue CPTmpN101_1; 43189 SDValue CPTmpN101_2; 43190 SDValue CPTmpN101_3; 43191 SDValue CPTmpN101_4; 43192 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 43193 N10.getNode()->getValueType(0) == MVT::v1i64) { 43194 SDNode *Result = Emit_16(N, X86::MMX_PUNPCKHBWrm, MVT::v8i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 43195 return Result; 43196 } 43197 } 43198 } 43199 } 43200 } 43201 43202 // Pattern: (vector_shuffle:v8i8 VR64:v8i8:$src1, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>))<<P:Predicate_mmx_unpckl>> 43203 // Emits: (MMX_PUNPCKLBWrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 43204 // Pattern complexity = 29 cost = 1 size = 3 43205 if (Predicate_mmx_unpckl(N.getNode())) { 43206 SDValue N0 = N.getOperand(0); 43207 SDValue N1 = N.getOperand(1); 43208 if (N1.getOpcode() == ISD::BIT_CONVERT && 43209 N1.hasOneUse()) { 43210 SDValue N10 = N1.getOperand(0); 43211 if (N10.getOpcode() == ISD::LOAD && 43212 N10.hasOneUse() && 43213 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 43214 SDValue Chain10 = N10.getOperand(0); 43215 if (Predicate_unindexedload(N10.getNode()) && 43216 Predicate_load(N10.getNode())) { 43217 SDValue N101 = N10.getOperand(1); 43218 SDValue CPTmpN101_0; 43219 SDValue CPTmpN101_1; 43220 SDValue CPTmpN101_2; 43221 SDValue CPTmpN101_3; 43222 SDValue CPTmpN101_4; 43223 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 43224 N10.getNode()->getValueType(0) == MVT::v1i64) { 43225 SDNode *Result = Emit_16(N, X86::MMX_PUNPCKLBWrm, MVT::v8i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 43226 return Result; 43227 } 43228 } 43229 } 43230 } 43231 } 43232 } 43233 43234 // Pattern: (vector_shuffle:v8i8 VR64:v8i8:$src, (undef:v8i8))<<P:Predicate_mmx_unpckl_undef>> 43235 // Emits: (MMX_PUNPCKLBWrr:v8i8 VR64:v8i8:$src, VR64:v8i8:$src) 43236 // Pattern complexity = 17 cost = 1 size = 3 43237 if (Predicate_mmx_unpckl_undef(N.getNode())) { 43238 SDValue N0 = N.getOperand(0); 43239 SDValue N1 = N.getOperand(1); 43240 if (N1.getOpcode() == ISD::UNDEF) { 43241 SDNode *Result = Emit_162(N, X86::MMX_PUNPCKLBWrr, MVT::v8i8); 43242 return Result; 43243 } 43244 } 43245 43246 // Pattern: (vector_shuffle:v8i8 VR64:v8i8:$src, (undef:v8i8))<<P:Predicate_mmx_unpckh_undef>> 43247 // Emits: (MMX_PUNPCKHBWrr:v8i8 VR64:v8i8:$src, VR64:v8i8:$src) 43248 // Pattern complexity = 17 cost = 1 size = 3 43249 if (Predicate_mmx_unpckh_undef(N.getNode())) { 43250 SDValue N0 = N.getOperand(0); 43251 SDValue N1 = N.getOperand(1); 43252 if (N1.getOpcode() == ISD::UNDEF) { 43253 SDNode *Result = Emit_162(N, X86::MMX_PUNPCKHBWrr, MVT::v8i8); 43254 return Result; 43255 } 43256 } 43257 if ((Subtarget->hasMMX())) { 43258 43259 // Pattern: (vector_shuffle:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2)<<P:Predicate_mmx_unpckh>> 43260 // Emits: (MMX_PUNPCKHBWrr:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 43261 // Pattern complexity = 4 cost = 1 size = 3 43262 if (Predicate_mmx_unpckh(N.getNode())) { 43263 SDNode *Result = Emit_15(N, X86::MMX_PUNPCKHBWrr, MVT::v8i8); 43264 return Result; 43265 } 43266 43267 // Pattern: (vector_shuffle:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2)<<P:Predicate_mmx_unpckl>> 43268 // Emits: (MMX_PUNPCKLBWrr:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 43269 // Pattern complexity = 4 cost = 1 size = 3 43270 if (Predicate_mmx_unpckl(N.getNode())) { 43271 SDNode *Result = Emit_15(N, X86::MMX_PUNPCKLBWrr, MVT::v8i8); 43272 return Result; 43273 } 43274 } 43275 43276 CannotYetSelect(N); 43277 return NULL; 43278 } 43279 43280 SDNode *Select_ISD_VECTOR_SHUFFLE_v16i8(const SDValue &N) { 43281 if (OptLevel != CodeGenOpt::None && 43282 (Subtarget->hasSSE2())) { 43283 43284 // Pattern: (vector_shuffle:v16i8 VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>))<<P:Predicate_unpckl>> 43285 // Emits: (PUNPCKLBWrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 43286 // Pattern complexity = 29 cost = 1 size = 3 43287 if (Predicate_unpckl(N.getNode())) { 43288 SDValue N0 = N.getOperand(0); 43289 SDValue N1 = N.getOperand(1); 43290 if (N1.getOpcode() == ISD::BIT_CONVERT && 43291 N1.hasOneUse()) { 43292 SDValue N10 = N1.getOperand(0); 43293 if (N10.getOpcode() == ISD::LOAD && 43294 N10.hasOneUse() && 43295 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 43296 SDValue Chain10 = N10.getOperand(0); 43297 if (Predicate_unindexedload(N10.getNode()) && 43298 Predicate_load(N10.getNode()) && 43299 Predicate_memop(N10.getNode())) { 43300 SDValue N101 = N10.getOperand(1); 43301 SDValue CPTmpN101_0; 43302 SDValue CPTmpN101_1; 43303 SDValue CPTmpN101_2; 43304 SDValue CPTmpN101_3; 43305 SDValue CPTmpN101_4; 43306 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 43307 N10.getNode()->getValueType(0) == MVT::v2i64) { 43308 SDNode *Result = Emit_16(N, X86::PUNPCKLBWrm, MVT::v16i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 43309 return Result; 43310 } 43311 } 43312 } 43313 } 43314 } 43315 43316 // Pattern: (vector_shuffle:v16i8 VR128:v16i8:$src1, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>))<<P:Predicate_unpckh>> 43317 // Emits: (PUNPCKHBWrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 43318 // Pattern complexity = 29 cost = 1 size = 3 43319 if (Predicate_unpckh(N.getNode())) { 43320 SDValue N0 = N.getOperand(0); 43321 SDValue N1 = N.getOperand(1); 43322 if (N1.getOpcode() == ISD::BIT_CONVERT && 43323 N1.hasOneUse()) { 43324 SDValue N10 = N1.getOperand(0); 43325 if (N10.getOpcode() == ISD::LOAD && 43326 N10.hasOneUse() && 43327 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 43328 SDValue Chain10 = N10.getOperand(0); 43329 if (Predicate_unindexedload(N10.getNode()) && 43330 Predicate_load(N10.getNode()) && 43331 Predicate_memop(N10.getNode())) { 43332 SDValue N101 = N10.getOperand(1); 43333 SDValue CPTmpN101_0; 43334 SDValue CPTmpN101_1; 43335 SDValue CPTmpN101_2; 43336 SDValue CPTmpN101_3; 43337 SDValue CPTmpN101_4; 43338 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 43339 N10.getNode()->getValueType(0) == MVT::v2i64) { 43340 SDNode *Result = Emit_16(N, X86::PUNPCKHBWrm, MVT::v16i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 43341 return Result; 43342 } 43343 } 43344 } 43345 } 43346 } 43347 } 43348 if ((Subtarget->hasSSE2())) { 43349 43350 // Pattern: (vector_shuffle:v16i8 VR128:v16i8:$src, (undef:v16i8))<<P:Predicate_unpckl_undef>> 43351 // Emits: (PUNPCKLBWrr:v16i8 VR128:v16i8:$src, VR128:v16i8:$src) 43352 // Pattern complexity = 17 cost = 1 size = 3 43353 if (Predicate_unpckl_undef(N.getNode())) { 43354 SDValue N0 = N.getOperand(0); 43355 SDValue N1 = N.getOperand(1); 43356 if (N1.getOpcode() == ISD::UNDEF) { 43357 SDNode *Result = Emit_162(N, X86::PUNPCKLBWrr, MVT::v16i8); 43358 return Result; 43359 } 43360 } 43361 43362 // Pattern: (vector_shuffle:v16i8 VR128:v16i8:$src, (undef:v16i8))<<P:Predicate_unpckh_undef>> 43363 // Emits: (PUNPCKHBWrr:v16i8 VR128:v16i8:$src, VR128:v16i8:$src) 43364 // Pattern complexity = 17 cost = 1 size = 3 43365 if (Predicate_unpckh_undef(N.getNode())) { 43366 SDValue N0 = N.getOperand(0); 43367 SDValue N1 = N.getOperand(1); 43368 if (N1.getOpcode() == ISD::UNDEF) { 43369 SDNode *Result = Emit_162(N, X86::PUNPCKHBWrr, MVT::v16i8); 43370 return Result; 43371 } 43372 } 43373 43374 // Pattern: (vector_shuffle:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2)<<P:Predicate_unpckl>> 43375 // Emits: (PUNPCKLBWrr:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 43376 // Pattern complexity = 4 cost = 1 size = 3 43377 if (Predicate_unpckl(N.getNode())) { 43378 SDNode *Result = Emit_15(N, X86::PUNPCKLBWrr, MVT::v16i8); 43379 return Result; 43380 } 43381 43382 // Pattern: (vector_shuffle:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2)<<P:Predicate_unpckh>> 43383 // Emits: (PUNPCKHBWrr:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 43384 // Pattern complexity = 4 cost = 1 size = 3 43385 if (Predicate_unpckh(N.getNode())) { 43386 SDNode *Result = Emit_15(N, X86::PUNPCKHBWrr, MVT::v16i8); 43387 return Result; 43388 } 43389 } 43390 43391 CannotYetSelect(N); 43392 return NULL; 43393 } 43394 43395 SDNode *Emit_233(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 43396 SDValue N0 = N.getOperand(0); 43397 SDValue N1 = N.getOperand(1); 43398 SDValue Tmp2 = Transform_MMX_SHUFFLE_get_shuf_imm(N.getNode()); 43399 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, Tmp2); 43400 } 43401 SDNode *Emit_234(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN001_0, SDValue &CPTmpN001_1, SDValue &CPTmpN001_2, SDValue &CPTmpN001_3, SDValue &CPTmpN001_4) DISABLE_INLINE { 43402 SDValue N0 = N.getOperand(0); 43403 SDValue N00 = N0.getOperand(0); 43404 SDValue Chain00 = N00.getOperand(0); 43405 SDValue N001 = N00.getOperand(1); 43406 SDValue N1 = N.getOperand(1); 43407 SDValue Tmp2 = Transform_MMX_SHUFFLE_get_shuf_imm(N.getNode()); 43408 SDValue LSI_N00 = CurDAG->getMemOperand(cast<MemSDNode>(N00)->getMemOperand()); 43409 SDValue Ops0[] = { CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4, Tmp2, LSI_N00, Chain00 }; 43410 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 43411 ReplaceUses(SDValue(N00.getNode(), 1), SDValue(ResNode, 1)); 43412 return ResNode; 43413 } 43414 SDNode *Select_ISD_VECTOR_SHUFFLE_v4i16(const SDValue &N) { 43415 if (OptLevel != CodeGenOpt::None && 43416 (Subtarget->hasMMX())) { 43417 43418 // Pattern: (vector_shuffle:v4i16 (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>>), (undef:v4i16))<<P:Predicate_mmx_pshufw>><<X:MMX_SHUFFLE_get_shuf_imm>>:$src2 43419 // Emits: (MMX_PSHUFWmi:v4i16 addr:iPTR:$src1, (MMX_SHUFFLE_get_shuf_imm:i8 (vector_shuffle:v4i16 (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>>), (undef:v4i16)):$src2)) 43420 // Pattern complexity = 32 cost = 1 size = 3 43421 if (Predicate_mmx_pshufw(N.getNode())) { 43422 SDValue N0 = N.getOperand(0); 43423 if (N0.getOpcode() == ISD::BIT_CONVERT && 43424 N0.hasOneUse()) { 43425 SDValue N00 = N0.getOperand(0); 43426 if (N00.getOpcode() == ISD::LOAD && 43427 N00.hasOneUse() && 43428 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 43429 SDValue Chain00 = N00.getOperand(0); 43430 if (Predicate_unindexedload(N00.getNode()) && 43431 Predicate_load(N00.getNode())) { 43432 SDValue N001 = N00.getOperand(1); 43433 SDValue CPTmpN001_0; 43434 SDValue CPTmpN001_1; 43435 SDValue CPTmpN001_2; 43436 SDValue CPTmpN001_3; 43437 SDValue CPTmpN001_4; 43438 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 43439 SDValue N1 = N.getOperand(1); 43440 if (N1.getOpcode() == ISD::UNDEF && 43441 N00.getNode()->getValueType(0) == MVT::v1i64) { 43442 SDNode *Result = Emit_234(N, X86::MMX_PSHUFWmi, MVT::v4i16, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 43443 return Result; 43444 } 43445 } 43446 } 43447 } 43448 } 43449 } 43450 43451 // Pattern: (vector_shuffle:v4i16 VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>))<<P:Predicate_mmx_unpckh>> 43452 // Emits: (MMX_PUNPCKHWDrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 43453 // Pattern complexity = 29 cost = 1 size = 3 43454 if (Predicate_mmx_unpckh(N.getNode())) { 43455 SDValue N0 = N.getOperand(0); 43456 SDValue N1 = N.getOperand(1); 43457 if (N1.getOpcode() == ISD::BIT_CONVERT && 43458 N1.hasOneUse()) { 43459 SDValue N10 = N1.getOperand(0); 43460 if (N10.getOpcode() == ISD::LOAD && 43461 N10.hasOneUse() && 43462 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 43463 SDValue Chain10 = N10.getOperand(0); 43464 if (Predicate_unindexedload(N10.getNode()) && 43465 Predicate_load(N10.getNode())) { 43466 SDValue N101 = N10.getOperand(1); 43467 SDValue CPTmpN101_0; 43468 SDValue CPTmpN101_1; 43469 SDValue CPTmpN101_2; 43470 SDValue CPTmpN101_3; 43471 SDValue CPTmpN101_4; 43472 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 43473 N10.getNode()->getValueType(0) == MVT::v1i64) { 43474 SDNode *Result = Emit_16(N, X86::MMX_PUNPCKHWDrm, MVT::v4i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 43475 return Result; 43476 } 43477 } 43478 } 43479 } 43480 } 43481 43482 // Pattern: (vector_shuffle:v4i16 VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>))<<P:Predicate_mmx_unpckl>> 43483 // Emits: (MMX_PUNPCKLWDrm:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2) 43484 // Pattern complexity = 29 cost = 1 size = 3 43485 if (Predicate_mmx_unpckl(N.getNode())) { 43486 SDValue N0 = N.getOperand(0); 43487 SDValue N1 = N.getOperand(1); 43488 if (N1.getOpcode() == ISD::BIT_CONVERT && 43489 N1.hasOneUse()) { 43490 SDValue N10 = N1.getOperand(0); 43491 if (N10.getOpcode() == ISD::LOAD && 43492 N10.hasOneUse() && 43493 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 43494 SDValue Chain10 = N10.getOperand(0); 43495 if (Predicate_unindexedload(N10.getNode()) && 43496 Predicate_load(N10.getNode())) { 43497 SDValue N101 = N10.getOperand(1); 43498 SDValue CPTmpN101_0; 43499 SDValue CPTmpN101_1; 43500 SDValue CPTmpN101_2; 43501 SDValue CPTmpN101_3; 43502 SDValue CPTmpN101_4; 43503 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 43504 N10.getNode()->getValueType(0) == MVT::v1i64) { 43505 SDNode *Result = Emit_16(N, X86::MMX_PUNPCKLWDrm, MVT::v4i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 43506 return Result; 43507 } 43508 } 43509 } 43510 } 43511 } 43512 } 43513 43514 // Pattern: (vector_shuffle:v4i16 VR64:v4i16:$src, (undef:v4i16))<<P:Predicate_mmx_unpckl_undef>> 43515 // Emits: (MMX_PUNPCKLWDrr:v4i16 VR64:v8i8:$src, VR64:v8i8:$src) 43516 // Pattern complexity = 17 cost = 1 size = 3 43517 if (Predicate_mmx_unpckl_undef(N.getNode())) { 43518 SDValue N0 = N.getOperand(0); 43519 SDValue N1 = N.getOperand(1); 43520 if (N1.getOpcode() == ISD::UNDEF) { 43521 SDNode *Result = Emit_162(N, X86::MMX_PUNPCKLWDrr, MVT::v4i16); 43522 return Result; 43523 } 43524 } 43525 43526 // Pattern: (vector_shuffle:v4i16 VR64:v4i16:$src, (undef:v4i16))<<P:Predicate_mmx_unpckh_undef>> 43527 // Emits: (MMX_PUNPCKHWDrr:v4i16 VR64:v8i8:$src, VR64:v8i8:$src) 43528 // Pattern complexity = 17 cost = 1 size = 3 43529 if (Predicate_mmx_unpckh_undef(N.getNode())) { 43530 SDValue N0 = N.getOperand(0); 43531 SDValue N1 = N.getOperand(1); 43532 if (N1.getOpcode() == ISD::UNDEF) { 43533 SDNode *Result = Emit_162(N, X86::MMX_PUNPCKHWDrr, MVT::v4i16); 43534 return Result; 43535 } 43536 } 43537 if ((Subtarget->hasMMX())) { 43538 43539 // Pattern: (vector_shuffle:v4i16 VR64:v4i16:$src1, (undef:v4i16))<<P:Predicate_mmx_pshufw>><<X:MMX_SHUFFLE_get_shuf_imm>>:$src2 43540 // Emits: (MMX_PSHUFWri:v4i16 VR64:v4i16:$src1, (MMX_SHUFFLE_get_shuf_imm:i8 (vector_shuffle:v4i16 VR64:v4i16:$src1, (undef:v4i16)):$src2)) 43541 // Pattern complexity = 7 cost = 1 size = 3 43542 if (Predicate_mmx_pshufw(N.getNode())) { 43543 SDValue N0 = N.getOperand(0); 43544 SDValue N1 = N.getOperand(1); 43545 if (N1.getOpcode() == ISD::UNDEF) { 43546 SDNode *Result = Emit_233(N, X86::MMX_PSHUFWri, MVT::v4i16); 43547 return Result; 43548 } 43549 } 43550 43551 // Pattern: (vector_shuffle:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2)<<P:Predicate_mmx_unpckh>> 43552 // Emits: (MMX_PUNPCKHWDrr:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 43553 // Pattern complexity = 4 cost = 1 size = 3 43554 if (Predicate_mmx_unpckh(N.getNode())) { 43555 SDNode *Result = Emit_15(N, X86::MMX_PUNPCKHWDrr, MVT::v4i16); 43556 return Result; 43557 } 43558 43559 // Pattern: (vector_shuffle:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2)<<P:Predicate_mmx_unpckl>> 43560 // Emits: (MMX_PUNPCKLWDrr:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 43561 // Pattern complexity = 4 cost = 1 size = 3 43562 if (Predicate_mmx_unpckl(N.getNode())) { 43563 SDNode *Result = Emit_15(N, X86::MMX_PUNPCKLWDrr, MVT::v4i16); 43564 return Result; 43565 } 43566 } 43567 43568 CannotYetSelect(N); 43569 return NULL; 43570 } 43571 43572 SDNode *Emit_235(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 43573 SDValue N0 = N.getOperand(0); 43574 SDValue N1 = N.getOperand(1); 43575 SDValue Tmp2 = Transform_SHUFFLE_get_pshufhw_imm(N.getNode()); 43576 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, Tmp2); 43577 } 43578 SDNode *Emit_236(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN001_0, SDValue &CPTmpN001_1, SDValue &CPTmpN001_2, SDValue &CPTmpN001_3, SDValue &CPTmpN001_4) DISABLE_INLINE { 43579 SDValue N0 = N.getOperand(0); 43580 SDValue N00 = N0.getOperand(0); 43581 SDValue Chain00 = N00.getOperand(0); 43582 SDValue N001 = N00.getOperand(1); 43583 SDValue N1 = N.getOperand(1); 43584 SDValue Tmp2 = Transform_SHUFFLE_get_pshufhw_imm(N.getNode()); 43585 SDValue LSI_N00 = CurDAG->getMemOperand(cast<MemSDNode>(N00)->getMemOperand()); 43586 SDValue Ops0[] = { CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4, Tmp2, LSI_N00, Chain00 }; 43587 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 43588 ReplaceUses(SDValue(N00.getNode(), 1), SDValue(ResNode, 1)); 43589 return ResNode; 43590 } 43591 SDNode *Emit_237(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 43592 SDValue N0 = N.getOperand(0); 43593 SDValue N1 = N.getOperand(1); 43594 SDValue Tmp2 = Transform_SHUFFLE_get_pshuflw_imm(N.getNode()); 43595 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, Tmp2); 43596 } 43597 SDNode *Emit_238(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN001_0, SDValue &CPTmpN001_1, SDValue &CPTmpN001_2, SDValue &CPTmpN001_3, SDValue &CPTmpN001_4) DISABLE_INLINE { 43598 SDValue N0 = N.getOperand(0); 43599 SDValue N00 = N0.getOperand(0); 43600 SDValue Chain00 = N00.getOperand(0); 43601 SDValue N001 = N00.getOperand(1); 43602 SDValue N1 = N.getOperand(1); 43603 SDValue Tmp2 = Transform_SHUFFLE_get_pshuflw_imm(N.getNode()); 43604 SDValue LSI_N00 = CurDAG->getMemOperand(cast<MemSDNode>(N00)->getMemOperand()); 43605 SDValue Ops0[] = { CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4, Tmp2, LSI_N00, Chain00 }; 43606 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 43607 ReplaceUses(SDValue(N00.getNode(), 1), SDValue(ResNode, 1)); 43608 return ResNode; 43609 } 43610 SDNode *Select_ISD_VECTOR_SHUFFLE_v8i16(const SDValue &N) { 43611 if (OptLevel != CodeGenOpt::None && 43612 (Subtarget->hasSSE2())) { 43613 43614 // Pattern: (vector_shuffle:v8i16 (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), (undef:v8i16))<<P:Predicate_pshufhw>><<X:SHUFFLE_get_pshufhw_imm>>:$src2 43615 // Emits: (PSHUFHWmi:v8i16 addr:iPTR:$src1, (SHUFFLE_get_pshufhw_imm:i8 (vector_shuffle:v8i16 (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), (undef:v8i16)):$src2)) 43616 // Pattern complexity = 32 cost = 1 size = 3 43617 if (Predicate_pshufhw(N.getNode())) { 43618 SDValue N0 = N.getOperand(0); 43619 if (N0.getOpcode() == ISD::BIT_CONVERT && 43620 N0.hasOneUse()) { 43621 SDValue N00 = N0.getOperand(0); 43622 if (N00.getOpcode() == ISD::LOAD && 43623 N00.hasOneUse() && 43624 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 43625 SDValue Chain00 = N00.getOperand(0); 43626 if (Predicate_unindexedload(N00.getNode()) && 43627 Predicate_load(N00.getNode()) && 43628 Predicate_memop(N00.getNode())) { 43629 SDValue N001 = N00.getOperand(1); 43630 SDValue CPTmpN001_0; 43631 SDValue CPTmpN001_1; 43632 SDValue CPTmpN001_2; 43633 SDValue CPTmpN001_3; 43634 SDValue CPTmpN001_4; 43635 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 43636 SDValue N1 = N.getOperand(1); 43637 if (N1.getOpcode() == ISD::UNDEF && 43638 N00.getNode()->getValueType(0) == MVT::v2i64) { 43639 SDNode *Result = Emit_236(N, X86::PSHUFHWmi, MVT::v8i16, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 43640 return Result; 43641 } 43642 } 43643 } 43644 } 43645 } 43646 } 43647 43648 // Pattern: (vector_shuffle:v8i16 (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), (undef:v8i16))<<P:Predicate_pshuflw>><<X:SHUFFLE_get_pshuflw_imm>>:$src2 43649 // Emits: (PSHUFLWmi:v8i16 addr:iPTR:$src1, (SHUFFLE_get_pshuflw_imm:i8 (vector_shuffle:v8i16 (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), (undef:v8i16)):$src2)) 43650 // Pattern complexity = 32 cost = 1 size = 3 43651 if (Predicate_pshuflw(N.getNode())) { 43652 SDValue N0 = N.getOperand(0); 43653 if (N0.getOpcode() == ISD::BIT_CONVERT && 43654 N0.hasOneUse()) { 43655 SDValue N00 = N0.getOperand(0); 43656 if (N00.getOpcode() == ISD::LOAD && 43657 N00.hasOneUse() && 43658 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 43659 SDValue Chain00 = N00.getOperand(0); 43660 if (Predicate_unindexedload(N00.getNode()) && 43661 Predicate_load(N00.getNode()) && 43662 Predicate_memop(N00.getNode())) { 43663 SDValue N001 = N00.getOperand(1); 43664 SDValue CPTmpN001_0; 43665 SDValue CPTmpN001_1; 43666 SDValue CPTmpN001_2; 43667 SDValue CPTmpN001_3; 43668 SDValue CPTmpN001_4; 43669 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 43670 SDValue N1 = N.getOperand(1); 43671 if (N1.getOpcode() == ISD::UNDEF && 43672 N00.getNode()->getValueType(0) == MVT::v2i64) { 43673 SDNode *Result = Emit_238(N, X86::PSHUFLWmi, MVT::v8i16, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 43674 return Result; 43675 } 43676 } 43677 } 43678 } 43679 } 43680 } 43681 43682 // Pattern: (vector_shuffle:v8i16 VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>))<<P:Predicate_unpckl>> 43683 // Emits: (PUNPCKLWDrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 43684 // Pattern complexity = 29 cost = 1 size = 3 43685 if (Predicate_unpckl(N.getNode())) { 43686 SDValue N0 = N.getOperand(0); 43687 SDValue N1 = N.getOperand(1); 43688 if (N1.getOpcode() == ISD::BIT_CONVERT && 43689 N1.hasOneUse()) { 43690 SDValue N10 = N1.getOperand(0); 43691 if (N10.getOpcode() == ISD::LOAD && 43692 N10.hasOneUse() && 43693 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 43694 SDValue Chain10 = N10.getOperand(0); 43695 if (Predicate_unindexedload(N10.getNode()) && 43696 Predicate_load(N10.getNode()) && 43697 Predicate_memop(N10.getNode())) { 43698 SDValue N101 = N10.getOperand(1); 43699 SDValue CPTmpN101_0; 43700 SDValue CPTmpN101_1; 43701 SDValue CPTmpN101_2; 43702 SDValue CPTmpN101_3; 43703 SDValue CPTmpN101_4; 43704 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 43705 N10.getNode()->getValueType(0) == MVT::v2i64) { 43706 SDNode *Result = Emit_16(N, X86::PUNPCKLWDrm, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 43707 return Result; 43708 } 43709 } 43710 } 43711 } 43712 } 43713 43714 // Pattern: (vector_shuffle:v8i16 VR128:v8i16:$src1, (bitconvert:v8i16 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>))<<P:Predicate_unpckh>> 43715 // Emits: (PUNPCKHWDrm:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2) 43716 // Pattern complexity = 29 cost = 1 size = 3 43717 if (Predicate_unpckh(N.getNode())) { 43718 SDValue N0 = N.getOperand(0); 43719 SDValue N1 = N.getOperand(1); 43720 if (N1.getOpcode() == ISD::BIT_CONVERT && 43721 N1.hasOneUse()) { 43722 SDValue N10 = N1.getOperand(0); 43723 if (N10.getOpcode() == ISD::LOAD && 43724 N10.hasOneUse() && 43725 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 43726 SDValue Chain10 = N10.getOperand(0); 43727 if (Predicate_unindexedload(N10.getNode()) && 43728 Predicate_load(N10.getNode()) && 43729 Predicate_memop(N10.getNode())) { 43730 SDValue N101 = N10.getOperand(1); 43731 SDValue CPTmpN101_0; 43732 SDValue CPTmpN101_1; 43733 SDValue CPTmpN101_2; 43734 SDValue CPTmpN101_3; 43735 SDValue CPTmpN101_4; 43736 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 43737 N10.getNode()->getValueType(0) == MVT::v2i64) { 43738 SDNode *Result = Emit_16(N, X86::PUNPCKHWDrm, MVT::v8i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 43739 return Result; 43740 } 43741 } 43742 } 43743 } 43744 } 43745 } 43746 if ((Subtarget->hasSSE2())) { 43747 43748 // Pattern: (vector_shuffle:v8i16 VR128:v8i16:$src, (undef:v8i16))<<P:Predicate_unpckl_undef>> 43749 // Emits: (PUNPCKLWDrr:v8i16 VR128:v16i8:$src, VR128:v16i8:$src) 43750 // Pattern complexity = 17 cost = 1 size = 3 43751 if (Predicate_unpckl_undef(N.getNode())) { 43752 SDValue N0 = N.getOperand(0); 43753 SDValue N1 = N.getOperand(1); 43754 if (N1.getOpcode() == ISD::UNDEF) { 43755 SDNode *Result = Emit_162(N, X86::PUNPCKLWDrr, MVT::v8i16); 43756 return Result; 43757 } 43758 } 43759 43760 // Pattern: (vector_shuffle:v8i16 VR128:v8i16:$src, (undef:v8i16))<<P:Predicate_unpckh_undef>> 43761 // Emits: (PUNPCKHWDrr:v8i16 VR128:v16i8:$src, VR128:v16i8:$src) 43762 // Pattern complexity = 17 cost = 1 size = 3 43763 if (Predicate_unpckh_undef(N.getNode())) { 43764 SDValue N0 = N.getOperand(0); 43765 SDValue N1 = N.getOperand(1); 43766 if (N1.getOpcode() == ISD::UNDEF) { 43767 SDNode *Result = Emit_162(N, X86::PUNPCKHWDrr, MVT::v8i16); 43768 return Result; 43769 } 43770 } 43771 43772 // Pattern: (vector_shuffle:v8i16 VR128:v8i16:$src1, (undef:v8i16))<<P:Predicate_pshufhw>><<X:SHUFFLE_get_pshufhw_imm>>:$src2 43773 // Emits: (PSHUFHWri:v8i16 VR128:v8i16:$src1, (SHUFFLE_get_pshufhw_imm:i8 (vector_shuffle:v8i16 VR128:v8i16:$src1, (undef:v8i16)):$src2)) 43774 // Pattern complexity = 7 cost = 1 size = 3 43775 if (Predicate_pshufhw(N.getNode())) { 43776 SDValue N0 = N.getOperand(0); 43777 SDValue N1 = N.getOperand(1); 43778 if (N1.getOpcode() == ISD::UNDEF) { 43779 SDNode *Result = Emit_235(N, X86::PSHUFHWri, MVT::v8i16); 43780 return Result; 43781 } 43782 } 43783 43784 // Pattern: (vector_shuffle:v8i16 VR128:v8i16:$src1, (undef:v8i16))<<P:Predicate_pshuflw>><<X:SHUFFLE_get_pshuflw_imm>>:$src2 43785 // Emits: (PSHUFLWri:v8i16 VR128:v8i16:$src1, (SHUFFLE_get_pshuflw_imm:i8 (vector_shuffle:v8i16 VR128:v8i16:$src1, (undef:v8i16)):$src2)) 43786 // Pattern complexity = 7 cost = 1 size = 3 43787 if (Predicate_pshuflw(N.getNode())) { 43788 SDValue N0 = N.getOperand(0); 43789 SDValue N1 = N.getOperand(1); 43790 if (N1.getOpcode() == ISD::UNDEF) { 43791 SDNode *Result = Emit_237(N, X86::PSHUFLWri, MVT::v8i16); 43792 return Result; 43793 } 43794 } 43795 43796 // Pattern: (vector_shuffle:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2)<<P:Predicate_unpckl>> 43797 // Emits: (PUNPCKLWDrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 43798 // Pattern complexity = 4 cost = 1 size = 3 43799 if (Predicate_unpckl(N.getNode())) { 43800 SDNode *Result = Emit_15(N, X86::PUNPCKLWDrr, MVT::v8i16); 43801 return Result; 43802 } 43803 43804 // Pattern: (vector_shuffle:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2)<<P:Predicate_unpckh>> 43805 // Emits: (PUNPCKHWDrr:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 43806 // Pattern complexity = 4 cost = 1 size = 3 43807 if (Predicate_unpckh(N.getNode())) { 43808 SDNode *Result = Emit_15(N, X86::PUNPCKHWDrr, MVT::v8i16); 43809 return Result; 43810 } 43811 } 43812 43813 CannotYetSelect(N); 43814 return NULL; 43815 } 43816 43817 SDNode *Select_ISD_VECTOR_SHUFFLE_v2i32(const SDValue &N) { 43818 if (OptLevel != CodeGenOpt::None && 43819 (Subtarget->hasMMX())) { 43820 43821 // Pattern: (vector_shuffle:v2i32 VR64:v2i32:$src1, (bitconvert:v2i32 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>))<<P:Predicate_mmx_unpckh>> 43822 // Emits: (MMX_PUNPCKHDQrm:v2i32 VR64:v2i32:$src1, addr:iPTR:$src2) 43823 // Pattern complexity = 29 cost = 1 size = 3 43824 if (Predicate_mmx_unpckh(N.getNode())) { 43825 SDValue N0 = N.getOperand(0); 43826 SDValue N1 = N.getOperand(1); 43827 if (N1.getOpcode() == ISD::BIT_CONVERT && 43828 N1.hasOneUse()) { 43829 SDValue N10 = N1.getOperand(0); 43830 if (N10.getOpcode() == ISD::LOAD && 43831 N10.hasOneUse() && 43832 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 43833 SDValue Chain10 = N10.getOperand(0); 43834 if (Predicate_unindexedload(N10.getNode()) && 43835 Predicate_load(N10.getNode())) { 43836 SDValue N101 = N10.getOperand(1); 43837 SDValue CPTmpN101_0; 43838 SDValue CPTmpN101_1; 43839 SDValue CPTmpN101_2; 43840 SDValue CPTmpN101_3; 43841 SDValue CPTmpN101_4; 43842 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 43843 N10.getNode()->getValueType(0) == MVT::v1i64) { 43844 SDNode *Result = Emit_16(N, X86::MMX_PUNPCKHDQrm, MVT::v2i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 43845 return Result; 43846 } 43847 } 43848 } 43849 } 43850 } 43851 43852 // Pattern: (vector_shuffle:v2i32 VR64:v2i32:$src1, (bitconvert:v2i32 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>))<<P:Predicate_mmx_unpckl>> 43853 // Emits: (MMX_PUNPCKLDQrm:v2i32 VR64:v2i32:$src1, addr:iPTR:$src2) 43854 // Pattern complexity = 29 cost = 1 size = 3 43855 if (Predicate_mmx_unpckl(N.getNode())) { 43856 SDValue N0 = N.getOperand(0); 43857 SDValue N1 = N.getOperand(1); 43858 if (N1.getOpcode() == ISD::BIT_CONVERT && 43859 N1.hasOneUse()) { 43860 SDValue N10 = N1.getOperand(0); 43861 if (N10.getOpcode() == ISD::LOAD && 43862 N10.hasOneUse() && 43863 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 43864 SDValue Chain10 = N10.getOperand(0); 43865 if (Predicate_unindexedload(N10.getNode()) && 43866 Predicate_load(N10.getNode())) { 43867 SDValue N101 = N10.getOperand(1); 43868 SDValue CPTmpN101_0; 43869 SDValue CPTmpN101_1; 43870 SDValue CPTmpN101_2; 43871 SDValue CPTmpN101_3; 43872 SDValue CPTmpN101_4; 43873 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 43874 N10.getNode()->getValueType(0) == MVT::v1i64) { 43875 SDNode *Result = Emit_16(N, X86::MMX_PUNPCKLDQrm, MVT::v2i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 43876 return Result; 43877 } 43878 } 43879 } 43880 } 43881 } 43882 } 43883 43884 // Pattern: (vector_shuffle:v2i32 VR64:v2i32:$src, (undef:v2i32))<<P:Predicate_mmx_unpckl_undef>> 43885 // Emits: (MMX_PUNPCKLDQrr:v2i32 VR64:v8i8:$src, VR64:v8i8:$src) 43886 // Pattern complexity = 17 cost = 1 size = 3 43887 if (Predicate_mmx_unpckl_undef(N.getNode())) { 43888 SDValue N0 = N.getOperand(0); 43889 SDValue N1 = N.getOperand(1); 43890 if (N1.getOpcode() == ISD::UNDEF) { 43891 SDNode *Result = Emit_162(N, X86::MMX_PUNPCKLDQrr, MVT::v2i32); 43892 return Result; 43893 } 43894 } 43895 43896 // Pattern: (vector_shuffle:v2i32 VR64:v2i32:$src, (undef:v2i32))<<P:Predicate_mmx_unpckh_undef>> 43897 // Emits: (MMX_PUNPCKHDQrr:v2i32 VR64:v8i8:$src, VR64:v8i8:$src) 43898 // Pattern complexity = 17 cost = 1 size = 3 43899 if (Predicate_mmx_unpckh_undef(N.getNode())) { 43900 SDValue N0 = N.getOperand(0); 43901 SDValue N1 = N.getOperand(1); 43902 if (N1.getOpcode() == ISD::UNDEF) { 43903 SDNode *Result = Emit_162(N, X86::MMX_PUNPCKHDQrr, MVT::v2i32); 43904 return Result; 43905 } 43906 } 43907 if ((Subtarget->hasMMX())) { 43908 43909 // Pattern: (vector_shuffle:v2i32 VR64:v2i32:$src1, VR64:v2i32:$src2)<<P:Predicate_mmx_unpckh>> 43910 // Emits: (MMX_PUNPCKHDQrr:v2i32 VR64:v2i32:$src1, VR64:v2i32:$src2) 43911 // Pattern complexity = 4 cost = 1 size = 3 43912 if (Predicate_mmx_unpckh(N.getNode())) { 43913 SDNode *Result = Emit_15(N, X86::MMX_PUNPCKHDQrr, MVT::v2i32); 43914 return Result; 43915 } 43916 43917 // Pattern: (vector_shuffle:v2i32 VR64:v2i32:$src1, VR64:v2i32:$src2)<<P:Predicate_mmx_unpckl>> 43918 // Emits: (MMX_PUNPCKLDQrr:v2i32 VR64:v2i32:$src1, VR64:v2i32:$src2) 43919 // Pattern complexity = 4 cost = 1 size = 3 43920 if (Predicate_mmx_unpckl(N.getNode())) { 43921 SDNode *Result = Emit_15(N, X86::MMX_PUNPCKLDQrr, MVT::v2i32); 43922 return Result; 43923 } 43924 } 43925 43926 CannotYetSelect(N); 43927 return NULL; 43928 } 43929 43930 SDNode *Emit_239(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 43931 SDValue N0 = N.getOperand(0); 43932 SDValue N1 = N.getOperand(1); 43933 SDValue Tmp2 = Transform_SHUFFLE_get_shuf_imm(N.getNode()); 43934 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, Tmp2); 43935 } 43936 SDNode *Emit_240(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN001_0, SDValue &CPTmpN001_1, SDValue &CPTmpN001_2, SDValue &CPTmpN001_3, SDValue &CPTmpN001_4) DISABLE_INLINE { 43937 SDValue N0 = N.getOperand(0); 43938 SDValue N00 = N0.getOperand(0); 43939 SDValue Chain00 = N00.getOperand(0); 43940 SDValue N001 = N00.getOperand(1); 43941 SDValue N1 = N.getOperand(1); 43942 SDValue Tmp2 = Transform_SHUFFLE_get_shuf_imm(N.getNode()); 43943 SDValue LSI_N00 = CurDAG->getMemOperand(cast<MemSDNode>(N00)->getMemOperand()); 43944 SDValue Ops0[] = { CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4, Tmp2, LSI_N00, Chain00 }; 43945 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 43946 ReplaceUses(SDValue(N00.getNode(), 1), SDValue(ResNode, 1)); 43947 return ResNode; 43948 } 43949 SDNode *Emit_241(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN001_0, SDValue &CPTmpN001_1, SDValue &CPTmpN001_2, SDValue &CPTmpN001_3, SDValue &CPTmpN001_4) DISABLE_INLINE { 43950 SDValue N0 = N.getOperand(0); 43951 SDValue N00 = N0.getOperand(0); 43952 SDValue Chain00 = N00.getOperand(0); 43953 SDValue N001 = N00.getOperand(1); 43954 SDValue N1 = N.getOperand(1); 43955 SDValue LSI_N00 = CurDAG->getMemOperand(cast<MemSDNode>(N00)->getMemOperand()); 43956 SDValue Ops0[] = { CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4, LSI_N00, Chain00 }; 43957 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 7); 43958 ReplaceUses(SDValue(N00.getNode(), 1), SDValue(ResNode, 1)); 43959 return ResNode; 43960 } 43961 SDNode *Emit_242(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 43962 SDValue N0 = N.getOperand(0); 43963 SDValue N1 = N.getOperand(1); 43964 SDValue Tmp3 = Transform_SHUFFLE_get_shuf_imm(N.getNode()); 43965 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, N1, Tmp3); 43966 } 43967 SDNode *Emit_243(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 43968 SDValue N0 = N.getOperand(0); 43969 SDValue N1 = N.getOperand(1); 43970 SDValue N10 = N1.getOperand(0); 43971 SDValue Chain10 = N10.getOperand(0); 43972 SDValue N101 = N10.getOperand(1); 43973 SDValue Tmp3 = Transform_SHUFFLE_get_shuf_imm(N.getNode()); 43974 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 43975 SDValue Ops0[] = { N0, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, Tmp3, LSI_N10, Chain10 }; 43976 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 9); 43977 ReplaceUses(SDValue(N10.getNode(), 1), SDValue(ResNode, 1)); 43978 return ResNode; 43979 } 43980 SDNode *Select_ISD_VECTOR_SHUFFLE_v4i32(const SDValue &N) { 43981 if (OptLevel != CodeGenOpt::None) { 43982 if ((Subtarget->hasSSE3())) { 43983 43984 // Pattern: (vector_shuffle:v4i32 (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), (undef:v4i32))<<P:Predicate_movshdup>> 43985 // Emits: (MOVSHDUPrm:v4i32 addr:iPTR:$src) 43986 // Pattern complexity = 52 cost = 1 size = 3 43987 if (Predicate_movshdup(N.getNode())) { 43988 SDValue N0 = N.getOperand(0); 43989 if (N0.getOpcode() == ISD::BIT_CONVERT && 43990 N0.hasOneUse()) { 43991 SDValue N00 = N0.getOperand(0); 43992 if (N00.getOpcode() == ISD::LOAD && 43993 N00.hasOneUse() && 43994 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 43995 SDValue Chain00 = N00.getOperand(0); 43996 if (Predicate_unindexedload(N00.getNode()) && 43997 Predicate_load(N00.getNode()) && 43998 Predicate_memop(N00.getNode())) { 43999 SDValue N001 = N00.getOperand(1); 44000 SDValue CPTmpN001_0; 44001 SDValue CPTmpN001_1; 44002 SDValue CPTmpN001_2; 44003 SDValue CPTmpN001_3; 44004 SDValue CPTmpN001_4; 44005 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 44006 SDValue N1 = N.getOperand(1); 44007 if (N1.getOpcode() == ISD::UNDEF && 44008 N00.getNode()->getValueType(0) == MVT::v2i64) { 44009 SDNode *Result = Emit_241(N, X86::MOVSHDUPrm, MVT::v4i32, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 44010 return Result; 44011 } 44012 } 44013 } 44014 } 44015 } 44016 } 44017 44018 // Pattern: (vector_shuffle:v4i32 (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), (undef:v4i32))<<P:Predicate_movsldup>> 44019 // Emits: (MOVSLDUPrm:v4i32 addr:iPTR:$src) 44020 // Pattern complexity = 52 cost = 1 size = 3 44021 if (Predicate_movsldup(N.getNode())) { 44022 SDValue N0 = N.getOperand(0); 44023 if (N0.getOpcode() == ISD::BIT_CONVERT && 44024 N0.hasOneUse()) { 44025 SDValue N00 = N0.getOperand(0); 44026 if (N00.getOpcode() == ISD::LOAD && 44027 N00.hasOneUse() && 44028 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 44029 SDValue Chain00 = N00.getOperand(0); 44030 if (Predicate_unindexedload(N00.getNode()) && 44031 Predicate_load(N00.getNode()) && 44032 Predicate_memop(N00.getNode())) { 44033 SDValue N001 = N00.getOperand(1); 44034 SDValue CPTmpN001_0; 44035 SDValue CPTmpN001_1; 44036 SDValue CPTmpN001_2; 44037 SDValue CPTmpN001_3; 44038 SDValue CPTmpN001_4; 44039 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 44040 SDValue N1 = N.getOperand(1); 44041 if (N1.getOpcode() == ISD::UNDEF && 44042 N00.getNode()->getValueType(0) == MVT::v2i64) { 44043 SDNode *Result = Emit_241(N, X86::MOVSLDUPrm, MVT::v4i32, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 44044 return Result; 44045 } 44046 } 44047 } 44048 } 44049 } 44050 } 44051 } 44052 44053 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src1, (ld:v4i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)<<P:Predicate_movlp>> 44054 // Emits: (MOVLPSrm:v4i32 VR128:v16i8:$src1, addr:iPTR:$src2) 44055 // Pattern complexity = 46 cost = 1 size = 3 44056 if ((Subtarget->hasSSE2()) && 44057 Predicate_movlp(N.getNode())) { 44058 SDValue N0 = N.getOperand(0); 44059 SDValue N1 = N.getOperand(1); 44060 if (N1.getOpcode() == ISD::LOAD && 44061 N1.hasOneUse() && 44062 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 44063 SDValue Chain1 = N1.getOperand(0); 44064 if (Predicate_unindexedload(N1.getNode()) && 44065 Predicate_load(N1.getNode())) { 44066 SDValue N11 = N1.getOperand(1); 44067 SDValue CPTmpN11_0; 44068 SDValue CPTmpN11_1; 44069 SDValue CPTmpN11_2; 44070 SDValue CPTmpN11_3; 44071 SDValue CPTmpN11_4; 44072 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 44073 SDNode *Result = Emit_18(N, X86::MOVLPSrm, MVT::v4i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 44074 return Result; 44075 } 44076 } 44077 } 44078 } 44079 44080 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src1, (ld:v4i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)<<P:Predicate_movhp>> 44081 // Emits: (MOVHPSrm:v4i32 VR128:v16i8:$src1, addr:iPTR:$src2) 44082 // Pattern complexity = 46 cost = 1 size = 3 44083 if ((Subtarget->hasSSE1()) && 44084 Predicate_movhp(N.getNode())) { 44085 SDValue N0 = N.getOperand(0); 44086 SDValue N1 = N.getOperand(1); 44087 if (N1.getOpcode() == ISD::LOAD && 44088 N1.hasOneUse() && 44089 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 44090 SDValue Chain1 = N1.getOperand(0); 44091 if (Predicate_unindexedload(N1.getNode()) && 44092 Predicate_load(N1.getNode())) { 44093 SDValue N11 = N1.getOperand(1); 44094 SDValue CPTmpN11_0; 44095 SDValue CPTmpN11_1; 44096 SDValue CPTmpN11_2; 44097 SDValue CPTmpN11_3; 44098 SDValue CPTmpN11_4; 44099 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 44100 SDNode *Result = Emit_18(N, X86::MOVHPSrm, MVT::v4i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 44101 return Result; 44102 } 44103 } 44104 } 44105 } 44106 44107 // Pattern: (vector_shuffle:v4i32 (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), (undef:v4i32))<<P:Predicate_movddup>> 44108 // Emits: (MOVDDUPrm:v4i32 addr:iPTR:$src) 44109 // Pattern complexity = 37 cost = 1 size = 3 44110 if ((Subtarget->hasSSE3()) && 44111 Predicate_movddup(N.getNode())) { 44112 SDValue N0 = N.getOperand(0); 44113 if (N0.getOpcode() == ISD::BIT_CONVERT && 44114 N0.hasOneUse()) { 44115 SDValue N00 = N0.getOperand(0); 44116 if (N00.getOpcode() == ISD::LOAD && 44117 N00.hasOneUse() && 44118 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 44119 SDValue Chain00 = N00.getOperand(0); 44120 if (Predicate_unindexedload(N00.getNode()) && 44121 Predicate_load(N00.getNode()) && 44122 Predicate_memop(N00.getNode())) { 44123 SDValue N001 = N00.getOperand(1); 44124 SDValue CPTmpN001_0; 44125 SDValue CPTmpN001_1; 44126 SDValue CPTmpN001_2; 44127 SDValue CPTmpN001_3; 44128 SDValue CPTmpN001_4; 44129 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 44130 SDValue N1 = N.getOperand(1); 44131 if (N1.getOpcode() == ISD::UNDEF && 44132 N00.getNode()->getValueType(0) == MVT::v2i64) { 44133 SDNode *Result = Emit_241(N, X86::MOVDDUPrm, MVT::v4i32, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 44134 return Result; 44135 } 44136 } 44137 } 44138 } 44139 } 44140 } 44141 if ((Subtarget->hasSSE2())) { 44142 if (Predicate_pshufd(N.getNode())) { 44143 SDValue N0 = N.getOperand(0); 44144 if (N0.getOpcode() == ISD::BIT_CONVERT && 44145 N0.hasOneUse()) { 44146 SDValue N00 = N0.getOperand(0); 44147 if (N00.getOpcode() == ISD::LOAD && 44148 N00.hasOneUse() && 44149 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 44150 SDValue Chain00 = N00.getOperand(0); 44151 if (Predicate_unindexedload(N00.getNode()) && 44152 Predicate_load(N00.getNode()) && 44153 Predicate_memop(N00.getNode())) { 44154 SDValue N001 = N00.getOperand(1); 44155 SDValue CPTmpN001_0; 44156 SDValue CPTmpN001_1; 44157 SDValue CPTmpN001_2; 44158 SDValue CPTmpN001_3; 44159 SDValue CPTmpN001_4; 44160 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 44161 SDValue N1 = N.getOperand(1); 44162 if (N1.getOpcode() == ISD::UNDEF) { 44163 44164 // Pattern: (vector_shuffle:v4i32 (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), (undef:v4i32))<<P:Predicate_pshufd>><<X:SHUFFLE_get_shuf_imm>>:$src2 44165 // Emits: (PSHUFDmi:v4i32 addr:iPTR:$src1, (SHUFFLE_get_shuf_imm:i8 (vector_shuffle:v4i32 (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), (undef:v4i32)):$src2)) 44166 // Pattern complexity = 32 cost = 1 size = 3 44167 if (N00.getNode()->getValueType(0) == MVT::v2i64) { 44168 SDNode *Result = Emit_240(N, X86::PSHUFDmi, MVT::v4i32, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 44169 return Result; 44170 } 44171 44172 // Pattern: (vector_shuffle:v4i32 (bitconvert:v4i32 (ld:v4f32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), (undef:v4i32))<<P:Predicate_pshufd>><<X:SHUFFLE_get_shuf_imm>>:$src2 44173 // Emits: (PSHUFDmi:v4i32 addr:iPTR:$src1, (SHUFFLE_get_shuf_imm:i8 VR128:i8:$src2)) 44174 // Pattern complexity = 32 cost = 1 size = 3 44175 if (N00.getNode()->getValueType(0) == MVT::v4f32) { 44176 SDNode *Result = Emit_240(N, X86::PSHUFDmi, MVT::v4i32, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 44177 return Result; 44178 } 44179 } 44180 } 44181 } 44182 } 44183 } 44184 } 44185 44186 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>))<<P:Predicate_unpckl>> 44187 // Emits: (PUNPCKLDQrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 44188 // Pattern complexity = 29 cost = 1 size = 3 44189 if (Predicate_unpckl(N.getNode())) { 44190 SDValue N0 = N.getOperand(0); 44191 SDValue N1 = N.getOperand(1); 44192 if (N1.getOpcode() == ISD::BIT_CONVERT && 44193 N1.hasOneUse()) { 44194 SDValue N10 = N1.getOperand(0); 44195 if (N10.getOpcode() == ISD::LOAD && 44196 N10.hasOneUse() && 44197 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 44198 SDValue Chain10 = N10.getOperand(0); 44199 if (Predicate_unindexedload(N10.getNode()) && 44200 Predicate_load(N10.getNode()) && 44201 Predicate_memop(N10.getNode())) { 44202 SDValue N101 = N10.getOperand(1); 44203 SDValue CPTmpN101_0; 44204 SDValue CPTmpN101_1; 44205 SDValue CPTmpN101_2; 44206 SDValue CPTmpN101_3; 44207 SDValue CPTmpN101_4; 44208 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 44209 N10.getNode()->getValueType(0) == MVT::v2i64) { 44210 SDNode *Result = Emit_16(N, X86::PUNPCKLDQrm, MVT::v4i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 44211 return Result; 44212 } 44213 } 44214 } 44215 } 44216 } 44217 44218 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>))<<P:Predicate_unpckh>> 44219 // Emits: (PUNPCKHDQrm:v4i32 VR128:v4i32:$src1, addr:iPTR:$src2) 44220 // Pattern complexity = 29 cost = 1 size = 3 44221 if (Predicate_unpckh(N.getNode())) { 44222 SDValue N0 = N.getOperand(0); 44223 SDValue N1 = N.getOperand(1); 44224 if (N1.getOpcode() == ISD::BIT_CONVERT && 44225 N1.hasOneUse()) { 44226 SDValue N10 = N1.getOperand(0); 44227 if (N10.getOpcode() == ISD::LOAD && 44228 N10.hasOneUse() && 44229 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 44230 SDValue Chain10 = N10.getOperand(0); 44231 if (Predicate_unindexedload(N10.getNode()) && 44232 Predicate_load(N10.getNode()) && 44233 Predicate_memop(N10.getNode())) { 44234 SDValue N101 = N10.getOperand(1); 44235 SDValue CPTmpN101_0; 44236 SDValue CPTmpN101_1; 44237 SDValue CPTmpN101_2; 44238 SDValue CPTmpN101_3; 44239 SDValue CPTmpN101_4; 44240 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 44241 N10.getNode()->getValueType(0) == MVT::v2i64) { 44242 SDNode *Result = Emit_16(N, X86::PUNPCKHDQrm, MVT::v4i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 44243 return Result; 44244 } 44245 } 44246 } 44247 } 44248 } 44249 44250 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src1, (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>))<<P:Predicate_shufp>><<X:SHUFFLE_get_shuf_imm>>:$src3 44251 // Emits: (SHUFPSrmi:v4i32 VR128:v16i8:$src1, addr:iPTR:$src2, (SHUFFLE_get_shuf_imm:i8 VR128:i8:$src3)) 44252 // Pattern complexity = 29 cost = 1 size = 3 44253 if (Predicate_shufp(N.getNode())) { 44254 SDValue N0 = N.getOperand(0); 44255 SDValue N1 = N.getOperand(1); 44256 if (N1.getOpcode() == ISD::BIT_CONVERT && 44257 N1.hasOneUse()) { 44258 SDValue N10 = N1.getOperand(0); 44259 if (N10.getOpcode() == ISD::LOAD && 44260 N10.hasOneUse() && 44261 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 44262 SDValue Chain10 = N10.getOperand(0); 44263 if (Predicate_unindexedload(N10.getNode()) && 44264 Predicate_load(N10.getNode()) && 44265 Predicate_memop(N10.getNode())) { 44266 SDValue N101 = N10.getOperand(1); 44267 SDValue CPTmpN101_0; 44268 SDValue CPTmpN101_1; 44269 SDValue CPTmpN101_2; 44270 SDValue CPTmpN101_3; 44271 SDValue CPTmpN101_4; 44272 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 44273 N10.getNode()->getValueType(0) == MVT::v2i64) { 44274 SDNode *Result = Emit_243(N, X86::SHUFPSrmi, MVT::v4i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 44275 return Result; 44276 } 44277 } 44278 } 44279 } 44280 } 44281 } 44282 } 44283 44284 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src1, (undef:v4i32))<<P:Predicate_movhlps_undef>> 44285 // Emits: (MOVHLPSrr:v4i32 VR128:v16i8:$src1, VR128:v16i8:$src1) 44286 // Pattern complexity = 27 cost = 1 size = 3 44287 if (Predicate_movhlps_undef(N.getNode())) { 44288 SDValue N0 = N.getOperand(0); 44289 SDValue N1 = N.getOperand(1); 44290 if (N1.getOpcode() == ISD::UNDEF) { 44291 SDNode *Result = Emit_162(N, X86::MOVHLPSrr, MVT::v4i32); 44292 return Result; 44293 } 44294 } 44295 44296 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2)<<P:Predicate_movhp>> 44297 // Emits: (MOVLHPSrr:v4i32 VR128:v16i8:$src1, VR128:v16i8:$src2) 44298 // Pattern complexity = 24 cost = 1 size = 3 44299 if (Predicate_movhp(N.getNode())) { 44300 SDNode *Result = Emit_15(N, X86::MOVLHPSrr, MVT::v4i32); 44301 return Result; 44302 } 44303 44304 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2)<<P:Predicate_movhlps>> 44305 // Emits: (MOVHLPSrr:v4i32 VR128:v16i8:$src1, VR128:v16i8:$src2) 44306 // Pattern complexity = 24 cost = 1 size = 3 44307 if (Predicate_movhlps(N.getNode())) { 44308 SDNode *Result = Emit_15(N, X86::MOVHLPSrr, MVT::v4i32); 44309 return Result; 44310 } 44311 if ((Subtarget->hasSSE3())) { 44312 44313 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src, (undef:v4i32))<<P:Predicate_movshdup>> 44314 // Emits: (MOVSHDUPrr:v4i32 VR128:v16i8:$src) 44315 // Pattern complexity = 22 cost = 1 size = 3 44316 if (Predicate_movshdup(N.getNode())) { 44317 SDValue N0 = N.getOperand(0); 44318 SDValue N1 = N.getOperand(1); 44319 if (N1.getOpcode() == ISD::UNDEF) { 44320 SDNode *Result = Emit_92(N, X86::MOVSHDUPrr, MVT::v4i32); 44321 return Result; 44322 } 44323 } 44324 44325 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src, (undef:v4i32))<<P:Predicate_movsldup>> 44326 // Emits: (MOVSLDUPrr:v4i32 VR128:v16i8:$src) 44327 // Pattern complexity = 22 cost = 1 size = 3 44328 if (Predicate_movsldup(N.getNode())) { 44329 SDValue N0 = N.getOperand(0); 44330 SDValue N1 = N.getOperand(1); 44331 if (N1.getOpcode() == ISD::UNDEF) { 44332 SDNode *Result = Emit_92(N, X86::MOVSLDUPrr, MVT::v4i32); 44333 return Result; 44334 } 44335 } 44336 } 44337 if ((!OptForSize) && (Subtarget->hasSSE2())) { 44338 44339 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src, (undef:v4i32))<<P:Predicate_unpckl_undef>>:$src2 44340 // Emits: (PSHUFDri:v4i32 VR128:v16i8:$src, (SHUFFLE_get_shuf_imm:i8 VR128:i8:$src2)) 44341 // Pattern complexity = 22 cost = 1 size = 3 44342 if (Predicate_unpckl_undef(N.getNode())) { 44343 SDValue N0 = N.getOperand(0); 44344 SDValue N1 = N.getOperand(1); 44345 if (N1.getOpcode() == ISD::UNDEF) { 44346 SDNode *Result = Emit_239(N, X86::PSHUFDri, MVT::v4i32); 44347 return Result; 44348 } 44349 } 44350 44351 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src, (undef:v4i32))<<P:Predicate_unpckh_undef>>:$src2 44352 // Emits: (PSHUFDri:v4i32 VR128:v16i8:$src, (SHUFFLE_get_shuf_imm:i8 VR128:i8:$src2)) 44353 // Pattern complexity = 22 cost = 1 size = 3 44354 if (Predicate_unpckh_undef(N.getNode())) { 44355 SDValue N0 = N.getOperand(0); 44356 SDValue N1 = N.getOperand(1); 44357 if (N1.getOpcode() == ISD::UNDEF) { 44358 SDNode *Result = Emit_239(N, X86::PSHUFDri, MVT::v4i32); 44359 return Result; 44360 } 44361 } 44362 } 44363 if ((Subtarget->hasSSE2())) { 44364 44365 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2)<<P:Predicate_movl>> 44366 // Emits: (MOVLPSrr:v4i32 VR128:v16i8:$src1, VR128:v16i8:$src2) 44367 // Pattern complexity = 19 cost = 1 size = 3 44368 if (Predicate_movl(N.getNode())) { 44369 SDNode *Result = Emit_15(N, X86::MOVLPSrr, MVT::v4i32); 44370 return Result; 44371 } 44372 44373 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2)<<P:Predicate_movlp>> 44374 // Emits: (MOVLPDrr:v4i32 VR128:v16i8:$src1, VR128:v16i8:$src2) 44375 // Pattern complexity = 19 cost = 1 size = 3 44376 if (Predicate_movlp(N.getNode())) { 44377 SDNode *Result = Emit_15(N, X86::MOVLPDrr, MVT::v4i32); 44378 return Result; 44379 } 44380 44381 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src, (undef:v4i32))<<P:Predicate_unpckl_undef>> 44382 // Emits: (PUNPCKLDQrr:v4i32 VR128:v16i8:$src, VR128:v16i8:$src) 44383 // Pattern complexity = 17 cost = 1 size = 3 44384 if (Predicate_unpckl_undef(N.getNode())) { 44385 SDValue N0 = N.getOperand(0); 44386 SDValue N1 = N.getOperand(1); 44387 if (N1.getOpcode() == ISD::UNDEF) { 44388 SDNode *Result = Emit_162(N, X86::PUNPCKLDQrr, MVT::v4i32); 44389 return Result; 44390 } 44391 } 44392 44393 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src, (undef:v4i32))<<P:Predicate_unpckh_undef>> 44394 // Emits: (PUNPCKHDQrr:v4i32 VR128:v16i8:$src, VR128:v16i8:$src) 44395 // Pattern complexity = 17 cost = 1 size = 3 44396 if (Predicate_unpckh_undef(N.getNode())) { 44397 SDValue N0 = N.getOperand(0); 44398 SDValue N1 = N.getOperand(1); 44399 if (N1.getOpcode() == ISD::UNDEF) { 44400 SDNode *Result = Emit_162(N, X86::PUNPCKHDQrr, MVT::v4i32); 44401 return Result; 44402 } 44403 } 44404 44405 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src1, (undef:v4i32))<<P:Predicate_pshufd>><<X:SHUFFLE_get_shuf_imm>>:$src2 44406 // Emits: (PSHUFDri:v4i32 VR128:v4i32:$src1, (SHUFFLE_get_shuf_imm:i8 (vector_shuffle:v4i32 VR128:v4i32:$src1, (undef:v4i32)):$src2)) 44407 // Pattern complexity = 7 cost = 1 size = 3 44408 if (Predicate_pshufd(N.getNode())) { 44409 SDValue N0 = N.getOperand(0); 44410 SDValue N1 = N.getOperand(1); 44411 if (N1.getOpcode() == ISD::UNDEF) { 44412 SDNode *Result = Emit_239(N, X86::PSHUFDri, MVT::v4i32); 44413 return Result; 44414 } 44415 } 44416 44417 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2)<<P:Predicate_unpckl>> 44418 // Emits: (PUNPCKLDQrr:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 44419 // Pattern complexity = 4 cost = 1 size = 3 44420 if (Predicate_unpckl(N.getNode())) { 44421 SDNode *Result = Emit_15(N, X86::PUNPCKLDQrr, MVT::v4i32); 44422 return Result; 44423 } 44424 44425 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2)<<P:Predicate_unpckh>> 44426 // Emits: (PUNPCKHDQrr:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 44427 // Pattern complexity = 4 cost = 1 size = 3 44428 if (Predicate_unpckh(N.getNode())) { 44429 SDNode *Result = Emit_15(N, X86::PUNPCKHDQrr, MVT::v4i32); 44430 return Result; 44431 } 44432 44433 // Pattern: (vector_shuffle:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2)<<P:Predicate_shufp>><<X:SHUFFLE_get_shuf_imm>>:$src3 44434 // Emits: (SHUFPSrri:v4i32 VR128:v16i8:$src1, VR128:v16i8:$src2, (SHUFFLE_get_shuf_imm:i8 VR128:i8:$src3)) 44435 // Pattern complexity = 4 cost = 1 size = 3 44436 if (Predicate_shufp(N.getNode())) { 44437 SDNode *Result = Emit_242(N, X86::SHUFPSrri, MVT::v4i32); 44438 return Result; 44439 } 44440 } 44441 44442 CannotYetSelect(N); 44443 return NULL; 44444 } 44445 44446 SDNode *Emit_244(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 44447 SDValue N0 = N.getOperand(0); 44448 SDValue N1 = N.getOperand(1); 44449 SDValue N10 = N1.getOperand(0); 44450 SDValue N100 = N10.getOperand(0); 44451 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N100); 44452 } 44453 SDNode *Emit_245(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 44454 SDValue N0 = N.getOperand(0); 44455 SDValue Chain0 = N0.getOperand(0); 44456 SDValue N01 = N0.getOperand(1); 44457 SDValue N1 = N.getOperand(1); 44458 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 44459 SDValue Ops0[] = { CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, LSI_N0, Chain0 }; 44460 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 7); 44461 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 44462 return ResNode; 44463 } 44464 SDNode *Emit_246(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 44465 SDValue N0 = N.getOperand(0); 44466 SDValue N1 = N.getOperand(1); 44467 SDValue Tmp3 = Transform_SHUFFLE_get_shuf_imm(N.getNode()); 44468 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, N0, Tmp3); 44469 } 44470 SDNode *Select_ISD_VECTOR_SHUFFLE_v2i64(const SDValue &N) { 44471 if (OptLevel != CodeGenOpt::None) { 44472 if ((Subtarget->hasSSE2())) { 44473 44474 // Pattern: (vector_shuffle:v2i64 VR128:v2i64:$src1, (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)<<P:Predicate_movlp>> 44475 // Emits: (MOVLPDrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 44476 // Pattern complexity = 46 cost = 1 size = 3 44477 if (Predicate_movlp(N.getNode())) { 44478 SDValue N0 = N.getOperand(0); 44479 SDValue N1 = N.getOperand(1); 44480 if (N1.getOpcode() == ISD::LOAD && 44481 N1.hasOneUse() && 44482 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 44483 SDValue Chain1 = N1.getOperand(0); 44484 if (Predicate_unindexedload(N1.getNode()) && 44485 Predicate_load(N1.getNode())) { 44486 SDValue N11 = N1.getOperand(1); 44487 SDValue CPTmpN11_0; 44488 SDValue CPTmpN11_1; 44489 SDValue CPTmpN11_2; 44490 SDValue CPTmpN11_3; 44491 SDValue CPTmpN11_4; 44492 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 44493 SDNode *Result = Emit_18(N, X86::MOVLPDrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 44494 return Result; 44495 } 44496 } 44497 } 44498 } 44499 44500 // Pattern: (vector_shuffle:v2i64 VR128:v2i64:$src1, (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)<<P:Predicate_movhp>> 44501 // Emits: (MOVHPDrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 44502 // Pattern complexity = 46 cost = 1 size = 3 44503 if (Predicate_movhp(N.getNode())) { 44504 SDValue N0 = N.getOperand(0); 44505 SDValue N1 = N.getOperand(1); 44506 if (N1.getOpcode() == ISD::LOAD && 44507 N1.hasOneUse() && 44508 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 44509 SDValue Chain1 = N1.getOperand(0); 44510 if (Predicate_unindexedload(N1.getNode()) && 44511 Predicate_load(N1.getNode())) { 44512 SDValue N11 = N1.getOperand(1); 44513 SDValue CPTmpN11_0; 44514 SDValue CPTmpN11_1; 44515 SDValue CPTmpN11_2; 44516 SDValue CPTmpN11_3; 44517 SDValue CPTmpN11_4; 44518 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 44519 SDNode *Result = Emit_18(N, X86::MOVHPDrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 44520 return Result; 44521 } 44522 } 44523 } 44524 } 44525 } 44526 44527 // Pattern: (vector_shuffle:v2i64 (ld:v2i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (undef:v2i64))<<P:Predicate_movddup>> 44528 // Emits: (MOVDDUPrm:v2i64 addr:iPTR:$src) 44529 // Pattern complexity = 34 cost = 1 size = 3 44530 if ((Subtarget->hasSSE3()) && 44531 Predicate_movddup(N.getNode())) { 44532 SDValue N0 = N.getOperand(0); 44533 if (N0.getOpcode() == ISD::LOAD && 44534 N0.hasOneUse() && 44535 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 44536 SDValue Chain0 = N0.getOperand(0); 44537 if (Predicate_unindexedload(N0.getNode()) && 44538 Predicate_load(N0.getNode()) && 44539 Predicate_memop(N0.getNode())) { 44540 SDValue N01 = N0.getOperand(1); 44541 SDValue CPTmpN01_0; 44542 SDValue CPTmpN01_1; 44543 SDValue CPTmpN01_2; 44544 SDValue CPTmpN01_3; 44545 SDValue CPTmpN01_4; 44546 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 44547 SDValue N1 = N.getOperand(1); 44548 if (N1.getOpcode() == ISD::UNDEF) { 44549 SDNode *Result = Emit_245(N, X86::MOVDDUPrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 44550 return Result; 44551 } 44552 } 44553 } 44554 } 44555 } 44556 } 44557 44558 // Pattern: (vector_shuffle:v2i64 VR128:v2i64:$src, (undef:v2i64))<<P:Predicate_movddup>> 44559 // Emits: (MOVLHPSrr:v2i64 VR128:v16i8:$src, VR128:v16i8:$src) 44560 // Pattern complexity = 27 cost = 1 size = 3 44561 if ((Subtarget->hasSSE1()) && 44562 Predicate_movddup(N.getNode())) { 44563 SDValue N0 = N.getOperand(0); 44564 SDValue N1 = N.getOperand(1); 44565 if (N1.getOpcode() == ISD::UNDEF) { 44566 SDNode *Result = Emit_162(N, X86::MOVLHPSrr, MVT::v2i64); 44567 return Result; 44568 } 44569 } 44570 if (OptLevel != CodeGenOpt::None && 44571 (Subtarget->hasSSE2())) { 44572 44573 // Pattern: (vector_shuffle:v2i64 VR128:v2i64:$src1, (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)<<P:Predicate_unpckl>> 44574 // Emits: (PUNPCKLQDQrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 44575 // Pattern complexity = 26 cost = 1 size = 3 44576 if (Predicate_unpckl(N.getNode())) { 44577 SDValue N0 = N.getOperand(0); 44578 SDValue N1 = N.getOperand(1); 44579 if (N1.getOpcode() == ISD::LOAD && 44580 N1.hasOneUse() && 44581 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 44582 SDValue Chain1 = N1.getOperand(0); 44583 if (Predicate_unindexedload(N1.getNode()) && 44584 Predicate_load(N1.getNode()) && 44585 Predicate_memop(N1.getNode())) { 44586 SDValue N11 = N1.getOperand(1); 44587 SDValue CPTmpN11_0; 44588 SDValue CPTmpN11_1; 44589 SDValue CPTmpN11_2; 44590 SDValue CPTmpN11_3; 44591 SDValue CPTmpN11_4; 44592 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 44593 SDNode *Result = Emit_18(N, X86::PUNPCKLQDQrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 44594 return Result; 44595 } 44596 } 44597 } 44598 } 44599 44600 // Pattern: (vector_shuffle:v2i64 VR128:v2i64:$src1, (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)<<P:Predicate_unpckh>> 44601 // Emits: (PUNPCKHQDQrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 44602 // Pattern complexity = 26 cost = 1 size = 3 44603 if (Predicate_unpckh(N.getNode())) { 44604 SDValue N0 = N.getOperand(0); 44605 SDValue N1 = N.getOperand(1); 44606 if (N1.getOpcode() == ISD::LOAD && 44607 N1.hasOneUse() && 44608 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 44609 SDValue Chain1 = N1.getOperand(0); 44610 if (Predicate_unindexedload(N1.getNode()) && 44611 Predicate_load(N1.getNode()) && 44612 Predicate_memop(N1.getNode())) { 44613 SDValue N11 = N1.getOperand(1); 44614 SDValue CPTmpN11_0; 44615 SDValue CPTmpN11_1; 44616 SDValue CPTmpN11_2; 44617 SDValue CPTmpN11_3; 44618 SDValue CPTmpN11_4; 44619 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 44620 SDNode *Result = Emit_18(N, X86::PUNPCKHQDQrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 44621 return Result; 44622 } 44623 } 44624 } 44625 } 44626 } 44627 if ((Subtarget->hasSSE2())) { 44628 44629 // Pattern: (vector_shuffle:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2)<<P:Predicate_movl>> 44630 // Emits: (MOVLPDrr:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src2) 44631 // Pattern complexity = 19 cost = 1 size = 3 44632 if (Predicate_movl(N.getNode())) { 44633 SDNode *Result = Emit_15(N, X86::MOVLPDrr, MVT::v2i64); 44634 return Result; 44635 } 44636 44637 // Pattern: (vector_shuffle:v2i64 VR128:v2i64:$src, (undef:v2i64))<<P:Predicate_splat_lo>> 44638 // Emits: (PUNPCKLQDQrr:v2i64 VR128:v16i8:$src, VR128:v16i8:$src) 44639 // Pattern complexity = 17 cost = 1 size = 3 44640 if (Predicate_splat_lo(N.getNode())) { 44641 SDValue N0 = N.getOperand(0); 44642 SDValue N1 = N.getOperand(1); 44643 if (N1.getOpcode() == ISD::UNDEF) { 44644 SDNode *Result = Emit_162(N, X86::PUNPCKLQDQrr, MVT::v2i64); 44645 return Result; 44646 } 44647 } 44648 44649 // Pattern: (vector_shuffle:v2i64 VR128:v2i64:$src, (undef:v2i64))<<P:Predicate_unpckh>> 44650 // Emits: (PUNPCKHQDQrr:v2i64 VR128:v16i8:$src, VR128:v16i8:$src) 44651 // Pattern complexity = 17 cost = 1 size = 3 44652 if (Predicate_unpckh(N.getNode())) { 44653 SDValue N0 = N.getOperand(0); 44654 SDValue N1 = N.getOperand(1); 44655 if (N1.getOpcode() == ISD::UNDEF) { 44656 SDNode *Result = Emit_162(N, X86::PUNPCKHQDQrr, MVT::v2i64); 44657 return Result; 44658 } 44659 } 44660 44661 // Pattern: (vector_shuffle:v2i64 (build_vector:v2i64)<<P:Predicate_immAllZerosV>>, (scalar_to_vector:v2i64 (bitconvert:i64 VR64:v8i8:$src)))<<P:Predicate_movl>> 44662 // Emits: (MMX_MOVQ2DQrr:v2i64 VR64:v8i8:$src) 44663 // Pattern complexity = 14 cost = 1 size = 3 44664 if (Predicate_movl(N.getNode())) { 44665 SDValue N0 = N.getOperand(0); 44666 if (N0.getOpcode() == ISD::BUILD_VECTOR && 44667 Predicate_immAllZerosV(N0.getNode())) { 44668 SDValue N1 = N.getOperand(1); 44669 if (N1.getOpcode() == ISD::SCALAR_TO_VECTOR) { 44670 SDValue N10 = N1.getOperand(0); 44671 if (N10.getOpcode() == ISD::BIT_CONVERT) { 44672 SDValue N100 = N10.getOperand(0); 44673 if (N10.getNode()->getValueType(0) == MVT::i64 && 44674 N100.getNode()->getValueType(0) == MVT::v8i8) { 44675 SDNode *Result = Emit_244(N, X86::MMX_MOVQ2DQrr, MVT::v2i64); 44676 return Result; 44677 } 44678 } 44679 } 44680 } 44681 } 44682 44683 // Pattern: (vector_shuffle:v2i64 VR128:v2i64:$src1, (undef:v2i64))<<P:Predicate_pshufd>><<X:SHUFFLE_get_shuf_imm>>:$src3 44684 // Emits: (SHUFPDrri:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src1, (SHUFFLE_get_shuf_imm:i8 VR128:i8:$src3)) 44685 // Pattern complexity = 7 cost = 1 size = 3 44686 if (Predicate_pshufd(N.getNode())) { 44687 SDValue N0 = N.getOperand(0); 44688 SDValue N1 = N.getOperand(1); 44689 if (N1.getOpcode() == ISD::UNDEF) { 44690 SDNode *Result = Emit_246(N, X86::SHUFPDrri, MVT::v2i64); 44691 return Result; 44692 } 44693 } 44694 44695 // Pattern: (vector_shuffle:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2)<<P:Predicate_unpckl>> 44696 // Emits: (PUNPCKLQDQrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 44697 // Pattern complexity = 4 cost = 1 size = 3 44698 if (Predicate_unpckl(N.getNode())) { 44699 SDNode *Result = Emit_15(N, X86::PUNPCKLQDQrr, MVT::v2i64); 44700 return Result; 44701 } 44702 44703 // Pattern: (vector_shuffle:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2)<<P:Predicate_unpckh>> 44704 // Emits: (PUNPCKHQDQrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 44705 // Pattern complexity = 4 cost = 1 size = 3 44706 if (Predicate_unpckh(N.getNode())) { 44707 SDNode *Result = Emit_15(N, X86::PUNPCKHQDQrr, MVT::v2i64); 44708 return Result; 44709 } 44710 44711 // Pattern: (vector_shuffle:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2)<<P:Predicate_shufp>><<X:SHUFFLE_get_shuf_imm>>:$src3 44712 // Emits: (SHUFPDrri:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src2, (SHUFFLE_get_shuf_imm:i8 VR128:i8:$src3)) 44713 // Pattern complexity = 4 cost = 1 size = 3 44714 if (Predicate_shufp(N.getNode())) { 44715 SDNode *Result = Emit_242(N, X86::SHUFPDrri, MVT::v2i64); 44716 return Result; 44717 } 44718 } 44719 44720 CannotYetSelect(N); 44721 return NULL; 44722 } 44723 44724 SDNode *Emit_247(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN1001_0, SDValue &CPTmpN1001_1, SDValue &CPTmpN1001_2, SDValue &CPTmpN1001_3, SDValue &CPTmpN1001_4) DISABLE_INLINE { 44725 SDValue N0 = N.getOperand(0); 44726 SDValue N1 = N.getOperand(1); 44727 SDValue N10 = N1.getOperand(0); 44728 SDValue N100 = N10.getOperand(0); 44729 SDValue Chain100 = N100.getOperand(0); 44730 SDValue N1001 = N100.getOperand(1); 44731 SDValue LSI_N100 = CurDAG->getMemOperand(cast<MemSDNode>(N100)->getMemOperand()); 44732 SDValue Ops0[] = { N0, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4, LSI_N100, Chain100 }; 44733 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 8); 44734 ReplaceUses(SDValue(N100.getNode(), 1), SDValue(ResNode, 1)); 44735 return ResNode; 44736 } 44737 SDNode *Emit_248(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 44738 SDValue N0 = N.getOperand(0); 44739 SDValue N1 = N.getOperand(1); 44740 SDValue Chain1 = N1.getOperand(0); 44741 SDValue N11 = N1.getOperand(1); 44742 SDValue Tmp3 = Transform_SHUFFLE_get_shuf_imm(N.getNode()); 44743 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 44744 SDValue Ops0[] = { N0, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, Tmp3, LSI_N1, Chain1 }; 44745 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 9); 44746 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 44747 return ResNode; 44748 } 44749 SDNode *Emit_249(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 44750 SDValue N0 = N.getOperand(0); 44751 SDValue N1 = N.getOperand(1); 44752 SDValue Tmp3 = Transform_SHUFFLE_get_shuf_imm(N.getNode()); 44753 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N1, N0, Tmp3); 44754 } 44755 SDNode *Select_ISD_VECTOR_SHUFFLE_v4f32(const SDValue &N) { 44756 if (OptLevel != CodeGenOpt::None) { 44757 if ((Subtarget->hasSSE1())) { 44758 44759 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src1, (bitconvert:v4f32 (scalar_to_vector:v2f64 (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>)))<<P:Predicate_movlp>> 44760 // Emits: (MOVLPSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 44761 // Pattern complexity = 52 cost = 1 size = 3 44762 if (Predicate_movlp(N.getNode())) { 44763 SDValue N0 = N.getOperand(0); 44764 SDValue N1 = N.getOperand(1); 44765 if (N1.getOpcode() == ISD::BIT_CONVERT && 44766 N1.hasOneUse()) { 44767 SDValue N10 = N1.getOperand(0); 44768 if (N10.getOpcode() == ISD::SCALAR_TO_VECTOR && 44769 N10.hasOneUse()) { 44770 SDValue N100 = N10.getOperand(0); 44771 if (N100.getOpcode() == ISD::LOAD && 44772 N100.hasOneUse() && 44773 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode())) { 44774 SDValue Chain100 = N100.getOperand(0); 44775 if (Predicate_unindexedload(N100.getNode()) && 44776 Predicate_load(N100.getNode()) && 44777 Predicate_loadf64(N100.getNode())) { 44778 SDValue N1001 = N100.getOperand(1); 44779 SDValue CPTmpN1001_0; 44780 SDValue CPTmpN1001_1; 44781 SDValue CPTmpN1001_2; 44782 SDValue CPTmpN1001_3; 44783 SDValue CPTmpN1001_4; 44784 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4) && 44785 N10.getNode()->getValueType(0) == MVT::v2f64 && 44786 N100.getNode()->getValueType(0) == MVT::f64) { 44787 SDNode *Result = Emit_247(N, X86::MOVLPSrm, MVT::v4f32, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 44788 return Result; 44789 } 44790 } 44791 } 44792 } 44793 } 44794 } 44795 44796 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src1, (bitconvert:v4f32 (scalar_to_vector:v2f64 (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>)))<<P:Predicate_movhp>> 44797 // Emits: (MOVHPSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 44798 // Pattern complexity = 52 cost = 1 size = 3 44799 if (Predicate_movhp(N.getNode())) { 44800 SDValue N0 = N.getOperand(0); 44801 SDValue N1 = N.getOperand(1); 44802 if (N1.getOpcode() == ISD::BIT_CONVERT && 44803 N1.hasOneUse()) { 44804 SDValue N10 = N1.getOperand(0); 44805 if (N10.getOpcode() == ISD::SCALAR_TO_VECTOR && 44806 N10.hasOneUse()) { 44807 SDValue N100 = N10.getOperand(0); 44808 if (N100.getOpcode() == ISD::LOAD && 44809 N100.hasOneUse() && 44810 IsLegalAndProfitableToFold(N100.getNode(), N10.getNode(), N.getNode())) { 44811 SDValue Chain100 = N100.getOperand(0); 44812 if (Predicate_unindexedload(N100.getNode()) && 44813 Predicate_load(N100.getNode()) && 44814 Predicate_loadf64(N100.getNode())) { 44815 SDValue N1001 = N100.getOperand(1); 44816 SDValue CPTmpN1001_0; 44817 SDValue CPTmpN1001_1; 44818 SDValue CPTmpN1001_2; 44819 SDValue CPTmpN1001_3; 44820 SDValue CPTmpN1001_4; 44821 if (SelectAddr(N, N1001, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4) && 44822 N10.getNode()->getValueType(0) == MVT::v2f64 && 44823 N100.getNode()->getValueType(0) == MVT::f64) { 44824 SDNode *Result = Emit_247(N, X86::MOVHPSrm, MVT::v4f32, CPTmpN1001_0, CPTmpN1001_1, CPTmpN1001_2, CPTmpN1001_3, CPTmpN1001_4); 44825 return Result; 44826 } 44827 } 44828 } 44829 } 44830 } 44831 } 44832 44833 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)<<P:Predicate_movlp>> 44834 // Emits: (MOVLPSrm:v4f32 VR128:v16i8:$src1, addr:iPTR:$src2) 44835 // Pattern complexity = 46 cost = 1 size = 3 44836 if (Predicate_movlp(N.getNode())) { 44837 SDValue N0 = N.getOperand(0); 44838 SDValue N1 = N.getOperand(1); 44839 if (N1.getOpcode() == ISD::LOAD && 44840 N1.hasOneUse() && 44841 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 44842 SDValue Chain1 = N1.getOperand(0); 44843 if (Predicate_unindexedload(N1.getNode()) && 44844 Predicate_load(N1.getNode())) { 44845 SDValue N11 = N1.getOperand(1); 44846 SDValue CPTmpN11_0; 44847 SDValue CPTmpN11_1; 44848 SDValue CPTmpN11_2; 44849 SDValue CPTmpN11_3; 44850 SDValue CPTmpN11_4; 44851 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 44852 SDNode *Result = Emit_18(N, X86::MOVLPSrm, MVT::v4f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 44853 return Result; 44854 } 44855 } 44856 } 44857 } 44858 44859 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)<<P:Predicate_movhp>> 44860 // Emits: (MOVHPSrm:v4f32 VR128:v16i8:$src1, addr:iPTR:$src2) 44861 // Pattern complexity = 46 cost = 1 size = 3 44862 if (Predicate_movhp(N.getNode())) { 44863 SDValue N0 = N.getOperand(0); 44864 SDValue N1 = N.getOperand(1); 44865 if (N1.getOpcode() == ISD::LOAD && 44866 N1.hasOneUse() && 44867 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 44868 SDValue Chain1 = N1.getOperand(0); 44869 if (Predicate_unindexedload(N1.getNode()) && 44870 Predicate_load(N1.getNode())) { 44871 SDValue N11 = N1.getOperand(1); 44872 SDValue CPTmpN11_0; 44873 SDValue CPTmpN11_1; 44874 SDValue CPTmpN11_2; 44875 SDValue CPTmpN11_3; 44876 SDValue CPTmpN11_4; 44877 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 44878 SDNode *Result = Emit_18(N, X86::MOVHPSrm, MVT::v4f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 44879 return Result; 44880 } 44881 } 44882 } 44883 } 44884 } 44885 44886 // Pattern: (vector_shuffle:v4f32 (bitconvert:v4f32 (ld:v2f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>), (undef:v4f32))<<P:Predicate_movddup>> 44887 // Emits: (MOVDDUPrm:v4f32 addr:iPTR:$src) 44888 // Pattern complexity = 37 cost = 1 size = 3 44889 if ((Subtarget->hasSSE3()) && 44890 Predicate_movddup(N.getNode())) { 44891 SDValue N0 = N.getOperand(0); 44892 if (N0.getOpcode() == ISD::BIT_CONVERT && 44893 N0.hasOneUse()) { 44894 SDValue N00 = N0.getOperand(0); 44895 if (N00.getOpcode() == ISD::LOAD && 44896 N00.hasOneUse() && 44897 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 44898 SDValue Chain00 = N00.getOperand(0); 44899 if (Predicate_unindexedload(N00.getNode()) && 44900 Predicate_load(N00.getNode()) && 44901 Predicate_memop(N00.getNode())) { 44902 SDValue N001 = N00.getOperand(1); 44903 SDValue CPTmpN001_0; 44904 SDValue CPTmpN001_1; 44905 SDValue CPTmpN001_2; 44906 SDValue CPTmpN001_3; 44907 SDValue CPTmpN001_4; 44908 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 44909 SDValue N1 = N.getOperand(1); 44910 if (N1.getOpcode() == ISD::UNDEF && 44911 N00.getNode()->getValueType(0) == MVT::v2f64) { 44912 SDNode *Result = Emit_241(N, X86::MOVDDUPrm, MVT::v4f32, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 44913 return Result; 44914 } 44915 } 44916 } 44917 } 44918 } 44919 } 44920 if ((Subtarget->hasSSE1())) { 44921 44922 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)<<P:Predicate_unpckh>> 44923 // Emits: (UNPCKHPSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 44924 // Pattern complexity = 36 cost = 1 size = 3 44925 if (Predicate_unpckh(N.getNode())) { 44926 SDValue N0 = N.getOperand(0); 44927 SDValue N1 = N.getOperand(1); 44928 if (N1.getOpcode() == ISD::LOAD && 44929 N1.hasOneUse() && 44930 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 44931 SDValue Chain1 = N1.getOperand(0); 44932 if (Predicate_unindexedload(N1.getNode()) && 44933 Predicate_load(N1.getNode()) && 44934 Predicate_memop(N1.getNode())) { 44935 SDValue N11 = N1.getOperand(1); 44936 SDValue CPTmpN11_0; 44937 SDValue CPTmpN11_1; 44938 SDValue CPTmpN11_2; 44939 SDValue CPTmpN11_3; 44940 SDValue CPTmpN11_4; 44941 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 44942 SDNode *Result = Emit_18(N, X86::UNPCKHPSrm, MVT::v4f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 44943 return Result; 44944 } 44945 } 44946 } 44947 } 44948 44949 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)<<P:Predicate_unpckl>> 44950 // Emits: (UNPCKLPSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 44951 // Pattern complexity = 36 cost = 1 size = 3 44952 if (Predicate_unpckl(N.getNode())) { 44953 SDValue N0 = N.getOperand(0); 44954 SDValue N1 = N.getOperand(1); 44955 if (N1.getOpcode() == ISD::LOAD && 44956 N1.hasOneUse() && 44957 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 44958 SDValue Chain1 = N1.getOperand(0); 44959 if (Predicate_unindexedload(N1.getNode()) && 44960 Predicate_load(N1.getNode()) && 44961 Predicate_memop(N1.getNode())) { 44962 SDValue N11 = N1.getOperand(1); 44963 SDValue CPTmpN11_0; 44964 SDValue CPTmpN11_1; 44965 SDValue CPTmpN11_2; 44966 SDValue CPTmpN11_3; 44967 SDValue CPTmpN11_4; 44968 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 44969 SDNode *Result = Emit_18(N, X86::UNPCKLPSrm, MVT::v4f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 44970 return Result; 44971 } 44972 } 44973 } 44974 } 44975 } 44976 if ((Subtarget->hasSSE3())) { 44977 44978 // Pattern: (vector_shuffle:v4f32 (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (undef:v4f32))<<P:Predicate_movshdup>> 44979 // Emits: (MOVSHDUPrm:v4f32 addr:iPTR:$src) 44980 // Pattern complexity = 29 cost = 1 size = 3 44981 if (Predicate_movshdup(N.getNode())) { 44982 SDValue N0 = N.getOperand(0); 44983 if (N0.getOpcode() == ISD::LOAD && 44984 N0.hasOneUse() && 44985 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 44986 SDValue Chain0 = N0.getOperand(0); 44987 if (Predicate_unindexedload(N0.getNode()) && 44988 Predicate_load(N0.getNode()) && 44989 Predicate_memop(N0.getNode())) { 44990 SDValue N01 = N0.getOperand(1); 44991 SDValue CPTmpN01_0; 44992 SDValue CPTmpN01_1; 44993 SDValue CPTmpN01_2; 44994 SDValue CPTmpN01_3; 44995 SDValue CPTmpN01_4; 44996 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 44997 SDValue N1 = N.getOperand(1); 44998 if (N1.getOpcode() == ISD::UNDEF) { 44999 SDNode *Result = Emit_245(N, X86::MOVSHDUPrm, MVT::v4f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 45000 return Result; 45001 } 45002 } 45003 } 45004 } 45005 } 45006 45007 // Pattern: (vector_shuffle:v4f32 (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (undef:v4f32))<<P:Predicate_movsldup>> 45008 // Emits: (MOVSLDUPrm:v4f32 addr:iPTR:$src) 45009 // Pattern complexity = 29 cost = 1 size = 3 45010 if (Predicate_movsldup(N.getNode())) { 45011 SDValue N0 = N.getOperand(0); 45012 if (N0.getOpcode() == ISD::LOAD && 45013 N0.hasOneUse() && 45014 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 45015 SDValue Chain0 = N0.getOperand(0); 45016 if (Predicate_unindexedload(N0.getNode()) && 45017 Predicate_load(N0.getNode()) && 45018 Predicate_memop(N0.getNode())) { 45019 SDValue N01 = N0.getOperand(1); 45020 SDValue CPTmpN01_0; 45021 SDValue CPTmpN01_1; 45022 SDValue CPTmpN01_2; 45023 SDValue CPTmpN01_3; 45024 SDValue CPTmpN01_4; 45025 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 45026 SDValue N1 = N.getOperand(1); 45027 if (N1.getOpcode() == ISD::UNDEF) { 45028 SDNode *Result = Emit_245(N, X86::MOVSLDUPrm, MVT::v4f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 45029 return Result; 45030 } 45031 } 45032 } 45033 } 45034 } 45035 } 45036 } 45037 45038 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src, (undef:v4f32))<<P:Predicate_movddup>> 45039 // Emits: (MOVLHPSrr:v4f32 VR128:v16i8:$src, VR128:v16i8:$src) 45040 // Pattern complexity = 27 cost = 1 size = 3 45041 if ((Subtarget->hasSSE1()) && 45042 Predicate_movddup(N.getNode())) { 45043 SDValue N0 = N.getOperand(0); 45044 SDValue N1 = N.getOperand(1); 45045 if (N1.getOpcode() == ISD::UNDEF) { 45046 SDNode *Result = Emit_162(N, X86::MOVLHPSrr, MVT::v4f32); 45047 return Result; 45048 } 45049 } 45050 45051 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src1, (undef:v4f32))<<P:Predicate_movhlps_undef>> 45052 // Emits: (MOVHLPSrr:v4f32 VR128:v16i8:$src1, VR128:v16i8:$src1) 45053 // Pattern complexity = 27 cost = 1 size = 3 45054 if (Predicate_movhlps_undef(N.getNode())) { 45055 SDValue N0 = N.getOperand(0); 45056 SDValue N1 = N.getOperand(1); 45057 if (N1.getOpcode() == ISD::UNDEF) { 45058 SDNode *Result = Emit_162(N, X86::MOVHLPSrr, MVT::v4f32); 45059 return Result; 45060 } 45061 } 45062 45063 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)<<P:Predicate_shufp>><<X:SHUFFLE_get_shuf_imm>>:$src3 45064 // Emits: (SHUFPSrmi:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2, (SHUFFLE_get_shuf_imm:i8 (vector_shuffle:v4f32 VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>):$src3)) 45065 // Pattern complexity = 26 cost = 1 size = 3 45066 if (OptLevel != CodeGenOpt::None && 45067 (Subtarget->hasSSE1()) && 45068 Predicate_shufp(N.getNode())) { 45069 SDValue N0 = N.getOperand(0); 45070 SDValue N1 = N.getOperand(1); 45071 if (N1.getOpcode() == ISD::LOAD && 45072 N1.hasOneUse() && 45073 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 45074 SDValue Chain1 = N1.getOperand(0); 45075 if (Predicate_unindexedload(N1.getNode()) && 45076 Predicate_load(N1.getNode()) && 45077 Predicate_memop(N1.getNode())) { 45078 SDValue N11 = N1.getOperand(1); 45079 SDValue CPTmpN11_0; 45080 SDValue CPTmpN11_1; 45081 SDValue CPTmpN11_2; 45082 SDValue CPTmpN11_3; 45083 SDValue CPTmpN11_4; 45084 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 45085 SDNode *Result = Emit_248(N, X86::SHUFPSrmi, MVT::v4f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 45086 return Result; 45087 } 45088 } 45089 } 45090 } 45091 if ((Subtarget->hasSSE1())) { 45092 45093 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2)<<P:Predicate_movhp>> 45094 // Emits: (MOVLHPSrr:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 45095 // Pattern complexity = 24 cost = 1 size = 3 45096 if (Predicate_movhp(N.getNode())) { 45097 SDNode *Result = Emit_15(N, X86::MOVLHPSrr, MVT::v4f32); 45098 return Result; 45099 } 45100 45101 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2)<<P:Predicate_movhlps>> 45102 // Emits: (MOVHLPSrr:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 45103 // Pattern complexity = 24 cost = 1 size = 3 45104 if (Predicate_movhlps(N.getNode())) { 45105 SDNode *Result = Emit_15(N, X86::MOVHLPSrr, MVT::v4f32); 45106 return Result; 45107 } 45108 } 45109 if ((!OptForSize) && (Subtarget->hasSSE2())) { 45110 45111 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src, (undef:v4f32))<<P:Predicate_unpckl_undef>>:$src2 45112 // Emits: (PSHUFDri:v4f32 VR128:v16i8:$src, (SHUFFLE_get_shuf_imm:i8 VR128:i8:$src2)) 45113 // Pattern complexity = 22 cost = 1 size = 3 45114 if (Predicate_unpckl_undef(N.getNode())) { 45115 SDValue N0 = N.getOperand(0); 45116 SDValue N1 = N.getOperand(1); 45117 if (N1.getOpcode() == ISD::UNDEF) { 45118 SDNode *Result = Emit_239(N, X86::PSHUFDri, MVT::v4f32); 45119 return Result; 45120 } 45121 } 45122 45123 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src, (undef:v4f32))<<P:Predicate_unpckh_undef>>:$src2 45124 // Emits: (PSHUFDri:v4f32 VR128:v16i8:$src, (SHUFFLE_get_shuf_imm:i8 VR128:i8:$src2)) 45125 // Pattern complexity = 22 cost = 1 size = 3 45126 if (Predicate_unpckh_undef(N.getNode())) { 45127 SDValue N0 = N.getOperand(0); 45128 SDValue N1 = N.getOperand(1); 45129 if (N1.getOpcode() == ISD::UNDEF) { 45130 SDNode *Result = Emit_239(N, X86::PSHUFDri, MVT::v4f32); 45131 return Result; 45132 } 45133 } 45134 } 45135 45136 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2)<<P:Predicate_movl>> 45137 // Emits: (MOVLPSrr:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 45138 // Pattern complexity = 19 cost = 1 size = 3 45139 if ((Subtarget->hasSSE1()) && 45140 Predicate_movl(N.getNode())) { 45141 SDNode *Result = Emit_15(N, X86::MOVLPSrr, MVT::v4f32); 45142 return Result; 45143 } 45144 45145 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2)<<P:Predicate_movlp>> 45146 // Emits: (MOVLPDrr:v4f32 VR128:v16i8:$src1, VR128:v16i8:$src2) 45147 // Pattern complexity = 19 cost = 1 size = 3 45148 if ((Subtarget->hasSSE2()) && 45149 Predicate_movlp(N.getNode())) { 45150 SDNode *Result = Emit_15(N, X86::MOVLPDrr, MVT::v4f32); 45151 return Result; 45152 } 45153 if ((Subtarget->hasSSE1())) { 45154 45155 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src, (undef:v4f32))<<P:Predicate_unpckl_undef>> 45156 // Emits: (UNPCKLPSrr:v4f32 VR128:v16i8:$src, VR128:v16i8:$src) 45157 // Pattern complexity = 17 cost = 1 size = 3 45158 if (Predicate_unpckl_undef(N.getNode())) { 45159 SDValue N0 = N.getOperand(0); 45160 SDValue N1 = N.getOperand(1); 45161 if (N1.getOpcode() == ISD::UNDEF) { 45162 SDNode *Result = Emit_162(N, X86::UNPCKLPSrr, MVT::v4f32); 45163 return Result; 45164 } 45165 } 45166 45167 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src, (undef:v4f32))<<P:Predicate_unpckh_undef>> 45168 // Emits: (UNPCKHPSrr:v4f32 VR128:v16i8:$src, VR128:v16i8:$src) 45169 // Pattern complexity = 17 cost = 1 size = 3 45170 if (Predicate_unpckh_undef(N.getNode())) { 45171 SDValue N0 = N.getOperand(0); 45172 SDValue N1 = N.getOperand(1); 45173 if (N1.getOpcode() == ISD::UNDEF) { 45174 SDNode *Result = Emit_162(N, X86::UNPCKHPSrr, MVT::v4f32); 45175 return Result; 45176 } 45177 } 45178 45179 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2)<<P:Predicate_unpckh>> 45180 // Emits: (UNPCKHPSrr:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 45181 // Pattern complexity = 14 cost = 1 size = 3 45182 if (Predicate_unpckh(N.getNode())) { 45183 SDNode *Result = Emit_15(N, X86::UNPCKHPSrr, MVT::v4f32); 45184 return Result; 45185 } 45186 45187 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2)<<P:Predicate_unpckl>> 45188 // Emits: (UNPCKLPSrr:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 45189 // Pattern complexity = 14 cost = 1 size = 3 45190 if (Predicate_unpckl(N.getNode())) { 45191 SDNode *Result = Emit_15(N, X86::UNPCKLPSrr, MVT::v4f32); 45192 return Result; 45193 } 45194 } 45195 45196 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src1, (undef:v4f32))<<P:Predicate_pshufd>><<X:SHUFFLE_get_shuf_imm>>:$src2 45197 // Emits: (PSHUFDri:v4f32 VR128:v16i8:$src1, (SHUFFLE_get_shuf_imm:i8 VR128:i8:$src2)) 45198 // Pattern complexity = 12 cost = 1 size = 3 45199 if ((Subtarget->hasSSE2()) && 45200 Predicate_pshufd(N.getNode())) { 45201 SDValue N0 = N.getOperand(0); 45202 SDValue N1 = N.getOperand(1); 45203 if (N1.getOpcode() == ISD::UNDEF) { 45204 SDNode *Result = Emit_239(N, X86::PSHUFDri, MVT::v4f32); 45205 return Result; 45206 } 45207 } 45208 if ((Subtarget->hasSSE3())) { 45209 45210 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src, (undef:v4f32))<<P:Predicate_movshdup>> 45211 // Emits: (MOVSHDUPrr:v4f32 VR128:v4f32:$src) 45212 // Pattern complexity = 7 cost = 1 size = 3 45213 if (Predicate_movshdup(N.getNode())) { 45214 SDValue N0 = N.getOperand(0); 45215 SDValue N1 = N.getOperand(1); 45216 if (N1.getOpcode() == ISD::UNDEF) { 45217 SDNode *Result = Emit_92(N, X86::MOVSHDUPrr, MVT::v4f32); 45218 return Result; 45219 } 45220 } 45221 45222 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src, (undef:v4f32))<<P:Predicate_movsldup>> 45223 // Emits: (MOVSLDUPrr:v4f32 VR128:v4f32:$src) 45224 // Pattern complexity = 7 cost = 1 size = 3 45225 if (Predicate_movsldup(N.getNode())) { 45226 SDValue N0 = N.getOperand(0); 45227 SDValue N1 = N.getOperand(1); 45228 if (N1.getOpcode() == ISD::UNDEF) { 45229 SDNode *Result = Emit_92(N, X86::MOVSLDUPrr, MVT::v4f32); 45230 return Result; 45231 } 45232 } 45233 } 45234 if ((Subtarget->hasSSE1())) { 45235 45236 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src1, (undef:v4f32))<<P:Predicate_pshufd>><<X:SHUFFLE_get_shuf_imm>>:$src3 45237 // Emits: (SHUFPSrri:v4f32 VR128:v16i8:$src1, VR128:v16i8:$src1, (SHUFFLE_get_shuf_imm:i8 VR128:i8:$src3)) 45238 // Pattern complexity = 7 cost = 1 size = 3 45239 if (Predicate_pshufd(N.getNode())) { 45240 SDValue N0 = N.getOperand(0); 45241 SDValue N1 = N.getOperand(1); 45242 if (N1.getOpcode() == ISD::UNDEF) { 45243 SDNode *Result = Emit_246(N, X86::SHUFPSrri, MVT::v4f32); 45244 return Result; 45245 } 45246 } 45247 45248 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2)<<P:Predicate_shufp>><<X:SHUFFLE_get_shuf_imm>>:$src3 45249 // Emits: (SHUFPSrri:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2, (SHUFFLE_get_shuf_imm:i8 (vector_shuffle:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2):$src3)) 45250 // Pattern complexity = 4 cost = 1 size = 3 45251 if (Predicate_shufp(N.getNode())) { 45252 SDNode *Result = Emit_242(N, X86::SHUFPSrri, MVT::v4f32); 45253 return Result; 45254 } 45255 45256 // Pattern: (vector_shuffle:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2)<<P:Predicate_movlp>>:$src3 45257 // Emits: (SHUFPSrri:v4f32 VR128:v16i8:$src2, VR128:v16i8:$src1, (SHUFFLE_get_shuf_imm:i8 VR128:i8:$src3)) 45258 // Pattern complexity = 4 cost = 1 size = 3 45259 if (Predicate_movlp(N.getNode())) { 45260 SDNode *Result = Emit_249(N, X86::SHUFPSrri, MVT::v4f32); 45261 return Result; 45262 } 45263 } 45264 45265 CannotYetSelect(N); 45266 return NULL; 45267 } 45268 45269 SDNode *Emit_250(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN0001_0, SDValue &CPTmpN0001_1, SDValue &CPTmpN0001_2, SDValue &CPTmpN0001_3, SDValue &CPTmpN0001_4) DISABLE_INLINE { 45270 SDValue N0 = N.getOperand(0); 45271 SDValue N00 = N0.getOperand(0); 45272 SDValue N000 = N00.getOperand(0); 45273 SDValue Chain000 = N000.getOperand(0); 45274 SDValue N0001 = N000.getOperand(1); 45275 SDValue N1 = N.getOperand(1); 45276 SDValue LSI_N000 = CurDAG->getMemOperand(cast<MemSDNode>(N000)->getMemOperand()); 45277 SDValue Ops0[] = { CPTmpN0001_0, CPTmpN0001_1, CPTmpN0001_2, CPTmpN0001_3, CPTmpN0001_4, LSI_N000, Chain000 }; 45278 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 7); 45279 ReplaceUses(SDValue(N000.getNode(), 1), SDValue(ResNode, 1)); 45280 return ResNode; 45281 } 45282 SDNode *Select_ISD_VECTOR_SHUFFLE_v2f64(const SDValue &N) { 45283 if (OptLevel != CodeGenOpt::None) { 45284 if ((Subtarget->hasSSE2())) { 45285 45286 // Pattern: (vector_shuffle:v2f64 VR128:v2f64:$src1, (scalar_to_vector:v2f64 (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>))<<P:Predicate_movlp>> 45287 // Emits: (MOVLPDrm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 45288 // Pattern complexity = 49 cost = 1 size = 3 45289 if (Predicate_movlp(N.getNode())) { 45290 SDValue N0 = N.getOperand(0); 45291 SDValue N1 = N.getOperand(1); 45292 if (N1.getOpcode() == ISD::SCALAR_TO_VECTOR && 45293 N1.hasOneUse()) { 45294 SDValue N10 = N1.getOperand(0); 45295 if (N10.getOpcode() == ISD::LOAD && 45296 N10.hasOneUse() && 45297 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 45298 SDValue Chain10 = N10.getOperand(0); 45299 if (Predicate_unindexedload(N10.getNode()) && 45300 Predicate_load(N10.getNode()) && 45301 Predicate_loadf64(N10.getNode())) { 45302 SDValue N101 = N10.getOperand(1); 45303 SDValue CPTmpN101_0; 45304 SDValue CPTmpN101_1; 45305 SDValue CPTmpN101_2; 45306 SDValue CPTmpN101_3; 45307 SDValue CPTmpN101_4; 45308 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 45309 N10.getNode()->getValueType(0) == MVT::f64) { 45310 SDNode *Result = Emit_16(N, X86::MOVLPDrm, MVT::v2f64, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 45311 return Result; 45312 } 45313 } 45314 } 45315 } 45316 } 45317 45318 // Pattern: (vector_shuffle:v2f64 VR128:v2f64:$src1, (scalar_to_vector:v2f64 (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>))<<P:Predicate_movhp>> 45319 // Emits: (MOVHPDrm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 45320 // Pattern complexity = 49 cost = 1 size = 3 45321 if (Predicate_movhp(N.getNode())) { 45322 SDValue N0 = N.getOperand(0); 45323 SDValue N1 = N.getOperand(1); 45324 if (N1.getOpcode() == ISD::SCALAR_TO_VECTOR && 45325 N1.hasOneUse()) { 45326 SDValue N10 = N1.getOperand(0); 45327 if (N10.getOpcode() == ISD::LOAD && 45328 N10.hasOneUse() && 45329 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 45330 SDValue Chain10 = N10.getOperand(0); 45331 if (Predicate_unindexedload(N10.getNode()) && 45332 Predicate_load(N10.getNode()) && 45333 Predicate_loadf64(N10.getNode())) { 45334 SDValue N101 = N10.getOperand(1); 45335 SDValue CPTmpN101_0; 45336 SDValue CPTmpN101_1; 45337 SDValue CPTmpN101_2; 45338 SDValue CPTmpN101_3; 45339 SDValue CPTmpN101_4; 45340 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 45341 N10.getNode()->getValueType(0) == MVT::f64) { 45342 SDNode *Result = Emit_16(N, X86::MOVHPDrm, MVT::v2f64, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 45343 return Result; 45344 } 45345 } 45346 } 45347 } 45348 } 45349 45350 // Pattern: (vector_shuffle:v2f64 VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)<<P:Predicate_movlp>> 45351 // Emits: (MOVLPDrm:v2f64 VR128:v16i8:$src1, addr:iPTR:$src2) 45352 // Pattern complexity = 46 cost = 1 size = 3 45353 if (Predicate_movlp(N.getNode())) { 45354 SDValue N0 = N.getOperand(0); 45355 SDValue N1 = N.getOperand(1); 45356 if (N1.getOpcode() == ISD::LOAD && 45357 N1.hasOneUse() && 45358 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 45359 SDValue Chain1 = N1.getOperand(0); 45360 if (Predicate_unindexedload(N1.getNode()) && 45361 Predicate_load(N1.getNode())) { 45362 SDValue N11 = N1.getOperand(1); 45363 SDValue CPTmpN11_0; 45364 SDValue CPTmpN11_1; 45365 SDValue CPTmpN11_2; 45366 SDValue CPTmpN11_3; 45367 SDValue CPTmpN11_4; 45368 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 45369 SDNode *Result = Emit_18(N, X86::MOVLPDrm, MVT::v2f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 45370 return Result; 45371 } 45372 } 45373 } 45374 } 45375 45376 // Pattern: (vector_shuffle:v2f64 VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)<<P:Predicate_movhp>> 45377 // Emits: (MOVHPDrm:v2f64 VR128:v16i8:$src1, addr:iPTR:$src2) 45378 // Pattern complexity = 46 cost = 1 size = 3 45379 if (Predicate_movhp(N.getNode())) { 45380 SDValue N0 = N.getOperand(0); 45381 SDValue N1 = N.getOperand(1); 45382 if (N1.getOpcode() == ISD::LOAD && 45383 N1.hasOneUse() && 45384 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 45385 SDValue Chain1 = N1.getOperand(0); 45386 if (Predicate_unindexedload(N1.getNode()) && 45387 Predicate_load(N1.getNode())) { 45388 SDValue N11 = N1.getOperand(1); 45389 SDValue CPTmpN11_0; 45390 SDValue CPTmpN11_1; 45391 SDValue CPTmpN11_2; 45392 SDValue CPTmpN11_3; 45393 SDValue CPTmpN11_4; 45394 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 45395 SDNode *Result = Emit_18(N, X86::MOVHPDrm, MVT::v2f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 45396 return Result; 45397 } 45398 } 45399 } 45400 } 45401 45402 // Pattern: (vector_shuffle:v2f64 VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)<<P:Predicate_unpckh>> 45403 // Emits: (UNPCKHPDrm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 45404 // Pattern complexity = 36 cost = 1 size = 3 45405 if (Predicate_unpckh(N.getNode())) { 45406 SDValue N0 = N.getOperand(0); 45407 SDValue N1 = N.getOperand(1); 45408 if (N1.getOpcode() == ISD::LOAD && 45409 N1.hasOneUse() && 45410 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 45411 SDValue Chain1 = N1.getOperand(0); 45412 if (Predicate_unindexedload(N1.getNode()) && 45413 Predicate_load(N1.getNode()) && 45414 Predicate_memop(N1.getNode())) { 45415 SDValue N11 = N1.getOperand(1); 45416 SDValue CPTmpN11_0; 45417 SDValue CPTmpN11_1; 45418 SDValue CPTmpN11_2; 45419 SDValue CPTmpN11_3; 45420 SDValue CPTmpN11_4; 45421 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 45422 SDNode *Result = Emit_18(N, X86::UNPCKHPDrm, MVT::v2f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 45423 return Result; 45424 } 45425 } 45426 } 45427 } 45428 45429 // Pattern: (vector_shuffle:v2f64 VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)<<P:Predicate_unpckl>> 45430 // Emits: (UNPCKLPDrm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 45431 // Pattern complexity = 36 cost = 1 size = 3 45432 if (Predicate_unpckl(N.getNode())) { 45433 SDValue N0 = N.getOperand(0); 45434 SDValue N1 = N.getOperand(1); 45435 if (N1.getOpcode() == ISD::LOAD && 45436 N1.hasOneUse() && 45437 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 45438 SDValue Chain1 = N1.getOperand(0); 45439 if (Predicate_unindexedload(N1.getNode()) && 45440 Predicate_load(N1.getNode()) && 45441 Predicate_memop(N1.getNode())) { 45442 SDValue N11 = N1.getOperand(1); 45443 SDValue CPTmpN11_0; 45444 SDValue CPTmpN11_1; 45445 SDValue CPTmpN11_2; 45446 SDValue CPTmpN11_3; 45447 SDValue CPTmpN11_4; 45448 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 45449 SDNode *Result = Emit_18(N, X86::UNPCKLPDrm, MVT::v2f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 45450 return Result; 45451 } 45452 } 45453 } 45454 } 45455 } 45456 if ((Subtarget->hasSSE3()) && 45457 Predicate_movddup(N.getNode())) { 45458 SDValue N0 = N.getOperand(0); 45459 45460 // Pattern: (vector_shuffle:v2f64 (bitconvert:v2f64 (scalar_to_vector:v2i64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>)), (undef:v2f64))<<P:Predicate_movddup>> 45461 // Emits: (MOVDDUPrm:v2f64 addr:iPTR:$src) 45462 // Pattern complexity = 35 cost = 1 size = 3 45463 if (N0.getOpcode() == ISD::BIT_CONVERT && 45464 N0.hasOneUse()) { 45465 SDValue N00 = N0.getOperand(0); 45466 if (N00.getOpcode() == ISD::SCALAR_TO_VECTOR && 45467 N00.hasOneUse()) { 45468 SDValue N000 = N00.getOperand(0); 45469 if (N000.getOpcode() == ISD::LOAD && 45470 N000.hasOneUse() && 45471 IsLegalAndProfitableToFold(N000.getNode(), N00.getNode(), N.getNode())) { 45472 SDValue Chain000 = N000.getOperand(0); 45473 if (Predicate_unindexedload(N000.getNode()) && 45474 Predicate_load(N000.getNode()) && 45475 Predicate_loadi64(N000.getNode())) { 45476 SDValue N0001 = N000.getOperand(1); 45477 SDValue CPTmpN0001_0; 45478 SDValue CPTmpN0001_1; 45479 SDValue CPTmpN0001_2; 45480 SDValue CPTmpN0001_3; 45481 SDValue CPTmpN0001_4; 45482 if (SelectAddr(N, N0001, CPTmpN0001_0, CPTmpN0001_1, CPTmpN0001_2, CPTmpN0001_3, CPTmpN0001_4)) { 45483 SDValue N1 = N.getOperand(1); 45484 if (N1.getOpcode() == ISD::UNDEF && 45485 N00.getNode()->getValueType(0) == MVT::v2i64 && 45486 N000.getNode()->getValueType(0) == MVT::i64) { 45487 SDNode *Result = Emit_250(N, X86::MOVDDUPrm, MVT::v2f64, CPTmpN0001_0, CPTmpN0001_1, CPTmpN0001_2, CPTmpN0001_3, CPTmpN0001_4); 45488 return Result; 45489 } 45490 } 45491 } 45492 } 45493 } 45494 } 45495 45496 // Pattern: (vector_shuffle:v2f64 (ld:v2f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (undef:v2f64))<<P:Predicate_movddup>> 45497 // Emits: (MOVDDUPrm:v2f64 addr:iPTR:$src) 45498 // Pattern complexity = 34 cost = 1 size = 3 45499 if (N0.getOpcode() == ISD::LOAD && 45500 N0.hasOneUse() && 45501 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 45502 SDValue Chain0 = N0.getOperand(0); 45503 if (Predicate_unindexedload(N0.getNode()) && 45504 Predicate_load(N0.getNode()) && 45505 Predicate_memop(N0.getNode())) { 45506 SDValue N01 = N0.getOperand(1); 45507 SDValue CPTmpN01_0; 45508 SDValue CPTmpN01_1; 45509 SDValue CPTmpN01_2; 45510 SDValue CPTmpN01_3; 45511 SDValue CPTmpN01_4; 45512 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 45513 SDValue N1 = N.getOperand(1); 45514 if (N1.getOpcode() == ISD::UNDEF) { 45515 SDNode *Result = Emit_245(N, X86::MOVDDUPrm, MVT::v2f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 45516 return Result; 45517 } 45518 } 45519 } 45520 } 45521 45522 // Pattern: (vector_shuffle:v2f64 (scalar_to_vector:v2f64 (ld:f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>), (undef:v2f64))<<P:Predicate_movddup>> 45523 // Emits: (MOVDDUPrm:v2f64 addr:iPTR:$src) 45524 // Pattern complexity = 32 cost = 1 size = 3 45525 if (N0.getOpcode() == ISD::SCALAR_TO_VECTOR && 45526 N0.hasOneUse()) { 45527 SDValue N00 = N0.getOperand(0); 45528 if (N00.getOpcode() == ISD::LOAD && 45529 N00.hasOneUse() && 45530 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 45531 SDValue Chain00 = N00.getOperand(0); 45532 if (Predicate_unindexedload(N00.getNode()) && 45533 Predicate_load(N00.getNode()) && 45534 Predicate_loadf64(N00.getNode())) { 45535 SDValue N001 = N00.getOperand(1); 45536 SDValue CPTmpN001_0; 45537 SDValue CPTmpN001_1; 45538 SDValue CPTmpN001_2; 45539 SDValue CPTmpN001_3; 45540 SDValue CPTmpN001_4; 45541 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 45542 SDValue N1 = N.getOperand(1); 45543 if (N1.getOpcode() == ISD::UNDEF && 45544 N00.getNode()->getValueType(0) == MVT::f64) { 45545 SDNode *Result = Emit_241(N, X86::MOVDDUPrm, MVT::v2f64, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 45546 return Result; 45547 } 45548 } 45549 } 45550 } 45551 } 45552 } 45553 45554 // Pattern: (vector_shuffle:v2f64 VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)<<P:Predicate_shufp>><<X:SHUFFLE_get_shuf_imm>>:$src3 45555 // Emits: (SHUFPDrmi:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2, (SHUFFLE_get_shuf_imm:i8 (vector_shuffle:v2f64 VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>):$src3)) 45556 // Pattern complexity = 26 cost = 1 size = 3 45557 if ((Subtarget->hasSSE2()) && 45558 Predicate_shufp(N.getNode())) { 45559 SDValue N0 = N.getOperand(0); 45560 SDValue N1 = N.getOperand(1); 45561 if (N1.getOpcode() == ISD::LOAD && 45562 N1.hasOneUse() && 45563 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 45564 SDValue Chain1 = N1.getOperand(0); 45565 if (Predicate_unindexedload(N1.getNode()) && 45566 Predicate_load(N1.getNode()) && 45567 Predicate_memop(N1.getNode())) { 45568 SDValue N11 = N1.getOperand(1); 45569 SDValue CPTmpN11_0; 45570 SDValue CPTmpN11_1; 45571 SDValue CPTmpN11_2; 45572 SDValue CPTmpN11_3; 45573 SDValue CPTmpN11_4; 45574 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 45575 SDNode *Result = Emit_248(N, X86::SHUFPDrmi, MVT::v2f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 45576 return Result; 45577 } 45578 } 45579 } 45580 } 45581 } 45582 if ((Subtarget->hasSSE2())) { 45583 if (Predicate_movl(N.getNode())) { 45584 45585 // Pattern: (vector_shuffle:v2f64 (bitconvert:v2f64)<<P:Predicate_immAllZerosV_bc>>, VR128:v2f64:$src)<<P:Predicate_movl>> 45586 // Emits: (MOVZPQILo2PQIrr:v2f64 VR128:v16i8:$src) 45587 // Pattern complexity = 23 cost = 1 size = 3 45588 { 45589 SDValue N0 = N.getOperand(0); 45590 if (N0.getOpcode() == ISD::BIT_CONVERT && 45591 Predicate_immAllZerosV_bc(N0.getNode())) { 45592 SDNode *Result = Emit_106(N, X86::MOVZPQILo2PQIrr, MVT::v2f64); 45593 return Result; 45594 } 45595 } 45596 45597 // Pattern: (vector_shuffle:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2)<<P:Predicate_movl>> 45598 // Emits: (MOVLPDrr:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 45599 // Pattern complexity = 19 cost = 1 size = 3 45600 SDNode *Result = Emit_15(N, X86::MOVLPDrr, MVT::v2f64); 45601 return Result; 45602 } 45603 45604 // Pattern: (vector_shuffle:v2f64 VR128:v2f64:$src, (undef:v2f64))<<P:Predicate_splat_lo>> 45605 // Emits: (UNPCKLPDrr:v2f64 VR128:v16i8:$src, VR128:v16i8:$src) 45606 // Pattern complexity = 17 cost = 1 size = 3 45607 if (Predicate_splat_lo(N.getNode())) { 45608 SDValue N0 = N.getOperand(0); 45609 SDValue N1 = N.getOperand(1); 45610 if (N1.getOpcode() == ISD::UNDEF) { 45611 SDNode *Result = Emit_162(N, X86::UNPCKLPDrr, MVT::v2f64); 45612 return Result; 45613 } 45614 } 45615 if (Predicate_unpckh(N.getNode())) { 45616 45617 // Pattern: (vector_shuffle:v2f64 VR128:v2f64:$src, (undef:v2f64))<<P:Predicate_unpckh>> 45618 // Emits: (UNPCKHPDrr:v2f64 VR128:v16i8:$src, VR128:v16i8:$src) 45619 // Pattern complexity = 17 cost = 1 size = 3 45620 { 45621 SDValue N0 = N.getOperand(0); 45622 SDValue N1 = N.getOperand(1); 45623 if (N1.getOpcode() == ISD::UNDEF) { 45624 SDNode *Result = Emit_162(N, X86::UNPCKHPDrr, MVT::v2f64); 45625 return Result; 45626 } 45627 } 45628 45629 // Pattern: (vector_shuffle:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2)<<P:Predicate_unpckh>> 45630 // Emits: (UNPCKHPDrr:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 45631 // Pattern complexity = 14 cost = 1 size = 3 45632 SDNode *Result = Emit_15(N, X86::UNPCKHPDrr, MVT::v2f64); 45633 return Result; 45634 } 45635 45636 // Pattern: (vector_shuffle:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2)<<P:Predicate_unpckl>> 45637 // Emits: (UNPCKLPDrr:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 45638 // Pattern complexity = 14 cost = 1 size = 3 45639 if (Predicate_unpckl(N.getNode())) { 45640 SDNode *Result = Emit_15(N, X86::UNPCKLPDrr, MVT::v2f64); 45641 return Result; 45642 } 45643 } 45644 45645 // Pattern: (vector_shuffle:v2f64 VR128:v2f64:$src, (undef:v2f64))<<P:Predicate_movddup>> 45646 // Emits: (MOVDDUPrr:v2f64 VR128:v2f64:$src) 45647 // Pattern complexity = 7 cost = 1 size = 3 45648 if ((Subtarget->hasSSE3()) && 45649 Predicate_movddup(N.getNode())) { 45650 SDValue N0 = N.getOperand(0); 45651 SDValue N1 = N.getOperand(1); 45652 if (N1.getOpcode() == ISD::UNDEF) { 45653 SDNode *Result = Emit_92(N, X86::MOVDDUPrr, MVT::v2f64); 45654 return Result; 45655 } 45656 } 45657 if ((Subtarget->hasSSE2())) { 45658 45659 // Pattern: (vector_shuffle:v2f64 VR128:v2f64:$src1, (undef:v2f64))<<P:Predicate_pshufd>><<X:SHUFFLE_get_shuf_imm>>:$src3 45660 // Emits: (SHUFPDrri:v2f64 VR128:v16i8:$src1, VR128:v16i8:$src1, (SHUFFLE_get_shuf_imm:i8 VR128:i8:$src3)) 45661 // Pattern complexity = 7 cost = 1 size = 3 45662 if (Predicate_pshufd(N.getNode())) { 45663 SDValue N0 = N.getOperand(0); 45664 SDValue N1 = N.getOperand(1); 45665 if (N1.getOpcode() == ISD::UNDEF) { 45666 SDNode *Result = Emit_246(N, X86::SHUFPDrri, MVT::v2f64); 45667 return Result; 45668 } 45669 } 45670 45671 // Pattern: (vector_shuffle:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2)<<P:Predicate_shufp>><<X:SHUFFLE_get_shuf_imm>>:$src3 45672 // Emits: (SHUFPDrri:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2, (SHUFFLE_get_shuf_imm:i8 (vector_shuffle:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2):$src3)) 45673 // Pattern complexity = 4 cost = 1 size = 3 45674 if (Predicate_shufp(N.getNode())) { 45675 SDNode *Result = Emit_242(N, X86::SHUFPDrri, MVT::v2f64); 45676 return Result; 45677 } 45678 } 45679 45680 CannotYetSelect(N); 45681 return NULL; 45682 } 45683 45684 SDNode *Select_ISD_XOR_i8(const SDValue &N) { 45685 if (OptLevel != CodeGenOpt::None) { 45686 SDValue N0 = N.getOperand(0); 45687 45688 // Pattern: (xor:i8 GR8:i8:$src1, (ld:i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 45689 // Emits: (XOR8rm:i8 GR8:i8:$src1, addr:iPTR:$src2) 45690 // Pattern complexity = 25 cost = 1 size = 3 45691 { 45692 SDValue N1 = N.getOperand(1); 45693 if (N1.getOpcode() == ISD::LOAD && 45694 N1.hasOneUse() && 45695 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 45696 SDValue Chain1 = N1.getOperand(0); 45697 if (Predicate_unindexedload(N1.getNode()) && 45698 Predicate_load(N1.getNode())) { 45699 SDValue N11 = N1.getOperand(1); 45700 SDValue CPTmpN11_0; 45701 SDValue CPTmpN11_1; 45702 SDValue CPTmpN11_2; 45703 SDValue CPTmpN11_3; 45704 SDValue CPTmpN11_4; 45705 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 45706 SDNode *Result = Emit_2(N, X86::XOR8rm, MVT::i8, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 45707 return Result; 45708 } 45709 } 45710 } 45711 } 45712 45713 // Pattern: (xor:i8 (ld:i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR8:i8:$src1) 45714 // Emits: (XOR8rm:i8 GR8:i8:$src1, addr:iPTR:$src2) 45715 // Pattern complexity = 25 cost = 1 size = 3 45716 if (N0.getOpcode() == ISD::LOAD && 45717 N0.hasOneUse() && 45718 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 45719 SDValue Chain0 = N0.getOperand(0); 45720 if (Predicate_unindexedload(N0.getNode()) && 45721 Predicate_load(N0.getNode())) { 45722 SDValue N01 = N0.getOperand(1); 45723 SDValue CPTmpN01_0; 45724 SDValue CPTmpN01_1; 45725 SDValue CPTmpN01_2; 45726 SDValue CPTmpN01_3; 45727 SDValue CPTmpN01_4; 45728 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 45729 SDNode *Result = Emit_4(N, X86::XOR8rm, MVT::i8, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 45730 return Result; 45731 } 45732 } 45733 } 45734 } 45735 { 45736 SDValue N0 = N.getOperand(0); 45737 SDValue N1 = N.getOperand(1); 45738 if (N1.getOpcode() == ISD::Constant) { 45739 45740 // Pattern: (xor:i8 GR8:i8:$src, (imm:i8)<<P:Predicate_immAllOnes>>) 45741 // Emits: (NOT8r:i8 GR8:i8:$src) 45742 // Pattern complexity = 22 cost = 1 size = 2 45743 if (Predicate_immAllOnes(N1.getNode())) { 45744 SDNode *Result = Emit_92(N, X86::NOT8r, MVT::i8); 45745 return Result; 45746 } 45747 45748 // Pattern: (xor:i8 GR8:i8:$src1, (imm:i8):$src2) 45749 // Emits: (XOR8ri:i8 GR8:i8:$src1, (imm:i8):$src2) 45750 // Pattern complexity = 6 cost = 1 size = 3 45751 SDNode *Result = Emit_3(N, X86::XOR8ri, MVT::i8); 45752 return Result; 45753 } 45754 } 45755 45756 // Pattern: (xor:i8 GR8:i8:$src1, GR8:i8:$src2) 45757 // Emits: (XOR8rr:i8 GR8:i8:$src1, GR8:i8:$src2) 45758 // Pattern complexity = 3 cost = 1 size = 3 45759 SDNode *Result = Emit_1(N, X86::XOR8rr, MVT::i8); 45760 return Result; 45761 } 45762 45763 SDNode *Select_ISD_XOR_i16(const SDValue &N) { 45764 if (OptLevel != CodeGenOpt::None) { 45765 SDValue N0 = N.getOperand(0); 45766 45767 // Pattern: (xor:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 45768 // Emits: (XOR16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 45769 // Pattern complexity = 25 cost = 1 size = 3 45770 { 45771 SDValue N1 = N.getOperand(1); 45772 if (N1.getOpcode() == ISD::LOAD && 45773 N1.hasOneUse() && 45774 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 45775 SDValue Chain1 = N1.getOperand(0); 45776 if (Predicate_unindexedload(N1.getNode()) && 45777 Predicate_load(N1.getNode())) { 45778 SDValue N11 = N1.getOperand(1); 45779 SDValue CPTmpN11_0; 45780 SDValue CPTmpN11_1; 45781 SDValue CPTmpN11_2; 45782 SDValue CPTmpN11_3; 45783 SDValue CPTmpN11_4; 45784 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 45785 SDNode *Result = Emit_2(N, X86::XOR16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 45786 return Result; 45787 } 45788 } 45789 } 45790 } 45791 45792 // Pattern: (xor:i16 (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR16:i16:$src1) 45793 // Emits: (XOR16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 45794 // Pattern complexity = 25 cost = 1 size = 3 45795 if (N0.getOpcode() == ISD::LOAD && 45796 N0.hasOneUse() && 45797 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 45798 SDValue Chain0 = N0.getOperand(0); 45799 if (Predicate_unindexedload(N0.getNode()) && 45800 Predicate_load(N0.getNode())) { 45801 SDValue N01 = N0.getOperand(1); 45802 SDValue CPTmpN01_0; 45803 SDValue CPTmpN01_1; 45804 SDValue CPTmpN01_2; 45805 SDValue CPTmpN01_3; 45806 SDValue CPTmpN01_4; 45807 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 45808 SDNode *Result = Emit_4(N, X86::XOR16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 45809 return Result; 45810 } 45811 } 45812 } 45813 } 45814 { 45815 SDValue N0 = N.getOperand(0); 45816 SDValue N1 = N.getOperand(1); 45817 if (N1.getOpcode() == ISD::Constant) { 45818 45819 // Pattern: (xor:i16 GR16:i16:$src, (imm:i16)<<P:Predicate_immAllOnes>>) 45820 // Emits: (NOT16r:i16 GR16:i16:$src) 45821 // Pattern complexity = 22 cost = 1 size = 2 45822 if (Predicate_immAllOnes(N1.getNode())) { 45823 SDNode *Result = Emit_92(N, X86::NOT16r, MVT::i16); 45824 return Result; 45825 } 45826 45827 // Pattern: (xor:i16 GR16:i16:$src1, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 45828 // Emits: (XOR16ri8:i16 GR16:i16:$src1, (imm:i16):$src2) 45829 // Pattern complexity = 7 cost = 1 size = 3 45830 if (Predicate_i16immSExt8(N1.getNode())) { 45831 SDNode *Result = Emit_5(N, X86::XOR16ri8, MVT::i16); 45832 return Result; 45833 } 45834 45835 // Pattern: (xor:i16 GR16:i16:$src1, (imm:i16):$src2) 45836 // Emits: (XOR16ri:i16 GR16:i16:$src1, (imm:i16):$src2) 45837 // Pattern complexity = 6 cost = 1 size = 3 45838 SDNode *Result = Emit_5(N, X86::XOR16ri, MVT::i16); 45839 return Result; 45840 } 45841 } 45842 45843 // Pattern: (xor:i16 GR16:i16:$src1, GR16:i16:$src2) 45844 // Emits: (XOR16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 45845 // Pattern complexity = 3 cost = 1 size = 3 45846 SDNode *Result = Emit_1(N, X86::XOR16rr, MVT::i16); 45847 return Result; 45848 } 45849 45850 SDNode *Select_ISD_XOR_i32(const SDValue &N) { 45851 if (OptLevel != CodeGenOpt::None) { 45852 SDValue N0 = N.getOperand(0); 45853 45854 // Pattern: (xor:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 45855 // Emits: (XOR32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 45856 // Pattern complexity = 25 cost = 1 size = 3 45857 { 45858 SDValue N1 = N.getOperand(1); 45859 if (N1.getOpcode() == ISD::LOAD && 45860 N1.hasOneUse() && 45861 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 45862 SDValue Chain1 = N1.getOperand(0); 45863 if (Predicate_unindexedload(N1.getNode()) && 45864 Predicate_load(N1.getNode())) { 45865 SDValue N11 = N1.getOperand(1); 45866 SDValue CPTmpN11_0; 45867 SDValue CPTmpN11_1; 45868 SDValue CPTmpN11_2; 45869 SDValue CPTmpN11_3; 45870 SDValue CPTmpN11_4; 45871 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 45872 SDNode *Result = Emit_2(N, X86::XOR32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 45873 return Result; 45874 } 45875 } 45876 } 45877 } 45878 45879 // Pattern: (xor:i32 (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR32:i32:$src1) 45880 // Emits: (XOR32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 45881 // Pattern complexity = 25 cost = 1 size = 3 45882 if (N0.getOpcode() == ISD::LOAD && 45883 N0.hasOneUse() && 45884 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 45885 SDValue Chain0 = N0.getOperand(0); 45886 if (Predicate_unindexedload(N0.getNode()) && 45887 Predicate_load(N0.getNode())) { 45888 SDValue N01 = N0.getOperand(1); 45889 SDValue CPTmpN01_0; 45890 SDValue CPTmpN01_1; 45891 SDValue CPTmpN01_2; 45892 SDValue CPTmpN01_3; 45893 SDValue CPTmpN01_4; 45894 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 45895 SDNode *Result = Emit_4(N, X86::XOR32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 45896 return Result; 45897 } 45898 } 45899 } 45900 } 45901 { 45902 SDValue N0 = N.getOperand(0); 45903 SDValue N1 = N.getOperand(1); 45904 if (N1.getOpcode() == ISD::Constant) { 45905 45906 // Pattern: (xor:i32 GR32:i32:$src, (imm:i32)<<P:Predicate_immAllOnes>>) 45907 // Emits: (NOT32r:i32 GR32:i32:$src) 45908 // Pattern complexity = 22 cost = 1 size = 2 45909 if (Predicate_immAllOnes(N1.getNode())) { 45910 SDNode *Result = Emit_92(N, X86::NOT32r, MVT::i32); 45911 return Result; 45912 } 45913 45914 // Pattern: (xor:i32 GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 45915 // Emits: (XOR32ri8:i32 GR32:i32:$src1, (imm:i32):$src2) 45916 // Pattern complexity = 7 cost = 1 size = 3 45917 if (Predicate_i32immSExt8(N1.getNode())) { 45918 SDNode *Result = Emit_8(N, X86::XOR32ri8, MVT::i32); 45919 return Result; 45920 } 45921 45922 // Pattern: (xor:i32 GR32:i32:$src1, (imm:i32):$src2) 45923 // Emits: (XOR32ri:i32 GR32:i32:$src1, (imm:i32):$src2) 45924 // Pattern complexity = 6 cost = 1 size = 3 45925 SDNode *Result = Emit_8(N, X86::XOR32ri, MVT::i32); 45926 return Result; 45927 } 45928 } 45929 45930 // Pattern: (xor:i32 GR32:i32:$src1, GR32:i32:$src2) 45931 // Emits: (XOR32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 45932 // Pattern complexity = 3 cost = 1 size = 3 45933 SDNode *Result = Emit_1(N, X86::XOR32rr, MVT::i32); 45934 return Result; 45935 } 45936 45937 SDNode *Select_ISD_XOR_i64(const SDValue &N) { 45938 if (OptLevel != CodeGenOpt::None) { 45939 SDValue N0 = N.getOperand(0); 45940 45941 // Pattern: (xor:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 45942 // Emits: (XOR64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 45943 // Pattern complexity = 25 cost = 1 size = 3 45944 { 45945 SDValue N1 = N.getOperand(1); 45946 if (N1.getOpcode() == ISD::LOAD && 45947 N1.hasOneUse() && 45948 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 45949 SDValue Chain1 = N1.getOperand(0); 45950 if (Predicate_unindexedload(N1.getNode()) && 45951 Predicate_load(N1.getNode())) { 45952 SDValue N11 = N1.getOperand(1); 45953 SDValue CPTmpN11_0; 45954 SDValue CPTmpN11_1; 45955 SDValue CPTmpN11_2; 45956 SDValue CPTmpN11_3; 45957 SDValue CPTmpN11_4; 45958 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 45959 SDNode *Result = Emit_2(N, X86::XOR64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 45960 return Result; 45961 } 45962 } 45963 } 45964 } 45965 45966 // Pattern: (xor:i64 (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, GR64:i64:$src1) 45967 // Emits: (XOR64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 45968 // Pattern complexity = 25 cost = 1 size = 3 45969 if (N0.getOpcode() == ISD::LOAD && 45970 N0.hasOneUse() && 45971 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 45972 SDValue Chain0 = N0.getOperand(0); 45973 if (Predicate_unindexedload(N0.getNode()) && 45974 Predicate_load(N0.getNode())) { 45975 SDValue N01 = N0.getOperand(1); 45976 SDValue CPTmpN01_0; 45977 SDValue CPTmpN01_1; 45978 SDValue CPTmpN01_2; 45979 SDValue CPTmpN01_3; 45980 SDValue CPTmpN01_4; 45981 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 45982 SDNode *Result = Emit_4(N, X86::XOR64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 45983 return Result; 45984 } 45985 } 45986 } 45987 } 45988 { 45989 SDValue N0 = N.getOperand(0); 45990 SDValue N1 = N.getOperand(1); 45991 if (N1.getOpcode() == ISD::Constant) { 45992 45993 // Pattern: (xor:i64 GR64:i64:$src, (imm:i64)<<P:Predicate_immAllOnes>>) 45994 // Emits: (NOT64r:i64 GR64:i64:$src) 45995 // Pattern complexity = 22 cost = 1 size = 3 45996 if (Predicate_immAllOnes(N1.getNode())) { 45997 SDNode *Result = Emit_92(N, X86::NOT64r, MVT::i64); 45998 return Result; 45999 } 46000 46001 // Pattern: (xor:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 46002 // Emits: (XOR64ri8:i64 GR64:i64:$src1, (imm:i64):$src2) 46003 // Pattern complexity = 7 cost = 1 size = 3 46004 if (Predicate_i64immSExt8(N1.getNode())) { 46005 SDNode *Result = Emit_12(N, X86::XOR64ri8, MVT::i64); 46006 return Result; 46007 } 46008 46009 // Pattern: (xor:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 46010 // Emits: (XOR64ri32:i64 GR64:i64:$src1, (imm:i64):$src2) 46011 // Pattern complexity = 7 cost = 1 size = 3 46012 if (Predicate_i64immSExt32(N1.getNode())) { 46013 SDNode *Result = Emit_12(N, X86::XOR64ri32, MVT::i64); 46014 return Result; 46015 } 46016 } 46017 } 46018 46019 // Pattern: (xor:i64 GR64:i64:$src1, GR64:i64:$src2) 46020 // Emits: (XOR64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 46021 // Pattern complexity = 3 cost = 1 size = 3 46022 SDNode *Result = Emit_1(N, X86::XOR64rr, MVT::i64); 46023 return Result; 46024 } 46025 46026 SDNode *Select_ISD_XOR_v1i64(const SDValue &N) { 46027 if (OptLevel != CodeGenOpt::None && 46028 (Subtarget->hasMMX())) { 46029 SDValue N0 = N.getOperand(0); 46030 46031 // Pattern: (xor:v1i64 VR64:v1i64:$src1, (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 46032 // Emits: (MMX_PXORrm:v1i64 VR64:v1i64:$src1, addr:iPTR:$src2) 46033 // Pattern complexity = 25 cost = 1 size = 3 46034 { 46035 SDValue N1 = N.getOperand(1); 46036 if (N1.getOpcode() == ISD::LOAD && 46037 N1.hasOneUse() && 46038 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 46039 SDValue Chain1 = N1.getOperand(0); 46040 if (Predicate_unindexedload(N1.getNode()) && 46041 Predicate_load(N1.getNode())) { 46042 SDValue N11 = N1.getOperand(1); 46043 SDValue CPTmpN11_0; 46044 SDValue CPTmpN11_1; 46045 SDValue CPTmpN11_2; 46046 SDValue CPTmpN11_3; 46047 SDValue CPTmpN11_4; 46048 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 46049 SDNode *Result = Emit_18(N, X86::MMX_PXORrm, MVT::v1i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 46050 return Result; 46051 } 46052 } 46053 } 46054 } 46055 46056 // Pattern: (xor:v1i64 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>, VR64:v1i64:$src1) 46057 // Emits: (MMX_PXORrm:v1i64 VR64:v1i64:$src1, addr:iPTR:$src2) 46058 // Pattern complexity = 25 cost = 1 size = 3 46059 if (N0.getOpcode() == ISD::LOAD && 46060 N0.hasOneUse() && 46061 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 46062 SDValue Chain0 = N0.getOperand(0); 46063 if (Predicate_unindexedload(N0.getNode()) && 46064 Predicate_load(N0.getNode())) { 46065 SDValue N01 = N0.getOperand(1); 46066 SDValue CPTmpN01_0; 46067 SDValue CPTmpN01_1; 46068 SDValue CPTmpN01_2; 46069 SDValue CPTmpN01_3; 46070 SDValue CPTmpN01_4; 46071 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 46072 SDNode *Result = Emit_19(N, X86::MMX_PXORrm, MVT::v1i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 46073 return Result; 46074 } 46075 } 46076 } 46077 } 46078 46079 // Pattern: (xor:v1i64 VR64:v1i64:$src1, VR64:v1i64:$src2) 46080 // Emits: (MMX_PXORrr:v1i64 VR64:v1i64:$src1, VR64:v1i64:$src2) 46081 // Pattern complexity = 3 cost = 1 size = 3 46082 if ((Subtarget->hasMMX())) { 46083 SDNode *Result = Emit_15(N, X86::MMX_PXORrr, MVT::v1i64); 46084 return Result; 46085 } 46086 46087 CannotYetSelect(N); 46088 return NULL; 46089 } 46090 46091 SDNode *Select_ISD_XOR_v2i64(const SDValue &N) { 46092 if (OptLevel != CodeGenOpt::None) { 46093 46094 // Pattern: (xor:v2i64 (bitconvert:v2i64 VR128:v4f32:$src1), (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 46095 // Emits: (XORPSrm:v2i64 VR128:v4f32:$src1, addr:iPTR:$src2) 46096 // Pattern complexity = 28 cost = 1 size = 3 46097 if ((Subtarget->hasSSE1())) { 46098 SDValue N0 = N.getOperand(0); 46099 if (N0.getOpcode() == ISD::BIT_CONVERT) { 46100 SDValue N00 = N0.getOperand(0); 46101 SDValue N1 = N.getOperand(1); 46102 if (N1.getOpcode() == ISD::LOAD && 46103 N1.hasOneUse() && 46104 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 46105 SDValue Chain1 = N1.getOperand(0); 46106 if (Predicate_unindexedload(N1.getNode()) && 46107 Predicate_load(N1.getNode()) && 46108 Predicate_memop(N1.getNode())) { 46109 SDValue N11 = N1.getOperand(1); 46110 SDValue CPTmpN11_0; 46111 SDValue CPTmpN11_1; 46112 SDValue CPTmpN11_2; 46113 SDValue CPTmpN11_3; 46114 SDValue CPTmpN11_4; 46115 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 46116 N00.getNode()->getValueType(0) == MVT::v4f32) { 46117 SDNode *Result = Emit_56(N, X86::XORPSrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 46118 return Result; 46119 } 46120 } 46121 } 46122 } 46123 } 46124 46125 // Pattern: (xor:v2i64 (bitconvert:v2i64 VR128:v2f64:$src1), (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 46126 // Emits: (XORPDrm:v2i64 VR128:v2f64:$src1, addr:iPTR:$src2) 46127 // Pattern complexity = 28 cost = 1 size = 3 46128 if ((Subtarget->hasSSE2())) { 46129 SDValue N0 = N.getOperand(0); 46130 if (N0.getOpcode() == ISD::BIT_CONVERT) { 46131 SDValue N00 = N0.getOperand(0); 46132 SDValue N1 = N.getOperand(1); 46133 if (N1.getOpcode() == ISD::LOAD && 46134 N1.hasOneUse() && 46135 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 46136 SDValue Chain1 = N1.getOperand(0); 46137 if (Predicate_unindexedload(N1.getNode()) && 46138 Predicate_load(N1.getNode()) && 46139 Predicate_memop(N1.getNode())) { 46140 SDValue N11 = N1.getOperand(1); 46141 SDValue CPTmpN11_0; 46142 SDValue CPTmpN11_1; 46143 SDValue CPTmpN11_2; 46144 SDValue CPTmpN11_3; 46145 SDValue CPTmpN11_4; 46146 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 46147 N00.getNode()->getValueType(0) == MVT::v2f64) { 46148 SDNode *Result = Emit_56(N, X86::XORPDrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 46149 return Result; 46150 } 46151 } 46152 } 46153 } 46154 } 46155 46156 // Pattern: (xor:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (bitconvert:v2i64 VR128:v4f32:$src1)) 46157 // Emits: (XORPSrm:v2i64 VR128:v4f32:$src1, addr:iPTR:$src2) 46158 // Pattern complexity = 28 cost = 1 size = 3 46159 if ((Subtarget->hasSSE1())) { 46160 SDValue N0 = N.getOperand(0); 46161 if (N0.getOpcode() == ISD::LOAD && 46162 N0.hasOneUse() && 46163 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 46164 SDValue Chain0 = N0.getOperand(0); 46165 if (Predicate_unindexedload(N0.getNode()) && 46166 Predicate_load(N0.getNode()) && 46167 Predicate_memop(N0.getNode())) { 46168 SDValue N01 = N0.getOperand(1); 46169 SDValue CPTmpN01_0; 46170 SDValue CPTmpN01_1; 46171 SDValue CPTmpN01_2; 46172 SDValue CPTmpN01_3; 46173 SDValue CPTmpN01_4; 46174 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 46175 SDValue N1 = N.getOperand(1); 46176 if (N1.getOpcode() == ISD::BIT_CONVERT) { 46177 SDValue N10 = N1.getOperand(0); 46178 if (N10.getNode()->getValueType(0) == MVT::v4f32) { 46179 SDNode *Result = Emit_61(N, X86::XORPSrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 46180 return Result; 46181 } 46182 } 46183 } 46184 } 46185 } 46186 } 46187 if ((Subtarget->hasSSE2())) { 46188 SDValue N0 = N.getOperand(0); 46189 46190 // Pattern: (xor:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (bitconvert:v2i64 VR128:v2f64:$src1)) 46191 // Emits: (XORPDrm:v2i64 VR128:v2f64:$src1, addr:iPTR:$src2) 46192 // Pattern complexity = 28 cost = 1 size = 3 46193 if (N0.getOpcode() == ISD::LOAD && 46194 N0.hasOneUse() && 46195 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 46196 SDValue Chain0 = N0.getOperand(0); 46197 if (Predicate_unindexedload(N0.getNode()) && 46198 Predicate_load(N0.getNode()) && 46199 Predicate_memop(N0.getNode())) { 46200 SDValue N01 = N0.getOperand(1); 46201 SDValue CPTmpN01_0; 46202 SDValue CPTmpN01_1; 46203 SDValue CPTmpN01_2; 46204 SDValue CPTmpN01_3; 46205 SDValue CPTmpN01_4; 46206 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 46207 SDValue N1 = N.getOperand(1); 46208 if (N1.getOpcode() == ISD::BIT_CONVERT) { 46209 SDValue N10 = N1.getOperand(0); 46210 if (N10.getNode()->getValueType(0) == MVT::v2f64) { 46211 SDNode *Result = Emit_61(N, X86::XORPDrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 46212 return Result; 46213 } 46214 } 46215 } 46216 } 46217 } 46218 46219 // Pattern: (xor:v2i64 VR128:v2i64:$src1, (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 46220 // Emits: (PXORrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 46221 // Pattern complexity = 25 cost = 1 size = 3 46222 { 46223 SDValue N1 = N.getOperand(1); 46224 if (N1.getOpcode() == ISD::LOAD && 46225 N1.hasOneUse() && 46226 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 46227 SDValue Chain1 = N1.getOperand(0); 46228 if (Predicate_unindexedload(N1.getNode()) && 46229 Predicate_load(N1.getNode()) && 46230 Predicate_memop(N1.getNode())) { 46231 SDValue N11 = N1.getOperand(1); 46232 SDValue CPTmpN11_0; 46233 SDValue CPTmpN11_1; 46234 SDValue CPTmpN11_2; 46235 SDValue CPTmpN11_3; 46236 SDValue CPTmpN11_4; 46237 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 46238 SDNode *Result = Emit_18(N, X86::PXORrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 46239 return Result; 46240 } 46241 } 46242 } 46243 } 46244 46245 // Pattern: (xor:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, VR128:v2i64:$src1) 46246 // Emits: (PXORrm:v2i64 VR128:v2i64:$src1, addr:iPTR:$src2) 46247 // Pattern complexity = 25 cost = 1 size = 3 46248 if (N0.getOpcode() == ISD::LOAD && 46249 N0.hasOneUse() && 46250 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 46251 SDValue Chain0 = N0.getOperand(0); 46252 if (Predicate_unindexedload(N0.getNode()) && 46253 Predicate_load(N0.getNode()) && 46254 Predicate_memop(N0.getNode())) { 46255 SDValue N01 = N0.getOperand(1); 46256 SDValue CPTmpN01_0; 46257 SDValue CPTmpN01_1; 46258 SDValue CPTmpN01_2; 46259 SDValue CPTmpN01_3; 46260 SDValue CPTmpN01_4; 46261 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 46262 SDNode *Result = Emit_19(N, X86::PXORrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 46263 return Result; 46264 } 46265 } 46266 } 46267 } 46268 } 46269 46270 // Pattern: (xor:v2i64 (bitconvert:v2i64 VR128:v2f64:$src1), (bitconvert:v2i64 VR128:v2f64:$src2)) 46271 // Emits: (XORPDrr:v2i64 VR128:v2f64:$src1, VR128:v2f64:$src2) 46272 // Pattern complexity = 9 cost = 1 size = 3 46273 if ((Subtarget->hasSSE2())) { 46274 SDValue N0 = N.getOperand(0); 46275 if (N0.getOpcode() == ISD::BIT_CONVERT) { 46276 SDValue N00 = N0.getOperand(0); 46277 SDValue N1 = N.getOperand(1); 46278 if (N1.getOpcode() == ISD::BIT_CONVERT) { 46279 SDValue N10 = N1.getOperand(0); 46280 if (N00.getNode()->getValueType(0) == MVT::v2f64 && 46281 N10.getNode()->getValueType(0) == MVT::v2f64) { 46282 SDNode *Result = Emit_58(N, X86::XORPDrr, MVT::v2i64); 46283 return Result; 46284 } 46285 } 46286 } 46287 } 46288 46289 // Pattern: (xor:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 46290 // Emits: (XORPSrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 46291 // Pattern complexity = 3 cost = 1 size = 3 46292 if ((Subtarget->hasSSE1())) { 46293 SDNode *Result = Emit_15(N, X86::XORPSrr, MVT::v2i64); 46294 return Result; 46295 } 46296 46297 // Pattern: (xor:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 46298 // Emits: (PXORrr:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 46299 // Pattern complexity = 3 cost = 1 size = 3 46300 if ((Subtarget->hasSSE2())) { 46301 SDNode *Result = Emit_15(N, X86::PXORrr, MVT::v2i64); 46302 return Result; 46303 } 46304 46305 CannotYetSelect(N); 46306 return NULL; 46307 } 46308 46309 SDNode *Select_ISD_ZERO_EXTEND_i16(const SDValue &N) { 46310 SDValue N0 = N.getOperand(0); 46311 if (N0.getNode()->getValueType(0) == MVT::i8) { 46312 SDNode *Result = Emit_71(N, X86::MOVZX16rr8, MVT::i16); 46313 return Result; 46314 } 46315 46316 CannotYetSelect(N); 46317 return NULL; 46318 } 46319 46320 SDNode *Emit_251(const SDValue &N, unsigned Opc0, unsigned Opc1, unsigned Opc2, EVT VT0, EVT VT1, EVT VT2) DISABLE_INLINE { 46321 SDValue N0 = N.getOperand(0); 46322 SDValue N00 = N0.getOperand(0); 46323 SDValue N01 = N0.getOperand(1); 46324 SDValue Tmp3 = CurDAG->getTargetConstant(X86::GR16_ABCDRegClassID, MVT::i32); 46325 SDValue Tmp4(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N00, Tmp3), 0); 46326 SDValue Tmp5 = CurDAG->getTargetConstant(0x2ULL, MVT::i32); 46327 SDValue Tmp6(CurDAG->getTargetNode(Opc1, N.getDebugLoc(), VT1, Tmp4, Tmp5), 0); 46328 return CurDAG->SelectNodeTo(N.getNode(), Opc2, VT2, Tmp6); 46329 } 46330 SDNode *Select_ISD_ZERO_EXTEND_i32(const SDValue &N) { 46331 46332 // Pattern: (zext:i32 (srl:i16 GR16:i16:$src, 8:i8)<<P:Predicate_srl_su>>) 46333 // Emits: (MOVZX32rr8:i32 (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i16 GR16:i16:$src, GR16_ABCD:i16), 2:i32)) 46334 // Pattern complexity = 12 cost = 3 size = 3 46335 if ((!Subtarget->is64Bit())) { 46336 SDValue N0 = N.getOperand(0); 46337 if (N0.getOpcode() == ISD::SRL && 46338 Predicate_srl_su(N0.getNode())) { 46339 SDValue N00 = N0.getOperand(0); 46340 SDValue N01 = N0.getOperand(1); 46341 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N01); 46342 if (Tmp0) { 46343 int64_t CN1 = Tmp0->getSExtValue(); 46344 if (CN1 == INT64_C(8) && 46345 N0.getNode()->getValueType(0) == MVT::i16 && 46346 N01.getNode()->getValueType(0) == MVT::i8) { 46347 SDNode *Result = Emit_251(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVZX32rr8, MVT::i16, MVT::i8, MVT::i32); 46348 return Result; 46349 } 46350 } 46351 } 46352 } 46353 46354 // Pattern: (zext:i32 (srl:i16 GR16:i16:$src, 8:i8)<<P:Predicate_srl_su>>) 46355 // Emits: (MOVZX32_NOREXrr8:i32 (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i16 GR16:i16:$src, GR16_ABCD:i16), 2:i32)) 46356 // Pattern complexity = 12 cost = 3 size = 3 46357 if ((Subtarget->is64Bit())) { 46358 SDValue N0 = N.getOperand(0); 46359 if (N0.getOpcode() == ISD::SRL && 46360 Predicate_srl_su(N0.getNode())) { 46361 SDValue N00 = N0.getOperand(0); 46362 SDValue N01 = N0.getOperand(1); 46363 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N01); 46364 if (Tmp0) { 46365 int64_t CN1 = Tmp0->getSExtValue(); 46366 if (CN1 == INT64_C(8) && 46367 N0.getNode()->getValueType(0) == MVT::i16 && 46368 N01.getNode()->getValueType(0) == MVT::i8) { 46369 SDNode *Result = Emit_251(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVZX32_NOREXrr8, MVT::i16, MVT::i8, MVT::i32); 46370 return Result; 46371 } 46372 } 46373 } 46374 } 46375 SDValue N0 = N.getOperand(0); 46376 46377 // Pattern: (zext:i32 GR8:i8:$src) 46378 // Emits: (MOVZX32rr8:i32 GR8:i8:$src) 46379 // Pattern complexity = 3 cost = 1 size = 3 46380 if (N0.getNode()->getValueType(0) == MVT::i8) { 46381 SDNode *Result = Emit_71(N, X86::MOVZX32rr8, MVT::i32); 46382 return Result; 46383 } 46384 46385 // Pattern: (zext:i32 GR16:i16:$src) 46386 // Emits: (MOVZX32rr16:i32 GR16:i16:$src) 46387 // Pattern complexity = 3 cost = 1 size = 3 46388 if (N0.getNode()->getValueType(0) == MVT::i16) { 46389 SDNode *Result = Emit_71(N, X86::MOVZX32rr16, MVT::i32); 46390 return Result; 46391 } 46392 46393 CannotYetSelect(N); 46394 return NULL; 46395 } 46396 46397 SDNode *Emit_252(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 46398 SDValue N0 = N.getOperand(0); 46399 SDValue Tmp0 = CurDAG->getTargetConstant(0x0ULL, MVT::i64); 46400 SDValue Tmp2 = CurDAG->getTargetConstant(0x4ULL, MVT::i32); 46401 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, Tmp0, N0, Tmp2); 46402 } 46403 SDNode *Emit_253(const SDValue &N, unsigned Opc0, unsigned Opc1, unsigned Opc2, unsigned Opc3, EVT VT0, EVT VT1, EVT VT2, EVT VT3) DISABLE_INLINE { 46404 SDValue N0 = N.getOperand(0); 46405 SDValue N00 = N0.getOperand(0); 46406 SDValue N01 = N0.getOperand(1); 46407 SDValue Tmp2 = CurDAG->getTargetConstant(0x0ULL, MVT::i64); 46408 SDValue Tmp4 = CurDAG->getTargetConstant(X86::GR16_ABCDRegClassID, MVT::i32); 46409 SDValue Tmp5(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0, N00, Tmp4), 0); 46410 SDValue Tmp6 = CurDAG->getTargetConstant(0x2ULL, MVT::i32); 46411 SDValue Tmp7(CurDAG->getTargetNode(Opc1, N.getDebugLoc(), VT1, Tmp5, Tmp6), 0); 46412 SDValue Tmp8(CurDAG->getTargetNode(Opc2, N.getDebugLoc(), VT2, Tmp7), 0); 46413 SDValue Tmp9 = CurDAG->getTargetConstant(0x4ULL, MVT::i32); 46414 return CurDAG->SelectNodeTo(N.getNode(), Opc3, VT3, Tmp2, Tmp8, Tmp9); 46415 } 46416 SDNode *Select_ISD_ZERO_EXTEND_i64(const SDValue &N) { 46417 SDValue N0 = N.getOperand(0); 46418 46419 // Pattern: (zext:i64 (srl:i16 GR16:i16:$src, 8:i8)<<P:Predicate_srl_su>>) 46420 // Emits: (SUBREG_TO_REG:i64 0:i64, (MOVZX32_NOREXrr8:i32 (EXTRACT_SUBREG:i8 (COPY_TO_REGCLASS:i16 GR16:i16:$src, GR16_ABCD:i16), 2:i32)), 4:i32) 46421 // Pattern complexity = 12 cost = 4 size = 3 46422 if (N0.getOpcode() == ISD::SRL && 46423 Predicate_srl_su(N0.getNode())) { 46424 SDValue N00 = N0.getOperand(0); 46425 SDValue N01 = N0.getOperand(1); 46426 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N01); 46427 if (Tmp0) { 46428 int64_t CN1 = Tmp0->getSExtValue(); 46429 if (CN1 == INT64_C(8) && 46430 N0.getNode()->getValueType(0) == MVT::i16 && 46431 N01.getNode()->getValueType(0) == MVT::i8) { 46432 SDNode *Result = Emit_253(N, TargetInstrInfo::COPY_TO_REGCLASS, TargetInstrInfo::EXTRACT_SUBREG, X86::MOVZX32_NOREXrr8, TargetInstrInfo::SUBREG_TO_REG, MVT::i16, MVT::i8, MVT::i32, MVT::i64); 46433 return Result; 46434 } 46435 } 46436 } 46437 46438 // Pattern: (zext:i64 GR32:i32<<P:Predicate_def32>>:$src) 46439 // Emits: (SUBREG_TO_REG:i64 0:i64, GR32:i32:$src, 4:i32) 46440 // Pattern complexity = 4 cost = 1 size = 0 46441 if (Predicate_def32(N0.getNode()) && 46442 N0.getNode()->getValueType(0) == MVT::i32) { 46443 SDNode *Result = Emit_252(N, TargetInstrInfo::SUBREG_TO_REG, MVT::i64); 46444 return Result; 46445 } 46446 46447 // Pattern: (zext:i64 GR8:i8:$src) 46448 // Emits: (MOVZX64rr8:i64 GR8:i8:$src) 46449 // Pattern complexity = 3 cost = 1 size = 3 46450 if (N0.getNode()->getValueType(0) == MVT::i8) { 46451 SDNode *Result = Emit_71(N, X86::MOVZX64rr8, MVT::i64); 46452 return Result; 46453 } 46454 46455 // Pattern: (zext:i64 GR16:i16:$src) 46456 // Emits: (MOVZX64rr16:i64 GR16:i16:$src) 46457 // Pattern complexity = 3 cost = 1 size = 3 46458 if (N0.getNode()->getValueType(0) == MVT::i16) { 46459 SDNode *Result = Emit_71(N, X86::MOVZX64rr16, MVT::i64); 46460 return Result; 46461 } 46462 46463 // Pattern: (zext:i64 GR32:i32:$src) 46464 // Emits: (MOVZX64rr32:i64 GR32:i32:$src) 46465 // Pattern complexity = 3 cost = 1 size = 3 46466 if (N0.getNode()->getValueType(0) == MVT::i32) { 46467 SDNode *Result = Emit_71(N, X86::MOVZX64rr32, MVT::i64); 46468 return Result; 46469 } 46470 46471 CannotYetSelect(N); 46472 return NULL; 46473 } 46474 46475 SDNode *Select_X86ISD_ADD_i8(const SDValue &N) { 46476 46477 // Pattern: (X86add_flag:i8 GR8:i8:$src1, (ld:i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>) 46478 // Emits: (ADD8rm:i8 GR8:i8:$src1, addr:iPTR:$src2) 46479 // Pattern complexity = 25 cost = 1 size = 3 46480 if (OptLevel != CodeGenOpt::None) { 46481 SDValue N0 = N.getOperand(0); 46482 SDValue N1 = N.getOperand(1); 46483 if (N1.getOpcode() == ISD::LOAD && 46484 N1.hasOneUse() && 46485 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 46486 SDValue Chain1 = N1.getOperand(0); 46487 if (Predicate_unindexedload(N1.getNode()) && 46488 Predicate_load(N1.getNode()) && 46489 Predicate_loadi8(N1.getNode())) { 46490 SDValue N11 = N1.getOperand(1); 46491 SDValue CPTmpN11_0; 46492 SDValue CPTmpN11_1; 46493 SDValue CPTmpN11_2; 46494 SDValue CPTmpN11_3; 46495 SDValue CPTmpN11_4; 46496 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 46497 SDNode *Result = Emit_2(N, X86::ADD8rm, MVT::i8, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 46498 return Result; 46499 } 46500 } 46501 } 46502 } 46503 46504 // Pattern: (X86add_flag:i8 GR8:i8:$src1, (imm:i8):$src2) 46505 // Emits: (ADD8ri:i8 GR8:i8:$src1, (imm:i8):$src2) 46506 // Pattern complexity = 6 cost = 1 size = 3 46507 { 46508 SDValue N0 = N.getOperand(0); 46509 SDValue N1 = N.getOperand(1); 46510 if (N1.getOpcode() == ISD::Constant) { 46511 SDNode *Result = Emit_3(N, X86::ADD8ri, MVT::i8); 46512 return Result; 46513 } 46514 } 46515 46516 // Pattern: (X86add_flag:i8 GR8:i8:$src1, GR8:i8:$src2) 46517 // Emits: (ADD8rr:i8 GR8:i8:$src1, GR8:i8:$src2) 46518 // Pattern complexity = 3 cost = 1 size = 3 46519 SDNode *Result = Emit_1(N, X86::ADD8rr, MVT::i8); 46520 return Result; 46521 } 46522 46523 SDNode *Select_X86ISD_ADD_i16(const SDValue &N) { 46524 46525 // Pattern: (X86add_flag:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>) 46526 // Emits: (ADD16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 46527 // Pattern complexity = 25 cost = 1 size = 3 46528 if (OptLevel != CodeGenOpt::None) { 46529 SDValue N0 = N.getOperand(0); 46530 SDValue N1 = N.getOperand(1); 46531 if (N1.getOpcode() == ISD::LOAD && 46532 N1.hasOneUse() && 46533 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 46534 SDValue Chain1 = N1.getOperand(0); 46535 if (Predicate_unindexedload(N1.getNode()) && 46536 Predicate_loadi16(N1.getNode())) { 46537 SDValue N11 = N1.getOperand(1); 46538 SDValue CPTmpN11_0; 46539 SDValue CPTmpN11_1; 46540 SDValue CPTmpN11_2; 46541 SDValue CPTmpN11_3; 46542 SDValue CPTmpN11_4; 46543 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 46544 SDNode *Result = Emit_2(N, X86::ADD16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 46545 return Result; 46546 } 46547 } 46548 } 46549 } 46550 { 46551 SDValue N0 = N.getOperand(0); 46552 SDValue N1 = N.getOperand(1); 46553 if (N1.getOpcode() == ISD::Constant) { 46554 46555 // Pattern: (X86add_flag:i16 GR16:i16:$src1, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 46556 // Emits: (ADD16ri8:i16 GR16:i16:$src1, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 46557 // Pattern complexity = 7 cost = 1 size = 3 46558 if (Predicate_i16immSExt8(N1.getNode())) { 46559 SDNode *Result = Emit_5(N, X86::ADD16ri8, MVT::i16); 46560 return Result; 46561 } 46562 46563 // Pattern: (X86add_flag:i16 GR16:i16:$src1, (imm:i16):$src2) 46564 // Emits: (ADD16ri:i16 GR16:i16:$src1, (imm:i16):$src2) 46565 // Pattern complexity = 6 cost = 1 size = 3 46566 SDNode *Result = Emit_5(N, X86::ADD16ri, MVT::i16); 46567 return Result; 46568 } 46569 } 46570 46571 // Pattern: (X86add_flag:i16 GR16:i16:$src1, GR16:i16:$src2) 46572 // Emits: (ADD16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 46573 // Pattern complexity = 3 cost = 1 size = 3 46574 SDNode *Result = Emit_1(N, X86::ADD16rr, MVT::i16); 46575 return Result; 46576 } 46577 46578 SDNode *Select_X86ISD_ADD_i32(const SDValue &N) { 46579 46580 // Pattern: (X86add_flag:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>) 46581 // Emits: (ADD32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 46582 // Pattern complexity = 25 cost = 1 size = 3 46583 if (OptLevel != CodeGenOpt::None) { 46584 SDValue N0 = N.getOperand(0); 46585 SDValue N1 = N.getOperand(1); 46586 if (N1.getOpcode() == ISD::LOAD && 46587 N1.hasOneUse() && 46588 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 46589 SDValue Chain1 = N1.getOperand(0); 46590 if (Predicate_unindexedload(N1.getNode()) && 46591 Predicate_loadi32(N1.getNode())) { 46592 SDValue N11 = N1.getOperand(1); 46593 SDValue CPTmpN11_0; 46594 SDValue CPTmpN11_1; 46595 SDValue CPTmpN11_2; 46596 SDValue CPTmpN11_3; 46597 SDValue CPTmpN11_4; 46598 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 46599 SDNode *Result = Emit_2(N, X86::ADD32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 46600 return Result; 46601 } 46602 } 46603 } 46604 } 46605 { 46606 SDValue N0 = N.getOperand(0); 46607 SDValue N1 = N.getOperand(1); 46608 if (N1.getOpcode() == ISD::Constant) { 46609 46610 // Pattern: (X86add_flag:i32 GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 46611 // Emits: (ADD32ri8:i32 GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 46612 // Pattern complexity = 7 cost = 1 size = 3 46613 if (Predicate_i32immSExt8(N1.getNode())) { 46614 SDNode *Result = Emit_8(N, X86::ADD32ri8, MVT::i32); 46615 return Result; 46616 } 46617 46618 // Pattern: (X86add_flag:i32 GR32:i32:$src1, (imm:i32):$src2) 46619 // Emits: (ADD32ri:i32 GR32:i32:$src1, (imm:i32):$src2) 46620 // Pattern complexity = 6 cost = 1 size = 3 46621 SDNode *Result = Emit_8(N, X86::ADD32ri, MVT::i32); 46622 return Result; 46623 } 46624 } 46625 46626 // Pattern: (X86add_flag:i32 GR32:i32:$src1, GR32:i32:$src2) 46627 // Emits: (ADD32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 46628 // Pattern complexity = 3 cost = 1 size = 3 46629 SDNode *Result = Emit_1(N, X86::ADD32rr, MVT::i32); 46630 return Result; 46631 } 46632 46633 SDNode *Select_X86ISD_ADD_i64(const SDValue &N) { 46634 46635 // Pattern: (X86add_flag:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>) 46636 // Emits: (ADD64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 46637 // Pattern complexity = 25 cost = 1 size = 3 46638 if (OptLevel != CodeGenOpt::None) { 46639 SDValue N0 = N.getOperand(0); 46640 SDValue N1 = N.getOperand(1); 46641 if (N1.getOpcode() == ISD::LOAD && 46642 N1.hasOneUse() && 46643 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 46644 SDValue Chain1 = N1.getOperand(0); 46645 if (Predicate_unindexedload(N1.getNode()) && 46646 Predicate_load(N1.getNode()) && 46647 Predicate_loadi64(N1.getNode())) { 46648 SDValue N11 = N1.getOperand(1); 46649 SDValue CPTmpN11_0; 46650 SDValue CPTmpN11_1; 46651 SDValue CPTmpN11_2; 46652 SDValue CPTmpN11_3; 46653 SDValue CPTmpN11_4; 46654 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 46655 SDNode *Result = Emit_2(N, X86::ADD64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 46656 return Result; 46657 } 46658 } 46659 } 46660 } 46661 { 46662 SDValue N0 = N.getOperand(0); 46663 SDValue N1 = N.getOperand(1); 46664 if (N1.getOpcode() == ISD::Constant) { 46665 46666 // Pattern: (X86add_flag:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 46667 // Emits: (ADD64ri8:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 46668 // Pattern complexity = 7 cost = 1 size = 3 46669 if (Predicate_i64immSExt8(N1.getNode())) { 46670 SDNode *Result = Emit_12(N, X86::ADD64ri8, MVT::i64); 46671 return Result; 46672 } 46673 46674 // Pattern: (X86add_flag:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 46675 // Emits: (ADD64ri32:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 46676 // Pattern complexity = 7 cost = 1 size = 3 46677 if (Predicate_i64immSExt32(N1.getNode())) { 46678 SDNode *Result = Emit_12(N, X86::ADD64ri32, MVT::i64); 46679 return Result; 46680 } 46681 } 46682 } 46683 46684 // Pattern: (X86add_flag:i64 GR64:i64:$src1, GR64:i64:$src2) 46685 // Emits: (ADD64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 46686 // Pattern complexity = 3 cost = 1 size = 3 46687 SDNode *Result = Emit_1(N, X86::ADD64rr, MVT::i64); 46688 return Result; 46689 } 46690 46691 SDNode *Emit_254(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 46692 SDValue Chain = N.getOperand(0); 46693 SDValue N1 = N.getOperand(1); 46694 SDValue N2 = N.getOperand(2); 46695 SDValue N3 = N.getOperand(3); 46696 SDValue InFlag(0, 0); 46697 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::EFLAGS, N3, InFlag).getNode(); 46698 Chain = SDValue(ResNode, 0); 46699 InFlag = SDValue(ResNode, 1); 46700 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, N1, Chain, InFlag); 46701 } 46702 SDNode *Select_X86ISD_BRCOND(const SDValue &N) { 46703 SDValue Chain = N.getOperand(0); 46704 SDValue N1 = N.getOperand(1); 46705 if (N1.getOpcode() == ISD::BasicBlock) { 46706 SDValue N2 = N.getOperand(2); 46707 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N2); 46708 if (Tmp0) { 46709 int64_t CN1 = Tmp0->getSExtValue(); 46710 46711 // Pattern: (X86brcond:isVoid (bb:Other):$dst, 4:i8, EFLAGS:i32) 46712 // Emits: (JE:isVoid (bb:Other):$dst) 46713 // Pattern complexity = 8 cost = 1 size = 3 46714 if (CN1 == INT64_C(4)) { 46715 SDNode *Result = Emit_254(N, X86::JE); 46716 return Result; 46717 } 46718 46719 // Pattern: (X86brcond:isVoid (bb:Other):$dst, 9:i8, EFLAGS:i32) 46720 // Emits: (JNE:isVoid (bb:Other):$dst) 46721 // Pattern complexity = 8 cost = 1 size = 3 46722 if (CN1 == INT64_C(9)) { 46723 SDNode *Result = Emit_254(N, X86::JNE); 46724 return Result; 46725 } 46726 46727 // Pattern: (X86brcond:isVoid (bb:Other):$dst, 7:i8, EFLAGS:i32) 46728 // Emits: (JL:isVoid (bb:Other):$dst) 46729 // Pattern complexity = 8 cost = 1 size = 3 46730 if (CN1 == INT64_C(7)) { 46731 SDNode *Result = Emit_254(N, X86::JL); 46732 return Result; 46733 } 46734 46735 // Pattern: (X86brcond:isVoid (bb:Other):$dst, 8:i8, EFLAGS:i32) 46736 // Emits: (JLE:isVoid (bb:Other):$dst) 46737 // Pattern complexity = 8 cost = 1 size = 3 46738 if (CN1 == INT64_C(8)) { 46739 SDNode *Result = Emit_254(N, X86::JLE); 46740 return Result; 46741 } 46742 46743 // Pattern: (X86brcond:isVoid (bb:Other):$dst, 5:i8, EFLAGS:i32) 46744 // Emits: (JG:isVoid (bb:Other):$dst) 46745 // Pattern complexity = 8 cost = 1 size = 3 46746 if (CN1 == INT64_C(5)) { 46747 SDNode *Result = Emit_254(N, X86::JG); 46748 return Result; 46749 } 46750 46751 // Pattern: (X86brcond:isVoid (bb:Other):$dst, 6:i8, EFLAGS:i32) 46752 // Emits: (JGE:isVoid (bb:Other):$dst) 46753 // Pattern complexity = 8 cost = 1 size = 3 46754 if (CN1 == INT64_C(6)) { 46755 SDNode *Result = Emit_254(N, X86::JGE); 46756 return Result; 46757 } 46758 46759 // Pattern: (X86brcond:isVoid (bb:Other):$dst, 2:i8, EFLAGS:i32) 46760 // Emits: (JB:isVoid (bb:Other):$dst) 46761 // Pattern complexity = 8 cost = 1 size = 3 46762 if (CN1 == INT64_C(2)) { 46763 SDNode *Result = Emit_254(N, X86::JB); 46764 return Result; 46765 } 46766 46767 // Pattern: (X86brcond:isVoid (bb:Other):$dst, 3:i8, EFLAGS:i32) 46768 // Emits: (JBE:isVoid (bb:Other):$dst) 46769 // Pattern complexity = 8 cost = 1 size = 3 46770 if (CN1 == INT64_C(3)) { 46771 SDNode *Result = Emit_254(N, X86::JBE); 46772 return Result; 46773 } 46774 46775 // Pattern: (X86brcond:isVoid (bb:Other):$dst, 0:i8, EFLAGS:i32) 46776 // Emits: (JA:isVoid (bb:Other):$dst) 46777 // Pattern complexity = 8 cost = 1 size = 3 46778 if (CN1 == INT64_C(0)) { 46779 SDNode *Result = Emit_254(N, X86::JA); 46780 return Result; 46781 } 46782 46783 // Pattern: (X86brcond:isVoid (bb:Other):$dst, 1:i8, EFLAGS:i32) 46784 // Emits: (JAE:isVoid (bb:Other):$dst) 46785 // Pattern complexity = 8 cost = 1 size = 3 46786 if (CN1 == INT64_C(1)) { 46787 SDNode *Result = Emit_254(N, X86::JAE); 46788 return Result; 46789 } 46790 46791 // Pattern: (X86brcond:isVoid (bb:Other):$dst, 15:i8, EFLAGS:i32) 46792 // Emits: (JS:isVoid (bb:Other):$dst) 46793 // Pattern complexity = 8 cost = 1 size = 3 46794 if (CN1 == INT64_C(15)) { 46795 SDNode *Result = Emit_254(N, X86::JS); 46796 return Result; 46797 } 46798 46799 // Pattern: (X86brcond:isVoid (bb:Other):$dst, 12:i8, EFLAGS:i32) 46800 // Emits: (JNS:isVoid (bb:Other):$dst) 46801 // Pattern complexity = 8 cost = 1 size = 3 46802 if (CN1 == INT64_C(12)) { 46803 SDNode *Result = Emit_254(N, X86::JNS); 46804 return Result; 46805 } 46806 46807 // Pattern: (X86brcond:isVoid (bb:Other):$dst, 14:i8, EFLAGS:i32) 46808 // Emits: (JP:isVoid (bb:Other):$dst) 46809 // Pattern complexity = 8 cost = 1 size = 3 46810 if (CN1 == INT64_C(14)) { 46811 SDNode *Result = Emit_254(N, X86::JP); 46812 return Result; 46813 } 46814 46815 // Pattern: (X86brcond:isVoid (bb:Other):$dst, 11:i8, EFLAGS:i32) 46816 // Emits: (JNP:isVoid (bb:Other):$dst) 46817 // Pattern complexity = 8 cost = 1 size = 3 46818 if (CN1 == INT64_C(11)) { 46819 SDNode *Result = Emit_254(N, X86::JNP); 46820 return Result; 46821 } 46822 46823 // Pattern: (X86brcond:isVoid (bb:Other):$dst, 13:i8, EFLAGS:i32) 46824 // Emits: (JO:isVoid (bb:Other):$dst) 46825 // Pattern complexity = 8 cost = 1 size = 3 46826 if (CN1 == INT64_C(13)) { 46827 SDNode *Result = Emit_254(N, X86::JO); 46828 return Result; 46829 } 46830 46831 // Pattern: (X86brcond:isVoid (bb:Other):$dst, 10:i8, EFLAGS:i32) 46832 // Emits: (JNO:isVoid (bb:Other):$dst) 46833 // Pattern complexity = 8 cost = 1 size = 3 46834 if (CN1 == INT64_C(10)) { 46835 SDNode *Result = Emit_254(N, X86::JNO); 46836 return Result; 46837 } 46838 } 46839 } 46840 46841 CannotYetSelect(N); 46842 return NULL; 46843 } 46844 46845 SDNode *Emit_255(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 46846 SDValue N0 = N.getOperand(0); 46847 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::i32, N0); 46848 } 46849 SDNode *Emit_256(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 46850 SDValue N0 = N.getOperand(0); 46851 SDValue Chain0 = N0.getOperand(0); 46852 SDValue N01 = N0.getOperand(1); 46853 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 46854 SDValue Ops0[] = { CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, LSI_N0, Chain0 }; 46855 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::i32, MVT::Other, Ops0, 7); 46856 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 2)); 46857 return ResNode; 46858 } 46859 SDNode *Select_X86ISD_BSF_i16(const SDValue &N) { 46860 46861 // Pattern: (X86bsf:i16 (ld:i16 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>) 46862 // Emits: (BSF16rm:i16 addr:iPTR:$src) 46863 // Pattern complexity = 25 cost = 1 size = 3 46864 if (OptLevel != CodeGenOpt::None) { 46865 SDValue N0 = N.getOperand(0); 46866 if (N0.getOpcode() == ISD::LOAD && 46867 N0.hasOneUse()) { 46868 SDValue Chain0 = N0.getOperand(0); 46869 if (Predicate_unindexedload(N0.getNode()) && 46870 Predicate_loadi16(N0.getNode())) { 46871 SDValue N01 = N0.getOperand(1); 46872 SDValue CPTmpN01_0; 46873 SDValue CPTmpN01_1; 46874 SDValue CPTmpN01_2; 46875 SDValue CPTmpN01_3; 46876 SDValue CPTmpN01_4; 46877 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 46878 SDNode *Result = Emit_256(N, X86::BSF16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 46879 return Result; 46880 } 46881 } 46882 } 46883 } 46884 46885 // Pattern: (X86bsf:i16 GR16:i16:$src) 46886 // Emits: (BSF16rr:i16 GR16:i16:$src) 46887 // Pattern complexity = 3 cost = 1 size = 3 46888 SDNode *Result = Emit_255(N, X86::BSF16rr, MVT::i16); 46889 return Result; 46890 } 46891 46892 SDNode *Select_X86ISD_BSF_i32(const SDValue &N) { 46893 46894 // Pattern: (X86bsf:i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>) 46895 // Emits: (BSF32rm:i32 addr:iPTR:$src) 46896 // Pattern complexity = 25 cost = 1 size = 3 46897 if (OptLevel != CodeGenOpt::None) { 46898 SDValue N0 = N.getOperand(0); 46899 if (N0.getOpcode() == ISD::LOAD && 46900 N0.hasOneUse()) { 46901 SDValue Chain0 = N0.getOperand(0); 46902 if (Predicate_unindexedload(N0.getNode()) && 46903 Predicate_loadi32(N0.getNode())) { 46904 SDValue N01 = N0.getOperand(1); 46905 SDValue CPTmpN01_0; 46906 SDValue CPTmpN01_1; 46907 SDValue CPTmpN01_2; 46908 SDValue CPTmpN01_3; 46909 SDValue CPTmpN01_4; 46910 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 46911 SDNode *Result = Emit_256(N, X86::BSF32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 46912 return Result; 46913 } 46914 } 46915 } 46916 } 46917 46918 // Pattern: (X86bsf:i32 GR32:i32:$src) 46919 // Emits: (BSF32rr:i32 GR32:i32:$src) 46920 // Pattern complexity = 3 cost = 1 size = 3 46921 SDNode *Result = Emit_255(N, X86::BSF32rr, MVT::i32); 46922 return Result; 46923 } 46924 46925 SDNode *Select_X86ISD_BSF_i64(const SDValue &N) { 46926 46927 // Pattern: (X86bsf:i64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>) 46928 // Emits: (BSF64rm:i64 addr:iPTR:$src) 46929 // Pattern complexity = 25 cost = 1 size = 3 46930 if (OptLevel != CodeGenOpt::None) { 46931 SDValue N0 = N.getOperand(0); 46932 if (N0.getOpcode() == ISD::LOAD && 46933 N0.hasOneUse()) { 46934 SDValue Chain0 = N0.getOperand(0); 46935 if (Predicate_unindexedload(N0.getNode()) && 46936 Predicate_load(N0.getNode()) && 46937 Predicate_loadi64(N0.getNode())) { 46938 SDValue N01 = N0.getOperand(1); 46939 SDValue CPTmpN01_0; 46940 SDValue CPTmpN01_1; 46941 SDValue CPTmpN01_2; 46942 SDValue CPTmpN01_3; 46943 SDValue CPTmpN01_4; 46944 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 46945 SDNode *Result = Emit_256(N, X86::BSF64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 46946 return Result; 46947 } 46948 } 46949 } 46950 } 46951 46952 // Pattern: (X86bsf:i64 GR64:i64:$src) 46953 // Emits: (BSF64rr:i64 GR64:i64:$src) 46954 // Pattern complexity = 3 cost = 1 size = 3 46955 SDNode *Result = Emit_255(N, X86::BSF64rr, MVT::i64); 46956 return Result; 46957 } 46958 46959 SDNode *Select_X86ISD_BSR_i16(const SDValue &N) { 46960 46961 // Pattern: (X86bsr:i16 (ld:i16 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>) 46962 // Emits: (BSR16rm:i16 addr:iPTR:$src) 46963 // Pattern complexity = 25 cost = 1 size = 3 46964 if (OptLevel != CodeGenOpt::None) { 46965 SDValue N0 = N.getOperand(0); 46966 if (N0.getOpcode() == ISD::LOAD && 46967 N0.hasOneUse()) { 46968 SDValue Chain0 = N0.getOperand(0); 46969 if (Predicate_unindexedload(N0.getNode()) && 46970 Predicate_loadi16(N0.getNode())) { 46971 SDValue N01 = N0.getOperand(1); 46972 SDValue CPTmpN01_0; 46973 SDValue CPTmpN01_1; 46974 SDValue CPTmpN01_2; 46975 SDValue CPTmpN01_3; 46976 SDValue CPTmpN01_4; 46977 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 46978 SDNode *Result = Emit_256(N, X86::BSR16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 46979 return Result; 46980 } 46981 } 46982 } 46983 } 46984 46985 // Pattern: (X86bsr:i16 GR16:i16:$src) 46986 // Emits: (BSR16rr:i16 GR16:i16:$src) 46987 // Pattern complexity = 3 cost = 1 size = 3 46988 SDNode *Result = Emit_255(N, X86::BSR16rr, MVT::i16); 46989 return Result; 46990 } 46991 46992 SDNode *Select_X86ISD_BSR_i32(const SDValue &N) { 46993 46994 // Pattern: (X86bsr:i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>) 46995 // Emits: (BSR32rm:i32 addr:iPTR:$src) 46996 // Pattern complexity = 25 cost = 1 size = 3 46997 if (OptLevel != CodeGenOpt::None) { 46998 SDValue N0 = N.getOperand(0); 46999 if (N0.getOpcode() == ISD::LOAD && 47000 N0.hasOneUse()) { 47001 SDValue Chain0 = N0.getOperand(0); 47002 if (Predicate_unindexedload(N0.getNode()) && 47003 Predicate_loadi32(N0.getNode())) { 47004 SDValue N01 = N0.getOperand(1); 47005 SDValue CPTmpN01_0; 47006 SDValue CPTmpN01_1; 47007 SDValue CPTmpN01_2; 47008 SDValue CPTmpN01_3; 47009 SDValue CPTmpN01_4; 47010 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 47011 SDNode *Result = Emit_256(N, X86::BSR32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47012 return Result; 47013 } 47014 } 47015 } 47016 } 47017 47018 // Pattern: (X86bsr:i32 GR32:i32:$src) 47019 // Emits: (BSR32rr:i32 GR32:i32:$src) 47020 // Pattern complexity = 3 cost = 1 size = 3 47021 SDNode *Result = Emit_255(N, X86::BSR32rr, MVT::i32); 47022 return Result; 47023 } 47024 47025 SDNode *Select_X86ISD_BSR_i64(const SDValue &N) { 47026 47027 // Pattern: (X86bsr:i64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>) 47028 // Emits: (BSR64rm:i64 addr:iPTR:$src) 47029 // Pattern complexity = 25 cost = 1 size = 3 47030 if (OptLevel != CodeGenOpt::None) { 47031 SDValue N0 = N.getOperand(0); 47032 if (N0.getOpcode() == ISD::LOAD && 47033 N0.hasOneUse()) { 47034 SDValue Chain0 = N0.getOperand(0); 47035 if (Predicate_unindexedload(N0.getNode()) && 47036 Predicate_load(N0.getNode()) && 47037 Predicate_loadi64(N0.getNode())) { 47038 SDValue N01 = N0.getOperand(1); 47039 SDValue CPTmpN01_0; 47040 SDValue CPTmpN01_1; 47041 SDValue CPTmpN01_2; 47042 SDValue CPTmpN01_3; 47043 SDValue CPTmpN01_4; 47044 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 47045 SDNode *Result = Emit_256(N, X86::BSR64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47046 return Result; 47047 } 47048 } 47049 } 47050 } 47051 47052 // Pattern: (X86bsr:i64 GR64:i64:$src) 47053 // Emits: (BSR64rr:i64 GR64:i64:$src) 47054 // Pattern complexity = 3 cost = 1 size = 3 47055 SDNode *Result = Emit_255(N, X86::BSR64rr, MVT::i64); 47056 return Result; 47057 } 47058 47059 SDNode *Emit_257(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 47060 SDValue N0 = N.getOperand(0); 47061 SDValue N1 = N.getOperand(1); 47062 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, N0, N1); 47063 } 47064 SDNode *Emit_258(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 47065 SDValue N0 = N.getOperand(0); 47066 SDValue N1 = N.getOperand(1); 47067 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned short) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i16); 47068 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, N0, Tmp1); 47069 } 47070 SDNode *Emit_259(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 47071 SDValue N0 = N.getOperand(0); 47072 SDValue N1 = N.getOperand(1); 47073 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i32); 47074 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, N0, Tmp1); 47075 } 47076 SDNode *Emit_260(const SDValue &N, unsigned Opc0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 47077 SDValue N0 = N.getOperand(0); 47078 SDValue Chain0 = N0.getOperand(0); 47079 SDValue N01 = N0.getOperand(1); 47080 SDValue N1 = N.getOperand(1); 47081 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned short) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i16); 47082 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 47083 SDValue Ops0[] = { CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, Tmp1, LSI_N0, Chain0 }; 47084 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 8); 47085 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 47086 return ResNode; 47087 } 47088 SDNode *Emit_261(const SDValue &N, unsigned Opc0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 47089 SDValue N0 = N.getOperand(0); 47090 SDValue Chain0 = N0.getOperand(0); 47091 SDValue N01 = N0.getOperand(1); 47092 SDValue N1 = N.getOperand(1); 47093 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i32); 47094 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 47095 SDValue Ops0[] = { CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, Tmp1, LSI_N0, Chain0 }; 47096 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 8); 47097 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 47098 return ResNode; 47099 } 47100 SDNode *Emit_262(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 47101 SDValue N0 = N.getOperand(0); 47102 SDValue N1 = N.getOperand(1); 47103 SDValue Tmp1 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i64); 47104 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, N0, Tmp1); 47105 } 47106 SDNode *Emit_263(const SDValue &N, unsigned Opc0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 47107 SDValue N0 = N.getOperand(0); 47108 SDValue Chain0 = N0.getOperand(0); 47109 SDValue N01 = N0.getOperand(1); 47110 SDValue N1 = N.getOperand(1); 47111 SDValue Tmp1 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i64); 47112 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 47113 SDValue Ops0[] = { CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, Tmp1, LSI_N0, Chain0 }; 47114 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 8); 47115 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 47116 return ResNode; 47117 } 47118 SDNode *Select_X86ISD_BT(const SDValue &N) { 47119 if (OptLevel != CodeGenOpt::None) { 47120 SDValue N0 = N.getOperand(0); 47121 if (N0.getOpcode() == ISD::LOAD && 47122 N0.hasOneUse() && 47123 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 47124 SDValue Chain0 = N0.getOperand(0); 47125 if (Predicate_unindexedload(N0.getNode())) { 47126 47127 // Pattern: (X86bt:isVoid (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 47128 // Emits: (BT16mi8:isVoid addr:iPTR:$src1, (imm:i16):$src2) 47129 // Pattern complexity = 29 cost = 1 size = 3 47130 if (Predicate_loadi16(N0.getNode())) { 47131 SDValue N01 = N0.getOperand(1); 47132 SDValue CPTmpN01_0; 47133 SDValue CPTmpN01_1; 47134 SDValue CPTmpN01_2; 47135 SDValue CPTmpN01_3; 47136 SDValue CPTmpN01_4; 47137 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 47138 SDValue N1 = N.getOperand(1); 47139 if (N1.getOpcode() == ISD::Constant && 47140 Predicate_i16immSExt8(N1.getNode()) && 47141 N0.getNode()->getValueType(0) == MVT::i16) { 47142 SDNode *Result = Emit_260(N, X86::BT16mi8, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47143 return Result; 47144 } 47145 } 47146 } 47147 47148 // Pattern: (X86bt:isVoid (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 47149 // Emits: (BT32mi8:isVoid addr:iPTR:$src1, (imm:i32):$src2) 47150 // Pattern complexity = 29 cost = 1 size = 3 47151 if (Predicate_loadi32(N0.getNode())) { 47152 SDValue N01 = N0.getOperand(1); 47153 SDValue CPTmpN01_0; 47154 SDValue CPTmpN01_1; 47155 SDValue CPTmpN01_2; 47156 SDValue CPTmpN01_3; 47157 SDValue CPTmpN01_4; 47158 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 47159 SDValue N1 = N.getOperand(1); 47160 if (N1.getOpcode() == ISD::Constant && 47161 Predicate_i32immSExt8(N1.getNode()) && 47162 N0.getNode()->getValueType(0) == MVT::i32) { 47163 SDNode *Result = Emit_261(N, X86::BT32mi8, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47164 return Result; 47165 } 47166 } 47167 } 47168 47169 // Pattern: (X86bt:isVoid (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 47170 // Emits: (BT64mi8:isVoid addr:iPTR:$src1, (imm:i64):$src2) 47171 // Pattern complexity = 29 cost = 1 size = 3 47172 if (Predicate_load(N0.getNode()) && 47173 Predicate_loadi64(N0.getNode())) { 47174 SDValue N01 = N0.getOperand(1); 47175 SDValue CPTmpN01_0; 47176 SDValue CPTmpN01_1; 47177 SDValue CPTmpN01_2; 47178 SDValue CPTmpN01_3; 47179 SDValue CPTmpN01_4; 47180 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 47181 SDValue N1 = N.getOperand(1); 47182 if (N1.getOpcode() == ISD::Constant && 47183 Predicate_i64immSExt8(N1.getNode()) && 47184 N0.getNode()->getValueType(0) == MVT::i64) { 47185 SDNode *Result = Emit_263(N, X86::BT64mi8, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47186 return Result; 47187 } 47188 } 47189 } 47190 } 47191 } 47192 } 47193 SDValue N0 = N.getOperand(0); 47194 SDValue N1 = N.getOperand(1); 47195 if (N1.getOpcode() == ISD::Constant) { 47196 47197 // Pattern: (X86bt:isVoid GR16:i16:$src1, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 47198 // Emits: (BT16ri8:isVoid GR16:i16:$src1, (imm:i16):$src2) 47199 // Pattern complexity = 7 cost = 1 size = 3 47200 if (Predicate_i16immSExt8(N1.getNode()) && 47201 N0.getNode()->getValueType(0) == MVT::i16) { 47202 SDNode *Result = Emit_258(N, X86::BT16ri8); 47203 return Result; 47204 } 47205 47206 // Pattern: (X86bt:isVoid GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 47207 // Emits: (BT32ri8:isVoid GR32:i32:$src1, (imm:i32):$src2) 47208 // Pattern complexity = 7 cost = 1 size = 3 47209 if (Predicate_i32immSExt8(N1.getNode()) && 47210 N0.getNode()->getValueType(0) == MVT::i32) { 47211 SDNode *Result = Emit_259(N, X86::BT32ri8); 47212 return Result; 47213 } 47214 47215 // Pattern: (X86bt:isVoid GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 47216 // Emits: (BT64ri8:isVoid GR64:i64:$src1, (imm:i64):$src2) 47217 // Pattern complexity = 7 cost = 1 size = 3 47218 if (Predicate_i64immSExt8(N1.getNode()) && 47219 N0.getNode()->getValueType(0) == MVT::i64) { 47220 SDNode *Result = Emit_262(N, X86::BT64ri8); 47221 return Result; 47222 } 47223 } 47224 47225 // Pattern: (X86bt:isVoid GR16:i16:$src1, GR16:i16:$src2) 47226 // Emits: (BT16rr:isVoid GR16:i16:$src1, GR16:i16:$src2) 47227 // Pattern complexity = 3 cost = 1 size = 3 47228 if (N0.getNode()->getValueType(0) == MVT::i16) { 47229 SDNode *Result = Emit_257(N, X86::BT16rr); 47230 return Result; 47231 } 47232 47233 // Pattern: (X86bt:isVoid GR32:i32:$src1, GR32:i32:$src2) 47234 // Emits: (BT32rr:isVoid GR32:i32:$src1, GR32:i32:$src2) 47235 // Pattern complexity = 3 cost = 1 size = 3 47236 if (N0.getNode()->getValueType(0) == MVT::i32) { 47237 SDNode *Result = Emit_257(N, X86::BT32rr); 47238 return Result; 47239 } 47240 47241 // Pattern: (X86bt:isVoid GR64:i64:$src1, GR64:i64:$src2) 47242 // Emits: (BT64rr:isVoid GR64:i64:$src1, GR64:i64:$src2) 47243 // Pattern complexity = 3 cost = 1 size = 3 47244 if (N0.getNode()->getValueType(0) == MVT::i64) { 47245 SDNode *Result = Emit_257(N, X86::BT64rr); 47246 return Result; 47247 } 47248 47249 CannotYetSelect(N); 47250 return NULL; 47251 } 47252 47253 SDNode *Emit_264(const SDValue &N, unsigned Opc0, unsigned NumInputRootOps) DISABLE_INLINE { 47254 SDValue Chain = N.getOperand(0); 47255 SDValue N1 = N.getOperand(1); 47256 bool HasInFlag = (N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag); 47257 SmallVector<SDValue, 8> Ops0; 47258 SDValue InFlag(0, 0); 47259 if (HasInFlag) { 47260 InFlag = N.getOperand(N.getNumOperands()-1); 47261 } 47262 Ops0.push_back(N1); 47263 for (unsigned i = NumInputRootOps + 1, e = N.getNumOperands()-(HasInFlag?1:0); i != e; ++i) { 47264 Ops0.push_back(N.getOperand(i)); 47265 } 47266 Ops0.push_back(Chain); 47267 if (HasInFlag) 47268 Ops0.push_back(InFlag); 47269 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, MVT::Flag, &Ops0[0], Ops0.size()); 47270 Chain = SDValue(ResNode, 0); 47271 InFlag = SDValue(ResNode, 1); 47272 const SDValue Froms[] = { 47273 SDValue(N.getNode(), 1), 47274 SDValue(N.getNode(), 0) 47275 }; 47276 const SDValue Tos[] = { 47277 InFlag, 47278 SDValue(Chain.getNode(), Chain.getResNo()) 47279 }; 47280 ReplaceUses(Froms, Tos, 2); 47281 return ResNode; 47282 } 47283 SDNode *Emit_265(const SDValue &N, unsigned Opc0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4, unsigned NumInputRootOps) DISABLE_INLINE { 47284 SDValue Chain = N.getOperand(0); 47285 SDValue N1 = N.getOperand(1); 47286 SDValue Chain1 = N1.getOperand(0); 47287 SDValue N11 = N1.getOperand(1); 47288 bool HasInFlag = (N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag); 47289 SmallVector<SDValue, 8> Ops0; 47290 SmallVector<SDValue, 8> InChains; 47291 if (Chain.getNode() != N1.getNode()) { 47292 InChains.push_back(Chain); 47293 } 47294 InChains.push_back(Chain1); 47295 Chain1 = CurDAG->getNode(ISD::TokenFactor, N.getDebugLoc(), MVT::Other, &InChains[0], InChains.size()); 47296 SDValue InFlag(0, 0); 47297 if (HasInFlag) { 47298 InFlag = N.getOperand(N.getNumOperands()-1); 47299 } 47300 Ops0.push_back(CPTmpN11_0); 47301 Ops0.push_back(CPTmpN11_1); 47302 Ops0.push_back(CPTmpN11_2); 47303 Ops0.push_back(CPTmpN11_3); 47304 Ops0.push_back(CPTmpN11_4); 47305 for (unsigned i = NumInputRootOps + 1, e = N.getNumOperands()-(HasInFlag?1:0); i != e; ++i) { 47306 Ops0.push_back(N.getOperand(i)); 47307 } 47308 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 47309 Ops0.push_back(LSI_N1); 47310 Ops0.push_back(Chain1); 47311 if (HasInFlag) 47312 Ops0.push_back(InFlag); 47313 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, MVT::Flag, &Ops0[0], Ops0.size()); 47314 Chain1 = SDValue(ResNode, 0); 47315 InFlag = SDValue(ResNode, 1); 47316 const SDValue Froms[] = { 47317 SDValue(N1.getNode(), 1), 47318 SDValue(N.getNode(), 1), 47319 SDValue(N.getNode(), 0) 47320 }; 47321 const SDValue Tos[] = { 47322 SDValue(ResNode, 0), 47323 InFlag, 47324 SDValue(Chain1.getNode(), Chain1.getResNo()) 47325 }; 47326 ReplaceUses(Froms, Tos, 3); 47327 return ResNode; 47328 } 47329 SDNode *Emit_266(const SDValue &N, unsigned Opc0, unsigned NumInputRootOps) DISABLE_INLINE { 47330 SDValue Chain = N.getOperand(0); 47331 SDValue N1 = N.getOperand(1); 47332 bool HasInFlag = (N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag); 47333 SmallVector<SDValue, 8> Ops0; 47334 SDValue Tmp0 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i32); 47335 SDValue InFlag(0, 0); 47336 if (HasInFlag) { 47337 InFlag = N.getOperand(N.getNumOperands()-1); 47338 } 47339 Ops0.push_back(Tmp0); 47340 for (unsigned i = NumInputRootOps + 1, e = N.getNumOperands()-(HasInFlag?1:0); i != e; ++i) { 47341 Ops0.push_back(N.getOperand(i)); 47342 } 47343 Ops0.push_back(Chain); 47344 if (HasInFlag) 47345 Ops0.push_back(InFlag); 47346 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, MVT::Flag, &Ops0[0], Ops0.size()); 47347 Chain = SDValue(ResNode, 0); 47348 InFlag = SDValue(ResNode, 1); 47349 const SDValue Froms[] = { 47350 SDValue(N.getNode(), 1), 47351 SDValue(N.getNode(), 0) 47352 }; 47353 const SDValue Tos[] = { 47354 InFlag, 47355 SDValue(Chain.getNode(), Chain.getResNo()) 47356 }; 47357 ReplaceUses(Froms, Tos, 2); 47358 return ResNode; 47359 } 47360 SDNode *Select_X86ISD_CALL(const SDValue &N) { 47361 47362 // Pattern: (X86call:isVoid (ld:i32 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>) 47363 // Emits: (CALL32m:isVoid addr:iPTR:$dst) 47364 // Pattern complexity = 25 cost = 1 size = 3 47365 { 47366 SDValue Chain = N.getOperand(0); 47367 SDValue N1 = N.getOperand(1); 47368 if (N1.getOpcode() == ISD::LOAD && 47369 N1.hasOneUse() && 47370 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode()) && 47371 (Chain.getNode() == N1.getNode() || IsChainCompatible(Chain.getNode(), N1.getNode()))) { 47372 SDValue Chain1 = N1.getOperand(0); 47373 if (Predicate_unindexedload(N1.getNode()) && 47374 Predicate_loadi32(N1.getNode())) { 47375 SDValue N11 = N1.getOperand(1); 47376 SDValue CPTmpN11_0; 47377 SDValue CPTmpN11_1; 47378 SDValue CPTmpN11_2; 47379 SDValue CPTmpN11_3; 47380 SDValue CPTmpN11_4; 47381 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 47382 N1.getNode()->getValueType(0) == MVT::i32) { 47383 SDNode *Result = Emit_265(N, X86::CALL32m, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, 1); 47384 return Result; 47385 } 47386 } 47387 } 47388 } 47389 47390 // Pattern: (X86call:isVoid (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>) 47391 // Emits: (CALL64m:isVoid addr:iPTR:$dst) 47392 // Pattern complexity = 25 cost = 1 size = 3 47393 if ((!Subtarget->isTargetWin64())) { 47394 SDValue Chain = N.getOperand(0); 47395 SDValue N1 = N.getOperand(1); 47396 if (N1.getOpcode() == ISD::LOAD && 47397 N1.hasOneUse() && 47398 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode()) && 47399 (Chain.getNode() == N1.getNode() || IsChainCompatible(Chain.getNode(), N1.getNode()))) { 47400 SDValue Chain1 = N1.getOperand(0); 47401 if (Predicate_unindexedload(N1.getNode()) && 47402 Predicate_load(N1.getNode()) && 47403 Predicate_loadi64(N1.getNode())) { 47404 SDValue N11 = N1.getOperand(1); 47405 SDValue CPTmpN11_0; 47406 SDValue CPTmpN11_1; 47407 SDValue CPTmpN11_2; 47408 SDValue CPTmpN11_3; 47409 SDValue CPTmpN11_4; 47410 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 47411 N1.getNode()->getValueType(0) == MVT::i64) { 47412 SDNode *Result = Emit_265(N, X86::CALL64m, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, 1); 47413 return Result; 47414 } 47415 } 47416 } 47417 } 47418 47419 // Pattern: (X86call:isVoid (ld:i64 addr:iPTR:$dst)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>) 47420 // Emits: (WINCALL64m:isVoid addr:iPTR:$dst) 47421 // Pattern complexity = 25 cost = 1 size = 3 47422 if ((Subtarget->isTargetWin64())) { 47423 SDValue Chain = N.getOperand(0); 47424 SDValue N1 = N.getOperand(1); 47425 if (N1.getOpcode() == ISD::LOAD && 47426 N1.hasOneUse() && 47427 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode()) && 47428 (Chain.getNode() == N1.getNode() || IsChainCompatible(Chain.getNode(), N1.getNode()))) { 47429 SDValue Chain1 = N1.getOperand(0); 47430 if (Predicate_unindexedload(N1.getNode()) && 47431 Predicate_load(N1.getNode()) && 47432 Predicate_loadi64(N1.getNode())) { 47433 SDValue N11 = N1.getOperand(1); 47434 SDValue CPTmpN11_0; 47435 SDValue CPTmpN11_1; 47436 SDValue CPTmpN11_2; 47437 SDValue CPTmpN11_3; 47438 SDValue CPTmpN11_4; 47439 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 47440 N1.getNode()->getValueType(0) == MVT::i64) { 47441 SDNode *Result = Emit_265(N, X86::WINCALL64m, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, 1); 47442 return Result; 47443 } 47444 } 47445 } 47446 } 47447 if ((!Subtarget->isTargetWin64())) { 47448 SDValue Chain = N.getOperand(0); 47449 SDValue N1 = N.getOperand(1); 47450 47451 // Pattern: (X86call:isVoid (tglobaladdr:i64):$dst) 47452 // Emits: (CALL64pcrel32:isVoid (tglobaladdr:i64):$dst) 47453 // Pattern complexity = 6 cost = 1 size = 3 47454 if (N1.getOpcode() == ISD::TargetGlobalAddress && 47455 N1.getNode()->getValueType(0) == MVT::i64) { 47456 SDNode *Result = Emit_264(N, X86::CALL64pcrel32, 1); 47457 return Result; 47458 } 47459 47460 // Pattern: (X86call:isVoid (texternalsym:i64):$dst) 47461 // Emits: (CALL64pcrel32:isVoid (texternalsym:i64):$dst) 47462 // Pattern complexity = 6 cost = 1 size = 3 47463 if (N1.getOpcode() == ISD::TargetExternalSymbol && 47464 N1.getNode()->getValueType(0) == MVT::i64) { 47465 SDNode *Result = Emit_264(N, X86::CALL64pcrel32, 1); 47466 return Result; 47467 } 47468 } 47469 if ((Subtarget->isTargetWin64())) { 47470 SDValue Chain = N.getOperand(0); 47471 SDValue N1 = N.getOperand(1); 47472 47473 // Pattern: (X86call:isVoid (tglobaladdr:i64):$dst) 47474 // Emits: (WINCALL64pcrel32:isVoid (tglobaladdr:i64):$dst) 47475 // Pattern complexity = 6 cost = 1 size = 3 47476 if (N1.getOpcode() == ISD::TargetGlobalAddress && 47477 N1.getNode()->getValueType(0) == MVT::i64) { 47478 SDNode *Result = Emit_264(N, X86::WINCALL64pcrel32, 1); 47479 return Result; 47480 } 47481 47482 // Pattern: (X86call:isVoid (texternalsym:i64):$dst) 47483 // Emits: (WINCALL64pcrel32:isVoid (texternalsym:i64):$dst) 47484 // Pattern complexity = 6 cost = 1 size = 3 47485 if (N1.getOpcode() == ISD::TargetExternalSymbol && 47486 N1.getNode()->getValueType(0) == MVT::i64) { 47487 SDNode *Result = Emit_264(N, X86::WINCALL64pcrel32, 1); 47488 return Result; 47489 } 47490 } 47491 { 47492 SDValue Chain = N.getOperand(0); 47493 SDValue N1 = N.getOperand(1); 47494 47495 // Pattern: (X86call:isVoid (tglobaladdr:i32):$dst) 47496 // Emits: (CALLpcrel32:isVoid (tglobaladdr:i32):$dst) 47497 // Pattern complexity = 6 cost = 1 size = 3 47498 if (N1.getOpcode() == ISD::TargetGlobalAddress && 47499 N1.getNode()->getValueType(0) == MVT::i32) { 47500 SDNode *Result = Emit_264(N, X86::CALLpcrel32, 1); 47501 return Result; 47502 } 47503 47504 // Pattern: (X86call:isVoid (texternalsym:i32):$dst) 47505 // Emits: (CALLpcrel32:isVoid (texternalsym:i32):$dst) 47506 // Pattern complexity = 6 cost = 1 size = 3 47507 if (N1.getOpcode() == ISD::TargetExternalSymbol && 47508 N1.getNode()->getValueType(0) == MVT::i32) { 47509 SDNode *Result = Emit_264(N, X86::CALLpcrel32, 1); 47510 return Result; 47511 } 47512 } 47513 47514 // Pattern: (X86call:isVoid (imm:i32):$dst) 47515 // Emits: (CALLpcrel32:isVoid (imm:i32):$dst) 47516 // Pattern complexity = 6 cost = 1 size = 3 47517 if ((Subtarget->IsLegalToCallImmediateAddr(TM))) { 47518 SDValue Chain = N.getOperand(0); 47519 SDValue N1 = N.getOperand(1); 47520 if (N1.getOpcode() == ISD::Constant && 47521 N1.getNode()->getValueType(0) == MVT::i32) { 47522 SDNode *Result = Emit_266(N, X86::CALLpcrel32, 1); 47523 return Result; 47524 } 47525 } 47526 47527 // Pattern: (X86call:isVoid GR32:i32:$dst) 47528 // Emits: (CALL32r:isVoid GR32:i32:$dst) 47529 // Pattern complexity = 3 cost = 1 size = 3 47530 { 47531 SDValue Chain = N.getOperand(0); 47532 SDValue N1 = N.getOperand(1); 47533 if (N1.getNode()->getValueType(0) == MVT::i32) { 47534 SDNode *Result = Emit_264(N, X86::CALL32r, 1); 47535 return Result; 47536 } 47537 } 47538 47539 // Pattern: (X86call:isVoid GR64:i64:$dst) 47540 // Emits: (CALL64r:isVoid GR64:i64:$dst) 47541 // Pattern complexity = 3 cost = 1 size = 3 47542 if ((!Subtarget->isTargetWin64())) { 47543 SDValue Chain = N.getOperand(0); 47544 SDValue N1 = N.getOperand(1); 47545 if (N1.getNode()->getValueType(0) == MVT::i64) { 47546 SDNode *Result = Emit_264(N, X86::CALL64r, 1); 47547 return Result; 47548 } 47549 } 47550 47551 // Pattern: (X86call:isVoid GR64:i64:$dst) 47552 // Emits: (WINCALL64r:isVoid GR64:i64:$dst) 47553 // Pattern complexity = 3 cost = 1 size = 3 47554 if ((Subtarget->isTargetWin64())) { 47555 SDValue Chain = N.getOperand(0); 47556 SDValue N1 = N.getOperand(1); 47557 if (N1.getNode()->getValueType(0) == MVT::i64) { 47558 SDNode *Result = Emit_264(N, X86::WINCALL64r, 1); 47559 return Result; 47560 } 47561 } 47562 47563 CannotYetSelect(N); 47564 return NULL; 47565 } 47566 47567 SDNode *Emit_267(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 47568 SDValue N0 = N.getOperand(0); 47569 SDValue N1 = N.getOperand(1); 47570 SDValue N2 = N.getOperand(2); 47571 SDValue N3 = N.getOperand(3); 47572 SDValue Chain = CurDAG->getEntryNode(); 47573 SDValue InFlag(0, 0); 47574 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::EFLAGS, N3, InFlag).getNode(); 47575 Chain = SDValue(ResNode, 0); 47576 InFlag = SDValue(ResNode, 1); 47577 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, N1, InFlag); 47578 } 47579 SDNode *Emit_268(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 47580 SDValue N0 = N.getOperand(0); 47581 SDValue N1 = N.getOperand(1); 47582 SDValue Chain1 = N1.getOperand(0); 47583 SDValue N11 = N1.getOperand(1); 47584 SDValue N2 = N.getOperand(2); 47585 SDValue N3 = N.getOperand(3); 47586 SDValue InFlag(0, 0); 47587 SDNode *ResNode = CurDAG->getCopyToReg(Chain1, N.getDebugLoc(), X86::EFLAGS, N3, InFlag).getNode(); 47588 Chain1 = SDValue(ResNode, 0); 47589 InFlag = SDValue(ResNode, 1); 47590 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 47591 SDValue Ops0[] = { N0, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1, InFlag }; 47592 ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 9); 47593 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 47594 return ResNode; 47595 } 47596 SDNode *Emit_269(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 47597 SDValue N0 = N.getOperand(0); 47598 SDValue Chain0 = N0.getOperand(0); 47599 SDValue N01 = N0.getOperand(1); 47600 SDValue N1 = N.getOperand(1); 47601 SDValue N2 = N.getOperand(2); 47602 SDValue N3 = N.getOperand(3); 47603 SDValue InFlag(0, 0); 47604 SDNode *ResNode = CurDAG->getCopyToReg(Chain0, N.getDebugLoc(), X86::EFLAGS, N3, InFlag).getNode(); 47605 Chain0 = SDValue(ResNode, 0); 47606 InFlag = SDValue(ResNode, 1); 47607 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 47608 SDValue Ops0[] = { N1, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, LSI_N0, Chain0, InFlag }; 47609 ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 9); 47610 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 47611 return ResNode; 47612 } 47613 SDNode *Select_X86ISD_CMOV_i16(const SDValue &N) { 47614 if (OptLevel != CodeGenOpt::None) { 47615 SDValue N0 = N.getOperand(0); 47616 { 47617 SDValue N1 = N.getOperand(1); 47618 if (N1.getOpcode() == ISD::LOAD && 47619 N1.hasOneUse() && 47620 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 47621 SDValue Chain1 = N1.getOperand(0); 47622 if (Predicate_unindexedload(N1.getNode()) && 47623 Predicate_loadi16(N1.getNode())) { 47624 SDValue N11 = N1.getOperand(1); 47625 SDValue CPTmpN11_0; 47626 SDValue CPTmpN11_1; 47627 SDValue CPTmpN11_2; 47628 SDValue CPTmpN11_3; 47629 SDValue CPTmpN11_4; 47630 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 47631 SDValue N2 = N.getOperand(2); 47632 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N2); 47633 if (Tmp0) { 47634 int64_t CN1 = Tmp0->getSExtValue(); 47635 47636 // Pattern: (X86cmov:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 2:i8, EFLAGS:i32) 47637 // Emits: (CMOVB16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 47638 // Pattern complexity = 30 cost = 1 size = 3 47639 if (CN1 == INT64_C(2)) { 47640 SDNode *Result = Emit_268(N, X86::CMOVB16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 47641 return Result; 47642 } 47643 47644 // Pattern: (X86cmov:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 1:i8, EFLAGS:i32) 47645 // Emits: (CMOVAE16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 47646 // Pattern complexity = 30 cost = 1 size = 3 47647 if (CN1 == INT64_C(1)) { 47648 SDNode *Result = Emit_268(N, X86::CMOVAE16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 47649 return Result; 47650 } 47651 47652 // Pattern: (X86cmov:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 4:i8, EFLAGS:i32) 47653 // Emits: (CMOVE16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 47654 // Pattern complexity = 30 cost = 1 size = 3 47655 if (CN1 == INT64_C(4)) { 47656 SDNode *Result = Emit_268(N, X86::CMOVE16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 47657 return Result; 47658 } 47659 47660 // Pattern: (X86cmov:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 9:i8, EFLAGS:i32) 47661 // Emits: (CMOVNE16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 47662 // Pattern complexity = 30 cost = 1 size = 3 47663 if (CN1 == INT64_C(9)) { 47664 SDNode *Result = Emit_268(N, X86::CMOVNE16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 47665 return Result; 47666 } 47667 47668 // Pattern: (X86cmov:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 3:i8, EFLAGS:i32) 47669 // Emits: (CMOVBE16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 47670 // Pattern complexity = 30 cost = 1 size = 3 47671 if (CN1 == INT64_C(3)) { 47672 SDNode *Result = Emit_268(N, X86::CMOVBE16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 47673 return Result; 47674 } 47675 47676 // Pattern: (X86cmov:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 0:i8, EFLAGS:i32) 47677 // Emits: (CMOVA16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 47678 // Pattern complexity = 30 cost = 1 size = 3 47679 if (CN1 == INT64_C(0)) { 47680 SDNode *Result = Emit_268(N, X86::CMOVA16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 47681 return Result; 47682 } 47683 47684 // Pattern: (X86cmov:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 7:i8, EFLAGS:i32) 47685 // Emits: (CMOVL16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 47686 // Pattern complexity = 30 cost = 1 size = 3 47687 if (CN1 == INT64_C(7)) { 47688 SDNode *Result = Emit_268(N, X86::CMOVL16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 47689 return Result; 47690 } 47691 47692 // Pattern: (X86cmov:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 6:i8, EFLAGS:i32) 47693 // Emits: (CMOVGE16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 47694 // Pattern complexity = 30 cost = 1 size = 3 47695 if (CN1 == INT64_C(6)) { 47696 SDNode *Result = Emit_268(N, X86::CMOVGE16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 47697 return Result; 47698 } 47699 47700 // Pattern: (X86cmov:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 8:i8, EFLAGS:i32) 47701 // Emits: (CMOVLE16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 47702 // Pattern complexity = 30 cost = 1 size = 3 47703 if (CN1 == INT64_C(8)) { 47704 SDNode *Result = Emit_268(N, X86::CMOVLE16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 47705 return Result; 47706 } 47707 47708 // Pattern: (X86cmov:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 5:i8, EFLAGS:i32) 47709 // Emits: (CMOVG16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 47710 // Pattern complexity = 30 cost = 1 size = 3 47711 if (CN1 == INT64_C(5)) { 47712 SDNode *Result = Emit_268(N, X86::CMOVG16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 47713 return Result; 47714 } 47715 47716 // Pattern: (X86cmov:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 15:i8, EFLAGS:i32) 47717 // Emits: (CMOVS16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 47718 // Pattern complexity = 30 cost = 1 size = 3 47719 if (CN1 == INT64_C(15)) { 47720 SDNode *Result = Emit_268(N, X86::CMOVS16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 47721 return Result; 47722 } 47723 47724 // Pattern: (X86cmov:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 12:i8, EFLAGS:i32) 47725 // Emits: (CMOVNS16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 47726 // Pattern complexity = 30 cost = 1 size = 3 47727 if (CN1 == INT64_C(12)) { 47728 SDNode *Result = Emit_268(N, X86::CMOVNS16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 47729 return Result; 47730 } 47731 47732 // Pattern: (X86cmov:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 14:i8, EFLAGS:i32) 47733 // Emits: (CMOVP16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 47734 // Pattern complexity = 30 cost = 1 size = 3 47735 if (CN1 == INT64_C(14)) { 47736 SDNode *Result = Emit_268(N, X86::CMOVP16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 47737 return Result; 47738 } 47739 47740 // Pattern: (X86cmov:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 11:i8, EFLAGS:i32) 47741 // Emits: (CMOVNP16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 47742 // Pattern complexity = 30 cost = 1 size = 3 47743 if (CN1 == INT64_C(11)) { 47744 SDNode *Result = Emit_268(N, X86::CMOVNP16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 47745 return Result; 47746 } 47747 47748 // Pattern: (X86cmov:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 13:i8, EFLAGS:i32) 47749 // Emits: (CMOVO16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 47750 // Pattern complexity = 30 cost = 1 size = 3 47751 if (CN1 == INT64_C(13)) { 47752 SDNode *Result = Emit_268(N, X86::CMOVO16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 47753 return Result; 47754 } 47755 47756 // Pattern: (X86cmov:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, 10:i8, EFLAGS:i32) 47757 // Emits: (CMOVNO16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 47758 // Pattern complexity = 30 cost = 1 size = 3 47759 if (CN1 == INT64_C(10)) { 47760 SDNode *Result = Emit_268(N, X86::CMOVNO16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 47761 return Result; 47762 } 47763 } 47764 } 47765 } 47766 } 47767 } 47768 if (N0.getOpcode() == ISD::LOAD && 47769 N0.hasOneUse() && 47770 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 47771 SDValue Chain0 = N0.getOperand(0); 47772 if (Predicate_unindexedload(N0.getNode()) && 47773 Predicate_loadi16(N0.getNode())) { 47774 SDValue N01 = N0.getOperand(1); 47775 SDValue CPTmpN01_0; 47776 SDValue CPTmpN01_1; 47777 SDValue CPTmpN01_2; 47778 SDValue CPTmpN01_3; 47779 SDValue CPTmpN01_4; 47780 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 47781 SDValue N1 = N.getOperand(1); 47782 SDValue N2 = N.getOperand(2); 47783 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N2); 47784 if (Tmp0) { 47785 int64_t CN1 = Tmp0->getSExtValue(); 47786 47787 // Pattern: (X86cmov:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, 5:i8, EFLAGS:i32) 47788 // Emits: (CMOVLE16rm:i16 GR16:i16:$src2, addr:iPTR:$src1) 47789 // Pattern complexity = 30 cost = 1 size = 3 47790 if (CN1 == INT64_C(5)) { 47791 SDNode *Result = Emit_269(N, X86::CMOVLE16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47792 return Result; 47793 } 47794 47795 // Pattern: (X86cmov:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, 14:i8, EFLAGS:i32) 47796 // Emits: (CMOVNP16rm:i16 GR16:i16:$src2, addr:iPTR:$src1) 47797 // Pattern complexity = 30 cost = 1 size = 3 47798 if (CN1 == INT64_C(14)) { 47799 SDNode *Result = Emit_269(N, X86::CMOVNP16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47800 return Result; 47801 } 47802 47803 // Pattern: (X86cmov:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, 11:i8, EFLAGS:i32) 47804 // Emits: (CMOVP16rm:i16 GR16:i16:$src2, addr:iPTR:$src1) 47805 // Pattern complexity = 30 cost = 1 size = 3 47806 if (CN1 == INT64_C(11)) { 47807 SDNode *Result = Emit_269(N, X86::CMOVP16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47808 return Result; 47809 } 47810 47811 // Pattern: (X86cmov:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, 15:i8, EFLAGS:i32) 47812 // Emits: (CMOVNS16rm:i16 GR16:i16:$src2, addr:iPTR:$src1) 47813 // Pattern complexity = 30 cost = 1 size = 3 47814 if (CN1 == INT64_C(15)) { 47815 SDNode *Result = Emit_269(N, X86::CMOVNS16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47816 return Result; 47817 } 47818 47819 // Pattern: (X86cmov:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, 12:i8, EFLAGS:i32) 47820 // Emits: (CMOVS16rm:i16 GR16:i16:$src2, addr:iPTR:$src1) 47821 // Pattern complexity = 30 cost = 1 size = 3 47822 if (CN1 == INT64_C(12)) { 47823 SDNode *Result = Emit_269(N, X86::CMOVS16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47824 return Result; 47825 } 47826 47827 // Pattern: (X86cmov:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, 13:i8, EFLAGS:i32) 47828 // Emits: (CMOVNO16rm:i16 GR16:i16:$src2, addr:iPTR:$src1) 47829 // Pattern complexity = 30 cost = 1 size = 3 47830 if (CN1 == INT64_C(13)) { 47831 SDNode *Result = Emit_269(N, X86::CMOVNO16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47832 return Result; 47833 } 47834 47835 // Pattern: (X86cmov:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, 10:i8, EFLAGS:i32) 47836 // Emits: (CMOVO16rm:i16 GR16:i16:$src2, addr:iPTR:$src1) 47837 // Pattern complexity = 30 cost = 1 size = 3 47838 if (CN1 == INT64_C(10)) { 47839 SDNode *Result = Emit_269(N, X86::CMOVO16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47840 return Result; 47841 } 47842 47843 // Pattern: (X86cmov:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, 2:i8, EFLAGS:i32) 47844 // Emits: (CMOVAE16rm:i16 GR16:i16:$src2, addr:iPTR:$src1) 47845 // Pattern complexity = 30 cost = 1 size = 3 47846 if (CN1 == INT64_C(2)) { 47847 SDNode *Result = Emit_269(N, X86::CMOVAE16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47848 return Result; 47849 } 47850 47851 // Pattern: (X86cmov:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, 1:i8, EFLAGS:i32) 47852 // Emits: (CMOVB16rm:i16 GR16:i16:$src2, addr:iPTR:$src1) 47853 // Pattern complexity = 30 cost = 1 size = 3 47854 if (CN1 == INT64_C(1)) { 47855 SDNode *Result = Emit_269(N, X86::CMOVB16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47856 return Result; 47857 } 47858 47859 // Pattern: (X86cmov:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, 4:i8, EFLAGS:i32) 47860 // Emits: (CMOVNE16rm:i16 GR16:i16:$src2, addr:iPTR:$src1) 47861 // Pattern complexity = 30 cost = 1 size = 3 47862 if (CN1 == INT64_C(4)) { 47863 SDNode *Result = Emit_269(N, X86::CMOVNE16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47864 return Result; 47865 } 47866 47867 // Pattern: (X86cmov:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, 9:i8, EFLAGS:i32) 47868 // Emits: (CMOVE16rm:i16 GR16:i16:$src2, addr:iPTR:$src1) 47869 // Pattern complexity = 30 cost = 1 size = 3 47870 if (CN1 == INT64_C(9)) { 47871 SDNode *Result = Emit_269(N, X86::CMOVE16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47872 return Result; 47873 } 47874 47875 // Pattern: (X86cmov:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, 3:i8, EFLAGS:i32) 47876 // Emits: (CMOVA16rm:i16 GR16:i16:$src2, addr:iPTR:$src1) 47877 // Pattern complexity = 30 cost = 1 size = 3 47878 if (CN1 == INT64_C(3)) { 47879 SDNode *Result = Emit_269(N, X86::CMOVA16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47880 return Result; 47881 } 47882 47883 // Pattern: (X86cmov:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, 0:i8, EFLAGS:i32) 47884 // Emits: (CMOVBE16rm:i16 GR16:i16:$src2, addr:iPTR:$src1) 47885 // Pattern complexity = 30 cost = 1 size = 3 47886 if (CN1 == INT64_C(0)) { 47887 SDNode *Result = Emit_269(N, X86::CMOVBE16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47888 return Result; 47889 } 47890 47891 // Pattern: (X86cmov:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, 7:i8, EFLAGS:i32) 47892 // Emits: (CMOVGE16rm:i16 GR16:i16:$src2, addr:iPTR:$src1) 47893 // Pattern complexity = 30 cost = 1 size = 3 47894 if (CN1 == INT64_C(7)) { 47895 SDNode *Result = Emit_269(N, X86::CMOVGE16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47896 return Result; 47897 } 47898 47899 // Pattern: (X86cmov:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, 6:i8, EFLAGS:i32) 47900 // Emits: (CMOVL16rm:i16 GR16:i16:$src2, addr:iPTR:$src1) 47901 // Pattern complexity = 30 cost = 1 size = 3 47902 if (CN1 == INT64_C(6)) { 47903 SDNode *Result = Emit_269(N, X86::CMOVL16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47904 return Result; 47905 } 47906 47907 // Pattern: (X86cmov:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2, 8:i8, EFLAGS:i32) 47908 // Emits: (CMOVG16rm:i16 GR16:i16:$src2, addr:iPTR:$src1) 47909 // Pattern complexity = 30 cost = 1 size = 3 47910 if (CN1 == INT64_C(8)) { 47911 SDNode *Result = Emit_269(N, X86::CMOVG16rm, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 47912 return Result; 47913 } 47914 } 47915 } 47916 } 47917 } 47918 } 47919 SDValue N0 = N.getOperand(0); 47920 SDValue N1 = N.getOperand(1); 47921 SDValue N2 = N.getOperand(2); 47922 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N2); 47923 if (Tmp0) { 47924 int64_t CN1 = Tmp0->getSExtValue(); 47925 47926 // Pattern: (X86cmov:i16 GR16:i16:$src1, GR16:i16:$src2, 2:i8, EFLAGS:i32) 47927 // Emits: (CMOVB16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 47928 // Pattern complexity = 8 cost = 1 size = 3 47929 if (CN1 == INT64_C(2)) { 47930 SDNode *Result = Emit_267(N, X86::CMOVB16rr, MVT::i16); 47931 return Result; 47932 } 47933 47934 // Pattern: (X86cmov:i16 GR16:i16:$src1, GR16:i16:$src2, 1:i8, EFLAGS:i32) 47935 // Emits: (CMOVAE16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 47936 // Pattern complexity = 8 cost = 1 size = 3 47937 if (CN1 == INT64_C(1)) { 47938 SDNode *Result = Emit_267(N, X86::CMOVAE16rr, MVT::i16); 47939 return Result; 47940 } 47941 47942 // Pattern: (X86cmov:i16 GR16:i16:$src1, GR16:i16:$src2, 4:i8, EFLAGS:i32) 47943 // Emits: (CMOVE16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 47944 // Pattern complexity = 8 cost = 1 size = 3 47945 if (CN1 == INT64_C(4)) { 47946 SDNode *Result = Emit_267(N, X86::CMOVE16rr, MVT::i16); 47947 return Result; 47948 } 47949 47950 // Pattern: (X86cmov:i16 GR16:i16:$src1, GR16:i16:$src2, 9:i8, EFLAGS:i32) 47951 // Emits: (CMOVNE16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 47952 // Pattern complexity = 8 cost = 1 size = 3 47953 if (CN1 == INT64_C(9)) { 47954 SDNode *Result = Emit_267(N, X86::CMOVNE16rr, MVT::i16); 47955 return Result; 47956 } 47957 47958 // Pattern: (X86cmov:i16 GR16:i16:$src1, GR16:i16:$src2, 3:i8, EFLAGS:i32) 47959 // Emits: (CMOVBE16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 47960 // Pattern complexity = 8 cost = 1 size = 3 47961 if (CN1 == INT64_C(3)) { 47962 SDNode *Result = Emit_267(N, X86::CMOVBE16rr, MVT::i16); 47963 return Result; 47964 } 47965 47966 // Pattern: (X86cmov:i16 GR16:i16:$src1, GR16:i16:$src2, 0:i8, EFLAGS:i32) 47967 // Emits: (CMOVA16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 47968 // Pattern complexity = 8 cost = 1 size = 3 47969 if (CN1 == INT64_C(0)) { 47970 SDNode *Result = Emit_267(N, X86::CMOVA16rr, MVT::i16); 47971 return Result; 47972 } 47973 47974 // Pattern: (X86cmov:i16 GR16:i16:$src1, GR16:i16:$src2, 7:i8, EFLAGS:i32) 47975 // Emits: (CMOVL16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 47976 // Pattern complexity = 8 cost = 1 size = 3 47977 if (CN1 == INT64_C(7)) { 47978 SDNode *Result = Emit_267(N, X86::CMOVL16rr, MVT::i16); 47979 return Result; 47980 } 47981 47982 // Pattern: (X86cmov:i16 GR16:i16:$src1, GR16:i16:$src2, 6:i8, EFLAGS:i32) 47983 // Emits: (CMOVGE16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 47984 // Pattern complexity = 8 cost = 1 size = 3 47985 if (CN1 == INT64_C(6)) { 47986 SDNode *Result = Emit_267(N, X86::CMOVGE16rr, MVT::i16); 47987 return Result; 47988 } 47989 47990 // Pattern: (X86cmov:i16 GR16:i16:$src1, GR16:i16:$src2, 8:i8, EFLAGS:i32) 47991 // Emits: (CMOVLE16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 47992 // Pattern complexity = 8 cost = 1 size = 3 47993 if (CN1 == INT64_C(8)) { 47994 SDNode *Result = Emit_267(N, X86::CMOVLE16rr, MVT::i16); 47995 return Result; 47996 } 47997 47998 // Pattern: (X86cmov:i16 GR16:i16:$src1, GR16:i16:$src2, 5:i8, EFLAGS:i32) 47999 // Emits: (CMOVG16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 48000 // Pattern complexity = 8 cost = 1 size = 3 48001 if (CN1 == INT64_C(5)) { 48002 SDNode *Result = Emit_267(N, X86::CMOVG16rr, MVT::i16); 48003 return Result; 48004 } 48005 48006 // Pattern: (X86cmov:i16 GR16:i16:$src1, GR16:i16:$src2, 15:i8, EFLAGS:i32) 48007 // Emits: (CMOVS16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 48008 // Pattern complexity = 8 cost = 1 size = 3 48009 if (CN1 == INT64_C(15)) { 48010 SDNode *Result = Emit_267(N, X86::CMOVS16rr, MVT::i16); 48011 return Result; 48012 } 48013 48014 // Pattern: (X86cmov:i16 GR16:i16:$src1, GR16:i16:$src2, 12:i8, EFLAGS:i32) 48015 // Emits: (CMOVNS16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 48016 // Pattern complexity = 8 cost = 1 size = 3 48017 if (CN1 == INT64_C(12)) { 48018 SDNode *Result = Emit_267(N, X86::CMOVNS16rr, MVT::i16); 48019 return Result; 48020 } 48021 48022 // Pattern: (X86cmov:i16 GR16:i16:$src1, GR16:i16:$src2, 14:i8, EFLAGS:i32) 48023 // Emits: (CMOVP16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 48024 // Pattern complexity = 8 cost = 1 size = 3 48025 if (CN1 == INT64_C(14)) { 48026 SDNode *Result = Emit_267(N, X86::CMOVP16rr, MVT::i16); 48027 return Result; 48028 } 48029 48030 // Pattern: (X86cmov:i16 GR16:i16:$src1, GR16:i16:$src2, 11:i8, EFLAGS:i32) 48031 // Emits: (CMOVNP16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 48032 // Pattern complexity = 8 cost = 1 size = 3 48033 if (CN1 == INT64_C(11)) { 48034 SDNode *Result = Emit_267(N, X86::CMOVNP16rr, MVT::i16); 48035 return Result; 48036 } 48037 48038 // Pattern: (X86cmov:i16 GR16:i16:$src1, GR16:i16:$src2, 13:i8, EFLAGS:i32) 48039 // Emits: (CMOVO16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 48040 // Pattern complexity = 8 cost = 1 size = 3 48041 if (CN1 == INT64_C(13)) { 48042 SDNode *Result = Emit_267(N, X86::CMOVO16rr, MVT::i16); 48043 return Result; 48044 } 48045 48046 // Pattern: (X86cmov:i16 GR16:i16:$src1, GR16:i16:$src2, 10:i8, EFLAGS:i32) 48047 // Emits: (CMOVNO16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 48048 // Pattern complexity = 8 cost = 1 size = 3 48049 if (CN1 == INT64_C(10)) { 48050 SDNode *Result = Emit_267(N, X86::CMOVNO16rr, MVT::i16); 48051 return Result; 48052 } 48053 } 48054 48055 CannotYetSelect(N); 48056 return NULL; 48057 } 48058 48059 SDNode *Select_X86ISD_CMOV_i32(const SDValue &N) { 48060 if (OptLevel != CodeGenOpt::None) { 48061 SDValue N0 = N.getOperand(0); 48062 { 48063 SDValue N1 = N.getOperand(1); 48064 if (N1.getOpcode() == ISD::LOAD && 48065 N1.hasOneUse() && 48066 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 48067 SDValue Chain1 = N1.getOperand(0); 48068 if (Predicate_unindexedload(N1.getNode()) && 48069 Predicate_loadi32(N1.getNode())) { 48070 SDValue N11 = N1.getOperand(1); 48071 SDValue CPTmpN11_0; 48072 SDValue CPTmpN11_1; 48073 SDValue CPTmpN11_2; 48074 SDValue CPTmpN11_3; 48075 SDValue CPTmpN11_4; 48076 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 48077 SDValue N2 = N.getOperand(2); 48078 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N2); 48079 if (Tmp0) { 48080 int64_t CN1 = Tmp0->getSExtValue(); 48081 48082 // Pattern: (X86cmov:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 2:i8, EFLAGS:i32) 48083 // Emits: (CMOVB32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 48084 // Pattern complexity = 30 cost = 1 size = 3 48085 if (CN1 == INT64_C(2)) { 48086 SDNode *Result = Emit_268(N, X86::CMOVB32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48087 return Result; 48088 } 48089 48090 // Pattern: (X86cmov:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 1:i8, EFLAGS:i32) 48091 // Emits: (CMOVAE32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 48092 // Pattern complexity = 30 cost = 1 size = 3 48093 if (CN1 == INT64_C(1)) { 48094 SDNode *Result = Emit_268(N, X86::CMOVAE32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48095 return Result; 48096 } 48097 48098 // Pattern: (X86cmov:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 4:i8, EFLAGS:i32) 48099 // Emits: (CMOVE32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 48100 // Pattern complexity = 30 cost = 1 size = 3 48101 if (CN1 == INT64_C(4)) { 48102 SDNode *Result = Emit_268(N, X86::CMOVE32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48103 return Result; 48104 } 48105 48106 // Pattern: (X86cmov:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 9:i8, EFLAGS:i32) 48107 // Emits: (CMOVNE32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 48108 // Pattern complexity = 30 cost = 1 size = 3 48109 if (CN1 == INT64_C(9)) { 48110 SDNode *Result = Emit_268(N, X86::CMOVNE32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48111 return Result; 48112 } 48113 48114 // Pattern: (X86cmov:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 3:i8, EFLAGS:i32) 48115 // Emits: (CMOVBE32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 48116 // Pattern complexity = 30 cost = 1 size = 3 48117 if (CN1 == INT64_C(3)) { 48118 SDNode *Result = Emit_268(N, X86::CMOVBE32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48119 return Result; 48120 } 48121 48122 // Pattern: (X86cmov:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 0:i8, EFLAGS:i32) 48123 // Emits: (CMOVA32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 48124 // Pattern complexity = 30 cost = 1 size = 3 48125 if (CN1 == INT64_C(0)) { 48126 SDNode *Result = Emit_268(N, X86::CMOVA32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48127 return Result; 48128 } 48129 48130 // Pattern: (X86cmov:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 7:i8, EFLAGS:i32) 48131 // Emits: (CMOVL32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 48132 // Pattern complexity = 30 cost = 1 size = 3 48133 if (CN1 == INT64_C(7)) { 48134 SDNode *Result = Emit_268(N, X86::CMOVL32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48135 return Result; 48136 } 48137 48138 // Pattern: (X86cmov:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 6:i8, EFLAGS:i32) 48139 // Emits: (CMOVGE32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 48140 // Pattern complexity = 30 cost = 1 size = 3 48141 if (CN1 == INT64_C(6)) { 48142 SDNode *Result = Emit_268(N, X86::CMOVGE32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48143 return Result; 48144 } 48145 48146 // Pattern: (X86cmov:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 8:i8, EFLAGS:i32) 48147 // Emits: (CMOVLE32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 48148 // Pattern complexity = 30 cost = 1 size = 3 48149 if (CN1 == INT64_C(8)) { 48150 SDNode *Result = Emit_268(N, X86::CMOVLE32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48151 return Result; 48152 } 48153 48154 // Pattern: (X86cmov:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 5:i8, EFLAGS:i32) 48155 // Emits: (CMOVG32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 48156 // Pattern complexity = 30 cost = 1 size = 3 48157 if (CN1 == INT64_C(5)) { 48158 SDNode *Result = Emit_268(N, X86::CMOVG32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48159 return Result; 48160 } 48161 48162 // Pattern: (X86cmov:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 15:i8, EFLAGS:i32) 48163 // Emits: (CMOVS32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 48164 // Pattern complexity = 30 cost = 1 size = 3 48165 if (CN1 == INT64_C(15)) { 48166 SDNode *Result = Emit_268(N, X86::CMOVS32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48167 return Result; 48168 } 48169 48170 // Pattern: (X86cmov:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 12:i8, EFLAGS:i32) 48171 // Emits: (CMOVNS32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 48172 // Pattern complexity = 30 cost = 1 size = 3 48173 if (CN1 == INT64_C(12)) { 48174 SDNode *Result = Emit_268(N, X86::CMOVNS32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48175 return Result; 48176 } 48177 48178 // Pattern: (X86cmov:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 14:i8, EFLAGS:i32) 48179 // Emits: (CMOVP32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 48180 // Pattern complexity = 30 cost = 1 size = 3 48181 if (CN1 == INT64_C(14)) { 48182 SDNode *Result = Emit_268(N, X86::CMOVP32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48183 return Result; 48184 } 48185 48186 // Pattern: (X86cmov:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 11:i8, EFLAGS:i32) 48187 // Emits: (CMOVNP32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 48188 // Pattern complexity = 30 cost = 1 size = 3 48189 if (CN1 == INT64_C(11)) { 48190 SDNode *Result = Emit_268(N, X86::CMOVNP32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48191 return Result; 48192 } 48193 48194 // Pattern: (X86cmov:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 13:i8, EFLAGS:i32) 48195 // Emits: (CMOVO32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 48196 // Pattern complexity = 30 cost = 1 size = 3 48197 if (CN1 == INT64_C(13)) { 48198 SDNode *Result = Emit_268(N, X86::CMOVO32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48199 return Result; 48200 } 48201 48202 // Pattern: (X86cmov:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, 10:i8, EFLAGS:i32) 48203 // Emits: (CMOVNO32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 48204 // Pattern complexity = 30 cost = 1 size = 3 48205 if (CN1 == INT64_C(10)) { 48206 SDNode *Result = Emit_268(N, X86::CMOVNO32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48207 return Result; 48208 } 48209 } 48210 } 48211 } 48212 } 48213 } 48214 if (N0.getOpcode() == ISD::LOAD && 48215 N0.hasOneUse() && 48216 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 48217 SDValue Chain0 = N0.getOperand(0); 48218 if (Predicate_unindexedload(N0.getNode()) && 48219 Predicate_loadi32(N0.getNode())) { 48220 SDValue N01 = N0.getOperand(1); 48221 SDValue CPTmpN01_0; 48222 SDValue CPTmpN01_1; 48223 SDValue CPTmpN01_2; 48224 SDValue CPTmpN01_3; 48225 SDValue CPTmpN01_4; 48226 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 48227 SDValue N1 = N.getOperand(1); 48228 SDValue N2 = N.getOperand(2); 48229 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N2); 48230 if (Tmp0) { 48231 int64_t CN1 = Tmp0->getSExtValue(); 48232 48233 // Pattern: (X86cmov:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, 8:i8, EFLAGS:i32) 48234 // Emits: (CMOVG32rm:i32 GR32:i32:$src2, addr:iPTR:$src1) 48235 // Pattern complexity = 30 cost = 1 size = 3 48236 if (CN1 == INT64_C(8)) { 48237 SDNode *Result = Emit_269(N, X86::CMOVG32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48238 return Result; 48239 } 48240 48241 // Pattern: (X86cmov:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, 5:i8, EFLAGS:i32) 48242 // Emits: (CMOVLE32rm:i32 GR32:i32:$src2, addr:iPTR:$src1) 48243 // Pattern complexity = 30 cost = 1 size = 3 48244 if (CN1 == INT64_C(5)) { 48245 SDNode *Result = Emit_269(N, X86::CMOVLE32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48246 return Result; 48247 } 48248 48249 // Pattern: (X86cmov:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, 14:i8, EFLAGS:i32) 48250 // Emits: (CMOVNP32rm:i32 GR32:i32:$src2, addr:iPTR:$src1) 48251 // Pattern complexity = 30 cost = 1 size = 3 48252 if (CN1 == INT64_C(14)) { 48253 SDNode *Result = Emit_269(N, X86::CMOVNP32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48254 return Result; 48255 } 48256 48257 // Pattern: (X86cmov:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, 11:i8, EFLAGS:i32) 48258 // Emits: (CMOVP32rm:i32 GR32:i32:$src2, addr:iPTR:$src1) 48259 // Pattern complexity = 30 cost = 1 size = 3 48260 if (CN1 == INT64_C(11)) { 48261 SDNode *Result = Emit_269(N, X86::CMOVP32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48262 return Result; 48263 } 48264 48265 // Pattern: (X86cmov:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, 15:i8, EFLAGS:i32) 48266 // Emits: (CMOVNS32rm:i32 GR32:i32:$src2, addr:iPTR:$src1) 48267 // Pattern complexity = 30 cost = 1 size = 3 48268 if (CN1 == INT64_C(15)) { 48269 SDNode *Result = Emit_269(N, X86::CMOVNS32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48270 return Result; 48271 } 48272 48273 // Pattern: (X86cmov:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, 12:i8, EFLAGS:i32) 48274 // Emits: (CMOVS32rm:i32 GR32:i32:$src2, addr:iPTR:$src1) 48275 // Pattern complexity = 30 cost = 1 size = 3 48276 if (CN1 == INT64_C(12)) { 48277 SDNode *Result = Emit_269(N, X86::CMOVS32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48278 return Result; 48279 } 48280 48281 // Pattern: (X86cmov:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, 13:i8, EFLAGS:i32) 48282 // Emits: (CMOVNO32rm:i32 GR32:i32:$src2, addr:iPTR:$src1) 48283 // Pattern complexity = 30 cost = 1 size = 3 48284 if (CN1 == INT64_C(13)) { 48285 SDNode *Result = Emit_269(N, X86::CMOVNO32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48286 return Result; 48287 } 48288 48289 // Pattern: (X86cmov:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, 10:i8, EFLAGS:i32) 48290 // Emits: (CMOVO32rm:i32 GR32:i32:$src2, addr:iPTR:$src1) 48291 // Pattern complexity = 30 cost = 1 size = 3 48292 if (CN1 == INT64_C(10)) { 48293 SDNode *Result = Emit_269(N, X86::CMOVO32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48294 return Result; 48295 } 48296 48297 // Pattern: (X86cmov:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, 2:i8, EFLAGS:i32) 48298 // Emits: (CMOVAE32rm:i32 GR32:i32:$src2, addr:iPTR:$src1) 48299 // Pattern complexity = 30 cost = 1 size = 3 48300 if (CN1 == INT64_C(2)) { 48301 SDNode *Result = Emit_269(N, X86::CMOVAE32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48302 return Result; 48303 } 48304 48305 // Pattern: (X86cmov:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, 1:i8, EFLAGS:i32) 48306 // Emits: (CMOVB32rm:i32 GR32:i32:$src2, addr:iPTR:$src1) 48307 // Pattern complexity = 30 cost = 1 size = 3 48308 if (CN1 == INT64_C(1)) { 48309 SDNode *Result = Emit_269(N, X86::CMOVB32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48310 return Result; 48311 } 48312 48313 // Pattern: (X86cmov:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, 4:i8, EFLAGS:i32) 48314 // Emits: (CMOVNE32rm:i32 GR32:i32:$src2, addr:iPTR:$src1) 48315 // Pattern complexity = 30 cost = 1 size = 3 48316 if (CN1 == INT64_C(4)) { 48317 SDNode *Result = Emit_269(N, X86::CMOVNE32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48318 return Result; 48319 } 48320 48321 // Pattern: (X86cmov:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, 9:i8, EFLAGS:i32) 48322 // Emits: (CMOVE32rm:i32 GR32:i32:$src2, addr:iPTR:$src1) 48323 // Pattern complexity = 30 cost = 1 size = 3 48324 if (CN1 == INT64_C(9)) { 48325 SDNode *Result = Emit_269(N, X86::CMOVE32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48326 return Result; 48327 } 48328 48329 // Pattern: (X86cmov:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, 3:i8, EFLAGS:i32) 48330 // Emits: (CMOVA32rm:i32 GR32:i32:$src2, addr:iPTR:$src1) 48331 // Pattern complexity = 30 cost = 1 size = 3 48332 if (CN1 == INT64_C(3)) { 48333 SDNode *Result = Emit_269(N, X86::CMOVA32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48334 return Result; 48335 } 48336 48337 // Pattern: (X86cmov:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, 0:i8, EFLAGS:i32) 48338 // Emits: (CMOVBE32rm:i32 GR32:i32:$src2, addr:iPTR:$src1) 48339 // Pattern complexity = 30 cost = 1 size = 3 48340 if (CN1 == INT64_C(0)) { 48341 SDNode *Result = Emit_269(N, X86::CMOVBE32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48342 return Result; 48343 } 48344 48345 // Pattern: (X86cmov:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, 7:i8, EFLAGS:i32) 48346 // Emits: (CMOVGE32rm:i32 GR32:i32:$src2, addr:iPTR:$src1) 48347 // Pattern complexity = 30 cost = 1 size = 3 48348 if (CN1 == INT64_C(7)) { 48349 SDNode *Result = Emit_269(N, X86::CMOVGE32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48350 return Result; 48351 } 48352 48353 // Pattern: (X86cmov:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2, 6:i8, EFLAGS:i32) 48354 // Emits: (CMOVL32rm:i32 GR32:i32:$src2, addr:iPTR:$src1) 48355 // Pattern complexity = 30 cost = 1 size = 3 48356 if (CN1 == INT64_C(6)) { 48357 SDNode *Result = Emit_269(N, X86::CMOVL32rm, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48358 return Result; 48359 } 48360 } 48361 } 48362 } 48363 } 48364 } 48365 SDValue N0 = N.getOperand(0); 48366 SDValue N1 = N.getOperand(1); 48367 SDValue N2 = N.getOperand(2); 48368 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N2); 48369 if (Tmp0) { 48370 int64_t CN1 = Tmp0->getSExtValue(); 48371 48372 // Pattern: (X86cmov:i32 GR32:i32:$src1, GR32:i32:$src2, 2:i8, EFLAGS:i32) 48373 // Emits: (CMOVB32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 48374 // Pattern complexity = 8 cost = 1 size = 3 48375 if (CN1 == INT64_C(2)) { 48376 SDNode *Result = Emit_267(N, X86::CMOVB32rr, MVT::i32); 48377 return Result; 48378 } 48379 48380 // Pattern: (X86cmov:i32 GR32:i32:$src1, GR32:i32:$src2, 1:i8, EFLAGS:i32) 48381 // Emits: (CMOVAE32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 48382 // Pattern complexity = 8 cost = 1 size = 3 48383 if (CN1 == INT64_C(1)) { 48384 SDNode *Result = Emit_267(N, X86::CMOVAE32rr, MVT::i32); 48385 return Result; 48386 } 48387 48388 // Pattern: (X86cmov:i32 GR32:i32:$src1, GR32:i32:$src2, 4:i8, EFLAGS:i32) 48389 // Emits: (CMOVE32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 48390 // Pattern complexity = 8 cost = 1 size = 3 48391 if (CN1 == INT64_C(4)) { 48392 SDNode *Result = Emit_267(N, X86::CMOVE32rr, MVT::i32); 48393 return Result; 48394 } 48395 48396 // Pattern: (X86cmov:i32 GR32:i32:$src1, GR32:i32:$src2, 9:i8, EFLAGS:i32) 48397 // Emits: (CMOVNE32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 48398 // Pattern complexity = 8 cost = 1 size = 3 48399 if (CN1 == INT64_C(9)) { 48400 SDNode *Result = Emit_267(N, X86::CMOVNE32rr, MVT::i32); 48401 return Result; 48402 } 48403 48404 // Pattern: (X86cmov:i32 GR32:i32:$src1, GR32:i32:$src2, 3:i8, EFLAGS:i32) 48405 // Emits: (CMOVBE32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 48406 // Pattern complexity = 8 cost = 1 size = 3 48407 if (CN1 == INT64_C(3)) { 48408 SDNode *Result = Emit_267(N, X86::CMOVBE32rr, MVT::i32); 48409 return Result; 48410 } 48411 48412 // Pattern: (X86cmov:i32 GR32:i32:$src1, GR32:i32:$src2, 0:i8, EFLAGS:i32) 48413 // Emits: (CMOVA32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 48414 // Pattern complexity = 8 cost = 1 size = 3 48415 if (CN1 == INT64_C(0)) { 48416 SDNode *Result = Emit_267(N, X86::CMOVA32rr, MVT::i32); 48417 return Result; 48418 } 48419 48420 // Pattern: (X86cmov:i32 GR32:i32:$src1, GR32:i32:$src2, 7:i8, EFLAGS:i32) 48421 // Emits: (CMOVL32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 48422 // Pattern complexity = 8 cost = 1 size = 3 48423 if (CN1 == INT64_C(7)) { 48424 SDNode *Result = Emit_267(N, X86::CMOVL32rr, MVT::i32); 48425 return Result; 48426 } 48427 48428 // Pattern: (X86cmov:i32 GR32:i32:$src1, GR32:i32:$src2, 6:i8, EFLAGS:i32) 48429 // Emits: (CMOVGE32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 48430 // Pattern complexity = 8 cost = 1 size = 3 48431 if (CN1 == INT64_C(6)) { 48432 SDNode *Result = Emit_267(N, X86::CMOVGE32rr, MVT::i32); 48433 return Result; 48434 } 48435 48436 // Pattern: (X86cmov:i32 GR32:i32:$src1, GR32:i32:$src2, 8:i8, EFLAGS:i32) 48437 // Emits: (CMOVLE32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 48438 // Pattern complexity = 8 cost = 1 size = 3 48439 if (CN1 == INT64_C(8)) { 48440 SDNode *Result = Emit_267(N, X86::CMOVLE32rr, MVT::i32); 48441 return Result; 48442 } 48443 48444 // Pattern: (X86cmov:i32 GR32:i32:$src1, GR32:i32:$src2, 5:i8, EFLAGS:i32) 48445 // Emits: (CMOVG32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 48446 // Pattern complexity = 8 cost = 1 size = 3 48447 if (CN1 == INT64_C(5)) { 48448 SDNode *Result = Emit_267(N, X86::CMOVG32rr, MVT::i32); 48449 return Result; 48450 } 48451 48452 // Pattern: (X86cmov:i32 GR32:i32:$src1, GR32:i32:$src2, 15:i8, EFLAGS:i32) 48453 // Emits: (CMOVS32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 48454 // Pattern complexity = 8 cost = 1 size = 3 48455 if (CN1 == INT64_C(15)) { 48456 SDNode *Result = Emit_267(N, X86::CMOVS32rr, MVT::i32); 48457 return Result; 48458 } 48459 48460 // Pattern: (X86cmov:i32 GR32:i32:$src1, GR32:i32:$src2, 12:i8, EFLAGS:i32) 48461 // Emits: (CMOVNS32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 48462 // Pattern complexity = 8 cost = 1 size = 3 48463 if (CN1 == INT64_C(12)) { 48464 SDNode *Result = Emit_267(N, X86::CMOVNS32rr, MVT::i32); 48465 return Result; 48466 } 48467 48468 // Pattern: (X86cmov:i32 GR32:i32:$src1, GR32:i32:$src2, 14:i8, EFLAGS:i32) 48469 // Emits: (CMOVP32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 48470 // Pattern complexity = 8 cost = 1 size = 3 48471 if (CN1 == INT64_C(14)) { 48472 SDNode *Result = Emit_267(N, X86::CMOVP32rr, MVT::i32); 48473 return Result; 48474 } 48475 48476 // Pattern: (X86cmov:i32 GR32:i32:$src1, GR32:i32:$src2, 11:i8, EFLAGS:i32) 48477 // Emits: (CMOVNP32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 48478 // Pattern complexity = 8 cost = 1 size = 3 48479 if (CN1 == INT64_C(11)) { 48480 SDNode *Result = Emit_267(N, X86::CMOVNP32rr, MVT::i32); 48481 return Result; 48482 } 48483 48484 // Pattern: (X86cmov:i32 GR32:i32:$src1, GR32:i32:$src2, 13:i8, EFLAGS:i32) 48485 // Emits: (CMOVO32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 48486 // Pattern complexity = 8 cost = 1 size = 3 48487 if (CN1 == INT64_C(13)) { 48488 SDNode *Result = Emit_267(N, X86::CMOVO32rr, MVT::i32); 48489 return Result; 48490 } 48491 48492 // Pattern: (X86cmov:i32 GR32:i32:$src1, GR32:i32:$src2, 10:i8, EFLAGS:i32) 48493 // Emits: (CMOVNO32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 48494 // Pattern complexity = 8 cost = 1 size = 3 48495 if (CN1 == INT64_C(10)) { 48496 SDNode *Result = Emit_267(N, X86::CMOVNO32rr, MVT::i32); 48497 return Result; 48498 } 48499 } 48500 48501 CannotYetSelect(N); 48502 return NULL; 48503 } 48504 48505 SDNode *Select_X86ISD_CMOV_i64(const SDValue &N) { 48506 if (OptLevel != CodeGenOpt::None) { 48507 SDValue N0 = N.getOperand(0); 48508 { 48509 SDValue N1 = N.getOperand(1); 48510 if (N1.getOpcode() == ISD::LOAD && 48511 N1.hasOneUse() && 48512 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 48513 SDValue Chain1 = N1.getOperand(0); 48514 if (Predicate_unindexedload(N1.getNode()) && 48515 Predicate_load(N1.getNode()) && 48516 Predicate_loadi64(N1.getNode())) { 48517 SDValue N11 = N1.getOperand(1); 48518 SDValue CPTmpN11_0; 48519 SDValue CPTmpN11_1; 48520 SDValue CPTmpN11_2; 48521 SDValue CPTmpN11_3; 48522 SDValue CPTmpN11_4; 48523 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 48524 SDValue N2 = N.getOperand(2); 48525 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N2); 48526 if (Tmp0) { 48527 int64_t CN1 = Tmp0->getSExtValue(); 48528 48529 // Pattern: (X86cmov:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 2:i8, EFLAGS:i32) 48530 // Emits: (CMOVB64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 48531 // Pattern complexity = 30 cost = 1 size = 3 48532 if (CN1 == INT64_C(2)) { 48533 SDNode *Result = Emit_268(N, X86::CMOVB64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48534 return Result; 48535 } 48536 48537 // Pattern: (X86cmov:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 1:i8, EFLAGS:i32) 48538 // Emits: (CMOVAE64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 48539 // Pattern complexity = 30 cost = 1 size = 3 48540 if (CN1 == INT64_C(1)) { 48541 SDNode *Result = Emit_268(N, X86::CMOVAE64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48542 return Result; 48543 } 48544 48545 // Pattern: (X86cmov:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 4:i8, EFLAGS:i32) 48546 // Emits: (CMOVE64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 48547 // Pattern complexity = 30 cost = 1 size = 3 48548 if (CN1 == INT64_C(4)) { 48549 SDNode *Result = Emit_268(N, X86::CMOVE64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48550 return Result; 48551 } 48552 48553 // Pattern: (X86cmov:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 9:i8, EFLAGS:i32) 48554 // Emits: (CMOVNE64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 48555 // Pattern complexity = 30 cost = 1 size = 3 48556 if (CN1 == INT64_C(9)) { 48557 SDNode *Result = Emit_268(N, X86::CMOVNE64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48558 return Result; 48559 } 48560 48561 // Pattern: (X86cmov:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 3:i8, EFLAGS:i32) 48562 // Emits: (CMOVBE64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 48563 // Pattern complexity = 30 cost = 1 size = 3 48564 if (CN1 == INT64_C(3)) { 48565 SDNode *Result = Emit_268(N, X86::CMOVBE64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48566 return Result; 48567 } 48568 48569 // Pattern: (X86cmov:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 0:i8, EFLAGS:i32) 48570 // Emits: (CMOVA64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 48571 // Pattern complexity = 30 cost = 1 size = 3 48572 if (CN1 == INT64_C(0)) { 48573 SDNode *Result = Emit_268(N, X86::CMOVA64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48574 return Result; 48575 } 48576 48577 // Pattern: (X86cmov:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 7:i8, EFLAGS:i32) 48578 // Emits: (CMOVL64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 48579 // Pattern complexity = 30 cost = 1 size = 3 48580 if (CN1 == INT64_C(7)) { 48581 SDNode *Result = Emit_268(N, X86::CMOVL64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48582 return Result; 48583 } 48584 48585 // Pattern: (X86cmov:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 6:i8, EFLAGS:i32) 48586 // Emits: (CMOVGE64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 48587 // Pattern complexity = 30 cost = 1 size = 3 48588 if (CN1 == INT64_C(6)) { 48589 SDNode *Result = Emit_268(N, X86::CMOVGE64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48590 return Result; 48591 } 48592 48593 // Pattern: (X86cmov:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 8:i8, EFLAGS:i32) 48594 // Emits: (CMOVLE64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 48595 // Pattern complexity = 30 cost = 1 size = 3 48596 if (CN1 == INT64_C(8)) { 48597 SDNode *Result = Emit_268(N, X86::CMOVLE64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48598 return Result; 48599 } 48600 48601 // Pattern: (X86cmov:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 5:i8, EFLAGS:i32) 48602 // Emits: (CMOVG64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 48603 // Pattern complexity = 30 cost = 1 size = 3 48604 if (CN1 == INT64_C(5)) { 48605 SDNode *Result = Emit_268(N, X86::CMOVG64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48606 return Result; 48607 } 48608 48609 // Pattern: (X86cmov:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 15:i8, EFLAGS:i32) 48610 // Emits: (CMOVS64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 48611 // Pattern complexity = 30 cost = 1 size = 3 48612 if (CN1 == INT64_C(15)) { 48613 SDNode *Result = Emit_268(N, X86::CMOVS64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48614 return Result; 48615 } 48616 48617 // Pattern: (X86cmov:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 12:i8, EFLAGS:i32) 48618 // Emits: (CMOVNS64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 48619 // Pattern complexity = 30 cost = 1 size = 3 48620 if (CN1 == INT64_C(12)) { 48621 SDNode *Result = Emit_268(N, X86::CMOVNS64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48622 return Result; 48623 } 48624 48625 // Pattern: (X86cmov:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 14:i8, EFLAGS:i32) 48626 // Emits: (CMOVP64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 48627 // Pattern complexity = 30 cost = 1 size = 3 48628 if (CN1 == INT64_C(14)) { 48629 SDNode *Result = Emit_268(N, X86::CMOVP64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48630 return Result; 48631 } 48632 48633 // Pattern: (X86cmov:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 11:i8, EFLAGS:i32) 48634 // Emits: (CMOVNP64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 48635 // Pattern complexity = 30 cost = 1 size = 3 48636 if (CN1 == INT64_C(11)) { 48637 SDNode *Result = Emit_268(N, X86::CMOVNP64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48638 return Result; 48639 } 48640 48641 // Pattern: (X86cmov:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 13:i8, EFLAGS:i32) 48642 // Emits: (CMOVO64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 48643 // Pattern complexity = 30 cost = 1 size = 3 48644 if (CN1 == INT64_C(13)) { 48645 SDNode *Result = Emit_268(N, X86::CMOVO64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48646 return Result; 48647 } 48648 48649 // Pattern: (X86cmov:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, 10:i8, EFLAGS:i32) 48650 // Emits: (CMOVNO64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 48651 // Pattern complexity = 30 cost = 1 size = 3 48652 if (CN1 == INT64_C(10)) { 48653 SDNode *Result = Emit_268(N, X86::CMOVNO64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 48654 return Result; 48655 } 48656 } 48657 } 48658 } 48659 } 48660 } 48661 if (N0.getOpcode() == ISD::LOAD && 48662 N0.hasOneUse() && 48663 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 48664 SDValue Chain0 = N0.getOperand(0); 48665 if (Predicate_unindexedload(N0.getNode()) && 48666 Predicate_load(N0.getNode()) && 48667 Predicate_loadi64(N0.getNode())) { 48668 SDValue N01 = N0.getOperand(1); 48669 SDValue CPTmpN01_0; 48670 SDValue CPTmpN01_1; 48671 SDValue CPTmpN01_2; 48672 SDValue CPTmpN01_3; 48673 SDValue CPTmpN01_4; 48674 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 48675 SDValue N1 = N.getOperand(1); 48676 SDValue N2 = N.getOperand(2); 48677 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N2); 48678 if (Tmp0) { 48679 int64_t CN1 = Tmp0->getSExtValue(); 48680 48681 // Pattern: (X86cmov:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, 2:i8, EFLAGS:i32) 48682 // Emits: (CMOVAE64rm:i64 GR64:i64:$src2, addr:iPTR:$src1) 48683 // Pattern complexity = 30 cost = 1 size = 3 48684 if (CN1 == INT64_C(2)) { 48685 SDNode *Result = Emit_269(N, X86::CMOVAE64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48686 return Result; 48687 } 48688 48689 // Pattern: (X86cmov:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, 1:i8, EFLAGS:i32) 48690 // Emits: (CMOVB64rm:i64 GR64:i64:$src2, addr:iPTR:$src1) 48691 // Pattern complexity = 30 cost = 1 size = 3 48692 if (CN1 == INT64_C(1)) { 48693 SDNode *Result = Emit_269(N, X86::CMOVB64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48694 return Result; 48695 } 48696 48697 // Pattern: (X86cmov:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, 4:i8, EFLAGS:i32) 48698 // Emits: (CMOVNE64rm:i64 GR64:i64:$src2, addr:iPTR:$src1) 48699 // Pattern complexity = 30 cost = 1 size = 3 48700 if (CN1 == INT64_C(4)) { 48701 SDNode *Result = Emit_269(N, X86::CMOVNE64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48702 return Result; 48703 } 48704 48705 // Pattern: (X86cmov:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, 9:i8, EFLAGS:i32) 48706 // Emits: (CMOVE64rm:i64 GR64:i64:$src2, addr:iPTR:$src1) 48707 // Pattern complexity = 30 cost = 1 size = 3 48708 if (CN1 == INT64_C(9)) { 48709 SDNode *Result = Emit_269(N, X86::CMOVE64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48710 return Result; 48711 } 48712 48713 // Pattern: (X86cmov:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, 3:i8, EFLAGS:i32) 48714 // Emits: (CMOVA64rm:i64 GR64:i64:$src2, addr:iPTR:$src1) 48715 // Pattern complexity = 30 cost = 1 size = 3 48716 if (CN1 == INT64_C(3)) { 48717 SDNode *Result = Emit_269(N, X86::CMOVA64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48718 return Result; 48719 } 48720 48721 // Pattern: (X86cmov:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, 0:i8, EFLAGS:i32) 48722 // Emits: (CMOVBE64rm:i64 GR64:i64:$src2, addr:iPTR:$src1) 48723 // Pattern complexity = 30 cost = 1 size = 3 48724 if (CN1 == INT64_C(0)) { 48725 SDNode *Result = Emit_269(N, X86::CMOVBE64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48726 return Result; 48727 } 48728 48729 // Pattern: (X86cmov:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, 7:i8, EFLAGS:i32) 48730 // Emits: (CMOVGE64rm:i64 GR64:i64:$src2, addr:iPTR:$src1) 48731 // Pattern complexity = 30 cost = 1 size = 3 48732 if (CN1 == INT64_C(7)) { 48733 SDNode *Result = Emit_269(N, X86::CMOVGE64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48734 return Result; 48735 } 48736 48737 // Pattern: (X86cmov:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, 6:i8, EFLAGS:i32) 48738 // Emits: (CMOVL64rm:i64 GR64:i64:$src2, addr:iPTR:$src1) 48739 // Pattern complexity = 30 cost = 1 size = 3 48740 if (CN1 == INT64_C(6)) { 48741 SDNode *Result = Emit_269(N, X86::CMOVL64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48742 return Result; 48743 } 48744 48745 // Pattern: (X86cmov:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, 8:i8, EFLAGS:i32) 48746 // Emits: (CMOVG64rm:i64 GR64:i64:$src2, addr:iPTR:$src1) 48747 // Pattern complexity = 30 cost = 1 size = 3 48748 if (CN1 == INT64_C(8)) { 48749 SDNode *Result = Emit_269(N, X86::CMOVG64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48750 return Result; 48751 } 48752 48753 // Pattern: (X86cmov:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, 5:i8, EFLAGS:i32) 48754 // Emits: (CMOVLE64rm:i64 GR64:i64:$src2, addr:iPTR:$src1) 48755 // Pattern complexity = 30 cost = 1 size = 3 48756 if (CN1 == INT64_C(5)) { 48757 SDNode *Result = Emit_269(N, X86::CMOVLE64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48758 return Result; 48759 } 48760 48761 // Pattern: (X86cmov:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, 14:i8, EFLAGS:i32) 48762 // Emits: (CMOVNP64rm:i64 GR64:i64:$src2, addr:iPTR:$src1) 48763 // Pattern complexity = 30 cost = 1 size = 3 48764 if (CN1 == INT64_C(14)) { 48765 SDNode *Result = Emit_269(N, X86::CMOVNP64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48766 return Result; 48767 } 48768 48769 // Pattern: (X86cmov:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, 11:i8, EFLAGS:i32) 48770 // Emits: (CMOVP64rm:i64 GR64:i64:$src2, addr:iPTR:$src1) 48771 // Pattern complexity = 30 cost = 1 size = 3 48772 if (CN1 == INT64_C(11)) { 48773 SDNode *Result = Emit_269(N, X86::CMOVP64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48774 return Result; 48775 } 48776 48777 // Pattern: (X86cmov:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, 15:i8, EFLAGS:i32) 48778 // Emits: (CMOVNS64rm:i64 GR64:i64:$src2, addr:iPTR:$src1) 48779 // Pattern complexity = 30 cost = 1 size = 3 48780 if (CN1 == INT64_C(15)) { 48781 SDNode *Result = Emit_269(N, X86::CMOVNS64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48782 return Result; 48783 } 48784 48785 // Pattern: (X86cmov:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, 12:i8, EFLAGS:i32) 48786 // Emits: (CMOVS64rm:i64 GR64:i64:$src2, addr:iPTR:$src1) 48787 // Pattern complexity = 30 cost = 1 size = 3 48788 if (CN1 == INT64_C(12)) { 48789 SDNode *Result = Emit_269(N, X86::CMOVS64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48790 return Result; 48791 } 48792 48793 // Pattern: (X86cmov:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, 13:i8, EFLAGS:i32) 48794 // Emits: (CMOVNO64rm:i64 GR64:i64:$src2, addr:iPTR:$src1) 48795 // Pattern complexity = 30 cost = 1 size = 3 48796 if (CN1 == INT64_C(13)) { 48797 SDNode *Result = Emit_269(N, X86::CMOVNO64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48798 return Result; 48799 } 48800 48801 // Pattern: (X86cmov:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2, 10:i8, EFLAGS:i32) 48802 // Emits: (CMOVO64rm:i64 GR64:i64:$src2, addr:iPTR:$src1) 48803 // Pattern complexity = 30 cost = 1 size = 3 48804 if (CN1 == INT64_C(10)) { 48805 SDNode *Result = Emit_269(N, X86::CMOVO64rm, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 48806 return Result; 48807 } 48808 } 48809 } 48810 } 48811 } 48812 } 48813 SDValue N0 = N.getOperand(0); 48814 SDValue N1 = N.getOperand(1); 48815 SDValue N2 = N.getOperand(2); 48816 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N2); 48817 if (Tmp0) { 48818 int64_t CN1 = Tmp0->getSExtValue(); 48819 48820 // Pattern: (X86cmov:i64 GR64:i64:$src1, GR64:i64:$src2, 2:i8, EFLAGS:i32) 48821 // Emits: (CMOVB64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 48822 // Pattern complexity = 8 cost = 1 size = 3 48823 if (CN1 == INT64_C(2)) { 48824 SDNode *Result = Emit_267(N, X86::CMOVB64rr, MVT::i64); 48825 return Result; 48826 } 48827 48828 // Pattern: (X86cmov:i64 GR64:i64:$src1, GR64:i64:$src2, 1:i8, EFLAGS:i32) 48829 // Emits: (CMOVAE64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 48830 // Pattern complexity = 8 cost = 1 size = 3 48831 if (CN1 == INT64_C(1)) { 48832 SDNode *Result = Emit_267(N, X86::CMOVAE64rr, MVT::i64); 48833 return Result; 48834 } 48835 48836 // Pattern: (X86cmov:i64 GR64:i64:$src1, GR64:i64:$src2, 4:i8, EFLAGS:i32) 48837 // Emits: (CMOVE64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 48838 // Pattern complexity = 8 cost = 1 size = 3 48839 if (CN1 == INT64_C(4)) { 48840 SDNode *Result = Emit_267(N, X86::CMOVE64rr, MVT::i64); 48841 return Result; 48842 } 48843 48844 // Pattern: (X86cmov:i64 GR64:i64:$src1, GR64:i64:$src2, 9:i8, EFLAGS:i32) 48845 // Emits: (CMOVNE64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 48846 // Pattern complexity = 8 cost = 1 size = 3 48847 if (CN1 == INT64_C(9)) { 48848 SDNode *Result = Emit_267(N, X86::CMOVNE64rr, MVT::i64); 48849 return Result; 48850 } 48851 48852 // Pattern: (X86cmov:i64 GR64:i64:$src1, GR64:i64:$src2, 3:i8, EFLAGS:i32) 48853 // Emits: (CMOVBE64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 48854 // Pattern complexity = 8 cost = 1 size = 3 48855 if (CN1 == INT64_C(3)) { 48856 SDNode *Result = Emit_267(N, X86::CMOVBE64rr, MVT::i64); 48857 return Result; 48858 } 48859 48860 // Pattern: (X86cmov:i64 GR64:i64:$src1, GR64:i64:$src2, 0:i8, EFLAGS:i32) 48861 // Emits: (CMOVA64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 48862 // Pattern complexity = 8 cost = 1 size = 3 48863 if (CN1 == INT64_C(0)) { 48864 SDNode *Result = Emit_267(N, X86::CMOVA64rr, MVT::i64); 48865 return Result; 48866 } 48867 48868 // Pattern: (X86cmov:i64 GR64:i64:$src1, GR64:i64:$src2, 7:i8, EFLAGS:i32) 48869 // Emits: (CMOVL64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 48870 // Pattern complexity = 8 cost = 1 size = 3 48871 if (CN1 == INT64_C(7)) { 48872 SDNode *Result = Emit_267(N, X86::CMOVL64rr, MVT::i64); 48873 return Result; 48874 } 48875 48876 // Pattern: (X86cmov:i64 GR64:i64:$src1, GR64:i64:$src2, 6:i8, EFLAGS:i32) 48877 // Emits: (CMOVGE64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 48878 // Pattern complexity = 8 cost = 1 size = 3 48879 if (CN1 == INT64_C(6)) { 48880 SDNode *Result = Emit_267(N, X86::CMOVGE64rr, MVT::i64); 48881 return Result; 48882 } 48883 48884 // Pattern: (X86cmov:i64 GR64:i64:$src1, GR64:i64:$src2, 8:i8, EFLAGS:i32) 48885 // Emits: (CMOVLE64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 48886 // Pattern complexity = 8 cost = 1 size = 3 48887 if (CN1 == INT64_C(8)) { 48888 SDNode *Result = Emit_267(N, X86::CMOVLE64rr, MVT::i64); 48889 return Result; 48890 } 48891 48892 // Pattern: (X86cmov:i64 GR64:i64:$src1, GR64:i64:$src2, 5:i8, EFLAGS:i32) 48893 // Emits: (CMOVG64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 48894 // Pattern complexity = 8 cost = 1 size = 3 48895 if (CN1 == INT64_C(5)) { 48896 SDNode *Result = Emit_267(N, X86::CMOVG64rr, MVT::i64); 48897 return Result; 48898 } 48899 48900 // Pattern: (X86cmov:i64 GR64:i64:$src1, GR64:i64:$src2, 15:i8, EFLAGS:i32) 48901 // Emits: (CMOVS64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 48902 // Pattern complexity = 8 cost = 1 size = 3 48903 if (CN1 == INT64_C(15)) { 48904 SDNode *Result = Emit_267(N, X86::CMOVS64rr, MVT::i64); 48905 return Result; 48906 } 48907 48908 // Pattern: (X86cmov:i64 GR64:i64:$src1, GR64:i64:$src2, 12:i8, EFLAGS:i32) 48909 // Emits: (CMOVNS64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 48910 // Pattern complexity = 8 cost = 1 size = 3 48911 if (CN1 == INT64_C(12)) { 48912 SDNode *Result = Emit_267(N, X86::CMOVNS64rr, MVT::i64); 48913 return Result; 48914 } 48915 48916 // Pattern: (X86cmov:i64 GR64:i64:$src1, GR64:i64:$src2, 14:i8, EFLAGS:i32) 48917 // Emits: (CMOVP64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 48918 // Pattern complexity = 8 cost = 1 size = 3 48919 if (CN1 == INT64_C(14)) { 48920 SDNode *Result = Emit_267(N, X86::CMOVP64rr, MVT::i64); 48921 return Result; 48922 } 48923 48924 // Pattern: (X86cmov:i64 GR64:i64:$src1, GR64:i64:$src2, 11:i8, EFLAGS:i32) 48925 // Emits: (CMOVNP64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 48926 // Pattern complexity = 8 cost = 1 size = 3 48927 if (CN1 == INT64_C(11)) { 48928 SDNode *Result = Emit_267(N, X86::CMOVNP64rr, MVT::i64); 48929 return Result; 48930 } 48931 48932 // Pattern: (X86cmov:i64 GR64:i64:$src1, GR64:i64:$src2, 13:i8, EFLAGS:i32) 48933 // Emits: (CMOVO64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 48934 // Pattern complexity = 8 cost = 1 size = 3 48935 if (CN1 == INT64_C(13)) { 48936 SDNode *Result = Emit_267(N, X86::CMOVO64rr, MVT::i64); 48937 return Result; 48938 } 48939 48940 // Pattern: (X86cmov:i64 GR64:i64:$src1, GR64:i64:$src2, 10:i8, EFLAGS:i32) 48941 // Emits: (CMOVNO64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 48942 // Pattern complexity = 8 cost = 1 size = 3 48943 if (CN1 == INT64_C(10)) { 48944 SDNode *Result = Emit_267(N, X86::CMOVNO64rr, MVT::i64); 48945 return Result; 48946 } 48947 } 48948 48949 CannotYetSelect(N); 48950 return NULL; 48951 } 48952 48953 SDNode *Emit_270(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 48954 SDValue N0 = N.getOperand(0); 48955 SDValue N1 = N.getOperand(1); 48956 SDValue N2 = N.getOperand(2); 48957 SDValue N3 = N.getOperand(3); 48958 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N2)->getZExtValue()), MVT::i8); 48959 SDValue Chain = CurDAG->getEntryNode(); 48960 SDValue InFlag(0, 0); 48961 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::EFLAGS, N3, InFlag).getNode(); 48962 Chain = SDValue(ResNode, 0); 48963 InFlag = SDValue(ResNode, 1); 48964 SDValue Ops0[] = { N0, N1, Tmp2, InFlag }; 48965 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, Ops0, 4); 48966 } 48967 SDNode *Select_X86ISD_CMOV_f32(const SDValue &N) { 48968 if ((!Subtarget->hasSSE1())) { 48969 SDValue N0 = N.getOperand(0); 48970 SDValue N1 = N.getOperand(1); 48971 SDValue N2 = N.getOperand(2); 48972 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N2); 48973 if (Tmp0) { 48974 int64_t CN1 = Tmp0->getSExtValue(); 48975 48976 // Pattern: (X86cmov:f32 RFP32:f32:$src1, RFP32:f32:$src2, 2:i8, EFLAGS:i32) 48977 // Emits: (CMOVB_Fp32:f32 RFP32:f32:$src1, RFP32:f32:$src2) 48978 // Pattern complexity = 8 cost = 1 size = 0 48979 if (CN1 == INT64_C(2)) { 48980 SDNode *Result = Emit_267(N, X86::CMOVB_Fp32, MVT::f32); 48981 return Result; 48982 } 48983 48984 // Pattern: (X86cmov:f32 RFP32:f32:$src1, RFP32:f32:$src2, 3:i8, EFLAGS:i32) 48985 // Emits: (CMOVBE_Fp32:f32 RFP32:f32:$src1, RFP32:f32:$src2) 48986 // Pattern complexity = 8 cost = 1 size = 0 48987 if (CN1 == INT64_C(3)) { 48988 SDNode *Result = Emit_267(N, X86::CMOVBE_Fp32, MVT::f32); 48989 return Result; 48990 } 48991 48992 // Pattern: (X86cmov:f32 RFP32:f32:$src1, RFP32:f32:$src2, 4:i8, EFLAGS:i32) 48993 // Emits: (CMOVE_Fp32:f32 RFP32:f32:$src1, RFP32:f32:$src2) 48994 // Pattern complexity = 8 cost = 1 size = 0 48995 if (CN1 == INT64_C(4)) { 48996 SDNode *Result = Emit_267(N, X86::CMOVE_Fp32, MVT::f32); 48997 return Result; 48998 } 48999 49000 // Pattern: (X86cmov:f32 RFP32:f32:$src1, RFP32:f32:$src2, 14:i8, EFLAGS:i32) 49001 // Emits: (CMOVP_Fp32:f32 RFP32:f32:$src1, RFP32:f32:$src2) 49002 // Pattern complexity = 8 cost = 1 size = 0 49003 if (CN1 == INT64_C(14)) { 49004 SDNode *Result = Emit_267(N, X86::CMOVP_Fp32, MVT::f32); 49005 return Result; 49006 } 49007 49008 // Pattern: (X86cmov:f32 RFP32:f32:$src1, RFP32:f32:$src2, 1:i8, EFLAGS:i32) 49009 // Emits: (CMOVNB_Fp32:f32 RFP32:f32:$src1, RFP32:f32:$src2) 49010 // Pattern complexity = 8 cost = 1 size = 0 49011 if (CN1 == INT64_C(1)) { 49012 SDNode *Result = Emit_267(N, X86::CMOVNB_Fp32, MVT::f32); 49013 return Result; 49014 } 49015 49016 // Pattern: (X86cmov:f32 RFP32:f32:$src1, RFP32:f32:$src2, 0:i8, EFLAGS:i32) 49017 // Emits: (CMOVNBE_Fp32:f32 RFP32:f32:$src1, RFP32:f32:$src2) 49018 // Pattern complexity = 8 cost = 1 size = 0 49019 if (CN1 == INT64_C(0)) { 49020 SDNode *Result = Emit_267(N, X86::CMOVNBE_Fp32, MVT::f32); 49021 return Result; 49022 } 49023 49024 // Pattern: (X86cmov:f32 RFP32:f32:$src1, RFP32:f32:$src2, 9:i8, EFLAGS:i32) 49025 // Emits: (CMOVNE_Fp32:f32 RFP32:f32:$src1, RFP32:f32:$src2) 49026 // Pattern complexity = 8 cost = 1 size = 0 49027 if (CN1 == INT64_C(9)) { 49028 SDNode *Result = Emit_267(N, X86::CMOVNE_Fp32, MVT::f32); 49029 return Result; 49030 } 49031 49032 // Pattern: (X86cmov:f32 RFP32:f32:$src1, RFP32:f32:$src2, 11:i8, EFLAGS:i32) 49033 // Emits: (CMOVNP_Fp32:f32 RFP32:f32:$src1, RFP32:f32:$src2) 49034 // Pattern complexity = 8 cost = 1 size = 0 49035 if (CN1 == INT64_C(11)) { 49036 SDNode *Result = Emit_267(N, X86::CMOVNP_Fp32, MVT::f32); 49037 return Result; 49038 } 49039 } 49040 } 49041 49042 // Pattern: (X86cmov:f32 FR32:f32:$t, FR32:f32:$f, (imm:i8):$cond, EFLAGS:i32) 49043 // Emits: (CMOV_FR32:f32 FR32:f32:$t, FR32:f32:$f, (imm:i8):$cond) 49044 // Pattern complexity = 6 cost = 11 size = 3 49045 SDValue N0 = N.getOperand(0); 49046 SDValue N1 = N.getOperand(1); 49047 SDValue N2 = N.getOperand(2); 49048 if (N2.getOpcode() == ISD::Constant) { 49049 SDNode *Result = Emit_270(N, X86::CMOV_FR32, MVT::f32); 49050 return Result; 49051 } 49052 49053 CannotYetSelect(N); 49054 return NULL; 49055 } 49056 49057 SDNode *Select_X86ISD_CMOV_f64(const SDValue &N) { 49058 if ((!Subtarget->hasSSE2())) { 49059 SDValue N0 = N.getOperand(0); 49060 SDValue N1 = N.getOperand(1); 49061 SDValue N2 = N.getOperand(2); 49062 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N2); 49063 if (Tmp0) { 49064 int64_t CN1 = Tmp0->getSExtValue(); 49065 49066 // Pattern: (X86cmov:f64 RFP64:f64:$src1, RFP64:f64:$src2, 2:i8, EFLAGS:i32) 49067 // Emits: (CMOVB_Fp64:f64 RFP64:f64:$src1, RFP64:f64:$src2) 49068 // Pattern complexity = 8 cost = 1 size = 0 49069 if (CN1 == INT64_C(2)) { 49070 SDNode *Result = Emit_267(N, X86::CMOVB_Fp64, MVT::f64); 49071 return Result; 49072 } 49073 49074 // Pattern: (X86cmov:f64 RFP64:f64:$src1, RFP64:f64:$src2, 3:i8, EFLAGS:i32) 49075 // Emits: (CMOVBE_Fp64:f64 RFP64:f64:$src1, RFP64:f64:$src2) 49076 // Pattern complexity = 8 cost = 1 size = 0 49077 if (CN1 == INT64_C(3)) { 49078 SDNode *Result = Emit_267(N, X86::CMOVBE_Fp64, MVT::f64); 49079 return Result; 49080 } 49081 49082 // Pattern: (X86cmov:f64 RFP64:f64:$src1, RFP64:f64:$src2, 4:i8, EFLAGS:i32) 49083 // Emits: (CMOVE_Fp64:f64 RFP64:f64:$src1, RFP64:f64:$src2) 49084 // Pattern complexity = 8 cost = 1 size = 0 49085 if (CN1 == INT64_C(4)) { 49086 SDNode *Result = Emit_267(N, X86::CMOVE_Fp64, MVT::f64); 49087 return Result; 49088 } 49089 49090 // Pattern: (X86cmov:f64 RFP64:f64:$src1, RFP64:f64:$src2, 14:i8, EFLAGS:i32) 49091 // Emits: (CMOVP_Fp64:f64 RFP64:f64:$src1, RFP64:f64:$src2) 49092 // Pattern complexity = 8 cost = 1 size = 0 49093 if (CN1 == INT64_C(14)) { 49094 SDNode *Result = Emit_267(N, X86::CMOVP_Fp64, MVT::f64); 49095 return Result; 49096 } 49097 49098 // Pattern: (X86cmov:f64 RFP64:f64:$src1, RFP64:f64:$src2, 1:i8, EFLAGS:i32) 49099 // Emits: (CMOVNB_Fp64:f64 RFP64:f64:$src1, RFP64:f64:$src2) 49100 // Pattern complexity = 8 cost = 1 size = 0 49101 if (CN1 == INT64_C(1)) { 49102 SDNode *Result = Emit_267(N, X86::CMOVNB_Fp64, MVT::f64); 49103 return Result; 49104 } 49105 49106 // Pattern: (X86cmov:f64 RFP64:f64:$src1, RFP64:f64:$src2, 0:i8, EFLAGS:i32) 49107 // Emits: (CMOVNBE_Fp64:f64 RFP64:f64:$src1, RFP64:f64:$src2) 49108 // Pattern complexity = 8 cost = 1 size = 0 49109 if (CN1 == INT64_C(0)) { 49110 SDNode *Result = Emit_267(N, X86::CMOVNBE_Fp64, MVT::f64); 49111 return Result; 49112 } 49113 49114 // Pattern: (X86cmov:f64 RFP64:f64:$src1, RFP64:f64:$src2, 9:i8, EFLAGS:i32) 49115 // Emits: (CMOVNE_Fp64:f64 RFP64:f64:$src1, RFP64:f64:$src2) 49116 // Pattern complexity = 8 cost = 1 size = 0 49117 if (CN1 == INT64_C(9)) { 49118 SDNode *Result = Emit_267(N, X86::CMOVNE_Fp64, MVT::f64); 49119 return Result; 49120 } 49121 49122 // Pattern: (X86cmov:f64 RFP64:f64:$src1, RFP64:f64:$src2, 11:i8, EFLAGS:i32) 49123 // Emits: (CMOVNP_Fp64:f64 RFP64:f64:$src1, RFP64:f64:$src2) 49124 // Pattern complexity = 8 cost = 1 size = 0 49125 if (CN1 == INT64_C(11)) { 49126 SDNode *Result = Emit_267(N, X86::CMOVNP_Fp64, MVT::f64); 49127 return Result; 49128 } 49129 } 49130 } 49131 49132 // Pattern: (X86cmov:f64 FR64:f64:$t, FR64:f64:$f, (imm:i8):$cond, EFLAGS:i32) 49133 // Emits: (CMOV_FR64:f64 FR64:f64:$t, FR64:f64:$f, (imm:i8):$cond) 49134 // Pattern complexity = 6 cost = 11 size = 3 49135 SDValue N0 = N.getOperand(0); 49136 SDValue N1 = N.getOperand(1); 49137 SDValue N2 = N.getOperand(2); 49138 if (N2.getOpcode() == ISD::Constant) { 49139 SDNode *Result = Emit_270(N, X86::CMOV_FR64, MVT::f64); 49140 return Result; 49141 } 49142 49143 CannotYetSelect(N); 49144 return NULL; 49145 } 49146 49147 SDNode *Select_X86ISD_CMOV_f80(const SDValue &N) { 49148 SDValue N0 = N.getOperand(0); 49149 SDValue N1 = N.getOperand(1); 49150 SDValue N2 = N.getOperand(2); 49151 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N2); 49152 if (Tmp0) { 49153 int64_t CN1 = Tmp0->getSExtValue(); 49154 49155 // Pattern: (X86cmov:f80 RFP80:f80:$src1, RFP80:f80:$src2, 2:i8, EFLAGS:i32) 49156 // Emits: (CMOVB_Fp80:f80 RFP80:f80:$src1, RFP80:f80:$src2) 49157 // Pattern complexity = 8 cost = 1 size = 0 49158 if (CN1 == INT64_C(2)) { 49159 SDNode *Result = Emit_267(N, X86::CMOVB_Fp80, MVT::f80); 49160 return Result; 49161 } 49162 49163 // Pattern: (X86cmov:f80 RFP80:f80:$src1, RFP80:f80:$src2, 3:i8, EFLAGS:i32) 49164 // Emits: (CMOVBE_Fp80:f80 RFP80:f80:$src1, RFP80:f80:$src2) 49165 // Pattern complexity = 8 cost = 1 size = 0 49166 if (CN1 == INT64_C(3)) { 49167 SDNode *Result = Emit_267(N, X86::CMOVBE_Fp80, MVT::f80); 49168 return Result; 49169 } 49170 49171 // Pattern: (X86cmov:f80 RFP80:f80:$src1, RFP80:f80:$src2, 4:i8, EFLAGS:i32) 49172 // Emits: (CMOVE_Fp80:f80 RFP80:f80:$src1, RFP80:f80:$src2) 49173 // Pattern complexity = 8 cost = 1 size = 0 49174 if (CN1 == INT64_C(4)) { 49175 SDNode *Result = Emit_267(N, X86::CMOVE_Fp80, MVT::f80); 49176 return Result; 49177 } 49178 49179 // Pattern: (X86cmov:f80 RFP80:f80:$src1, RFP80:f80:$src2, 14:i8, EFLAGS:i32) 49180 // Emits: (CMOVP_Fp80:f80 RFP80:f80:$src1, RFP80:f80:$src2) 49181 // Pattern complexity = 8 cost = 1 size = 0 49182 if (CN1 == INT64_C(14)) { 49183 SDNode *Result = Emit_267(N, X86::CMOVP_Fp80, MVT::f80); 49184 return Result; 49185 } 49186 49187 // Pattern: (X86cmov:f80 RFP80:f80:$src1, RFP80:f80:$src2, 1:i8, EFLAGS:i32) 49188 // Emits: (CMOVNB_Fp80:f80 RFP80:f80:$src1, RFP80:f80:$src2) 49189 // Pattern complexity = 8 cost = 1 size = 0 49190 if (CN1 == INT64_C(1)) { 49191 SDNode *Result = Emit_267(N, X86::CMOVNB_Fp80, MVT::f80); 49192 return Result; 49193 } 49194 49195 // Pattern: (X86cmov:f80 RFP80:f80:$src1, RFP80:f80:$src2, 0:i8, EFLAGS:i32) 49196 // Emits: (CMOVNBE_Fp80:f80 RFP80:f80:$src1, RFP80:f80:$src2) 49197 // Pattern complexity = 8 cost = 1 size = 0 49198 if (CN1 == INT64_C(0)) { 49199 SDNode *Result = Emit_267(N, X86::CMOVNBE_Fp80, MVT::f80); 49200 return Result; 49201 } 49202 49203 // Pattern: (X86cmov:f80 RFP80:f80:$src1, RFP80:f80:$src2, 9:i8, EFLAGS:i32) 49204 // Emits: (CMOVNE_Fp80:f80 RFP80:f80:$src1, RFP80:f80:$src2) 49205 // Pattern complexity = 8 cost = 1 size = 0 49206 if (CN1 == INT64_C(9)) { 49207 SDNode *Result = Emit_267(N, X86::CMOVNE_Fp80, MVT::f80); 49208 return Result; 49209 } 49210 49211 // Pattern: (X86cmov:f80 RFP80:f80:$src1, RFP80:f80:$src2, 11:i8, EFLAGS:i32) 49212 // Emits: (CMOVNP_Fp80:f80 RFP80:f80:$src1, RFP80:f80:$src2) 49213 // Pattern complexity = 8 cost = 1 size = 0 49214 if (CN1 == INT64_C(11)) { 49215 SDNode *Result = Emit_267(N, X86::CMOVNP_Fp80, MVT::f80); 49216 return Result; 49217 } 49218 } 49219 49220 CannotYetSelect(N); 49221 return NULL; 49222 } 49223 49224 SDNode *Select_X86ISD_CMOV_v1i64(const SDValue &N) { 49225 SDValue N0 = N.getOperand(0); 49226 SDValue N1 = N.getOperand(1); 49227 SDValue N2 = N.getOperand(2); 49228 if (N2.getOpcode() == ISD::Constant) { 49229 SDNode *Result = Emit_270(N, X86::CMOV_V1I64, MVT::v1i64); 49230 return Result; 49231 } 49232 49233 CannotYetSelect(N); 49234 return NULL; 49235 } 49236 49237 SDNode *Select_X86ISD_CMOV_v2i64(const SDValue &N) { 49238 SDValue N0 = N.getOperand(0); 49239 SDValue N1 = N.getOperand(1); 49240 SDValue N2 = N.getOperand(2); 49241 if (N2.getOpcode() == ISD::Constant) { 49242 SDNode *Result = Emit_270(N, X86::CMOV_V2I64, MVT::v2i64); 49243 return Result; 49244 } 49245 49246 CannotYetSelect(N); 49247 return NULL; 49248 } 49249 49250 SDNode *Select_X86ISD_CMOV_v4f32(const SDValue &N) { 49251 SDValue N0 = N.getOperand(0); 49252 SDValue N1 = N.getOperand(1); 49253 SDValue N2 = N.getOperand(2); 49254 if (N2.getOpcode() == ISD::Constant) { 49255 SDNode *Result = Emit_270(N, X86::CMOV_V4F32, MVT::v4f32); 49256 return Result; 49257 } 49258 49259 CannotYetSelect(N); 49260 return NULL; 49261 } 49262 49263 SDNode *Select_X86ISD_CMOV_v2f64(const SDValue &N) { 49264 SDValue N0 = N.getOperand(0); 49265 SDValue N1 = N.getOperand(1); 49266 SDValue N2 = N.getOperand(2); 49267 if (N2.getOpcode() == ISD::Constant) { 49268 SDNode *Result = Emit_270(N, X86::CMOV_V2F64, MVT::v2f64); 49269 return Result; 49270 } 49271 49272 CannotYetSelect(N); 49273 return NULL; 49274 } 49275 49276 SDNode *Emit_271(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 49277 SDValue N0 = N.getOperand(0); 49278 SDValue N00 = N0.getOperand(0); 49279 SDValue N01 = N0.getOperand(1); 49280 SDValue N1 = N.getOperand(1); 49281 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, N00, N01); 49282 } 49283 SDNode *Emit_272(const SDValue &N, unsigned Opc0, SDValue &CPTmpN011_0, SDValue &CPTmpN011_1, SDValue &CPTmpN011_2, SDValue &CPTmpN011_3, SDValue &CPTmpN011_4) DISABLE_INLINE { 49284 SDValue N0 = N.getOperand(0); 49285 SDValue N00 = N0.getOperand(0); 49286 SDValue N01 = N0.getOperand(1); 49287 SDValue Chain01 = N01.getOperand(0); 49288 SDValue N011 = N01.getOperand(1); 49289 SDValue N1 = N.getOperand(1); 49290 SDValue LSI_N01 = CurDAG->getMemOperand(cast<MemSDNode>(N01)->getMemOperand()); 49291 SDValue Ops0[] = { N00, CPTmpN011_0, CPTmpN011_1, CPTmpN011_2, CPTmpN011_3, CPTmpN011_4, LSI_N01, Chain01 }; 49292 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 8); 49293 ReplaceUses(SDValue(N01.getNode(), 1), SDValue(ResNode, 1)); 49294 return ResNode; 49295 } 49296 SDNode *Emit_273(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 49297 SDValue N0 = N.getOperand(0); 49298 SDValue N00 = N0.getOperand(0); 49299 SDValue N01 = N0.getOperand(1); 49300 SDValue N1 = N.getOperand(1); 49301 SDValue Tmp3 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N01)->getZExtValue()), MVT::i8); 49302 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, N00, Tmp3); 49303 } 49304 SDNode *Emit_274(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 49305 SDValue N0 = N.getOperand(0); 49306 SDValue N00 = N0.getOperand(0); 49307 SDValue N01 = N0.getOperand(1); 49308 SDValue N1 = N.getOperand(1); 49309 SDValue Tmp3 = CurDAG->getTargetConstant(((unsigned short) cast<ConstantSDNode>(N01)->getZExtValue()), MVT::i16); 49310 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, N00, Tmp3); 49311 } 49312 SDNode *Emit_275(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 49313 SDValue N0 = N.getOperand(0); 49314 SDValue N00 = N0.getOperand(0); 49315 SDValue N01 = N0.getOperand(1); 49316 SDValue N1 = N.getOperand(1); 49317 SDValue Tmp3 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N01)->getZExtValue()), MVT::i32); 49318 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, N00, Tmp3); 49319 } 49320 SDNode *Emit_276(const SDValue &N, unsigned Opc0, SDValue &CPTmpN001_0, SDValue &CPTmpN001_1, SDValue &CPTmpN001_2, SDValue &CPTmpN001_3, SDValue &CPTmpN001_4) DISABLE_INLINE { 49321 SDValue N0 = N.getOperand(0); 49322 SDValue N00 = N0.getOperand(0); 49323 SDValue Chain00 = N00.getOperand(0); 49324 SDValue N001 = N00.getOperand(1); 49325 SDValue N01 = N0.getOperand(1); 49326 SDValue N1 = N.getOperand(1); 49327 SDValue Tmp3 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N01)->getZExtValue()), MVT::i8); 49328 SDValue LSI_N00 = CurDAG->getMemOperand(cast<MemSDNode>(N00)->getMemOperand()); 49329 SDValue Ops0[] = { CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4, Tmp3, LSI_N00, Chain00 }; 49330 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 8); 49331 ReplaceUses(SDValue(N00.getNode(), 1), SDValue(ResNode, 1)); 49332 return ResNode; 49333 } 49334 SDNode *Emit_277(const SDValue &N, unsigned Opc0, SDValue &CPTmpN001_0, SDValue &CPTmpN001_1, SDValue &CPTmpN001_2, SDValue &CPTmpN001_3, SDValue &CPTmpN001_4) DISABLE_INLINE { 49335 SDValue N0 = N.getOperand(0); 49336 SDValue N00 = N0.getOperand(0); 49337 SDValue Chain00 = N00.getOperand(0); 49338 SDValue N001 = N00.getOperand(1); 49339 SDValue N01 = N0.getOperand(1); 49340 SDValue N1 = N.getOperand(1); 49341 SDValue Tmp3 = CurDAG->getTargetConstant(((unsigned short) cast<ConstantSDNode>(N01)->getZExtValue()), MVT::i16); 49342 SDValue LSI_N00 = CurDAG->getMemOperand(cast<MemSDNode>(N00)->getMemOperand()); 49343 SDValue Ops0[] = { CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4, Tmp3, LSI_N00, Chain00 }; 49344 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 8); 49345 ReplaceUses(SDValue(N00.getNode(), 1), SDValue(ResNode, 1)); 49346 return ResNode; 49347 } 49348 SDNode *Emit_278(const SDValue &N, unsigned Opc0, SDValue &CPTmpN001_0, SDValue &CPTmpN001_1, SDValue &CPTmpN001_2, SDValue &CPTmpN001_3, SDValue &CPTmpN001_4) DISABLE_INLINE { 49349 SDValue N0 = N.getOperand(0); 49350 SDValue N00 = N0.getOperand(0); 49351 SDValue Chain00 = N00.getOperand(0); 49352 SDValue N001 = N00.getOperand(1); 49353 SDValue N01 = N0.getOperand(1); 49354 SDValue N1 = N.getOperand(1); 49355 SDValue Tmp3 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N01)->getZExtValue()), MVT::i32); 49356 SDValue LSI_N00 = CurDAG->getMemOperand(cast<MemSDNode>(N00)->getMemOperand()); 49357 SDValue Ops0[] = { CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4, Tmp3, LSI_N00, Chain00 }; 49358 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 8); 49359 ReplaceUses(SDValue(N00.getNode(), 1), SDValue(ResNode, 1)); 49360 return ResNode; 49361 } 49362 SDNode *Emit_279(const SDValue &N, unsigned Opc0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 49363 SDValue N0 = N.getOperand(0); 49364 SDValue Chain0 = N0.getOperand(0); 49365 SDValue N01 = N0.getOperand(1); 49366 SDValue N1 = N.getOperand(1); 49367 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 49368 SDValue Ops0[] = { CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, N1, LSI_N0, Chain0 }; 49369 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 8); 49370 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 49371 return ResNode; 49372 } 49373 SDNode *Emit_280(const SDValue &N, unsigned Opc0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 49374 SDValue N0 = N.getOperand(0); 49375 SDValue N1 = N.getOperand(1); 49376 SDValue Chain1 = N1.getOperand(0); 49377 SDValue N11 = N1.getOperand(1); 49378 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 49379 SDValue Ops0[] = { N0, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, LSI_N1, Chain1 }; 49380 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 8); 49381 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 49382 return ResNode; 49383 } 49384 SDNode *Emit_281(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 49385 SDValue N0 = N.getOperand(0); 49386 SDValue N1 = N.getOperand(1); 49387 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i8); 49388 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, N0, Tmp1); 49389 } 49390 SDNode *Emit_282(const SDValue &N, unsigned Opc0, SDValue &CPTmpN01_0, SDValue &CPTmpN01_1, SDValue &CPTmpN01_2, SDValue &CPTmpN01_3, SDValue &CPTmpN01_4) DISABLE_INLINE { 49391 SDValue N0 = N.getOperand(0); 49392 SDValue Chain0 = N0.getOperand(0); 49393 SDValue N01 = N0.getOperand(1); 49394 SDValue N1 = N.getOperand(1); 49395 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i8); 49396 SDValue LSI_N0 = CurDAG->getMemOperand(cast<MemSDNode>(N0)->getMemOperand()); 49397 SDValue Ops0[] = { CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4, Tmp1, LSI_N0, Chain0 }; 49398 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 8); 49399 ReplaceUses(SDValue(N0.getNode(), 1), SDValue(ResNode, 1)); 49400 return ResNode; 49401 } 49402 SDNode *Emit_283(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 49403 SDValue N0 = N.getOperand(0); 49404 SDValue N00 = N0.getOperand(0); 49405 SDValue N01 = N0.getOperand(1); 49406 SDValue N1 = N.getOperand(1); 49407 SDValue Tmp3 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N01)->getZExtValue()), MVT::i64); 49408 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, N00, Tmp3); 49409 } 49410 SDNode *Emit_284(const SDValue &N, unsigned Opc0, SDValue &CPTmpN001_0, SDValue &CPTmpN001_1, SDValue &CPTmpN001_2, SDValue &CPTmpN001_3, SDValue &CPTmpN001_4) DISABLE_INLINE { 49411 SDValue N0 = N.getOperand(0); 49412 SDValue N00 = N0.getOperand(0); 49413 SDValue Chain00 = N00.getOperand(0); 49414 SDValue N001 = N00.getOperand(1); 49415 SDValue N01 = N0.getOperand(1); 49416 SDValue N1 = N.getOperand(1); 49417 SDValue Tmp3 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N01)->getZExtValue()), MVT::i64); 49418 SDValue LSI_N00 = CurDAG->getMemOperand(cast<MemSDNode>(N00)->getMemOperand()); 49419 SDValue Ops0[] = { CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4, Tmp3, LSI_N00, Chain00 }; 49420 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 8); 49421 ReplaceUses(SDValue(N00.getNode(), 1), SDValue(ResNode, 1)); 49422 return ResNode; 49423 } 49424 SDNode *Emit_285(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 49425 SDValue N0 = N.getOperand(0); 49426 SDValue N1 = N.getOperand(1); 49427 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, N0, N0); 49428 } 49429 SDNode *Emit_286(const SDValue &N, unsigned Opc0, SDValue &CPTmpN001_0, SDValue &CPTmpN001_1, SDValue &CPTmpN001_2, SDValue &CPTmpN001_3, SDValue &CPTmpN001_4) DISABLE_INLINE { 49430 SDValue N0 = N.getOperand(0); 49431 SDValue N00 = N0.getOperand(0); 49432 SDValue Chain00 = N00.getOperand(0); 49433 SDValue N001 = N00.getOperand(1); 49434 SDValue N01 = N0.getOperand(1); 49435 SDValue N1 = N.getOperand(1); 49436 SDValue LSI_N00 = CurDAG->getMemOperand(cast<MemSDNode>(N00)->getMemOperand()); 49437 SDValue Ops0[] = { N01, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4, LSI_N00, Chain00 }; 49438 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::i32, MVT::Other, Ops0, 8); 49439 ReplaceUses(SDValue(N00.getNode(), 1), SDValue(ResNode, 1)); 49440 return ResNode; 49441 } 49442 SDNode *Select_X86ISD_CMP(const SDValue &N) { 49443 if (OptLevel != CodeGenOpt::None) { 49444 { 49445 SDValue N0 = N.getOperand(0); 49446 if (N0.getOpcode() == ISD::AND && 49447 N0.hasOneUse()) { 49448 SDValue N00 = N0.getOperand(0); 49449 if (N00.getOpcode() == ISD::LOAD && 49450 N00.hasOneUse() && 49451 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 49452 SDValue Chain00 = N00.getOperand(0); 49453 if (Predicate_unindexedload(N00.getNode())) { 49454 if (Predicate_load(N00.getNode())) { 49455 49456 // Pattern: (X86cmp:isVoid (and:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2), 0:i64) 49457 // Emits: (TEST64mi32:isVoid addr:iPTR:$src1, (imm:i64):$src2) 49458 // Pattern complexity = 37 cost = 1 size = 3 49459 if (Predicate_loadi64(N00.getNode())) { 49460 SDValue N001 = N00.getOperand(1); 49461 SDValue CPTmpN001_0; 49462 SDValue CPTmpN001_1; 49463 SDValue CPTmpN001_2; 49464 SDValue CPTmpN001_3; 49465 SDValue CPTmpN001_4; 49466 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 49467 SDValue N01 = N0.getOperand(1); 49468 if (N01.getOpcode() == ISD::Constant && 49469 Predicate_i64immSExt32(N01.getNode())) { 49470 SDValue N1 = N.getOperand(1); 49471 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 49472 if (Tmp0) { 49473 int64_t CN1 = Tmp0->getSExtValue(); 49474 if (CN1 == INT64_C(0) && 49475 N0.getNode()->getValueType(0) == MVT::i64) { 49476 SDNode *Result = Emit_284(N, X86::TEST64mi32, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 49477 return Result; 49478 } 49479 } 49480 } 49481 } 49482 } 49483 49484 // Pattern: (X86cmp:isVoid (and:i8 (ld:i8 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (imm:i8):$src2), 0:i8) 49485 // Emits: (TEST8mi:isVoid addr:iPTR:$src1, (imm:i8):$src2) 49486 // Pattern complexity = 36 cost = 1 size = 3 49487 if (Predicate_loadi8(N00.getNode())) { 49488 SDValue N001 = N00.getOperand(1); 49489 SDValue CPTmpN001_0; 49490 SDValue CPTmpN001_1; 49491 SDValue CPTmpN001_2; 49492 SDValue CPTmpN001_3; 49493 SDValue CPTmpN001_4; 49494 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 49495 SDValue N01 = N0.getOperand(1); 49496 if (N01.getOpcode() == ISD::Constant) { 49497 SDValue N1 = N.getOperand(1); 49498 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 49499 if (Tmp0) { 49500 int64_t CN1 = Tmp0->getSExtValue(); 49501 if (CN1 == INT64_C(0) && 49502 N0.getNode()->getValueType(0) == MVT::i8) { 49503 SDNode *Result = Emit_276(N, X86::TEST8mi, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 49504 return Result; 49505 } 49506 } 49507 } 49508 } 49509 } 49510 } 49511 49512 // Pattern: (X86cmp:isVoid (and:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i16):$src2), 0:i16) 49513 // Emits: (TEST16mi:isVoid addr:iPTR:$src1, (imm:i16):$src2) 49514 // Pattern complexity = 36 cost = 1 size = 3 49515 if (Predicate_loadi16(N00.getNode())) { 49516 SDValue N001 = N00.getOperand(1); 49517 SDValue CPTmpN001_0; 49518 SDValue CPTmpN001_1; 49519 SDValue CPTmpN001_2; 49520 SDValue CPTmpN001_3; 49521 SDValue CPTmpN001_4; 49522 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 49523 SDValue N01 = N0.getOperand(1); 49524 if (N01.getOpcode() == ISD::Constant) { 49525 SDValue N1 = N.getOperand(1); 49526 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 49527 if (Tmp0) { 49528 int64_t CN1 = Tmp0->getSExtValue(); 49529 if (CN1 == INT64_C(0) && 49530 N0.getNode()->getValueType(0) == MVT::i16) { 49531 SDNode *Result = Emit_277(N, X86::TEST16mi, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 49532 return Result; 49533 } 49534 } 49535 } 49536 } 49537 } 49538 49539 // Pattern: (X86cmp:isVoid (and:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i32):$src2), 0:i32) 49540 // Emits: (TEST32mi:isVoid addr:iPTR:$src1, (imm:i32):$src2) 49541 // Pattern complexity = 36 cost = 1 size = 3 49542 if (Predicate_loadi32(N00.getNode())) { 49543 SDValue N001 = N00.getOperand(1); 49544 SDValue CPTmpN001_0; 49545 SDValue CPTmpN001_1; 49546 SDValue CPTmpN001_2; 49547 SDValue CPTmpN001_3; 49548 SDValue CPTmpN001_4; 49549 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 49550 SDValue N01 = N0.getOperand(1); 49551 if (N01.getOpcode() == ISD::Constant) { 49552 SDValue N1 = N.getOperand(1); 49553 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 49554 if (Tmp0) { 49555 int64_t CN1 = Tmp0->getSExtValue(); 49556 if (CN1 == INT64_C(0) && 49557 N0.getNode()->getValueType(0) == MVT::i32) { 49558 SDNode *Result = Emit_278(N, X86::TEST32mi, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 49559 return Result; 49560 } 49561 } 49562 } 49563 } 49564 } 49565 } 49566 } 49567 { 49568 SDValue N01 = N0.getOperand(1); 49569 if (N01.getOpcode() == ISD::LOAD && 49570 N01.hasOneUse() && 49571 IsLegalAndProfitableToFold(N01.getNode(), N0.getNode(), N.getNode())) { 49572 SDValue Chain01 = N01.getOperand(0); 49573 if (Predicate_unindexedload(N01.getNode())) { 49574 49575 // Pattern: (X86cmp:isVoid (and:i8 GR8:i8:$src1, (ld:i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>), 0:i8) 49576 // Emits: (TEST8rm:isVoid GR8:i8:$src1, addr:iPTR:$src2) 49577 // Pattern complexity = 33 cost = 1 size = 3 49578 if (Predicate_load(N01.getNode()) && 49579 Predicate_loadi8(N01.getNode())) { 49580 SDValue N011 = N01.getOperand(1); 49581 SDValue CPTmpN011_0; 49582 SDValue CPTmpN011_1; 49583 SDValue CPTmpN011_2; 49584 SDValue CPTmpN011_3; 49585 SDValue CPTmpN011_4; 49586 if (SelectAddr(N, N011, CPTmpN011_0, CPTmpN011_1, CPTmpN011_2, CPTmpN011_3, CPTmpN011_4)) { 49587 SDValue N1 = N.getOperand(1); 49588 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 49589 if (Tmp0) { 49590 int64_t CN1 = Tmp0->getSExtValue(); 49591 if (CN1 == INT64_C(0) && 49592 N0.getNode()->getValueType(0) == MVT::i8) { 49593 SDNode *Result = Emit_272(N, X86::TEST8rm, CPTmpN011_0, CPTmpN011_1, CPTmpN011_2, CPTmpN011_3, CPTmpN011_4); 49594 return Result; 49595 } 49596 } 49597 } 49598 } 49599 49600 // Pattern: (X86cmp:isVoid (and:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>), 0:i16) 49601 // Emits: (TEST16rm:isVoid GR16:i16:$src1, addr:iPTR:$src2) 49602 // Pattern complexity = 33 cost = 1 size = 3 49603 if (Predicate_loadi16(N01.getNode())) { 49604 SDValue N011 = N01.getOperand(1); 49605 SDValue CPTmpN011_0; 49606 SDValue CPTmpN011_1; 49607 SDValue CPTmpN011_2; 49608 SDValue CPTmpN011_3; 49609 SDValue CPTmpN011_4; 49610 if (SelectAddr(N, N011, CPTmpN011_0, CPTmpN011_1, CPTmpN011_2, CPTmpN011_3, CPTmpN011_4)) { 49611 SDValue N1 = N.getOperand(1); 49612 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 49613 if (Tmp0) { 49614 int64_t CN1 = Tmp0->getSExtValue(); 49615 if (CN1 == INT64_C(0) && 49616 N0.getNode()->getValueType(0) == MVT::i16) { 49617 SDNode *Result = Emit_272(N, X86::TEST16rm, CPTmpN011_0, CPTmpN011_1, CPTmpN011_2, CPTmpN011_3, CPTmpN011_4); 49618 return Result; 49619 } 49620 } 49621 } 49622 } 49623 49624 // Pattern: (X86cmp:isVoid (and:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>), 0:i32) 49625 // Emits: (TEST32rm:isVoid GR32:i32:$src1, addr:iPTR:$src2) 49626 // Pattern complexity = 33 cost = 1 size = 3 49627 if (Predicate_loadi32(N01.getNode())) { 49628 SDValue N011 = N01.getOperand(1); 49629 SDValue CPTmpN011_0; 49630 SDValue CPTmpN011_1; 49631 SDValue CPTmpN011_2; 49632 SDValue CPTmpN011_3; 49633 SDValue CPTmpN011_4; 49634 if (SelectAddr(N, N011, CPTmpN011_0, CPTmpN011_1, CPTmpN011_2, CPTmpN011_3, CPTmpN011_4)) { 49635 SDValue N1 = N.getOperand(1); 49636 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 49637 if (Tmp0) { 49638 int64_t CN1 = Tmp0->getSExtValue(); 49639 if (CN1 == INT64_C(0) && 49640 N0.getNode()->getValueType(0) == MVT::i32) { 49641 SDNode *Result = Emit_272(N, X86::TEST32rm, CPTmpN011_0, CPTmpN011_1, CPTmpN011_2, CPTmpN011_3, CPTmpN011_4); 49642 return Result; 49643 } 49644 } 49645 } 49646 } 49647 49648 // Pattern: (X86cmp:isVoid (and:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>), 0:i64) 49649 // Emits: (TEST64rm:isVoid GR64:i64:$src1, addr:iPTR:$src2) 49650 // Pattern complexity = 33 cost = 1 size = 3 49651 if (Predicate_load(N01.getNode()) && 49652 Predicate_loadi64(N01.getNode())) { 49653 SDValue N011 = N01.getOperand(1); 49654 SDValue CPTmpN011_0; 49655 SDValue CPTmpN011_1; 49656 SDValue CPTmpN011_2; 49657 SDValue CPTmpN011_3; 49658 SDValue CPTmpN011_4; 49659 if (SelectAddr(N, N011, CPTmpN011_0, CPTmpN011_1, CPTmpN011_2, CPTmpN011_3, CPTmpN011_4)) { 49660 SDValue N1 = N.getOperand(1); 49661 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 49662 if (Tmp0) { 49663 int64_t CN1 = Tmp0->getSExtValue(); 49664 if (CN1 == INT64_C(0) && 49665 N0.getNode()->getValueType(0) == MVT::i64) { 49666 SDNode *Result = Emit_272(N, X86::TEST64rm, CPTmpN011_0, CPTmpN011_1, CPTmpN011_2, CPTmpN011_3, CPTmpN011_4); 49667 return Result; 49668 } 49669 } 49670 } 49671 } 49672 } 49673 } 49674 } 49675 if (N00.getOpcode() == ISD::LOAD && 49676 N00.hasOneUse() && 49677 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 49678 SDValue Chain00 = N00.getOperand(0); 49679 if (Predicate_unindexedload(N00.getNode())) { 49680 49681 // Pattern: (X86cmp:isVoid (and:i8 (ld:i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, GR8:i8:$src1), 0:i8) 49682 // Emits: (TEST8rm:isVoid GR8:i8:$src1, addr:iPTR:$src2) 49683 // Pattern complexity = 33 cost = 1 size = 3 49684 if (Predicate_load(N00.getNode()) && 49685 Predicate_loadi8(N00.getNode())) { 49686 SDValue N001 = N00.getOperand(1); 49687 SDValue CPTmpN001_0; 49688 SDValue CPTmpN001_1; 49689 SDValue CPTmpN001_2; 49690 SDValue CPTmpN001_3; 49691 SDValue CPTmpN001_4; 49692 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 49693 SDValue N01 = N0.getOperand(1); 49694 SDValue N1 = N.getOperand(1); 49695 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 49696 if (Tmp0) { 49697 int64_t CN1 = Tmp0->getSExtValue(); 49698 if (CN1 == INT64_C(0) && 49699 N0.getNode()->getValueType(0) == MVT::i8) { 49700 SDNode *Result = Emit_286(N, X86::TEST8rm, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 49701 return Result; 49702 } 49703 } 49704 } 49705 } 49706 49707 // Pattern: (X86cmp:isVoid (and:i16 (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src1), 0:i16) 49708 // Emits: (TEST16rm:isVoid GR16:i16:$src1, addr:iPTR:$src2) 49709 // Pattern complexity = 33 cost = 1 size = 3 49710 if (Predicate_loadi16(N00.getNode())) { 49711 SDValue N001 = N00.getOperand(1); 49712 SDValue CPTmpN001_0; 49713 SDValue CPTmpN001_1; 49714 SDValue CPTmpN001_2; 49715 SDValue CPTmpN001_3; 49716 SDValue CPTmpN001_4; 49717 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 49718 SDValue N01 = N0.getOperand(1); 49719 SDValue N1 = N.getOperand(1); 49720 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 49721 if (Tmp0) { 49722 int64_t CN1 = Tmp0->getSExtValue(); 49723 if (CN1 == INT64_C(0) && 49724 N0.getNode()->getValueType(0) == MVT::i16) { 49725 SDNode *Result = Emit_286(N, X86::TEST16rm, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 49726 return Result; 49727 } 49728 } 49729 } 49730 } 49731 49732 // Pattern: (X86cmp:isVoid (and:i32 (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src1), 0:i32) 49733 // Emits: (TEST32rm:isVoid GR32:i32:$src1, addr:iPTR:$src2) 49734 // Pattern complexity = 33 cost = 1 size = 3 49735 if (Predicate_loadi32(N00.getNode())) { 49736 SDValue N001 = N00.getOperand(1); 49737 SDValue CPTmpN001_0; 49738 SDValue CPTmpN001_1; 49739 SDValue CPTmpN001_2; 49740 SDValue CPTmpN001_3; 49741 SDValue CPTmpN001_4; 49742 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 49743 SDValue N01 = N0.getOperand(1); 49744 SDValue N1 = N.getOperand(1); 49745 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 49746 if (Tmp0) { 49747 int64_t CN1 = Tmp0->getSExtValue(); 49748 if (CN1 == INT64_C(0) && 49749 N0.getNode()->getValueType(0) == MVT::i32) { 49750 SDNode *Result = Emit_286(N, X86::TEST32rm, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 49751 return Result; 49752 } 49753 } 49754 } 49755 } 49756 49757 // Pattern: (X86cmp:isVoid (and:i64 (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src1), 0:i64) 49758 // Emits: (TEST64rm:isVoid GR64:i64:$src1, addr:iPTR:$src2) 49759 // Pattern complexity = 33 cost = 1 size = 3 49760 if (Predicate_load(N00.getNode()) && 49761 Predicate_loadi64(N00.getNode())) { 49762 SDValue N001 = N00.getOperand(1); 49763 SDValue CPTmpN001_0; 49764 SDValue CPTmpN001_1; 49765 SDValue CPTmpN001_2; 49766 SDValue CPTmpN001_3; 49767 SDValue CPTmpN001_4; 49768 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 49769 SDValue N01 = N0.getOperand(1); 49770 SDValue N1 = N.getOperand(1); 49771 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 49772 if (Tmp0) { 49773 int64_t CN1 = Tmp0->getSExtValue(); 49774 if (CN1 == INT64_C(0) && 49775 N0.getNode()->getValueType(0) == MVT::i64) { 49776 SDNode *Result = Emit_286(N, X86::TEST64rm, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 49777 return Result; 49778 } 49779 } 49780 } 49781 } 49782 } 49783 } 49784 } 49785 if (N0.getOpcode() == ISD::LOAD && 49786 N0.hasOneUse() && 49787 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 49788 SDValue Chain0 = N0.getOperand(0); 49789 if (Predicate_unindexedload(N0.getNode())) { 49790 49791 // Pattern: (X86cmp:isVoid (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 49792 // Emits: (CMP16mi8:isVoid addr:iPTR:$src1, (imm:i16):$src2) 49793 // Pattern complexity = 29 cost = 1 size = 3 49794 if (Predicate_loadi16(N0.getNode())) { 49795 SDValue N01 = N0.getOperand(1); 49796 SDValue CPTmpN01_0; 49797 SDValue CPTmpN01_1; 49798 SDValue CPTmpN01_2; 49799 SDValue CPTmpN01_3; 49800 SDValue CPTmpN01_4; 49801 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 49802 SDValue N1 = N.getOperand(1); 49803 if (N1.getOpcode() == ISD::Constant && 49804 Predicate_i16immSExt8(N1.getNode()) && 49805 N0.getNode()->getValueType(0) == MVT::i16) { 49806 SDNode *Result = Emit_260(N, X86::CMP16mi8, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 49807 return Result; 49808 } 49809 } 49810 } 49811 49812 // Pattern: (X86cmp:isVoid (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 49813 // Emits: (CMP32mi8:isVoid addr:iPTR:$src1, (imm:i32):$src2) 49814 // Pattern complexity = 29 cost = 1 size = 3 49815 if (Predicate_loadi32(N0.getNode())) { 49816 SDValue N01 = N0.getOperand(1); 49817 SDValue CPTmpN01_0; 49818 SDValue CPTmpN01_1; 49819 SDValue CPTmpN01_2; 49820 SDValue CPTmpN01_3; 49821 SDValue CPTmpN01_4; 49822 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 49823 SDValue N1 = N.getOperand(1); 49824 if (N1.getOpcode() == ISD::Constant && 49825 Predicate_i32immSExt8(N1.getNode()) && 49826 N0.getNode()->getValueType(0) == MVT::i32) { 49827 SDNode *Result = Emit_261(N, X86::CMP32mi8, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 49828 return Result; 49829 } 49830 } 49831 } 49832 if (Predicate_load(N0.getNode())) { 49833 if (Predicate_loadi64(N0.getNode())) { 49834 SDValue N01 = N0.getOperand(1); 49835 SDValue CPTmpN01_0; 49836 SDValue CPTmpN01_1; 49837 SDValue CPTmpN01_2; 49838 SDValue CPTmpN01_3; 49839 SDValue CPTmpN01_4; 49840 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 49841 SDValue N1 = N.getOperand(1); 49842 if (N1.getOpcode() == ISD::Constant) { 49843 49844 // Pattern: (X86cmp:isVoid (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 49845 // Emits: (CMP64mi8:isVoid addr:iPTR:$src1, (imm:i64):$src2) 49846 // Pattern complexity = 29 cost = 1 size = 3 49847 if (Predicate_i64immSExt8(N1.getNode()) && 49848 N0.getNode()->getValueType(0) == MVT::i64) { 49849 SDNode *Result = Emit_263(N, X86::CMP64mi8, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 49850 return Result; 49851 } 49852 49853 // Pattern: (X86cmp:isVoid (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 49854 // Emits: (CMP64mi32:isVoid addr:iPTR:$src1, (imm:i64):$src2) 49855 // Pattern complexity = 29 cost = 1 size = 3 49856 if (Predicate_i64immSExt32(N1.getNode()) && 49857 N0.getNode()->getValueType(0) == MVT::i64) { 49858 SDNode *Result = Emit_263(N, X86::CMP64mi32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 49859 return Result; 49860 } 49861 } 49862 } 49863 } 49864 49865 // Pattern: (X86cmp:isVoid (ld:i8 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, (imm:i8):$src2) 49866 // Emits: (CMP8mi:isVoid addr:iPTR:$src1, (imm:i8):$src2) 49867 // Pattern complexity = 28 cost = 1 size = 3 49868 if (Predicate_loadi8(N0.getNode())) { 49869 SDValue N01 = N0.getOperand(1); 49870 SDValue CPTmpN01_0; 49871 SDValue CPTmpN01_1; 49872 SDValue CPTmpN01_2; 49873 SDValue CPTmpN01_3; 49874 SDValue CPTmpN01_4; 49875 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 49876 SDValue N1 = N.getOperand(1); 49877 if (N1.getOpcode() == ISD::Constant && 49878 N0.getNode()->getValueType(0) == MVT::i8) { 49879 SDNode *Result = Emit_282(N, X86::CMP8mi, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 49880 return Result; 49881 } 49882 } 49883 } 49884 } 49885 49886 // Pattern: (X86cmp:isVoid (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i16):$src2) 49887 // Emits: (CMP16mi:isVoid addr:iPTR:$src1, (imm:i16):$src2) 49888 // Pattern complexity = 28 cost = 1 size = 3 49889 if (Predicate_loadi16(N0.getNode())) { 49890 SDValue N01 = N0.getOperand(1); 49891 SDValue CPTmpN01_0; 49892 SDValue CPTmpN01_1; 49893 SDValue CPTmpN01_2; 49894 SDValue CPTmpN01_3; 49895 SDValue CPTmpN01_4; 49896 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 49897 SDValue N1 = N.getOperand(1); 49898 if (N1.getOpcode() == ISD::Constant && 49899 N0.getNode()->getValueType(0) == MVT::i16) { 49900 SDNode *Result = Emit_260(N, X86::CMP16mi, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 49901 return Result; 49902 } 49903 } 49904 } 49905 49906 // Pattern: (X86cmp:isVoid (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i32):$src2) 49907 // Emits: (CMP32mi:isVoid addr:iPTR:$src1, (imm:i32):$src2) 49908 // Pattern complexity = 28 cost = 1 size = 3 49909 if (Predicate_loadi32(N0.getNode())) { 49910 SDValue N01 = N0.getOperand(1); 49911 SDValue CPTmpN01_0; 49912 SDValue CPTmpN01_1; 49913 SDValue CPTmpN01_2; 49914 SDValue CPTmpN01_3; 49915 SDValue CPTmpN01_4; 49916 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 49917 SDValue N1 = N.getOperand(1); 49918 if (N1.getOpcode() == ISD::Constant && 49919 N0.getNode()->getValueType(0) == MVT::i32) { 49920 SDNode *Result = Emit_261(N, X86::CMP32mi, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 49921 return Result; 49922 } 49923 } 49924 } 49925 49926 // Pattern: (X86cmp:isVoid (ld:i8 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>, GR8:i8:$src2) 49927 // Emits: (CMP8mr:isVoid addr:iPTR:$src1, GR8:i8:$src2) 49928 // Pattern complexity = 25 cost = 1 size = 3 49929 if (Predicate_load(N0.getNode()) && 49930 Predicate_loadi8(N0.getNode())) { 49931 SDValue N01 = N0.getOperand(1); 49932 SDValue CPTmpN01_0; 49933 SDValue CPTmpN01_1; 49934 SDValue CPTmpN01_2; 49935 SDValue CPTmpN01_3; 49936 SDValue CPTmpN01_4; 49937 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 49938 SDValue N1 = N.getOperand(1); 49939 if (N0.getNode()->getValueType(0) == MVT::i8) { 49940 SDNode *Result = Emit_279(N, X86::CMP8mr, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 49941 return Result; 49942 } 49943 } 49944 } 49945 49946 // Pattern: (X86cmp:isVoid (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, GR16:i16:$src2) 49947 // Emits: (CMP16mr:isVoid addr:iPTR:$src1, GR16:i16:$src2) 49948 // Pattern complexity = 25 cost = 1 size = 3 49949 if (Predicate_loadi16(N0.getNode())) { 49950 SDValue N01 = N0.getOperand(1); 49951 SDValue CPTmpN01_0; 49952 SDValue CPTmpN01_1; 49953 SDValue CPTmpN01_2; 49954 SDValue CPTmpN01_3; 49955 SDValue CPTmpN01_4; 49956 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 49957 SDValue N1 = N.getOperand(1); 49958 if (N0.getNode()->getValueType(0) == MVT::i16) { 49959 SDNode *Result = Emit_279(N, X86::CMP16mr, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 49960 return Result; 49961 } 49962 } 49963 } 49964 49965 // Pattern: (X86cmp:isVoid (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, GR32:i32:$src2) 49966 // Emits: (CMP32mr:isVoid addr:iPTR:$src1, GR32:i32:$src2) 49967 // Pattern complexity = 25 cost = 1 size = 3 49968 if (Predicate_loadi32(N0.getNode())) { 49969 SDValue N01 = N0.getOperand(1); 49970 SDValue CPTmpN01_0; 49971 SDValue CPTmpN01_1; 49972 SDValue CPTmpN01_2; 49973 SDValue CPTmpN01_3; 49974 SDValue CPTmpN01_4; 49975 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 49976 SDValue N1 = N.getOperand(1); 49977 if (N0.getNode()->getValueType(0) == MVT::i32) { 49978 SDNode *Result = Emit_279(N, X86::CMP32mr, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 49979 return Result; 49980 } 49981 } 49982 } 49983 } 49984 } 49985 { 49986 SDValue N1 = N.getOperand(1); 49987 if (N1.getOpcode() == ISD::LOAD && 49988 N1.hasOneUse() && 49989 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 49990 SDValue Chain1 = N1.getOperand(0); 49991 if (Predicate_unindexedload(N1.getNode())) { 49992 49993 // Pattern: (X86cmp:isVoid GR8:i8:$src1, (ld:i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>) 49994 // Emits: (CMP8rm:isVoid GR8:i8:$src1, addr:iPTR:$src2) 49995 // Pattern complexity = 25 cost = 1 size = 3 49996 if (Predicate_load(N1.getNode()) && 49997 Predicate_loadi8(N1.getNode())) { 49998 SDValue N11 = N1.getOperand(1); 49999 SDValue CPTmpN11_0; 50000 SDValue CPTmpN11_1; 50001 SDValue CPTmpN11_2; 50002 SDValue CPTmpN11_3; 50003 SDValue CPTmpN11_4; 50004 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 50005 N0.getNode()->getValueType(0) == MVT::i8) { 50006 SDNode *Result = Emit_280(N, X86::CMP8rm, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 50007 return Result; 50008 } 50009 } 50010 50011 // Pattern: (X86cmp:isVoid GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>) 50012 // Emits: (CMP16rm:isVoid GR16:i16:$src1, addr:iPTR:$src2) 50013 // Pattern complexity = 25 cost = 1 size = 3 50014 if (Predicate_loadi16(N1.getNode())) { 50015 SDValue N11 = N1.getOperand(1); 50016 SDValue CPTmpN11_0; 50017 SDValue CPTmpN11_1; 50018 SDValue CPTmpN11_2; 50019 SDValue CPTmpN11_3; 50020 SDValue CPTmpN11_4; 50021 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 50022 N0.getNode()->getValueType(0) == MVT::i16) { 50023 SDNode *Result = Emit_280(N, X86::CMP16rm, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 50024 return Result; 50025 } 50026 } 50027 50028 // Pattern: (X86cmp:isVoid GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>) 50029 // Emits: (CMP32rm:isVoid GR32:i32:$src1, addr:iPTR:$src2) 50030 // Pattern complexity = 25 cost = 1 size = 3 50031 if (Predicate_loadi32(N1.getNode())) { 50032 SDValue N11 = N1.getOperand(1); 50033 SDValue CPTmpN11_0; 50034 SDValue CPTmpN11_1; 50035 SDValue CPTmpN11_2; 50036 SDValue CPTmpN11_3; 50037 SDValue CPTmpN11_4; 50038 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 50039 N0.getNode()->getValueType(0) == MVT::i32) { 50040 SDNode *Result = Emit_280(N, X86::CMP32rm, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 50041 return Result; 50042 } 50043 } 50044 } 50045 } 50046 } 50047 50048 // Pattern: (X86cmp:isVoid (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, GR64:i64:$src2) 50049 // Emits: (CMP64mr:isVoid addr:iPTR:$src1, GR64:i64:$src2) 50050 // Pattern complexity = 25 cost = 1 size = 3 50051 if (N0.getOpcode() == ISD::LOAD && 50052 N0.hasOneUse() && 50053 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 50054 SDValue Chain0 = N0.getOperand(0); 50055 if (Predicate_unindexedload(N0.getNode()) && 50056 Predicate_load(N0.getNode()) && 50057 Predicate_loadi64(N0.getNode())) { 50058 SDValue N01 = N0.getOperand(1); 50059 SDValue CPTmpN01_0; 50060 SDValue CPTmpN01_1; 50061 SDValue CPTmpN01_2; 50062 SDValue CPTmpN01_3; 50063 SDValue CPTmpN01_4; 50064 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 50065 SDValue N1 = N.getOperand(1); 50066 if (N0.getNode()->getValueType(0) == MVT::i64) { 50067 SDNode *Result = Emit_279(N, X86::CMP64mr, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 50068 return Result; 50069 } 50070 } 50071 } 50072 } 50073 50074 // Pattern: (X86cmp:isVoid GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>) 50075 // Emits: (CMP64rm:isVoid GR64:i64:$src1, addr:iPTR:$src2) 50076 // Pattern complexity = 25 cost = 1 size = 3 50077 SDValue N1 = N.getOperand(1); 50078 if (N1.getOpcode() == ISD::LOAD && 50079 N1.hasOneUse() && 50080 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 50081 SDValue Chain1 = N1.getOperand(0); 50082 if (Predicate_unindexedload(N1.getNode()) && 50083 Predicate_load(N1.getNode()) && 50084 Predicate_loadi64(N1.getNode())) { 50085 SDValue N11 = N1.getOperand(1); 50086 SDValue CPTmpN11_0; 50087 SDValue CPTmpN11_1; 50088 SDValue CPTmpN11_2; 50089 SDValue CPTmpN11_3; 50090 SDValue CPTmpN11_4; 50091 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 50092 N0.getNode()->getValueType(0) == MVT::i64) { 50093 SDNode *Result = Emit_280(N, X86::CMP64rm, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 50094 return Result; 50095 } 50096 } 50097 } 50098 } 50099 50100 // Pattern: (X86cmp:isVoid FR32:f32:$src1, (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf32>>) 50101 // Emits: (UCOMISSrm:isVoid FR32:f32:$src1, addr:iPTR:$src2) 50102 // Pattern complexity = 25 cost = 1 size = 3 50103 if ((Subtarget->hasSSE1())) { 50104 SDValue N0 = N.getOperand(0); 50105 SDValue N1 = N.getOperand(1); 50106 if (N1.getOpcode() == ISD::LOAD && 50107 N1.hasOneUse() && 50108 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 50109 SDValue Chain1 = N1.getOperand(0); 50110 if (Predicate_unindexedload(N1.getNode()) && 50111 Predicate_load(N1.getNode()) && 50112 Predicate_loadf32(N1.getNode())) { 50113 SDValue N11 = N1.getOperand(1); 50114 SDValue CPTmpN11_0; 50115 SDValue CPTmpN11_1; 50116 SDValue CPTmpN11_2; 50117 SDValue CPTmpN11_3; 50118 SDValue CPTmpN11_4; 50119 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 50120 N0.getNode()->getValueType(0) == MVT::f32) { 50121 SDNode *Result = Emit_280(N, X86::UCOMISSrm, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 50122 return Result; 50123 } 50124 } 50125 } 50126 } 50127 50128 // Pattern: (X86cmp:isVoid FR64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>) 50129 // Emits: (UCOMISDrm:isVoid FR64:f64:$src1, addr:iPTR:$src2) 50130 // Pattern complexity = 25 cost = 1 size = 3 50131 if ((Subtarget->hasSSE2())) { 50132 SDValue N0 = N.getOperand(0); 50133 SDValue N1 = N.getOperand(1); 50134 if (N1.getOpcode() == ISD::LOAD && 50135 N1.hasOneUse() && 50136 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 50137 SDValue Chain1 = N1.getOperand(0); 50138 if (Predicate_unindexedload(N1.getNode()) && 50139 Predicate_load(N1.getNode()) && 50140 Predicate_loadf64(N1.getNode())) { 50141 SDValue N11 = N1.getOperand(1); 50142 SDValue CPTmpN11_0; 50143 SDValue CPTmpN11_1; 50144 SDValue CPTmpN11_2; 50145 SDValue CPTmpN11_3; 50146 SDValue CPTmpN11_4; 50147 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 50148 N0.getNode()->getValueType(0) == MVT::f64) { 50149 SDNode *Result = Emit_280(N, X86::UCOMISDrm, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 50150 return Result; 50151 } 50152 } 50153 } 50154 } 50155 } 50156 { 50157 SDValue N0 = N.getOperand(0); 50158 if (N0.getOpcode() == ISD::AND) { 50159 if (Predicate_and_su(N0.getNode())) { 50160 SDValue N00 = N0.getOperand(0); 50161 SDValue N01 = N0.getOperand(1); 50162 if (N01.getOpcode() == ISD::Constant) { 50163 SDValue N1 = N.getOperand(1); 50164 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 50165 if (Tmp0) { 50166 int64_t CN1 = Tmp0->getSExtValue(); 50167 if (CN1 == INT64_C(0)) { 50168 50169 // Pattern: (X86cmp:isVoid (and:i8 GR8:i8:$src1, (imm:i8):$src2)<<P:Predicate_and_su>>, 0:i8) 50170 // Emits: (TEST8ri:isVoid GR8:i8:$src1, (imm:i8):$src2) 50171 // Pattern complexity = 15 cost = 1 size = 3 50172 if (N0.getNode()->getValueType(0) == MVT::i8) { 50173 SDNode *Result = Emit_273(N, X86::TEST8ri); 50174 return Result; 50175 } 50176 50177 // Pattern: (X86cmp:isVoid (and:i16 GR16:i16:$src1, (imm:i16):$src2)<<P:Predicate_and_su>>, 0:i16) 50178 // Emits: (TEST16ri:isVoid GR16:i16:$src1, (imm:i16):$src2) 50179 // Pattern complexity = 15 cost = 1 size = 3 50180 if (N0.getNode()->getValueType(0) == MVT::i16) { 50181 SDNode *Result = Emit_274(N, X86::TEST16ri); 50182 return Result; 50183 } 50184 50185 // Pattern: (X86cmp:isVoid (and:i32 GR32:i32:$src1, (imm:i32):$src2)<<P:Predicate_and_su>>, 0:i32) 50186 // Emits: (TEST32ri:isVoid GR32:i32:$src1, (imm:i32):$src2) 50187 // Pattern complexity = 15 cost = 1 size = 3 50188 if (N0.getNode()->getValueType(0) == MVT::i32) { 50189 SDNode *Result = Emit_275(N, X86::TEST32ri); 50190 return Result; 50191 } 50192 } 50193 } 50194 } 50195 } 50196 50197 // Pattern: (X86cmp:isVoid (and:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2), 0:i64) 50198 // Emits: (TEST64ri32:isVoid GR64:i64:$src1, (imm:i64):$src2) 50199 // Pattern complexity = 15 cost = 1 size = 3 50200 { 50201 SDValue N00 = N0.getOperand(0); 50202 SDValue N01 = N0.getOperand(1); 50203 if (N01.getOpcode() == ISD::Constant && 50204 Predicate_i64immSExt32(N01.getNode())) { 50205 SDValue N1 = N.getOperand(1); 50206 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 50207 if (Tmp0) { 50208 int64_t CN1 = Tmp0->getSExtValue(); 50209 if (CN1 == INT64_C(0) && 50210 N0.getNode()->getValueType(0) == MVT::i64) { 50211 SDNode *Result = Emit_283(N, X86::TEST64ri32); 50212 return Result; 50213 } 50214 } 50215 } 50216 } 50217 if (Predicate_and_su(N0.getNode())) { 50218 SDValue N00 = N0.getOperand(0); 50219 SDValue N01 = N0.getOperand(1); 50220 SDValue N1 = N.getOperand(1); 50221 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 50222 if (Tmp0) { 50223 int64_t CN1 = Tmp0->getSExtValue(); 50224 if (CN1 == INT64_C(0)) { 50225 50226 // Pattern: (X86cmp:isVoid (and:i8 GR8:i8:$src1, GR8:i8:$src2)<<P:Predicate_and_su>>, 0:i8) 50227 // Emits: (TEST8rr:isVoid GR8:i8:$src1, GR8:i8:$src2) 50228 // Pattern complexity = 12 cost = 1 size = 3 50229 if (N0.getNode()->getValueType(0) == MVT::i8) { 50230 SDNode *Result = Emit_271(N, X86::TEST8rr); 50231 return Result; 50232 } 50233 50234 // Pattern: (X86cmp:isVoid (and:i16 GR16:i16:$src1, GR16:i16:$src2)<<P:Predicate_and_su>>, 0:i16) 50235 // Emits: (TEST16rr:isVoid GR16:i16:$src1, GR16:i16:$src2) 50236 // Pattern complexity = 12 cost = 1 size = 3 50237 if (N0.getNode()->getValueType(0) == MVT::i16) { 50238 SDNode *Result = Emit_271(N, X86::TEST16rr); 50239 return Result; 50240 } 50241 50242 // Pattern: (X86cmp:isVoid (and:i32 GR32:i32:$src1, GR32:i32:$src2)<<P:Predicate_and_su>>, 0:i32) 50243 // Emits: (TEST32rr:isVoid GR32:i32:$src1, GR32:i32:$src2) 50244 // Pattern complexity = 12 cost = 1 size = 3 50245 if (N0.getNode()->getValueType(0) == MVT::i32) { 50246 SDNode *Result = Emit_271(N, X86::TEST32rr); 50247 return Result; 50248 } 50249 } 50250 } 50251 } 50252 50253 // Pattern: (X86cmp:isVoid (and:i64 GR64:i64:$src1, GR64:i64:$src2), 0:i64) 50254 // Emits: (TEST64rr:isVoid GR64:i64:$src1, GR64:i64:$src2) 50255 // Pattern complexity = 11 cost = 1 size = 3 50256 SDValue N00 = N0.getOperand(0); 50257 SDValue N01 = N0.getOperand(1); 50258 SDValue N1 = N.getOperand(1); 50259 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 50260 if (Tmp0) { 50261 int64_t CN1 = Tmp0->getSExtValue(); 50262 if (CN1 == INT64_C(0) && 50263 N0.getNode()->getValueType(0) == MVT::i64) { 50264 SDNode *Result = Emit_271(N, X86::TEST64rr); 50265 return Result; 50266 } 50267 } 50268 } 50269 SDValue N1 = N.getOperand(1); 50270 { 50271 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 50272 if (Tmp0) { 50273 int64_t CN1 = Tmp0->getSExtValue(); 50274 if (CN1 == INT64_C(0)) { 50275 50276 // Pattern: (X86cmp:isVoid GR64:i64:$src1, 0:i64) 50277 // Emits: (TEST64rr:isVoid GR64:i64:$src1, GR64:i64:$src1) 50278 // Pattern complexity = 8 cost = 1 size = 3 50279 if (N0.getNode()->getValueType(0) == MVT::i64) { 50280 SDNode *Result = Emit_285(N, X86::TEST64rr); 50281 return Result; 50282 } 50283 50284 // Pattern: (X86cmp:isVoid GR8:i8:$src1, 0:i8) 50285 // Emits: (TEST8rr:isVoid GR8:i8:$src1, GR8:i8:$src1) 50286 // Pattern complexity = 8 cost = 1 size = 3 50287 if (N0.getNode()->getValueType(0) == MVT::i8) { 50288 SDNode *Result = Emit_285(N, X86::TEST8rr); 50289 return Result; 50290 } 50291 50292 // Pattern: (X86cmp:isVoid GR16:i16:$src1, 0:i16) 50293 // Emits: (TEST16rr:isVoid GR16:i16:$src1, GR16:i16:$src1) 50294 // Pattern complexity = 8 cost = 1 size = 3 50295 if (N0.getNode()->getValueType(0) == MVT::i16) { 50296 SDNode *Result = Emit_285(N, X86::TEST16rr); 50297 return Result; 50298 } 50299 50300 // Pattern: (X86cmp:isVoid GR32:i32:$src1, 0:i32) 50301 // Emits: (TEST32rr:isVoid GR32:i32:$src1, GR32:i32:$src1) 50302 // Pattern complexity = 8 cost = 1 size = 3 50303 if (N0.getNode()->getValueType(0) == MVT::i32) { 50304 SDNode *Result = Emit_285(N, X86::TEST32rr); 50305 return Result; 50306 } 50307 } 50308 } 50309 } 50310 if (N1.getOpcode() == ISD::Constant) { 50311 50312 // Pattern: (X86cmp:isVoid GR16:i16:$src1, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 50313 // Emits: (CMP16ri8:isVoid GR16:i16:$src1, (imm:i16):$src2) 50314 // Pattern complexity = 7 cost = 1 size = 3 50315 if (Predicate_i16immSExt8(N1.getNode()) && 50316 N0.getNode()->getValueType(0) == MVT::i16) { 50317 SDNode *Result = Emit_258(N, X86::CMP16ri8); 50318 return Result; 50319 } 50320 50321 // Pattern: (X86cmp:isVoid GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 50322 // Emits: (CMP32ri8:isVoid GR32:i32:$src1, (imm:i32):$src2) 50323 // Pattern complexity = 7 cost = 1 size = 3 50324 if (Predicate_i32immSExt8(N1.getNode()) && 50325 N0.getNode()->getValueType(0) == MVT::i32) { 50326 SDNode *Result = Emit_259(N, X86::CMP32ri8); 50327 return Result; 50328 } 50329 50330 // Pattern: (X86cmp:isVoid GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 50331 // Emits: (CMP64ri8:isVoid GR64:i64:$src1, (imm:i64):$src2) 50332 // Pattern complexity = 7 cost = 1 size = 3 50333 if (Predicate_i64immSExt8(N1.getNode()) && 50334 N0.getNode()->getValueType(0) == MVT::i64) { 50335 SDNode *Result = Emit_262(N, X86::CMP64ri8); 50336 return Result; 50337 } 50338 50339 // Pattern: (X86cmp:isVoid GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 50340 // Emits: (CMP64ri32:isVoid GR64:i64:$src1, (imm:i64):$src2) 50341 // Pattern complexity = 7 cost = 1 size = 3 50342 if (Predicate_i64immSExt32(N1.getNode()) && 50343 N0.getNode()->getValueType(0) == MVT::i64) { 50344 SDNode *Result = Emit_262(N, X86::CMP64ri32); 50345 return Result; 50346 } 50347 50348 // Pattern: (X86cmp:isVoid GR8:i8:$src1, (imm:i8):$src2) 50349 // Emits: (CMP8ri:isVoid GR8:i8:$src1, (imm:i8):$src2) 50350 // Pattern complexity = 6 cost = 1 size = 3 50351 if (N0.getNode()->getValueType(0) == MVT::i8) { 50352 SDNode *Result = Emit_281(N, X86::CMP8ri); 50353 return Result; 50354 } 50355 50356 // Pattern: (X86cmp:isVoid GR16:i16:$src1, (imm:i16):$src2) 50357 // Emits: (CMP16ri:isVoid GR16:i16:$src1, (imm:i16):$src2) 50358 // Pattern complexity = 6 cost = 1 size = 3 50359 if (N0.getNode()->getValueType(0) == MVT::i16) { 50360 SDNode *Result = Emit_258(N, X86::CMP16ri); 50361 return Result; 50362 } 50363 50364 // Pattern: (X86cmp:isVoid GR32:i32:$src1, (imm:i32):$src2) 50365 // Emits: (CMP32ri:isVoid GR32:i32:$src1, (imm:i32):$src2) 50366 // Pattern complexity = 6 cost = 1 size = 3 50367 if (N0.getNode()->getValueType(0) == MVT::i32) { 50368 SDNode *Result = Emit_259(N, X86::CMP32ri); 50369 return Result; 50370 } 50371 } 50372 } 50373 50374 // Pattern: (X86cmp:isVoid RFP32:f32:$lhs, RFP32:f32:$rhs) 50375 // Emits: (UCOM_FpIr32:isVoid RFP32:f32:$lhs, RFP32:f32:$rhs) 50376 // Pattern complexity = 3 cost = 1 size = 0 50377 if ((!Subtarget->hasSSE1())) { 50378 SDValue N0 = N.getOperand(0); 50379 SDValue N1 = N.getOperand(1); 50380 if (N0.getNode()->getValueType(0) == MVT::f32) { 50381 SDNode *Result = Emit_257(N, X86::UCOM_FpIr32); 50382 return Result; 50383 } 50384 } 50385 50386 // Pattern: (X86cmp:isVoid RFP64:f64:$lhs, RFP64:f64:$rhs) 50387 // Emits: (UCOM_FpIr64:isVoid RFP64:f64:$lhs, RFP64:f64:$rhs) 50388 // Pattern complexity = 3 cost = 1 size = 0 50389 if ((!Subtarget->hasSSE2())) { 50390 SDValue N0 = N.getOperand(0); 50391 SDValue N1 = N.getOperand(1); 50392 if (N0.getNode()->getValueType(0) == MVT::f64) { 50393 SDNode *Result = Emit_257(N, X86::UCOM_FpIr64); 50394 return Result; 50395 } 50396 } 50397 { 50398 SDValue N0 = N.getOperand(0); 50399 SDValue N1 = N.getOperand(1); 50400 50401 // Pattern: (X86cmp:isVoid RFP80:f80:$lhs, RFP80:f80:$rhs) 50402 // Emits: (UCOM_FpIr80:isVoid RFP80:f80:$lhs, RFP80:f80:$rhs) 50403 // Pattern complexity = 3 cost = 1 size = 0 50404 if (N0.getNode()->getValueType(0) == MVT::f80) { 50405 SDNode *Result = Emit_257(N, X86::UCOM_FpIr80); 50406 return Result; 50407 } 50408 50409 // Pattern: (X86cmp:isVoid GR8:i8:$src1, GR8:i8:$src2) 50410 // Emits: (CMP8rr:isVoid GR8:i8:$src1, GR8:i8:$src2) 50411 // Pattern complexity = 3 cost = 1 size = 3 50412 if (N0.getNode()->getValueType(0) == MVT::i8) { 50413 SDNode *Result = Emit_257(N, X86::CMP8rr); 50414 return Result; 50415 } 50416 50417 // Pattern: (X86cmp:isVoid GR16:i16:$src1, GR16:i16:$src2) 50418 // Emits: (CMP16rr:isVoid GR16:i16:$src1, GR16:i16:$src2) 50419 // Pattern complexity = 3 cost = 1 size = 3 50420 if (N0.getNode()->getValueType(0) == MVT::i16) { 50421 SDNode *Result = Emit_257(N, X86::CMP16rr); 50422 return Result; 50423 } 50424 50425 // Pattern: (X86cmp:isVoid GR32:i32:$src1, GR32:i32:$src2) 50426 // Emits: (CMP32rr:isVoid GR32:i32:$src1, GR32:i32:$src2) 50427 // Pattern complexity = 3 cost = 1 size = 3 50428 if (N0.getNode()->getValueType(0) == MVT::i32) { 50429 SDNode *Result = Emit_257(N, X86::CMP32rr); 50430 return Result; 50431 } 50432 50433 // Pattern: (X86cmp:isVoid GR64:i64:$src1, GR64:i64:$src2) 50434 // Emits: (CMP64rr:isVoid GR64:i64:$src1, GR64:i64:$src2) 50435 // Pattern complexity = 3 cost = 1 size = 3 50436 if (N0.getNode()->getValueType(0) == MVT::i64) { 50437 SDNode *Result = Emit_257(N, X86::CMP64rr); 50438 return Result; 50439 } 50440 } 50441 50442 // Pattern: (X86cmp:isVoid FR32:f32:$src1, FR32:f32:$src2) 50443 // Emits: (UCOMISSrr:isVoid FR32:f32:$src1, FR32:f32:$src2) 50444 // Pattern complexity = 3 cost = 1 size = 3 50445 if ((Subtarget->hasSSE1())) { 50446 SDValue N0 = N.getOperand(0); 50447 SDValue N1 = N.getOperand(1); 50448 if (N0.getNode()->getValueType(0) == MVT::f32) { 50449 SDNode *Result = Emit_257(N, X86::UCOMISSrr); 50450 return Result; 50451 } 50452 } 50453 50454 // Pattern: (X86cmp:isVoid FR64:f64:$src1, FR64:f64:$src2) 50455 // Emits: (UCOMISDrr:isVoid FR64:f64:$src1, FR64:f64:$src2) 50456 // Pattern complexity = 3 cost = 1 size = 3 50457 if ((Subtarget->hasSSE2())) { 50458 SDValue N0 = N.getOperand(0); 50459 SDValue N1 = N.getOperand(1); 50460 if (N0.getNode()->getValueType(0) == MVT::f64) { 50461 SDNode *Result = Emit_257(N, X86::UCOMISDrr); 50462 return Result; 50463 } 50464 } 50465 50466 CannotYetSelect(N); 50467 return NULL; 50468 } 50469 50470 SDNode *Emit_287(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 50471 SDValue N0 = N.getOperand(0); 50472 SDValue N1 = N.getOperand(1); 50473 SDValue N2 = N.getOperand(2); 50474 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N2)->getZExtValue()), MVT::i8); 50475 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, N1, Tmp2); 50476 } 50477 SDNode *Emit_288(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN11_0, SDValue &CPTmpN11_1, SDValue &CPTmpN11_2, SDValue &CPTmpN11_3, SDValue &CPTmpN11_4) DISABLE_INLINE { 50478 SDValue N0 = N.getOperand(0); 50479 SDValue N1 = N.getOperand(1); 50480 SDValue Chain1 = N1.getOperand(0); 50481 SDValue N11 = N1.getOperand(1); 50482 SDValue N2 = N.getOperand(2); 50483 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned char) cast<ConstantSDNode>(N2)->getZExtValue()), MVT::i8); 50484 SDValue LSI_N1 = CurDAG->getMemOperand(cast<MemSDNode>(N1)->getMemOperand()); 50485 SDValue Ops0[] = { N0, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4, Tmp2, LSI_N1, Chain1 }; 50486 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 9); 50487 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1)); 50488 return ResNode; 50489 } 50490 SDNode *Select_X86ISD_CMPPD_v2i64(const SDValue &N) { 50491 50492 // Pattern: (X86cmppd:v2i64 VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (imm:i8):$cc) 50493 // Emits: (CMPPDrmi:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2, (imm:i8):$cc) 50494 // Pattern complexity = 28 cost = 1 size = 3 50495 if (OptLevel != CodeGenOpt::None) { 50496 SDValue N0 = N.getOperand(0); 50497 SDValue N1 = N.getOperand(1); 50498 if (N1.getOpcode() == ISD::LOAD && 50499 N1.hasOneUse() && 50500 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 50501 SDValue Chain1 = N1.getOperand(0); 50502 if (Predicate_unindexedload(N1.getNode()) && 50503 Predicate_load(N1.getNode()) && 50504 Predicate_memop(N1.getNode())) { 50505 SDValue N11 = N1.getOperand(1); 50506 SDValue CPTmpN11_0; 50507 SDValue CPTmpN11_1; 50508 SDValue CPTmpN11_2; 50509 SDValue CPTmpN11_3; 50510 SDValue CPTmpN11_4; 50511 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 50512 SDValue N2 = N.getOperand(2); 50513 if (N2.getOpcode() == ISD::Constant && 50514 N0.getNode()->getValueType(0) == MVT::v2f64) { 50515 SDNode *Result = Emit_288(N, X86::CMPPDrmi, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 50516 return Result; 50517 } 50518 } 50519 } 50520 } 50521 } 50522 50523 // Pattern: (X86cmppd:v2i64 VR128:v2f64:$src1, VR128:v2f64:$src2, (imm:i8):$cc) 50524 // Emits: (CMPPDrri:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i8):$cc) 50525 // Pattern complexity = 6 cost = 1 size = 3 50526 SDValue N0 = N.getOperand(0); 50527 SDValue N1 = N.getOperand(1); 50528 SDValue N2 = N.getOperand(2); 50529 if (N2.getOpcode() == ISD::Constant && 50530 N0.getNode()->getValueType(0) == MVT::v2f64) { 50531 SDNode *Result = Emit_287(N, X86::CMPPDrri, MVT::v2i64); 50532 return Result; 50533 } 50534 50535 CannotYetSelect(N); 50536 return NULL; 50537 } 50538 50539 SDNode *Select_X86ISD_CMPPS_v4i32(const SDValue &N) { 50540 50541 // Pattern: (X86cmpps:v4i32 VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, (imm:i8):$cc) 50542 // Emits: (CMPPSrmi:v4i32 VR128:v16i8:$src1, addr:iPTR:$src2, (imm:i8):$cc) 50543 // Pattern complexity = 28 cost = 1 size = 3 50544 if (OptLevel != CodeGenOpt::None) { 50545 SDValue N0 = N.getOperand(0); 50546 SDValue N1 = N.getOperand(1); 50547 if (N1.getOpcode() == ISD::LOAD && 50548 N1.hasOneUse() && 50549 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 50550 SDValue Chain1 = N1.getOperand(0); 50551 if (Predicate_unindexedload(N1.getNode()) && 50552 Predicate_load(N1.getNode()) && 50553 Predicate_memop(N1.getNode())) { 50554 SDValue N11 = N1.getOperand(1); 50555 SDValue CPTmpN11_0; 50556 SDValue CPTmpN11_1; 50557 SDValue CPTmpN11_2; 50558 SDValue CPTmpN11_3; 50559 SDValue CPTmpN11_4; 50560 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 50561 SDValue N2 = N.getOperand(2); 50562 if (N2.getOpcode() == ISD::Constant && 50563 N0.getNode()->getValueType(0) == MVT::v4f32) { 50564 SDNode *Result = Emit_288(N, X86::CMPPSrmi, MVT::v4i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 50565 return Result; 50566 } 50567 } 50568 } 50569 } 50570 } 50571 50572 // Pattern: (X86cmpps:v4i32 VR128:v4f32:$src1, VR128:v4f32:$src2, (imm:i8):$cc) 50573 // Emits: (CMPPSrri:v4i32 VR128:v16i8:$src1, VR128:v16i8:$src2, (imm:i8):$cc) 50574 // Pattern complexity = 6 cost = 1 size = 3 50575 SDValue N0 = N.getOperand(0); 50576 SDValue N1 = N.getOperand(1); 50577 SDValue N2 = N.getOperand(2); 50578 if (N2.getOpcode() == ISD::Constant && 50579 N0.getNode()->getValueType(0) == MVT::v4f32) { 50580 SDNode *Result = Emit_287(N, X86::CMPPSrri, MVT::v4i32); 50581 return Result; 50582 } 50583 50584 CannotYetSelect(N); 50585 return NULL; 50586 } 50587 50588 SDNode *Select_X86ISD_COMI(const SDValue &N) { 50589 if (OptLevel != CodeGenOpt::None) { 50590 50591 // Pattern: (X86comi:isVoid VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 50592 // Emits: (Int_COMISSrm:isVoid VR128:v4f32:$src1, addr:iPTR:$src2) 50593 // Pattern complexity = 25 cost = 1 size = 3 50594 if ((Subtarget->hasSSE1())) { 50595 SDValue N0 = N.getOperand(0); 50596 SDValue N1 = N.getOperand(1); 50597 if (N1.getOpcode() == ISD::LOAD && 50598 N1.hasOneUse() && 50599 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 50600 SDValue Chain1 = N1.getOperand(0); 50601 if (Predicate_unindexedload(N1.getNode()) && 50602 Predicate_load(N1.getNode())) { 50603 SDValue N11 = N1.getOperand(1); 50604 SDValue CPTmpN11_0; 50605 SDValue CPTmpN11_1; 50606 SDValue CPTmpN11_2; 50607 SDValue CPTmpN11_3; 50608 SDValue CPTmpN11_4; 50609 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 50610 N0.getNode()->getValueType(0) == MVT::v4f32) { 50611 SDNode *Result = Emit_280(N, X86::Int_COMISSrm, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 50612 return Result; 50613 } 50614 } 50615 } 50616 } 50617 50618 // Pattern: (X86comi:isVoid VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 50619 // Emits: (Int_COMISDrm:isVoid VR128:v2f64:$src1, addr:iPTR:$src2) 50620 // Pattern complexity = 25 cost = 1 size = 3 50621 if ((Subtarget->hasSSE2())) { 50622 SDValue N0 = N.getOperand(0); 50623 SDValue N1 = N.getOperand(1); 50624 if (N1.getOpcode() == ISD::LOAD && 50625 N1.hasOneUse() && 50626 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 50627 SDValue Chain1 = N1.getOperand(0); 50628 if (Predicate_unindexedload(N1.getNode()) && 50629 Predicate_load(N1.getNode())) { 50630 SDValue N11 = N1.getOperand(1); 50631 SDValue CPTmpN11_0; 50632 SDValue CPTmpN11_1; 50633 SDValue CPTmpN11_2; 50634 SDValue CPTmpN11_3; 50635 SDValue CPTmpN11_4; 50636 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 50637 N0.getNode()->getValueType(0) == MVT::v2f64) { 50638 SDNode *Result = Emit_280(N, X86::Int_COMISDrm, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 50639 return Result; 50640 } 50641 } 50642 } 50643 } 50644 } 50645 50646 // Pattern: (X86comi:isVoid VR128:v4f32:$src1, VR128:v4f32:$src2) 50647 // Emits: (Int_COMISSrr:isVoid VR128:v4f32:$src1, VR128:v4f32:$src2) 50648 // Pattern complexity = 3 cost = 1 size = 3 50649 if ((Subtarget->hasSSE1())) { 50650 SDValue N0 = N.getOperand(0); 50651 SDValue N1 = N.getOperand(1); 50652 if (N0.getNode()->getValueType(0) == MVT::v4f32) { 50653 SDNode *Result = Emit_257(N, X86::Int_COMISSrr); 50654 return Result; 50655 } 50656 } 50657 50658 // Pattern: (X86comi:isVoid VR128:v2f64:$src1, VR128:v2f64:$src2) 50659 // Emits: (Int_COMISDrr:isVoid VR128:v2f64:$src1, VR128:v2f64:$src2) 50660 // Pattern complexity = 3 cost = 1 size = 3 50661 if ((Subtarget->hasSSE2())) { 50662 SDValue N0 = N.getOperand(0); 50663 SDValue N1 = N.getOperand(1); 50664 if (N0.getNode()->getValueType(0) == MVT::v2f64) { 50665 SDNode *Result = Emit_257(N, X86::Int_COMISDrr); 50666 return Result; 50667 } 50668 } 50669 50670 CannotYetSelect(N); 50671 return NULL; 50672 } 50673 50674 SDNode *Select_X86ISD_DEC_i8(const SDValue &N) { 50675 SDValue N0 = N.getOperand(0); 50676 if (N0.getNode()->getValueType(0) == MVT::i8) { 50677 SDNode *Result = Emit_255(N, X86::DEC8r, MVT::i8); 50678 return Result; 50679 } 50680 50681 CannotYetSelect(N); 50682 return NULL; 50683 } 50684 50685 SDNode *Select_X86ISD_DEC_i16(const SDValue &N) { 50686 50687 // Pattern: (X86dec_flag:i16 GR16:i16:$src) 50688 // Emits: (DEC16r:i16 GR16:i16:$src) 50689 // Pattern complexity = 3 cost = 1 size = 1 50690 if ((!Subtarget->is64Bit())) { 50691 SDValue N0 = N.getOperand(0); 50692 if (N0.getNode()->getValueType(0) == MVT::i16) { 50693 SDNode *Result = Emit_255(N, X86::DEC16r, MVT::i16); 50694 return Result; 50695 } 50696 } 50697 50698 // Pattern: (X86dec_flag:i16 GR16:i16:$src) 50699 // Emits: (DEC64_16r:i16 GR16:i16:$src) 50700 // Pattern complexity = 3 cost = 1 size = 2 50701 if ((Subtarget->is64Bit())) { 50702 SDValue N0 = N.getOperand(0); 50703 if (N0.getNode()->getValueType(0) == MVT::i16) { 50704 SDNode *Result = Emit_255(N, X86::DEC64_16r, MVT::i16); 50705 return Result; 50706 } 50707 } 50708 50709 CannotYetSelect(N); 50710 return NULL; 50711 } 50712 50713 SDNode *Select_X86ISD_DEC_i32(const SDValue &N) { 50714 50715 // Pattern: (X86dec_flag:i32 GR32:i32:$src) 50716 // Emits: (DEC32r:i32 GR32:i32:$src) 50717 // Pattern complexity = 3 cost = 1 size = 1 50718 if ((!Subtarget->is64Bit())) { 50719 SDValue N0 = N.getOperand(0); 50720 if (N0.getNode()->getValueType(0) == MVT::i32) { 50721 SDNode *Result = Emit_255(N, X86::DEC32r, MVT::i32); 50722 return Result; 50723 } 50724 } 50725 50726 // Pattern: (X86dec_flag:i32 GR32:i32:$src) 50727 // Emits: (DEC64_32r:i32 GR32:i32:$src) 50728 // Pattern complexity = 3 cost = 1 size = 2 50729 if ((Subtarget->is64Bit())) { 50730 SDValue N0 = N.getOperand(0); 50731 if (N0.getNode()->getValueType(0) == MVT::i32) { 50732 SDNode *Result = Emit_255(N, X86::DEC64_32r, MVT::i32); 50733 return Result; 50734 } 50735 } 50736 50737 CannotYetSelect(N); 50738 return NULL; 50739 } 50740 50741 SDNode *Select_X86ISD_DEC_i64(const SDValue &N) { 50742 SDValue N0 = N.getOperand(0); 50743 if (N0.getNode()->getValueType(0) == MVT::i64) { 50744 SDNode *Result = Emit_255(N, X86::DEC64r, MVT::i64); 50745 return Result; 50746 } 50747 50748 CannotYetSelect(N); 50749 return NULL; 50750 } 50751 50752 SDNode *Select_X86ISD_EH_RETURN(const SDValue &N) { 50753 SDValue Chain = N.getOperand(0); 50754 SDValue N1 = N.getOperand(1); 50755 50756 // Pattern: (X86ehret:isVoid GR32:i32:$addr) 50757 // Emits: (EH_RETURN:isVoid GR32:i32:$addr) 50758 // Pattern complexity = 3 cost = 1 size = 3 50759 if (N1.getNode()->getValueType(0) == MVT::i32) { 50760 SDNode *Result = Emit_80(N, X86::EH_RETURN); 50761 return Result; 50762 } 50763 50764 // Pattern: (X86ehret:isVoid GR64:i64:$addr) 50765 // Emits: (EH_RETURN64:isVoid GR64:i64:$addr) 50766 // Pattern complexity = 3 cost = 1 size = 3 50767 if (N1.getNode()->getValueType(0) == MVT::i64) { 50768 SDNode *Result = Emit_80(N, X86::EH_RETURN64); 50769 return Result; 50770 } 50771 50772 CannotYetSelect(N); 50773 return NULL; 50774 } 50775 50776 SDNode *Select_X86ISD_FAND_f32(const SDValue &N) { 50777 if (OptLevel != CodeGenOpt::None && 50778 (Subtarget->hasSSE1())) { 50779 SDValue N0 = N.getOperand(0); 50780 50781 // Pattern: (X86fand:f32 FR32:f32:$src1, (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 50782 // Emits: (FsANDPSrm:f32 FR32:f32:$src1, addr:iPTR:$src2) 50783 // Pattern complexity = 25 cost = 1 size = 3 50784 { 50785 SDValue N1 = N.getOperand(1); 50786 if (N1.getOpcode() == ISD::LOAD && 50787 N1.hasOneUse() && 50788 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 50789 SDValue Chain1 = N1.getOperand(0); 50790 if (Predicate_unindexedload(N1.getNode()) && 50791 Predicate_load(N1.getNode()) && 50792 Predicate_memop(N1.getNode())) { 50793 SDValue N11 = N1.getOperand(1); 50794 SDValue CPTmpN11_0; 50795 SDValue CPTmpN11_1; 50796 SDValue CPTmpN11_2; 50797 SDValue CPTmpN11_3; 50798 SDValue CPTmpN11_4; 50799 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 50800 SDNode *Result = Emit_18(N, X86::FsANDPSrm, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 50801 return Result; 50802 } 50803 } 50804 } 50805 } 50806 50807 // Pattern: (X86fand:f32 (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, FR32:f32:$src1) 50808 // Emits: (FsANDPSrm:f32 FR32:f32:$src1, addr:iPTR:$src2) 50809 // Pattern complexity = 25 cost = 1 size = 3 50810 if (N0.getOpcode() == ISD::LOAD && 50811 N0.hasOneUse() && 50812 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 50813 SDValue Chain0 = N0.getOperand(0); 50814 if (Predicate_unindexedload(N0.getNode()) && 50815 Predicate_load(N0.getNode()) && 50816 Predicate_memop(N0.getNode())) { 50817 SDValue N01 = N0.getOperand(1); 50818 SDValue CPTmpN01_0; 50819 SDValue CPTmpN01_1; 50820 SDValue CPTmpN01_2; 50821 SDValue CPTmpN01_3; 50822 SDValue CPTmpN01_4; 50823 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 50824 SDNode *Result = Emit_19(N, X86::FsANDPSrm, MVT::f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 50825 return Result; 50826 } 50827 } 50828 } 50829 } 50830 50831 // Pattern: (X86fand:f32 FR32:f32:$src1, FR32:f32:$src2) 50832 // Emits: (FsANDPSrr:f32 FR32:f32:$src1, FR32:f32:$src2) 50833 // Pattern complexity = 3 cost = 1 size = 3 50834 if ((Subtarget->hasSSE1())) { 50835 SDNode *Result = Emit_15(N, X86::FsANDPSrr, MVT::f32); 50836 return Result; 50837 } 50838 50839 CannotYetSelect(N); 50840 return NULL; 50841 } 50842 50843 SDNode *Select_X86ISD_FAND_f64(const SDValue &N) { 50844 if (OptLevel != CodeGenOpt::None && 50845 (Subtarget->hasSSE2())) { 50846 SDValue N0 = N.getOperand(0); 50847 50848 // Pattern: (X86fand:f64 FR64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 50849 // Emits: (FsANDPDrm:f64 FR64:f64:$src1, addr:iPTR:$src2) 50850 // Pattern complexity = 25 cost = 1 size = 3 50851 { 50852 SDValue N1 = N.getOperand(1); 50853 if (N1.getOpcode() == ISD::LOAD && 50854 N1.hasOneUse() && 50855 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 50856 SDValue Chain1 = N1.getOperand(0); 50857 if (Predicate_unindexedload(N1.getNode()) && 50858 Predicate_load(N1.getNode()) && 50859 Predicate_memop(N1.getNode())) { 50860 SDValue N11 = N1.getOperand(1); 50861 SDValue CPTmpN11_0; 50862 SDValue CPTmpN11_1; 50863 SDValue CPTmpN11_2; 50864 SDValue CPTmpN11_3; 50865 SDValue CPTmpN11_4; 50866 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 50867 SDNode *Result = Emit_18(N, X86::FsANDPDrm, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 50868 return Result; 50869 } 50870 } 50871 } 50872 } 50873 50874 // Pattern: (X86fand:f64 (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, FR64:f64:$src1) 50875 // Emits: (FsANDPDrm:f64 FR64:f64:$src1, addr:iPTR:$src2) 50876 // Pattern complexity = 25 cost = 1 size = 3 50877 if (N0.getOpcode() == ISD::LOAD && 50878 N0.hasOneUse() && 50879 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 50880 SDValue Chain0 = N0.getOperand(0); 50881 if (Predicate_unindexedload(N0.getNode()) && 50882 Predicate_load(N0.getNode()) && 50883 Predicate_memop(N0.getNode())) { 50884 SDValue N01 = N0.getOperand(1); 50885 SDValue CPTmpN01_0; 50886 SDValue CPTmpN01_1; 50887 SDValue CPTmpN01_2; 50888 SDValue CPTmpN01_3; 50889 SDValue CPTmpN01_4; 50890 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 50891 SDNode *Result = Emit_19(N, X86::FsANDPDrm, MVT::f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 50892 return Result; 50893 } 50894 } 50895 } 50896 } 50897 50898 // Pattern: (X86fand:f64 FR64:f64:$src1, FR64:f64:$src2) 50899 // Emits: (FsANDPDrr:f64 FR64:f64:$src1, FR64:f64:$src2) 50900 // Pattern complexity = 3 cost = 1 size = 3 50901 if ((Subtarget->hasSSE2())) { 50902 SDNode *Result = Emit_15(N, X86::FsANDPDrr, MVT::f64); 50903 return Result; 50904 } 50905 50906 CannotYetSelect(N); 50907 return NULL; 50908 } 50909 50910 SDNode *Emit_289(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN1_0, SDValue &CPTmpN1_1, SDValue &CPTmpN1_2, SDValue &CPTmpN1_3, SDValue &CPTmpN1_4) DISABLE_INLINE { 50911 SDValue Chain = N.getOperand(0); 50912 SDValue N1 = N.getOperand(1); 50913 SDValue N2 = N.getOperand(2); 50914 SDValue Ops0[] = { CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, Chain }; 50915 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 6); 50916 } 50917 SDNode *Select_X86ISD_FILD_f32(const SDValue &N) { 50918 if ((!Subtarget->hasSSE1())) { 50919 SDValue Chain = N.getOperand(0); 50920 SDValue N1 = N.getOperand(1); 50921 SDValue CPTmpN1_0; 50922 SDValue CPTmpN1_1; 50923 SDValue CPTmpN1_2; 50924 SDValue CPTmpN1_3; 50925 SDValue CPTmpN1_4; 50926 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 50927 SDValue N2 = N.getOperand(2); 50928 50929 // Pattern: (X86fild:f32 addr:iPTR:$src, i16:Other) 50930 // Emits: (ILD_Fp16m32:f32 addr:iPTR:$src) 50931 // Pattern complexity = 21 cost = 1 size = 0 50932 if (cast<VTSDNode>(N2)->getVT() == MVT::i16) { 50933 SDNode *Result = Emit_289(N, X86::ILD_Fp16m32, MVT::f32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 50934 return Result; 50935 } 50936 50937 // Pattern: (X86fild:f32 addr:iPTR:$src, i32:Other) 50938 // Emits: (ILD_Fp32m32:f32 addr:iPTR:$src) 50939 // Pattern complexity = 21 cost = 1 size = 0 50940 if (cast<VTSDNode>(N2)->getVT() == MVT::i32) { 50941 SDNode *Result = Emit_289(N, X86::ILD_Fp32m32, MVT::f32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 50942 return Result; 50943 } 50944 50945 // Pattern: (X86fild:f32 addr:iPTR:$src, i64:Other) 50946 // Emits: (ILD_Fp64m32:f32 addr:iPTR:$src) 50947 // Pattern complexity = 21 cost = 1 size = 0 50948 if (cast<VTSDNode>(N2)->getVT() == MVT::i64) { 50949 SDNode *Result = Emit_289(N, X86::ILD_Fp64m32, MVT::f32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 50950 return Result; 50951 } 50952 } 50953 } 50954 50955 CannotYetSelect(N); 50956 return NULL; 50957 } 50958 50959 SDNode *Select_X86ISD_FILD_f64(const SDValue &N) { 50960 if ((!Subtarget->hasSSE2())) { 50961 SDValue Chain = N.getOperand(0); 50962 SDValue N1 = N.getOperand(1); 50963 SDValue CPTmpN1_0; 50964 SDValue CPTmpN1_1; 50965 SDValue CPTmpN1_2; 50966 SDValue CPTmpN1_3; 50967 SDValue CPTmpN1_4; 50968 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 50969 SDValue N2 = N.getOperand(2); 50970 50971 // Pattern: (X86fild:f64 addr:iPTR:$src, i16:Other) 50972 // Emits: (ILD_Fp16m64:f64 addr:iPTR:$src) 50973 // Pattern complexity = 21 cost = 1 size = 0 50974 if (cast<VTSDNode>(N2)->getVT() == MVT::i16) { 50975 SDNode *Result = Emit_289(N, X86::ILD_Fp16m64, MVT::f64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 50976 return Result; 50977 } 50978 50979 // Pattern: (X86fild:f64 addr:iPTR:$src, i32:Other) 50980 // Emits: (ILD_Fp32m64:f64 addr:iPTR:$src) 50981 // Pattern complexity = 21 cost = 1 size = 0 50982 if (cast<VTSDNode>(N2)->getVT() == MVT::i32) { 50983 SDNode *Result = Emit_289(N, X86::ILD_Fp32m64, MVT::f64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 50984 return Result; 50985 } 50986 50987 // Pattern: (X86fild:f64 addr:iPTR:$src, i64:Other) 50988 // Emits: (ILD_Fp64m64:f64 addr:iPTR:$src) 50989 // Pattern complexity = 21 cost = 1 size = 0 50990 if (cast<VTSDNode>(N2)->getVT() == MVT::i64) { 50991 SDNode *Result = Emit_289(N, X86::ILD_Fp64m64, MVT::f64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 50992 return Result; 50993 } 50994 } 50995 } 50996 50997 CannotYetSelect(N); 50998 return NULL; 50999 } 51000 51001 SDNode *Select_X86ISD_FILD_f80(const SDValue &N) { 51002 SDValue Chain = N.getOperand(0); 51003 SDValue N1 = N.getOperand(1); 51004 SDValue CPTmpN1_0; 51005 SDValue CPTmpN1_1; 51006 SDValue CPTmpN1_2; 51007 SDValue CPTmpN1_3; 51008 SDValue CPTmpN1_4; 51009 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 51010 SDValue N2 = N.getOperand(2); 51011 51012 // Pattern: (X86fild:f80 addr:iPTR:$src, i16:Other) 51013 // Emits: (ILD_Fp16m80:f80 addr:iPTR:$src) 51014 // Pattern complexity = 21 cost = 1 size = 0 51015 if (cast<VTSDNode>(N2)->getVT() == MVT::i16) { 51016 SDNode *Result = Emit_289(N, X86::ILD_Fp16m80, MVT::f80, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 51017 return Result; 51018 } 51019 51020 // Pattern: (X86fild:f80 addr:iPTR:$src, i32:Other) 51021 // Emits: (ILD_Fp32m80:f80 addr:iPTR:$src) 51022 // Pattern complexity = 21 cost = 1 size = 0 51023 if (cast<VTSDNode>(N2)->getVT() == MVT::i32) { 51024 SDNode *Result = Emit_289(N, X86::ILD_Fp32m80, MVT::f80, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 51025 return Result; 51026 } 51027 51028 // Pattern: (X86fild:f80 addr:iPTR:$src, i64:Other) 51029 // Emits: (ILD_Fp64m80:f80 addr:iPTR:$src) 51030 // Pattern complexity = 21 cost = 1 size = 0 51031 if (cast<VTSDNode>(N2)->getVT() == MVT::i64) { 51032 SDNode *Result = Emit_289(N, X86::ILD_Fp64m80, MVT::f80, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 51033 return Result; 51034 } 51035 } 51036 51037 CannotYetSelect(N); 51038 return NULL; 51039 } 51040 51041 SDNode *Emit_290(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN1_0, SDValue &CPTmpN1_1, SDValue &CPTmpN1_2, SDValue &CPTmpN1_3, SDValue &CPTmpN1_4) DISABLE_INLINE { 51042 SDValue Chain = N.getOperand(0); 51043 SDValue N1 = N.getOperand(1); 51044 SDValue N2 = N.getOperand(2); 51045 SDValue Ops0[] = { CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, Chain }; 51046 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, MVT::Flag, Ops0, 6); 51047 Chain = SDValue(ResNode, 1); 51048 SDValue InFlag(ResNode, 2); 51049 const SDValue Froms[] = { 51050 SDValue(N.getNode(), 2), 51051 SDValue(N.getNode(), 1) 51052 }; 51053 const SDValue Tos[] = { 51054 InFlag, 51055 SDValue(Chain.getNode(), Chain.getResNo()) 51056 }; 51057 ReplaceUses(Froms, Tos, 2); 51058 return ResNode; 51059 } 51060 SDNode *Select_X86ISD_FILD_FLAG_f64(const SDValue &N) { 51061 SDValue Chain = N.getOperand(0); 51062 SDValue N1 = N.getOperand(1); 51063 SDValue CPTmpN1_0; 51064 SDValue CPTmpN1_1; 51065 SDValue CPTmpN1_2; 51066 SDValue CPTmpN1_3; 51067 SDValue CPTmpN1_4; 51068 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 51069 SDValue N2 = N.getOperand(2); 51070 if (cast<VTSDNode>(N2)->getVT() == MVT::i64) { 51071 SDNode *Result = Emit_290(N, X86::ILD_Fp64m64, MVT::f64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 51072 return Result; 51073 } 51074 } 51075 51076 CannotYetSelect(N); 51077 return NULL; 51078 } 51079 51080 SDNode *Select_X86ISD_FLD_f32(const SDValue &N) { 51081 SDValue Chain = N.getOperand(0); 51082 SDValue N1 = N.getOperand(1); 51083 SDValue CPTmpN1_0; 51084 SDValue CPTmpN1_1; 51085 SDValue CPTmpN1_2; 51086 SDValue CPTmpN1_3; 51087 SDValue CPTmpN1_4; 51088 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 51089 SDValue N2 = N.getOperand(2); 51090 if (cast<VTSDNode>(N2)->getVT() == MVT::f32) { 51091 SDNode *Result = Emit_289(N, X86::LD_Fp32m, MVT::f32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 51092 return Result; 51093 } 51094 } 51095 51096 CannotYetSelect(N); 51097 return NULL; 51098 } 51099 51100 SDNode *Select_X86ISD_FLD_f64(const SDValue &N) { 51101 SDValue Chain = N.getOperand(0); 51102 SDValue N1 = N.getOperand(1); 51103 SDValue CPTmpN1_0; 51104 SDValue CPTmpN1_1; 51105 SDValue CPTmpN1_2; 51106 SDValue CPTmpN1_3; 51107 SDValue CPTmpN1_4; 51108 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 51109 SDValue N2 = N.getOperand(2); 51110 if (cast<VTSDNode>(N2)->getVT() == MVT::f64) { 51111 SDNode *Result = Emit_289(N, X86::LD_Fp64m, MVT::f64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 51112 return Result; 51113 } 51114 } 51115 51116 CannotYetSelect(N); 51117 return NULL; 51118 } 51119 51120 SDNode *Select_X86ISD_FLD_f80(const SDValue &N) { 51121 SDValue Chain = N.getOperand(0); 51122 SDValue N1 = N.getOperand(1); 51123 SDValue CPTmpN1_0; 51124 SDValue CPTmpN1_1; 51125 SDValue CPTmpN1_2; 51126 SDValue CPTmpN1_3; 51127 SDValue CPTmpN1_4; 51128 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 51129 SDValue N2 = N.getOperand(2); 51130 if (cast<VTSDNode>(N2)->getVT() == MVT::f80) { 51131 SDNode *Result = Emit_289(N, X86::LD_Fp80m, MVT::f80, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 51132 return Result; 51133 } 51134 } 51135 51136 CannotYetSelect(N); 51137 return NULL; 51138 } 51139 51140 SDNode *Select_X86ISD_FMAX_f32(const SDValue &N) { 51141 51142 // Pattern: (X86fmax:f32 FR32:f32:$src1, (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 51143 // Emits: (MAXSSrm:f32 FR32:f32:$src1, addr:iPTR:$src2) 51144 // Pattern complexity = 25 cost = 1 size = 3 51145 if (OptLevel != CodeGenOpt::None && 51146 (Subtarget->hasSSE1())) { 51147 SDValue N0 = N.getOperand(0); 51148 SDValue N1 = N.getOperand(1); 51149 if (N1.getOpcode() == ISD::LOAD && 51150 N1.hasOneUse() && 51151 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 51152 SDValue Chain1 = N1.getOperand(0); 51153 if (Predicate_unindexedload(N1.getNode()) && 51154 Predicate_load(N1.getNode())) { 51155 SDValue N11 = N1.getOperand(1); 51156 SDValue CPTmpN11_0; 51157 SDValue CPTmpN11_1; 51158 SDValue CPTmpN11_2; 51159 SDValue CPTmpN11_3; 51160 SDValue CPTmpN11_4; 51161 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 51162 SDNode *Result = Emit_18(N, X86::MAXSSrm, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 51163 return Result; 51164 } 51165 } 51166 } 51167 } 51168 51169 // Pattern: (X86fmax:f32 FR32:f32:$src1, FR32:f32:$src2) 51170 // Emits: (MAXSSrr:f32 FR32:f32:$src1, FR32:f32:$src2) 51171 // Pattern complexity = 3 cost = 1 size = 3 51172 if ((Subtarget->hasSSE1())) { 51173 SDNode *Result = Emit_15(N, X86::MAXSSrr, MVT::f32); 51174 return Result; 51175 } 51176 51177 CannotYetSelect(N); 51178 return NULL; 51179 } 51180 51181 SDNode *Select_X86ISD_FMAX_f64(const SDValue &N) { 51182 51183 // Pattern: (X86fmax:f64 FR64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 51184 // Emits: (MAXSDrm:f64 FR64:f64:$src1, addr:iPTR:$src2) 51185 // Pattern complexity = 25 cost = 1 size = 3 51186 if (OptLevel != CodeGenOpt::None && 51187 (Subtarget->hasSSE2())) { 51188 SDValue N0 = N.getOperand(0); 51189 SDValue N1 = N.getOperand(1); 51190 if (N1.getOpcode() == ISD::LOAD && 51191 N1.hasOneUse() && 51192 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 51193 SDValue Chain1 = N1.getOperand(0); 51194 if (Predicate_unindexedload(N1.getNode()) && 51195 Predicate_load(N1.getNode())) { 51196 SDValue N11 = N1.getOperand(1); 51197 SDValue CPTmpN11_0; 51198 SDValue CPTmpN11_1; 51199 SDValue CPTmpN11_2; 51200 SDValue CPTmpN11_3; 51201 SDValue CPTmpN11_4; 51202 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 51203 SDNode *Result = Emit_18(N, X86::MAXSDrm, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 51204 return Result; 51205 } 51206 } 51207 } 51208 } 51209 51210 // Pattern: (X86fmax:f64 FR64:f64:$src1, FR64:f64:$src2) 51211 // Emits: (MAXSDrr:f64 FR64:f64:$src1, FR64:f64:$src2) 51212 // Pattern complexity = 3 cost = 1 size = 3 51213 if ((Subtarget->hasSSE2())) { 51214 SDNode *Result = Emit_15(N, X86::MAXSDrr, MVT::f64); 51215 return Result; 51216 } 51217 51218 CannotYetSelect(N); 51219 return NULL; 51220 } 51221 51222 SDNode *Select_X86ISD_FMAX_v4f32(const SDValue &N) { 51223 51224 // Pattern: (X86fmax:v4f32 VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 51225 // Emits: (MAXPSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 51226 // Pattern complexity = 25 cost = 1 size = 3 51227 if (OptLevel != CodeGenOpt::None && 51228 (Subtarget->hasSSE1())) { 51229 SDValue N0 = N.getOperand(0); 51230 SDValue N1 = N.getOperand(1); 51231 if (N1.getOpcode() == ISD::LOAD && 51232 N1.hasOneUse() && 51233 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 51234 SDValue Chain1 = N1.getOperand(0); 51235 if (Predicate_unindexedload(N1.getNode()) && 51236 Predicate_load(N1.getNode()) && 51237 Predicate_memop(N1.getNode())) { 51238 SDValue N11 = N1.getOperand(1); 51239 SDValue CPTmpN11_0; 51240 SDValue CPTmpN11_1; 51241 SDValue CPTmpN11_2; 51242 SDValue CPTmpN11_3; 51243 SDValue CPTmpN11_4; 51244 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 51245 SDNode *Result = Emit_18(N, X86::MAXPSrm, MVT::v4f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 51246 return Result; 51247 } 51248 } 51249 } 51250 } 51251 51252 // Pattern: (X86fmax:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 51253 // Emits: (MAXPSrr:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 51254 // Pattern complexity = 3 cost = 1 size = 3 51255 if ((Subtarget->hasSSE1())) { 51256 SDNode *Result = Emit_15(N, X86::MAXPSrr, MVT::v4f32); 51257 return Result; 51258 } 51259 51260 CannotYetSelect(N); 51261 return NULL; 51262 } 51263 51264 SDNode *Select_X86ISD_FMAX_v2f64(const SDValue &N) { 51265 51266 // Pattern: (X86fmax:v2f64 VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 51267 // Emits: (MAXPDrm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 51268 // Pattern complexity = 25 cost = 1 size = 3 51269 if (OptLevel != CodeGenOpt::None && 51270 (Subtarget->hasSSE2())) { 51271 SDValue N0 = N.getOperand(0); 51272 SDValue N1 = N.getOperand(1); 51273 if (N1.getOpcode() == ISD::LOAD && 51274 N1.hasOneUse() && 51275 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 51276 SDValue Chain1 = N1.getOperand(0); 51277 if (Predicate_unindexedload(N1.getNode()) && 51278 Predicate_load(N1.getNode()) && 51279 Predicate_memop(N1.getNode())) { 51280 SDValue N11 = N1.getOperand(1); 51281 SDValue CPTmpN11_0; 51282 SDValue CPTmpN11_1; 51283 SDValue CPTmpN11_2; 51284 SDValue CPTmpN11_3; 51285 SDValue CPTmpN11_4; 51286 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 51287 SDNode *Result = Emit_18(N, X86::MAXPDrm, MVT::v2f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 51288 return Result; 51289 } 51290 } 51291 } 51292 } 51293 51294 // Pattern: (X86fmax:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 51295 // Emits: (MAXPDrr:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 51296 // Pattern complexity = 3 cost = 1 size = 3 51297 if ((Subtarget->hasSSE2())) { 51298 SDNode *Result = Emit_15(N, X86::MAXPDrr, MVT::v2f64); 51299 return Result; 51300 } 51301 51302 CannotYetSelect(N); 51303 return NULL; 51304 } 51305 51306 SDNode *Select_X86ISD_FMIN_f32(const SDValue &N) { 51307 51308 // Pattern: (X86fmin:f32 FR32:f32:$src1, (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 51309 // Emits: (MINSSrm:f32 FR32:f32:$src1, addr:iPTR:$src2) 51310 // Pattern complexity = 25 cost = 1 size = 3 51311 if (OptLevel != CodeGenOpt::None && 51312 (Subtarget->hasSSE1())) { 51313 SDValue N0 = N.getOperand(0); 51314 SDValue N1 = N.getOperand(1); 51315 if (N1.getOpcode() == ISD::LOAD && 51316 N1.hasOneUse() && 51317 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 51318 SDValue Chain1 = N1.getOperand(0); 51319 if (Predicate_unindexedload(N1.getNode()) && 51320 Predicate_load(N1.getNode())) { 51321 SDValue N11 = N1.getOperand(1); 51322 SDValue CPTmpN11_0; 51323 SDValue CPTmpN11_1; 51324 SDValue CPTmpN11_2; 51325 SDValue CPTmpN11_3; 51326 SDValue CPTmpN11_4; 51327 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 51328 SDNode *Result = Emit_18(N, X86::MINSSrm, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 51329 return Result; 51330 } 51331 } 51332 } 51333 } 51334 51335 // Pattern: (X86fmin:f32 FR32:f32:$src1, FR32:f32:$src2) 51336 // Emits: (MINSSrr:f32 FR32:f32:$src1, FR32:f32:$src2) 51337 // Pattern complexity = 3 cost = 1 size = 3 51338 if ((Subtarget->hasSSE1())) { 51339 SDNode *Result = Emit_15(N, X86::MINSSrr, MVT::f32); 51340 return Result; 51341 } 51342 51343 CannotYetSelect(N); 51344 return NULL; 51345 } 51346 51347 SDNode *Select_X86ISD_FMIN_f64(const SDValue &N) { 51348 51349 // Pattern: (X86fmin:f64 FR64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 51350 // Emits: (MINSDrm:f64 FR64:f64:$src1, addr:iPTR:$src2) 51351 // Pattern complexity = 25 cost = 1 size = 3 51352 if (OptLevel != CodeGenOpt::None && 51353 (Subtarget->hasSSE2())) { 51354 SDValue N0 = N.getOperand(0); 51355 SDValue N1 = N.getOperand(1); 51356 if (N1.getOpcode() == ISD::LOAD && 51357 N1.hasOneUse() && 51358 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 51359 SDValue Chain1 = N1.getOperand(0); 51360 if (Predicate_unindexedload(N1.getNode()) && 51361 Predicate_load(N1.getNode())) { 51362 SDValue N11 = N1.getOperand(1); 51363 SDValue CPTmpN11_0; 51364 SDValue CPTmpN11_1; 51365 SDValue CPTmpN11_2; 51366 SDValue CPTmpN11_3; 51367 SDValue CPTmpN11_4; 51368 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 51369 SDNode *Result = Emit_18(N, X86::MINSDrm, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 51370 return Result; 51371 } 51372 } 51373 } 51374 } 51375 51376 // Pattern: (X86fmin:f64 FR64:f64:$src1, FR64:f64:$src2) 51377 // Emits: (MINSDrr:f64 FR64:f64:$src1, FR64:f64:$src2) 51378 // Pattern complexity = 3 cost = 1 size = 3 51379 if ((Subtarget->hasSSE2())) { 51380 SDNode *Result = Emit_15(N, X86::MINSDrr, MVT::f64); 51381 return Result; 51382 } 51383 51384 CannotYetSelect(N); 51385 return NULL; 51386 } 51387 51388 SDNode *Select_X86ISD_FMIN_v4f32(const SDValue &N) { 51389 51390 // Pattern: (X86fmin:v4f32 VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 51391 // Emits: (MINPSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2) 51392 // Pattern complexity = 25 cost = 1 size = 3 51393 if (OptLevel != CodeGenOpt::None && 51394 (Subtarget->hasSSE1())) { 51395 SDValue N0 = N.getOperand(0); 51396 SDValue N1 = N.getOperand(1); 51397 if (N1.getOpcode() == ISD::LOAD && 51398 N1.hasOneUse() && 51399 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 51400 SDValue Chain1 = N1.getOperand(0); 51401 if (Predicate_unindexedload(N1.getNode()) && 51402 Predicate_load(N1.getNode()) && 51403 Predicate_memop(N1.getNode())) { 51404 SDValue N11 = N1.getOperand(1); 51405 SDValue CPTmpN11_0; 51406 SDValue CPTmpN11_1; 51407 SDValue CPTmpN11_2; 51408 SDValue CPTmpN11_3; 51409 SDValue CPTmpN11_4; 51410 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 51411 SDNode *Result = Emit_18(N, X86::MINPSrm, MVT::v4f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 51412 return Result; 51413 } 51414 } 51415 } 51416 } 51417 51418 // Pattern: (X86fmin:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 51419 // Emits: (MINPSrr:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2) 51420 // Pattern complexity = 3 cost = 1 size = 3 51421 if ((Subtarget->hasSSE1())) { 51422 SDNode *Result = Emit_15(N, X86::MINPSrr, MVT::v4f32); 51423 return Result; 51424 } 51425 51426 CannotYetSelect(N); 51427 return NULL; 51428 } 51429 51430 SDNode *Select_X86ISD_FMIN_v2f64(const SDValue &N) { 51431 51432 // Pattern: (X86fmin:v2f64 VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 51433 // Emits: (MINPDrm:v2f64 VR128:v2f64:$src1, addr:iPTR:$src2) 51434 // Pattern complexity = 25 cost = 1 size = 3 51435 if (OptLevel != CodeGenOpt::None && 51436 (Subtarget->hasSSE2())) { 51437 SDValue N0 = N.getOperand(0); 51438 SDValue N1 = N.getOperand(1); 51439 if (N1.getOpcode() == ISD::LOAD && 51440 N1.hasOneUse() && 51441 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 51442 SDValue Chain1 = N1.getOperand(0); 51443 if (Predicate_unindexedload(N1.getNode()) && 51444 Predicate_load(N1.getNode()) && 51445 Predicate_memop(N1.getNode())) { 51446 SDValue N11 = N1.getOperand(1); 51447 SDValue CPTmpN11_0; 51448 SDValue CPTmpN11_1; 51449 SDValue CPTmpN11_2; 51450 SDValue CPTmpN11_3; 51451 SDValue CPTmpN11_4; 51452 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 51453 SDNode *Result = Emit_18(N, X86::MINPDrm, MVT::v2f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 51454 return Result; 51455 } 51456 } 51457 } 51458 } 51459 51460 // Pattern: (X86fmin:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 51461 // Emits: (MINPDrr:v2f64 VR128:v2f64:$src1, VR128:v2f64:$src2) 51462 // Pattern complexity = 3 cost = 1 size = 3 51463 if ((Subtarget->hasSSE2())) { 51464 SDNode *Result = Emit_15(N, X86::MINPDrr, MVT::v2f64); 51465 return Result; 51466 } 51467 51468 CannotYetSelect(N); 51469 return NULL; 51470 } 51471 51472 SDNode *Emit_291(const SDValue &N, unsigned Opc0, SDValue &CPTmpN1_0, SDValue &CPTmpN1_1, SDValue &CPTmpN1_2, SDValue &CPTmpN1_3, SDValue &CPTmpN1_4) DISABLE_INLINE { 51473 SDValue Chain = N.getOperand(0); 51474 SDValue N1 = N.getOperand(1); 51475 SDValue Ops0[] = { CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, Chain }; 51476 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 6); 51477 } 51478 SDNode *Select_X86ISD_FNSTCW16m(const SDValue &N) { 51479 SDValue Chain = N.getOperand(0); 51480 SDValue N1 = N.getOperand(1); 51481 SDValue CPTmpN1_0; 51482 SDValue CPTmpN1_1; 51483 SDValue CPTmpN1_2; 51484 SDValue CPTmpN1_3; 51485 SDValue CPTmpN1_4; 51486 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 51487 SDNode *Result = Emit_291(N, X86::FNSTCW16m, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 51488 return Result; 51489 } 51490 51491 CannotYetSelect(N); 51492 return NULL; 51493 } 51494 51495 SDNode *Select_X86ISD_FOR_f32(const SDValue &N) { 51496 if (OptLevel != CodeGenOpt::None && 51497 (Subtarget->hasSSE1())) { 51498 SDValue N0 = N.getOperand(0); 51499 51500 // Pattern: (X86for:f32 FR32:f32:$src1, (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 51501 // Emits: (FsORPSrm:f32 FR32:f32:$src1, addr:iPTR:$src2) 51502 // Pattern complexity = 25 cost = 1 size = 3 51503 { 51504 SDValue N1 = N.getOperand(1); 51505 if (N1.getOpcode() == ISD::LOAD && 51506 N1.hasOneUse() && 51507 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 51508 SDValue Chain1 = N1.getOperand(0); 51509 if (Predicate_unindexedload(N1.getNode()) && 51510 Predicate_load(N1.getNode()) && 51511 Predicate_memop(N1.getNode())) { 51512 SDValue N11 = N1.getOperand(1); 51513 SDValue CPTmpN11_0; 51514 SDValue CPTmpN11_1; 51515 SDValue CPTmpN11_2; 51516 SDValue CPTmpN11_3; 51517 SDValue CPTmpN11_4; 51518 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 51519 SDNode *Result = Emit_18(N, X86::FsORPSrm, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 51520 return Result; 51521 } 51522 } 51523 } 51524 } 51525 51526 // Pattern: (X86for:f32 (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, FR32:f32:$src1) 51527 // Emits: (FsORPSrm:f32 FR32:f32:$src1, addr:iPTR:$src2) 51528 // Pattern complexity = 25 cost = 1 size = 3 51529 if (N0.getOpcode() == ISD::LOAD && 51530 N0.hasOneUse() && 51531 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 51532 SDValue Chain0 = N0.getOperand(0); 51533 if (Predicate_unindexedload(N0.getNode()) && 51534 Predicate_load(N0.getNode()) && 51535 Predicate_memop(N0.getNode())) { 51536 SDValue N01 = N0.getOperand(1); 51537 SDValue CPTmpN01_0; 51538 SDValue CPTmpN01_1; 51539 SDValue CPTmpN01_2; 51540 SDValue CPTmpN01_3; 51541 SDValue CPTmpN01_4; 51542 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 51543 SDNode *Result = Emit_19(N, X86::FsORPSrm, MVT::f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 51544 return Result; 51545 } 51546 } 51547 } 51548 } 51549 51550 // Pattern: (X86for:f32 FR32:f32:$src1, FR32:f32:$src2) 51551 // Emits: (FsORPSrr:f32 FR32:f32:$src1, FR32:f32:$src2) 51552 // Pattern complexity = 3 cost = 1 size = 3 51553 if ((Subtarget->hasSSE1())) { 51554 SDNode *Result = Emit_15(N, X86::FsORPSrr, MVT::f32); 51555 return Result; 51556 } 51557 51558 CannotYetSelect(N); 51559 return NULL; 51560 } 51561 51562 SDNode *Select_X86ISD_FOR_f64(const SDValue &N) { 51563 if (OptLevel != CodeGenOpt::None && 51564 (Subtarget->hasSSE2())) { 51565 SDValue N0 = N.getOperand(0); 51566 51567 // Pattern: (X86for:f64 FR64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 51568 // Emits: (FsORPDrm:f64 FR64:f64:$src1, addr:iPTR:$src2) 51569 // Pattern complexity = 25 cost = 1 size = 3 51570 { 51571 SDValue N1 = N.getOperand(1); 51572 if (N1.getOpcode() == ISD::LOAD && 51573 N1.hasOneUse() && 51574 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 51575 SDValue Chain1 = N1.getOperand(0); 51576 if (Predicate_unindexedload(N1.getNode()) && 51577 Predicate_load(N1.getNode()) && 51578 Predicate_memop(N1.getNode())) { 51579 SDValue N11 = N1.getOperand(1); 51580 SDValue CPTmpN11_0; 51581 SDValue CPTmpN11_1; 51582 SDValue CPTmpN11_2; 51583 SDValue CPTmpN11_3; 51584 SDValue CPTmpN11_4; 51585 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 51586 SDNode *Result = Emit_18(N, X86::FsORPDrm, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 51587 return Result; 51588 } 51589 } 51590 } 51591 } 51592 51593 // Pattern: (X86for:f64 (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, FR64:f64:$src1) 51594 // Emits: (FsORPDrm:f64 FR64:f64:$src1, addr:iPTR:$src2) 51595 // Pattern complexity = 25 cost = 1 size = 3 51596 if (N0.getOpcode() == ISD::LOAD && 51597 N0.hasOneUse() && 51598 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 51599 SDValue Chain0 = N0.getOperand(0); 51600 if (Predicate_unindexedload(N0.getNode()) && 51601 Predicate_load(N0.getNode()) && 51602 Predicate_memop(N0.getNode())) { 51603 SDValue N01 = N0.getOperand(1); 51604 SDValue CPTmpN01_0; 51605 SDValue CPTmpN01_1; 51606 SDValue CPTmpN01_2; 51607 SDValue CPTmpN01_3; 51608 SDValue CPTmpN01_4; 51609 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 51610 SDNode *Result = Emit_19(N, X86::FsORPDrm, MVT::f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 51611 return Result; 51612 } 51613 } 51614 } 51615 } 51616 51617 // Pattern: (X86for:f64 FR64:f64:$src1, FR64:f64:$src2) 51618 // Emits: (FsORPDrr:f64 FR64:f64:$src1, FR64:f64:$src2) 51619 // Pattern complexity = 3 cost = 1 size = 3 51620 if ((Subtarget->hasSSE2())) { 51621 SDNode *Result = Emit_15(N, X86::FsORPDrr, MVT::f64); 51622 return Result; 51623 } 51624 51625 CannotYetSelect(N); 51626 return NULL; 51627 } 51628 51629 SDNode *Emit_292(const SDValue &N, unsigned Opc0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 51630 SDValue Chain = N.getOperand(0); 51631 SDValue N1 = N.getOperand(1); 51632 SDValue N2 = N.getOperand(2); 51633 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, N1, Chain }; 51634 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 7); 51635 } 51636 SDNode *Select_X86ISD_FP_TO_INT16_IN_MEM(const SDValue &N) { 51637 if ((Subtarget->hasSSE3())) { 51638 SDValue Chain = N.getOperand(0); 51639 SDValue N1 = N.getOperand(1); 51640 SDValue N2 = N.getOperand(2); 51641 SDValue CPTmpN2_0; 51642 SDValue CPTmpN2_1; 51643 SDValue CPTmpN2_2; 51644 SDValue CPTmpN2_3; 51645 SDValue CPTmpN2_4; 51646 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 51647 51648 // Pattern: (X86fp_to_i16mem:isVoid RFP32:f32:$src, addr:iPTR:$op) 51649 // Emits: (ISTT_Fp16m32:isVoid addr:iPTR:$op, RFP32:f32:$src) 51650 // Pattern complexity = 21 cost = 1 size = 0 51651 if (N1.getNode()->getValueType(0) == MVT::f32) { 51652 SDNode *Result = Emit_292(N, X86::ISTT_Fp16m32, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 51653 return Result; 51654 } 51655 51656 // Pattern: (X86fp_to_i16mem:isVoid RFP64:f64:$src, addr:iPTR:$op) 51657 // Emits: (ISTT_Fp16m64:isVoid addr:iPTR:$op, RFP64:f64:$src) 51658 // Pattern complexity = 21 cost = 1 size = 0 51659 if (N1.getNode()->getValueType(0) == MVT::f64) { 51660 SDNode *Result = Emit_292(N, X86::ISTT_Fp16m64, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 51661 return Result; 51662 } 51663 51664 // Pattern: (X86fp_to_i16mem:isVoid RFP80:f80:$src, addr:iPTR:$op) 51665 // Emits: (ISTT_Fp16m80:isVoid addr:iPTR:$op, RFP80:f80:$src) 51666 // Pattern complexity = 21 cost = 1 size = 0 51667 if (N1.getNode()->getValueType(0) == MVT::f80) { 51668 SDNode *Result = Emit_292(N, X86::ISTT_Fp16m80, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 51669 return Result; 51670 } 51671 } 51672 } 51673 SDValue Chain = N.getOperand(0); 51674 SDValue N1 = N.getOperand(1); 51675 SDValue N2 = N.getOperand(2); 51676 SDValue CPTmpN2_0; 51677 SDValue CPTmpN2_1; 51678 SDValue CPTmpN2_2; 51679 SDValue CPTmpN2_3; 51680 SDValue CPTmpN2_4; 51681 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 51682 51683 // Pattern: (X86fp_to_i16mem:isVoid RFP32:f32:$src, addr:iPTR:$dst) 51684 // Emits: (FP32_TO_INT16_IN_MEM:isVoid addr:iPTR:$dst, RFP32:f32:$src) 51685 // Pattern complexity = 21 cost = 11 size = 3 51686 if (N1.getNode()->getValueType(0) == MVT::f32) { 51687 SDNode *Result = Emit_292(N, X86::FP32_TO_INT16_IN_MEM, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 51688 return Result; 51689 } 51690 51691 // Pattern: (X86fp_to_i16mem:isVoid RFP64:f64:$src, addr:iPTR:$dst) 51692 // Emits: (FP64_TO_INT16_IN_MEM:isVoid addr:iPTR:$dst, RFP64:f64:$src) 51693 // Pattern complexity = 21 cost = 11 size = 3 51694 if (N1.getNode()->getValueType(0) == MVT::f64) { 51695 SDNode *Result = Emit_292(N, X86::FP64_TO_INT16_IN_MEM, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 51696 return Result; 51697 } 51698 51699 // Pattern: (X86fp_to_i16mem:isVoid RFP80:f80:$src, addr:iPTR:$dst) 51700 // Emits: (FP80_TO_INT16_IN_MEM:isVoid addr:iPTR:$dst, RFP80:f80:$src) 51701 // Pattern complexity = 21 cost = 11 size = 3 51702 if (N1.getNode()->getValueType(0) == MVT::f80) { 51703 SDNode *Result = Emit_292(N, X86::FP80_TO_INT16_IN_MEM, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 51704 return Result; 51705 } 51706 } 51707 51708 CannotYetSelect(N); 51709 return NULL; 51710 } 51711 51712 SDNode *Select_X86ISD_FP_TO_INT32_IN_MEM(const SDValue &N) { 51713 if ((Subtarget->hasSSE3())) { 51714 SDValue Chain = N.getOperand(0); 51715 SDValue N1 = N.getOperand(1); 51716 SDValue N2 = N.getOperand(2); 51717 SDValue CPTmpN2_0; 51718 SDValue CPTmpN2_1; 51719 SDValue CPTmpN2_2; 51720 SDValue CPTmpN2_3; 51721 SDValue CPTmpN2_4; 51722 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 51723 51724 // Pattern: (X86fp_to_i32mem:isVoid RFP32:f32:$src, addr:iPTR:$op) 51725 // Emits: (ISTT_Fp32m32:isVoid addr:iPTR:$op, RFP32:f32:$src) 51726 // Pattern complexity = 21 cost = 1 size = 0 51727 if (N1.getNode()->getValueType(0) == MVT::f32) { 51728 SDNode *Result = Emit_292(N, X86::ISTT_Fp32m32, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 51729 return Result; 51730 } 51731 51732 // Pattern: (X86fp_to_i32mem:isVoid RFP64:f64:$src, addr:iPTR:$op) 51733 // Emits: (ISTT_Fp32m64:isVoid addr:iPTR:$op, RFP64:f64:$src) 51734 // Pattern complexity = 21 cost = 1 size = 0 51735 if (N1.getNode()->getValueType(0) == MVT::f64) { 51736 SDNode *Result = Emit_292(N, X86::ISTT_Fp32m64, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 51737 return Result; 51738 } 51739 51740 // Pattern: (X86fp_to_i32mem:isVoid RFP80:f80:$src, addr:iPTR:$op) 51741 // Emits: (ISTT_Fp32m80:isVoid addr:iPTR:$op, RFP80:f80:$src) 51742 // Pattern complexity = 21 cost = 1 size = 0 51743 if (N1.getNode()->getValueType(0) == MVT::f80) { 51744 SDNode *Result = Emit_292(N, X86::ISTT_Fp32m80, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 51745 return Result; 51746 } 51747 } 51748 } 51749 SDValue Chain = N.getOperand(0); 51750 SDValue N1 = N.getOperand(1); 51751 SDValue N2 = N.getOperand(2); 51752 SDValue CPTmpN2_0; 51753 SDValue CPTmpN2_1; 51754 SDValue CPTmpN2_2; 51755 SDValue CPTmpN2_3; 51756 SDValue CPTmpN2_4; 51757 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 51758 51759 // Pattern: (X86fp_to_i32mem:isVoid RFP32:f32:$src, addr:iPTR:$dst) 51760 // Emits: (FP32_TO_INT32_IN_MEM:isVoid addr:iPTR:$dst, RFP32:f32:$src) 51761 // Pattern complexity = 21 cost = 11 size = 3 51762 if (N1.getNode()->getValueType(0) == MVT::f32) { 51763 SDNode *Result = Emit_292(N, X86::FP32_TO_INT32_IN_MEM, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 51764 return Result; 51765 } 51766 51767 // Pattern: (X86fp_to_i32mem:isVoid RFP64:f64:$src, addr:iPTR:$dst) 51768 // Emits: (FP64_TO_INT32_IN_MEM:isVoid addr:iPTR:$dst, RFP64:f64:$src) 51769 // Pattern complexity = 21 cost = 11 size = 3 51770 if (N1.getNode()->getValueType(0) == MVT::f64) { 51771 SDNode *Result = Emit_292(N, X86::FP64_TO_INT32_IN_MEM, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 51772 return Result; 51773 } 51774 51775 // Pattern: (X86fp_to_i32mem:isVoid RFP80:f80:$src, addr:iPTR:$dst) 51776 // Emits: (FP80_TO_INT32_IN_MEM:isVoid addr:iPTR:$dst, RFP80:f80:$src) 51777 // Pattern complexity = 21 cost = 11 size = 3 51778 if (N1.getNode()->getValueType(0) == MVT::f80) { 51779 SDNode *Result = Emit_292(N, X86::FP80_TO_INT32_IN_MEM, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 51780 return Result; 51781 } 51782 } 51783 51784 CannotYetSelect(N); 51785 return NULL; 51786 } 51787 51788 SDNode *Select_X86ISD_FP_TO_INT64_IN_MEM(const SDValue &N) { 51789 if ((Subtarget->hasSSE3())) { 51790 SDValue Chain = N.getOperand(0); 51791 SDValue N1 = N.getOperand(1); 51792 SDValue N2 = N.getOperand(2); 51793 SDValue CPTmpN2_0; 51794 SDValue CPTmpN2_1; 51795 SDValue CPTmpN2_2; 51796 SDValue CPTmpN2_3; 51797 SDValue CPTmpN2_4; 51798 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 51799 51800 // Pattern: (X86fp_to_i64mem:isVoid RFP32:f32:$src, addr:iPTR:$op) 51801 // Emits: (ISTT_Fp64m32:isVoid addr:iPTR:$op, RFP32:f32:$src) 51802 // Pattern complexity = 21 cost = 1 size = 0 51803 if (N1.getNode()->getValueType(0) == MVT::f32) { 51804 SDNode *Result = Emit_292(N, X86::ISTT_Fp64m32, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 51805 return Result; 51806 } 51807 51808 // Pattern: (X86fp_to_i64mem:isVoid RFP64:f64:$src, addr:iPTR:$op) 51809 // Emits: (ISTT_Fp64m64:isVoid addr:iPTR:$op, RFP64:f64:$src) 51810 // Pattern complexity = 21 cost = 1 size = 0 51811 if (N1.getNode()->getValueType(0) == MVT::f64) { 51812 SDNode *Result = Emit_292(N, X86::ISTT_Fp64m64, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 51813 return Result; 51814 } 51815 51816 // Pattern: (X86fp_to_i64mem:isVoid RFP80:f80:$src, addr:iPTR:$op) 51817 // Emits: (ISTT_Fp64m80:isVoid addr:iPTR:$op, RFP80:f80:$src) 51818 // Pattern complexity = 21 cost = 1 size = 0 51819 if (N1.getNode()->getValueType(0) == MVT::f80) { 51820 SDNode *Result = Emit_292(N, X86::ISTT_Fp64m80, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 51821 return Result; 51822 } 51823 } 51824 } 51825 SDValue Chain = N.getOperand(0); 51826 SDValue N1 = N.getOperand(1); 51827 SDValue N2 = N.getOperand(2); 51828 SDValue CPTmpN2_0; 51829 SDValue CPTmpN2_1; 51830 SDValue CPTmpN2_2; 51831 SDValue CPTmpN2_3; 51832 SDValue CPTmpN2_4; 51833 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 51834 51835 // Pattern: (X86fp_to_i64mem:isVoid RFP32:f32:$src, addr:iPTR:$dst) 51836 // Emits: (FP32_TO_INT64_IN_MEM:isVoid addr:iPTR:$dst, RFP32:f32:$src) 51837 // Pattern complexity = 21 cost = 11 size = 3 51838 if (N1.getNode()->getValueType(0) == MVT::f32) { 51839 SDNode *Result = Emit_292(N, X86::FP32_TO_INT64_IN_MEM, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 51840 return Result; 51841 } 51842 51843 // Pattern: (X86fp_to_i64mem:isVoid RFP64:f64:$src, addr:iPTR:$dst) 51844 // Emits: (FP64_TO_INT64_IN_MEM:isVoid addr:iPTR:$dst, RFP64:f64:$src) 51845 // Pattern complexity = 21 cost = 11 size = 3 51846 if (N1.getNode()->getValueType(0) == MVT::f64) { 51847 SDNode *Result = Emit_292(N, X86::FP64_TO_INT64_IN_MEM, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 51848 return Result; 51849 } 51850 51851 // Pattern: (X86fp_to_i64mem:isVoid RFP80:f80:$src, addr:iPTR:$dst) 51852 // Emits: (FP80_TO_INT64_IN_MEM:isVoid addr:iPTR:$dst, RFP80:f80:$src) 51853 // Pattern complexity = 21 cost = 11 size = 3 51854 if (N1.getNode()->getValueType(0) == MVT::f80) { 51855 SDNode *Result = Emit_292(N, X86::FP80_TO_INT64_IN_MEM, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 51856 return Result; 51857 } 51858 } 51859 51860 CannotYetSelect(N); 51861 return NULL; 51862 } 51863 51864 SDNode *Select_X86ISD_FRCP_f32(const SDValue &N) { 51865 51866 // Pattern: (X86frcp:f32 (ld:f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 51867 // Emits: (RCPSSm:f32 addr:iPTR:$src) 51868 // Pattern complexity = 25 cost = 1 size = 3 51869 if (OptLevel != CodeGenOpt::None && 51870 (Subtarget->hasSSE1())) { 51871 SDValue N0 = N.getOperand(0); 51872 if (N0.getOpcode() == ISD::LOAD && 51873 N0.hasOneUse()) { 51874 SDValue Chain0 = N0.getOperand(0); 51875 if (Predicate_unindexedload(N0.getNode()) && 51876 Predicate_load(N0.getNode())) { 51877 SDValue N01 = N0.getOperand(1); 51878 SDValue CPTmpN01_0; 51879 SDValue CPTmpN01_1; 51880 SDValue CPTmpN01_2; 51881 SDValue CPTmpN01_3; 51882 SDValue CPTmpN01_4; 51883 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 51884 SDNode *Result = Emit_76(N, X86::RCPSSm, MVT::f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 51885 return Result; 51886 } 51887 } 51888 } 51889 } 51890 51891 // Pattern: (X86frcp:f32 FR32:f32:$src) 51892 // Emits: (RCPSSr:f32 FR32:f32:$src) 51893 // Pattern complexity = 3 cost = 1 size = 3 51894 if ((Subtarget->hasSSE1())) { 51895 SDNode *Result = Emit_71(N, X86::RCPSSr, MVT::f32); 51896 return Result; 51897 } 51898 51899 CannotYetSelect(N); 51900 return NULL; 51901 } 51902 51903 SDNode *Select_X86ISD_FRCP_v4f32(const SDValue &N) { 51904 51905 // Pattern: (X86frcp:v4f32 (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 51906 // Emits: (RCPPSm:v4f32 addr:iPTR:$src) 51907 // Pattern complexity = 25 cost = 1 size = 3 51908 if (OptLevel != CodeGenOpt::None && 51909 (Subtarget->hasSSE1())) { 51910 SDValue N0 = N.getOperand(0); 51911 if (N0.getOpcode() == ISD::LOAD && 51912 N0.hasOneUse()) { 51913 SDValue Chain0 = N0.getOperand(0); 51914 if (Predicate_unindexedload(N0.getNode()) && 51915 Predicate_load(N0.getNode()) && 51916 Predicate_memop(N0.getNode())) { 51917 SDValue N01 = N0.getOperand(1); 51918 SDValue CPTmpN01_0; 51919 SDValue CPTmpN01_1; 51920 SDValue CPTmpN01_2; 51921 SDValue CPTmpN01_3; 51922 SDValue CPTmpN01_4; 51923 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 51924 SDNode *Result = Emit_76(N, X86::RCPPSm, MVT::v4f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 51925 return Result; 51926 } 51927 } 51928 } 51929 } 51930 51931 // Pattern: (X86frcp:v4f32 VR128:v4f32:$src) 51932 // Emits: (RCPPSr:v4f32 VR128:v4f32:$src) 51933 // Pattern complexity = 3 cost = 1 size = 3 51934 if ((Subtarget->hasSSE1())) { 51935 SDNode *Result = Emit_71(N, X86::RCPPSr, MVT::v4f32); 51936 return Result; 51937 } 51938 51939 CannotYetSelect(N); 51940 return NULL; 51941 } 51942 51943 SDNode *Select_X86ISD_FRSQRT_f32(const SDValue &N) { 51944 51945 // Pattern: (X86frsqrt:f32 (ld:f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 51946 // Emits: (RSQRTSSm:f32 addr:iPTR:$src) 51947 // Pattern complexity = 25 cost = 1 size = 3 51948 if (OptLevel != CodeGenOpt::None && 51949 (Subtarget->hasSSE1())) { 51950 SDValue N0 = N.getOperand(0); 51951 if (N0.getOpcode() == ISD::LOAD && 51952 N0.hasOneUse()) { 51953 SDValue Chain0 = N0.getOperand(0); 51954 if (Predicate_unindexedload(N0.getNode()) && 51955 Predicate_load(N0.getNode())) { 51956 SDValue N01 = N0.getOperand(1); 51957 SDValue CPTmpN01_0; 51958 SDValue CPTmpN01_1; 51959 SDValue CPTmpN01_2; 51960 SDValue CPTmpN01_3; 51961 SDValue CPTmpN01_4; 51962 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 51963 SDNode *Result = Emit_76(N, X86::RSQRTSSm, MVT::f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 51964 return Result; 51965 } 51966 } 51967 } 51968 } 51969 51970 // Pattern: (X86frsqrt:f32 FR32:f32:$src) 51971 // Emits: (RSQRTSSr:f32 FR32:f32:$src) 51972 // Pattern complexity = 3 cost = 1 size = 3 51973 if ((Subtarget->hasSSE1())) { 51974 SDNode *Result = Emit_71(N, X86::RSQRTSSr, MVT::f32); 51975 return Result; 51976 } 51977 51978 CannotYetSelect(N); 51979 return NULL; 51980 } 51981 51982 SDNode *Select_X86ISD_FRSQRT_v4f32(const SDValue &N) { 51983 51984 // Pattern: (X86frsqrt:v4f32 (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 51985 // Emits: (RSQRTPSm:v4f32 addr:iPTR:$src) 51986 // Pattern complexity = 25 cost = 1 size = 3 51987 if (OptLevel != CodeGenOpt::None && 51988 (Subtarget->hasSSE1())) { 51989 SDValue N0 = N.getOperand(0); 51990 if (N0.getOpcode() == ISD::LOAD && 51991 N0.hasOneUse()) { 51992 SDValue Chain0 = N0.getOperand(0); 51993 if (Predicate_unindexedload(N0.getNode()) && 51994 Predicate_load(N0.getNode()) && 51995 Predicate_memop(N0.getNode())) { 51996 SDValue N01 = N0.getOperand(1); 51997 SDValue CPTmpN01_0; 51998 SDValue CPTmpN01_1; 51999 SDValue CPTmpN01_2; 52000 SDValue CPTmpN01_3; 52001 SDValue CPTmpN01_4; 52002 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 52003 SDNode *Result = Emit_76(N, X86::RSQRTPSm, MVT::v4f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 52004 return Result; 52005 } 52006 } 52007 } 52008 } 52009 52010 // Pattern: (X86frsqrt:v4f32 VR128:v4f32:$src) 52011 // Emits: (RSQRTPSr:v4f32 VR128:v4f32:$src) 52012 // Pattern complexity = 3 cost = 1 size = 3 52013 if ((Subtarget->hasSSE1())) { 52014 SDNode *Result = Emit_71(N, X86::RSQRTPSr, MVT::v4f32); 52015 return Result; 52016 } 52017 52018 CannotYetSelect(N); 52019 return NULL; 52020 } 52021 52022 SDNode *Emit_293(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 52023 SDValue N0 = N.getOperand(0); 52024 SDValue N1 = N.getOperand(1); 52025 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i32); 52026 SDValue Tmp2 = Transform_PSxLDQ_imm(Tmp1.getNode()); 52027 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, Tmp2); 52028 } 52029 SDNode *Select_X86ISD_FSRL_v2f64(const SDValue &N) { 52030 if ((Subtarget->hasSSE2())) { 52031 SDValue N0 = N.getOperand(0); 52032 SDValue N1 = N.getOperand(1); 52033 if (N1.getOpcode() == ISD::Constant && 52034 Predicate_i32immSExt8(N1.getNode()) && 52035 N1.getNode()->getValueType(0) == MVT::i32) { 52036 SDNode *Result = Emit_293(N, X86::PSRLDQri, MVT::v2f64); 52037 return Result; 52038 } 52039 } 52040 52041 CannotYetSelect(N); 52042 return NULL; 52043 } 52044 52045 SDNode *Emit_294(const SDValue &N, unsigned Opc0, SDValue &CPTmpN2_0, SDValue &CPTmpN2_1, SDValue &CPTmpN2_2, SDValue &CPTmpN2_3, SDValue &CPTmpN2_4) DISABLE_INLINE { 52046 SDValue Chain = N.getOperand(0); 52047 SDValue N1 = N.getOperand(1); 52048 SDValue N2 = N.getOperand(2); 52049 SDValue N3 = N.getOperand(3); 52050 SDValue InFlag = N.getOperand(4); 52051 SDValue Ops0[] = { CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4, N1, Chain, InFlag }; 52052 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, Ops0, 8); 52053 } 52054 SDNode *Select_X86ISD_FST(const SDValue &N) { 52055 SDValue Chain = N.getOperand(0); 52056 SDValue N1 = N.getOperand(1); 52057 SDValue N2 = N.getOperand(2); 52058 SDValue CPTmpN2_0; 52059 SDValue CPTmpN2_1; 52060 SDValue CPTmpN2_2; 52061 SDValue CPTmpN2_3; 52062 SDValue CPTmpN2_4; 52063 if (SelectAddr(N, N2, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4)) { 52064 SDValue N3 = N.getOperand(3); 52065 if (cast<VTSDNode>(N3)->getVT() == MVT::f32) { 52066 52067 // Pattern: (X86fst:isVoid RFP32:f32:$src, addr:iPTR:$op, f32:Other) 52068 // Emits: (ST_Fp32m:isVoid addr:iPTR:$op, RFP32:f32:$src) 52069 // Pattern complexity = 21 cost = 1 size = 0 52070 if (N1.getNode()->getValueType(0) == MVT::f32) { 52071 SDNode *Result = Emit_294(N, X86::ST_Fp32m, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 52072 return Result; 52073 } 52074 52075 // Pattern: (X86fst:isVoid RFP64:f64:$src, addr:iPTR:$op, f32:Other) 52076 // Emits: (ST_Fp64m32:isVoid addr:iPTR:$op, RFP64:f64:$src) 52077 // Pattern complexity = 21 cost = 1 size = 0 52078 if (N1.getNode()->getValueType(0) == MVT::f64) { 52079 SDNode *Result = Emit_294(N, X86::ST_Fp64m32, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 52080 return Result; 52081 } 52082 } 52083 52084 // Pattern: (X86fst:isVoid RFP64:f64:$src, addr:iPTR:$op, f64:Other) 52085 // Emits: (ST_Fp64m:isVoid addr:iPTR:$op, RFP64:f64:$src) 52086 // Pattern complexity = 21 cost = 1 size = 0 52087 if (cast<VTSDNode>(N3)->getVT() == MVT::f64 && 52088 N1.getNode()->getValueType(0) == MVT::f64) { 52089 SDNode *Result = Emit_294(N, X86::ST_Fp64m, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 52090 return Result; 52091 } 52092 52093 // Pattern: (X86fst:isVoid RFP80:f80:$src, addr:iPTR:$op, f32:Other) 52094 // Emits: (ST_Fp80m32:isVoid addr:iPTR:$op, RFP80:f80:$src) 52095 // Pattern complexity = 21 cost = 1 size = 0 52096 if (cast<VTSDNode>(N3)->getVT() == MVT::f32 && 52097 N1.getNode()->getValueType(0) == MVT::f80) { 52098 SDNode *Result = Emit_294(N, X86::ST_Fp80m32, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 52099 return Result; 52100 } 52101 52102 // Pattern: (X86fst:isVoid RFP80:f80:$src, addr:iPTR:$op, f64:Other) 52103 // Emits: (ST_Fp80m64:isVoid addr:iPTR:$op, RFP80:f80:$src) 52104 // Pattern complexity = 21 cost = 1 size = 0 52105 if (cast<VTSDNode>(N3)->getVT() == MVT::f64 && 52106 N1.getNode()->getValueType(0) == MVT::f80) { 52107 SDNode *Result = Emit_294(N, X86::ST_Fp80m64, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 52108 return Result; 52109 } 52110 52111 // Pattern: (X86fst:isVoid RFP80:f80:$src, addr:iPTR:$op, f80:Other) 52112 // Emits: (ST_FpP80m:isVoid addr:iPTR:$op, RFP80:f80:$src) 52113 // Pattern complexity = 21 cost = 1 size = 0 52114 if (cast<VTSDNode>(N3)->getVT() == MVT::f80 && 52115 N1.getNode()->getValueType(0) == MVT::f80) { 52116 SDNode *Result = Emit_294(N, X86::ST_FpP80m, CPTmpN2_0, CPTmpN2_1, CPTmpN2_2, CPTmpN2_3, CPTmpN2_4); 52117 return Result; 52118 } 52119 } 52120 52121 CannotYetSelect(N); 52122 return NULL; 52123 } 52124 52125 SDNode *Select_X86ISD_FXOR_f32(const SDValue &N) { 52126 if (OptLevel != CodeGenOpt::None && 52127 (Subtarget->hasSSE1())) { 52128 SDValue N0 = N.getOperand(0); 52129 52130 // Pattern: (X86fxor:f32 FR32:f32:$src1, (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 52131 // Emits: (FsXORPSrm:f32 FR32:f32:$src1, addr:iPTR:$src2) 52132 // Pattern complexity = 25 cost = 1 size = 3 52133 { 52134 SDValue N1 = N.getOperand(1); 52135 if (N1.getOpcode() == ISD::LOAD && 52136 N1.hasOneUse() && 52137 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 52138 SDValue Chain1 = N1.getOperand(0); 52139 if (Predicate_unindexedload(N1.getNode()) && 52140 Predicate_load(N1.getNode()) && 52141 Predicate_memop(N1.getNode())) { 52142 SDValue N11 = N1.getOperand(1); 52143 SDValue CPTmpN11_0; 52144 SDValue CPTmpN11_1; 52145 SDValue CPTmpN11_2; 52146 SDValue CPTmpN11_3; 52147 SDValue CPTmpN11_4; 52148 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 52149 SDNode *Result = Emit_18(N, X86::FsXORPSrm, MVT::f32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 52150 return Result; 52151 } 52152 } 52153 } 52154 } 52155 52156 // Pattern: (X86fxor:f32 (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, FR32:f32:$src1) 52157 // Emits: (FsXORPSrm:f32 FR32:f32:$src1, addr:iPTR:$src2) 52158 // Pattern complexity = 25 cost = 1 size = 3 52159 if (N0.getOpcode() == ISD::LOAD && 52160 N0.hasOneUse() && 52161 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 52162 SDValue Chain0 = N0.getOperand(0); 52163 if (Predicate_unindexedload(N0.getNode()) && 52164 Predicate_load(N0.getNode()) && 52165 Predicate_memop(N0.getNode())) { 52166 SDValue N01 = N0.getOperand(1); 52167 SDValue CPTmpN01_0; 52168 SDValue CPTmpN01_1; 52169 SDValue CPTmpN01_2; 52170 SDValue CPTmpN01_3; 52171 SDValue CPTmpN01_4; 52172 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 52173 SDNode *Result = Emit_19(N, X86::FsXORPSrm, MVT::f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 52174 return Result; 52175 } 52176 } 52177 } 52178 } 52179 52180 // Pattern: (X86fxor:f32 FR32:f32:$src1, FR32:f32:$src2) 52181 // Emits: (FsXORPSrr:f32 FR32:f32:$src1, FR32:f32:$src2) 52182 // Pattern complexity = 3 cost = 1 size = 3 52183 if ((Subtarget->hasSSE1())) { 52184 SDNode *Result = Emit_15(N, X86::FsXORPSrr, MVT::f32); 52185 return Result; 52186 } 52187 52188 CannotYetSelect(N); 52189 return NULL; 52190 } 52191 52192 SDNode *Select_X86ISD_FXOR_f64(const SDValue &N) { 52193 if (OptLevel != CodeGenOpt::None && 52194 (Subtarget->hasSSE2())) { 52195 SDValue N0 = N.getOperand(0); 52196 52197 // Pattern: (X86fxor:f64 FR64:f64:$src1, (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 52198 // Emits: (FsXORPDrm:f64 FR64:f64:$src1, addr:iPTR:$src2) 52199 // Pattern complexity = 25 cost = 1 size = 3 52200 { 52201 SDValue N1 = N.getOperand(1); 52202 if (N1.getOpcode() == ISD::LOAD && 52203 N1.hasOneUse() && 52204 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 52205 SDValue Chain1 = N1.getOperand(0); 52206 if (Predicate_unindexedload(N1.getNode()) && 52207 Predicate_load(N1.getNode()) && 52208 Predicate_memop(N1.getNode())) { 52209 SDValue N11 = N1.getOperand(1); 52210 SDValue CPTmpN11_0; 52211 SDValue CPTmpN11_1; 52212 SDValue CPTmpN11_2; 52213 SDValue CPTmpN11_3; 52214 SDValue CPTmpN11_4; 52215 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 52216 SDNode *Result = Emit_18(N, X86::FsXORPDrm, MVT::f64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 52217 return Result; 52218 } 52219 } 52220 } 52221 } 52222 52223 // Pattern: (X86fxor:f64 (ld:f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, FR64:f64:$src1) 52224 // Emits: (FsXORPDrm:f64 FR64:f64:$src1, addr:iPTR:$src2) 52225 // Pattern complexity = 25 cost = 1 size = 3 52226 if (N0.getOpcode() == ISD::LOAD && 52227 N0.hasOneUse() && 52228 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 52229 SDValue Chain0 = N0.getOperand(0); 52230 if (Predicate_unindexedload(N0.getNode()) && 52231 Predicate_load(N0.getNode()) && 52232 Predicate_memop(N0.getNode())) { 52233 SDValue N01 = N0.getOperand(1); 52234 SDValue CPTmpN01_0; 52235 SDValue CPTmpN01_1; 52236 SDValue CPTmpN01_2; 52237 SDValue CPTmpN01_3; 52238 SDValue CPTmpN01_4; 52239 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 52240 SDNode *Result = Emit_19(N, X86::FsXORPDrm, MVT::f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 52241 return Result; 52242 } 52243 } 52244 } 52245 } 52246 52247 // Pattern: (X86fxor:f64 FR64:f64:$src1, FR64:f64:$src2) 52248 // Emits: (FsXORPDrr:f64 FR64:f64:$src1, FR64:f64:$src2) 52249 // Pattern complexity = 3 cost = 1 size = 3 52250 if ((Subtarget->hasSSE2())) { 52251 SDNode *Result = Emit_15(N, X86::FsXORPDrr, MVT::f64); 52252 return Result; 52253 } 52254 52255 CannotYetSelect(N); 52256 return NULL; 52257 } 52258 52259 SDNode *Select_X86ISD_INC_i8(const SDValue &N) { 52260 SDValue N0 = N.getOperand(0); 52261 if (N0.getNode()->getValueType(0) == MVT::i8) { 52262 SDNode *Result = Emit_255(N, X86::INC8r, MVT::i8); 52263 return Result; 52264 } 52265 52266 CannotYetSelect(N); 52267 return NULL; 52268 } 52269 52270 SDNode *Select_X86ISD_INC_i16(const SDValue &N) { 52271 52272 // Pattern: (X86inc_flag:i16 GR16:i16:$src) 52273 // Emits: (INC16r:i16 GR16:i16:$src) 52274 // Pattern complexity = 3 cost = 1 size = 1 52275 if ((!Subtarget->is64Bit())) { 52276 SDValue N0 = N.getOperand(0); 52277 if (N0.getNode()->getValueType(0) == MVT::i16) { 52278 SDNode *Result = Emit_255(N, X86::INC16r, MVT::i16); 52279 return Result; 52280 } 52281 } 52282 52283 // Pattern: (X86inc_flag:i16 GR16:i16:$src) 52284 // Emits: (INC64_16r:i16 GR16:i16:$src) 52285 // Pattern complexity = 3 cost = 1 size = 2 52286 if ((Subtarget->is64Bit())) { 52287 SDValue N0 = N.getOperand(0); 52288 if (N0.getNode()->getValueType(0) == MVT::i16) { 52289 SDNode *Result = Emit_255(N, X86::INC64_16r, MVT::i16); 52290 return Result; 52291 } 52292 } 52293 52294 CannotYetSelect(N); 52295 return NULL; 52296 } 52297 52298 SDNode *Select_X86ISD_INC_i32(const SDValue &N) { 52299 52300 // Pattern: (X86inc_flag:i32 GR32:i32:$src) 52301 // Emits: (INC32r:i32 GR32:i32:$src) 52302 // Pattern complexity = 3 cost = 1 size = 1 52303 if ((!Subtarget->is64Bit())) { 52304 SDValue N0 = N.getOperand(0); 52305 if (N0.getNode()->getValueType(0) == MVT::i32) { 52306 SDNode *Result = Emit_255(N, X86::INC32r, MVT::i32); 52307 return Result; 52308 } 52309 } 52310 52311 // Pattern: (X86inc_flag:i32 GR32:i32:$src) 52312 // Emits: (INC64_32r:i32 GR32:i32:$src) 52313 // Pattern complexity = 3 cost = 1 size = 2 52314 if ((Subtarget->is64Bit())) { 52315 SDValue N0 = N.getOperand(0); 52316 if (N0.getNode()->getValueType(0) == MVT::i32) { 52317 SDNode *Result = Emit_255(N, X86::INC64_32r, MVT::i32); 52318 return Result; 52319 } 52320 } 52321 52322 CannotYetSelect(N); 52323 return NULL; 52324 } 52325 52326 SDNode *Select_X86ISD_INC_i64(const SDValue &N) { 52327 SDValue N0 = N.getOperand(0); 52328 if (N0.getNode()->getValueType(0) == MVT::i64) { 52329 SDNode *Result = Emit_255(N, X86::INC64r, MVT::i64); 52330 return Result; 52331 } 52332 52333 CannotYetSelect(N); 52334 return NULL; 52335 } 52336 52337 SDNode *Emit_295(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 52338 SDValue N0 = N.getOperand(0); 52339 SDValue N1 = N.getOperand(1); 52340 SDValue N10 = N1.getOperand(0); 52341 SDValue Chain10 = N10.getOperand(0); 52342 SDValue N101 = N10.getOperand(1); 52343 SDValue N2 = N.getOperand(2); 52344 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N2)->getZExtValue()), MVT::i32); 52345 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 52346 SDValue Ops0[] = { N0, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, Tmp2, LSI_N10, Chain10 }; 52347 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 9); 52348 ReplaceUses(SDValue(N10.getNode(), 1), SDValue(ResNode, 1)); 52349 return ResNode; 52350 } 52351 SDNode *Select_X86ISD_INSERTPS_v4f32(const SDValue &N) { 52352 52353 // Pattern: (X86insrtps:v4f32 VR128:v4f32:$src1, (scalar_to_vector:v4f32 (ld:f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf32>>), (imm:iPTR):$src3) 52354 // Emits: (INSERTPSrm:v4f32 VR128:v4f32:$src1, addr:iPTR:$src2, (imm:i32):$src3) 52355 // Pattern complexity = 31 cost = 1 size = 3 52356 if (OptLevel != CodeGenOpt::None && 52357 (Subtarget->hasSSE41())) { 52358 SDValue N0 = N.getOperand(0); 52359 SDValue N1 = N.getOperand(1); 52360 if (N1.getOpcode() == ISD::SCALAR_TO_VECTOR && 52361 N1.hasOneUse()) { 52362 SDValue N10 = N1.getOperand(0); 52363 if (N10.getOpcode() == ISD::LOAD && 52364 N10.hasOneUse() && 52365 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 52366 SDValue Chain10 = N10.getOperand(0); 52367 if (Predicate_unindexedload(N10.getNode()) && 52368 Predicate_load(N10.getNode()) && 52369 Predicate_loadf32(N10.getNode())) { 52370 SDValue N101 = N10.getOperand(1); 52371 SDValue CPTmpN101_0; 52372 SDValue CPTmpN101_1; 52373 SDValue CPTmpN101_2; 52374 SDValue CPTmpN101_3; 52375 SDValue CPTmpN101_4; 52376 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 52377 SDValue N2 = N.getOperand(2); 52378 if (N2.getOpcode() == ISD::Constant && 52379 N10.getNode()->getValueType(0) == MVT::f32) { 52380 SDNode *Result = Emit_295(N, X86::INSERTPSrm, MVT::v4f32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 52381 return Result; 52382 } 52383 } 52384 } 52385 } 52386 } 52387 } 52388 52389 // Pattern: (X86insrtps:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2, (imm:iPTR):$src3) 52390 // Emits: (INSERTPSrr:v4f32 VR128:v4f32:$src1, VR128:v4f32:$src2, (imm:i32):$src3) 52391 // Pattern complexity = 6 cost = 1 size = 3 52392 if ((Subtarget->hasSSE41())) { 52393 SDValue N0 = N.getOperand(0); 52394 SDValue N1 = N.getOperand(1); 52395 SDValue N2 = N.getOperand(2); 52396 if (N2.getOpcode() == ISD::Constant) { 52397 SDNode *Result = Emit_97(N, X86::INSERTPSrr, MVT::v4f32); 52398 return Result; 52399 } 52400 } 52401 52402 CannotYetSelect(N); 52403 return NULL; 52404 } 52405 52406 SDNode *Emit_296(const SDValue &N, unsigned Opc0, SDValue &CPTmpN1_0, SDValue &CPTmpN1_1, SDValue &CPTmpN1_2, SDValue &CPTmpN1_3, SDValue &CPTmpN1_4) DISABLE_INLINE { 52407 SDValue Chain = N.getOperand(0); 52408 SDValue N1 = N.getOperand(1); 52409 SDValue InFlag = N.getOperand(2); 52410 SDValue Ops0[] = { CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, Chain, InFlag }; 52411 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, MVT::Flag, Ops0, 7); 52412 Chain = SDValue(ResNode, 0); 52413 InFlag = SDValue(ResNode, 1); 52414 const SDValue Froms[] = { 52415 SDValue(N.getNode(), 1), 52416 SDValue(N.getNode(), 0) 52417 }; 52418 const SDValue Tos[] = { 52419 InFlag, 52420 SDValue(Chain.getNode(), Chain.getResNo()) 52421 }; 52422 ReplaceUses(Froms, Tos, 2); 52423 return ResNode; 52424 } 52425 SDNode *Select_X86ISD_LCMPXCHG8_DAG(const SDValue &N) { 52426 SDValue Chain = N.getOperand(0); 52427 SDValue N1 = N.getOperand(1); 52428 SDValue CPTmpN1_0; 52429 SDValue CPTmpN1_1; 52430 SDValue CPTmpN1_2; 52431 SDValue CPTmpN1_3; 52432 SDValue CPTmpN1_4; 52433 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 52434 SDNode *Result = Emit_296(N, X86::LCMPXCHG8B, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 52435 return Result; 52436 } 52437 52438 CannotYetSelect(N); 52439 return NULL; 52440 } 52441 52442 SDNode *Emit_297(const SDValue &N, unsigned Opc0, SDValue &CPTmpN1_0, SDValue &CPTmpN1_1, SDValue &CPTmpN1_2, SDValue &CPTmpN1_3, SDValue &CPTmpN1_4) DISABLE_INLINE { 52443 SDValue Chain = N.getOperand(0); 52444 SDValue N1 = N.getOperand(1); 52445 SDValue N2 = N.getOperand(2); 52446 SDValue N3 = N.getOperand(3); 52447 SDValue InFlag = N.getOperand(4); 52448 SDValue Ops0[] = { CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, N2, Chain, InFlag }; 52449 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, MVT::Flag, Ops0, 8); 52450 Chain = SDValue(ResNode, 0); 52451 InFlag = SDValue(ResNode, 1); 52452 const SDValue Froms[] = { 52453 SDValue(N.getNode(), 1), 52454 SDValue(N.getNode(), 0) 52455 }; 52456 const SDValue Tos[] = { 52457 InFlag, 52458 SDValue(Chain.getNode(), Chain.getResNo()) 52459 }; 52460 ReplaceUses(Froms, Tos, 2); 52461 return ResNode; 52462 } 52463 SDNode *Select_X86ISD_LCMPXCHG_DAG(const SDValue &N) { 52464 SDValue Chain = N.getOperand(0); 52465 SDValue N1 = N.getOperand(1); 52466 SDValue CPTmpN1_0; 52467 SDValue CPTmpN1_1; 52468 SDValue CPTmpN1_2; 52469 SDValue CPTmpN1_3; 52470 SDValue CPTmpN1_4; 52471 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 52472 SDValue N2 = N.getOperand(2); 52473 SDValue N3 = N.getOperand(3); 52474 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N3); 52475 if (Tmp0) { 52476 int64_t CN1 = Tmp0->getSExtValue(); 52477 52478 // Pattern: (X86cas:isVoid addr:iPTR:$ptr, GR32:i32:$swap, 4:i8) 52479 // Emits: (LCMPXCHG32:isVoid addr:iPTR:$ptr, GR32:i32:$swap) 52480 // Pattern complexity = 26 cost = 1 size = 3 52481 if (CN1 == INT64_C(4) && 52482 N2.getNode()->getValueType(0) == MVT::i32) { 52483 SDNode *Result = Emit_297(N, X86::LCMPXCHG32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 52484 return Result; 52485 } 52486 52487 // Pattern: (X86cas:isVoid addr:iPTR:$ptr, GR16:i16:$swap, 2:i8) 52488 // Emits: (LCMPXCHG16:isVoid addr:iPTR:$ptr, GR16:i16:$swap) 52489 // Pattern complexity = 26 cost = 1 size = 3 52490 if (CN1 == INT64_C(2) && 52491 N2.getNode()->getValueType(0) == MVT::i16) { 52492 SDNode *Result = Emit_297(N, X86::LCMPXCHG16, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 52493 return Result; 52494 } 52495 52496 // Pattern: (X86cas:isVoid addr:iPTR:$ptr, GR8:i8:$swap, 1:i8) 52497 // Emits: (LCMPXCHG8:isVoid addr:iPTR:$ptr, GR8:i8:$swap) 52498 // Pattern complexity = 26 cost = 1 size = 3 52499 if (CN1 == INT64_C(1) && 52500 N2.getNode()->getValueType(0) == MVT::i8) { 52501 SDNode *Result = Emit_297(N, X86::LCMPXCHG8, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 52502 return Result; 52503 } 52504 52505 // Pattern: (X86cas:isVoid addr:iPTR:$ptr, GR64:i64:$swap, 8:i8) 52506 // Emits: (LCMPXCHG64:isVoid addr:iPTR:$ptr, GR64:i64:$swap) 52507 // Pattern complexity = 26 cost = 1 size = 3 52508 if (CN1 == INT64_C(8) && 52509 N2.getNode()->getValueType(0) == MVT::i64) { 52510 SDNode *Result = Emit_297(N, X86::LCMPXCHG64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 52511 return Result; 52512 } 52513 } 52514 } 52515 52516 CannotYetSelect(N); 52517 return NULL; 52518 } 52519 52520 SDNode *Select_X86ISD_MUL_IMM_i32(const SDValue &N) { 52521 52522 // Pattern: lea32addr:i32:$src 52523 // Emits: (LEA64_32r:i32 lea32addr:i32:$src) 52524 // Pattern complexity = 15 cost = 1 size = 3 52525 if ((Subtarget->is64Bit())) { 52526 SDValue CPTmpN_0; 52527 SDValue CPTmpN_1; 52528 SDValue CPTmpN_2; 52529 SDValue CPTmpN_3; 52530 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 52531 SDNode *Result = Emit_7(N, X86::LEA64_32r, MVT::i32, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 52532 return Result; 52533 } 52534 } 52535 52536 // Pattern: lea32addr:i32:$src 52537 // Emits: (LEA32r:i32 lea32addr:i32:$src) 52538 // Pattern complexity = 15 cost = 1 size = 3 52539 if ((!Subtarget->is64Bit())) { 52540 SDValue CPTmpN_0; 52541 SDValue CPTmpN_1; 52542 SDValue CPTmpN_2; 52543 SDValue CPTmpN_3; 52544 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 52545 SDNode *Result = Emit_7(N, X86::LEA32r, MVT::i32, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 52546 return Result; 52547 } 52548 } 52549 52550 CannotYetSelect(N); 52551 return NULL; 52552 } 52553 52554 SDNode *Select_X86ISD_MUL_IMM_i64(const SDValue &N) { 52555 SDValue CPTmpN_0; 52556 SDValue CPTmpN_1; 52557 SDValue CPTmpN_2; 52558 SDValue CPTmpN_3; 52559 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 52560 SDNode *Result = Emit_7(N, X86::LEA64r, MVT::i64, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 52561 return Result; 52562 } 52563 52564 CannotYetSelect(N); 52565 return NULL; 52566 } 52567 52568 SDNode *Select_X86ISD_PCMPEQB_v8i8(const SDValue &N) { 52569 if (OptLevel != CodeGenOpt::None) { 52570 SDValue N0 = N.getOperand(0); 52571 52572 // Pattern: (X86pcmpeqb:v8i8 VR64:v8i8:$src1, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 52573 // Emits: (MMX_PCMPEQBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 52574 // Pattern complexity = 28 cost = 1 size = 3 52575 { 52576 SDValue N1 = N.getOperand(1); 52577 if (N1.getOpcode() == ISD::BIT_CONVERT && 52578 N1.hasOneUse()) { 52579 SDValue N10 = N1.getOperand(0); 52580 if (N10.getOpcode() == ISD::LOAD && 52581 N10.hasOneUse() && 52582 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 52583 SDValue Chain10 = N10.getOperand(0); 52584 if (Predicate_unindexedload(N10.getNode()) && 52585 Predicate_load(N10.getNode())) { 52586 SDValue N101 = N10.getOperand(1); 52587 SDValue CPTmpN101_0; 52588 SDValue CPTmpN101_1; 52589 SDValue CPTmpN101_2; 52590 SDValue CPTmpN101_3; 52591 SDValue CPTmpN101_4; 52592 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 52593 N10.getNode()->getValueType(0) == MVT::v1i64) { 52594 SDNode *Result = Emit_16(N, X86::MMX_PCMPEQBrm, MVT::v8i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 52595 return Result; 52596 } 52597 } 52598 } 52599 } 52600 } 52601 52602 // Pattern: (X86pcmpeqb:v8i8 (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v8i8:$src1) 52603 // Emits: (MMX_PCMPEQBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 52604 // Pattern complexity = 28 cost = 1 size = 3 52605 if (N0.getOpcode() == ISD::BIT_CONVERT && 52606 N0.hasOneUse()) { 52607 SDValue N00 = N0.getOperand(0); 52608 if (N00.getOpcode() == ISD::LOAD && 52609 N00.hasOneUse() && 52610 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 52611 SDValue Chain00 = N00.getOperand(0); 52612 if (Predicate_unindexedload(N00.getNode()) && 52613 Predicate_load(N00.getNode())) { 52614 SDValue N001 = N00.getOperand(1); 52615 SDValue CPTmpN001_0; 52616 SDValue CPTmpN001_1; 52617 SDValue CPTmpN001_2; 52618 SDValue CPTmpN001_3; 52619 SDValue CPTmpN001_4; 52620 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 52621 SDValue N1 = N.getOperand(1); 52622 if (N00.getNode()->getValueType(0) == MVT::v1i64) { 52623 SDNode *Result = Emit_17(N, X86::MMX_PCMPEQBrm, MVT::v8i8, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 52624 return Result; 52625 } 52626 } 52627 } 52628 } 52629 } 52630 } 52631 52632 // Pattern: (X86pcmpeqb:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 52633 // Emits: (MMX_PCMPEQBrr:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 52634 // Pattern complexity = 3 cost = 1 size = 3 52635 SDNode *Result = Emit_15(N, X86::MMX_PCMPEQBrr, MVT::v8i8); 52636 return Result; 52637 } 52638 52639 SDNode *Select_X86ISD_PCMPEQB_v16i8(const SDValue &N) { 52640 if (OptLevel != CodeGenOpt::None) { 52641 SDValue N0 = N.getOperand(0); 52642 52643 // Pattern: (X86pcmpeqb:v16i8 VR128:v16i8:$src1, (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 52644 // Emits: (PCMPEQBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 52645 // Pattern complexity = 25 cost = 1 size = 3 52646 { 52647 SDValue N1 = N.getOperand(1); 52648 if (N1.getOpcode() == ISD::LOAD && 52649 N1.hasOneUse() && 52650 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 52651 SDValue Chain1 = N1.getOperand(0); 52652 if (Predicate_unindexedload(N1.getNode()) && 52653 Predicate_load(N1.getNode()) && 52654 Predicate_memop(N1.getNode())) { 52655 SDValue N11 = N1.getOperand(1); 52656 SDValue CPTmpN11_0; 52657 SDValue CPTmpN11_1; 52658 SDValue CPTmpN11_2; 52659 SDValue CPTmpN11_3; 52660 SDValue CPTmpN11_4; 52661 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 52662 SDNode *Result = Emit_18(N, X86::PCMPEQBrm, MVT::v16i8, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 52663 return Result; 52664 } 52665 } 52666 } 52667 } 52668 52669 // Pattern: (X86pcmpeqb:v16i8 (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, VR128:v16i8:$src1) 52670 // Emits: (PCMPEQBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 52671 // Pattern complexity = 25 cost = 1 size = 3 52672 if (N0.getOpcode() == ISD::LOAD && 52673 N0.hasOneUse() && 52674 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 52675 SDValue Chain0 = N0.getOperand(0); 52676 if (Predicate_unindexedload(N0.getNode()) && 52677 Predicate_load(N0.getNode()) && 52678 Predicate_memop(N0.getNode())) { 52679 SDValue N01 = N0.getOperand(1); 52680 SDValue CPTmpN01_0; 52681 SDValue CPTmpN01_1; 52682 SDValue CPTmpN01_2; 52683 SDValue CPTmpN01_3; 52684 SDValue CPTmpN01_4; 52685 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 52686 SDNode *Result = Emit_19(N, X86::PCMPEQBrm, MVT::v16i8, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 52687 return Result; 52688 } 52689 } 52690 } 52691 } 52692 52693 // Pattern: (X86pcmpeqb:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 52694 // Emits: (PCMPEQBrr:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 52695 // Pattern complexity = 3 cost = 1 size = 3 52696 SDNode *Result = Emit_15(N, X86::PCMPEQBrr, MVT::v16i8); 52697 return Result; 52698 } 52699 52700 SDNode *Select_X86ISD_PCMPEQD_v2i32(const SDValue &N) { 52701 if (OptLevel != CodeGenOpt::None) { 52702 SDValue N0 = N.getOperand(0); 52703 52704 // Pattern: (X86pcmpeqd:v2i32 VR64:v2i32:$src1, (bitconvert:v2i32 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 52705 // Emits: (MMX_PCMPEQDrm:v2i32 VR64:v8i8:$src1, addr:iPTR:$src2) 52706 // Pattern complexity = 28 cost = 1 size = 3 52707 { 52708 SDValue N1 = N.getOperand(1); 52709 if (N1.getOpcode() == ISD::BIT_CONVERT && 52710 N1.hasOneUse()) { 52711 SDValue N10 = N1.getOperand(0); 52712 if (N10.getOpcode() == ISD::LOAD && 52713 N10.hasOneUse() && 52714 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 52715 SDValue Chain10 = N10.getOperand(0); 52716 if (Predicate_unindexedload(N10.getNode()) && 52717 Predicate_load(N10.getNode())) { 52718 SDValue N101 = N10.getOperand(1); 52719 SDValue CPTmpN101_0; 52720 SDValue CPTmpN101_1; 52721 SDValue CPTmpN101_2; 52722 SDValue CPTmpN101_3; 52723 SDValue CPTmpN101_4; 52724 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 52725 N10.getNode()->getValueType(0) == MVT::v1i64) { 52726 SDNode *Result = Emit_16(N, X86::MMX_PCMPEQDrm, MVT::v2i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 52727 return Result; 52728 } 52729 } 52730 } 52731 } 52732 } 52733 52734 // Pattern: (X86pcmpeqd:v2i32 (bitconvert:v2i32 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v2i32:$src1) 52735 // Emits: (MMX_PCMPEQDrm:v2i32 VR64:v8i8:$src1, addr:iPTR:$src2) 52736 // Pattern complexity = 28 cost = 1 size = 3 52737 if (N0.getOpcode() == ISD::BIT_CONVERT && 52738 N0.hasOneUse()) { 52739 SDValue N00 = N0.getOperand(0); 52740 if (N00.getOpcode() == ISD::LOAD && 52741 N00.hasOneUse() && 52742 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 52743 SDValue Chain00 = N00.getOperand(0); 52744 if (Predicate_unindexedload(N00.getNode()) && 52745 Predicate_load(N00.getNode())) { 52746 SDValue N001 = N00.getOperand(1); 52747 SDValue CPTmpN001_0; 52748 SDValue CPTmpN001_1; 52749 SDValue CPTmpN001_2; 52750 SDValue CPTmpN001_3; 52751 SDValue CPTmpN001_4; 52752 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 52753 SDValue N1 = N.getOperand(1); 52754 if (N00.getNode()->getValueType(0) == MVT::v1i64) { 52755 SDNode *Result = Emit_17(N, X86::MMX_PCMPEQDrm, MVT::v2i32, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 52756 return Result; 52757 } 52758 } 52759 } 52760 } 52761 } 52762 } 52763 52764 // Pattern: (X86pcmpeqd:v2i32 VR64:v2i32:$src1, VR64:v2i32:$src2) 52765 // Emits: (MMX_PCMPEQDrr:v2i32 VR64:v8i8:$src1, VR64:v8i8:$src2) 52766 // Pattern complexity = 3 cost = 1 size = 3 52767 SDNode *Result = Emit_15(N, X86::MMX_PCMPEQDrr, MVT::v2i32); 52768 return Result; 52769 } 52770 52771 SDNode *Select_X86ISD_PCMPEQD_v4i32(const SDValue &N) { 52772 if (OptLevel != CodeGenOpt::None) { 52773 SDValue N0 = N.getOperand(0); 52774 52775 // Pattern: (X86pcmpeqd:v4i32 VR128:v4i32:$src1, (ld:v4i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 52776 // Emits: (PCMPEQDrm:v4i32 VR128:v16i8:$src1, addr:iPTR:$src2) 52777 // Pattern complexity = 25 cost = 1 size = 3 52778 { 52779 SDValue N1 = N.getOperand(1); 52780 if (N1.getOpcode() == ISD::LOAD && 52781 N1.hasOneUse() && 52782 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 52783 SDValue Chain1 = N1.getOperand(0); 52784 if (Predicate_unindexedload(N1.getNode()) && 52785 Predicate_load(N1.getNode()) && 52786 Predicate_memop(N1.getNode())) { 52787 SDValue N11 = N1.getOperand(1); 52788 SDValue CPTmpN11_0; 52789 SDValue CPTmpN11_1; 52790 SDValue CPTmpN11_2; 52791 SDValue CPTmpN11_3; 52792 SDValue CPTmpN11_4; 52793 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 52794 SDNode *Result = Emit_18(N, X86::PCMPEQDrm, MVT::v4i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 52795 return Result; 52796 } 52797 } 52798 } 52799 } 52800 52801 // Pattern: (X86pcmpeqd:v4i32 (ld:v4i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, VR128:v4i32:$src1) 52802 // Emits: (PCMPEQDrm:v4i32 VR128:v16i8:$src1, addr:iPTR:$src2) 52803 // Pattern complexity = 25 cost = 1 size = 3 52804 if (N0.getOpcode() == ISD::LOAD && 52805 N0.hasOneUse() && 52806 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 52807 SDValue Chain0 = N0.getOperand(0); 52808 if (Predicate_unindexedload(N0.getNode()) && 52809 Predicate_load(N0.getNode()) && 52810 Predicate_memop(N0.getNode())) { 52811 SDValue N01 = N0.getOperand(1); 52812 SDValue CPTmpN01_0; 52813 SDValue CPTmpN01_1; 52814 SDValue CPTmpN01_2; 52815 SDValue CPTmpN01_3; 52816 SDValue CPTmpN01_4; 52817 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 52818 SDNode *Result = Emit_19(N, X86::PCMPEQDrm, MVT::v4i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 52819 return Result; 52820 } 52821 } 52822 } 52823 } 52824 52825 // Pattern: (X86pcmpeqd:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 52826 // Emits: (PCMPEQDrr:v4i32 VR128:v16i8:$src1, VR128:v16i8:$src2) 52827 // Pattern complexity = 3 cost = 1 size = 3 52828 SDNode *Result = Emit_15(N, X86::PCMPEQDrr, MVT::v4i32); 52829 return Result; 52830 } 52831 52832 SDNode *Select_X86ISD_PCMPEQQ_v2i64(const SDValue &N) { 52833 if (OptLevel != CodeGenOpt::None) { 52834 SDValue N0 = N.getOperand(0); 52835 52836 // Pattern: (X86pcmpeqq:v2i64 VR128:v2i64:$src1, (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 52837 // Emits: (PCMPEQQrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 52838 // Pattern complexity = 25 cost = 1 size = 3 52839 { 52840 SDValue N1 = N.getOperand(1); 52841 if (N1.getOpcode() == ISD::LOAD && 52842 N1.hasOneUse() && 52843 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 52844 SDValue Chain1 = N1.getOperand(0); 52845 if (Predicate_unindexedload(N1.getNode()) && 52846 Predicate_load(N1.getNode()) && 52847 Predicate_memop(N1.getNode())) { 52848 SDValue N11 = N1.getOperand(1); 52849 SDValue CPTmpN11_0; 52850 SDValue CPTmpN11_1; 52851 SDValue CPTmpN11_2; 52852 SDValue CPTmpN11_3; 52853 SDValue CPTmpN11_4; 52854 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 52855 SDNode *Result = Emit_18(N, X86::PCMPEQQrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 52856 return Result; 52857 } 52858 } 52859 } 52860 } 52861 52862 // Pattern: (X86pcmpeqq:v2i64 (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, VR128:v2i64:$src1) 52863 // Emits: (PCMPEQQrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 52864 // Pattern complexity = 25 cost = 1 size = 3 52865 if (N0.getOpcode() == ISD::LOAD && 52866 N0.hasOneUse() && 52867 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 52868 SDValue Chain0 = N0.getOperand(0); 52869 if (Predicate_unindexedload(N0.getNode()) && 52870 Predicate_load(N0.getNode()) && 52871 Predicate_memop(N0.getNode())) { 52872 SDValue N01 = N0.getOperand(1); 52873 SDValue CPTmpN01_0; 52874 SDValue CPTmpN01_1; 52875 SDValue CPTmpN01_2; 52876 SDValue CPTmpN01_3; 52877 SDValue CPTmpN01_4; 52878 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 52879 SDNode *Result = Emit_19(N, X86::PCMPEQQrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 52880 return Result; 52881 } 52882 } 52883 } 52884 } 52885 52886 // Pattern: (X86pcmpeqq:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 52887 // Emits: (PCMPEQQrr:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src2) 52888 // Pattern complexity = 3 cost = 1 size = 3 52889 SDNode *Result = Emit_15(N, X86::PCMPEQQrr, MVT::v2i64); 52890 return Result; 52891 } 52892 52893 SDNode *Select_X86ISD_PCMPEQW_v4i16(const SDValue &N) { 52894 if (OptLevel != CodeGenOpt::None) { 52895 SDValue N0 = N.getOperand(0); 52896 52897 // Pattern: (X86pcmpeqw:v4i16 VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 52898 // Emits: (MMX_PCMPEQWrm:v4i16 VR64:v8i8:$src1, addr:iPTR:$src2) 52899 // Pattern complexity = 28 cost = 1 size = 3 52900 { 52901 SDValue N1 = N.getOperand(1); 52902 if (N1.getOpcode() == ISD::BIT_CONVERT && 52903 N1.hasOneUse()) { 52904 SDValue N10 = N1.getOperand(0); 52905 if (N10.getOpcode() == ISD::LOAD && 52906 N10.hasOneUse() && 52907 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 52908 SDValue Chain10 = N10.getOperand(0); 52909 if (Predicate_unindexedload(N10.getNode()) && 52910 Predicate_load(N10.getNode())) { 52911 SDValue N101 = N10.getOperand(1); 52912 SDValue CPTmpN101_0; 52913 SDValue CPTmpN101_1; 52914 SDValue CPTmpN101_2; 52915 SDValue CPTmpN101_3; 52916 SDValue CPTmpN101_4; 52917 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 52918 N10.getNode()->getValueType(0) == MVT::v1i64) { 52919 SDNode *Result = Emit_16(N, X86::MMX_PCMPEQWrm, MVT::v4i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 52920 return Result; 52921 } 52922 } 52923 } 52924 } 52925 } 52926 52927 // Pattern: (X86pcmpeqw:v4i16 (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>), VR64:v4i16:$src1) 52928 // Emits: (MMX_PCMPEQWrm:v4i16 VR64:v8i8:$src1, addr:iPTR:$src2) 52929 // Pattern complexity = 28 cost = 1 size = 3 52930 if (N0.getOpcode() == ISD::BIT_CONVERT && 52931 N0.hasOneUse()) { 52932 SDValue N00 = N0.getOperand(0); 52933 if (N00.getOpcode() == ISD::LOAD && 52934 N00.hasOneUse() && 52935 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 52936 SDValue Chain00 = N00.getOperand(0); 52937 if (Predicate_unindexedload(N00.getNode()) && 52938 Predicate_load(N00.getNode())) { 52939 SDValue N001 = N00.getOperand(1); 52940 SDValue CPTmpN001_0; 52941 SDValue CPTmpN001_1; 52942 SDValue CPTmpN001_2; 52943 SDValue CPTmpN001_3; 52944 SDValue CPTmpN001_4; 52945 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 52946 SDValue N1 = N.getOperand(1); 52947 if (N00.getNode()->getValueType(0) == MVT::v1i64) { 52948 SDNode *Result = Emit_17(N, X86::MMX_PCMPEQWrm, MVT::v4i16, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 52949 return Result; 52950 } 52951 } 52952 } 52953 } 52954 } 52955 } 52956 52957 // Pattern: (X86pcmpeqw:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 52958 // Emits: (MMX_PCMPEQWrr:v4i16 VR64:v8i8:$src1, VR64:v8i8:$src2) 52959 // Pattern complexity = 3 cost = 1 size = 3 52960 SDNode *Result = Emit_15(N, X86::MMX_PCMPEQWrr, MVT::v4i16); 52961 return Result; 52962 } 52963 52964 SDNode *Select_X86ISD_PCMPEQW_v8i16(const SDValue &N) { 52965 if (OptLevel != CodeGenOpt::None) { 52966 SDValue N0 = N.getOperand(0); 52967 52968 // Pattern: (X86pcmpeqw:v8i16 VR128:v8i16:$src1, (ld:v8i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 52969 // Emits: (PCMPEQWrm:v8i16 VR128:v16i8:$src1, addr:iPTR:$src2) 52970 // Pattern complexity = 25 cost = 1 size = 3 52971 { 52972 SDValue N1 = N.getOperand(1); 52973 if (N1.getOpcode() == ISD::LOAD && 52974 N1.hasOneUse() && 52975 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 52976 SDValue Chain1 = N1.getOperand(0); 52977 if (Predicate_unindexedload(N1.getNode()) && 52978 Predicate_load(N1.getNode()) && 52979 Predicate_memop(N1.getNode())) { 52980 SDValue N11 = N1.getOperand(1); 52981 SDValue CPTmpN11_0; 52982 SDValue CPTmpN11_1; 52983 SDValue CPTmpN11_2; 52984 SDValue CPTmpN11_3; 52985 SDValue CPTmpN11_4; 52986 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 52987 SDNode *Result = Emit_18(N, X86::PCMPEQWrm, MVT::v8i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 52988 return Result; 52989 } 52990 } 52991 } 52992 } 52993 52994 // Pattern: (X86pcmpeqw:v8i16 (ld:v8i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>, VR128:v8i16:$src1) 52995 // Emits: (PCMPEQWrm:v8i16 VR128:v16i8:$src1, addr:iPTR:$src2) 52996 // Pattern complexity = 25 cost = 1 size = 3 52997 if (N0.getOpcode() == ISD::LOAD && 52998 N0.hasOneUse() && 52999 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 53000 SDValue Chain0 = N0.getOperand(0); 53001 if (Predicate_unindexedload(N0.getNode()) && 53002 Predicate_load(N0.getNode()) && 53003 Predicate_memop(N0.getNode())) { 53004 SDValue N01 = N0.getOperand(1); 53005 SDValue CPTmpN01_0; 53006 SDValue CPTmpN01_1; 53007 SDValue CPTmpN01_2; 53008 SDValue CPTmpN01_3; 53009 SDValue CPTmpN01_4; 53010 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 53011 SDNode *Result = Emit_19(N, X86::PCMPEQWrm, MVT::v8i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 53012 return Result; 53013 } 53014 } 53015 } 53016 } 53017 53018 // Pattern: (X86pcmpeqw:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 53019 // Emits: (PCMPEQWrr:v8i16 VR128:v16i8:$src1, VR128:v16i8:$src2) 53020 // Pattern complexity = 3 cost = 1 size = 3 53021 SDNode *Result = Emit_15(N, X86::PCMPEQWrr, MVT::v8i16); 53022 return Result; 53023 } 53024 53025 SDNode *Select_X86ISD_PCMPGTB_v8i8(const SDValue &N) { 53026 53027 // Pattern: (X86pcmpgtb:v8i8 VR64:v8i8:$src1, (bitconvert:v8i8 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 53028 // Emits: (MMX_PCMPGTBrm:v8i8 VR64:v8i8:$src1, addr:iPTR:$src2) 53029 // Pattern complexity = 28 cost = 1 size = 3 53030 if (OptLevel != CodeGenOpt::None) { 53031 SDValue N0 = N.getOperand(0); 53032 SDValue N1 = N.getOperand(1); 53033 if (N1.getOpcode() == ISD::BIT_CONVERT && 53034 N1.hasOneUse()) { 53035 SDValue N10 = N1.getOperand(0); 53036 if (N10.getOpcode() == ISD::LOAD && 53037 N10.hasOneUse() && 53038 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 53039 SDValue Chain10 = N10.getOperand(0); 53040 if (Predicate_unindexedload(N10.getNode()) && 53041 Predicate_load(N10.getNode())) { 53042 SDValue N101 = N10.getOperand(1); 53043 SDValue CPTmpN101_0; 53044 SDValue CPTmpN101_1; 53045 SDValue CPTmpN101_2; 53046 SDValue CPTmpN101_3; 53047 SDValue CPTmpN101_4; 53048 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 53049 N10.getNode()->getValueType(0) == MVT::v1i64) { 53050 SDNode *Result = Emit_16(N, X86::MMX_PCMPGTBrm, MVT::v8i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 53051 return Result; 53052 } 53053 } 53054 } 53055 } 53056 } 53057 53058 // Pattern: (X86pcmpgtb:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 53059 // Emits: (MMX_PCMPGTBrr:v8i8 VR64:v8i8:$src1, VR64:v8i8:$src2) 53060 // Pattern complexity = 3 cost = 1 size = 3 53061 SDNode *Result = Emit_15(N, X86::MMX_PCMPGTBrr, MVT::v8i8); 53062 return Result; 53063 } 53064 53065 SDNode *Select_X86ISD_PCMPGTB_v16i8(const SDValue &N) { 53066 53067 // Pattern: (X86pcmpgtb:v16i8 VR128:v16i8:$src1, (ld:v16i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 53068 // Emits: (PCMPGTBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2) 53069 // Pattern complexity = 25 cost = 1 size = 3 53070 if (OptLevel != CodeGenOpt::None) { 53071 SDValue N0 = N.getOperand(0); 53072 SDValue N1 = N.getOperand(1); 53073 if (N1.getOpcode() == ISD::LOAD && 53074 N1.hasOneUse() && 53075 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 53076 SDValue Chain1 = N1.getOperand(0); 53077 if (Predicate_unindexedload(N1.getNode()) && 53078 Predicate_load(N1.getNode()) && 53079 Predicate_memop(N1.getNode())) { 53080 SDValue N11 = N1.getOperand(1); 53081 SDValue CPTmpN11_0; 53082 SDValue CPTmpN11_1; 53083 SDValue CPTmpN11_2; 53084 SDValue CPTmpN11_3; 53085 SDValue CPTmpN11_4; 53086 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 53087 SDNode *Result = Emit_18(N, X86::PCMPGTBrm, MVT::v16i8, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 53088 return Result; 53089 } 53090 } 53091 } 53092 } 53093 53094 // Pattern: (X86pcmpgtb:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 53095 // Emits: (PCMPGTBrr:v16i8 VR128:v16i8:$src1, VR128:v16i8:$src2) 53096 // Pattern complexity = 3 cost = 1 size = 3 53097 SDNode *Result = Emit_15(N, X86::PCMPGTBrr, MVT::v16i8); 53098 return Result; 53099 } 53100 53101 SDNode *Select_X86ISD_PCMPGTD_v2i32(const SDValue &N) { 53102 53103 // Pattern: (X86pcmpgtd:v2i32 VR64:v2i32:$src1, (bitconvert:v2i32 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 53104 // Emits: (MMX_PCMPGTDrm:v2i32 VR64:v8i8:$src1, addr:iPTR:$src2) 53105 // Pattern complexity = 28 cost = 1 size = 3 53106 if (OptLevel != CodeGenOpt::None) { 53107 SDValue N0 = N.getOperand(0); 53108 SDValue N1 = N.getOperand(1); 53109 if (N1.getOpcode() == ISD::BIT_CONVERT && 53110 N1.hasOneUse()) { 53111 SDValue N10 = N1.getOperand(0); 53112 if (N10.getOpcode() == ISD::LOAD && 53113 N10.hasOneUse() && 53114 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 53115 SDValue Chain10 = N10.getOperand(0); 53116 if (Predicate_unindexedload(N10.getNode()) && 53117 Predicate_load(N10.getNode())) { 53118 SDValue N101 = N10.getOperand(1); 53119 SDValue CPTmpN101_0; 53120 SDValue CPTmpN101_1; 53121 SDValue CPTmpN101_2; 53122 SDValue CPTmpN101_3; 53123 SDValue CPTmpN101_4; 53124 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 53125 N10.getNode()->getValueType(0) == MVT::v1i64) { 53126 SDNode *Result = Emit_16(N, X86::MMX_PCMPGTDrm, MVT::v2i32, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 53127 return Result; 53128 } 53129 } 53130 } 53131 } 53132 } 53133 53134 // Pattern: (X86pcmpgtd:v2i32 VR64:v2i32:$src1, VR64:v2i32:$src2) 53135 // Emits: (MMX_PCMPGTDrr:v2i32 VR64:v8i8:$src1, VR64:v8i8:$src2) 53136 // Pattern complexity = 3 cost = 1 size = 3 53137 SDNode *Result = Emit_15(N, X86::MMX_PCMPGTDrr, MVT::v2i32); 53138 return Result; 53139 } 53140 53141 SDNode *Select_X86ISD_PCMPGTD_v4i32(const SDValue &N) { 53142 53143 // Pattern: (X86pcmpgtd:v4i32 VR128:v4i32:$src1, (ld:v4i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 53144 // Emits: (PCMPGTDrm:v4i32 VR128:v16i8:$src1, addr:iPTR:$src2) 53145 // Pattern complexity = 25 cost = 1 size = 3 53146 if (OptLevel != CodeGenOpt::None) { 53147 SDValue N0 = N.getOperand(0); 53148 SDValue N1 = N.getOperand(1); 53149 if (N1.getOpcode() == ISD::LOAD && 53150 N1.hasOneUse() && 53151 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 53152 SDValue Chain1 = N1.getOperand(0); 53153 if (Predicate_unindexedload(N1.getNode()) && 53154 Predicate_load(N1.getNode()) && 53155 Predicate_memop(N1.getNode())) { 53156 SDValue N11 = N1.getOperand(1); 53157 SDValue CPTmpN11_0; 53158 SDValue CPTmpN11_1; 53159 SDValue CPTmpN11_2; 53160 SDValue CPTmpN11_3; 53161 SDValue CPTmpN11_4; 53162 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 53163 SDNode *Result = Emit_18(N, X86::PCMPGTDrm, MVT::v4i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 53164 return Result; 53165 } 53166 } 53167 } 53168 } 53169 53170 // Pattern: (X86pcmpgtd:v4i32 VR128:v4i32:$src1, VR128:v4i32:$src2) 53171 // Emits: (PCMPGTDrr:v4i32 VR128:v16i8:$src1, VR128:v16i8:$src2) 53172 // Pattern complexity = 3 cost = 1 size = 3 53173 SDNode *Result = Emit_15(N, X86::PCMPGTDrr, MVT::v4i32); 53174 return Result; 53175 } 53176 53177 SDNode *Select_X86ISD_PCMPGTQ_v2i64(const SDValue &N) { 53178 53179 // Pattern: (X86pcmpgtq:v2i64 VR128:v2i64:$src1, (ld:v2i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 53180 // Emits: (PCMPGTQrm:v2i64 VR128:v16i8:$src1, addr:iPTR:$src2) 53181 // Pattern complexity = 25 cost = 1 size = 3 53182 if (OptLevel != CodeGenOpt::None) { 53183 SDValue N0 = N.getOperand(0); 53184 SDValue N1 = N.getOperand(1); 53185 if (N1.getOpcode() == ISD::LOAD && 53186 N1.hasOneUse() && 53187 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 53188 SDValue Chain1 = N1.getOperand(0); 53189 if (Predicate_unindexedload(N1.getNode()) && 53190 Predicate_load(N1.getNode()) && 53191 Predicate_memop(N1.getNode())) { 53192 SDValue N11 = N1.getOperand(1); 53193 SDValue CPTmpN11_0; 53194 SDValue CPTmpN11_1; 53195 SDValue CPTmpN11_2; 53196 SDValue CPTmpN11_3; 53197 SDValue CPTmpN11_4; 53198 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 53199 SDNode *Result = Emit_18(N, X86::PCMPGTQrm, MVT::v2i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 53200 return Result; 53201 } 53202 } 53203 } 53204 } 53205 53206 // Pattern: (X86pcmpgtq:v2i64 VR128:v2i64:$src1, VR128:v2i64:$src2) 53207 // Emits: (PCMPGTQrr:v2i64 VR128:v16i8:$src1, VR128:v16i8:$src2) 53208 // Pattern complexity = 3 cost = 1 size = 3 53209 SDNode *Result = Emit_15(N, X86::PCMPGTQrr, MVT::v2i64); 53210 return Result; 53211 } 53212 53213 SDNode *Select_X86ISD_PCMPGTW_v4i16(const SDValue &N) { 53214 53215 // Pattern: (X86pcmpgtw:v4i16 VR64:v4i16:$src1, (bitconvert:v4i16 (ld:v1i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 53216 // Emits: (MMX_PCMPGTWrm:v4i16 VR64:v8i8:$src1, addr:iPTR:$src2) 53217 // Pattern complexity = 28 cost = 1 size = 3 53218 if (OptLevel != CodeGenOpt::None) { 53219 SDValue N0 = N.getOperand(0); 53220 SDValue N1 = N.getOperand(1); 53221 if (N1.getOpcode() == ISD::BIT_CONVERT && 53222 N1.hasOneUse()) { 53223 SDValue N10 = N1.getOperand(0); 53224 if (N10.getOpcode() == ISD::LOAD && 53225 N10.hasOneUse() && 53226 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 53227 SDValue Chain10 = N10.getOperand(0); 53228 if (Predicate_unindexedload(N10.getNode()) && 53229 Predicate_load(N10.getNode())) { 53230 SDValue N101 = N10.getOperand(1); 53231 SDValue CPTmpN101_0; 53232 SDValue CPTmpN101_1; 53233 SDValue CPTmpN101_2; 53234 SDValue CPTmpN101_3; 53235 SDValue CPTmpN101_4; 53236 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 53237 N10.getNode()->getValueType(0) == MVT::v1i64) { 53238 SDNode *Result = Emit_16(N, X86::MMX_PCMPGTWrm, MVT::v4i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 53239 return Result; 53240 } 53241 } 53242 } 53243 } 53244 } 53245 53246 // Pattern: (X86pcmpgtw:v4i16 VR64:v4i16:$src1, VR64:v4i16:$src2) 53247 // Emits: (MMX_PCMPGTWrr:v4i16 VR64:v8i8:$src1, VR64:v8i8:$src2) 53248 // Pattern complexity = 3 cost = 1 size = 3 53249 SDNode *Result = Emit_15(N, X86::MMX_PCMPGTWrr, MVT::v4i16); 53250 return Result; 53251 } 53252 53253 SDNode *Select_X86ISD_PCMPGTW_v8i16(const SDValue &N) { 53254 53255 // Pattern: (X86pcmpgtw:v8i16 VR128:v8i16:$src1, (ld:v8i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>) 53256 // Emits: (PCMPGTWrm:v8i16 VR128:v16i8:$src1, addr:iPTR:$src2) 53257 // Pattern complexity = 25 cost = 1 size = 3 53258 if (OptLevel != CodeGenOpt::None) { 53259 SDValue N0 = N.getOperand(0); 53260 SDValue N1 = N.getOperand(1); 53261 if (N1.getOpcode() == ISD::LOAD && 53262 N1.hasOneUse() && 53263 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 53264 SDValue Chain1 = N1.getOperand(0); 53265 if (Predicate_unindexedload(N1.getNode()) && 53266 Predicate_load(N1.getNode()) && 53267 Predicate_memop(N1.getNode())) { 53268 SDValue N11 = N1.getOperand(1); 53269 SDValue CPTmpN11_0; 53270 SDValue CPTmpN11_1; 53271 SDValue CPTmpN11_2; 53272 SDValue CPTmpN11_3; 53273 SDValue CPTmpN11_4; 53274 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 53275 SDNode *Result = Emit_18(N, X86::PCMPGTWrm, MVT::v8i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 53276 return Result; 53277 } 53278 } 53279 } 53280 } 53281 53282 // Pattern: (X86pcmpgtw:v8i16 VR128:v8i16:$src1, VR128:v8i16:$src2) 53283 // Emits: (PCMPGTWrr:v8i16 VR128:v16i8:$src1, VR128:v16i8:$src2) 53284 // Pattern complexity = 3 cost = 1 size = 3 53285 SDNode *Result = Emit_15(N, X86::PCMPGTWrr, MVT::v8i16); 53286 return Result; 53287 } 53288 53289 SDNode *Select_X86ISD_PEXTRB_i32(const SDValue &N) { 53290 if ((Subtarget->hasSSE41())) { 53291 SDValue N0 = N.getOperand(0); 53292 SDValue N1 = N.getOperand(1); 53293 if (N1.getOpcode() == ISD::Constant && 53294 N0.getNode()->getValueType(0) == MVT::v16i8) { 53295 SDNode *Result = Emit_93(N, X86::PEXTRBrr, MVT::i32); 53296 return Result; 53297 } 53298 } 53299 53300 CannotYetSelect(N); 53301 return NULL; 53302 } 53303 53304 SDNode *Emit_298(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 53305 SDValue N0 = N.getOperand(0); 53306 SDValue N1 = N.getOperand(1); 53307 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned short) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i16); 53308 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, Tmp1); 53309 } 53310 SDNode *Select_X86ISD_PEXTRW_i32(const SDValue &N) { 53311 53312 // Pattern: (X86pextrw:i32 VR128:v8i16:$src1, (imm:iPTR):$src2) 53313 // Emits: (PEXTRWri:i32 VR128:v8i16:$src1, (imm:i32):$src2) 53314 // Pattern complexity = 6 cost = 1 size = 3 53315 if ((Subtarget->hasSSE2())) { 53316 SDValue N0 = N.getOperand(0); 53317 SDValue N1 = N.getOperand(1); 53318 if (N1.getOpcode() == ISD::Constant && 53319 N0.getNode()->getValueType(0) == MVT::v8i16) { 53320 SDNode *Result = Emit_93(N, X86::PEXTRWri, MVT::i32); 53321 return Result; 53322 } 53323 } 53324 53325 // Pattern: (MMX_X86pextrw:i32 VR64:v4i16:$src1, (imm:iPTR):$src2) 53326 // Emits: (MMX_PEXTRWri:i32 VR64:v4i16:$src1, (imm:i16):$src2) 53327 // Pattern complexity = 6 cost = 1 size = 3 53328 if ((Subtarget->hasMMX())) { 53329 SDValue N0 = N.getOperand(0); 53330 SDValue N1 = N.getOperand(1); 53331 if (N1.getOpcode() == ISD::Constant && 53332 N0.getNode()->getValueType(0) == MVT::v4i16 && 53333 N1.getNode()->getValueType(0) == TLI.getPointerTy()) { 53334 SDNode *Result = Emit_298(N, X86::MMX_PEXTRWri, MVT::i32); 53335 return Result; 53336 } 53337 } 53338 53339 CannotYetSelect(N); 53340 return NULL; 53341 } 53342 53343 SDNode *Select_X86ISD_PINSRB_v16i8(const SDValue &N) { 53344 53345 // Pattern: (X86pinsrb:v16i8 VR128:v16i8:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi8>>, (imm:iPTR):$src3) 53346 // Emits: (PINSRBrm:v16i8 VR128:v16i8:$src1, addr:iPTR:$src2, (imm:i32):$src3) 53347 // Pattern complexity = 28 cost = 1 size = 3 53348 if (OptLevel != CodeGenOpt::None && 53349 (Subtarget->hasSSE41())) { 53350 SDValue N0 = N.getOperand(0); 53351 SDValue N1 = N.getOperand(1); 53352 if (N1.getOpcode() == ISD::LOAD && 53353 N1.hasOneUse() && 53354 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 53355 SDValue Chain1 = N1.getOperand(0); 53356 if (Predicate_unindexedload(N1.getNode()) && 53357 Predicate_extload(N1.getNode()) && 53358 Predicate_extloadi8(N1.getNode())) { 53359 SDValue N11 = N1.getOperand(1); 53360 SDValue CPTmpN11_0; 53361 SDValue CPTmpN11_1; 53362 SDValue CPTmpN11_2; 53363 SDValue CPTmpN11_3; 53364 SDValue CPTmpN11_4; 53365 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 53366 SDValue N2 = N.getOperand(2); 53367 if (N2.getOpcode() == ISD::Constant) { 53368 SDNode *Result = Emit_98(N, X86::PINSRBrm, MVT::v16i8, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 53369 return Result; 53370 } 53371 } 53372 } 53373 } 53374 } 53375 53376 // Pattern: (X86pinsrb:v16i8 VR128:v16i8:$src1, GR32:i32:$src2, (imm:iPTR):$src3) 53377 // Emits: (PINSRBrr:v16i8 VR128:v16i8:$src1, GR32:i32:$src2, (imm:i32):$src3) 53378 // Pattern complexity = 6 cost = 1 size = 3 53379 if ((Subtarget->hasSSE41())) { 53380 SDValue N0 = N.getOperand(0); 53381 SDValue N1 = N.getOperand(1); 53382 SDValue N2 = N.getOperand(2); 53383 if (N2.getOpcode() == ISD::Constant) { 53384 SDNode *Result = Emit_97(N, X86::PINSRBrr, MVT::v16i8); 53385 return Result; 53386 } 53387 } 53388 53389 CannotYetSelect(N); 53390 return NULL; 53391 } 53392 53393 SDNode *Emit_299(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 53394 SDValue N0 = N.getOperand(0); 53395 SDValue N1 = N.getOperand(1); 53396 SDValue N2 = N.getOperand(2); 53397 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned short) cast<ConstantSDNode>(N2)->getZExtValue()), MVT::i16); 53398 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, N1, Tmp2); 53399 } 53400 SDNode *Emit_300(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN101_0, SDValue &CPTmpN101_1, SDValue &CPTmpN101_2, SDValue &CPTmpN101_3, SDValue &CPTmpN101_4) DISABLE_INLINE { 53401 SDValue N0 = N.getOperand(0); 53402 SDValue N1 = N.getOperand(1); 53403 SDValue N10 = N1.getOperand(0); 53404 SDValue Chain10 = N10.getOperand(0); 53405 SDValue N101 = N10.getOperand(1); 53406 SDValue N2 = N.getOperand(2); 53407 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned short) cast<ConstantSDNode>(N2)->getZExtValue()), MVT::i16); 53408 SDValue LSI_N10 = CurDAG->getMemOperand(cast<MemSDNode>(N10)->getMemOperand()); 53409 SDValue Ops0[] = { N0, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4, Tmp2, LSI_N10, Chain10 }; 53410 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 9); 53411 ReplaceUses(SDValue(N10.getNode(), 1), SDValue(ResNode, 1)); 53412 return ResNode; 53413 } 53414 SDNode *Select_X86ISD_PINSRW_v4i16(const SDValue &N) { 53415 53416 // Pattern: (MMX_X86pinsrw:v4i16 VR64:v4i16:$src1, (anyext:i32 (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>), (imm:iPTR):$src3) 53417 // Emits: (MMX_PINSRWrmi:v4i16 VR64:v4i16:$src1, addr:iPTR:$src2, (imm:i16):$src3) 53418 // Pattern complexity = 31 cost = 1 size = 3 53419 if (OptLevel != CodeGenOpt::None && 53420 (Subtarget->hasMMX())) { 53421 SDValue N0 = N.getOperand(0); 53422 SDValue N1 = N.getOperand(1); 53423 if (N1.getOpcode() == ISD::ANY_EXTEND && 53424 N1.hasOneUse()) { 53425 SDValue N10 = N1.getOperand(0); 53426 if (N10.getOpcode() == ISD::LOAD && 53427 N10.hasOneUse() && 53428 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 53429 SDValue Chain10 = N10.getOperand(0); 53430 if (Predicate_unindexedload(N10.getNode()) && 53431 Predicate_loadi16(N10.getNode())) { 53432 SDValue N101 = N10.getOperand(1); 53433 SDValue CPTmpN101_0; 53434 SDValue CPTmpN101_1; 53435 SDValue CPTmpN101_2; 53436 SDValue CPTmpN101_3; 53437 SDValue CPTmpN101_4; 53438 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4)) { 53439 SDValue N2 = N.getOperand(2); 53440 if (N2.getOpcode() == ISD::Constant && 53441 N0.getNode()->getValueType(0) == MVT::v4i16 && 53442 N1.getNode()->getValueType(0) == MVT::i32 && 53443 N10.getNode()->getValueType(0) == MVT::i16 && 53444 N2.getNode()->getValueType(0) == TLI.getPointerTy()) { 53445 SDNode *Result = Emit_300(N, X86::MMX_PINSRWrmi, MVT::v4i16, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 53446 return Result; 53447 } 53448 } 53449 } 53450 } 53451 } 53452 } 53453 53454 // Pattern: (MMX_X86pinsrw:v4i16 VR64:v4i16:$src1, GR32:i32:$src2, (imm:iPTR):$src3) 53455 // Emits: (MMX_PINSRWrri:v4i16 VR64:v4i16:$src1, GR32:i32:$src2, (imm:i16):$src3) 53456 // Pattern complexity = 6 cost = 1 size = 3 53457 if ((Subtarget->hasMMX())) { 53458 SDValue N0 = N.getOperand(0); 53459 SDValue N1 = N.getOperand(1); 53460 SDValue N2 = N.getOperand(2); 53461 if (N2.getOpcode() == ISD::Constant && 53462 N0.getNode()->getValueType(0) == MVT::v4i16 && 53463 N1.getNode()->getValueType(0) == MVT::i32 && 53464 N2.getNode()->getValueType(0) == TLI.getPointerTy()) { 53465 SDNode *Result = Emit_299(N, X86::MMX_PINSRWrri, MVT::v4i16); 53466 return Result; 53467 } 53468 } 53469 53470 CannotYetSelect(N); 53471 return NULL; 53472 } 53473 53474 SDNode *Select_X86ISD_PINSRW_v8i16(const SDValue &N) { 53475 53476 // Pattern: (X86pinsrw:v8i16 VR128:v8i16:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_extload>><<P:Predicate_extloadi16>>, (imm:iPTR):$src3) 53477 // Emits: (PINSRWrmi:v8i16 VR128:v8i16:$src1, addr:iPTR:$src2, (imm:i32):$src3) 53478 // Pattern complexity = 28 cost = 1 size = 3 53479 if (OptLevel != CodeGenOpt::None && 53480 (Subtarget->hasSSE2())) { 53481 SDValue N0 = N.getOperand(0); 53482 SDValue N1 = N.getOperand(1); 53483 if (N1.getOpcode() == ISD::LOAD && 53484 N1.hasOneUse() && 53485 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 53486 SDValue Chain1 = N1.getOperand(0); 53487 if (Predicate_unindexedload(N1.getNode()) && 53488 Predicate_extload(N1.getNode()) && 53489 Predicate_extloadi16(N1.getNode())) { 53490 SDValue N11 = N1.getOperand(1); 53491 SDValue CPTmpN11_0; 53492 SDValue CPTmpN11_1; 53493 SDValue CPTmpN11_2; 53494 SDValue CPTmpN11_3; 53495 SDValue CPTmpN11_4; 53496 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 53497 SDValue N2 = N.getOperand(2); 53498 if (N2.getOpcode() == ISD::Constant) { 53499 SDNode *Result = Emit_98(N, X86::PINSRWrmi, MVT::v8i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 53500 return Result; 53501 } 53502 } 53503 } 53504 } 53505 } 53506 53507 // Pattern: (X86pinsrw:v8i16 VR128:v8i16:$src1, GR32:i32:$src2, (imm:iPTR):$src3) 53508 // Emits: (PINSRWrri:v8i16 VR128:v8i16:$src1, GR32:i32:$src2, (imm:i32):$src3) 53509 // Pattern complexity = 6 cost = 1 size = 3 53510 if ((Subtarget->hasSSE2())) { 53511 SDValue N0 = N.getOperand(0); 53512 SDValue N1 = N.getOperand(1); 53513 SDValue N2 = N.getOperand(2); 53514 if (N2.getOpcode() == ISD::Constant) { 53515 SDNode *Result = Emit_97(N, X86::PINSRWrri, MVT::v8i16); 53516 return Result; 53517 } 53518 } 53519 53520 CannotYetSelect(N); 53521 return NULL; 53522 } 53523 53524 SDNode *Select_X86ISD_PSHUFB_v16i8(const SDValue &N) { 53525 53526 // Pattern: (X86pshufb:v16i8 VR128:v16i8:$src, (bitconvert:v16i8 (ld:v2i64 addr:iPTR:$mask)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_memop>>)) 53527 // Emits: (PSHUFBrm128:v16i8 VR128:v16i8:$src, addr:iPTR:$mask) 53528 // Pattern complexity = 28 cost = 1 size = 3 53529 if (OptLevel != CodeGenOpt::None && 53530 (Subtarget->hasSSSE3())) { 53531 SDValue N0 = N.getOperand(0); 53532 SDValue N1 = N.getOperand(1); 53533 if (N1.getOpcode() == ISD::BIT_CONVERT && 53534 N1.hasOneUse()) { 53535 SDValue N10 = N1.getOperand(0); 53536 if (N10.getOpcode() == ISD::LOAD && 53537 N10.hasOneUse() && 53538 IsLegalAndProfitableToFold(N10.getNode(), N1.getNode(), N.getNode())) { 53539 SDValue Chain10 = N10.getOperand(0); 53540 if (Predicate_unindexedload(N10.getNode()) && 53541 Predicate_load(N10.getNode()) && 53542 Predicate_memop(N10.getNode())) { 53543 SDValue N101 = N10.getOperand(1); 53544 SDValue CPTmpN101_0; 53545 SDValue CPTmpN101_1; 53546 SDValue CPTmpN101_2; 53547 SDValue CPTmpN101_3; 53548 SDValue CPTmpN101_4; 53549 if (SelectAddr(N, N101, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4) && 53550 N10.getNode()->getValueType(0) == MVT::v2i64) { 53551 SDNode *Result = Emit_16(N, X86::PSHUFBrm128, MVT::v16i8, CPTmpN101_0, CPTmpN101_1, CPTmpN101_2, CPTmpN101_3, CPTmpN101_4); 53552 return Result; 53553 } 53554 } 53555 } 53556 } 53557 } 53558 53559 // Pattern: (X86pshufb:v16i8 VR128:v16i8:$src, VR128:v16i8:$mask) 53560 // Emits: (PSHUFBrr128:v16i8 VR128:v16i8:$src, VR128:v16i8:$mask) 53561 // Pattern complexity = 3 cost = 1 size = 3 53562 if ((Subtarget->hasSSSE3())) { 53563 SDNode *Result = Emit_15(N, X86::PSHUFBrr128, MVT::v16i8); 53564 return Result; 53565 } 53566 53567 CannotYetSelect(N); 53568 return NULL; 53569 } 53570 53571 SDNode *Select_X86ISD_PTEST(const SDValue &N) { 53572 53573 // Pattern: (X86ptest:isVoid VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 53574 // Emits: (PTESTrm:isVoid VR128:v4f32:$src1, addr:iPTR:$src2) 53575 // Pattern complexity = 25 cost = 1 size = 3 53576 if (OptLevel != CodeGenOpt::None && 53577 (Subtarget->hasSSE41())) { 53578 SDValue N0 = N.getOperand(0); 53579 SDValue N1 = N.getOperand(1); 53580 if (N1.getOpcode() == ISD::LOAD && 53581 N1.hasOneUse() && 53582 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 53583 SDValue Chain1 = N1.getOperand(0); 53584 if (Predicate_unindexedload(N1.getNode()) && 53585 Predicate_load(N1.getNode())) { 53586 SDValue N11 = N1.getOperand(1); 53587 SDValue CPTmpN11_0; 53588 SDValue CPTmpN11_1; 53589 SDValue CPTmpN11_2; 53590 SDValue CPTmpN11_3; 53591 SDValue CPTmpN11_4; 53592 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 53593 SDNode *Result = Emit_280(N, X86::PTESTrm, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 53594 return Result; 53595 } 53596 } 53597 } 53598 } 53599 53600 // Pattern: (X86ptest:isVoid VR128:v4f32:$src1, VR128:v4f32:$src2) 53601 // Emits: (PTESTrr:isVoid VR128:v4f32:$src1, VR128:v4f32:$src2) 53602 // Pattern complexity = 3 cost = 1 size = 3 53603 if ((Subtarget->hasSSE41())) { 53604 SDNode *Result = Emit_257(N, X86::PTESTrr); 53605 return Result; 53606 } 53607 53608 CannotYetSelect(N); 53609 return NULL; 53610 } 53611 53612 SDNode *Emit_301(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 53613 SDValue Chain = N.getOperand(0); 53614 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, MVT::Flag, Chain); 53615 Chain = SDValue(ResNode, 0); 53616 SDValue InFlag(ResNode, 1); 53617 const SDValue Froms[] = { 53618 SDValue(N.getNode(), 1), 53619 SDValue(N.getNode(), 0) 53620 }; 53621 const SDValue Tos[] = { 53622 InFlag, 53623 SDValue(Chain.getNode(), Chain.getResNo()) 53624 }; 53625 ReplaceUses(Froms, Tos, 2); 53626 return ResNode; 53627 } 53628 SDNode *Select_X86ISD_RDTSC_DAG(const SDValue &N) { 53629 SDNode *Result = Emit_301(N, X86::RDTSC); 53630 return Result; 53631 } 53632 53633 SDNode *Emit_302(const SDValue &N, unsigned Opc0) DISABLE_INLINE { 53634 SDValue Chain = N.getOperand(0); 53635 SDValue N1 = N.getOperand(1); 53636 SDValue InFlag = N.getOperand(2); 53637 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, MVT::Flag, Chain, InFlag); 53638 Chain = SDValue(ResNode, 0); 53639 InFlag = SDValue(ResNode, 1); 53640 const SDValue Froms[] = { 53641 SDValue(N.getNode(), 1), 53642 SDValue(N.getNode(), 0) 53643 }; 53644 const SDValue Tos[] = { 53645 InFlag, 53646 SDValue(Chain.getNode(), Chain.getResNo()) 53647 }; 53648 ReplaceUses(Froms, Tos, 2); 53649 return ResNode; 53650 } 53651 SDNode *Select_X86ISD_REP_MOVS(const SDValue &N) { 53652 SDValue Chain = N.getOperand(0); 53653 SDValue N1 = N.getOperand(1); 53654 53655 // Pattern: (X86rep_movs:isVoid i8:Other) 53656 // Emits: (REP_MOVSB:isVoid) 53657 // Pattern complexity = 3 cost = 1 size = 3 53658 if (cast<VTSDNode>(N1)->getVT() == MVT::i8) { 53659 SDNode *Result = Emit_302(N, X86::REP_MOVSB); 53660 return Result; 53661 } 53662 53663 // Pattern: (X86rep_movs:isVoid i16:Other) 53664 // Emits: (REP_MOVSW:isVoid) 53665 // Pattern complexity = 3 cost = 1 size = 3 53666 if (cast<VTSDNode>(N1)->getVT() == MVT::i16) { 53667 SDNode *Result = Emit_302(N, X86::REP_MOVSW); 53668 return Result; 53669 } 53670 53671 // Pattern: (X86rep_movs:isVoid i32:Other) 53672 // Emits: (REP_MOVSD:isVoid) 53673 // Pattern complexity = 3 cost = 1 size = 3 53674 if (cast<VTSDNode>(N1)->getVT() == MVT::i32) { 53675 SDNode *Result = Emit_302(N, X86::REP_MOVSD); 53676 return Result; 53677 } 53678 53679 // Pattern: (X86rep_movs:isVoid i64:Other) 53680 // Emits: (REP_MOVSQ:isVoid) 53681 // Pattern complexity = 3 cost = 1 size = 3 53682 if (cast<VTSDNode>(N1)->getVT() == MVT::i64) { 53683 SDNode *Result = Emit_302(N, X86::REP_MOVSQ); 53684 return Result; 53685 } 53686 53687 CannotYetSelect(N); 53688 return NULL; 53689 } 53690 53691 SDNode *Select_X86ISD_REP_STOS(const SDValue &N) { 53692 SDValue Chain = N.getOperand(0); 53693 SDValue N1 = N.getOperand(1); 53694 53695 // Pattern: (X86rep_stos:isVoid i8:Other) 53696 // Emits: (REP_STOSB:isVoid) 53697 // Pattern complexity = 3 cost = 1 size = 3 53698 if (cast<VTSDNode>(N1)->getVT() == MVT::i8) { 53699 SDNode *Result = Emit_302(N, X86::REP_STOSB); 53700 return Result; 53701 } 53702 53703 // Pattern: (X86rep_stos:isVoid i16:Other) 53704 // Emits: (REP_STOSW:isVoid) 53705 // Pattern complexity = 3 cost = 1 size = 3 53706 if (cast<VTSDNode>(N1)->getVT() == MVT::i16) { 53707 SDNode *Result = Emit_302(N, X86::REP_STOSW); 53708 return Result; 53709 } 53710 53711 // Pattern: (X86rep_stos:isVoid i32:Other) 53712 // Emits: (REP_STOSD:isVoid) 53713 // Pattern complexity = 3 cost = 1 size = 3 53714 if (cast<VTSDNode>(N1)->getVT() == MVT::i32) { 53715 SDNode *Result = Emit_302(N, X86::REP_STOSD); 53716 return Result; 53717 } 53718 53719 // Pattern: (X86rep_stos:isVoid i64:Other) 53720 // Emits: (REP_STOSQ:isVoid) 53721 // Pattern complexity = 3 cost = 1 size = 3 53722 if (cast<VTSDNode>(N1)->getVT() == MVT::i64) { 53723 SDNode *Result = Emit_302(N, X86::REP_STOSQ); 53724 return Result; 53725 } 53726 53727 CannotYetSelect(N); 53728 return NULL; 53729 } 53730 53731 SDNode *Emit_303(const SDValue &N, unsigned Opc0, unsigned NumInputRootOps) DISABLE_INLINE { 53732 SDValue Chain = N.getOperand(0); 53733 SDValue N1 = N.getOperand(1); 53734 bool HasInFlag = (N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag); 53735 SmallVector<SDValue, 8> Ops0; 53736 SDValue InFlag(0, 0); 53737 if (HasInFlag) { 53738 InFlag = N.getOperand(N.getNumOperands()-1); 53739 } 53740 for (unsigned i = NumInputRootOps + 1, e = N.getNumOperands()-(HasInFlag?1:0); i != e; ++i) { 53741 Ops0.push_back(N.getOperand(i)); 53742 } 53743 Ops0.push_back(Chain); 53744 if (HasInFlag) 53745 Ops0.push_back(InFlag); 53746 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, &Ops0[0], Ops0.size()); 53747 } 53748 SDNode *Emit_304(const SDValue &N, unsigned Opc0, unsigned NumInputRootOps) DISABLE_INLINE { 53749 SDValue Chain = N.getOperand(0); 53750 SDValue N1 = N.getOperand(1); 53751 bool HasInFlag = (N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag); 53752 SmallVector<SDValue, 8> Ops0; 53753 SDValue Tmp0 = CurDAG->getTargetConstant(((unsigned short) cast<ConstantSDNode>(N1)->getZExtValue()), MVT::i16); 53754 SDValue InFlag(0, 0); 53755 if (HasInFlag) { 53756 InFlag = N.getOperand(N.getNumOperands()-1); 53757 } 53758 Ops0.push_back(Tmp0); 53759 for (unsigned i = NumInputRootOps + 1, e = N.getNumOperands()-(HasInFlag?1:0); i != e; ++i) { 53760 Ops0.push_back(N.getOperand(i)); 53761 } 53762 Ops0.push_back(Chain); 53763 if (HasInFlag) 53764 Ops0.push_back(InFlag); 53765 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, &Ops0[0], Ops0.size()); 53766 } 53767 SDNode *Select_X86ISD_RET_FLAG(const SDValue &N) { 53768 SDValue Chain = N.getOperand(0); 53769 SDValue N1 = N.getOperand(1); 53770 53771 // Pattern: (X86retflag:isVoid 0:i16) 53772 // Emits: (RET:isVoid) 53773 // Pattern complexity = 8 cost = 1 size = 3 53774 { 53775 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 53776 if (Tmp0) { 53777 int64_t CN1 = Tmp0->getSExtValue(); 53778 if (CN1 == INT64_C(0)) { 53779 SDNode *Result = Emit_303(N, X86::RET, 1); 53780 return Result; 53781 } 53782 } 53783 } 53784 53785 // Pattern: (X86retflag:isVoid (imm:i16):$amt) 53786 // Emits: (RETI:isVoid (imm:i16):$amt) 53787 // Pattern complexity = 6 cost = 1 size = 3 53788 if (N1.getOpcode() == ISD::Constant) { 53789 SDNode *Result = Emit_304(N, X86::RETI, 1); 53790 return Result; 53791 } 53792 53793 CannotYetSelect(N); 53794 return NULL; 53795 } 53796 53797 SDNode *Emit_305(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 53798 SDValue N0 = N.getOperand(0); 53799 SDValue N1 = N.getOperand(1); 53800 SDValue Chain = CurDAG->getEntryNode(); 53801 SDValue InFlag(0, 0); 53802 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::EFLAGS, N1, InFlag).getNode(); 53803 Chain = SDValue(ResNode, 0); 53804 InFlag = SDValue(ResNode, 1); 53805 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, InFlag); 53806 } 53807 SDNode *Select_X86ISD_SETCC_i8(const SDValue &N) { 53808 SDValue N0 = N.getOperand(0); 53809 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N0); 53810 if (Tmp0) { 53811 int64_t CN1 = Tmp0->getSExtValue(); 53812 53813 // Pattern: (X86setcc:i8 4:i8, EFLAGS:i32) 53814 // Emits: (SETEr:i8) 53815 // Pattern complexity = 8 cost = 1 size = 3 53816 if (CN1 == INT64_C(4)) { 53817 SDNode *Result = Emit_305(N, X86::SETEr, MVT::i8); 53818 return Result; 53819 } 53820 53821 // Pattern: (X86setcc:i8 9:i8, EFLAGS:i32) 53822 // Emits: (SETNEr:i8) 53823 // Pattern complexity = 8 cost = 1 size = 3 53824 if (CN1 == INT64_C(9)) { 53825 SDNode *Result = Emit_305(N, X86::SETNEr, MVT::i8); 53826 return Result; 53827 } 53828 53829 // Pattern: (X86setcc:i8 7:i8, EFLAGS:i32) 53830 // Emits: (SETLr:i8) 53831 // Pattern complexity = 8 cost = 1 size = 3 53832 if (CN1 == INT64_C(7)) { 53833 SDNode *Result = Emit_305(N, X86::SETLr, MVT::i8); 53834 return Result; 53835 } 53836 53837 // Pattern: (X86setcc:i8 6:i8, EFLAGS:i32) 53838 // Emits: (SETGEr:i8) 53839 // Pattern complexity = 8 cost = 1 size = 3 53840 if (CN1 == INT64_C(6)) { 53841 SDNode *Result = Emit_305(N, X86::SETGEr, MVT::i8); 53842 return Result; 53843 } 53844 53845 // Pattern: (X86setcc:i8 8:i8, EFLAGS:i32) 53846 // Emits: (SETLEr:i8) 53847 // Pattern complexity = 8 cost = 1 size = 3 53848 if (CN1 == INT64_C(8)) { 53849 SDNode *Result = Emit_305(N, X86::SETLEr, MVT::i8); 53850 return Result; 53851 } 53852 53853 // Pattern: (X86setcc:i8 5:i8, EFLAGS:i32) 53854 // Emits: (SETGr:i8) 53855 // Pattern complexity = 8 cost = 1 size = 3 53856 if (CN1 == INT64_C(5)) { 53857 SDNode *Result = Emit_305(N, X86::SETGr, MVT::i8); 53858 return Result; 53859 } 53860 53861 // Pattern: (X86setcc:i8 2:i8, EFLAGS:i32) 53862 // Emits: (SETBr:i8) 53863 // Pattern complexity = 8 cost = 1 size = 3 53864 if (CN1 == INT64_C(2)) { 53865 SDNode *Result = Emit_305(N, X86::SETBr, MVT::i8); 53866 return Result; 53867 } 53868 53869 // Pattern: (X86setcc:i8 1:i8, EFLAGS:i32) 53870 // Emits: (SETAEr:i8) 53871 // Pattern complexity = 8 cost = 1 size = 3 53872 if (CN1 == INT64_C(1)) { 53873 SDNode *Result = Emit_305(N, X86::SETAEr, MVT::i8); 53874 return Result; 53875 } 53876 53877 // Pattern: (X86setcc:i8 3:i8, EFLAGS:i32) 53878 // Emits: (SETBEr:i8) 53879 // Pattern complexity = 8 cost = 1 size = 3 53880 if (CN1 == INT64_C(3)) { 53881 SDNode *Result = Emit_305(N, X86::SETBEr, MVT::i8); 53882 return Result; 53883 } 53884 53885 // Pattern: (X86setcc:i8 0:i8, EFLAGS:i32) 53886 // Emits: (SETAr:i8) 53887 // Pattern complexity = 8 cost = 1 size = 3 53888 if (CN1 == INT64_C(0)) { 53889 SDNode *Result = Emit_305(N, X86::SETAr, MVT::i8); 53890 return Result; 53891 } 53892 53893 // Pattern: (X86setcc:i8 15:i8, EFLAGS:i32) 53894 // Emits: (SETSr:i8) 53895 // Pattern complexity = 8 cost = 1 size = 3 53896 if (CN1 == INT64_C(15)) { 53897 SDNode *Result = Emit_305(N, X86::SETSr, MVT::i8); 53898 return Result; 53899 } 53900 53901 // Pattern: (X86setcc:i8 12:i8, EFLAGS:i32) 53902 // Emits: (SETNSr:i8) 53903 // Pattern complexity = 8 cost = 1 size = 3 53904 if (CN1 == INT64_C(12)) { 53905 SDNode *Result = Emit_305(N, X86::SETNSr, MVT::i8); 53906 return Result; 53907 } 53908 53909 // Pattern: (X86setcc:i8 14:i8, EFLAGS:i32) 53910 // Emits: (SETPr:i8) 53911 // Pattern complexity = 8 cost = 1 size = 3 53912 if (CN1 == INT64_C(14)) { 53913 SDNode *Result = Emit_305(N, X86::SETPr, MVT::i8); 53914 return Result; 53915 } 53916 53917 // Pattern: (X86setcc:i8 11:i8, EFLAGS:i32) 53918 // Emits: (SETNPr:i8) 53919 // Pattern complexity = 8 cost = 1 size = 3 53920 if (CN1 == INT64_C(11)) { 53921 SDNode *Result = Emit_305(N, X86::SETNPr, MVT::i8); 53922 return Result; 53923 } 53924 53925 // Pattern: (X86setcc:i8 13:i8, EFLAGS:i32) 53926 // Emits: (SETOr:i8) 53927 // Pattern complexity = 8 cost = 1 size = 3 53928 if (CN1 == INT64_C(13)) { 53929 SDNode *Result = Emit_305(N, X86::SETOr, MVT::i8); 53930 return Result; 53931 } 53932 53933 // Pattern: (X86setcc:i8 10:i8, EFLAGS:i32) 53934 // Emits: (SETNOr:i8) 53935 // Pattern complexity = 8 cost = 1 size = 3 53936 if (CN1 == INT64_C(10)) { 53937 SDNode *Result = Emit_305(N, X86::SETNOr, MVT::i8); 53938 return Result; 53939 } 53940 } 53941 53942 CannotYetSelect(N); 53943 return NULL; 53944 } 53945 53946 SDNode *Emit_306(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 53947 SDValue N0 = N.getOperand(0); 53948 SDValue N1 = N.getOperand(1); 53949 SDValue N2 = N.getOperand(2); 53950 SDValue Chain = CurDAG->getEntryNode(); 53951 SDValue InFlag(0, 0); 53952 SDNode *ResNode = CurDAG->getCopyToReg(Chain, N.getDebugLoc(), X86::CL, N2, InFlag).getNode(); 53953 Chain = SDValue(ResNode, 0); 53954 InFlag = SDValue(ResNode, 1); 53955 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, N0, N1, InFlag); 53956 } 53957 SDNode *Select_X86ISD_SHLD_i16(const SDValue &N) { 53958 SDValue N0 = N.getOperand(0); 53959 SDValue N1 = N.getOperand(1); 53960 SDValue N2 = N.getOperand(2); 53961 53962 // Pattern: (X86shld:i16 GR16:i16:$src1, GR16:i16:$src2, (imm:i8):$src3) 53963 // Emits: (SHLD16rri8:i16 GR16:i16:$src1, GR16:i16:$src2, (imm:i8):$src3) 53964 // Pattern complexity = 6 cost = 1 size = 3 53965 if (N2.getOpcode() == ISD::Constant && 53966 N2.getNode()->getValueType(0) == MVT::i8) { 53967 SDNode *Result = Emit_287(N, X86::SHLD16rri8, MVT::i16); 53968 return Result; 53969 } 53970 53971 // Pattern: (X86shld:i16 GR16:i16:$src1, GR16:i16:$src2, CL:i8) 53972 // Emits: (SHLD16rrCL:i16 GR16:i16:$src1, GR16:i16:$src2) 53973 // Pattern complexity = 3 cost = 1 size = 3 53974 if (N2.getNode()->getValueType(0) == MVT::i8) { 53975 SDNode *Result = Emit_306(N, X86::SHLD16rrCL, MVT::i16); 53976 return Result; 53977 } 53978 53979 CannotYetSelect(N); 53980 return NULL; 53981 } 53982 53983 SDNode *Select_X86ISD_SHLD_i32(const SDValue &N) { 53984 SDValue N0 = N.getOperand(0); 53985 SDValue N1 = N.getOperand(1); 53986 SDValue N2 = N.getOperand(2); 53987 53988 // Pattern: (X86shld:i32 GR32:i32:$src1, GR32:i32:$src2, (imm:i8):$src3) 53989 // Emits: (SHLD32rri8:i32 GR32:i32:$src1, GR32:i32:$src2, (imm:i8):$src3) 53990 // Pattern complexity = 6 cost = 1 size = 3 53991 if (N2.getOpcode() == ISD::Constant && 53992 N2.getNode()->getValueType(0) == MVT::i8) { 53993 SDNode *Result = Emit_287(N, X86::SHLD32rri8, MVT::i32); 53994 return Result; 53995 } 53996 53997 // Pattern: (X86shld:i32 GR32:i32:$src1, GR32:i32:$src2, CL:i8) 53998 // Emits: (SHLD32rrCL:i32 GR32:i32:$src1, GR32:i32:$src2) 53999 // Pattern complexity = 3 cost = 1 size = 3 54000 if (N2.getNode()->getValueType(0) == MVT::i8) { 54001 SDNode *Result = Emit_306(N, X86::SHLD32rrCL, MVT::i32); 54002 return Result; 54003 } 54004 54005 CannotYetSelect(N); 54006 return NULL; 54007 } 54008 54009 SDNode *Select_X86ISD_SHLD_i64(const SDValue &N) { 54010 SDValue N0 = N.getOperand(0); 54011 SDValue N1 = N.getOperand(1); 54012 SDValue N2 = N.getOperand(2); 54013 54014 // Pattern: (X86shld:i64 GR64:i64:$src1, GR64:i64:$src2, (imm:i8):$src3) 54015 // Emits: (SHLD64rri8:i64 GR64:i64:$src1, GR64:i64:$src2, (imm:i8):$src3) 54016 // Pattern complexity = 6 cost = 1 size = 3 54017 if (N2.getOpcode() == ISD::Constant && 54018 N2.getNode()->getValueType(0) == MVT::i8) { 54019 SDNode *Result = Emit_287(N, X86::SHLD64rri8, MVT::i64); 54020 return Result; 54021 } 54022 54023 // Pattern: (X86shld:i64 GR64:i64:$src1, GR64:i64:$src2, CL:i8) 54024 // Emits: (SHLD64rrCL:i64 GR64:i64:$src1, GR64:i64:$src2) 54025 // Pattern complexity = 3 cost = 1 size = 3 54026 if (N2.getNode()->getValueType(0) == MVT::i8) { 54027 SDNode *Result = Emit_306(N, X86::SHLD64rrCL, MVT::i64); 54028 return Result; 54029 } 54030 54031 CannotYetSelect(N); 54032 return NULL; 54033 } 54034 54035 SDNode *Select_X86ISD_SHRD_i16(const SDValue &N) { 54036 SDValue N0 = N.getOperand(0); 54037 SDValue N1 = N.getOperand(1); 54038 SDValue N2 = N.getOperand(2); 54039 54040 // Pattern: (X86shrd:i16 GR16:i16:$src1, GR16:i16:$src2, (imm:i8):$src3) 54041 // Emits: (SHRD16rri8:i16 GR16:i16:$src1, GR16:i16:$src2, (imm:i8):$src3) 54042 // Pattern complexity = 6 cost = 1 size = 3 54043 if (N2.getOpcode() == ISD::Constant && 54044 N2.getNode()->getValueType(0) == MVT::i8) { 54045 SDNode *Result = Emit_287(N, X86::SHRD16rri8, MVT::i16); 54046 return Result; 54047 } 54048 54049 // Pattern: (X86shrd:i16 GR16:i16:$src1, GR16:i16:$src2, CL:i8) 54050 // Emits: (SHRD16rrCL:i16 GR16:i16:$src1, GR16:i16:$src2) 54051 // Pattern complexity = 3 cost = 1 size = 3 54052 if (N2.getNode()->getValueType(0) == MVT::i8) { 54053 SDNode *Result = Emit_306(N, X86::SHRD16rrCL, MVT::i16); 54054 return Result; 54055 } 54056 54057 CannotYetSelect(N); 54058 return NULL; 54059 } 54060 54061 SDNode *Select_X86ISD_SHRD_i32(const SDValue &N) { 54062 SDValue N0 = N.getOperand(0); 54063 SDValue N1 = N.getOperand(1); 54064 SDValue N2 = N.getOperand(2); 54065 54066 // Pattern: (X86shrd:i32 GR32:i32:$src1, GR32:i32:$src2, (imm:i8):$src3) 54067 // Emits: (SHRD32rri8:i32 GR32:i32:$src1, GR32:i32:$src2, (imm:i8):$src3) 54068 // Pattern complexity = 6 cost = 1 size = 3 54069 if (N2.getOpcode() == ISD::Constant && 54070 N2.getNode()->getValueType(0) == MVT::i8) { 54071 SDNode *Result = Emit_287(N, X86::SHRD32rri8, MVT::i32); 54072 return Result; 54073 } 54074 54075 // Pattern: (X86shrd:i32 GR32:i32:$src1, GR32:i32:$src2, CL:i8) 54076 // Emits: (SHRD32rrCL:i32 GR32:i32:$src1, GR32:i32:$src2) 54077 // Pattern complexity = 3 cost = 1 size = 3 54078 if (N2.getNode()->getValueType(0) == MVT::i8) { 54079 SDNode *Result = Emit_306(N, X86::SHRD32rrCL, MVT::i32); 54080 return Result; 54081 } 54082 54083 CannotYetSelect(N); 54084 return NULL; 54085 } 54086 54087 SDNode *Select_X86ISD_SHRD_i64(const SDValue &N) { 54088 SDValue N0 = N.getOperand(0); 54089 SDValue N1 = N.getOperand(1); 54090 SDValue N2 = N.getOperand(2); 54091 54092 // Pattern: (X86shrd:i64 GR64:i64:$src1, GR64:i64:$src2, (imm:i8):$src3) 54093 // Emits: (SHRD64rri8:i64 GR64:i64:$src1, GR64:i64:$src2, (imm:i8):$src3) 54094 // Pattern complexity = 6 cost = 1 size = 3 54095 if (N2.getOpcode() == ISD::Constant && 54096 N2.getNode()->getValueType(0) == MVT::i8) { 54097 SDNode *Result = Emit_287(N, X86::SHRD64rri8, MVT::i64); 54098 return Result; 54099 } 54100 54101 // Pattern: (X86shrd:i64 GR64:i64:$src1, GR64:i64:$src2, CL:i8) 54102 // Emits: (SHRD64rrCL:i64 GR64:i64:$src1, GR64:i64:$src2) 54103 // Pattern complexity = 3 cost = 1 size = 3 54104 if (N2.getNode()->getValueType(0) == MVT::i8) { 54105 SDNode *Result = Emit_306(N, X86::SHRD64rrCL, MVT::i64); 54106 return Result; 54107 } 54108 54109 CannotYetSelect(N); 54110 return NULL; 54111 } 54112 54113 SDNode *Emit_307(const SDValue &N, unsigned Opc0, EVT VT0) DISABLE_INLINE { 54114 SDValue N0 = N.getOperand(0); 54115 SDValue N1 = N.getOperand(1); 54116 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::i32, N0, N0); 54117 } 54118 SDNode *Select_X86ISD_SMUL_i16(const SDValue &N) { 54119 if (OptLevel != CodeGenOpt::None) { 54120 SDValue N0 = N.getOperand(0); 54121 if (N0.getOpcode() == ISD::LOAD && 54122 N0.hasOneUse() && 54123 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 54124 SDValue Chain0 = N0.getOperand(0); 54125 if (Predicate_unindexedload(N0.getNode()) && 54126 Predicate_loadi16(N0.getNode())) { 54127 SDValue N01 = N0.getOperand(1); 54128 SDValue CPTmpN01_0; 54129 SDValue CPTmpN01_1; 54130 SDValue CPTmpN01_2; 54131 SDValue CPTmpN01_3; 54132 SDValue CPTmpN01_4; 54133 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 54134 SDValue N1 = N.getOperand(1); 54135 if (N1.getOpcode() == ISD::Constant) { 54136 54137 // Pattern: (X86smul_flag:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 54138 // Emits: (IMUL16rmi8:i16 addr:iPTR:$src1, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 54139 // Pattern complexity = 29 cost = 1 size = 3 54140 if (Predicate_i16immSExt8(N1.getNode())) { 54141 SDNode *Result = Emit_145(N, X86::IMUL16rmi8, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 54142 return Result; 54143 } 54144 54145 // Pattern: (X86smul_flag:i16 (ld:i16 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>, (imm:i16):$src2) 54146 // Emits: (IMUL16rmi:i16 addr:iPTR:$src1, (imm:i16):$src2) 54147 // Pattern complexity = 28 cost = 1 size = 3 54148 SDNode *Result = Emit_145(N, X86::IMUL16rmi, MVT::i16, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 54149 return Result; 54150 } 54151 } 54152 } 54153 } 54154 54155 // Pattern: (X86smul_flag:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>) 54156 // Emits: (IMUL16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 54157 // Pattern complexity = 25 cost = 1 size = 3 54158 SDValue N1 = N.getOperand(1); 54159 if (N1.getOpcode() == ISD::LOAD && 54160 N1.hasOneUse() && 54161 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 54162 SDValue Chain1 = N1.getOperand(0); 54163 if (Predicate_unindexedload(N1.getNode()) && 54164 Predicate_loadi16(N1.getNode())) { 54165 SDValue N11 = N1.getOperand(1); 54166 SDValue CPTmpN11_0; 54167 SDValue CPTmpN11_1; 54168 SDValue CPTmpN11_2; 54169 SDValue CPTmpN11_3; 54170 SDValue CPTmpN11_4; 54171 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 54172 SDNode *Result = Emit_2(N, X86::IMUL16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 54173 return Result; 54174 } 54175 } 54176 } 54177 } 54178 { 54179 SDValue N0 = N.getOperand(0); 54180 SDValue N1 = N.getOperand(1); 54181 54182 // Pattern: (X86smul_flag:i16 GR16:i16:$src1, 2:i16) 54183 // Emits: (ADD16rr:i16 GR16:i16:$src1, GR16:i16:$src1) 54184 // Pattern complexity = 10 cost = 1 size = 3 54185 { 54186 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 54187 if (Tmp0) { 54188 int64_t CN1 = Tmp0->getSExtValue(); 54189 if (CN1 == INT64_C(2)) { 54190 SDNode *Result = Emit_307(N, X86::ADD16rr, MVT::i16); 54191 return Result; 54192 } 54193 } 54194 } 54195 if (N1.getOpcode() == ISD::Constant) { 54196 54197 // Pattern: (X86smul_flag:i16 GR16:i16:$src1, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 54198 // Emits: (IMUL16rri8:i16 GR16:i16:$src1, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 54199 // Pattern complexity = 7 cost = 1 size = 3 54200 if (Predicate_i16immSExt8(N1.getNode())) { 54201 SDNode *Result = Emit_5(N, X86::IMUL16rri8, MVT::i16); 54202 return Result; 54203 } 54204 54205 // Pattern: (X86smul_flag:i16 GR16:i16:$src1, (imm:i16):$src2) 54206 // Emits: (IMUL16rri:i16 GR16:i16:$src1, (imm:i16):$src2) 54207 // Pattern complexity = 6 cost = 1 size = 3 54208 SDNode *Result = Emit_5(N, X86::IMUL16rri, MVT::i16); 54209 return Result; 54210 } 54211 } 54212 54213 // Pattern: (X86smul_flag:i16 GR16:i16:$src1, GR16:i16:$src2) 54214 // Emits: (IMUL16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 54215 // Pattern complexity = 3 cost = 1 size = 3 54216 SDNode *Result = Emit_1(N, X86::IMUL16rr, MVT::i16); 54217 return Result; 54218 } 54219 54220 SDNode *Select_X86ISD_SMUL_i32(const SDValue &N) { 54221 if (OptLevel != CodeGenOpt::None) { 54222 SDValue N0 = N.getOperand(0); 54223 if (N0.getOpcode() == ISD::LOAD && 54224 N0.hasOneUse() && 54225 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 54226 SDValue Chain0 = N0.getOperand(0); 54227 if (Predicate_unindexedload(N0.getNode()) && 54228 Predicate_loadi32(N0.getNode())) { 54229 SDValue N01 = N0.getOperand(1); 54230 SDValue CPTmpN01_0; 54231 SDValue CPTmpN01_1; 54232 SDValue CPTmpN01_2; 54233 SDValue CPTmpN01_3; 54234 SDValue CPTmpN01_4; 54235 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 54236 SDValue N1 = N.getOperand(1); 54237 if (N1.getOpcode() == ISD::Constant) { 54238 54239 // Pattern: (X86smul_flag:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 54240 // Emits: (IMUL32rmi8:i32 addr:iPTR:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 54241 // Pattern complexity = 29 cost = 1 size = 3 54242 if (Predicate_i32immSExt8(N1.getNode())) { 54243 SDNode *Result = Emit_146(N, X86::IMUL32rmi8, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 54244 return Result; 54245 } 54246 54247 // Pattern: (X86smul_flag:i32 (ld:i32 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>, (imm:i32):$src2) 54248 // Emits: (IMUL32rmi:i32 addr:iPTR:$src1, (imm:i32):$src2) 54249 // Pattern complexity = 28 cost = 1 size = 3 54250 SDNode *Result = Emit_146(N, X86::IMUL32rmi, MVT::i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 54251 return Result; 54252 } 54253 } 54254 } 54255 } 54256 54257 // Pattern: (X86smul_flag:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>) 54258 // Emits: (IMUL32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 54259 // Pattern complexity = 25 cost = 1 size = 3 54260 SDValue N1 = N.getOperand(1); 54261 if (N1.getOpcode() == ISD::LOAD && 54262 N1.hasOneUse() && 54263 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 54264 SDValue Chain1 = N1.getOperand(0); 54265 if (Predicate_unindexedload(N1.getNode()) && 54266 Predicate_loadi32(N1.getNode())) { 54267 SDValue N11 = N1.getOperand(1); 54268 SDValue CPTmpN11_0; 54269 SDValue CPTmpN11_1; 54270 SDValue CPTmpN11_2; 54271 SDValue CPTmpN11_3; 54272 SDValue CPTmpN11_4; 54273 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 54274 SDNode *Result = Emit_2(N, X86::IMUL32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 54275 return Result; 54276 } 54277 } 54278 } 54279 } 54280 { 54281 SDValue N0 = N.getOperand(0); 54282 SDValue N1 = N.getOperand(1); 54283 54284 // Pattern: (X86smul_flag:i32 GR32:i32:$src1, 2:i32) 54285 // Emits: (ADD32rr:i32 GR32:i32:$src1, GR32:i32:$src1) 54286 // Pattern complexity = 10 cost = 1 size = 3 54287 { 54288 ConstantSDNode *Tmp0 = dyn_cast<ConstantSDNode>(N1); 54289 if (Tmp0) { 54290 int64_t CN1 = Tmp0->getSExtValue(); 54291 if (CN1 == INT64_C(2)) { 54292 SDNode *Result = Emit_307(N, X86::ADD32rr, MVT::i32); 54293 return Result; 54294 } 54295 } 54296 } 54297 if (N1.getOpcode() == ISD::Constant) { 54298 54299 // Pattern: (X86smul_flag:i32 GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 54300 // Emits: (IMUL32rri8:i32 GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 54301 // Pattern complexity = 7 cost = 1 size = 3 54302 if (Predicate_i32immSExt8(N1.getNode())) { 54303 SDNode *Result = Emit_8(N, X86::IMUL32rri8, MVT::i32); 54304 return Result; 54305 } 54306 54307 // Pattern: (X86smul_flag:i32 GR32:i32:$src1, (imm:i32):$src2) 54308 // Emits: (IMUL32rri:i32 GR32:i32:$src1, (imm:i32):$src2) 54309 // Pattern complexity = 6 cost = 1 size = 3 54310 SDNode *Result = Emit_8(N, X86::IMUL32rri, MVT::i32); 54311 return Result; 54312 } 54313 } 54314 54315 // Pattern: (X86smul_flag:i32 GR32:i32:$src1, GR32:i32:$src2) 54316 // Emits: (IMUL32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 54317 // Pattern complexity = 3 cost = 1 size = 3 54318 SDNode *Result = Emit_1(N, X86::IMUL32rr, MVT::i32); 54319 return Result; 54320 } 54321 54322 SDNode *Select_X86ISD_SMUL_i64(const SDValue &N) { 54323 if (OptLevel != CodeGenOpt::None) { 54324 SDValue N0 = N.getOperand(0); 54325 if (N0.getOpcode() == ISD::LOAD && 54326 N0.hasOneUse() && 54327 IsLegalAndProfitableToFold(N0.getNode(), N.getNode(), N.getNode())) { 54328 SDValue Chain0 = N0.getOperand(0); 54329 if (Predicate_unindexedload(N0.getNode()) && 54330 Predicate_load(N0.getNode()) && 54331 Predicate_loadi64(N0.getNode())) { 54332 SDValue N01 = N0.getOperand(1); 54333 SDValue CPTmpN01_0; 54334 SDValue CPTmpN01_1; 54335 SDValue CPTmpN01_2; 54336 SDValue CPTmpN01_3; 54337 SDValue CPTmpN01_4; 54338 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 54339 SDValue N1 = N.getOperand(1); 54340 if (N1.getOpcode() == ISD::Constant) { 54341 54342 // Pattern: (X86smul_flag:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 54343 // Emits: (IMUL64rmi8:i64 addr:iPTR:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 54344 // Pattern complexity = 29 cost = 1 size = 3 54345 if (Predicate_i64immSExt8(N1.getNode())) { 54346 SDNode *Result = Emit_147(N, X86::IMUL64rmi8, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 54347 return Result; 54348 } 54349 54350 // Pattern: (X86smul_flag:i64 (ld:i64 addr:iPTR:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 54351 // Emits: (IMUL64rmi32:i64 addr:iPTR:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 54352 // Pattern complexity = 29 cost = 1 size = 3 54353 if (Predicate_i64immSExt32(N1.getNode())) { 54354 SDNode *Result = Emit_147(N, X86::IMUL64rmi32, MVT::i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 54355 return Result; 54356 } 54357 } 54358 } 54359 } 54360 } 54361 54362 // Pattern: (X86smul_flag:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>) 54363 // Emits: (IMUL64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 54364 // Pattern complexity = 25 cost = 1 size = 3 54365 SDValue N1 = N.getOperand(1); 54366 if (N1.getOpcode() == ISD::LOAD && 54367 N1.hasOneUse() && 54368 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 54369 SDValue Chain1 = N1.getOperand(0); 54370 if (Predicate_unindexedload(N1.getNode()) && 54371 Predicate_load(N1.getNode()) && 54372 Predicate_loadi64(N1.getNode())) { 54373 SDValue N11 = N1.getOperand(1); 54374 SDValue CPTmpN11_0; 54375 SDValue CPTmpN11_1; 54376 SDValue CPTmpN11_2; 54377 SDValue CPTmpN11_3; 54378 SDValue CPTmpN11_4; 54379 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 54380 SDNode *Result = Emit_2(N, X86::IMUL64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 54381 return Result; 54382 } 54383 } 54384 } 54385 } 54386 { 54387 SDValue N0 = N.getOperand(0); 54388 SDValue N1 = N.getOperand(1); 54389 if (N1.getOpcode() == ISD::Constant) { 54390 54391 // Pattern: (X86smul_flag:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 54392 // Emits: (IMUL64rri8:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 54393 // Pattern complexity = 7 cost = 1 size = 3 54394 if (Predicate_i64immSExt8(N1.getNode())) { 54395 SDNode *Result = Emit_12(N, X86::IMUL64rri8, MVT::i64); 54396 return Result; 54397 } 54398 54399 // Pattern: (X86smul_flag:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 54400 // Emits: (IMUL64rri32:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 54401 // Pattern complexity = 7 cost = 1 size = 3 54402 if (Predicate_i64immSExt32(N1.getNode())) { 54403 SDNode *Result = Emit_12(N, X86::IMUL64rri32, MVT::i64); 54404 return Result; 54405 } 54406 } 54407 } 54408 54409 // Pattern: (X86smul_flag:i64 GR64:i64:$src1, GR64:i64:$src2) 54410 // Emits: (IMUL64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 54411 // Pattern complexity = 3 cost = 1 size = 3 54412 SDNode *Result = Emit_1(N, X86::IMUL64rr, MVT::i64); 54413 return Result; 54414 } 54415 54416 SDNode *Select_X86ISD_SUB_i8(const SDValue &N) { 54417 54418 // Pattern: (X86sub_flag:i8 GR8:i8:$src1, (ld:i8 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi8>>) 54419 // Emits: (SUB8rm:i8 GR8:i8:$src1, addr:iPTR:$src2) 54420 // Pattern complexity = 25 cost = 1 size = 3 54421 if (OptLevel != CodeGenOpt::None) { 54422 SDValue N0 = N.getOperand(0); 54423 SDValue N1 = N.getOperand(1); 54424 if (N1.getOpcode() == ISD::LOAD && 54425 N1.hasOneUse() && 54426 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 54427 SDValue Chain1 = N1.getOperand(0); 54428 if (Predicate_unindexedload(N1.getNode()) && 54429 Predicate_load(N1.getNode()) && 54430 Predicate_loadi8(N1.getNode())) { 54431 SDValue N11 = N1.getOperand(1); 54432 SDValue CPTmpN11_0; 54433 SDValue CPTmpN11_1; 54434 SDValue CPTmpN11_2; 54435 SDValue CPTmpN11_3; 54436 SDValue CPTmpN11_4; 54437 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 54438 SDNode *Result = Emit_2(N, X86::SUB8rm, MVT::i8, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 54439 return Result; 54440 } 54441 } 54442 } 54443 } 54444 54445 // Pattern: (X86sub_flag:i8 GR8:i8:$src1, (imm:i8):$src2) 54446 // Emits: (SUB8ri:i8 GR8:i8:$src1, (imm:i8):$src2) 54447 // Pattern complexity = 6 cost = 1 size = 3 54448 { 54449 SDValue N0 = N.getOperand(0); 54450 SDValue N1 = N.getOperand(1); 54451 if (N1.getOpcode() == ISD::Constant) { 54452 SDNode *Result = Emit_3(N, X86::SUB8ri, MVT::i8); 54453 return Result; 54454 } 54455 } 54456 54457 // Pattern: (X86sub_flag:i8 GR8:i8:$src1, GR8:i8:$src2) 54458 // Emits: (SUB8rr:i8 GR8:i8:$src1, GR8:i8:$src2) 54459 // Pattern complexity = 3 cost = 1 size = 3 54460 SDNode *Result = Emit_1(N, X86::SUB8rr, MVT::i8); 54461 return Result; 54462 } 54463 54464 SDNode *Select_X86ISD_SUB_i16(const SDValue &N) { 54465 54466 // Pattern: (X86sub_flag:i16 GR16:i16:$src1, (ld:i16 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi16>>) 54467 // Emits: (SUB16rm:i16 GR16:i16:$src1, addr:iPTR:$src2) 54468 // Pattern complexity = 25 cost = 1 size = 3 54469 if (OptLevel != CodeGenOpt::None) { 54470 SDValue N0 = N.getOperand(0); 54471 SDValue N1 = N.getOperand(1); 54472 if (N1.getOpcode() == ISD::LOAD && 54473 N1.hasOneUse() && 54474 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 54475 SDValue Chain1 = N1.getOperand(0); 54476 if (Predicate_unindexedload(N1.getNode()) && 54477 Predicate_loadi16(N1.getNode())) { 54478 SDValue N11 = N1.getOperand(1); 54479 SDValue CPTmpN11_0; 54480 SDValue CPTmpN11_1; 54481 SDValue CPTmpN11_2; 54482 SDValue CPTmpN11_3; 54483 SDValue CPTmpN11_4; 54484 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 54485 SDNode *Result = Emit_2(N, X86::SUB16rm, MVT::i16, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 54486 return Result; 54487 } 54488 } 54489 } 54490 } 54491 { 54492 SDValue N0 = N.getOperand(0); 54493 SDValue N1 = N.getOperand(1); 54494 if (N1.getOpcode() == ISD::Constant) { 54495 54496 // Pattern: (X86sub_flag:i16 GR16:i16:$src1, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 54497 // Emits: (SUB16ri8:i16 GR16:i16:$src1, (imm:i16)<<P:Predicate_i16immSExt8>>:$src2) 54498 // Pattern complexity = 7 cost = 1 size = 3 54499 if (Predicate_i16immSExt8(N1.getNode())) { 54500 SDNode *Result = Emit_5(N, X86::SUB16ri8, MVT::i16); 54501 return Result; 54502 } 54503 54504 // Pattern: (X86sub_flag:i16 GR16:i16:$src1, (imm:i16):$src2) 54505 // Emits: (SUB16ri:i16 GR16:i16:$src1, (imm:i16):$src2) 54506 // Pattern complexity = 6 cost = 1 size = 3 54507 SDNode *Result = Emit_5(N, X86::SUB16ri, MVT::i16); 54508 return Result; 54509 } 54510 } 54511 54512 // Pattern: (X86sub_flag:i16 GR16:i16:$src1, GR16:i16:$src2) 54513 // Emits: (SUB16rr:i16 GR16:i16:$src1, GR16:i16:$src2) 54514 // Pattern complexity = 3 cost = 1 size = 3 54515 SDNode *Result = Emit_1(N, X86::SUB16rr, MVT::i16); 54516 return Result; 54517 } 54518 54519 SDNode *Select_X86ISD_SUB_i32(const SDValue &N) { 54520 54521 // Pattern: (X86sub_flag:i32 GR32:i32:$src1, (ld:i32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>) 54522 // Emits: (SUB32rm:i32 GR32:i32:$src1, addr:iPTR:$src2) 54523 // Pattern complexity = 25 cost = 1 size = 3 54524 if (OptLevel != CodeGenOpt::None) { 54525 SDValue N0 = N.getOperand(0); 54526 SDValue N1 = N.getOperand(1); 54527 if (N1.getOpcode() == ISD::LOAD && 54528 N1.hasOneUse() && 54529 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 54530 SDValue Chain1 = N1.getOperand(0); 54531 if (Predicate_unindexedload(N1.getNode()) && 54532 Predicate_loadi32(N1.getNode())) { 54533 SDValue N11 = N1.getOperand(1); 54534 SDValue CPTmpN11_0; 54535 SDValue CPTmpN11_1; 54536 SDValue CPTmpN11_2; 54537 SDValue CPTmpN11_3; 54538 SDValue CPTmpN11_4; 54539 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 54540 SDNode *Result = Emit_2(N, X86::SUB32rm, MVT::i32, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 54541 return Result; 54542 } 54543 } 54544 } 54545 } 54546 { 54547 SDValue N0 = N.getOperand(0); 54548 SDValue N1 = N.getOperand(1); 54549 if (N1.getOpcode() == ISD::Constant) { 54550 54551 // Pattern: (X86sub_flag:i32 GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 54552 // Emits: (SUB32ri8:i32 GR32:i32:$src1, (imm:i32)<<P:Predicate_i32immSExt8>>:$src2) 54553 // Pattern complexity = 7 cost = 1 size = 3 54554 if (Predicate_i32immSExt8(N1.getNode())) { 54555 SDNode *Result = Emit_8(N, X86::SUB32ri8, MVT::i32); 54556 return Result; 54557 } 54558 54559 // Pattern: (X86sub_flag:i32 GR32:i32:$src1, (imm:i32):$src2) 54560 // Emits: (SUB32ri:i32 GR32:i32:$src1, (imm:i32):$src2) 54561 // Pattern complexity = 6 cost = 1 size = 3 54562 SDNode *Result = Emit_8(N, X86::SUB32ri, MVT::i32); 54563 return Result; 54564 } 54565 } 54566 54567 // Pattern: (X86sub_flag:i32 GR32:i32:$src1, GR32:i32:$src2) 54568 // Emits: (SUB32rr:i32 GR32:i32:$src1, GR32:i32:$src2) 54569 // Pattern complexity = 3 cost = 1 size = 3 54570 SDNode *Result = Emit_1(N, X86::SUB32rr, MVT::i32); 54571 return Result; 54572 } 54573 54574 SDNode *Select_X86ISD_SUB_i64(const SDValue &N) { 54575 54576 // Pattern: (X86sub_flag:i64 GR64:i64:$src1, (ld:i64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>) 54577 // Emits: (SUB64rm:i64 GR64:i64:$src1, addr:iPTR:$src2) 54578 // Pattern complexity = 25 cost = 1 size = 3 54579 if (OptLevel != CodeGenOpt::None) { 54580 SDValue N0 = N.getOperand(0); 54581 SDValue N1 = N.getOperand(1); 54582 if (N1.getOpcode() == ISD::LOAD && 54583 N1.hasOneUse() && 54584 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 54585 SDValue Chain1 = N1.getOperand(0); 54586 if (Predicate_unindexedload(N1.getNode()) && 54587 Predicate_load(N1.getNode()) && 54588 Predicate_loadi64(N1.getNode())) { 54589 SDValue N11 = N1.getOperand(1); 54590 SDValue CPTmpN11_0; 54591 SDValue CPTmpN11_1; 54592 SDValue CPTmpN11_2; 54593 SDValue CPTmpN11_3; 54594 SDValue CPTmpN11_4; 54595 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4)) { 54596 SDNode *Result = Emit_2(N, X86::SUB64rm, MVT::i64, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 54597 return Result; 54598 } 54599 } 54600 } 54601 } 54602 { 54603 SDValue N0 = N.getOperand(0); 54604 SDValue N1 = N.getOperand(1); 54605 if (N1.getOpcode() == ISD::Constant) { 54606 54607 // Pattern: (X86sub_flag:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 54608 // Emits: (SUB64ri8:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt8>>:$src2) 54609 // Pattern complexity = 7 cost = 1 size = 3 54610 if (Predicate_i64immSExt8(N1.getNode())) { 54611 SDNode *Result = Emit_12(N, X86::SUB64ri8, MVT::i64); 54612 return Result; 54613 } 54614 54615 // Pattern: (X86sub_flag:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 54616 // Emits: (SUB64ri32:i64 GR64:i64:$src1, (imm:i64)<<P:Predicate_i64immSExt32>>:$src2) 54617 // Pattern complexity = 7 cost = 1 size = 3 54618 if (Predicate_i64immSExt32(N1.getNode())) { 54619 SDNode *Result = Emit_12(N, X86::SUB64ri32, MVT::i64); 54620 return Result; 54621 } 54622 } 54623 } 54624 54625 // Pattern: (X86sub_flag:i64 GR64:i64:$src1, GR64:i64:$src2) 54626 // Emits: (SUB64rr:i64 GR64:i64:$src1, GR64:i64:$src2) 54627 // Pattern complexity = 3 cost = 1 size = 3 54628 SDNode *Result = Emit_1(N, X86::SUB64rr, MVT::i64); 54629 return Result; 54630 } 54631 54632 SDNode *Emit_308(const SDValue &N, unsigned Opc0, unsigned NumInputRootOps) DISABLE_INLINE { 54633 SDValue Chain = N.getOperand(0); 54634 SDValue N1 = N.getOperand(1); 54635 SDValue N2 = N.getOperand(2); 54636 bool HasInFlag = (N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag); 54637 SmallVector<SDValue, 8> Ops0; 54638 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N2)->getZExtValue()), MVT::i32); 54639 SDValue InFlag(0, 0); 54640 if (HasInFlag) { 54641 InFlag = N.getOperand(N.getNumOperands()-1); 54642 } 54643 Ops0.push_back(N1); 54644 Ops0.push_back(Tmp1); 54645 for (unsigned i = NumInputRootOps + 1, e = N.getNumOperands()-(HasInFlag?1:0); i != e; ++i) { 54646 Ops0.push_back(N.getOperand(i)); 54647 } 54648 Ops0.push_back(Chain); 54649 if (HasInFlag) 54650 Ops0.push_back(InFlag); 54651 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, &Ops0[0], Ops0.size()); 54652 } 54653 SDNode *Select_X86ISD_TC_RETURN(const SDValue &N) { 54654 SDValue Chain = N.getOperand(0); 54655 SDValue N1 = N.getOperand(1); 54656 54657 // Pattern: (X86tcret:isVoid (tglobaladdr:i64):$dst, (imm:i32):$off) 54658 // Emits: (TCRETURNdi64:isVoid (texternalsym:i64):$dst, (imm:i32):$off) 54659 // Pattern complexity = 9 cost = 1 size = 3 54660 if (N1.getOpcode() == ISD::TargetGlobalAddress) { 54661 SDValue N2 = N.getOperand(2); 54662 if (N2.getOpcode() == ISD::Constant && 54663 N1.getNode()->getValueType(0) == MVT::i64) { 54664 SDNode *Result = Emit_308(N, X86::TCRETURNdi64, 2); 54665 return Result; 54666 } 54667 } 54668 54669 // Pattern: (X86tcret:isVoid (texternalsym:i64):$dst, (imm:i32):$off) 54670 // Emits: (TCRETURNdi64:isVoid (texternalsym:i64):$dst, (imm:i32):$off) 54671 // Pattern complexity = 9 cost = 1 size = 3 54672 if (N1.getOpcode() == ISD::TargetExternalSymbol) { 54673 SDValue N2 = N.getOperand(2); 54674 if (N2.getOpcode() == ISD::Constant && 54675 N1.getNode()->getValueType(0) == MVT::i64) { 54676 SDNode *Result = Emit_308(N, X86::TCRETURNdi64, 2); 54677 return Result; 54678 } 54679 } 54680 54681 // Pattern: (X86tcret:isVoid (tglobaladdr:i32):$dst, (imm:i32):$off) 54682 // Emits: (TCRETURNdi:isVoid (texternalsym:i32):$dst, (imm:i32):$off) 54683 // Pattern complexity = 9 cost = 1 size = 3 54684 if (N1.getOpcode() == ISD::TargetGlobalAddress) { 54685 SDValue N2 = N.getOperand(2); 54686 if (N2.getOpcode() == ISD::Constant && 54687 N1.getNode()->getValueType(0) == MVT::i32) { 54688 SDNode *Result = Emit_308(N, X86::TCRETURNdi, 2); 54689 return Result; 54690 } 54691 } 54692 54693 // Pattern: (X86tcret:isVoid (texternalsym:i32):$dst, (imm:i32):$off) 54694 // Emits: (TCRETURNdi:isVoid (texternalsym:i32):$dst, (imm:i32):$off) 54695 // Pattern complexity = 9 cost = 1 size = 3 54696 if (N1.getOpcode() == ISD::TargetExternalSymbol) { 54697 SDValue N2 = N.getOperand(2); 54698 if (N2.getOpcode() == ISD::Constant && 54699 N1.getNode()->getValueType(0) == MVT::i32) { 54700 SDNode *Result = Emit_308(N, X86::TCRETURNdi, 2); 54701 return Result; 54702 } 54703 } 54704 SDValue N2 = N.getOperand(2); 54705 if (N2.getOpcode() == ISD::Constant) { 54706 54707 // Pattern: (X86tcret:isVoid GR64:i64:$dst, (imm:i32):$off) 54708 // Emits: (TCRETURNri64:isVoid GR64:i64:$dst, (imm:i32):$off) 54709 // Pattern complexity = 6 cost = 1 size = 3 54710 if (N1.getNode()->getValueType(0) == MVT::i64) { 54711 SDNode *Result = Emit_308(N, X86::TCRETURNri64, 2); 54712 return Result; 54713 } 54714 54715 // Pattern: (X86tcret:isVoid GR32:i32:$dst, (imm:i32):$off) 54716 // Emits: (TCRETURNri:isVoid GR32:i32:$dst, (imm:i32):$off) 54717 // Pattern complexity = 6 cost = 1 size = 3 54718 if (N1.getNode()->getValueType(0) == MVT::i32) { 54719 SDNode *Result = Emit_308(N, X86::TCRETURNri, 2); 54720 return Result; 54721 } 54722 } 54723 54724 CannotYetSelect(N); 54725 return NULL; 54726 } 54727 54728 SDNode *Emit_309(const SDValue &N, unsigned Opc0, SDValue &CPTmpN1_0, SDValue &CPTmpN1_1, SDValue &CPTmpN1_2, SDValue &CPTmpN1_3) DISABLE_INLINE { 54729 SDValue Chain = N.getOperand(0); 54730 SDValue N1 = N.getOperand(1); 54731 bool HasInFlag = (N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag); 54732 SDValue InFlag(0, 0); 54733 if (HasInFlag) { 54734 InFlag = N.getOperand(N.getNumOperands()-1); 54735 } 54736 SDValue Ops0[] = { CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, Chain, InFlag }; 54737 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, MVT::Flag, Ops0, HasInFlag ? 6 : 5); 54738 Chain = SDValue(ResNode, 0); 54739 InFlag = SDValue(ResNode, 1); 54740 const SDValue Froms[] = { 54741 SDValue(N.getNode(), 1), 54742 SDValue(N.getNode(), 0) 54743 }; 54744 const SDValue Tos[] = { 54745 InFlag, 54746 SDValue(Chain.getNode(), Chain.getResNo()) 54747 }; 54748 ReplaceUses(Froms, Tos, 2); 54749 return ResNode; 54750 } 54751 SDNode *Select_X86ISD_TLSADDR(const SDValue &N) { 54752 54753 // Pattern: (X86tlsaddr:isVoid tls32addr:i32:$sym) 54754 // Emits: (TLS_addr32:isVoid tls32addr:i32:$sym) 54755 // Pattern complexity = 18 cost = 1 size = 3 54756 if ((!Subtarget->is64Bit())) { 54757 SDValue Chain = N.getOperand(0); 54758 SDValue N1 = N.getOperand(1); 54759 SDValue CPTmpN1_0; 54760 SDValue CPTmpN1_1; 54761 SDValue CPTmpN1_2; 54762 SDValue CPTmpN1_3; 54763 if (SelectTLSADDRAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3) && 54764 N1.getNode()->getValueType(0) == MVT::i32) { 54765 SDNode *Result = Emit_309(N, X86::TLS_addr32, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3); 54766 return Result; 54767 } 54768 } 54769 54770 // Pattern: (X86tlsaddr:isVoid tls64addr:i64:$sym) 54771 // Emits: (TLS_addr64:isVoid tls64addr:i64:$sym) 54772 // Pattern complexity = 18 cost = 1 size = 3 54773 if ((Subtarget->is64Bit())) { 54774 SDValue Chain = N.getOperand(0); 54775 SDValue N1 = N.getOperand(1); 54776 SDValue CPTmpN1_0; 54777 SDValue CPTmpN1_1; 54778 SDValue CPTmpN1_2; 54779 SDValue CPTmpN1_3; 54780 if (SelectTLSADDRAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3) && 54781 N1.getNode()->getValueType(0) == MVT::i64) { 54782 SDNode *Result = Emit_309(N, X86::TLS_addr64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3); 54783 return Result; 54784 } 54785 } 54786 54787 CannotYetSelect(N); 54788 return NULL; 54789 } 54790 54791 SDNode *Select_X86ISD_UCOMI(const SDValue &N) { 54792 if (OptLevel != CodeGenOpt::None) { 54793 54794 // Pattern: (X86ucomi:isVoid VR128:v4f32:$src1, (ld:v4f32 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 54795 // Emits: (Int_UCOMISSrm:isVoid VR128:v4f32:$src1, addr:iPTR:$src2) 54796 // Pattern complexity = 25 cost = 1 size = 3 54797 if ((Subtarget->hasSSE1())) { 54798 SDValue N0 = N.getOperand(0); 54799 SDValue N1 = N.getOperand(1); 54800 if (N1.getOpcode() == ISD::LOAD && 54801 N1.hasOneUse() && 54802 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 54803 SDValue Chain1 = N1.getOperand(0); 54804 if (Predicate_unindexedload(N1.getNode()) && 54805 Predicate_load(N1.getNode())) { 54806 SDValue N11 = N1.getOperand(1); 54807 SDValue CPTmpN11_0; 54808 SDValue CPTmpN11_1; 54809 SDValue CPTmpN11_2; 54810 SDValue CPTmpN11_3; 54811 SDValue CPTmpN11_4; 54812 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 54813 N0.getNode()->getValueType(0) == MVT::v4f32) { 54814 SDNode *Result = Emit_280(N, X86::Int_UCOMISSrm, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 54815 return Result; 54816 } 54817 } 54818 } 54819 } 54820 54821 // Pattern: (X86ucomi:isVoid VR128:v2f64:$src1, (ld:v2f64 addr:iPTR:$src2)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 54822 // Emits: (Int_UCOMISDrm:isVoid VR128:v2f64:$src1, addr:iPTR:$src2) 54823 // Pattern complexity = 25 cost = 1 size = 3 54824 if ((Subtarget->hasSSE2())) { 54825 SDValue N0 = N.getOperand(0); 54826 SDValue N1 = N.getOperand(1); 54827 if (N1.getOpcode() == ISD::LOAD && 54828 N1.hasOneUse() && 54829 IsLegalAndProfitableToFold(N1.getNode(), N.getNode(), N.getNode())) { 54830 SDValue Chain1 = N1.getOperand(0); 54831 if (Predicate_unindexedload(N1.getNode()) && 54832 Predicate_load(N1.getNode())) { 54833 SDValue N11 = N1.getOperand(1); 54834 SDValue CPTmpN11_0; 54835 SDValue CPTmpN11_1; 54836 SDValue CPTmpN11_2; 54837 SDValue CPTmpN11_3; 54838 SDValue CPTmpN11_4; 54839 if (SelectAddr(N, N11, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4) && 54840 N0.getNode()->getValueType(0) == MVT::v2f64) { 54841 SDNode *Result = Emit_280(N, X86::Int_UCOMISDrm, CPTmpN11_0, CPTmpN11_1, CPTmpN11_2, CPTmpN11_3, CPTmpN11_4); 54842 return Result; 54843 } 54844 } 54845 } 54846 } 54847 } 54848 54849 // Pattern: (X86ucomi:isVoid VR128:v4f32:$src1, VR128:v4f32:$src2) 54850 // Emits: (Int_UCOMISSrr:isVoid VR128:v4f32:$src1, VR128:v4f32:$src2) 54851 // Pattern complexity = 3 cost = 1 size = 3 54852 if ((Subtarget->hasSSE1())) { 54853 SDValue N0 = N.getOperand(0); 54854 SDValue N1 = N.getOperand(1); 54855 if (N0.getNode()->getValueType(0) == MVT::v4f32) { 54856 SDNode *Result = Emit_257(N, X86::Int_UCOMISSrr); 54857 return Result; 54858 } 54859 } 54860 54861 // Pattern: (X86ucomi:isVoid VR128:v2f64:$src1, VR128:v2f64:$src2) 54862 // Emits: (Int_UCOMISDrr:isVoid VR128:v2f64:$src1, VR128:v2f64:$src2) 54863 // Pattern complexity = 3 cost = 1 size = 3 54864 if ((Subtarget->hasSSE2())) { 54865 SDValue N0 = N.getOperand(0); 54866 SDValue N1 = N.getOperand(1); 54867 if (N0.getNode()->getValueType(0) == MVT::v2f64) { 54868 SDNode *Result = Emit_257(N, X86::Int_UCOMISDrr); 54869 return Result; 54870 } 54871 } 54872 54873 CannotYetSelect(N); 54874 return NULL; 54875 } 54876 54877 SDNode *Emit_310(const SDValue &N, unsigned Opc0, unsigned NumInputRootOps) DISABLE_INLINE { 54878 SDValue Chain = N.getOperand(0); 54879 SDValue N1 = N.getOperand(1); 54880 SDValue N2 = N.getOperand(2); 54881 SDValue N3 = N.getOperand(3); 54882 SmallVector<SDValue, 8> Ops0; 54883 SDValue Tmp1 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N2)->getZExtValue()), MVT::i64); 54884 SDValue Tmp2 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N3)->getZExtValue()), MVT::i64); 54885 Ops0.push_back(N1); 54886 Ops0.push_back(Tmp1); 54887 Ops0.push_back(Tmp2); 54888 for (unsigned i = NumInputRootOps + 1, e = N.getNumOperands(); i != e; ++i) { 54889 Ops0.push_back(N.getOperand(i)); 54890 } 54891 Ops0.push_back(Chain); 54892 return CurDAG->SelectNodeTo(N.getNode(), Opc0, MVT::Other, &Ops0[0], Ops0.size()); 54893 } 54894 SDNode *Select_X86ISD_VASTART_SAVE_XMM_REGS(const SDValue &N) { 54895 SDValue Chain = N.getOperand(0); 54896 SDValue N1 = N.getOperand(1); 54897 SDValue N2 = N.getOperand(2); 54898 if (N2.getOpcode() == ISD::Constant) { 54899 SDValue N3 = N.getOperand(3); 54900 if (N3.getOpcode() == ISD::Constant) { 54901 SDNode *Result = Emit_310(N, X86::VASTART_SAVE_XMM_REGS, 3); 54902 return Result; 54903 } 54904 } 54905 54906 CannotYetSelect(N); 54907 return NULL; 54908 } 54909 54910 SDNode *Select_X86ISD_VSHL_v1i64(const SDValue &N) { 54911 SDValue N0 = N.getOperand(0); 54912 SDValue N1 = N.getOperand(1); 54913 if (N1.getOpcode() == ISD::Constant && 54914 N1.getNode()->getValueType(0) == MVT::i8) { 54915 SDNode *Result = Emit_93(N, X86::MMX_PSLLQri, MVT::v1i64); 54916 return Result; 54917 } 54918 54919 CannotYetSelect(N); 54920 return NULL; 54921 } 54922 54923 SDNode *Select_X86ISD_VSHL_v2i64(const SDValue &N) { 54924 if ((Subtarget->hasSSE2())) { 54925 SDValue N0 = N.getOperand(0); 54926 SDValue N1 = N.getOperand(1); 54927 if (N1.getOpcode() == ISD::Constant && 54928 N1.getNode()->getValueType(0) == MVT::i8) { 54929 SDNode *Result = Emit_293(N, X86::PSLLDQri, MVT::v2i64); 54930 return Result; 54931 } 54932 } 54933 54934 CannotYetSelect(N); 54935 return NULL; 54936 } 54937 54938 SDNode *Select_X86ISD_VSRL_v1i64(const SDValue &N) { 54939 SDValue N0 = N.getOperand(0); 54940 SDValue N1 = N.getOperand(1); 54941 if (N1.getOpcode() == ISD::Constant && 54942 N1.getNode()->getValueType(0) == MVT::i8) { 54943 SDNode *Result = Emit_93(N, X86::MMX_PSRLQri, MVT::v1i64); 54944 return Result; 54945 } 54946 54947 CannotYetSelect(N); 54948 return NULL; 54949 } 54950 54951 SDNode *Select_X86ISD_VSRL_v2i64(const SDValue &N) { 54952 if ((Subtarget->hasSSE2())) { 54953 SDValue N0 = N.getOperand(0); 54954 SDValue N1 = N.getOperand(1); 54955 if (N1.getOpcode() == ISD::Constant && 54956 N1.getNode()->getValueType(0) == MVT::i8) { 54957 SDNode *Result = Emit_293(N, X86::PSRLDQri, MVT::v2i64); 54958 return Result; 54959 } 54960 } 54961 54962 CannotYetSelect(N); 54963 return NULL; 54964 } 54965 54966 SDNode *Emit_311(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN1_0, SDValue &CPTmpN1_1, SDValue &CPTmpN1_2, SDValue &CPTmpN1_3, SDValue &CPTmpN1_4) DISABLE_INLINE { 54967 SDValue Chain = N.getOperand(0); 54968 SDValue N1 = N.getOperand(1); 54969 SDValue Ops0[] = { CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4, Chain }; 54970 return CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 6); 54971 } 54972 SDNode *Select_X86ISD_VZEXT_LOAD_v2i64(const SDValue &N) { 54973 SDValue Chain = N.getOperand(0); 54974 SDValue N1 = N.getOperand(1); 54975 SDValue CPTmpN1_0; 54976 SDValue CPTmpN1_1; 54977 SDValue CPTmpN1_2; 54978 SDValue CPTmpN1_3; 54979 SDValue CPTmpN1_4; 54980 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 54981 SDNode *Result = Emit_311(N, X86::MOVZQI2PQIrm, MVT::v2i64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 54982 return Result; 54983 } 54984 54985 CannotYetSelect(N); 54986 return NULL; 54987 } 54988 54989 SDNode *Select_X86ISD_VZEXT_LOAD_v2f64(const SDValue &N) { 54990 SDValue Chain = N.getOperand(0); 54991 SDValue N1 = N.getOperand(1); 54992 SDValue CPTmpN1_0; 54993 SDValue CPTmpN1_1; 54994 SDValue CPTmpN1_2; 54995 SDValue CPTmpN1_3; 54996 SDValue CPTmpN1_4; 54997 if (SelectAddr(N, N1, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4)) { 54998 SDNode *Result = Emit_311(N, X86::MOVZSD2PDrm, MVT::v2f64, CPTmpN1_0, CPTmpN1_1, CPTmpN1_2, CPTmpN1_3, CPTmpN1_4); 54999 return Result; 55000 } 55001 55002 CannotYetSelect(N); 55003 return NULL; 55004 } 55005 55006 SDNode *Emit_312(const SDValue &N, unsigned Opc0, EVT VT0, SDValue &CPTmpN001_0, SDValue &CPTmpN001_1, SDValue &CPTmpN001_2, SDValue &CPTmpN001_3, SDValue &CPTmpN001_4) DISABLE_INLINE { 55007 SDValue N0 = N.getOperand(0); 55008 SDValue N00 = N0.getOperand(0); 55009 SDValue Chain00 = N00.getOperand(0); 55010 SDValue N001 = N00.getOperand(1); 55011 SDValue LSI_N00 = CurDAG->getMemOperand(cast<MemSDNode>(N00)->getMemOperand()); 55012 SDValue Ops0[] = { CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4, LSI_N00, Chain00 }; 55013 SDNode *ResNode = CurDAG->SelectNodeTo(N.getNode(), Opc0, VT0, MVT::Other, Ops0, 7); 55014 ReplaceUses(SDValue(N00.getNode(), 1), SDValue(ResNode, 1)); 55015 return ResNode; 55016 } 55017 SDNode *Emit_313(const SDValue &N, unsigned Opc0, unsigned Opc1, EVT VT0, EVT VT1) DISABLE_INLINE { 55018 SDValue N0 = N.getOperand(0); 55019 SDValue Tmp1(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0), 0); 55020 return CurDAG->SelectNodeTo(N.getNode(), Opc1, VT1, N0, Tmp1); 55021 } 55022 SDNode *Select_X86ISD_VZEXT_MOVL_v2i32(const SDValue &N) { 55023 if (OptLevel != CodeGenOpt::None) { 55024 55025 // Pattern: (X86vzmovl:v2i32 (scalar_to_vector:v2i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>)) 55026 // Emits: (MMX_MOVZDI2PDIrm:v2i32 addr:iPTR:$src) 55027 // Pattern complexity = 48 cost = 1 size = 3 55028 if ((Subtarget->hasMMX())) { 55029 SDValue N0 = N.getOperand(0); 55030 if (N0.getOpcode() == ISD::SCALAR_TO_VECTOR && 55031 N0.hasOneUse()) { 55032 SDValue N00 = N0.getOperand(0); 55033 if (N00.getOpcode() == ISD::LOAD && 55034 N00.hasOneUse() && 55035 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 55036 SDValue Chain00 = N00.getOperand(0); 55037 if (Predicate_unindexedload(N00.getNode()) && 55038 Predicate_loadi32(N00.getNode())) { 55039 SDValue N001 = N00.getOperand(1); 55040 SDValue CPTmpN001_0; 55041 SDValue CPTmpN001_1; 55042 SDValue CPTmpN001_2; 55043 SDValue CPTmpN001_3; 55044 SDValue CPTmpN001_4; 55045 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4) && 55046 N00.getNode()->getValueType(0) == MVT::i32) { 55047 SDNode *Result = Emit_312(N, X86::MMX_MOVZDI2PDIrm, MVT::v2i32, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 55048 return Result; 55049 } 55050 } 55051 } 55052 } 55053 } 55054 55055 // Pattern: (X86vzmovl:v2i32 (bitconvert:v2i32 (ld:v1i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 55056 // Emits: (MMX_MOVZDI2PDIrm:v2i32 addr:iPTR:$src) 55057 // Pattern complexity = 48 cost = 1 size = 3 55058 SDValue N0 = N.getOperand(0); 55059 if (N0.getOpcode() == ISD::BIT_CONVERT && 55060 N0.hasOneUse()) { 55061 SDValue N00 = N0.getOperand(0); 55062 if (N00.getOpcode() == ISD::LOAD && 55063 N00.hasOneUse() && 55064 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 55065 SDValue Chain00 = N00.getOperand(0); 55066 if (Predicate_unindexedload(N00.getNode()) && 55067 Predicate_load(N00.getNode())) { 55068 SDValue N001 = N00.getOperand(1); 55069 SDValue CPTmpN001_0; 55070 SDValue CPTmpN001_1; 55071 SDValue CPTmpN001_2; 55072 SDValue CPTmpN001_3; 55073 SDValue CPTmpN001_4; 55074 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4) && 55075 N00.getNode()->getValueType(0) == MVT::v1i64) { 55076 SDNode *Result = Emit_312(N, X86::MMX_MOVZDI2PDIrm, MVT::v2i32, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 55077 return Result; 55078 } 55079 } 55080 } 55081 } 55082 } 55083 55084 // Pattern: (X86vzmovl:v2i32 (scalar_to_vector:v2i32 GR32:i32:$src)) 55085 // Emits: (MMX_MOVZDI2PDIrr:v2i32 GR32:i32:$src) 55086 // Pattern complexity = 21 cost = 1 size = 3 55087 if ((Subtarget->hasMMX())) { 55088 SDValue N0 = N.getOperand(0); 55089 if (N0.getOpcode() == ISD::SCALAR_TO_VECTOR) { 55090 SDValue N00 = N0.getOperand(0); 55091 if (N00.getNode()->getValueType(0) == MVT::i32) { 55092 SDNode *Result = Emit_161(N, X86::MMX_MOVZDI2PDIrr, MVT::v2i32); 55093 return Result; 55094 } 55095 } 55096 } 55097 55098 // Pattern: (X86vzmovl:v2i32 VR64:v2i32:$src) 55099 // Emits: (MMX_PUNPCKLDQrr:v2i32 VR64:v8i8:$src, (MMX_V_SET0:v8i8)) 55100 // Pattern complexity = 18 cost = 2 size = 6 55101 SDNode *Result = Emit_313(N, X86::MMX_V_SET0, X86::MMX_PUNPCKLDQrr, MVT::v8i8, MVT::v2i32); 55102 return Result; 55103 } 55104 55105 SDNode *Emit_314(const SDValue &N, unsigned Opc0, unsigned Opc1, EVT VT0, EVT VT1) DISABLE_INLINE { 55106 SDValue N0 = N.getOperand(0); 55107 SDValue Tmp0(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0), 0); 55108 return CurDAG->SelectNodeTo(N.getNode(), Opc1, VT1, Tmp0, N0); 55109 } 55110 SDNode *Select_X86ISD_VZEXT_MOVL_v4i32(const SDValue &N) { 55111 if (OptLevel != CodeGenOpt::None) { 55112 55113 // Pattern: (X86vzmovl:v4i32 (scalar_to_vector:v4i32 (ld:i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_loadi32>>)) 55114 // Emits: (MOVZDI2PDIrm:v4i32 addr:iPTR:$src) 55115 // Pattern complexity = 48 cost = 1 size = 3 55116 if ((Subtarget->hasSSE2())) { 55117 SDValue N0 = N.getOperand(0); 55118 if (N0.getOpcode() == ISD::SCALAR_TO_VECTOR && 55119 N0.hasOneUse()) { 55120 SDValue N00 = N0.getOperand(0); 55121 if (N00.getOpcode() == ISD::LOAD && 55122 N00.hasOneUse() && 55123 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 55124 SDValue Chain00 = N00.getOperand(0); 55125 if (Predicate_unindexedload(N00.getNode()) && 55126 Predicate_loadi32(N00.getNode())) { 55127 SDValue N001 = N00.getOperand(1); 55128 SDValue CPTmpN001_0; 55129 SDValue CPTmpN001_1; 55130 SDValue CPTmpN001_2; 55131 SDValue CPTmpN001_3; 55132 SDValue CPTmpN001_4; 55133 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4) && 55134 N00.getNode()->getValueType(0) == MVT::i32) { 55135 SDNode *Result = Emit_312(N, X86::MOVZDI2PDIrm, MVT::v4i32, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 55136 return Result; 55137 } 55138 } 55139 } 55140 } 55141 } 55142 SDValue N0 = N.getOperand(0); 55143 if (N0.getOpcode() == ISD::BIT_CONVERT && 55144 N0.hasOneUse()) { 55145 SDValue N00 = N0.getOperand(0); 55146 if (N00.getOpcode() == ISD::LOAD && 55147 N00.hasOneUse() && 55148 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 55149 SDValue Chain00 = N00.getOperand(0); 55150 if (Predicate_unindexedload(N00.getNode()) && 55151 Predicate_load(N00.getNode())) { 55152 SDValue N001 = N00.getOperand(1); 55153 SDValue CPTmpN001_0; 55154 SDValue CPTmpN001_1; 55155 SDValue CPTmpN001_2; 55156 SDValue CPTmpN001_3; 55157 SDValue CPTmpN001_4; 55158 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 55159 55160 // Pattern: (X86vzmovl:v4i32 (bitconvert:v4i32 (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 55161 // Emits: (MOVZDI2PDIrm:v4i32 addr:iPTR:$src) 55162 // Pattern complexity = 48 cost = 1 size = 3 55163 if (N00.getNode()->getValueType(0) == MVT::v4f32) { 55164 SDNode *Result = Emit_312(N, X86::MOVZDI2PDIrm, MVT::v4i32, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 55165 return Result; 55166 } 55167 55168 // Pattern: (X86vzmovl:v4i32 (bitconvert:v4i32 (ld:v2i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 55169 // Emits: (MOVZDI2PDIrm:v4i32 addr:iPTR:$src) 55170 // Pattern complexity = 48 cost = 1 size = 3 55171 if (N00.getNode()->getValueType(0) == MVT::v2i64) { 55172 SDNode *Result = Emit_312(N, X86::MOVZDI2PDIrm, MVT::v4i32, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 55173 return Result; 55174 } 55175 } 55176 } 55177 } 55178 } 55179 55180 // Pattern: (X86vzmovl:v4i32 (ld:v4i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 55181 // Emits: (MOVZDI2PDIrm:v4i32 addr:iPTR:$src) 55182 // Pattern complexity = 45 cost = 1 size = 3 55183 if (N0.getOpcode() == ISD::LOAD && 55184 N0.hasOneUse()) { 55185 SDValue Chain0 = N0.getOperand(0); 55186 if (Predicate_unindexedload(N0.getNode()) && 55187 Predicate_load(N0.getNode())) { 55188 SDValue N01 = N0.getOperand(1); 55189 SDValue CPTmpN01_0; 55190 SDValue CPTmpN01_1; 55191 SDValue CPTmpN01_2; 55192 SDValue CPTmpN01_3; 55193 SDValue CPTmpN01_4; 55194 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 55195 SDNode *Result = Emit_76(N, X86::MOVZDI2PDIrm, MVT::v4i32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 55196 return Result; 55197 } 55198 } 55199 } 55200 } 55201 55202 // Pattern: (X86vzmovl:v4i32 (scalar_to_vector:v4i32 GR32:i32:$src)) 55203 // Emits: (MOVZDI2PDIrr:v4i32 GR32:i32:$src) 55204 // Pattern complexity = 21 cost = 1 size = 3 55205 if ((Subtarget->hasSSE2())) { 55206 SDValue N0 = N.getOperand(0); 55207 if (N0.getOpcode() == ISD::SCALAR_TO_VECTOR) { 55208 SDValue N00 = N0.getOperand(0); 55209 if (N00.getNode()->getValueType(0) == MVT::i32) { 55210 SDNode *Result = Emit_161(N, X86::MOVZDI2PDIrr, MVT::v4i32); 55211 return Result; 55212 } 55213 } 55214 } 55215 55216 // Pattern: (X86vzmovl:v4i32 VR128:v4i32:$src) 55217 // Emits: (MOVLPSrr:v4i32 (V_SET0:v16i8), VR128:v16i8:$src) 55218 // Pattern complexity = 18 cost = 2 size = 6 55219 if ((Subtarget->hasSSE1())) { 55220 SDNode *Result = Emit_314(N, X86::V_SET0, X86::MOVLPSrr, MVT::v16i8, MVT::v4i32); 55221 return Result; 55222 } 55223 55224 CannotYetSelect(N); 55225 return NULL; 55226 } 55227 55228 SDNode *Select_X86ISD_VZEXT_MOVL_v2i64(const SDValue &N) { 55229 if (OptLevel != CodeGenOpt::None) { 55230 55231 // Pattern: (X86vzmovl:v2i64 (scalar_to_vector:v2i64 (ld:i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadi64>>)) 55232 // Emits: (MOVZQI2PQIrm:v2i64 addr:iPTR:$src) 55233 // Pattern complexity = 48 cost = 1 size = 3 55234 if ((Subtarget->hasSSE2())) { 55235 SDValue N0 = N.getOperand(0); 55236 if (N0.getOpcode() == ISD::SCALAR_TO_VECTOR && 55237 N0.hasOneUse()) { 55238 SDValue N00 = N0.getOperand(0); 55239 if (N00.getOpcode() == ISD::LOAD && 55240 N00.hasOneUse() && 55241 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 55242 SDValue Chain00 = N00.getOperand(0); 55243 if (Predicate_unindexedload(N00.getNode()) && 55244 Predicate_load(N00.getNode()) && 55245 Predicate_loadi64(N00.getNode())) { 55246 SDValue N001 = N00.getOperand(1); 55247 SDValue CPTmpN001_0; 55248 SDValue CPTmpN001_1; 55249 SDValue CPTmpN001_2; 55250 SDValue CPTmpN001_3; 55251 SDValue CPTmpN001_4; 55252 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4) && 55253 N00.getNode()->getValueType(0) == MVT::i64) { 55254 SDNode *Result = Emit_312(N, X86::MOVZQI2PQIrm, MVT::v2i64, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 55255 return Result; 55256 } 55257 } 55258 } 55259 } 55260 } 55261 { 55262 SDValue N0 = N.getOperand(0); 55263 if (N0.getOpcode() == ISD::BIT_CONVERT && 55264 N0.hasOneUse()) { 55265 SDValue N00 = N0.getOperand(0); 55266 if (N00.getOpcode() == ISD::LOAD && 55267 N00.hasOneUse() && 55268 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 55269 SDValue Chain00 = N00.getOperand(0); 55270 if (Predicate_unindexedload(N00.getNode()) && 55271 Predicate_load(N00.getNode())) { 55272 SDValue N001 = N00.getOperand(1); 55273 SDValue CPTmpN001_0; 55274 SDValue CPTmpN001_1; 55275 SDValue CPTmpN001_2; 55276 SDValue CPTmpN001_3; 55277 SDValue CPTmpN001_4; 55278 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4)) { 55279 55280 // Pattern: (X86vzmovl:v2i64 (bitconvert:v2i64 (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 55281 // Emits: (MOVZQI2PQIrm:v2i64 addr:iPTR:$src) 55282 // Pattern complexity = 48 cost = 1 size = 3 55283 if (N00.getNode()->getValueType(0) == MVT::v4f32) { 55284 SDNode *Result = Emit_312(N, X86::MOVZQI2PQIrm, MVT::v2i64, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 55285 return Result; 55286 } 55287 55288 // Pattern: (X86vzmovl:v2i64 (bitconvert:v2i64 (ld:v4i32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 55289 // Emits: (MOVZPQILo2PQIrm:v2i64 addr:iPTR:$src) 55290 // Pattern complexity = 48 cost = 1 size = 3 55291 if (N00.getNode()->getValueType(0) == MVT::v4i32) { 55292 SDNode *Result = Emit_312(N, X86::MOVZPQILo2PQIrm, MVT::v2i64, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 55293 return Result; 55294 } 55295 } 55296 } 55297 } 55298 } 55299 } 55300 55301 // Pattern: (X86vzmovl:v2i64 (ld:v2i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 55302 // Emits: (MOVZPQILo2PQIrm:v2i64 addr:iPTR:$src) 55303 // Pattern complexity = 45 cost = 1 size = 3 55304 if ((Subtarget->hasSSE2())) { 55305 SDValue N0 = N.getOperand(0); 55306 if (N0.getOpcode() == ISD::LOAD && 55307 N0.hasOneUse()) { 55308 SDValue Chain0 = N0.getOperand(0); 55309 if (Predicate_unindexedload(N0.getNode()) && 55310 Predicate_load(N0.getNode())) { 55311 SDValue N01 = N0.getOperand(1); 55312 SDValue CPTmpN01_0; 55313 SDValue CPTmpN01_1; 55314 SDValue CPTmpN01_2; 55315 SDValue CPTmpN01_3; 55316 SDValue CPTmpN01_4; 55317 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 55318 SDNode *Result = Emit_76(N, X86::MOVZPQILo2PQIrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 55319 return Result; 55320 } 55321 } 55322 } 55323 } 55324 55325 // Pattern: (X86vzmovl:v2i64 (ld:v2i64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 55326 // Emits: (MOVZQI2PQIrm:v2i64 addr:iPTR:$src) 55327 // Pattern complexity = 45 cost = 1 size = 3 55328 SDValue N0 = N.getOperand(0); 55329 if (N0.getOpcode() == ISD::LOAD && 55330 N0.hasOneUse()) { 55331 SDValue Chain0 = N0.getOperand(0); 55332 if (Predicate_unindexedload(N0.getNode()) && 55333 Predicate_load(N0.getNode())) { 55334 SDValue N01 = N0.getOperand(1); 55335 SDValue CPTmpN01_0; 55336 SDValue CPTmpN01_1; 55337 SDValue CPTmpN01_2; 55338 SDValue CPTmpN01_3; 55339 SDValue CPTmpN01_4; 55340 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 55341 SDNode *Result = Emit_76(N, X86::MOVZQI2PQIrm, MVT::v2i64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 55342 return Result; 55343 } 55344 } 55345 } 55346 } 55347 if ((Subtarget->hasSSE2())) { 55348 55349 // Pattern: (X86vzmovl:v2i64 (scalar_to_vector:v2i64 GR64:i64:$src)) 55350 // Emits: (MOVZQI2PQIrr:v2i64 GR64:i64:$src) 55351 // Pattern complexity = 21 cost = 1 size = 3 55352 { 55353 SDValue N0 = N.getOperand(0); 55354 if (N0.getOpcode() == ISD::SCALAR_TO_VECTOR) { 55355 SDValue N00 = N0.getOperand(0); 55356 if (N00.getNode()->getValueType(0) == MVT::i64) { 55357 SDNode *Result = Emit_161(N, X86::MOVZQI2PQIrr, MVT::v2i64); 55358 return Result; 55359 } 55360 } 55361 } 55362 55363 // Pattern: (X86vzmovl:v2i64 VR128:v2i64:$src) 55364 // Emits: (MOVZPQILo2PQIrr:v2i64 VR128:v2i64:$src) 55365 // Pattern complexity = 18 cost = 1 size = 3 55366 SDNode *Result = Emit_71(N, X86::MOVZPQILo2PQIrr, MVT::v2i64); 55367 return Result; 55368 } 55369 55370 CannotYetSelect(N); 55371 return NULL; 55372 } 55373 55374 SDNode *Emit_315(const SDValue &N, unsigned Opc0, unsigned Opc1, EVT VT0, EVT VT1) DISABLE_INLINE { 55375 SDValue N0 = N.getOperand(0); 55376 SDValue N00 = N0.getOperand(0); 55377 SDValue Tmp0(CurDAG->getTargetNode(Opc0, N.getDebugLoc(), VT0), 0); 55378 return CurDAG->SelectNodeTo(N.getNode(), Opc1, VT1, Tmp0, N00); 55379 } 55380 SDNode *Select_X86ISD_VZEXT_MOVL_v4f32(const SDValue &N) { 55381 if (OptLevel != CodeGenOpt::None) { 55382 55383 // Pattern: (X86vzmovl:v4f32 (scalar_to_vector:v4f32 (ld:f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf32>>)) 55384 // Emits: (MOVZSS2PSrm:v4f32 addr:iPTR:$src) 55385 // Pattern complexity = 48 cost = 1 size = 3 55386 if ((Subtarget->hasSSE1())) { 55387 SDValue N0 = N.getOperand(0); 55388 if (N0.getOpcode() == ISD::SCALAR_TO_VECTOR && 55389 N0.hasOneUse()) { 55390 SDValue N00 = N0.getOperand(0); 55391 if (N00.getOpcode() == ISD::LOAD && 55392 N00.hasOneUse() && 55393 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 55394 SDValue Chain00 = N00.getOperand(0); 55395 if (Predicate_unindexedload(N00.getNode()) && 55396 Predicate_load(N00.getNode()) && 55397 Predicate_loadf32(N00.getNode())) { 55398 SDValue N001 = N00.getOperand(1); 55399 SDValue CPTmpN001_0; 55400 SDValue CPTmpN001_1; 55401 SDValue CPTmpN001_2; 55402 SDValue CPTmpN001_3; 55403 SDValue CPTmpN001_4; 55404 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4) && 55405 N00.getNode()->getValueType(0) == MVT::f32) { 55406 SDNode *Result = Emit_312(N, X86::MOVZSS2PSrm, MVT::v4f32, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 55407 return Result; 55408 } 55409 } 55410 } 55411 } 55412 } 55413 55414 // Pattern: (X86vzmovl:v4f32 (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 55415 // Emits: (MOVZSS2PSrm:v4f32 addr:iPTR:$src) 55416 // Pattern complexity = 25 cost = 1 size = 3 55417 SDValue N0 = N.getOperand(0); 55418 if (N0.getOpcode() == ISD::LOAD && 55419 N0.hasOneUse()) { 55420 SDValue Chain0 = N0.getOperand(0); 55421 if (Predicate_unindexedload(N0.getNode()) && 55422 Predicate_load(N0.getNode())) { 55423 SDValue N01 = N0.getOperand(1); 55424 SDValue CPTmpN01_0; 55425 SDValue CPTmpN01_1; 55426 SDValue CPTmpN01_2; 55427 SDValue CPTmpN01_3; 55428 SDValue CPTmpN01_4; 55429 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 55430 SDNode *Result = Emit_76(N, X86::MOVZSS2PSrm, MVT::v4f32, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 55431 return Result; 55432 } 55433 } 55434 } 55435 } 55436 if ((Subtarget->hasSSE1())) { 55437 55438 // Pattern: (X86vzmovl:v4f32 (scalar_to_vector:v4f32 FR32:f32:$src)) 55439 // Emits: (MOVLSS2PSrr:v4f32 (V_SET0:v16i8), FR32:f32:$src) 55440 // Pattern complexity = 21 cost = 2 size = 6 55441 { 55442 SDValue N0 = N.getOperand(0); 55443 if (N0.getOpcode() == ISD::SCALAR_TO_VECTOR) { 55444 SDValue N00 = N0.getOperand(0); 55445 if (N00.getNode()->getValueType(0) == MVT::f32) { 55446 SDNode *Result = Emit_315(N, X86::V_SET0, X86::MOVLSS2PSrr, MVT::v16i8, MVT::v4f32); 55447 return Result; 55448 } 55449 } 55450 } 55451 55452 // Pattern: (X86vzmovl:v4f32 VR128:v4f32:$src) 55453 // Emits: (MOVLPSrr:v4f32 (V_SET0:v16i8), VR128:v16i8:$src) 55454 // Pattern complexity = 18 cost = 2 size = 6 55455 SDNode *Result = Emit_314(N, X86::V_SET0, X86::MOVLPSrr, MVT::v16i8, MVT::v4f32); 55456 return Result; 55457 } 55458 55459 CannotYetSelect(N); 55460 return NULL; 55461 } 55462 55463 SDNode *Select_X86ISD_VZEXT_MOVL_v2f64(const SDValue &N) { 55464 if (OptLevel != CodeGenOpt::None) { 55465 55466 // Pattern: (X86vzmovl:v2f64 (scalar_to_vector:v2f64 (ld:f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>><<P:Predicate_loadf64>>)) 55467 // Emits: (MOVZSD2PDrm:v2f64 addr:iPTR:$src) 55468 // Pattern complexity = 48 cost = 1 size = 3 55469 if ((Subtarget->hasSSE2())) { 55470 SDValue N0 = N.getOperand(0); 55471 if (N0.getOpcode() == ISD::SCALAR_TO_VECTOR && 55472 N0.hasOneUse()) { 55473 SDValue N00 = N0.getOperand(0); 55474 if (N00.getOpcode() == ISD::LOAD && 55475 N00.hasOneUse() && 55476 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 55477 SDValue Chain00 = N00.getOperand(0); 55478 if (Predicate_unindexedload(N00.getNode()) && 55479 Predicate_load(N00.getNode()) && 55480 Predicate_loadf64(N00.getNode())) { 55481 SDValue N001 = N00.getOperand(1); 55482 SDValue CPTmpN001_0; 55483 SDValue CPTmpN001_1; 55484 SDValue CPTmpN001_2; 55485 SDValue CPTmpN001_3; 55486 SDValue CPTmpN001_4; 55487 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4) && 55488 N00.getNode()->getValueType(0) == MVT::f64) { 55489 SDNode *Result = Emit_312(N, X86::MOVZSD2PDrm, MVT::v2f64, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 55490 return Result; 55491 } 55492 } 55493 } 55494 } 55495 } 55496 SDValue N0 = N.getOperand(0); 55497 55498 // Pattern: (X86vzmovl:v2f64 (bitconvert:v2f64 (ld:v4f32 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>)) 55499 // Emits: (MOVZSD2PDrm:v2f64 addr:iPTR:$src) 55500 // Pattern complexity = 48 cost = 1 size = 3 55501 if (N0.getOpcode() == ISD::BIT_CONVERT && 55502 N0.hasOneUse()) { 55503 SDValue N00 = N0.getOperand(0); 55504 if (N00.getOpcode() == ISD::LOAD && 55505 N00.hasOneUse() && 55506 IsLegalAndProfitableToFold(N00.getNode(), N0.getNode(), N.getNode())) { 55507 SDValue Chain00 = N00.getOperand(0); 55508 if (Predicate_unindexedload(N00.getNode()) && 55509 Predicate_load(N00.getNode())) { 55510 SDValue N001 = N00.getOperand(1); 55511 SDValue CPTmpN001_0; 55512 SDValue CPTmpN001_1; 55513 SDValue CPTmpN001_2; 55514 SDValue CPTmpN001_3; 55515 SDValue CPTmpN001_4; 55516 if (SelectAddr(N, N001, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4) && 55517 N00.getNode()->getValueType(0) == MVT::v4f32) { 55518 SDNode *Result = Emit_312(N, X86::MOVZSD2PDrm, MVT::v2f64, CPTmpN001_0, CPTmpN001_1, CPTmpN001_2, CPTmpN001_3, CPTmpN001_4); 55519 return Result; 55520 } 55521 } 55522 } 55523 } 55524 55525 // Pattern: (X86vzmovl:v2f64 (ld:v2f64 addr:iPTR:$src)<<P:Predicate_unindexedload>><<P:Predicate_load>>) 55526 // Emits: (MOVZSD2PDrm:v2f64 addr:iPTR:$src) 55527 // Pattern complexity = 45 cost = 1 size = 3 55528 if (N0.getOpcode() == ISD::LOAD && 55529 N0.hasOneUse()) { 55530 SDValue Chain0 = N0.getOperand(0); 55531 if (Predicate_unindexedload(N0.getNode()) && 55532 Predicate_load(N0.getNode())) { 55533 SDValue N01 = N0.getOperand(1); 55534 SDValue CPTmpN01_0; 55535 SDValue CPTmpN01_1; 55536 SDValue CPTmpN01_2; 55537 SDValue CPTmpN01_3; 55538 SDValue CPTmpN01_4; 55539 if (SelectAddr(N, N01, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4)) { 55540 SDNode *Result = Emit_76(N, X86::MOVZSD2PDrm, MVT::v2f64, CPTmpN01_0, CPTmpN01_1, CPTmpN01_2, CPTmpN01_3, CPTmpN01_4); 55541 return Result; 55542 } 55543 } 55544 } 55545 } 55546 if ((Subtarget->hasSSE2())) { 55547 55548 // Pattern: (X86vzmovl:v2f64 (scalar_to_vector:v2f64 FR64:f64:$src)) 55549 // Emits: (MOVLSD2PDrr:v2f64 (V_SET0:v16i8), FR64:f64:$src) 55550 // Pattern complexity = 21 cost = 2 size = 6 55551 { 55552 SDValue N0 = N.getOperand(0); 55553 if (N0.getOpcode() == ISD::SCALAR_TO_VECTOR) { 55554 SDValue N00 = N0.getOperand(0); 55555 if (N00.getNode()->getValueType(0) == MVT::f64) { 55556 SDNode *Result = Emit_315(N, X86::V_SET0, X86::MOVLSD2PDrr, MVT::v16i8, MVT::v2f64); 55557 return Result; 55558 } 55559 } 55560 } 55561 55562 // Pattern: (X86vzmovl:v2f64 VR128:v2f64:$src) 55563 // Emits: (MOVZPQILo2PQIrr:v2f64 VR128:v16i8:$src) 55564 // Pattern complexity = 3 cost = 1 size = 3 55565 SDNode *Result = Emit_71(N, X86::MOVZPQILo2PQIrr, MVT::v2f64); 55566 return Result; 55567 } 55568 55569 CannotYetSelect(N); 55570 return NULL; 55571 } 55572 55573 SDNode *Select_X86ISD_Wrapper_i32(const SDValue &N) { 55574 SDValue N0 = N.getOperand(0); 55575 55576 // Pattern: (X86Wrapper:i32 (tconstpool:i32):$dst) 55577 // Emits: (MOV32ri:i32 (tconstpool:i32):$dst) 55578 // Pattern complexity = 6 cost = 1 size = 3 55579 if (N0.getOpcode() == ISD::TargetConstantPool) { 55580 SDNode *Result = Emit_71(N, X86::MOV32ri, MVT::i32); 55581 return Result; 55582 } 55583 55584 // Pattern: (X86Wrapper:i32 (tjumptable:i32):$dst) 55585 // Emits: (MOV32ri:i32 (tjumptable:i32):$dst) 55586 // Pattern complexity = 6 cost = 1 size = 3 55587 if (N0.getOpcode() == ISD::TargetJumpTable) { 55588 SDNode *Result = Emit_71(N, X86::MOV32ri, MVT::i32); 55589 return Result; 55590 } 55591 55592 // Pattern: (X86Wrapper:i32 (tglobaltlsaddr:i32):$dst) 55593 // Emits: (MOV32ri:i32 (tglobaltlsaddr:i32):$dst) 55594 // Pattern complexity = 6 cost = 1 size = 3 55595 if (N0.getOpcode() == ISD::TargetGlobalTLSAddress) { 55596 SDNode *Result = Emit_71(N, X86::MOV32ri, MVT::i32); 55597 return Result; 55598 } 55599 55600 // Pattern: (X86Wrapper:i32 (tglobaladdr:i32):$dst) 55601 // Emits: (MOV32ri:i32 (tglobaladdr:i32):$dst) 55602 // Pattern complexity = 6 cost = 1 size = 3 55603 if (N0.getOpcode() == ISD::TargetGlobalAddress) { 55604 SDNode *Result = Emit_71(N, X86::MOV32ri, MVT::i32); 55605 return Result; 55606 } 55607 55608 // Pattern: (X86Wrapper:i32 (texternalsym:i32):$dst) 55609 // Emits: (MOV32ri:i32 (texternalsym:i32):$dst) 55610 // Pattern complexity = 6 cost = 1 size = 3 55611 if (N0.getOpcode() == ISD::TargetExternalSymbol) { 55612 SDNode *Result = Emit_71(N, X86::MOV32ri, MVT::i32); 55613 return Result; 55614 } 55615 55616 CannotYetSelect(N); 55617 return NULL; 55618 } 55619 55620 SDNode *Select_X86ISD_Wrapper_i64(const SDValue &N) { 55621 if ((TM.getCodeModel() != CodeModel::Small &&TM.getCodeModel() != CodeModel::Kernel)) { 55622 SDValue N0 = N.getOperand(0); 55623 55624 // Pattern: (X86Wrapper:i64 (tconstpool:i64):$dst) 55625 // Emits: (MOV64ri:i64 (tconstpool:i64):$dst) 55626 // Pattern complexity = 6 cost = 1 size = 3 55627 if (N0.getOpcode() == ISD::TargetConstantPool) { 55628 SDNode *Result = Emit_71(N, X86::MOV64ri, MVT::i64); 55629 return Result; 55630 } 55631 55632 // Pattern: (X86Wrapper:i64 (tjumptable:i64):$dst) 55633 // Emits: (MOV64ri:i64 (tjumptable:i64):$dst) 55634 // Pattern complexity = 6 cost = 1 size = 3 55635 if (N0.getOpcode() == ISD::TargetJumpTable) { 55636 SDNode *Result = Emit_71(N, X86::MOV64ri, MVT::i64); 55637 return Result; 55638 } 55639 55640 // Pattern: (X86Wrapper:i64 (tglobaladdr:i64):$dst) 55641 // Emits: (MOV64ri:i64 (tglobaladdr:i64):$dst) 55642 // Pattern complexity = 6 cost = 1 size = 3 55643 if (N0.getOpcode() == ISD::TargetGlobalAddress) { 55644 SDNode *Result = Emit_71(N, X86::MOV64ri, MVT::i64); 55645 return Result; 55646 } 55647 55648 // Pattern: (X86Wrapper:i64 (texternalsym:i64):$dst) 55649 // Emits: (MOV64ri:i64 (texternalsym:i64):$dst) 55650 // Pattern complexity = 6 cost = 1 size = 3 55651 if (N0.getOpcode() == ISD::TargetExternalSymbol) { 55652 SDNode *Result = Emit_71(N, X86::MOV64ri, MVT::i64); 55653 return Result; 55654 } 55655 } 55656 if ((TM.getCodeModel() == CodeModel::Small)) { 55657 SDValue N0 = N.getOperand(0); 55658 55659 // Pattern: (X86Wrapper:i64 (tconstpool:i64):$dst) 55660 // Emits: (MOV64ri64i32:i64 (tconstpool:i64):$dst) 55661 // Pattern complexity = 6 cost = 1 size = 3 55662 if (N0.getOpcode() == ISD::TargetConstantPool) { 55663 SDNode *Result = Emit_71(N, X86::MOV64ri64i32, MVT::i64); 55664 return Result; 55665 } 55666 55667 // Pattern: (X86Wrapper:i64 (tjumptable:i64):$dst) 55668 // Emits: (MOV64ri64i32:i64 (tjumptable:i64):$dst) 55669 // Pattern complexity = 6 cost = 1 size = 3 55670 if (N0.getOpcode() == ISD::TargetJumpTable) { 55671 SDNode *Result = Emit_71(N, X86::MOV64ri64i32, MVT::i64); 55672 return Result; 55673 } 55674 55675 // Pattern: (X86Wrapper:i64 (tglobaladdr:i64):$dst) 55676 // Emits: (MOV64ri64i32:i64 (tglobaladdr:i64):$dst) 55677 // Pattern complexity = 6 cost = 1 size = 3 55678 if (N0.getOpcode() == ISD::TargetGlobalAddress) { 55679 SDNode *Result = Emit_71(N, X86::MOV64ri64i32, MVT::i64); 55680 return Result; 55681 } 55682 55683 // Pattern: (X86Wrapper:i64 (texternalsym:i64):$dst) 55684 // Emits: (MOV64ri64i32:i64 (texternalsym:i64):$dst) 55685 // Pattern complexity = 6 cost = 1 size = 3 55686 if (N0.getOpcode() == ISD::TargetExternalSymbol) { 55687 SDNode *Result = Emit_71(N, X86::MOV64ri64i32, MVT::i64); 55688 return Result; 55689 } 55690 } 55691 if ((TM.getCodeModel() == CodeModel::Kernel)) { 55692 SDValue N0 = N.getOperand(0); 55693 55694 // Pattern: (X86Wrapper:i64 (tconstpool:i64):$dst) 55695 // Emits: (MOV64ri32:i64 (tconstpool:i64):$dst) 55696 // Pattern complexity = 6 cost = 1 size = 3 55697 if (N0.getOpcode() == ISD::TargetConstantPool) { 55698 SDNode *Result = Emit_71(N, X86::MOV64ri32, MVT::i64); 55699 return Result; 55700 } 55701 55702 // Pattern: (X86Wrapper:i64 (tjumptable:i64):$dst) 55703 // Emits: (MOV64ri32:i64 (tjumptable:i64):$dst) 55704 // Pattern complexity = 6 cost = 1 size = 3 55705 if (N0.getOpcode() == ISD::TargetJumpTable) { 55706 SDNode *Result = Emit_71(N, X86::MOV64ri32, MVT::i64); 55707 return Result; 55708 } 55709 55710 // Pattern: (X86Wrapper:i64 (tglobaladdr:i64):$dst) 55711 // Emits: (MOV64ri32:i64 (tglobaladdr:i64):$dst) 55712 // Pattern complexity = 6 cost = 1 size = 3 55713 if (N0.getOpcode() == ISD::TargetGlobalAddress) { 55714 SDNode *Result = Emit_71(N, X86::MOV64ri32, MVT::i64); 55715 return Result; 55716 } 55717 55718 // Pattern: (X86Wrapper:i64 (texternalsym:i64):$dst) 55719 // Emits: (MOV64ri32:i64 (texternalsym:i64):$dst) 55720 // Pattern complexity = 6 cost = 1 size = 3 55721 if (N0.getOpcode() == ISD::TargetExternalSymbol) { 55722 SDNode *Result = Emit_71(N, X86::MOV64ri32, MVT::i64); 55723 return Result; 55724 } 55725 } 55726 55727 CannotYetSelect(N); 55728 return NULL; 55729 } 55730 55731 SDNode *Select_X86ISD_WrapperRIP_i64(const SDValue &N) { 55732 SDValue CPTmpN_0; 55733 SDValue CPTmpN_1; 55734 SDValue CPTmpN_2; 55735 SDValue CPTmpN_3; 55736 if (SelectLEAAddr(N, N, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3)) { 55737 SDNode *Result = Emit_7(N, X86::LEA64r, MVT::i64, CPTmpN_0, CPTmpN_1, CPTmpN_2, CPTmpN_3); 55738 return Result; 55739 } 55740 55741 CannotYetSelect(N); 55742 return NULL; 55743 } 55744 55745 SDNode *Select_INLINEASM(SDValue N) { 55746 std::vector<SDValue> Ops(N.getNode()->op_begin(), N.getNode()->op_end()); 55747 SelectInlineAsmMemoryOperands(Ops); 55748 55749 std::vector<EVT> VTs; 55750 VTs.push_back(MVT::Other); 55751 VTs.push_back(MVT::Flag); 55752 SDValue New = CurDAG->getNode(ISD::INLINEASM, N.getDebugLoc(), VTs, &Ops[0], Ops.size()); 55753 return New.getNode(); 55754 } 55755 55756 SDNode *Select_UNDEF(const SDValue &N) { 55757 return CurDAG->SelectNodeTo(N.getNode(), TargetInstrInfo::IMPLICIT_DEF, 55758 N.getValueType()); 55759 } 55760 55761 SDNode *Select_DBG_LABEL(const SDValue &N) { 55762 SDValue Chain = N.getOperand(0); 55763 unsigned C = cast<LabelSDNode>(N)->getLabelID(); 55764 SDValue Tmp = CurDAG->getTargetConstant(C, MVT::i32); 55765 return CurDAG->SelectNodeTo(N.getNode(), TargetInstrInfo::DBG_LABEL, 55766 MVT::Other, Tmp, Chain); 55767 } 55768 55769 SDNode *Select_EH_LABEL(const SDValue &N) { 55770 SDValue Chain = N.getOperand(0); 55771 unsigned C = cast<LabelSDNode>(N)->getLabelID(); 55772 SDValue Tmp = CurDAG->getTargetConstant(C, MVT::i32); 55773 return CurDAG->SelectNodeTo(N.getNode(), TargetInstrInfo::EH_LABEL, 55774 MVT::Other, Tmp, Chain); 55775 } 55776 55777 SDNode *Select_DECLARE(const SDValue &N) { 55778 SDValue Chain = N.getOperand(0); 55779 SDValue N1 = N.getOperand(1); 55780 SDValue N2 = N.getOperand(2); 55781 if (!isa<FrameIndexSDNode>(N1) || !isa<GlobalAddressSDNode>(N2)) { 55782 CannotYetSelect(N); 55783 } 55784 int FI = cast<FrameIndexSDNode>(N1)->getIndex(); 55785 GlobalValue *GV = cast<GlobalAddressSDNode>(N2)->getGlobal(); 55786 SDValue Tmp1 = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy()); 55787 SDValue Tmp2 = CurDAG->getTargetGlobalAddress(GV, TLI.getPointerTy()); 55788 return CurDAG->SelectNodeTo(N.getNode(), TargetInstrInfo::DECLARE, 55789 MVT::Other, Tmp1, Tmp2, Chain); 55790 } 55791 55792 // The main instruction selector code. 55793 SDNode *SelectCode(SDValue N) { 55794 MVT::SimpleValueType NVT = N.getNode()->getValueType(0).getSimpleVT().SimpleTy; 55795 switch (N.getOpcode()) { 55796 default: 55797 assert(!N.isMachineOpcode() && "Node already selected!"); 55798 break; 55799 case ISD::EntryToken: // These nodes remain the same. 55800 case ISD::MEMOPERAND: 55801 case ISD::BasicBlock: 55802 case ISD::Register: 55803 case ISD::HANDLENODE: 55804 case ISD::TargetConstant: 55805 case ISD::TargetConstantFP: 55806 case ISD::TargetConstantPool: 55807 case ISD::TargetFrameIndex: 55808 case ISD::TargetExternalSymbol: 55809 case ISD::TargetJumpTable: 55810 case ISD::TargetGlobalTLSAddress: 55811 case ISD::TargetGlobalAddress: 55812 case ISD::TokenFactor: 55813 case ISD::CopyFromReg: 55814 case ISD::CopyToReg: { 55815 return NULL; 55816 } 55817 case ISD::AssertSext: 55818 case ISD::AssertZext: { 55819 ReplaceUses(N, N.getOperand(0)); 55820 return NULL; 55821 } 55822 case ISD::INLINEASM: return Select_INLINEASM(N); 55823 case ISD::DBG_LABEL: return Select_DBG_LABEL(N); 55824 case ISD::EH_LABEL: return Select_EH_LABEL(N); 55825 case ISD::DECLARE: return Select_DECLARE(N); 55826 case ISD::UNDEF: return Select_UNDEF(N); 55827 case ISD::ADD: { 55828 switch (NVT) { 55829 case MVT::i8: 55830 return Select_ISD_ADD_i8(N); 55831 case MVT::i16: 55832 return Select_ISD_ADD_i16(N); 55833 case MVT::i32: 55834 return Select_ISD_ADD_i32(N); 55835 case MVT::i64: 55836 return Select_ISD_ADD_i64(N); 55837 case MVT::v8i8: 55838 return Select_ISD_ADD_v8i8(N); 55839 case MVT::v16i8: 55840 return Select_ISD_ADD_v16i8(N); 55841 case MVT::v4i16: 55842 return Select_ISD_ADD_v4i16(N); 55843 case MVT::v8i16: 55844 return Select_ISD_ADD_v8i16(N); 55845 case MVT::v2i32: 55846 return Select_ISD_ADD_v2i32(N); 55847 case MVT::v4i32: 55848 return Select_ISD_ADD_v4i32(N); 55849 case MVT::v1i64: 55850 return Select_ISD_ADD_v1i64(N); 55851 case MVT::v2i64: 55852 return Select_ISD_ADD_v2i64(N); 55853 default: 55854 break; 55855 } 55856 break; 55857 } 55858 case ISD::ADDC: { 55859 switch (NVT) { 55860 case MVT::i32: 55861 return Select_ISD_ADDC_i32(N); 55862 case MVT::i64: 55863 return Select_ISD_ADDC_i64(N); 55864 default: 55865 break; 55866 } 55867 break; 55868 } 55869 case ISD::ADDE: { 55870 switch (NVT) { 55871 case MVT::i8: 55872 return Select_ISD_ADDE_i8(N); 55873 case MVT::i16: 55874 return Select_ISD_ADDE_i16(N); 55875 case MVT::i32: 55876 return Select_ISD_ADDE_i32(N); 55877 case MVT::i64: 55878 return Select_ISD_ADDE_i64(N); 55879 default: 55880 break; 55881 } 55882 break; 55883 } 55884 case ISD::AND: { 55885 switch (NVT) { 55886 case MVT::i8: 55887 return Select_ISD_AND_i8(N); 55888 case MVT::i16: 55889 return Select_ISD_AND_i16(N); 55890 case MVT::i32: 55891 return Select_ISD_AND_i32(N); 55892 case MVT::i64: 55893 return Select_ISD_AND_i64(N); 55894 case MVT::v1i64: 55895 return Select_ISD_AND_v1i64(N); 55896 case MVT::v2i64: 55897 return Select_ISD_AND_v2i64(N); 55898 default: 55899 break; 55900 } 55901 break; 55902 } 55903 case ISD::ANY_EXTEND: { 55904 switch (NVT) { 55905 case MVT::i16: 55906 return Select_ISD_ANY_EXTEND_i16(N); 55907 case MVT::i32: 55908 return Select_ISD_ANY_EXTEND_i32(N); 55909 case MVT::i64: 55910 return Select_ISD_ANY_EXTEND_i64(N); 55911 default: 55912 break; 55913 } 55914 break; 55915 } 55916 case ISD::ATOMIC_LOAD_ADD: { 55917 switch (NVT) { 55918 case MVT::i8: 55919 return Select_ISD_ATOMIC_LOAD_ADD_i8(N); 55920 case MVT::i16: 55921 return Select_ISD_ATOMIC_LOAD_ADD_i16(N); 55922 case MVT::i32: 55923 return Select_ISD_ATOMIC_LOAD_ADD_i32(N); 55924 case MVT::i64: 55925 return Select_ISD_ATOMIC_LOAD_ADD_i64(N); 55926 default: 55927 break; 55928 } 55929 break; 55930 } 55931 case ISD::ATOMIC_LOAD_AND: { 55932 switch (NVT) { 55933 case MVT::i8: 55934 return Select_ISD_ATOMIC_LOAD_AND_i8(N); 55935 case MVT::i16: 55936 return Select_ISD_ATOMIC_LOAD_AND_i16(N); 55937 case MVT::i32: 55938 return Select_ISD_ATOMIC_LOAD_AND_i32(N); 55939 case MVT::i64: 55940 return Select_ISD_ATOMIC_LOAD_AND_i64(N); 55941 default: 55942 break; 55943 } 55944 break; 55945 } 55946 case ISD::ATOMIC_LOAD_MAX: { 55947 switch (NVT) { 55948 case MVT::i16: 55949 return Select_ISD_ATOMIC_LOAD_MAX_i16(N); 55950 case MVT::i32: 55951 return Select_ISD_ATOMIC_LOAD_MAX_i32(N); 55952 case MVT::i64: 55953 return Select_ISD_ATOMIC_LOAD_MAX_i64(N); 55954 default: 55955 break; 55956 } 55957 break; 55958 } 55959 case ISD::ATOMIC_LOAD_MIN: { 55960 switch (NVT) { 55961 case MVT::i16: 55962 return Select_ISD_ATOMIC_LOAD_MIN_i16(N); 55963 case MVT::i32: 55964 return Select_ISD_ATOMIC_LOAD_MIN_i32(N); 55965 case MVT::i64: 55966 return Select_ISD_ATOMIC_LOAD_MIN_i64(N); 55967 default: 55968 break; 55969 } 55970 break; 55971 } 55972 case ISD::ATOMIC_LOAD_NAND: { 55973 switch (NVT) { 55974 case MVT::i8: 55975 return Select_ISD_ATOMIC_LOAD_NAND_i8(N); 55976 case MVT::i16: 55977 return Select_ISD_ATOMIC_LOAD_NAND_i16(N); 55978 case MVT::i32: 55979 return Select_ISD_ATOMIC_LOAD_NAND_i32(N); 55980 case MVT::i64: 55981 return Select_ISD_ATOMIC_LOAD_NAND_i64(N); 55982 default: 55983 break; 55984 } 55985 break; 55986 } 55987 case ISD::ATOMIC_LOAD_OR: { 55988 switch (NVT) { 55989 case MVT::i8: 55990 return Select_ISD_ATOMIC_LOAD_OR_i8(N); 55991 case MVT::i16: 55992 return Select_ISD_ATOMIC_LOAD_OR_i16(N); 55993 case MVT::i32: 55994 return Select_ISD_ATOMIC_LOAD_OR_i32(N); 55995 case MVT::i64: 55996 return Select_ISD_ATOMIC_LOAD_OR_i64(N); 55997 default: 55998 break; 55999 } 56000 break; 56001 } 56002 case ISD::ATOMIC_LOAD_UMAX: { 56003 switch (NVT) { 56004 case MVT::i16: 56005 return Select_ISD_ATOMIC_LOAD_UMAX_i16(N); 56006 case MVT::i32: 56007 return Select_ISD_ATOMIC_LOAD_UMAX_i32(N); 56008 case MVT::i64: 56009 return Select_ISD_ATOMIC_LOAD_UMAX_i64(N); 56010 default: 56011 break; 56012 } 56013 break; 56014 } 56015 case ISD::ATOMIC_LOAD_UMIN: { 56016 switch (NVT) { 56017 case MVT::i16: 56018 return Select_ISD_ATOMIC_LOAD_UMIN_i16(N); 56019 case MVT::i32: 56020 return Select_ISD_ATOMIC_LOAD_UMIN_i32(N); 56021 case MVT::i64: 56022 return Select_ISD_ATOMIC_LOAD_UMIN_i64(N); 56023 default: 56024 break; 56025 } 56026 break; 56027 } 56028 case ISD::ATOMIC_LOAD_XOR: { 56029 switch (NVT) { 56030 case MVT::i8: 56031 return Select_ISD_ATOMIC_LOAD_XOR_i8(N); 56032 case MVT::i16: 56033 return Select_ISD_ATOMIC_LOAD_XOR_i16(N); 56034 case MVT::i32: 56035 return Select_ISD_ATOMIC_LOAD_XOR_i32(N); 56036 case MVT::i64: 56037 return Select_ISD_ATOMIC_LOAD_XOR_i64(N); 56038 default: 56039 break; 56040 } 56041 break; 56042 } 56043 case ISD::ATOMIC_SWAP: { 56044 switch (NVT) { 56045 case MVT::i8: 56046 return Select_ISD_ATOMIC_SWAP_i8(N); 56047 case MVT::i16: 56048 return Select_ISD_ATOMIC_SWAP_i16(N); 56049 case MVT::i32: 56050 return Select_ISD_ATOMIC_SWAP_i32(N); 56051 case MVT::i64: 56052 return Select_ISD_ATOMIC_SWAP_i64(N); 56053 default: 56054 break; 56055 } 56056 break; 56057 } 56058 case ISD::BIT_CONVERT: { 56059 switch (NVT) { 56060 case MVT::i32: 56061 return Select_ISD_BIT_CONVERT_i32(N); 56062 case MVT::i64: 56063 return Select_ISD_BIT_CONVERT_i64(N); 56064 case MVT::f32: 56065 return Select_ISD_BIT_CONVERT_f32(N); 56066 case MVT::f64: 56067 return Select_ISD_BIT_CONVERT_f64(N); 56068 case MVT::v8i8: 56069 return Select_ISD_BIT_CONVERT_v8i8(N); 56070 case MVT::v16i8: 56071 return Select_ISD_BIT_CONVERT_v16i8(N); 56072 case MVT::v4i16: 56073 return Select_ISD_BIT_CONVERT_v4i16(N); 56074 case MVT::v8i16: 56075 return Select_ISD_BIT_CONVERT_v8i16(N); 56076 case MVT::v2i32: 56077 return Select_ISD_BIT_CONVERT_v2i32(N); 56078 case MVT::v4i32: 56079 return Select_ISD_BIT_CONVERT_v4i32(N); 56080 case MVT::v1i64: 56081 return Select_ISD_BIT_CONVERT_v1i64(N); 56082 case MVT::v2i64: 56083 return Select_ISD_BIT_CONVERT_v2i64(N); 56084 case MVT::v2f32: 56085 return Select_ISD_BIT_CONVERT_v2f32(N); 56086 case MVT::v4f32: 56087 return Select_ISD_BIT_CONVERT_v4f32(N); 56088 case MVT::v2f64: 56089 return Select_ISD_BIT_CONVERT_v2f64(N); 56090 default: 56091 break; 56092 } 56093 break; 56094 } 56095 case ISD::BR: { 56096 return Select_ISD_BR(N); 56097 break; 56098 } 56099 case ISD::BRIND: { 56100 return Select_ISD_BRIND(N); 56101 break; 56102 } 56103 case ISD::BSWAP: { 56104 switch (NVT) { 56105 case MVT::i32: 56106 return Select_ISD_BSWAP_i32(N); 56107 case MVT::i64: 56108 return Select_ISD_BSWAP_i64(N); 56109 default: 56110 break; 56111 } 56112 break; 56113 } 56114 case ISD::BUILD_VECTOR: { 56115 switch (NVT) { 56116 case MVT::v8i8: 56117 return Select_ISD_BUILD_VECTOR_v8i8(N); 56118 case MVT::v16i8: 56119 return Select_ISD_BUILD_VECTOR_v16i8(N); 56120 case MVT::v4i16: 56121 return Select_ISD_BUILD_VECTOR_v4i16(N); 56122 case MVT::v8i16: 56123 return Select_ISD_BUILD_VECTOR_v8i16(N); 56124 case MVT::v2i32: 56125 return Select_ISD_BUILD_VECTOR_v2i32(N); 56126 case MVT::v4i32: 56127 return Select_ISD_BUILD_VECTOR_v4i32(N); 56128 case MVT::v1i64: 56129 return Select_ISD_BUILD_VECTOR_v1i64(N); 56130 case MVT::v2i64: 56131 return Select_ISD_BUILD_VECTOR_v2i64(N); 56132 case MVT::v4f32: 56133 return Select_ISD_BUILD_VECTOR_v4f32(N); 56134 case MVT::v2f64: 56135 return Select_ISD_BUILD_VECTOR_v2f64(N); 56136 default: 56137 break; 56138 } 56139 break; 56140 } 56141 case ISD::CALLSEQ_END: { 56142 return Select_ISD_CALLSEQ_END(N); 56143 break; 56144 } 56145 case ISD::CALLSEQ_START: { 56146 return Select_ISD_CALLSEQ_START(N); 56147 break; 56148 } 56149 case ISD::Constant: { 56150 switch (NVT) { 56151 case MVT::i8: 56152 return Select_ISD_Constant_i8(N); 56153 case MVT::i16: 56154 return Select_ISD_Constant_i16(N); 56155 case MVT::i32: 56156 return Select_ISD_Constant_i32(N); 56157 case MVT::i64: 56158 return Select_ISD_Constant_i64(N); 56159 default: 56160 break; 56161 } 56162 break; 56163 } 56164 case ISD::ConstantFP: { 56165 switch (NVT) { 56166 case MVT::f32: 56167 return Select_ISD_ConstantFP_f32(N); 56168 case MVT::f64: 56169 return Select_ISD_ConstantFP_f64(N); 56170 case MVT::f80: 56171 return Select_ISD_ConstantFP_f80(N); 56172 default: 56173 break; 56174 } 56175 break; 56176 } 56177 case ISD::DEBUG_LOC: { 56178 return Select_ISD_DEBUG_LOC(N); 56179 break; 56180 } 56181 case ISD::EXTRACT_VECTOR_ELT: { 56182 switch (NVT) { 56183 case MVT::i32: 56184 return Select_ISD_EXTRACT_VECTOR_ELT_i32(N); 56185 case MVT::i64: 56186 return Select_ISD_EXTRACT_VECTOR_ELT_i64(N); 56187 case MVT::f32: 56188 return Select_ISD_EXTRACT_VECTOR_ELT_f32(N); 56189 case MVT::f64: 56190 return Select_ISD_EXTRACT_VECTOR_ELT_f64(N); 56191 default: 56192 break; 56193 } 56194 break; 56195 } 56196 case ISD::FABS: { 56197 switch (NVT) { 56198 case MVT::f32: 56199 return Select_ISD_FABS_f32(N); 56200 case MVT::f64: 56201 return Select_ISD_FABS_f64(N); 56202 case MVT::f80: 56203 return Select_ISD_FABS_f80(N); 56204 default: 56205 break; 56206 } 56207 break; 56208 } 56209 case ISD::FADD: { 56210 switch (NVT) { 56211 case MVT::f32: 56212 return Select_ISD_FADD_f32(N); 56213 case MVT::f64: 56214 return Select_ISD_FADD_f64(N); 56215 case MVT::f80: 56216 return Select_ISD_FADD_f80(N); 56217 case MVT::v4f32: 56218 return Select_ISD_FADD_v4f32(N); 56219 case MVT::v2f64: 56220 return Select_ISD_FADD_v2f64(N); 56221 default: 56222 break; 56223 } 56224 break; 56225 } 56226 case ISD::FCOS: { 56227 switch (NVT) { 56228 case MVT::f32: 56229 return Select_ISD_FCOS_f32(N); 56230 case MVT::f64: 56231 return Select_ISD_FCOS_f64(N); 56232 case MVT::f80: 56233 return Select_ISD_FCOS_f80(N); 56234 default: 56235 break; 56236 } 56237 break; 56238 } 56239 case ISD::FDIV: { 56240 switch (NVT) { 56241 case MVT::f32: 56242 return Select_ISD_FDIV_f32(N); 56243 case MVT::f64: 56244 return Select_ISD_FDIV_f64(N); 56245 case MVT::f80: 56246 return Select_ISD_FDIV_f80(N); 56247 case MVT::v4f32: 56248 return Select_ISD_FDIV_v4f32(N); 56249 case MVT::v2f64: 56250 return Select_ISD_FDIV_v2f64(N); 56251 default: 56252 break; 56253 } 56254 break; 56255 } 56256 case ISD::FMUL: { 56257 switch (NVT) { 56258 case MVT::f32: 56259 return Select_ISD_FMUL_f32(N); 56260 case MVT::f64: 56261 return Select_ISD_FMUL_f64(N); 56262 case MVT::f80: 56263 return Select_ISD_FMUL_f80(N); 56264 case MVT::v4f32: 56265 return Select_ISD_FMUL_v4f32(N); 56266 case MVT::v2f64: 56267 return Select_ISD_FMUL_v2f64(N); 56268 default: 56269 break; 56270 } 56271 break; 56272 } 56273 case ISD::FNEG: { 56274 switch (NVT) { 56275 case MVT::f32: 56276 return Select_ISD_FNEG_f32(N); 56277 case MVT::f64: 56278 return Select_ISD_FNEG_f64(N); 56279 case MVT::f80: 56280 return Select_ISD_FNEG_f80(N); 56281 default: 56282 break; 56283 } 56284 break; 56285 } 56286 case ISD::FP_EXTEND: { 56287 switch (NVT) { 56288 case MVT::f64: 56289 return Select_ISD_FP_EXTEND_f64(N); 56290 case MVT::f80: 56291 return Select_ISD_FP_EXTEND_f80(N); 56292 default: 56293 break; 56294 } 56295 break; 56296 } 56297 case ISD::FP_ROUND: { 56298 switch (NVT) { 56299 case MVT::f32: 56300 return Select_ISD_FP_ROUND_f32(N); 56301 case MVT::f64: 56302 return Select_ISD_FP_ROUND_f64(N); 56303 default: 56304 break; 56305 } 56306 break; 56307 } 56308 case ISD::FP_TO_SINT: { 56309 switch (NVT) { 56310 case MVT::i32: 56311 return Select_ISD_FP_TO_SINT_i32(N); 56312 case MVT::i64: 56313 return Select_ISD_FP_TO_SINT_i64(N); 56314 case MVT::v2i32: 56315 return Select_ISD_FP_TO_SINT_v2i32(N); 56316 case MVT::v4i32: 56317 return Select_ISD_FP_TO_SINT_v4i32(N); 56318 default: 56319 break; 56320 } 56321 break; 56322 } 56323 case ISD::FSIN: { 56324 switch (NVT) { 56325 case MVT::f32: 56326 return Select_ISD_FSIN_f32(N); 56327 case MVT::f64: 56328 return Select_ISD_FSIN_f64(N); 56329 case MVT::f80: 56330 return Select_ISD_FSIN_f80(N); 56331 default: 56332 break; 56333 } 56334 break; 56335 } 56336 case ISD::FSQRT: { 56337 switch (NVT) { 56338 case MVT::f32: 56339 return Select_ISD_FSQRT_f32(N); 56340 case MVT::f64: 56341 return Select_ISD_FSQRT_f64(N); 56342 case MVT::f80: 56343 return Select_ISD_FSQRT_f80(N); 56344 case MVT::v4f32: 56345 return Select_ISD_FSQRT_v4f32(N); 56346 case MVT::v2f64: 56347 return Select_ISD_FSQRT_v2f64(N); 56348 default: 56349 break; 56350 } 56351 break; 56352 } 56353 case ISD::FSUB: { 56354 switch (NVT) { 56355 case MVT::f32: 56356 return Select_ISD_FSUB_f32(N); 56357 case MVT::f64: 56358 return Select_ISD_FSUB_f64(N); 56359 case MVT::f80: 56360 return Select_ISD_FSUB_f80(N); 56361 case MVT::v4f32: 56362 return Select_ISD_FSUB_v4f32(N); 56363 case MVT::v2f64: 56364 return Select_ISD_FSUB_v2f64(N); 56365 default: 56366 break; 56367 } 56368 break; 56369 } 56370 case ISD::FrameIndex: { 56371 switch (NVT) { 56372 case MVT::i32: 56373 return Select_ISD_FrameIndex_i32(N); 56374 case MVT::i64: 56375 return Select_ISD_FrameIndex_i64(N); 56376 default: 56377 break; 56378 } 56379 break; 56380 } 56381 case ISD::INSERT_VECTOR_ELT: { 56382 switch (NVT) { 56383 case MVT::v4i32: 56384 return Select_ISD_INSERT_VECTOR_ELT_v4i32(N); 56385 case MVT::v2i64: 56386 return Select_ISD_INSERT_VECTOR_ELT_v2i64(N); 56387 default: 56388 break; 56389 } 56390 break; 56391 } 56392 case ISD::INTRINSIC_VOID: { 56393 return Select_ISD_INTRINSIC_VOID(N); 56394 break; 56395 } 56396 case ISD::INTRINSIC_WO_CHAIN: { 56397 switch (NVT) { 56398 case MVT::i32: 56399 return Select_ISD_INTRINSIC_WO_CHAIN_i32(N); 56400 case MVT::i64: 56401 return Select_ISD_INTRINSIC_WO_CHAIN_i64(N); 56402 case MVT::v8i8: 56403 return Select_ISD_INTRINSIC_WO_CHAIN_v8i8(N); 56404 case MVT::v16i8: 56405 return Select_ISD_INTRINSIC_WO_CHAIN_v16i8(N); 56406 case MVT::v4i16: 56407 return Select_ISD_INTRINSIC_WO_CHAIN_v4i16(N); 56408 case MVT::v8i16: 56409 return Select_ISD_INTRINSIC_WO_CHAIN_v8i16(N); 56410 case MVT::v2i32: 56411 return Select_ISD_INTRINSIC_WO_CHAIN_v2i32(N); 56412 case MVT::v4i32: 56413 return Select_ISD_INTRINSIC_WO_CHAIN_v4i32(N); 56414 case MVT::v1i64: 56415 return Select_ISD_INTRINSIC_WO_CHAIN_v1i64(N); 56416 case MVT::v2i64: 56417 return Select_ISD_INTRINSIC_WO_CHAIN_v2i64(N); 56418 case MVT::v4f32: 56419 return Select_ISD_INTRINSIC_WO_CHAIN_v4f32(N); 56420 case MVT::v2f64: 56421 return Select_ISD_INTRINSIC_WO_CHAIN_v2f64(N); 56422 default: 56423 break; 56424 } 56425 break; 56426 } 56427 case ISD::INTRINSIC_W_CHAIN: { 56428 switch (NVT) { 56429 case MVT::v16i8: 56430 return Select_ISD_INTRINSIC_W_CHAIN_v16i8(N); 56431 case MVT::v2i64: 56432 return Select_ISD_INTRINSIC_W_CHAIN_v2i64(N); 56433 case MVT::v4f32: 56434 return Select_ISD_INTRINSIC_W_CHAIN_v4f32(N); 56435 case MVT::v2f64: 56436 return Select_ISD_INTRINSIC_W_CHAIN_v2f64(N); 56437 default: 56438 break; 56439 } 56440 break; 56441 } 56442 case ISD::LOAD: { 56443 switch (NVT) { 56444 case MVT::i8: 56445 return Select_ISD_LOAD_i8(N); 56446 case MVT::i16: 56447 return Select_ISD_LOAD_i16(N); 56448 case MVT::i32: 56449 return Select_ISD_LOAD_i32(N); 56450 case MVT::i64: 56451 return Select_ISD_LOAD_i64(N); 56452 case MVT::f32: 56453 return Select_ISD_LOAD_f32(N); 56454 case MVT::f64: 56455 return Select_ISD_LOAD_f64(N); 56456 case MVT::f80: 56457 return Select_ISD_LOAD_f80(N); 56458 case MVT::v4i32: 56459 return Select_ISD_LOAD_v4i32(N); 56460 case MVT::v1i64: 56461 return Select_ISD_LOAD_v1i64(N); 56462 case MVT::v2i64: 56463 return Select_ISD_LOAD_v2i64(N); 56464 case MVT::v4f32: 56465 return Select_ISD_LOAD_v4f32(N); 56466 case MVT::v2f64: 56467 return Select_ISD_LOAD_v2f64(N); 56468 default: 56469 break; 56470 } 56471 break; 56472 } 56473 case ISD::MEMBARRIER: { 56474 return Select_ISD_MEMBARRIER(N); 56475 break; 56476 } 56477 case ISD::MUL: { 56478 switch (NVT) { 56479 case MVT::i8: 56480 return Select_ISD_MUL_i8(N); 56481 case MVT::i16: 56482 return Select_ISD_MUL_i16(N); 56483 case MVT::i32: 56484 return Select_ISD_MUL_i32(N); 56485 case MVT::i64: 56486 return Select_ISD_MUL_i64(N); 56487 case MVT::v16i8: 56488 return Select_ISD_MUL_v16i8(N); 56489 case MVT::v4i16: 56490 return Select_ISD_MUL_v4i16(N); 56491 case MVT::v8i16: 56492 return Select_ISD_MUL_v8i16(N); 56493 case MVT::v4i32: 56494 return Select_ISD_MUL_v4i32(N); 56495 default: 56496 break; 56497 } 56498 break; 56499 } 56500 case ISD::OR: { 56501 switch (NVT) { 56502 case MVT::i8: 56503 return Select_ISD_OR_i8(N); 56504 case MVT::i16: 56505 return Select_ISD_OR_i16(N); 56506 case MVT::i32: 56507 return Select_ISD_OR_i32(N); 56508 case MVT::i64: 56509 return Select_ISD_OR_i64(N); 56510 case MVT::v1i64: 56511 return Select_ISD_OR_v1i64(N); 56512 case MVT::v2i64: 56513 return Select_ISD_OR_v2i64(N); 56514 default: 56515 break; 56516 } 56517 break; 56518 } 56519 case ISD::PREFETCH: { 56520 return Select_ISD_PREFETCH(N); 56521 break; 56522 } 56523 case ISD::ROTL: { 56524 switch (NVT) { 56525 case MVT::i8: 56526 return Select_ISD_ROTL_i8(N); 56527 case MVT::i16: 56528 return Select_ISD_ROTL_i16(N); 56529 case MVT::i32: 56530 return Select_ISD_ROTL_i32(N); 56531 case MVT::i64: 56532 return Select_ISD_ROTL_i64(N); 56533 default: 56534 break; 56535 } 56536 break; 56537 } 56538 case ISD::ROTR: { 56539 switch (NVT) { 56540 case MVT::i8: 56541 return Select_ISD_ROTR_i8(N); 56542 case MVT::i16: 56543 return Select_ISD_ROTR_i16(N); 56544 case MVT::i32: 56545 return Select_ISD_ROTR_i32(N); 56546 case MVT::i64: 56547 return Select_ISD_ROTR_i64(N); 56548 default: 56549 break; 56550 } 56551 break; 56552 } 56553 case ISD::SCALAR_TO_VECTOR: { 56554 switch (NVT) { 56555 case MVT::v2i32: 56556 return Select_ISD_SCALAR_TO_VECTOR_v2i32(N); 56557 case MVT::v4i32: 56558 return Select_ISD_SCALAR_TO_VECTOR_v4i32(N); 56559 case MVT::v1i64: 56560 return Select_ISD_SCALAR_TO_VECTOR_v1i64(N); 56561 case MVT::v2i64: 56562 return Select_ISD_SCALAR_TO_VECTOR_v2i64(N); 56563 case MVT::v4f32: 56564 return Select_ISD_SCALAR_TO_VECTOR_v4f32(N); 56565 case MVT::v2f64: 56566 return Select_ISD_SCALAR_TO_VECTOR_v2f64(N); 56567 default: 56568 break; 56569 } 56570 break; 56571 } 56572 case ISD::SHL: { 56573 switch (NVT) { 56574 case MVT::i8: 56575 return Select_ISD_SHL_i8(N); 56576 case MVT::i16: 56577 return Select_ISD_SHL_i16(N); 56578 case MVT::i32: 56579 return Select_ISD_SHL_i32(N); 56580 case MVT::i64: 56581 return Select_ISD_SHL_i64(N); 56582 default: 56583 break; 56584 } 56585 break; 56586 } 56587 case ISD::SIGN_EXTEND: { 56588 switch (NVT) { 56589 case MVT::i16: 56590 return Select_ISD_SIGN_EXTEND_i16(N); 56591 case MVT::i32: 56592 return Select_ISD_SIGN_EXTEND_i32(N); 56593 case MVT::i64: 56594 return Select_ISD_SIGN_EXTEND_i64(N); 56595 default: 56596 break; 56597 } 56598 break; 56599 } 56600 case ISD::SIGN_EXTEND_INREG: { 56601 switch (NVT) { 56602 case MVT::i16: 56603 return Select_ISD_SIGN_EXTEND_INREG_i16(N); 56604 case MVT::i32: 56605 return Select_ISD_SIGN_EXTEND_INREG_i32(N); 56606 case MVT::i64: 56607 return Select_ISD_SIGN_EXTEND_INREG_i64(N); 56608 default: 56609 break; 56610 } 56611 break; 56612 } 56613 case ISD::SINT_TO_FP: { 56614 switch (NVT) { 56615 case MVT::f32: 56616 return Select_ISD_SINT_TO_FP_f32(N); 56617 case MVT::f64: 56618 return Select_ISD_SINT_TO_FP_f64(N); 56619 case MVT::v4f32: 56620 return Select_ISD_SINT_TO_FP_v4f32(N); 56621 case MVT::v2f64: 56622 return Select_ISD_SINT_TO_FP_v2f64(N); 56623 default: 56624 break; 56625 } 56626 break; 56627 } 56628 case ISD::SRA: { 56629 switch (NVT) { 56630 case MVT::i8: 56631 return Select_ISD_SRA_i8(N); 56632 case MVT::i16: 56633 return Select_ISD_SRA_i16(N); 56634 case MVT::i32: 56635 return Select_ISD_SRA_i32(N); 56636 case MVT::i64: 56637 return Select_ISD_SRA_i64(N); 56638 default: 56639 break; 56640 } 56641 break; 56642 } 56643 case ISD::SRL: { 56644 switch (NVT) { 56645 case MVT::i8: 56646 return Select_ISD_SRL_i8(N); 56647 case MVT::i16: 56648 return Select_ISD_SRL_i16(N); 56649 case MVT::i32: 56650 return Select_ISD_SRL_i32(N); 56651 case MVT::i64: 56652 return Select_ISD_SRL_i64(N); 56653 default: 56654 break; 56655 } 56656 break; 56657 } 56658 case ISD::STORE: { 56659 return Select_ISD_STORE(N); 56660 break; 56661 } 56662 case ISD::SUB: { 56663 switch (NVT) { 56664 case MVT::i8: 56665 return Select_ISD_SUB_i8(N); 56666 case MVT::i16: 56667 return Select_ISD_SUB_i16(N); 56668 case MVT::i32: 56669 return Select_ISD_SUB_i32(N); 56670 case MVT::i64: 56671 return Select_ISD_SUB_i64(N); 56672 case MVT::v8i8: 56673 return Select_ISD_SUB_v8i8(N); 56674 case MVT::v16i8: 56675 return Select_ISD_SUB_v16i8(N); 56676 case MVT::v4i16: 56677 return Select_ISD_SUB_v4i16(N); 56678 case MVT::v8i16: 56679 return Select_ISD_SUB_v8i16(N); 56680 case MVT::v2i32: 56681 return Select_ISD_SUB_v2i32(N); 56682 case MVT::v4i32: 56683 return Select_ISD_SUB_v4i32(N); 56684 case MVT::v1i64: 56685 return Select_ISD_SUB_v1i64(N); 56686 case MVT::v2i64: 56687 return Select_ISD_SUB_v2i64(N); 56688 default: 56689 break; 56690 } 56691 break; 56692 } 56693 case ISD::SUBC: { 56694 switch (NVT) { 56695 case MVT::i32: 56696 return Select_ISD_SUBC_i32(N); 56697 case MVT::i64: 56698 return Select_ISD_SUBC_i64(N); 56699 default: 56700 break; 56701 } 56702 break; 56703 } 56704 case ISD::SUBE: { 56705 switch (NVT) { 56706 case MVT::i8: 56707 return Select_ISD_SUBE_i8(N); 56708 case MVT::i16: 56709 return Select_ISD_SUBE_i16(N); 56710 case MVT::i32: 56711 return Select_ISD_SUBE_i32(N); 56712 case MVT::i64: 56713 return Select_ISD_SUBE_i64(N); 56714 default: 56715 break; 56716 } 56717 break; 56718 } 56719 case ISD::TRAP: { 56720 return Select_ISD_TRAP(N); 56721 break; 56722 } 56723 case ISD::TRUNCATE: { 56724 switch (NVT) { 56725 case MVT::i8: 56726 return Select_ISD_TRUNCATE_i8(N); 56727 case MVT::i16: 56728 return Select_ISD_TRUNCATE_i16(N); 56729 case MVT::i32: 56730 return Select_ISD_TRUNCATE_i32(N); 56731 default: 56732 break; 56733 } 56734 break; 56735 } 56736 case ISD::VECTOR_SHUFFLE: { 56737 switch (NVT) { 56738 case MVT::v8i8: 56739 return Select_ISD_VECTOR_SHUFFLE_v8i8(N); 56740 case MVT::v16i8: 56741 return Select_ISD_VECTOR_SHUFFLE_v16i8(N); 56742 case MVT::v4i16: 56743 return Select_ISD_VECTOR_SHUFFLE_v4i16(N); 56744 case MVT::v8i16: 56745 return Select_ISD_VECTOR_SHUFFLE_v8i16(N); 56746 case MVT::v2i32: 56747 return Select_ISD_VECTOR_SHUFFLE_v2i32(N); 56748 case MVT::v4i32: 56749 return Select_ISD_VECTOR_SHUFFLE_v4i32(N); 56750 case MVT::v2i64: 56751 return Select_ISD_VECTOR_SHUFFLE_v2i64(N); 56752 case MVT::v4f32: 56753 return Select_ISD_VECTOR_SHUFFLE_v4f32(N); 56754 case MVT::v2f64: 56755 return Select_ISD_VECTOR_SHUFFLE_v2f64(N); 56756 default: 56757 break; 56758 } 56759 break; 56760 } 56761 case ISD::XOR: { 56762 switch (NVT) { 56763 case MVT::i8: 56764 return Select_ISD_XOR_i8(N); 56765 case MVT::i16: 56766 return Select_ISD_XOR_i16(N); 56767 case MVT::i32: 56768 return Select_ISD_XOR_i32(N); 56769 case MVT::i64: 56770 return Select_ISD_XOR_i64(N); 56771 case MVT::v1i64: 56772 return Select_ISD_XOR_v1i64(N); 56773 case MVT::v2i64: 56774 return Select_ISD_XOR_v2i64(N); 56775 default: 56776 break; 56777 } 56778 break; 56779 } 56780 case ISD::ZERO_EXTEND: { 56781 switch (NVT) { 56782 case MVT::i16: 56783 return Select_ISD_ZERO_EXTEND_i16(N); 56784 case MVT::i32: 56785 return Select_ISD_ZERO_EXTEND_i32(N); 56786 case MVT::i64: 56787 return Select_ISD_ZERO_EXTEND_i64(N); 56788 default: 56789 break; 56790 } 56791 break; 56792 } 56793 case X86ISD::ADD: { 56794 switch (NVT) { 56795 case MVT::i8: 56796 return Select_X86ISD_ADD_i8(N); 56797 case MVT::i16: 56798 return Select_X86ISD_ADD_i16(N); 56799 case MVT::i32: 56800 return Select_X86ISD_ADD_i32(N); 56801 case MVT::i64: 56802 return Select_X86ISD_ADD_i64(N); 56803 default: 56804 break; 56805 } 56806 break; 56807 } 56808 case X86ISD::BRCOND: { 56809 return Select_X86ISD_BRCOND(N); 56810 break; 56811 } 56812 case X86ISD::BSF: { 56813 switch (NVT) { 56814 case MVT::i16: 56815 return Select_X86ISD_BSF_i16(N); 56816 case MVT::i32: 56817 return Select_X86ISD_BSF_i32(N); 56818 case MVT::i64: 56819 return Select_X86ISD_BSF_i64(N); 56820 default: 56821 break; 56822 } 56823 break; 56824 } 56825 case X86ISD::BSR: { 56826 switch (NVT) { 56827 case MVT::i16: 56828 return Select_X86ISD_BSR_i16(N); 56829 case MVT::i32: 56830 return Select_X86ISD_BSR_i32(N); 56831 case MVT::i64: 56832 return Select_X86ISD_BSR_i64(N); 56833 default: 56834 break; 56835 } 56836 break; 56837 } 56838 case X86ISD::BT: { 56839 return Select_X86ISD_BT(N); 56840 break; 56841 } 56842 case X86ISD::CALL: { 56843 return Select_X86ISD_CALL(N); 56844 break; 56845 } 56846 case X86ISD::CMOV: { 56847 switch (NVT) { 56848 case MVT::i16: 56849 return Select_X86ISD_CMOV_i16(N); 56850 case MVT::i32: 56851 return Select_X86ISD_CMOV_i32(N); 56852 case MVT::i64: 56853 return Select_X86ISD_CMOV_i64(N); 56854 case MVT::f32: 56855 return Select_X86ISD_CMOV_f32(N); 56856 case MVT::f64: 56857 return Select_X86ISD_CMOV_f64(N); 56858 case MVT::f80: 56859 return Select_X86ISD_CMOV_f80(N); 56860 case MVT::v1i64: 56861 return Select_X86ISD_CMOV_v1i64(N); 56862 case MVT::v2i64: 56863 return Select_X86ISD_CMOV_v2i64(N); 56864 case MVT::v4f32: 56865 return Select_X86ISD_CMOV_v4f32(N); 56866 case MVT::v2f64: 56867 return Select_X86ISD_CMOV_v2f64(N); 56868 default: 56869 break; 56870 } 56871 break; 56872 } 56873 case X86ISD::CMP: { 56874 return Select_X86ISD_CMP(N); 56875 break; 56876 } 56877 case X86ISD::CMPPD: { 56878 switch (NVT) { 56879 case MVT::v2i64: 56880 return Select_X86ISD_CMPPD_v2i64(N); 56881 default: 56882 break; 56883 } 56884 break; 56885 } 56886 case X86ISD::CMPPS: { 56887 switch (NVT) { 56888 case MVT::v4i32: 56889 return Select_X86ISD_CMPPS_v4i32(N); 56890 default: 56891 break; 56892 } 56893 break; 56894 } 56895 case X86ISD::COMI: { 56896 return Select_X86ISD_COMI(N); 56897 break; 56898 } 56899 case X86ISD::DEC: { 56900 switch (NVT) { 56901 case MVT::i8: 56902 return Select_X86ISD_DEC_i8(N); 56903 case MVT::i16: 56904 return Select_X86ISD_DEC_i16(N); 56905 case MVT::i32: 56906 return Select_X86ISD_DEC_i32(N); 56907 case MVT::i64: 56908 return Select_X86ISD_DEC_i64(N); 56909 default: 56910 break; 56911 } 56912 break; 56913 } 56914 case X86ISD::EH_RETURN: { 56915 return Select_X86ISD_EH_RETURN(N); 56916 break; 56917 } 56918 case X86ISD::FAND: { 56919 switch (NVT) { 56920 case MVT::f32: 56921 return Select_X86ISD_FAND_f32(N); 56922 case MVT::f64: 56923 return Select_X86ISD_FAND_f64(N); 56924 default: 56925 break; 56926 } 56927 break; 56928 } 56929 case X86ISD::FILD: { 56930 switch (NVT) { 56931 case MVT::f32: 56932 return Select_X86ISD_FILD_f32(N); 56933 case MVT::f64: 56934 return Select_X86ISD_FILD_f64(N); 56935 case MVT::f80: 56936 return Select_X86ISD_FILD_f80(N); 56937 default: 56938 break; 56939 } 56940 break; 56941 } 56942 case X86ISD::FILD_FLAG: { 56943 switch (NVT) { 56944 case MVT::f64: 56945 return Select_X86ISD_FILD_FLAG_f64(N); 56946 default: 56947 break; 56948 } 56949 break; 56950 } 56951 case X86ISD::FLD: { 56952 switch (NVT) { 56953 case MVT::f32: 56954 return Select_X86ISD_FLD_f32(N); 56955 case MVT::f64: 56956 return Select_X86ISD_FLD_f64(N); 56957 case MVT::f80: 56958 return Select_X86ISD_FLD_f80(N); 56959 default: 56960 break; 56961 } 56962 break; 56963 } 56964 case X86ISD::FMAX: { 56965 switch (NVT) { 56966 case MVT::f32: 56967 return Select_X86ISD_FMAX_f32(N); 56968 case MVT::f64: 56969 return Select_X86ISD_FMAX_f64(N); 56970 case MVT::v4f32: 56971 return Select_X86ISD_FMAX_v4f32(N); 56972 case MVT::v2f64: 56973 return Select_X86ISD_FMAX_v2f64(N); 56974 default: 56975 break; 56976 } 56977 break; 56978 } 56979 case X86ISD::FMIN: { 56980 switch (NVT) { 56981 case MVT::f32: 56982 return Select_X86ISD_FMIN_f32(N); 56983 case MVT::f64: 56984 return Select_X86ISD_FMIN_f64(N); 56985 case MVT::v4f32: 56986 return Select_X86ISD_FMIN_v4f32(N); 56987 case MVT::v2f64: 56988 return Select_X86ISD_FMIN_v2f64(N); 56989 default: 56990 break; 56991 } 56992 break; 56993 } 56994 case X86ISD::FNSTCW16m: { 56995 return Select_X86ISD_FNSTCW16m(N); 56996 break; 56997 } 56998 case X86ISD::FOR: { 56999 switch (NVT) { 57000 case MVT::f32: 57001 return Select_X86ISD_FOR_f32(N); 57002 case MVT::f64: 57003 return Select_X86ISD_FOR_f64(N); 57004 default: 57005 break; 57006 } 57007 break; 57008 } 57009 case X86ISD::FP_TO_INT16_IN_MEM: { 57010 return Select_X86ISD_FP_TO_INT16_IN_MEM(N); 57011 break; 57012 } 57013 case X86ISD::FP_TO_INT32_IN_MEM: { 57014 return Select_X86ISD_FP_TO_INT32_IN_MEM(N); 57015 break; 57016 } 57017 case X86ISD::FP_TO_INT64_IN_MEM: { 57018 return Select_X86ISD_FP_TO_INT64_IN_MEM(N); 57019 break; 57020 } 57021 case X86ISD::FRCP: { 57022 switch (NVT) { 57023 case MVT::f32: 57024 return Select_X86ISD_FRCP_f32(N); 57025 case MVT::v4f32: 57026 return Select_X86ISD_FRCP_v4f32(N); 57027 default: 57028 break; 57029 } 57030 break; 57031 } 57032 case X86ISD::FRSQRT: { 57033 switch (NVT) { 57034 case MVT::f32: 57035 return Select_X86ISD_FRSQRT_f32(N); 57036 case MVT::v4f32: 57037 return Select_X86ISD_FRSQRT_v4f32(N); 57038 default: 57039 break; 57040 } 57041 break; 57042 } 57043 case X86ISD::FSRL: { 57044 switch (NVT) { 57045 case MVT::v2f64: 57046 return Select_X86ISD_FSRL_v2f64(N); 57047 default: 57048 break; 57049 } 57050 break; 57051 } 57052 case X86ISD::FST: { 57053 return Select_X86ISD_FST(N); 57054 break; 57055 } 57056 case X86ISD::FXOR: { 57057 switch (NVT) { 57058 case MVT::f32: 57059 return Select_X86ISD_FXOR_f32(N); 57060 case MVT::f64: 57061 return Select_X86ISD_FXOR_f64(N); 57062 default: 57063 break; 57064 } 57065 break; 57066 } 57067 case X86ISD::INC: { 57068 switch (NVT) { 57069 case MVT::i8: 57070 return Select_X86ISD_INC_i8(N); 57071 case MVT::i16: 57072 return Select_X86ISD_INC_i16(N); 57073 case MVT::i32: 57074 return Select_X86ISD_INC_i32(N); 57075 case MVT::i64: 57076 return Select_X86ISD_INC_i64(N); 57077 default: 57078 break; 57079 } 57080 break; 57081 } 57082 case X86ISD::INSERTPS: { 57083 switch (NVT) { 57084 case MVT::v4f32: 57085 return Select_X86ISD_INSERTPS_v4f32(N); 57086 default: 57087 break; 57088 } 57089 break; 57090 } 57091 case X86ISD::LCMPXCHG8_DAG: { 57092 return Select_X86ISD_LCMPXCHG8_DAG(N); 57093 break; 57094 } 57095 case X86ISD::LCMPXCHG_DAG: { 57096 return Select_X86ISD_LCMPXCHG_DAG(N); 57097 break; 57098 } 57099 case X86ISD::MUL_IMM: { 57100 switch (NVT) { 57101 case MVT::i32: 57102 return Select_X86ISD_MUL_IMM_i32(N); 57103 case MVT::i64: 57104 return Select_X86ISD_MUL_IMM_i64(N); 57105 default: 57106 break; 57107 } 57108 break; 57109 } 57110 case X86ISD::PCMPEQB: { 57111 switch (NVT) { 57112 case MVT::v8i8: 57113 return Select_X86ISD_PCMPEQB_v8i8(N); 57114 case MVT::v16i8: 57115 return Select_X86ISD_PCMPEQB_v16i8(N); 57116 default: 57117 break; 57118 } 57119 break; 57120 } 57121 case X86ISD::PCMPEQD: { 57122 switch (NVT) { 57123 case MVT::v2i32: 57124 return Select_X86ISD_PCMPEQD_v2i32(N); 57125 case MVT::v4i32: 57126 return Select_X86ISD_PCMPEQD_v4i32(N); 57127 default: 57128 break; 57129 } 57130 break; 57131 } 57132 case X86ISD::PCMPEQQ: { 57133 switch (NVT) { 57134 case MVT::v2i64: 57135 return Select_X86ISD_PCMPEQQ_v2i64(N); 57136 default: 57137 break; 57138 } 57139 break; 57140 } 57141 case X86ISD::PCMPEQW: { 57142 switch (NVT) { 57143 case MVT::v4i16: 57144 return Select_X86ISD_PCMPEQW_v4i16(N); 57145 case MVT::v8i16: 57146 return Select_X86ISD_PCMPEQW_v8i16(N); 57147 default: 57148 break; 57149 } 57150 break; 57151 } 57152 case X86ISD::PCMPGTB: { 57153 switch (NVT) { 57154 case MVT::v8i8: 57155 return Select_X86ISD_PCMPGTB_v8i8(N); 57156 case MVT::v16i8: 57157 return Select_X86ISD_PCMPGTB_v16i8(N); 57158 default: 57159 break; 57160 } 57161 break; 57162 } 57163 case X86ISD::PCMPGTD: { 57164 switch (NVT) { 57165 case MVT::v2i32: 57166 return Select_X86ISD_PCMPGTD_v2i32(N); 57167 case MVT::v4i32: 57168 return Select_X86ISD_PCMPGTD_v4i32(N); 57169 default: 57170 break; 57171 } 57172 break; 57173 } 57174 case X86ISD::PCMPGTQ: { 57175 switch (NVT) { 57176 case MVT::v2i64: 57177 return Select_X86ISD_PCMPGTQ_v2i64(N); 57178 default: 57179 break; 57180 } 57181 break; 57182 } 57183 case X86ISD::PCMPGTW: { 57184 switch (NVT) { 57185 case MVT::v4i16: 57186 return Select_X86ISD_PCMPGTW_v4i16(N); 57187 case MVT::v8i16: 57188 return Select_X86ISD_PCMPGTW_v8i16(N); 57189 default: 57190 break; 57191 } 57192 break; 57193 } 57194 case X86ISD::PEXTRB: { 57195 switch (NVT) { 57196 case MVT::i32: 57197 return Select_X86ISD_PEXTRB_i32(N); 57198 default: 57199 break; 57200 } 57201 break; 57202 } 57203 case X86ISD::PEXTRW: { 57204 switch (NVT) { 57205 case MVT::i32: 57206 return Select_X86ISD_PEXTRW_i32(N); 57207 default: 57208 break; 57209 } 57210 break; 57211 } 57212 case X86ISD::PINSRB: { 57213 switch (NVT) { 57214 case MVT::v16i8: 57215 return Select_X86ISD_PINSRB_v16i8(N); 57216 default: 57217 break; 57218 } 57219 break; 57220 } 57221 case X86ISD::PINSRW: { 57222 switch (NVT) { 57223 case MVT::v4i16: 57224 return Select_X86ISD_PINSRW_v4i16(N); 57225 case MVT::v8i16: 57226 return Select_X86ISD_PINSRW_v8i16(N); 57227 default: 57228 break; 57229 } 57230 break; 57231 } 57232 case X86ISD::PSHUFB: { 57233 switch (NVT) { 57234 case MVT::v16i8: 57235 return Select_X86ISD_PSHUFB_v16i8(N); 57236 default: 57237 break; 57238 } 57239 break; 57240 } 57241 case X86ISD::PTEST: { 57242 return Select_X86ISD_PTEST(N); 57243 break; 57244 } 57245 case X86ISD::RDTSC_DAG: { 57246 return Select_X86ISD_RDTSC_DAG(N); 57247 break; 57248 } 57249 case X86ISD::REP_MOVS: { 57250 return Select_X86ISD_REP_MOVS(N); 57251 break; 57252 } 57253 case X86ISD::REP_STOS: { 57254 return Select_X86ISD_REP_STOS(N); 57255 break; 57256 } 57257 case X86ISD::RET_FLAG: { 57258 return Select_X86ISD_RET_FLAG(N); 57259 break; 57260 } 57261 case X86ISD::SETCC: { 57262 switch (NVT) { 57263 case MVT::i8: 57264 return Select_X86ISD_SETCC_i8(N); 57265 default: 57266 break; 57267 } 57268 break; 57269 } 57270 case X86ISD::SHLD: { 57271 switch (NVT) { 57272 case MVT::i16: 57273 return Select_X86ISD_SHLD_i16(N); 57274 case MVT::i32: 57275 return Select_X86ISD_SHLD_i32(N); 57276 case MVT::i64: 57277 return Select_X86ISD_SHLD_i64(N); 57278 default: 57279 break; 57280 } 57281 break; 57282 } 57283 case X86ISD::SHRD: { 57284 switch (NVT) { 57285 case MVT::i16: 57286 return Select_X86ISD_SHRD_i16(N); 57287 case MVT::i32: 57288 return Select_X86ISD_SHRD_i32(N); 57289 case MVT::i64: 57290 return Select_X86ISD_SHRD_i64(N); 57291 default: 57292 break; 57293 } 57294 break; 57295 } 57296 case X86ISD::SMUL: { 57297 switch (NVT) { 57298 case MVT::i16: 57299 return Select_X86ISD_SMUL_i16(N); 57300 case MVT::i32: 57301 return Select_X86ISD_SMUL_i32(N); 57302 case MVT::i64: 57303 return Select_X86ISD_SMUL_i64(N); 57304 default: 57305 break; 57306 } 57307 break; 57308 } 57309 case X86ISD::SUB: { 57310 switch (NVT) { 57311 case MVT::i8: 57312 return Select_X86ISD_SUB_i8(N); 57313 case MVT::i16: 57314 return Select_X86ISD_SUB_i16(N); 57315 case MVT::i32: 57316 return Select_X86ISD_SUB_i32(N); 57317 case MVT::i64: 57318 return Select_X86ISD_SUB_i64(N); 57319 default: 57320 break; 57321 } 57322 break; 57323 } 57324 case X86ISD::TC_RETURN: { 57325 return Select_X86ISD_TC_RETURN(N); 57326 break; 57327 } 57328 case X86ISD::TLSADDR: { 57329 return Select_X86ISD_TLSADDR(N); 57330 break; 57331 } 57332 case X86ISD::UCOMI: { 57333 return Select_X86ISD_UCOMI(N); 57334 break; 57335 } 57336 case X86ISD::VASTART_SAVE_XMM_REGS: { 57337 return Select_X86ISD_VASTART_SAVE_XMM_REGS(N); 57338 break; 57339 } 57340 case X86ISD::VSHL: { 57341 switch (NVT) { 57342 case MVT::v1i64: 57343 return Select_X86ISD_VSHL_v1i64(N); 57344 case MVT::v2i64: 57345 return Select_X86ISD_VSHL_v2i64(N); 57346 default: 57347 break; 57348 } 57349 break; 57350 } 57351 case X86ISD::VSRL: { 57352 switch (NVT) { 57353 case MVT::v1i64: 57354 return Select_X86ISD_VSRL_v1i64(N); 57355 case MVT::v2i64: 57356 return Select_X86ISD_VSRL_v2i64(N); 57357 default: 57358 break; 57359 } 57360 break; 57361 } 57362 case X86ISD::VZEXT_LOAD: { 57363 switch (NVT) { 57364 case MVT::v2i64: 57365 return Select_X86ISD_VZEXT_LOAD_v2i64(N); 57366 case MVT::v2f64: 57367 return Select_X86ISD_VZEXT_LOAD_v2f64(N); 57368 default: 57369 break; 57370 } 57371 break; 57372 } 57373 case X86ISD::VZEXT_MOVL: { 57374 switch (NVT) { 57375 case MVT::v2i32: 57376 return Select_X86ISD_VZEXT_MOVL_v2i32(N); 57377 case MVT::v4i32: 57378 return Select_X86ISD_VZEXT_MOVL_v4i32(N); 57379 case MVT::v2i64: 57380 return Select_X86ISD_VZEXT_MOVL_v2i64(N); 57381 case MVT::v4f32: 57382 return Select_X86ISD_VZEXT_MOVL_v4f32(N); 57383 case MVT::v2f64: 57384 return Select_X86ISD_VZEXT_MOVL_v2f64(N); 57385 default: 57386 break; 57387 } 57388 break; 57389 } 57390 case X86ISD::Wrapper: { 57391 switch (NVT) { 57392 case MVT::i32: 57393 return Select_X86ISD_Wrapper_i32(N); 57394 case MVT::i64: 57395 return Select_X86ISD_Wrapper_i64(N); 57396 default: 57397 break; 57398 } 57399 break; 57400 } 57401 case X86ISD::WrapperRIP: { 57402 switch (NVT) { 57403 case MVT::i64: 57404 return Select_X86ISD_WrapperRIP_i64(N); 57405 default: 57406 break; 57407 } 57408 break; 57409 } 57410 } // end of big switch. 57411 57412 if (N.getOpcode() != ISD::INTRINSIC_W_CHAIN && 57413 N.getOpcode() != ISD::INTRINSIC_WO_CHAIN && 57414 N.getOpcode() != ISD::INTRINSIC_VOID) { 57415 CannotYetSelect(N); 57416 } else { 57417 CannotYetSelectIntrinsic(N); 57418 } 57419 return NULL; 57420 } 57421 57422 void CannotYetSelect(SDValue N) DISABLE_INLINE { 57423 std::string msg; 57424 raw_string_ostream Msg(msg); 57425 Msg << "Cannot yet select: "; 57426 N.getNode()->print(Msg, CurDAG); 57427 llvm_report_error(Msg.str()); 57428 } 57429 57430 void CannotYetSelectIntrinsic(SDValue N) DISABLE_INLINE { 57431 cerr << "Cannot yet select: "; 57432 unsigned iid = cast<ConstantSDNode>(N.getOperand(N.getOperand(0).getValueType() == MVT::Other))->getZExtValue(); 57433 llvm_report_error("Cannot yet select: intrinsic %" + 57434 Intrinsic::getName((Intrinsic::ID)iid)); 57435 } 57436