LLVM API Documentation

X86GenDAGISel.inc

Go to the documentation of this file.
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