LLVM API Documentation
00001 //===- TableGen'erated file -------------------------------------*- C++ -*-===// 00002 // 00003 // DAG Instruction Selector for the PPC 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 // Instance var to keep track of multiply used nodes that have 00013 // already been selected. 00014 std::map<SDOperand, SDOperand> CodeGenMap; 00015 // Instance var to keep track of mapping of chain generating nodes 00016 // and their place handle nodes. 00017 std::map<SDOperand, SDOperand> HandleMap; 00018 // Instance var to keep track of mapping of place handle nodes 00019 // and their replacement nodes. 00020 std::map<SDOperand, SDOperand> ReplaceMap; 00021 00022 static void findNonImmUse(SDNode* Use, SDNode* Def, bool &found, std::set<SDNode *> &Visited) { 00023 if (found || !Visited.insert(Use).second) return; 00024 for (unsigned i = 0, e = Use->getNumOperands(); i != e; ++i) { 00025 SDNode *N = Use->getOperand(i).Val; 00026 if (N->getNodeDepth() >= Def->getNodeDepth()) { 00027 if (N != Def) { 00028 findNonImmUse(N, Def, found, Visited); 00029 } else { 00030 found = true; 00031 break; 00032 } 00033 } 00034 } 00035 } 00036 00037 static bool isNonImmUse(SDNode* Use, SDNode* Def) { 00038 std::set<SDNode *> Visited; 00039 bool found = false; 00040 for (unsigned i = 0, e = Use->getNumOperands(); i != e; ++i) { 00041 SDNode *N = Use->getOperand(i).Val; 00042 if (N != Def) { 00043 findNonImmUse(N, Def, found, Visited); 00044 if (found) break; 00045 } 00046 } 00047 return found; 00048 } 00049 00050 // AddHandleReplacement - Note the pending replacement node for a 00051 // handle node in ReplaceMap. 00052 void AddHandleReplacement(SDNode *H, unsigned HNum, SDNode *R, unsigned RNum) { 00053 SDOperand N(H, HNum); 00054 std::map<SDOperand, SDOperand>::iterator HMI = HandleMap.find(N); 00055 if (HMI != HandleMap.end()) { 00056 ReplaceMap[HMI->second] = SDOperand(R, RNum); 00057 HandleMap.erase(N); 00058 } 00059 } 00060 00061 // SelectDanglingHandles - Select replacements for all `dangling` 00062 // handles.Some handles do not yet have replacements because the 00063 // nodes they replacements have only dead readers. 00064 void SelectDanglingHandles() { 00065 for (std::map<SDOperand, SDOperand>::iterator I = HandleMap.begin(), 00066 E = HandleMap.end(); I != E; ++I) { 00067 SDOperand N = I->first; 00068 SDOperand R; 00069 Select(R, N.getValue(0)); 00070 AddHandleReplacement(N.Val, N.ResNo, R.Val, R.ResNo); 00071 } 00072 } 00073 00074 // ReplaceHandles - Replace all the handles with the real target 00075 // specific nodes. 00076 void ReplaceHandles() { 00077 for (std::map<SDOperand, SDOperand>::iterator I = ReplaceMap.begin(), 00078 E = ReplaceMap.end(); I != E; ++I) { 00079 SDOperand From = I->first; 00080 SDOperand To = I->second; 00081 for (SDNode::use_iterator UI = From.Val->use_begin(), E = From.Val->use_end(); UI != E; ++UI) { 00082 SDNode *Use = *UI; 00083 std::vector<SDOperand> Ops; 00084 for (unsigned i = 0, e = Use->getNumOperands(); i != e; ++i) { 00085 SDOperand O = Use->getOperand(i); 00086 if (O.Val == From.Val) 00087 Ops.push_back(To); 00088 else 00089 Ops.push_back(O); 00090 } 00091 SDOperand U = SDOperand(Use, 0); 00092 CurDAG->UpdateNodeOperands(U, Ops); 00093 } 00094 } 00095 } 00096 00097 // UpdateFoldedChain - return a SDOperand of the new chain created 00098 // if the folding were to happen. This is called when, for example, 00099 // a load is folded into a store. If the store's chain is the load, 00100 // then the resulting node's input chain would be the load's input 00101 // chain. If the store's chain is a TokenFactor and the load's 00102 // output chain feeds into in, then the new chain is a TokenFactor 00103 // with the other operands along with the input chain of the load. 00104 SDOperand UpdateFoldedChain(SelectionDAG *DAG, SDNode *N, SDNode *Chain, SDNode* &OldTF) { 00105 OldTF = NULL; 00106 if (N == Chain) { 00107 return N->getOperand(0); 00108 } else if (Chain->getOpcode() == ISD::TokenFactor && 00109 N->isOperand(Chain)) { 00110 SDOperand Ch = SDOperand(Chain, 0); 00111 std::map<SDOperand, SDOperand>::iterator CGMI = CodeGenMap.find(Ch); 00112 if (CGMI != CodeGenMap.end()) 00113 return SDOperand(0, 0); 00114 OldTF = Chain; 00115 std::vector<SDOperand> Ops; 00116 for (unsigned i = 0; i < Chain->getNumOperands(); ++i) { 00117 SDOperand Op = Chain->getOperand(i); 00118 if (Op.Val == N) 00119 Ops.push_back(N->getOperand(0)); 00120 else 00121 Ops.push_back(Op); 00122 } 00123 return DAG->getNode(ISD::TokenFactor, MVT::Other, Ops); 00124 } 00125 return SDOperand(0, 0); 00126 } 00127 00128 // SelectRoot - Top level entry to DAG isel. 00129 SDOperand SelectRoot(SDOperand N) { 00130 SDOperand ResNode; 00131 Select(ResNode, N); 00132 SelectDanglingHandles(); 00133 ReplaceHandles(); 00134 ReplaceMap.clear(); 00135 return ResNode; 00136 } 00137 00138 // Node transformations. 00139 inline SDOperand Transform_VSPLTW_get_imm(SDNode *N) { 00140 00141 return getI32Imm(PPC::getVSPLTImmediate(N, 4)); 00142 00143 } 00144 inline SDOperand Transform_VSPLTISW_get_imm(SDNode *N) { 00145 00146 return PPC::get_VSPLTI_elt(N, 4, *CurDAG); 00147 00148 } 00149 inline SDOperand Transform_VSPLTISH_get_imm(SDNode *N) { 00150 00151 return PPC::get_VSPLTI_elt(N, 2, *CurDAG); 00152 00153 } 00154 inline SDOperand Transform_VSPLTISB_get_imm(SDNode *N) { 00155 00156 return PPC::get_VSPLTI_elt(N, 1, *CurDAG); 00157 00158 } 00159 inline SDOperand Transform_VSPLTH_get_imm(SDNode *N) { 00160 00161 return getI32Imm(PPC::getVSPLTImmediate(N, 2)); 00162 00163 } 00164 inline SDOperand Transform_VSPLTB_get_imm(SDNode *N) { 00165 00166 return getI32Imm(PPC::getVSPLTImmediate(N, 1)); 00167 00168 } 00169 inline SDOperand Transform_VSLDOI_unary_get_imm(SDNode *N) { 00170 00171 return getI32Imm(PPC::isVSLDOIShuffleMask(N, true)); 00172 00173 } 00174 inline SDOperand Transform_VSLDOI_get_imm(SDNode *N) { 00175 00176 return getI32Imm(PPC::isVSLDOIShuffleMask(N, false)); 00177 00178 } 00179 inline SDOperand Transform_SRL64(SDNode *inN) { 00180 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00181 00182 // Transformation function: 64 - imm 00183 return N->getValue() ? getI32Imm(64 - N->getValue()) : getI32Imm(0); 00184 00185 } 00186 inline SDOperand Transform_SRL32(SDNode *inN) { 00187 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00188 00189 // Transformation function: 32 - imm 00190 return N->getValue() ? getI32Imm(32 - N->getValue()) : getI32Imm(0); 00191 00192 } 00193 inline SDOperand Transform_SHL64(SDNode *inN) { 00194 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00195 00196 // Transformation function: 63 - imm 00197 return getI32Imm(63 - N->getValue()); 00198 00199 } 00200 inline SDOperand Transform_SHL32(SDNode *inN) { 00201 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00202 00203 // Transformation function: 31 - imm 00204 return getI32Imm(31 - N->getValue()); 00205 00206 } 00207 inline SDOperand Transform_LO16(SDNode *inN) { 00208 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00209 00210 // Transformation function: get the low 16 bits. 00211 return getI32Imm((unsigned short)N->getValue()); 00212 00213 } 00214 inline SDOperand Transform_HI16(SDNode *inN) { 00215 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00216 00217 // Transformation function: shift the immediate value down into the low bits. 00218 return getI32Imm((unsigned)N->getValue() >> 16); 00219 00220 } 00221 inline SDOperand Transform_HA16(SDNode *inN) { 00222 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00223 00224 // Transformation function: shift the immediate value down into the low bits. 00225 signed int Val = N->getValue(); 00226 return getI32Imm((Val - (signed short)Val) >> 16); 00227 00228 } 00229 00230 // Predicate functions. 00231 inline bool Predicate_VMRGHB_shuffle_mask(SDNode *N) { 00232 00233 return PPC::isVMRGHShuffleMask(N, 1, false); 00234 00235 } 00236 inline bool Predicate_VMRGHB_unary_shuffle_mask(SDNode *N) { 00237 00238 return PPC::isVMRGHShuffleMask(N, 1, true); 00239 00240 } 00241 inline bool Predicate_VMRGHH_shuffle_mask(SDNode *N) { 00242 00243 return PPC::isVMRGHShuffleMask(N, 2, false); 00244 00245 } 00246 inline bool Predicate_VMRGHH_unary_shuffle_mask(SDNode *N) { 00247 00248 return PPC::isVMRGHShuffleMask(N, 2, true); 00249 00250 } 00251 inline bool Predicate_VMRGHW_shuffle_mask(SDNode *N) { 00252 00253 return PPC::isVMRGHShuffleMask(N, 4, false); 00254 00255 } 00256 inline bool Predicate_VMRGHW_unary_shuffle_mask(SDNode *N) { 00257 00258 return PPC::isVMRGHShuffleMask(N, 4, true); 00259 00260 } 00261 inline bool Predicate_VMRGLB_shuffle_mask(SDNode *N) { 00262 00263 return PPC::isVMRGLShuffleMask(N, 1, false); 00264 00265 } 00266 inline bool Predicate_VMRGLB_unary_shuffle_mask(SDNode *N) { 00267 00268 return PPC::isVMRGLShuffleMask(N, 1, true); 00269 00270 } 00271 inline bool Predicate_VMRGLH_shuffle_mask(SDNode *N) { 00272 00273 return PPC::isVMRGLShuffleMask(N, 2, false); 00274 00275 } 00276 inline bool Predicate_VMRGLH_unary_shuffle_mask(SDNode *N) { 00277 00278 return PPC::isVMRGLShuffleMask(N, 2, true); 00279 00280 } 00281 inline bool Predicate_VMRGLW_shuffle_mask(SDNode *N) { 00282 00283 return PPC::isVMRGLShuffleMask(N, 4, false); 00284 00285 } 00286 inline bool Predicate_VMRGLW_unary_shuffle_mask(SDNode *N) { 00287 00288 return PPC::isVMRGLShuffleMask(N, 4, true); 00289 00290 } 00291 inline bool Predicate_VPKUHUM_shuffle_mask(SDNode *N) { 00292 00293 return PPC::isVPKUHUMShuffleMask(N, false); 00294 00295 } 00296 inline bool Predicate_VPKUHUM_unary_shuffle_mask(SDNode *N) { 00297 00298 return PPC::isVPKUHUMShuffleMask(N, true); 00299 00300 } 00301 inline bool Predicate_VPKUWUM_shuffle_mask(SDNode *N) { 00302 00303 return PPC::isVPKUWUMShuffleMask(N, false); 00304 00305 } 00306 inline bool Predicate_VPKUWUM_unary_shuffle_mask(SDNode *N) { 00307 00308 return PPC::isVPKUWUMShuffleMask(N, true); 00309 00310 } 00311 inline bool Predicate_VSLDOI_shuffle_mask(SDNode *N) { 00312 00313 return PPC::isVSLDOIShuffleMask(N, false) != -1; 00314 00315 } 00316 inline bool Predicate_VSLDOI_unary_shuffle_mask(SDNode *N) { 00317 00318 return PPC::isVSLDOIShuffleMask(N, true) != -1; 00319 00320 } 00321 inline bool Predicate_VSPLTB_shuffle_mask(SDNode *N) { 00322 00323 return PPC::isSplatShuffleMask(N, 1); 00324 00325 } 00326 inline bool Predicate_VSPLTH_shuffle_mask(SDNode *N) { 00327 00328 return PPC::isSplatShuffleMask(N, 2); 00329 00330 } 00331 inline bool Predicate_VSPLTW_shuffle_mask(SDNode *N) { 00332 00333 return PPC::isSplatShuffleMask(N, 4); 00334 00335 } 00336 inline bool Predicate_imm16Shifted(SDNode *inN) { 00337 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00338 00339 // imm16Shifted predicate - True if only bits in the top 16-bits of the 00340 // immediate are set. Used by instructions like 'addis'. 00341 return ((unsigned)N->getValue() & 0xFFFF0000U) == (unsigned)N->getValue(); 00342 00343 } 00344 inline bool Predicate_immAllOnes(SDNode *inN) { 00345 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00346 return N->isAllOnesValue(); 00347 } 00348 inline bool Predicate_immAllOnesV(SDNode *N) { 00349 00350 return ISD::isBuildVectorAllOnes(N); 00351 00352 } 00353 inline bool Predicate_immAllZerosV(SDNode *N) { 00354 00355 return ISD::isBuildVectorAllZeros(N); 00356 00357 } 00358 inline bool Predicate_immSExt16(SDNode *inN) { 00359 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00360 00361 // immSExt16 predicate - True if the immediate fits in a 16-bit sign extended 00362 // field. Used by instructions like 'addi'. 00363 return (int)N->getValue() == (short)N->getValue(); 00364 00365 } 00366 inline bool Predicate_immZExt16(SDNode *inN) { 00367 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00368 00369 // immZExt16 predicate - True if the immediate fits in a 16-bit zero extended 00370 // field. Used by instructions like 'ori'. 00371 return (unsigned)N->getValue() == (unsigned short)N->getValue(); 00372 00373 } 00374 inline bool Predicate_vecspltisb(SDNode *N) { 00375 00376 return PPC::get_VSPLTI_elt(N, 1, *CurDAG).Val != 0; 00377 00378 } 00379 inline bool Predicate_vecspltish(SDNode *N) { 00380 00381 return PPC::get_VSPLTI_elt(N, 2, *CurDAG).Val != 0; 00382 00383 } 00384 inline bool Predicate_vecspltisw(SDNode *N) { 00385 00386 return PPC::get_VSPLTI_elt(N, 4, *CurDAG).Val != 0; 00387 00388 } 00389 inline bool Predicate_vtFP(SDNode *inN) { 00390 VTSDNode *N = cast<VTSDNode>(inN); 00391 return MVT::isFloatingPoint(N->getVT()); 00392 } 00393 inline bool Predicate_vtInt(SDNode *inN) { 00394 VTSDNode *N = cast<VTSDNode>(inN); 00395 return MVT::isInteger(N->getVT()); 00396 } 00397 00398 00399 void Select_PPCextsw_32(SDOperand &Result, SDOperand N) { 00400 SDOperand N0(0, 0); 00401 SDOperand Tmp0(0, 0); 00402 SDNode *ResNode; 00403 N0 = N.getOperand(0); 00404 if (N.Val->getValueType(0) == MVT::i32) { 00405 Select(Tmp0, N0); 00406 if (N.Val->hasOneUse()) { 00407 Result = CurDAG->SelectNodeTo(N.Val, PPC::EXTSW_32, MVT::i32, Tmp0); 00408 } else { 00409 ResNode = CurDAG->getTargetNode(PPC::EXTSW_32, MVT::i32, Tmp0); 00410 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00411 Result = SDOperand(ResNode, 0); 00412 } 00413 return; 00414 } 00415 std::cerr << "Cannot yet select: "; 00416 N.Val->dump(CurDAG); 00417 std::cerr << '\n'; 00418 abort(); 00419 } 00420 00421 void Select_PPCfcfid(SDOperand &Result, SDOperand N) { 00422 SDOperand N0(0, 0); 00423 SDOperand Tmp0(0, 0); 00424 SDNode *ResNode; 00425 N0 = N.getOperand(0); 00426 if (N.Val->getValueType(0) == MVT::f64) { 00427 Select(Tmp0, N0); 00428 if (N.Val->hasOneUse()) { 00429 Result = CurDAG->SelectNodeTo(N.Val, PPC::FCFID, MVT::f64, Tmp0); 00430 } else { 00431 ResNode = CurDAG->getTargetNode(PPC::FCFID, MVT::f64, Tmp0); 00432 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00433 Result = SDOperand(ResNode, 0); 00434 } 00435 return; 00436 } 00437 std::cerr << "Cannot yet select: "; 00438 N.Val->dump(CurDAG); 00439 std::cerr << '\n'; 00440 abort(); 00441 } 00442 00443 void Select_PPCfctidz(SDOperand &Result, SDOperand N) { 00444 SDOperand N0(0, 0); 00445 SDOperand Tmp0(0, 0); 00446 SDNode *ResNode; 00447 N0 = N.getOperand(0); 00448 if (N.Val->getValueType(0) == MVT::f64) { 00449 Select(Tmp0, N0); 00450 if (N.Val->hasOneUse()) { 00451 Result = CurDAG->SelectNodeTo(N.Val, PPC::FCTIDZ, MVT::f64, Tmp0); 00452 } else { 00453 ResNode = CurDAG->getTargetNode(PPC::FCTIDZ, MVT::f64, Tmp0); 00454 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00455 Result = SDOperand(ResNode, 0); 00456 } 00457 return; 00458 } 00459 std::cerr << "Cannot yet select: "; 00460 N.Val->dump(CurDAG); 00461 std::cerr << '\n'; 00462 abort(); 00463 } 00464 00465 void Select_PPCfctiwz(SDOperand &Result, SDOperand N) { 00466 SDOperand N0(0, 0); 00467 SDOperand Tmp0(0, 0); 00468 SDNode *ResNode; 00469 N0 = N.getOperand(0); 00470 if (N.Val->getValueType(0) == MVT::f64) { 00471 Select(Tmp0, N0); 00472 if (N.Val->hasOneUse()) { 00473 Result = CurDAG->SelectNodeTo(N.Val, PPC::FCTIWZ, MVT::f64, Tmp0); 00474 } else { 00475 ResNode = CurDAG->getTargetNode(PPC::FCTIWZ, MVT::f64, Tmp0); 00476 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00477 Result = SDOperand(ResNode, 0); 00478 } 00479 return; 00480 } 00481 std::cerr << "Cannot yet select: "; 00482 N.Val->dump(CurDAG); 00483 std::cerr << '\n'; 00484 abort(); 00485 } 00486 00487 void Select_PPCfsel(SDOperand &Result, SDOperand N) { 00488 SDOperand N0(0, 0); 00489 SDOperand N1(0, 0); 00490 SDOperand N2(0, 0); 00491 SDOperand Tmp0(0, 0); 00492 SDOperand Tmp1(0, 0); 00493 SDOperand Tmp2(0, 0); 00494 SDNode *ResNode; 00495 N0 = N.getOperand(0); 00496 N1 = N.getOperand(1); 00497 N2 = N.getOperand(2); 00498 00499 // Pattern: (PPCfsel:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB) 00500 // Emits: (FSELD:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB) 00501 // Pattern complexity = 2 cost = 1 00502 if (N.Val->getValueType(0) == MVT::f64) { 00503 Select(Tmp0, N0); 00504 Select(Tmp1, N1); 00505 Select(Tmp2, N2); 00506 if (N.Val->hasOneUse()) { 00507 Result = CurDAG->SelectNodeTo(N.Val, PPC::FSELD, MVT::f64, Tmp0, Tmp1, Tmp2); 00508 } else { 00509 ResNode = CurDAG->getTargetNode(PPC::FSELD, MVT::f64, Tmp0, Tmp1, Tmp2); 00510 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00511 Result = SDOperand(ResNode, 0); 00512 } 00513 return; 00514 } 00515 00516 // Pattern: (PPCfsel:f32 F8RC:f64:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB) 00517 // Emits: (FSELS:f32 F8RC:f64:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB) 00518 // Pattern complexity = 2 cost = 1 00519 if (N.Val->getValueType(0) == MVT::f32) { 00520 Select(Tmp0, N0); 00521 Select(Tmp1, N1); 00522 Select(Tmp2, N2); 00523 if (N.Val->hasOneUse()) { 00524 Result = CurDAG->SelectNodeTo(N.Val, PPC::FSELS, MVT::f32, Tmp0, Tmp1, Tmp2); 00525 } else { 00526 ResNode = CurDAG->getTargetNode(PPC::FSELS, MVT::f32, Tmp0, Tmp1, Tmp2); 00527 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00528 Result = SDOperand(ResNode, 0); 00529 } 00530 return; 00531 } 00532 std::cerr << "Cannot yet select: "; 00533 N.Val->dump(CurDAG); 00534 std::cerr << '\n'; 00535 abort(); 00536 } 00537 00538 void Select_PPChi(SDOperand &Result, SDOperand N) { 00539 SDOperand N0(0, 0); 00540 SDOperand N1(0, 0); 00541 SDOperand Tmp1(0, 0); 00542 SDNode *ResNode; 00543 N0 = N.getOperand(0); 00544 00545 // Pattern: (PPChi:i32 (tglobaladdr:i32):$in, 0:i32) 00546 // Emits: (LIS:i32 (tglobaladdr:i32):$in) 00547 // Pattern complexity = 7 cost = 1 00548 if (N0.getOpcode() == ISD::TargetGlobalAddress) { 00549 N1 = N.getOperand(1); 00550 if (isa<ConstantSDNode>(N1)) { 00551 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 00552 if (CN0 == 0) { 00553 Tmp1 = N0; 00554 if (N.Val->hasOneUse()) { 00555 Result = CurDAG->SelectNodeTo(N.Val, PPC::LIS, MVT::i32, Tmp1); 00556 } else { 00557 ResNode = CurDAG->getTargetNode(PPC::LIS, MVT::i32, Tmp1); 00558 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00559 Result = SDOperand(ResNode, 0); 00560 } 00561 return; 00562 } 00563 } 00564 } 00565 00566 // Pattern: (PPChi:i32 (tconstpool:i32):$in, 0:i32) 00567 // Emits: (LIS:i32 (tconstpool:i32):$in) 00568 // Pattern complexity = 7 cost = 1 00569 if (N0.getOpcode() == ISD::TargetConstantPool) { 00570 N1 = N.getOperand(1); 00571 if (isa<ConstantSDNode>(N1)) { 00572 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 00573 if (CN0 == 0) { 00574 Tmp1 = N0; 00575 if (N.Val->hasOneUse()) { 00576 Result = CurDAG->SelectNodeTo(N.Val, PPC::LIS, MVT::i32, Tmp1); 00577 } else { 00578 ResNode = CurDAG->getTargetNode(PPC::LIS, MVT::i32, Tmp1); 00579 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00580 Result = SDOperand(ResNode, 0); 00581 } 00582 return; 00583 } 00584 } 00585 } 00586 std::cerr << "Cannot yet select: "; 00587 N.Val->dump(CurDAG); 00588 std::cerr << '\n'; 00589 abort(); 00590 } 00591 00592 void Select_PPClo(SDOperand &Result, SDOperand N) { 00593 SDOperand N0(0, 0); 00594 SDOperand N1(0, 0); 00595 SDOperand Tmp1(0, 0); 00596 SDNode *ResNode; 00597 N0 = N.getOperand(0); 00598 00599 // Pattern: (PPClo:i32 (tglobaladdr:i32):$in, 0:i32) 00600 // Emits: (LI:i32 (tglobaladdr:i32):$in) 00601 // Pattern complexity = 7 cost = 1 00602 if (N0.getOpcode() == ISD::TargetGlobalAddress) { 00603 N1 = N.getOperand(1); 00604 if (isa<ConstantSDNode>(N1)) { 00605 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 00606 if (CN0 == 0) { 00607 Tmp1 = N0; 00608 if (N.Val->hasOneUse()) { 00609 Result = CurDAG->SelectNodeTo(N.Val, PPC::LI, MVT::i32, Tmp1); 00610 } else { 00611 ResNode = CurDAG->getTargetNode(PPC::LI, MVT::i32, Tmp1); 00612 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00613 Result = SDOperand(ResNode, 0); 00614 } 00615 return; 00616 } 00617 } 00618 } 00619 00620 // Pattern: (PPClo:i32 (tconstpool:i32):$in, 0:i32) 00621 // Emits: (LI:i32 (tconstpool:i32):$in) 00622 // Pattern complexity = 7 cost = 1 00623 if (N0.getOpcode() == ISD::TargetConstantPool) { 00624 N1 = N.getOperand(1); 00625 if (isa<ConstantSDNode>(N1)) { 00626 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 00627 if (CN0 == 0) { 00628 Tmp1 = N0; 00629 if (N.Val->hasOneUse()) { 00630 Result = CurDAG->SelectNodeTo(N.Val, PPC::LI, MVT::i32, Tmp1); 00631 } else { 00632 ResNode = CurDAG->getTargetNode(PPC::LI, MVT::i32, Tmp1); 00633 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00634 Result = SDOperand(ResNode, 0); 00635 } 00636 return; 00637 } 00638 } 00639 } 00640 std::cerr << "Cannot yet select: "; 00641 N.Val->dump(CurDAG); 00642 std::cerr << '\n'; 00643 abort(); 00644 } 00645 00646 void Select_PPCshl(SDOperand &Result, SDOperand N) { 00647 SDOperand N0(0, 0); 00648 SDOperand N1(0, 0); 00649 SDOperand Tmp0(0, 0); 00650 SDOperand Tmp1(0, 0); 00651 SDNode *ResNode; 00652 N0 = N.getOperand(0); 00653 N1 = N.getOperand(1); 00654 Select(Tmp0, N0); 00655 Select(Tmp1, N1); 00656 if (N.Val->hasOneUse()) { 00657 Result = CurDAG->SelectNodeTo(N.Val, PPC::SLW, MVT::i32, Tmp0, Tmp1); 00658 } else { 00659 ResNode = CurDAG->getTargetNode(PPC::SLW, MVT::i32, Tmp0, Tmp1); 00660 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00661 Result = SDOperand(ResNode, 0); 00662 } 00663 return; 00664 } 00665 00666 void Select_PPCsra(SDOperand &Result, SDOperand N) { 00667 SDOperand N0(0, 0); 00668 SDOperand N1(0, 0); 00669 SDOperand Tmp0(0, 0); 00670 SDOperand Tmp1(0, 0); 00671 SDNode *ResNode; 00672 N0 = N.getOperand(0); 00673 N1 = N.getOperand(1); 00674 Select(Tmp0, N0); 00675 Select(Tmp1, N1); 00676 if (N.Val->hasOneUse()) { 00677 Result = CurDAG->SelectNodeTo(N.Val, PPC::SRAW, MVT::i32, Tmp0, Tmp1); 00678 } else { 00679 ResNode = CurDAG->getTargetNode(PPC::SRAW, MVT::i32, Tmp0, Tmp1); 00680 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00681 Result = SDOperand(ResNode, 0); 00682 } 00683 return; 00684 } 00685 00686 void Select_PPCsrl(SDOperand &Result, SDOperand N) { 00687 SDOperand N0(0, 0); 00688 SDOperand N1(0, 0); 00689 SDOperand Tmp0(0, 0); 00690 SDOperand Tmp1(0, 0); 00691 SDNode *ResNode; 00692 N0 = N.getOperand(0); 00693 N1 = N.getOperand(1); 00694 Select(Tmp0, N0); 00695 Select(Tmp1, N1); 00696 if (N.Val->hasOneUse()) { 00697 Result = CurDAG->SelectNodeTo(N.Val, PPC::SRW, MVT::i32, Tmp0, Tmp1); 00698 } else { 00699 ResNode = CurDAG->getTargetNode(PPC::SRW, MVT::i32, Tmp0, Tmp1); 00700 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00701 Result = SDOperand(ResNode, 0); 00702 } 00703 return; 00704 } 00705 00706 void Select_PPCstd_32(SDOperand &Result, SDOperand N) { 00707 SDOperand Chain(0, 0); 00708 SDOperand N1(0, 0); 00709 SDOperand N2(0, 0); 00710 SDOperand Tmp0(0, 0); 00711 SDOperand Tmp1(0, 0); 00712 SDOperand Tmp2(0, 0); 00713 SDNode *ResNode; 00714 Chain = N.getOperand(0); 00715 N1 = N.getOperand(1); 00716 N2 = N.getOperand(2); 00717 if (N1.Val->getValueType(0) == MVT::i32) { 00718 00719 // Pattern: (PPCstd_32:void GPRC:i32:$rT, ixaddr:i32:$dst) 00720 // Emits: (STD_32:void GPRC:i32:$rT, ixaddr:i32:$dst) 00721 // Pattern complexity = 8 cost = 1 00722 if (SelectAddrImmShift(N2, Tmp0, Tmp1)) { 00723 Select(Tmp0, Tmp0); 00724 Select(Tmp1, Tmp1); 00725 Select(Tmp2, N1); 00726 Select(Chain, Chain); 00727 ResNode = CurDAG->getTargetNode(PPC::STD_32, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 00728 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 00729 Result = SDOperand(ResNode, N.ResNo); 00730 return; 00731 } 00732 00733 // Pattern: (PPCstd_32:void GPRC:i32:$rT, xaddr:i32:$dst) 00734 // Emits: (STDX_32:void GPRC:i32:$rT, xaddr:i32:$dst) 00735 // Pattern complexity = 8 cost = 1 00736 if (SelectAddrIdx(N2, Tmp0, Tmp1)) { 00737 Select(Tmp0, Tmp0); 00738 Select(Tmp1, Tmp1); 00739 Select(Tmp2, N1); 00740 Select(Chain, Chain); 00741 ResNode = CurDAG->getTargetNode(PPC::STDX_32, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 00742 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 00743 Result = SDOperand(ResNode, N.ResNo); 00744 return; 00745 } 00746 } 00747 std::cerr << "Cannot yet select: "; 00748 N.Val->dump(CurDAG); 00749 std::cerr << '\n'; 00750 abort(); 00751 } 00752 00753 void Select_PPCstfiwx(SDOperand &Result, SDOperand N) { 00754 SDOperand Chain(0, 0); 00755 SDOperand N1(0, 0); 00756 SDOperand N2(0, 0); 00757 SDOperand Tmp0(0, 0); 00758 SDOperand Tmp1(0, 0); 00759 SDOperand Tmp2(0, 0); 00760 SDNode *ResNode; 00761 Chain = N.getOperand(0); 00762 N1 = N.getOperand(1); 00763 N2 = N.getOperand(2); 00764 if (SelectAddrIdxOnly(N2, Tmp0, Tmp1)) { 00765 Select(Tmp0, Tmp0); 00766 Select(Tmp1, Tmp1); 00767 Select(Tmp2, N1); 00768 Select(Chain, Chain); 00769 ResNode = CurDAG->getTargetNode(PPC::STFIWX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 00770 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 00771 Result = SDOperand(ResNode, N.ResNo); 00772 return; 00773 } 00774 std::cerr << "Cannot yet select: "; 00775 N.Val->dump(CurDAG); 00776 std::cerr << '\n'; 00777 abort(); 00778 } 00779 00780 void Select_PPCvcmp(SDOperand &Result, SDOperand N) { 00781 SDOperand N0(0, 0); 00782 SDOperand N1(0, 0); 00783 SDOperand N2(0, 0); 00784 SDOperand Tmp1(0, 0); 00785 SDOperand Tmp2(0, 0); 00786 SDNode *ResNode; 00787 N0 = N.getOperand(0); 00788 N1 = N.getOperand(1); 00789 N2 = N.getOperand(2); 00790 if (isa<ConstantSDNode>(N2)) { 00791 int64_t CN0 = cast<ConstantSDNode>(N2)->getSignExtended(); 00792 00793 // Pattern: (PPCvcmp:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 966:i32) 00794 // Emits: (VCMPBFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 00795 // Pattern complexity = 5 cost = 1 00796 if (CN0 == 966 && 00797 N.Val->getValueType(0) == MVT::v4f32) { 00798 Select(Tmp1, N0); 00799 Select(Tmp2, N1); 00800 if (N.Val->hasOneUse()) { 00801 Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPBFP, MVT::v4f32, Tmp1, Tmp2); 00802 } else { 00803 ResNode = CurDAG->getTargetNode(PPC::VCMPBFP, MVT::v4f32, Tmp1, Tmp2); 00804 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00805 Result = SDOperand(ResNode, 0); 00806 } 00807 return; 00808 } 00809 00810 // Pattern: (PPCvcmp:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 198:i32) 00811 // Emits: (VCMPEQFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 00812 // Pattern complexity = 5 cost = 1 00813 if (CN0 == 198 && 00814 N.Val->getValueType(0) == MVT::v4f32) { 00815 Select(Tmp1, N0); 00816 Select(Tmp2, N1); 00817 if (N.Val->hasOneUse()) { 00818 Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPEQFP, MVT::v4f32, Tmp1, Tmp2); 00819 } else { 00820 ResNode = CurDAG->getTargetNode(PPC::VCMPEQFP, MVT::v4f32, Tmp1, Tmp2); 00821 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00822 Result = SDOperand(ResNode, 0); 00823 } 00824 return; 00825 } 00826 00827 // Pattern: (PPCvcmp:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 454:i32) 00828 // Emits: (VCMPGEFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 00829 // Pattern complexity = 5 cost = 1 00830 if (CN0 == 454 && 00831 N.Val->getValueType(0) == MVT::v4f32) { 00832 Select(Tmp1, N0); 00833 Select(Tmp2, N1); 00834 if (N.Val->hasOneUse()) { 00835 Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPGEFP, MVT::v4f32, Tmp1, Tmp2); 00836 } else { 00837 ResNode = CurDAG->getTargetNode(PPC::VCMPGEFP, MVT::v4f32, Tmp1, Tmp2); 00838 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00839 Result = SDOperand(ResNode, 0); 00840 } 00841 return; 00842 } 00843 00844 // Pattern: (PPCvcmp:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 710:i32) 00845 // Emits: (VCMPGTFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 00846 // Pattern complexity = 5 cost = 1 00847 if (CN0 == 710 && 00848 N.Val->getValueType(0) == MVT::v4f32) { 00849 Select(Tmp1, N0); 00850 Select(Tmp2, N1); 00851 if (N.Val->hasOneUse()) { 00852 Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPGTFP, MVT::v4f32, Tmp1, Tmp2); 00853 } else { 00854 ResNode = CurDAG->getTargetNode(PPC::VCMPGTFP, MVT::v4f32, Tmp1, Tmp2); 00855 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00856 Result = SDOperand(ResNode, 0); 00857 } 00858 return; 00859 } 00860 00861 // Pattern: (PPCvcmp:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, 6:i32) 00862 // Emits: (VCMPEQUB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 00863 // Pattern complexity = 5 cost = 1 00864 if (CN0 == 6 && 00865 N.Val->getValueType(0) == MVT::v16i8) { 00866 Select(Tmp1, N0); 00867 Select(Tmp2, N1); 00868 if (N.Val->hasOneUse()) { 00869 Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPEQUB, MVT::v16i8, Tmp1, Tmp2); 00870 } else { 00871 ResNode = CurDAG->getTargetNode(PPC::VCMPEQUB, MVT::v16i8, Tmp1, Tmp2); 00872 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00873 Result = SDOperand(ResNode, 0); 00874 } 00875 return; 00876 } 00877 00878 // Pattern: (PPCvcmp:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, 774:i32) 00879 // Emits: (VCMPGTSB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 00880 // Pattern complexity = 5 cost = 1 00881 if (CN0 == 774 && 00882 N.Val->getValueType(0) == MVT::v16i8) { 00883 Select(Tmp1, N0); 00884 Select(Tmp2, N1); 00885 if (N.Val->hasOneUse()) { 00886 Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPGTSB, MVT::v16i8, Tmp1, Tmp2); 00887 } else { 00888 ResNode = CurDAG->getTargetNode(PPC::VCMPGTSB, MVT::v16i8, Tmp1, Tmp2); 00889 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00890 Result = SDOperand(ResNode, 0); 00891 } 00892 return; 00893 } 00894 00895 // Pattern: (PPCvcmp:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, 518:i32) 00896 // Emits: (VCMPGTUB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 00897 // Pattern complexity = 5 cost = 1 00898 if (CN0 == 518 && 00899 N.Val->getValueType(0) == MVT::v16i8) { 00900 Select(Tmp1, N0); 00901 Select(Tmp2, N1); 00902 if (N.Val->hasOneUse()) { 00903 Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPGTUB, MVT::v16i8, Tmp1, Tmp2); 00904 } else { 00905 ResNode = CurDAG->getTargetNode(PPC::VCMPGTUB, MVT::v16i8, Tmp1, Tmp2); 00906 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00907 Result = SDOperand(ResNode, 0); 00908 } 00909 return; 00910 } 00911 00912 // Pattern: (PPCvcmp:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, 70:i32) 00913 // Emits: (VCMPEQUH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 00914 // Pattern complexity = 5 cost = 1 00915 if (CN0 == 70 && 00916 N.Val->getValueType(0) == MVT::v8i16) { 00917 Select(Tmp1, N0); 00918 Select(Tmp2, N1); 00919 if (N.Val->hasOneUse()) { 00920 Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPEQUH, MVT::v8i16, Tmp1, Tmp2); 00921 } else { 00922 ResNode = CurDAG->getTargetNode(PPC::VCMPEQUH, MVT::v8i16, Tmp1, Tmp2); 00923 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00924 Result = SDOperand(ResNode, 0); 00925 } 00926 return; 00927 } 00928 00929 // Pattern: (PPCvcmp:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, 838:i32) 00930 // Emits: (VCMPGTSH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 00931 // Pattern complexity = 5 cost = 1 00932 if (CN0 == 838 && 00933 N.Val->getValueType(0) == MVT::v8i16) { 00934 Select(Tmp1, N0); 00935 Select(Tmp2, N1); 00936 if (N.Val->hasOneUse()) { 00937 Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPGTSH, MVT::v8i16, Tmp1, Tmp2); 00938 } else { 00939 ResNode = CurDAG->getTargetNode(PPC::VCMPGTSH, MVT::v8i16, Tmp1, Tmp2); 00940 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00941 Result = SDOperand(ResNode, 0); 00942 } 00943 return; 00944 } 00945 00946 // Pattern: (PPCvcmp:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, 582:i32) 00947 // Emits: (VCMPGTUH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 00948 // Pattern complexity = 5 cost = 1 00949 if (CN0 == 582 && 00950 N.Val->getValueType(0) == MVT::v8i16) { 00951 Select(Tmp1, N0); 00952 Select(Tmp2, N1); 00953 if (N.Val->hasOneUse()) { 00954 Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPGTUH, MVT::v8i16, Tmp1, Tmp2); 00955 } else { 00956 ResNode = CurDAG->getTargetNode(PPC::VCMPGTUH, MVT::v8i16, Tmp1, Tmp2); 00957 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00958 Result = SDOperand(ResNode, 0); 00959 } 00960 return; 00961 } 00962 00963 // Pattern: (PPCvcmp:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, 134:i32) 00964 // Emits: (VCMPEQUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 00965 // Pattern complexity = 5 cost = 1 00966 if (CN0 == 134 && 00967 N.Val->getValueType(0) == MVT::v4i32) { 00968 Select(Tmp1, N0); 00969 Select(Tmp2, N1); 00970 if (N.Val->hasOneUse()) { 00971 Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPEQUW, MVT::v4i32, Tmp1, Tmp2); 00972 } else { 00973 ResNode = CurDAG->getTargetNode(PPC::VCMPEQUW, MVT::v4i32, Tmp1, Tmp2); 00974 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00975 Result = SDOperand(ResNode, 0); 00976 } 00977 return; 00978 } 00979 00980 // Pattern: (PPCvcmp:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, 902:i32) 00981 // Emits: (VCMPGTSW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 00982 // Pattern complexity = 5 cost = 1 00983 if (CN0 == 902 && 00984 N.Val->getValueType(0) == MVT::v4i32) { 00985 Select(Tmp1, N0); 00986 Select(Tmp2, N1); 00987 if (N.Val->hasOneUse()) { 00988 Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPGTSW, MVT::v4i32, Tmp1, Tmp2); 00989 } else { 00990 ResNode = CurDAG->getTargetNode(PPC::VCMPGTSW, MVT::v4i32, Tmp1, Tmp2); 00991 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00992 Result = SDOperand(ResNode, 0); 00993 } 00994 return; 00995 } 00996 00997 // Pattern: (PPCvcmp:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, 646:i32) 00998 // Emits: (VCMPGTUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 00999 // Pattern complexity = 5 cost = 1 01000 if (CN0 == 646 && 01001 N.Val->getValueType(0) == MVT::v4i32) { 01002 Select(Tmp1, N0); 01003 Select(Tmp2, N1); 01004 if (N.Val->hasOneUse()) { 01005 Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPGTUW, MVT::v4i32, Tmp1, Tmp2); 01006 } else { 01007 ResNode = CurDAG->getTargetNode(PPC::VCMPGTUW, MVT::v4i32, Tmp1, Tmp2); 01008 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01009 Result = SDOperand(ResNode, 0); 01010 } 01011 return; 01012 } 01013 } 01014 std::cerr << "Cannot yet select: "; 01015 N.Val->dump(CurDAG); 01016 std::cerr << '\n'; 01017 abort(); 01018 } 01019 01020 void Select_PPCvcmp_o(SDOperand &Result, SDOperand N) { 01021 SDOperand InFlag(0, 0); 01022 SDOperand N0(0, 0); 01023 SDOperand N1(0, 0); 01024 SDOperand N2(0, 0); 01025 SDOperand Tmp1(0, 0); 01026 SDOperand Tmp2(0, 0); 01027 SDNode *ResNode; 01028 N0 = N.getOperand(0); 01029 N1 = N.getOperand(1); 01030 N2 = N.getOperand(2); 01031 if (isa<ConstantSDNode>(N2)) { 01032 int64_t CN0 = cast<ConstantSDNode>(N2)->getSignExtended(); 01033 01034 // Pattern: (PPCvcmp_o:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 966:i32) 01035 // Emits: (VCMPBFPo:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 01036 // Pattern complexity = 5 cost = 1 01037 if (CN0 == 966 && 01038 N.Val->getValueType(0) == MVT::v4f32) { 01039 Select(Tmp1, N0); 01040 Select(Tmp2, N1); 01041 ResNode = CurDAG->getTargetNode(PPC::VCMPBFPo, MVT::v4f32, MVT::Flag, Tmp1, Tmp2); 01042 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01043 InFlag = SDOperand(ResNode, 1); 01044 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01045 Result = SDOperand(ResNode, N.ResNo); 01046 return; 01047 } 01048 01049 // Pattern: (PPCvcmp_o:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 198:i32) 01050 // Emits: (VCMPEQFPo:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 01051 // Pattern complexity = 5 cost = 1 01052 if (CN0 == 198 && 01053 N.Val->getValueType(0) == MVT::v4f32) { 01054 Select(Tmp1, N0); 01055 Select(Tmp2, N1); 01056 ResNode = CurDAG->getTargetNode(PPC::VCMPEQFPo, MVT::v4f32, MVT::Flag, Tmp1, Tmp2); 01057 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01058 InFlag = SDOperand(ResNode, 1); 01059 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01060 Result = SDOperand(ResNode, N.ResNo); 01061 return; 01062 } 01063 01064 // Pattern: (PPCvcmp_o:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 454:i32) 01065 // Emits: (VCMPGEFPo:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 01066 // Pattern complexity = 5 cost = 1 01067 if (CN0 == 454 && 01068 N.Val->getValueType(0) == MVT::v4f32) { 01069 Select(Tmp1, N0); 01070 Select(Tmp2, N1); 01071 ResNode = CurDAG->getTargetNode(PPC::VCMPGEFPo, MVT::v4f32, MVT::Flag, Tmp1, Tmp2); 01072 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01073 InFlag = SDOperand(ResNode, 1); 01074 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01075 Result = SDOperand(ResNode, N.ResNo); 01076 return; 01077 } 01078 01079 // Pattern: (PPCvcmp_o:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 710:i32) 01080 // Emits: (VCMPGTFPo:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 01081 // Pattern complexity = 5 cost = 1 01082 if (CN0 == 710 && 01083 N.Val->getValueType(0) == MVT::v4f32) { 01084 Select(Tmp1, N0); 01085 Select(Tmp2, N1); 01086 ResNode = CurDAG->getTargetNode(PPC::VCMPGTFPo, MVT::v4f32, MVT::Flag, Tmp1, Tmp2); 01087 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01088 InFlag = SDOperand(ResNode, 1); 01089 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01090 Result = SDOperand(ResNode, N.ResNo); 01091 return; 01092 } 01093 01094 // Pattern: (PPCvcmp_o:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, 6:i32) 01095 // Emits: (VCMPEQUBo:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 01096 // Pattern complexity = 5 cost = 1 01097 if (CN0 == 6 && 01098 N.Val->getValueType(0) == MVT::v16i8) { 01099 Select(Tmp1, N0); 01100 Select(Tmp2, N1); 01101 ResNode = CurDAG->getTargetNode(PPC::VCMPEQUBo, MVT::v16i8, MVT::Flag, Tmp1, Tmp2); 01102 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01103 InFlag = SDOperand(ResNode, 1); 01104 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01105 Result = SDOperand(ResNode, N.ResNo); 01106 return; 01107 } 01108 01109 // Pattern: (PPCvcmp_o:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, 774:i32) 01110 // Emits: (VCMPGTSBo:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 01111 // Pattern complexity = 5 cost = 1 01112 if (CN0 == 774 && 01113 N.Val->getValueType(0) == MVT::v16i8) { 01114 Select(Tmp1, N0); 01115 Select(Tmp2, N1); 01116 ResNode = CurDAG->getTargetNode(PPC::VCMPGTSBo, MVT::v16i8, MVT::Flag, Tmp1, Tmp2); 01117 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01118 InFlag = SDOperand(ResNode, 1); 01119 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01120 Result = SDOperand(ResNode, N.ResNo); 01121 return; 01122 } 01123 01124 // Pattern: (PPCvcmp_o:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, 518:i32) 01125 // Emits: (VCMPGTUBo:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 01126 // Pattern complexity = 5 cost = 1 01127 if (CN0 == 518 && 01128 N.Val->getValueType(0) == MVT::v16i8) { 01129 Select(Tmp1, N0); 01130 Select(Tmp2, N1); 01131 ResNode = CurDAG->getTargetNode(PPC::VCMPGTUBo, MVT::v16i8, MVT::Flag, Tmp1, Tmp2); 01132 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01133 InFlag = SDOperand(ResNode, 1); 01134 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01135 Result = SDOperand(ResNode, N.ResNo); 01136 return; 01137 } 01138 01139 // Pattern: (PPCvcmp_o:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, 70:i32) 01140 // Emits: (VCMPEQUHo:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 01141 // Pattern complexity = 5 cost = 1 01142 if (CN0 == 70 && 01143 N.Val->getValueType(0) == MVT::v8i16) { 01144 Select(Tmp1, N0); 01145 Select(Tmp2, N1); 01146 ResNode = CurDAG->getTargetNode(PPC::VCMPEQUHo, MVT::v8i16, MVT::Flag, Tmp1, Tmp2); 01147 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01148 InFlag = SDOperand(ResNode, 1); 01149 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01150 Result = SDOperand(ResNode, N.ResNo); 01151 return; 01152 } 01153 01154 // Pattern: (PPCvcmp_o:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, 838:i32) 01155 // Emits: (VCMPGTSHo:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 01156 // Pattern complexity = 5 cost = 1 01157 if (CN0 == 838 && 01158 N.Val->getValueType(0) == MVT::v8i16) { 01159 Select(Tmp1, N0); 01160 Select(Tmp2, N1); 01161 ResNode = CurDAG->getTargetNode(PPC::VCMPGTSHo, MVT::v8i16, MVT::Flag, Tmp1, Tmp2); 01162 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01163 InFlag = SDOperand(ResNode, 1); 01164 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01165 Result = SDOperand(ResNode, N.ResNo); 01166 return; 01167 } 01168 01169 // Pattern: (PPCvcmp_o:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, 582:i32) 01170 // Emits: (VCMPGTUHo:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 01171 // Pattern complexity = 5 cost = 1 01172 if (CN0 == 582 && 01173 N.Val->getValueType(0) == MVT::v8i16) { 01174 Select(Tmp1, N0); 01175 Select(Tmp2, N1); 01176 ResNode = CurDAG->getTargetNode(PPC::VCMPGTUHo, MVT::v8i16, MVT::Flag, Tmp1, Tmp2); 01177 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01178 InFlag = SDOperand(ResNode, 1); 01179 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01180 Result = SDOperand(ResNode, N.ResNo); 01181 return; 01182 } 01183 01184 // Pattern: (PPCvcmp_o:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, 134:i32) 01185 // Emits: (VCMPEQUWo:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 01186 // Pattern complexity = 5 cost = 1 01187 if (CN0 == 134 && 01188 N.Val->getValueType(0) == MVT::v4i32) { 01189 Select(Tmp1, N0); 01190 Select(Tmp2, N1); 01191 ResNode = CurDAG->getTargetNode(PPC::VCMPEQUWo, MVT::v4i32, MVT::Flag, Tmp1, Tmp2); 01192 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01193 InFlag = SDOperand(ResNode, 1); 01194 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01195 Result = SDOperand(ResNode, N.ResNo); 01196 return; 01197 } 01198 01199 // Pattern: (PPCvcmp_o:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, 902:i32) 01200 // Emits: (VCMPGTSWo:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 01201 // Pattern complexity = 5 cost = 1 01202 if (CN0 == 902 && 01203 N.Val->getValueType(0) == MVT::v4i32) { 01204 Select(Tmp1, N0); 01205 Select(Tmp2, N1); 01206 ResNode = CurDAG->getTargetNode(PPC::VCMPGTSWo, MVT::v4i32, MVT::Flag, Tmp1, Tmp2); 01207 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01208 InFlag = SDOperand(ResNode, 1); 01209 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01210 Result = SDOperand(ResNode, N.ResNo); 01211 return; 01212 } 01213 01214 // Pattern: (PPCvcmp_o:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, 646:i32) 01215 // Emits: (VCMPGTUWo:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 01216 // Pattern complexity = 5 cost = 1 01217 if (CN0 == 646 && 01218 N.Val->getValueType(0) == MVT::v4i32) { 01219 Select(Tmp1, N0); 01220 Select(Tmp2, N1); 01221 ResNode = CurDAG->getTargetNode(PPC::VCMPGTUWo, MVT::v4i32, MVT::Flag, Tmp1, Tmp2); 01222 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01223 InFlag = SDOperand(ResNode, 1); 01224 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01225 Result = SDOperand(ResNode, N.ResNo); 01226 return; 01227 } 01228 } 01229 std::cerr << "Cannot yet select: "; 01230 N.Val->dump(CurDAG); 01231 std::cerr << '\n'; 01232 abort(); 01233 } 01234 01235 void Select_PPCvmaddfp(SDOperand &Result, SDOperand N) { 01236 SDOperand N0(0, 0); 01237 SDOperand N1(0, 0); 01238 SDOperand N2(0, 0); 01239 SDOperand Tmp0(0, 0); 01240 SDOperand Tmp1(0, 0); 01241 SDOperand Tmp2(0, 0); 01242 SDNode *ResNode; 01243 N0 = N.getOperand(0); 01244 N1 = N.getOperand(1); 01245 N2 = N.getOperand(2); 01246 if (N.Val->getValueType(0) == MVT::v4f32) { 01247 Select(Tmp0, N0); 01248 Select(Tmp1, N1); 01249 Select(Tmp2, N2); 01250 if (N.Val->hasOneUse()) { 01251 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMADDFP, MVT::v16i8, Tmp0, Tmp1, Tmp2); 01252 } else { 01253 ResNode = CurDAG->getTargetNode(PPC::VMADDFP, MVT::v16i8, Tmp0, Tmp1, Tmp2); 01254 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01255 Result = SDOperand(ResNode, 0); 01256 } 01257 return; 01258 } 01259 std::cerr << "Cannot yet select: "; 01260 N.Val->dump(CurDAG); 01261 std::cerr << '\n'; 01262 abort(); 01263 } 01264 01265 void Select_PPCvnmsubfp(SDOperand &Result, SDOperand N) { 01266 SDOperand N0(0, 0); 01267 SDOperand N1(0, 0); 01268 SDOperand N2(0, 0); 01269 SDOperand Tmp0(0, 0); 01270 SDOperand Tmp1(0, 0); 01271 SDOperand Tmp2(0, 0); 01272 SDNode *ResNode; 01273 N0 = N.getOperand(0); 01274 N1 = N.getOperand(1); 01275 N2 = N.getOperand(2); 01276 if (N.Val->getValueType(0) == MVT::v4f32) { 01277 Select(Tmp0, N0); 01278 Select(Tmp1, N1); 01279 Select(Tmp2, N2); 01280 if (N.Val->hasOneUse()) { 01281 Result = CurDAG->SelectNodeTo(N.Val, PPC::VNMSUBFP, MVT::v16i8, Tmp0, Tmp1, Tmp2); 01282 } else { 01283 ResNode = CurDAG->getTargetNode(PPC::VNMSUBFP, MVT::v16i8, Tmp0, Tmp1, Tmp2); 01284 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01285 Result = SDOperand(ResNode, 0); 01286 } 01287 return; 01288 } 01289 std::cerr << "Cannot yet select: "; 01290 N.Val->dump(CurDAG); 01291 std::cerr << '\n'; 01292 abort(); 01293 } 01294 01295 void Select_PPCvperm(SDOperand &Result, SDOperand N) { 01296 SDOperand N0(0, 0); 01297 SDOperand N1(0, 0); 01298 SDOperand N2(0, 0); 01299 SDOperand Tmp0(0, 0); 01300 SDOperand Tmp1(0, 0); 01301 SDOperand Tmp2(0, 0); 01302 SDNode *ResNode; 01303 N0 = N.getOperand(0); 01304 N1 = N.getOperand(1); 01305 N2 = N.getOperand(2); 01306 if (N.Val->getValueType(0) == MVT::v16i8) { 01307 Select(Tmp0, N0); 01308 Select(Tmp1, N1); 01309 Select(Tmp2, N2); 01310 if (N.Val->hasOneUse()) { 01311 Result = CurDAG->SelectNodeTo(N.Val, PPC::VPERM, MVT::v16i8, Tmp0, Tmp1, Tmp2); 01312 } else { 01313 ResNode = CurDAG->getTargetNode(PPC::VPERM, MVT::v16i8, Tmp0, Tmp1, Tmp2); 01314 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01315 Result = SDOperand(ResNode, 0); 01316 } 01317 return; 01318 } 01319 std::cerr << "Cannot yet select: "; 01320 N.Val->dump(CurDAG); 01321 std::cerr << '\n'; 01322 abort(); 01323 } 01324 01325 void Select_add(SDOperand &Result, SDOperand N) { 01326 SDOperand N0(0, 0); 01327 SDOperand N00(0, 0); 01328 SDOperand N01(0, 0); 01329 SDOperand N1(0, 0); 01330 SDOperand N10(0, 0); 01331 SDOperand N11(0, 0); 01332 SDOperand Tmp0(0, 0); 01333 SDOperand Tmp1(0, 0); 01334 SDOperand Tmp2(0, 0); 01335 SDOperand Tmp3(0, 0); 01336 SDOperand Tmp4(0, 0); 01337 SDNode *ResNode; 01338 N0 = N.getOperand(0); 01339 { 01340 N1 = N.getOperand(1); 01341 01342 // Pattern: (add:i32 GPRC:i32:$rA, (PPClo:i32 (tglobaladdr:i32):$sym, 0:i32)) 01343 // Emits: (LA:i32 GPRC:i32:$rA, (tglobaladdr:i32):$sym) 01344 // Pattern complexity = 9 cost = 1 01345 if (N1.getOpcode() == PPCISD::Lo) { 01346 N10 = N1.getOperand(0); 01347 if (N10.getOpcode() == ISD::TargetGlobalAddress) { 01348 N11 = N1.getOperand(1); 01349 if (isa<ConstantSDNode>(N11)) { 01350 int64_t CN0 = cast<ConstantSDNode>(N11)->getSignExtended(); 01351 if (CN0 == 0) { 01352 Select(Tmp1, N0); 01353 Tmp2 = N10; 01354 if (N.Val->hasOneUse()) { 01355 Result = CurDAG->SelectNodeTo(N.Val, PPC::LA, MVT::i32, Tmp1, Tmp2); 01356 } else { 01357 ResNode = CurDAG->getTargetNode(PPC::LA, MVT::i32, Tmp1, Tmp2); 01358 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01359 Result = SDOperand(ResNode, 0); 01360 } 01361 return; 01362 } 01363 } 01364 } 01365 } 01366 if (N1.getOpcode() == PPCISD::Hi) { 01367 N10 = N1.getOperand(0); 01368 01369 // Pattern: (add:i32 GPRC:i32:$in, (PPChi:i32 (tglobaladdr:i32):$g, 0:i32)) 01370 // Emits: (ADDIS:i32 GPRC:i32:$in, (tglobaladdr:i32):$g) 01371 // Pattern complexity = 9 cost = 1 01372 if (N10.getOpcode() == ISD::TargetGlobalAddress) { 01373 N11 = N1.getOperand(1); 01374 if (isa<ConstantSDNode>(N11)) { 01375 int64_t CN0 = cast<ConstantSDNode>(N11)->getSignExtended(); 01376 if (CN0 == 0) { 01377 Select(Tmp1, N0); 01378 Tmp2 = N10; 01379 if (N.Val->hasOneUse()) { 01380 Result = CurDAG->SelectNodeTo(N.Val, PPC::ADDIS, MVT::i32, Tmp1, Tmp2); 01381 } else { 01382 ResNode = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, Tmp1, Tmp2); 01383 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01384 Result = SDOperand(ResNode, 0); 01385 } 01386 return; 01387 } 01388 } 01389 } 01390 01391 // Pattern: (add:i32 GPRC:i32:$in, (PPChi:i32 (tconstpool:i32):$g, 0:i32)) 01392 // Emits: (ADDIS:i32 GPRC:i32:$in, (tconstpool:i32):$g) 01393 // Pattern complexity = 9 cost = 1 01394 if (N10.getOpcode() == ISD::TargetConstantPool) { 01395 N11 = N1.getOperand(1); 01396 if (isa<ConstantSDNode>(N11)) { 01397 int64_t CN0 = cast<ConstantSDNode>(N11)->getSignExtended(); 01398 if (CN0 == 0) { 01399 Select(Tmp1, N0); 01400 Tmp2 = N10; 01401 if (N.Val->hasOneUse()) { 01402 Result = CurDAG->SelectNodeTo(N.Val, PPC::ADDIS, MVT::i32, Tmp1, Tmp2); 01403 } else { 01404 ResNode = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, Tmp1, Tmp2); 01405 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01406 Result = SDOperand(ResNode, 0); 01407 } 01408 return; 01409 } 01410 } 01411 } 01412 } 01413 } 01414 01415 // Pattern: (add:i32 (PPClo:i32 (tglobaladdr:i32):$sym, 0:i32), GPRC:i32:$rA) 01416 // Emits: (LA:i32 GPRC:i32:$rA, (tglobaladdr:i32):$sym) 01417 // Pattern complexity = 9 cost = 1 01418 if (N0.getOpcode() == PPCISD::Lo) { 01419 N00 = N0.getOperand(0); 01420 if (N00.getOpcode() == ISD::TargetGlobalAddress) { 01421 N01 = N0.getOperand(1); 01422 if (isa<ConstantSDNode>(N01)) { 01423 int64_t CN0 = cast<ConstantSDNode>(N01)->getSignExtended(); 01424 if (CN0 == 0) { 01425 N1 = N.getOperand(1); 01426 Select(Tmp1, N1); 01427 Tmp2 = N00; 01428 if (N.Val->hasOneUse()) { 01429 Result = CurDAG->SelectNodeTo(N.Val, PPC::LA, MVT::i32, Tmp1, Tmp2); 01430 } else { 01431 ResNode = CurDAG->getTargetNode(PPC::LA, MVT::i32, Tmp1, Tmp2); 01432 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01433 Result = SDOperand(ResNode, 0); 01434 } 01435 return; 01436 } 01437 } 01438 } 01439 } 01440 if (N0.getOpcode() == PPCISD::Hi) { 01441 N00 = N0.getOperand(0); 01442 01443 // Pattern: (add:i32 (PPChi:i32 (tglobaladdr:i32):$g, 0:i32), GPRC:i32:$in) 01444 // Emits: (ADDIS:i32 GPRC:i32:$in, (tglobaladdr:i32):$g) 01445 // Pattern complexity = 9 cost = 1 01446 if (N00.getOpcode() == ISD::TargetGlobalAddress) { 01447 N01 = N0.getOperand(1); 01448 if (isa<ConstantSDNode>(N01)) { 01449 int64_t CN0 = cast<ConstantSDNode>(N01)->getSignExtended(); 01450 if (CN0 == 0) { 01451 N1 = N.getOperand(1); 01452 Select(Tmp1, N1); 01453 Tmp2 = N00; 01454 if (N.Val->hasOneUse()) { 01455 Result = CurDAG->SelectNodeTo(N.Val, PPC::ADDIS, MVT::i32, Tmp1, Tmp2); 01456 } else { 01457 ResNode = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, Tmp1, Tmp2); 01458 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01459 Result = SDOperand(ResNode, 0); 01460 } 01461 return; 01462 } 01463 } 01464 } 01465 01466 // Pattern: (add:i32 (PPChi:i32 (tconstpool:i32):$g, 0:i32), GPRC:i32:$in) 01467 // Emits: (ADDIS:i32 GPRC:i32:$in, (tconstpool:i32):$g) 01468 // Pattern complexity = 9 cost = 1 01469 if (N00.getOpcode() == ISD::TargetConstantPool) { 01470 N01 = N0.getOperand(1); 01471 if (isa<ConstantSDNode>(N01)) { 01472 int64_t CN0 = cast<ConstantSDNode>(N01)->getSignExtended(); 01473 if (CN0 == 0) { 01474 N1 = N.getOperand(1); 01475 Select(Tmp1, N1); 01476 Tmp2 = N00; 01477 if (N.Val->hasOneUse()) { 01478 Result = CurDAG->SelectNodeTo(N.Val, PPC::ADDIS, MVT::i32, Tmp1, Tmp2); 01479 } else { 01480 ResNode = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, Tmp1, Tmp2); 01481 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01482 Result = SDOperand(ResNode, 0); 01483 } 01484 return; 01485 } 01486 } 01487 } 01488 } 01489 N1 = N.getOperand(1); 01490 if (N1.getOpcode() == ISD::Constant) { 01491 01492 // Pattern: (add:i32 GPRC:i32:$rA, (imm:i32)<<P:Predicate_immSExt16>>:$imm) 01493 // Emits: (ADDI:i32 GPRC:i32:$rA, (imm:i32):$imm) 01494 // Pattern complexity = 5 cost = 1 01495 if (Predicate_immSExt16(N1.Val) && 01496 N.Val->getValueType(0) == MVT::i32) { 01497 Select(Tmp0, N0); 01498 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 01499 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 01500 if (N.Val->hasOneUse()) { 01501 Result = CurDAG->SelectNodeTo(N.Val, PPC::ADDI, MVT::i32, Tmp0, Tmp1); 01502 } else { 01503 ResNode = CurDAG->getTargetNode(PPC::ADDI, MVT::i32, Tmp0, Tmp1); 01504 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01505 Result = SDOperand(ResNode, 0); 01506 } 01507 return; 01508 } 01509 01510 // Pattern: (add:i32 GPRC:i32:$rA, (imm:i32)<<P:Predicate_imm16Shifted>><<X:HI16>>:$imm) 01511 // Emits: (ADDIS:i32 GPRC:i32:$rA, (HI16:i32 (imm:i32):$imm)) 01512 // Pattern complexity = 5 cost = 1 01513 if (Predicate_imm16Shifted(N1.Val) && 01514 N.Val->getValueType(0) == MVT::i32) { 01515 Select(Tmp0, N0); 01516 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 01517 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 01518 Tmp2 = Transform_HI16(Tmp1.Val); 01519 if (N.Val->hasOneUse()) { 01520 Result = CurDAG->SelectNodeTo(N.Val, PPC::ADDIS, MVT::i32, Tmp0, Tmp2); 01521 } else { 01522 ResNode = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, Tmp0, Tmp2); 01523 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01524 Result = SDOperand(ResNode, 0); 01525 } 01526 return; 01527 } 01528 01529 // Pattern: (add:i32 GPRC:i32:$in, (imm:i32):$imm) 01530 // Emits: (ADDIS:i32 (ADDI:i32 GPRC:i32:$in, (LO16:i32 (imm:i32):$imm)), (HA16:i32 (imm:i32):$imm)) 01531 // Pattern complexity = 4 cost = 2 01532 if (N.Val->getValueType(0) == MVT::i32) { 01533 Select(Tmp0, N0); 01534 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 01535 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 01536 Tmp2 = Transform_LO16(Tmp1.Val); 01537 Tmp3 = SDOperand(CurDAG->getTargetNode(PPC::ADDI, MVT::i32, Tmp0, Tmp2), 0); 01538 Tmp4 = Transform_HA16(Tmp1.Val); 01539 if (N.Val->hasOneUse()) { 01540 Result = CurDAG->SelectNodeTo(N.Val, PPC::ADDIS, MVT::i32, Tmp3, Tmp4); 01541 } else { 01542 ResNode = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, Tmp3, Tmp4); 01543 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01544 Result = SDOperand(ResNode, 0); 01545 } 01546 return; 01547 } 01548 } 01549 01550 // Pattern: (add:i32 GPRC:i32:$rA, GPRC:i32:$rB) 01551 // Emits: (ADD4:i32 GPRC:i32:$rA, GPRC:i32:$rB) 01552 // Pattern complexity = 2 cost = 1 01553 if (N.Val->getValueType(0) == MVT::i32) { 01554 Select(Tmp0, N0); 01555 Select(Tmp1, N1); 01556 if (N.Val->hasOneUse()) { 01557 Result = CurDAG->SelectNodeTo(N.Val, PPC::ADD4, MVT::i32, Tmp0, Tmp1); 01558 } else { 01559 ResNode = CurDAG->getTargetNode(PPC::ADD4, MVT::i32, Tmp0, Tmp1); 01560 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01561 Result = SDOperand(ResNode, 0); 01562 } 01563 return; 01564 } 01565 01566 // Pattern: (add:i64 G8RC:i64:$rA, G8RC:i64:$rB) 01567 // Emits: (ADD8:i64 G8RC:i64:$rA, G8RC:i64:$rB) 01568 // Pattern complexity = 2 cost = 1 01569 if (N.Val->getValueType(0) == MVT::i64) { 01570 Select(Tmp0, N0); 01571 Select(Tmp1, N1); 01572 if (N.Val->hasOneUse()) { 01573 Result = CurDAG->SelectNodeTo(N.Val, PPC::ADD8, MVT::i64, Tmp0, Tmp1); 01574 } else { 01575 ResNode = CurDAG->getTargetNode(PPC::ADD8, MVT::i64, Tmp0, Tmp1); 01576 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01577 Result = SDOperand(ResNode, 0); 01578 } 01579 return; 01580 } 01581 01582 // Pattern: (add:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 01583 // Emits: (VADDUBM:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 01584 // Pattern complexity = 2 cost = 1 01585 if (N.Val->getValueType(0) == MVT::v16i8) { 01586 Select(Tmp0, N0); 01587 Select(Tmp1, N1); 01588 if (N.Val->hasOneUse()) { 01589 Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDUBM, MVT::v16i8, Tmp0, Tmp1); 01590 } else { 01591 ResNode = CurDAG->getTargetNode(PPC::VADDUBM, MVT::v16i8, Tmp0, Tmp1); 01592 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01593 Result = SDOperand(ResNode, 0); 01594 } 01595 return; 01596 } 01597 01598 // Pattern: (add:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 01599 // Emits: (VADDUHM:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 01600 // Pattern complexity = 2 cost = 1 01601 if (N.Val->getValueType(0) == MVT::v8i16) { 01602 Select(Tmp0, N0); 01603 Select(Tmp1, N1); 01604 if (N.Val->hasOneUse()) { 01605 Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDUHM, MVT::v8i16, Tmp0, Tmp1); 01606 } else { 01607 ResNode = CurDAG->getTargetNode(PPC::VADDUHM, MVT::v8i16, Tmp0, Tmp1); 01608 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01609 Result = SDOperand(ResNode, 0); 01610 } 01611 return; 01612 } 01613 01614 // Pattern: (add:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 01615 // Emits: (VADDUWM:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 01616 // Pattern complexity = 2 cost = 1 01617 if (N.Val->getValueType(0) == MVT::v4i32) { 01618 Select(Tmp0, N0); 01619 Select(Tmp1, N1); 01620 if (N.Val->hasOneUse()) { 01621 Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDUWM, MVT::v4i32, Tmp0, Tmp1); 01622 } else { 01623 ResNode = CurDAG->getTargetNode(PPC::VADDUWM, MVT::v4i32, Tmp0, Tmp1); 01624 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01625 Result = SDOperand(ResNode, 0); 01626 } 01627 return; 01628 } 01629 std::cerr << "Cannot yet select: "; 01630 N.Val->dump(CurDAG); 01631 std::cerr << '\n'; 01632 abort(); 01633 } 01634 01635 void Select_addc(SDOperand &Result, SDOperand N) { 01636 SDOperand InFlag(0, 0); 01637 SDOperand N0(0, 0); 01638 SDOperand N1(0, 0); 01639 SDOperand Tmp0(0, 0); 01640 SDOperand Tmp1(0, 0); 01641 SDNode *ResNode; 01642 N0 = N.getOperand(0); 01643 N1 = N.getOperand(1); 01644 01645 // Pattern: (addc:i32 GPRC:i32:$rA, (imm:i32)<<P:Predicate_immSExt16>>:$imm) 01646 // Emits: (ADDIC:i32 GPRC:i32:$rA, (imm:i32):$imm) 01647 // Pattern complexity = 5 cost = 1 01648 if (N1.getOpcode() == ISD::Constant && 01649 Predicate_immSExt16(N1.Val) && 01650 N.Val->getValueType(0) == MVT::i32) { 01651 Select(Tmp0, N0); 01652 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 01653 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 01654 ResNode = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, Tmp0, Tmp1); 01655 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01656 InFlag = SDOperand(ResNode, 1); 01657 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01658 Result = SDOperand(ResNode, N.ResNo); 01659 return; 01660 } 01661 01662 // Pattern: (addc:i32 GPRC:i32:$rA, GPRC:i32:$rB) 01663 // Emits: (ADDC:i32 GPRC:i32:$rA, GPRC:i32:$rB) 01664 // Pattern complexity = 2 cost = 1 01665 if (N.Val->getValueType(0) == MVT::i32) { 01666 Select(Tmp0, N0); 01667 Select(Tmp1, N1); 01668 ResNode = CurDAG->getTargetNode(PPC::ADDC, MVT::i32, MVT::Flag, Tmp0, Tmp1); 01669 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01670 InFlag = SDOperand(ResNode, 1); 01671 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01672 Result = SDOperand(ResNode, N.ResNo); 01673 return; 01674 } 01675 std::cerr << "Cannot yet select: "; 01676 N.Val->dump(CurDAG); 01677 std::cerr << '\n'; 01678 abort(); 01679 } 01680 01681 void Select_adde(SDOperand &Result, SDOperand N) { 01682 SDOperand InFlag(0, 0); 01683 SDOperand N0(0, 0); 01684 SDOperand N1(0, 0); 01685 SDOperand Tmp0(0, 0); 01686 SDOperand Tmp1(0, 0); 01687 SDNode *ResNode; 01688 N0 = N.getOperand(0); 01689 { 01690 N1 = N.getOperand(1); 01691 01692 // Pattern: (adde:i32 GPRC:i32:$rA, (imm:i32)<<P:Predicate_immAllOnes>>) 01693 // Emits: (ADDME:i32 GPRC:i32:$rA) 01694 // Pattern complexity = 5 cost = 1 01695 if (N1.getOpcode() == ISD::Constant && 01696 Predicate_immAllOnes(N1.Val) && 01697 N.Val->getValueType(0) == MVT::i32) { 01698 Select(Tmp0, N0); 01699 Select(InFlag, N.getOperand(2)); 01700 ResNode = CurDAG->getTargetNode(PPC::ADDME, MVT::i32, MVT::Flag, Tmp0, InFlag); 01701 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01702 InFlag = SDOperand(ResNode, 1); 01703 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01704 Result = SDOperand(ResNode, N.ResNo); 01705 return; 01706 } 01707 01708 // Pattern: (adde:i32 GPRC:i32:$rA, 0:i32) 01709 // Emits: (ADDZE:i32 GPRC:i32:$rA) 01710 // Pattern complexity = 5 cost = 1 01711 if (isa<ConstantSDNode>(N1)) { 01712 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 01713 if (CN0 == 0 && 01714 N.Val->getValueType(0) == MVT::i32) { 01715 Select(Tmp1, N0); 01716 Select(InFlag, N.getOperand(2)); 01717 ResNode = CurDAG->getTargetNode(PPC::ADDZE, MVT::i32, MVT::Flag, Tmp1, InFlag); 01718 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01719 InFlag = SDOperand(ResNode, 1); 01720 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01721 Result = SDOperand(ResNode, N.ResNo); 01722 return; 01723 } 01724 } 01725 } 01726 01727 // Pattern: (adde:i32 0:i32, GPRC:i32:$rA) 01728 // Emits: (ADDZE:i32 GPRC:i32:$rA) 01729 // Pattern complexity = 5 cost = 1 01730 if (isa<ConstantSDNode>(N0)) { 01731 int64_t CN0 = cast<ConstantSDNode>(N0)->getSignExtended(); 01732 if (CN0 == 0) { 01733 N1 = N.getOperand(1); 01734 if (N.Val->getValueType(0) == MVT::i32) { 01735 Select(Tmp1, N1); 01736 Select(InFlag, N.getOperand(2)); 01737 ResNode = CurDAG->getTargetNode(PPC::ADDZE, MVT::i32, MVT::Flag, Tmp1, InFlag); 01738 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01739 InFlag = SDOperand(ResNode, 1); 01740 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01741 Result = SDOperand(ResNode, N.ResNo); 01742 return; 01743 } 01744 } 01745 } 01746 01747 // Pattern: (adde:i32 GPRC:i32:$rA, GPRC:i32:$rB) 01748 // Emits: (ADDE:i32 GPRC:i32:$rA, GPRC:i32:$rB) 01749 // Pattern complexity = 2 cost = 1 01750 N1 = N.getOperand(1); 01751 if (N.Val->getValueType(0) == MVT::i32) { 01752 Select(Tmp0, N0); 01753 Select(Tmp1, N1); 01754 Select(InFlag, N.getOperand(2)); 01755 ResNode = CurDAG->getTargetNode(PPC::ADDE, MVT::i32, MVT::Flag, Tmp0, Tmp1, InFlag); 01756 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01757 InFlag = SDOperand(ResNode, 1); 01758 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01759 Result = SDOperand(ResNode, N.ResNo); 01760 return; 01761 } 01762 std::cerr << "Cannot yet select: "; 01763 N.Val->dump(CurDAG); 01764 std::cerr << '\n'; 01765 abort(); 01766 } 01767 01768 void Select_and(SDOperand &Result, SDOperand N) { 01769 SDOperand N0(0, 0); 01770 SDOperand N00(0, 0); 01771 SDOperand N01(0, 0); 01772 SDOperand N1(0, 0); 01773 SDOperand N10(0, 0); 01774 SDOperand N11(0, 0); 01775 SDOperand Tmp0(0, 0); 01776 SDOperand Tmp1(0, 0); 01777 SDOperand Tmp2(0, 0); 01778 SDNode *ResNode; 01779 N0 = N.getOperand(0); 01780 { 01781 N1 = N.getOperand(1); 01782 if (N1.getOpcode() == ISD::XOR) { 01783 N10 = N1.getOperand(0); 01784 N11 = N1.getOperand(1); 01785 01786 // Pattern: (and:i32 GPRC:i32:$rS, (xor:i32 GPRC:i32:$rB, (imm:i32)<<P:Predicate_immAllOnes>>)) 01787 // Emits: (ANDC:i32 GPRC:i32:$rS, GPRC:i32:$rB) 01788 // Pattern complexity = 7 cost = 1 01789 if (N11.getOpcode() == ISD::Constant && 01790 Predicate_immAllOnes(N11.Val) && 01791 N.Val->getValueType(0) == MVT::i32) { 01792 Select(Tmp0, N0); 01793 Select(Tmp1, N10); 01794 if (N.Val->hasOneUse()) { 01795 Result = CurDAG->SelectNodeTo(N.Val, PPC::ANDC, MVT::i32, Tmp0, Tmp1); 01796 } else { 01797 ResNode = CurDAG->getTargetNode(PPC::ANDC, MVT::i32, Tmp0, Tmp1); 01798 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01799 Result = SDOperand(ResNode, 0); 01800 } 01801 return; 01802 } 01803 if (N11.getOpcode() == ISD::BUILD_VECTOR && 01804 Predicate_immAllOnesV(N11.Val)) { 01805 01806 // Pattern: (and:v4i32 VRRC:v4i32:$vA, (xor:v4i32 VRRC:v4i32:$vB, (build_vector:v4i32)<<P:Predicate_immAllOnesV>>)) 01807 // Emits: (VANDC:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 01808 // Pattern complexity = 7 cost = 1 01809 if (N.Val->getValueType(0) == MVT::v4i32) { 01810 Select(Tmp0, N0); 01811 Select(Tmp1, N10); 01812 if (N.Val->hasOneUse()) { 01813 Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v4i32, Tmp0, Tmp1); 01814 } else { 01815 ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v4i32, Tmp0, Tmp1); 01816 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01817 Result = SDOperand(ResNode, 0); 01818 } 01819 return; 01820 } 01821 01822 // Pattern: (and:v16i8 VRRC:v16i8:$A, (xor:v16i8 VRRC:v16i8:$B, (build_vector:v16i8)<<P:Predicate_immAllOnesV>>)) 01823 // Emits: (VANDC:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B) 01824 // Pattern complexity = 7 cost = 1 01825 if (N.Val->getValueType(0) == MVT::v16i8) { 01826 Select(Tmp0, N0); 01827 Select(Tmp1, N10); 01828 if (N.Val->hasOneUse()) { 01829 Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v16i8, Tmp0, Tmp1); 01830 } else { 01831 ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v16i8, Tmp0, Tmp1); 01832 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01833 Result = SDOperand(ResNode, 0); 01834 } 01835 return; 01836 } 01837 01838 // Pattern: (and:v8i16 VRRC:v8i16:$A, (xor:v8i16 VRRC:v8i16:$B, (build_vector:v8i16)<<P:Predicate_immAllOnesV>>)) 01839 // Emits: (VANDC:v8i16 VRRC:v16i8:$A, VRRC:v16i8:$B) 01840 // Pattern complexity = 7 cost = 1 01841 if (N.Val->getValueType(0) == MVT::v8i16) { 01842 Select(Tmp0, N0); 01843 Select(Tmp1, N10); 01844 if (N.Val->hasOneUse()) { 01845 Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v8i16, Tmp0, Tmp1); 01846 } else { 01847 ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v8i16, Tmp0, Tmp1); 01848 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01849 Result = SDOperand(ResNode, 0); 01850 } 01851 return; 01852 } 01853 } 01854 } 01855 } 01856 01857 // Pattern: (and:i32 (xor:i32 GPRC:i32:$rB, (imm:i32)<<P:Predicate_immAllOnes>>), GPRC:i32:$rS) 01858 // Emits: (ANDC:i32 GPRC:i32:$rS, GPRC:i32:$rB) 01859 // Pattern complexity = 7 cost = 1 01860 if (N0.getOpcode() == ISD::XOR) { 01861 N00 = N0.getOperand(0); 01862 N01 = N0.getOperand(1); 01863 if (N01.getOpcode() == ISD::Constant && 01864 Predicate_immAllOnes(N01.Val)) { 01865 N1 = N.getOperand(1); 01866 if (N.Val->getValueType(0) == MVT::i32) { 01867 Select(Tmp0, N1); 01868 Select(Tmp1, N00); 01869 if (N.Val->hasOneUse()) { 01870 Result = CurDAG->SelectNodeTo(N.Val, PPC::ANDC, MVT::i32, Tmp0, Tmp1); 01871 } else { 01872 ResNode = CurDAG->getTargetNode(PPC::ANDC, MVT::i32, Tmp0, Tmp1); 01873 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01874 Result = SDOperand(ResNode, 0); 01875 } 01876 return; 01877 } 01878 } 01879 } 01880 01881 // Pattern: (and:v4i32 VRRC:v4i32:$vA, (xor:v4i32 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>, VRRC:v4i32:$vB)) 01882 // Emits: (VANDC:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 01883 // Pattern complexity = 7 cost = 1 01884 { 01885 N1 = N.getOperand(1); 01886 if (N1.getOpcode() == ISD::XOR) { 01887 N10 = N1.getOperand(0); 01888 if (N10.getOpcode() == ISD::BUILD_VECTOR && 01889 Predicate_immAllOnesV(N10.Val)) { 01890 N11 = N1.getOperand(1); 01891 if (N.Val->getValueType(0) == MVT::v4i32) { 01892 Select(Tmp0, N0); 01893 Select(Tmp1, N11); 01894 if (N.Val->hasOneUse()) { 01895 Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v4i32, Tmp0, Tmp1); 01896 } else { 01897 ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v4i32, Tmp0, Tmp1); 01898 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01899 Result = SDOperand(ResNode, 0); 01900 } 01901 return; 01902 } 01903 } 01904 } 01905 } 01906 if (N0.getOpcode() == ISD::XOR) { 01907 N00 = N0.getOperand(0); 01908 01909 // Pattern: (and:v4i32 (xor:v4i32 VRRC:v4i32:$vB, (build_vector:v4i32)<<P:Predicate_immAllOnesV>>), VRRC:v4i32:$vA) 01910 // Emits: (VANDC:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 01911 // Pattern complexity = 7 cost = 1 01912 { 01913 N01 = N0.getOperand(1); 01914 if (N01.getOpcode() == ISD::BUILD_VECTOR && 01915 Predicate_immAllOnesV(N01.Val)) { 01916 N1 = N.getOperand(1); 01917 if (N.Val->getValueType(0) == MVT::v4i32) { 01918 Select(Tmp0, N1); 01919 Select(Tmp1, N00); 01920 if (N.Val->hasOneUse()) { 01921 Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v4i32, Tmp0, Tmp1); 01922 } else { 01923 ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v4i32, Tmp0, Tmp1); 01924 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01925 Result = SDOperand(ResNode, 0); 01926 } 01927 return; 01928 } 01929 } 01930 } 01931 01932 // Pattern: (and:v4i32 (xor:v4i32 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>, VRRC:v4i32:$vB), VRRC:v4i32:$vA) 01933 // Emits: (VANDC:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 01934 // Pattern complexity = 7 cost = 1 01935 if (N00.getOpcode() == ISD::BUILD_VECTOR && 01936 Predicate_immAllOnesV(N00.Val)) { 01937 N01 = N0.getOperand(1); 01938 N1 = N.getOperand(1); 01939 if (N.Val->getValueType(0) == MVT::v4i32) { 01940 Select(Tmp0, N1); 01941 Select(Tmp1, N01); 01942 if (N.Val->hasOneUse()) { 01943 Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v4i32, Tmp0, Tmp1); 01944 } else { 01945 ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v4i32, Tmp0, Tmp1); 01946 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01947 Result = SDOperand(ResNode, 0); 01948 } 01949 return; 01950 } 01951 } 01952 } 01953 01954 // Pattern: (and:v16i8 VRRC:v16i8:$A, (xor:v16i8 (build_vector:v16i8)<<P:Predicate_immAllOnesV>>, VRRC:v16i8:$B)) 01955 // Emits: (VANDC:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B) 01956 // Pattern complexity = 7 cost = 1 01957 { 01958 N1 = N.getOperand(1); 01959 if (N1.getOpcode() == ISD::XOR) { 01960 N10 = N1.getOperand(0); 01961 if (N10.getOpcode() == ISD::BUILD_VECTOR && 01962 Predicate_immAllOnesV(N10.Val)) { 01963 N11 = N1.getOperand(1); 01964 if (N.Val->getValueType(0) == MVT::v16i8) { 01965 Select(Tmp0, N0); 01966 Select(Tmp1, N11); 01967 if (N.Val->hasOneUse()) { 01968 Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v16i8, Tmp0, Tmp1); 01969 } else { 01970 ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v16i8, Tmp0, Tmp1); 01971 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01972 Result = SDOperand(ResNode, 0); 01973 } 01974 return; 01975 } 01976 } 01977 } 01978 } 01979 if (N0.getOpcode() == ISD::XOR) { 01980 N00 = N0.getOperand(0); 01981 01982 // Pattern: (and:v16i8 (xor:v16i8 VRRC:v16i8:$B, (build_vector:v16i8)<<P:Predicate_immAllOnesV>>), VRRC:v16i8:$A) 01983 // Emits: (VANDC:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B) 01984 // Pattern complexity = 7 cost = 1 01985 { 01986 N01 = N0.getOperand(1); 01987 if (N01.getOpcode() == ISD::BUILD_VECTOR && 01988 Predicate_immAllOnesV(N01.Val)) { 01989 N1 = N.getOperand(1); 01990 if (N.Val->getValueType(0) == MVT::v16i8) { 01991 Select(Tmp0, N1); 01992 Select(Tmp1, N00); 01993 if (N.Val->hasOneUse()) { 01994 Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v16i8, Tmp0, Tmp1); 01995 } else { 01996 ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v16i8, Tmp0, Tmp1); 01997 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01998 Result = SDOperand(ResNode, 0); 01999 } 02000 return; 02001 } 02002 } 02003 } 02004 02005 // Pattern: (and:v16i8 (xor:v16i8 (build_vector:v16i8)<<P:Predicate_immAllOnesV>>, VRRC:v16i8:$B), VRRC:v16i8:$A) 02006 // Emits: (VANDC:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B) 02007 // Pattern complexity = 7 cost = 1 02008 if (N00.getOpcode() == ISD::BUILD_VECTOR && 02009 Predicate_immAllOnesV(N00.Val)) { 02010 N01 = N0.getOperand(1); 02011 N1 = N.getOperand(1); 02012 if (N.Val->getValueType(0) == MVT::v16i8) { 02013 Select(Tmp0, N1); 02014 Select(Tmp1, N01); 02015 if (N.Val->hasOneUse()) { 02016 Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v16i8, Tmp0, Tmp1); 02017 } else { 02018 ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v16i8, Tmp0, Tmp1); 02019 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02020 Result = SDOperand(ResNode, 0); 02021 } 02022 return; 02023 } 02024 } 02025 } 02026 02027 // Pattern: (and:v8i16 VRRC:v8i16:$A, (xor:v8i16 (build_vector:v8i16)<<P:Predicate_immAllOnesV>>, VRRC:v8i16:$B)) 02028 // Emits: (VANDC:v8i16 VRRC:v16i8:$A, VRRC:v16i8:$B) 02029 // Pattern complexity = 7 cost = 1 02030 { 02031 N1 = N.getOperand(1); 02032 if (N1.getOpcode() == ISD::XOR) { 02033 N10 = N1.getOperand(0); 02034 if (N10.getOpcode() == ISD::BUILD_VECTOR && 02035 Predicate_immAllOnesV(N10.Val)) { 02036 N11 = N1.getOperand(1); 02037 if (N.Val->getValueType(0) == MVT::v8i16) { 02038 Select(Tmp0, N0); 02039 Select(Tmp1, N11); 02040 if (N.Val->hasOneUse()) { 02041 Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v8i16, Tmp0, Tmp1); 02042 } else { 02043 ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v8i16, Tmp0, Tmp1); 02044 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02045 Result = SDOperand(ResNode, 0); 02046 } 02047 return; 02048 } 02049 } 02050 } 02051 } 02052 if (N0.getOpcode() == ISD::XOR) { 02053 N00 = N0.getOperand(0); 02054 02055 // Pattern: (and:v8i16 (xor:v8i16 VRRC:v8i16:$B, (build_vector:v8i16)<<P:Predicate_immAllOnesV>>), VRRC:v8i16:$A) 02056 // Emits: (VANDC:v8i16 VRRC:v16i8:$A, VRRC:v16i8:$B) 02057 // Pattern complexity = 7 cost = 1 02058 { 02059 N01 = N0.getOperand(1); 02060 if (N01.getOpcode() == ISD::BUILD_VECTOR && 02061 Predicate_immAllOnesV(N01.Val)) { 02062 N1 = N.getOperand(1); 02063 if (N.Val->getValueType(0) == MVT::v8i16) { 02064 Select(Tmp0, N1); 02065 Select(Tmp1, N00); 02066 if (N.Val->hasOneUse()) { 02067 Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v8i16, Tmp0, Tmp1); 02068 } else { 02069 ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v8i16, Tmp0, Tmp1); 02070 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02071 Result = SDOperand(ResNode, 0); 02072 } 02073 return; 02074 } 02075 } 02076 } 02077 02078 // Pattern: (and:v8i16 (xor:v8i16 (build_vector:v8i16)<<P:Predicate_immAllOnesV>>, VRRC:v8i16:$B), VRRC:v8i16:$A) 02079 // Emits: (VANDC:v8i16 VRRC:v16i8:$A, VRRC:v16i8:$B) 02080 // Pattern complexity = 7 cost = 1 02081 if (N00.getOpcode() == ISD::BUILD_VECTOR && 02082 Predicate_immAllOnesV(N00.Val)) { 02083 N01 = N0.getOperand(1); 02084 N1 = N.getOperand(1); 02085 if (N.Val->getValueType(0) == MVT::v8i16) { 02086 Select(Tmp0, N1); 02087 Select(Tmp1, N01); 02088 if (N.Val->hasOneUse()) { 02089 Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v8i16, Tmp0, Tmp1); 02090 } else { 02091 ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v8i16, Tmp0, Tmp1); 02092 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02093 Result = SDOperand(ResNode, 0); 02094 } 02095 return; 02096 } 02097 } 02098 } 02099 N1 = N.getOperand(1); 02100 if (N1.getOpcode() == ISD::Constant) { 02101 02102 // Pattern: (and:i32 GPRC:i32:$src1, (imm:i32)<<P:Predicate_immZExt16>><<X:LO16>>:$src2) 02103 // Emits: (ANDIo:i32 GPRC:i32:$src1, (LO16:i32 (imm:i32):$src2)) 02104 // Pattern complexity = 5 cost = 1 02105 if (Predicate_immZExt16(N1.Val) && 02106 N.Val->getValueType(0) == MVT::i32) { 02107 Select(Tmp0, N0); 02108 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 02109 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 02110 Tmp2 = Transform_LO16(Tmp1.Val); 02111 if (N.Val->hasOneUse()) { 02112 Result = CurDAG->SelectNodeTo(N.Val, PPC::ANDIo, MVT::i32, Tmp0, Tmp2); 02113 } else { 02114 ResNode = CurDAG->getTargetNode(PPC::ANDIo, MVT::i32, Tmp0, Tmp2); 02115 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02116 Result = SDOperand(ResNode, 0); 02117 } 02118 return; 02119 } 02120 02121 // Pattern: (and:i32 GPRC:i32:$src1, (imm:i32)<<P:Predicate_imm16Shifted>><<X:HI16>>:$src2) 02122 // Emits: (ANDISo:i32 GPRC:i32:$src1, (HI16:i32 (imm:i32):$src2)) 02123 // Pattern complexity = 5 cost = 1 02124 if (Predicate_imm16Shifted(N1.Val) && 02125 N.Val->getValueType(0) == MVT::i32) { 02126 Select(Tmp0, N0); 02127 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 02128 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 02129 Tmp2 = Transform_HI16(Tmp1.Val); 02130 if (N.Val->hasOneUse()) { 02131 Result = CurDAG->SelectNodeTo(N.Val, PPC::ANDISo, MVT::i32, Tmp0, Tmp2); 02132 } else { 02133 ResNode = CurDAG->getTargetNode(PPC::ANDISo, MVT::i32, Tmp0, Tmp2); 02134 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02135 Result = SDOperand(ResNode, 0); 02136 } 02137 return; 02138 } 02139 } 02140 02141 // Pattern: (and:i32 GPRC:i32:$rS, GPRC:i32:$rB) 02142 // Emits: (AND:i32 GPRC:i32:$rS, GPRC:i32:$rB) 02143 // Pattern complexity = 2 cost = 1 02144 if (N.Val->getValueType(0) == MVT::i32) { 02145 Select(Tmp0, N0); 02146 Select(Tmp1, N1); 02147 if (N.Val->hasOneUse()) { 02148 Result = CurDAG->SelectNodeTo(N.Val, PPC::AND, MVT::i32, Tmp0, Tmp1); 02149 } else { 02150 ResNode = CurDAG->getTargetNode(PPC::AND, MVT::i32, Tmp0, Tmp1); 02151 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02152 Result = SDOperand(ResNode, 0); 02153 } 02154 return; 02155 } 02156 02157 // Pattern: (and:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 02158 // Emits: (VAND:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 02159 // Pattern complexity = 2 cost = 1 02160 if (N.Val->getValueType(0) == MVT::v4i32) { 02161 Select(Tmp0, N0); 02162 Select(Tmp1, N1); 02163 if (N.Val->hasOneUse()) { 02164 Result = CurDAG->SelectNodeTo(N.Val, PPC::VAND, MVT::v4i32, Tmp0, Tmp1); 02165 } else { 02166 ResNode = CurDAG->getTargetNode(PPC::VAND, MVT::v4i32, Tmp0, Tmp1); 02167 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02168 Result = SDOperand(ResNode, 0); 02169 } 02170 return; 02171 } 02172 02173 // Pattern: (and:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B) 02174 // Emits: (VAND:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B) 02175 // Pattern complexity = 2 cost = 1 02176 if (N.Val->getValueType(0) == MVT::v16i8) { 02177 Select(Tmp0, N0); 02178 Select(Tmp1, N1); 02179 if (N.Val->hasOneUse()) { 02180 Result = CurDAG->SelectNodeTo(N.Val, PPC::VAND, MVT::v16i8, Tmp0, Tmp1); 02181 } else { 02182 ResNode = CurDAG->getTargetNode(PPC::VAND, MVT::v16i8, Tmp0, Tmp1); 02183 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02184 Result = SDOperand(ResNode, 0); 02185 } 02186 return; 02187 } 02188 02189 // Pattern: (and:v8i16 VRRC:v8i16:$A, VRRC:v8i16:$B) 02190 // Emits: (VAND:v8i16 VRRC:v16i8:$A, VRRC:v16i8:$B) 02191 // Pattern complexity = 2 cost = 1 02192 if (N.Val->getValueType(0) == MVT::v8i16) { 02193 Select(Tmp0, N0); 02194 Select(Tmp1, N1); 02195 if (N.Val->hasOneUse()) { 02196 Result = CurDAG->SelectNodeTo(N.Val, PPC::VAND, MVT::v8i16, Tmp0, Tmp1); 02197 } else { 02198 ResNode = CurDAG->getTargetNode(PPC::VAND, MVT::v8i16, Tmp0, Tmp1); 02199 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02200 Result = SDOperand(ResNode, 0); 02201 } 02202 return; 02203 } 02204 std::cerr << "Cannot yet select: "; 02205 N.Val->dump(CurDAG); 02206 std::cerr << '\n'; 02207 abort(); 02208 } 02209 02210 void Select_anyext(SDOperand &Result, SDOperand N) { 02211 SDOperand N0(0, 0); 02212 SDOperand Tmp0(0, 0); 02213 SDNode *ResNode; 02214 N0 = N.getOperand(0); 02215 if (N.Val->getValueType(0) == MVT::i64 && 02216 N0.Val->getValueType(0) == MVT::i32) { 02217 Select(Tmp0, N0); 02218 if (N.Val->hasOneUse()) { 02219 Result = CurDAG->SelectNodeTo(N.Val, PPC::OR4To8, MVT::i64, Tmp0, Tmp0); 02220 } else { 02221 ResNode = CurDAG->getTargetNode(PPC::OR4To8, MVT::i64, Tmp0, Tmp0); 02222 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02223 Result = SDOperand(ResNode, 0); 02224 } 02225 return; 02226 } 02227 std::cerr << "Cannot yet select: "; 02228 N.Val->dump(CurDAG); 02229 std::cerr << '\n'; 02230 abort(); 02231 } 02232 02233 void Select_bitconvert(SDOperand &Result, SDOperand N) { 02234 SDOperand N0(0, 0); 02235 SDOperand Tmp0(0, 0); 02236 N0 = N.getOperand(0); 02237 if (N.Val->getValueType(0) == MVT::v16i8) { 02238 02239 // Pattern: (bitconvert:v16i8 VRRC:v8i16:$src) 02240 // Emits: VRRC:v16i8:$src 02241 // Pattern complexity = 2 cost = 0 02242 if (N0.Val->getValueType(0) == MVT::v8i16) { 02243 Select(Tmp0, N0); 02244 Result = Tmp0; 02245 return; 02246 } 02247 02248 // Pattern: (bitconvert:v16i8 VRRC:v4i32:$src) 02249 // Emits: VRRC:v16i8:$src 02250 // Pattern complexity = 2 cost = 0 02251 if (N0.Val->getValueType(0) == MVT::v4i32) { 02252 Select(Tmp0, N0); 02253 Result = Tmp0; 02254 return; 02255 } 02256 02257 // Pattern: (bitconvert:v16i8 VRRC:v4f32:$src) 02258 // Emits: VRRC:v16i8:$src 02259 // Pattern complexity = 2 cost = 0 02260 if (N0.Val->getValueType(0) == MVT::v4f32) { 02261 Select(Tmp0, N0); 02262 Result = Tmp0; 02263 return; 02264 } 02265 } 02266 if (N.Val->getValueType(0) == MVT::v8i16) { 02267 02268 // Pattern: (bitconvert:v8i16 VRRC:v16i8:$src) 02269 // Emits: VRRC:v8i16:$src 02270 // Pattern complexity = 2 cost = 0 02271 if (N0.Val->getValueType(0) == MVT::v16i8) { 02272 Select(Tmp0, N0); 02273 Result = Tmp0; 02274 return; 02275 } 02276 02277 // Pattern: (bitconvert:v8i16 VRRC:v4i32:$src) 02278 // Emits: VRRC:v8i16:$src 02279 // Pattern complexity = 2 cost = 0 02280 if (N0.Val->getValueType(0) == MVT::v4i32) { 02281 Select(Tmp0, N0); 02282 Result = Tmp0; 02283 return; 02284 } 02285 02286 // Pattern: (bitconvert:v8i16 VRRC:v4f32:$src) 02287 // Emits: VRRC:v8i16:$src 02288 // Pattern complexity = 2 cost = 0 02289 if (N0.Val->getValueType(0) == MVT::v4f32) { 02290 Select(Tmp0, N0); 02291 Result = Tmp0; 02292 return; 02293 } 02294 } 02295 if (N.Val->getValueType(0) == MVT::v4i32) { 02296 02297 // Pattern: (bitconvert:v4i32 VRRC:v16i8:$src) 02298 // Emits: VRRC:v4i32:$src 02299 // Pattern complexity = 2 cost = 0 02300 if (N0.Val->getValueType(0) == MVT::v16i8) { 02301 Select(Tmp0, N0); 02302 Result = Tmp0; 02303 return; 02304 } 02305 02306 // Pattern: (bitconvert:v4i32 VRRC:v8i16:$src) 02307 // Emits: VRRC:v4i32:$src 02308 // Pattern complexity = 2 cost = 0 02309 if (N0.Val->getValueType(0) == MVT::v8i16) { 02310 Select(Tmp0, N0); 02311 Result = Tmp0; 02312 return; 02313 } 02314 02315 // Pattern: (bitconvert:v4i32 VRRC:v4f32:$src) 02316 // Emits: VRRC:v4i32:$src 02317 // Pattern complexity = 2 cost = 0 02318 if (N0.Val->getValueType(0) == MVT::v4f32) { 02319 Select(Tmp0, N0); 02320 Result = Tmp0; 02321 return; 02322 } 02323 } 02324 if (N.Val->getValueType(0) == MVT::v4f32) { 02325 02326 // Pattern: (bitconvert:v4f32 VRRC:v16i8:$src) 02327 // Emits: VRRC:v4f32:$src 02328 // Pattern complexity = 2 cost = 0 02329 if (N0.Val->getValueType(0) == MVT::v16i8) { 02330 Select(Tmp0, N0); 02331 Result = Tmp0; 02332 return; 02333 } 02334 02335 // Pattern: (bitconvert:v4f32 VRRC:v8i16:$src) 02336 // Emits: VRRC:v4f32:$src 02337 // Pattern complexity = 2 cost = 0 02338 if (N0.Val->getValueType(0) == MVT::v8i16) { 02339 Select(Tmp0, N0); 02340 Result = Tmp0; 02341 return; 02342 } 02343 02344 // Pattern: (bitconvert:v4f32 VRRC:v4i32:$src) 02345 // Emits: VRRC:v4f32:$src 02346 // Pattern complexity = 2 cost = 0 02347 if (N0.Val->getValueType(0) == MVT::v4i32) { 02348 Select(Tmp0, N0); 02349 Result = Tmp0; 02350 return; 02351 } 02352 } 02353 std::cerr << "Cannot yet select: "; 02354 N.Val->dump(CurDAG); 02355 std::cerr << '\n'; 02356 abort(); 02357 } 02358 02359 void Select_br(SDOperand &Result, SDOperand N) { 02360 SDOperand Chain(0, 0); 02361 SDOperand N1(0, 0); 02362 SDOperand Tmp0(0, 0); 02363 SDNode *ResNode; 02364 Chain = N.getOperand(0); 02365 N1 = N.getOperand(1); 02366 if (N1.getOpcode() == ISD::BasicBlock) { 02367 Select(Tmp0, N1); 02368 Select(Chain, Chain); 02369 ResNode = CurDAG->getTargetNode(PPC::B, MVT::Other, Tmp0, Chain); 02370 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02371 Result = SDOperand(ResNode, N.ResNo); 02372 return; 02373 } 02374 std::cerr << "Cannot yet select: "; 02375 N.Val->dump(CurDAG); 02376 std::cerr << '\n'; 02377 abort(); 02378 } 02379 02380 void Select_build_vector(SDOperand &Result, SDOperand N) { 02381 SDOperand Tmp0(0, 0); 02382 SDOperand Tmp1(0, 0); 02383 SDNode *ResNode; 02384 02385 // Pattern: (build_vector:v16i8)<<P:Predicate_vecspltisb>><<X:VSPLTISB_get_imm>>:$SIMM 02386 // Emits: (VSPLTISB:v16i8 (VSPLTISB_get_imm:i32 (build_vector:v16i8):$SIMM)) 02387 // Pattern complexity = 3 cost = 1 02388 if (Predicate_vecspltisb(N.Val) && 02389 N.Val->getValueType(0) == MVT::v16i8) { 02390 Tmp0 = N; 02391 Tmp1 = Transform_VSPLTISB_get_imm(Tmp0.Val); 02392 if (N.Val->hasOneUse()) { 02393 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSPLTISB, MVT::v16i8, Tmp1); 02394 } else { 02395 ResNode = CurDAG->getTargetNode(PPC::VSPLTISB, MVT::v16i8, Tmp1); 02396 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02397 Result = SDOperand(ResNode, 0); 02398 } 02399 return; 02400 } 02401 02402 // Pattern: (build_vector:v8i16)<<P:Predicate_vecspltish>><<X:VSPLTISH_get_imm>>:$SIMM 02403 // Emits: (VSPLTISH:v8i16 (VSPLTISH_get_imm:i32 (build_vector:v8i16):$SIMM)) 02404 // Pattern complexity = 3 cost = 1 02405 if (Predicate_vecspltish(N.Val) && 02406 N.Val->getValueType(0) == MVT::v8i16) { 02407 Tmp0 = N; 02408 Tmp1 = Transform_VSPLTISH_get_imm(Tmp0.Val); 02409 if (N.Val->hasOneUse()) { 02410 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSPLTISH, MVT::v8i16, Tmp1); 02411 } else { 02412 ResNode = CurDAG->getTargetNode(PPC::VSPLTISH, MVT::v8i16, Tmp1); 02413 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02414 Result = SDOperand(ResNode, 0); 02415 } 02416 return; 02417 } 02418 02419 // Pattern: (build_vector:v4i32)<<P:Predicate_vecspltisw>><<X:VSPLTISW_get_imm>>:$SIMM 02420 // Emits: (VSPLTISW:v4i32 (VSPLTISW_get_imm:i32 (build_vector:v4i32):$SIMM)) 02421 // Pattern complexity = 3 cost = 1 02422 if (Predicate_vecspltisw(N.Val) && 02423 N.Val->getValueType(0) == MVT::v4i32) { 02424 Tmp0 = N; 02425 Tmp1 = Transform_VSPLTISW_get_imm(Tmp0.Val); 02426 if (N.Val->hasOneUse()) { 02427 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSPLTISW, MVT::v4i32, Tmp1); 02428 } else { 02429 ResNode = CurDAG->getTargetNode(PPC::VSPLTISW, MVT::v4i32, Tmp1); 02430 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02431 Result = SDOperand(ResNode, 0); 02432 } 02433 return; 02434 } 02435 02436 // Pattern: (build_vector:v4i32)<<P:Predicate_immAllZerosV>> 02437 // Emits: (V_SET0:v4i32) 02438 // Pattern complexity = 3 cost = 1 02439 if (Predicate_immAllZerosV(N.Val) && 02440 N.Val->getValueType(0) == MVT::v4i32) { 02441 if (N.Val->hasOneUse()) { 02442 Result = CurDAG->SelectNodeTo(N.Val, PPC::V_SET0, MVT::v4i32); 02443 } else { 02444 ResNode = CurDAG->getTargetNode(PPC::V_SET0, MVT::v4i32); 02445 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02446 Result = SDOperand(ResNode, 0); 02447 } 02448 return; 02449 } 02450 std::cerr << "Cannot yet select: "; 02451 N.Val->dump(CurDAG); 02452 std::cerr << '\n'; 02453 abort(); 02454 } 02455 02456 void Select_callseq_end(SDOperand &Result, SDOperand N) { 02457 SDOperand Chain(0, 0); 02458 SDOperand N1(0, 0); 02459 SDOperand Tmp0(0, 0); 02460 SDNode *ResNode; 02461 Chain = N.getOperand(0); 02462 N1 = N.getOperand(1); 02463 if (N1.getOpcode() == ISD::Constant) { 02464 unsigned Tmp0C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 02465 Tmp0 = CurDAG->getTargetConstant(Tmp0C, MVT::i32); 02466 Select(Chain, Chain); 02467 ResNode = CurDAG->getTargetNode(PPC::ADJCALLSTACKUP, MVT::Other, Tmp0, Chain); 02468 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02469 Result = SDOperand(ResNode, N.ResNo); 02470 return; 02471 } 02472 std::cerr << "Cannot yet select: "; 02473 N.Val->dump(CurDAG); 02474 std::cerr << '\n'; 02475 abort(); 02476 } 02477 02478 void Select_callseq_start(SDOperand &Result, SDOperand N) { 02479 SDOperand Chain(0, 0); 02480 SDOperand N1(0, 0); 02481 SDOperand Tmp0(0, 0); 02482 SDNode *ResNode; 02483 Chain = N.getOperand(0); 02484 N1 = N.getOperand(1); 02485 if (N1.getOpcode() == ISD::Constant) { 02486 unsigned Tmp0C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 02487 Tmp0 = CurDAG->getTargetConstant(Tmp0C, MVT::i32); 02488 Select(Chain, Chain); 02489 ResNode = CurDAG->getTargetNode(PPC::ADJCALLSTACKDOWN, MVT::Other, Tmp0, Chain); 02490 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02491 Result = SDOperand(ResNode, N.ResNo); 02492 return; 02493 } 02494 std::cerr << "Cannot yet select: "; 02495 N.Val->dump(CurDAG); 02496 std::cerr << '\n'; 02497 abort(); 02498 } 02499 02500 void Select_ctlz(SDOperand &Result, SDOperand N) { 02501 SDOperand N0(0, 0); 02502 SDOperand Tmp0(0, 0); 02503 SDNode *ResNode; 02504 N0 = N.getOperand(0); 02505 if (N.Val->getValueType(0) == MVT::i32) { 02506 Select(Tmp0, N0); 02507 if (N.Val->hasOneUse()) { 02508 Result = CurDAG->SelectNodeTo(N.Val, PPC::CNTLZW, MVT::i32, Tmp0); 02509 } else { 02510 ResNode = CurDAG->getTargetNode(PPC::CNTLZW, MVT::i32, Tmp0); 02511 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02512 Result = SDOperand(ResNode, 0); 02513 } 02514 return; 02515 } 02516 std::cerr << "Cannot yet select: "; 02517 N.Val->dump(CurDAG); 02518 std::cerr << '\n'; 02519 abort(); 02520 } 02521 02522 void Select_dwarf_label(SDOperand &Result, SDOperand N) { 02523 SDOperand Chain(0, 0); 02524 SDOperand N1(0, 0); 02525 SDOperand Tmp0(0, 0); 02526 SDNode *ResNode; 02527 Chain = N.getOperand(0); 02528 N1 = N.getOperand(1); 02529 if (N1.getOpcode() == ISD::Constant && 02530 N1.Val->getValueType(0) == MVT::i32) { 02531 unsigned Tmp0C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 02532 Tmp0 = CurDAG->getTargetConstant(Tmp0C, MVT::i32); 02533 Select(Chain, Chain); 02534 ResNode = CurDAG->getTargetNode(PPC::DWARF_LABEL, MVT::Other, Tmp0, Chain); 02535 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02536 Result = SDOperand(ResNode, N.ResNo); 02537 return; 02538 } 02539 std::cerr << "Cannot yet select: "; 02540 N.Val->dump(CurDAG); 02541 std::cerr << '\n'; 02542 abort(); 02543 } 02544 02545 void Select_dwarf_loc(SDOperand &Result, SDOperand N) { 02546 SDOperand Chain(0, 0); 02547 SDOperand N1(0, 0); 02548 SDOperand N2(0, 0); 02549 SDOperand N3(0, 0); 02550 SDOperand Tmp0(0, 0); 02551 SDOperand Tmp1(0, 0); 02552 SDOperand Tmp2(0, 0); 02553 SDNode *ResNode; 02554 Chain = N.getOperand(0); 02555 N1 = N.getOperand(1); 02556 if (N1.getOpcode() == ISD::Constant) { 02557 N2 = N.getOperand(2); 02558 if (N2.getOpcode() == ISD::Constant) { 02559 N3 = N.getOperand(3); 02560 if (N3.getOpcode() == ISD::Constant && 02561 N1.Val->getValueType(0) == MVT::i32 && 02562 N2.Val->getValueType(0) == MVT::i32 && 02563 N3.Val->getValueType(0) == MVT::i32) { 02564 unsigned Tmp0C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 02565 Tmp0 = CurDAG->getTargetConstant(Tmp0C, MVT::i32); 02566 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N2)->getValue(); 02567 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 02568 unsigned Tmp2C = (unsigned)cast<ConstantSDNode>(N3)->getValue(); 02569 Tmp2 = CurDAG->getTargetConstant(Tmp2C, MVT::i32); 02570 Select(Chain, Chain); 02571 ResNode = CurDAG->getTargetNode(PPC::DWARF_LOC, MVT::Other, Tmp0, Tmp1, Tmp2, Chain); 02572 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02573 Result = SDOperand(ResNode, N.ResNo); 02574 return; 02575 } 02576 } 02577 } 02578 std::cerr << "Cannot yet select: "; 02579 N.Val->dump(CurDAG); 02580 std::cerr << '\n'; 02581 abort(); 02582 } 02583 02584 void Select_extld(SDOperand &Result, SDOperand N) { 02585 if (N.ResNo == 1 && N.getValue(0).hasOneUse()) { 02586 SDOperand Dummy = CurDAG->getNode(ISD::HANDLENODE, MVT::Other, N); 02587 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Dummy.Val, 0); 02588 SelectionDAG::InsertISelMapEntry(HandleMap, N.Val, 1, Dummy.Val, 0); 02589 Result = Dummy; 02590 return; 02591 } 02592 SDOperand Chain(0, 0); 02593 SDOperand N1(0, 0); 02594 SDOperand N2(0, 0); 02595 SDOperand N3(0, 0); 02596 SDOperand Tmp0(0, 0); 02597 SDOperand Tmp1(0, 0); 02598 SDOperand Tmp2(0, 0); 02599 SDNode *ResNode; 02600 Chain = N.getOperand(0); 02601 N1 = N.getOperand(1); 02602 N2 = N.getOperand(2); 02603 N3 = N.getOperand(3); 02604 if (cast<VTSDNode>(N3)->getVT() == MVT::i1 && 02605 N.Val->getValueType(0) == MVT::i32) { 02606 02607 // Pattern: (extld:i32 iaddr:i32:$src, srcvalue:Other:$dummy, i1:Other) 02608 // Emits: (LBZ:i32 iaddr:i32:$src) 02609 // Pattern complexity = 8 cost = 1 02610 if (SelectAddrImm(N1, Tmp0, Tmp1)) { 02611 Select(Tmp0, Tmp0); 02612 Select(Tmp1, Tmp1); 02613 Select(Chain, Chain); 02614 ResNode = CurDAG->getTargetNode(PPC::LBZ, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain); 02615 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02616 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 02617 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 02618 Result = SDOperand(ResNode, N.ResNo); 02619 return; 02620 } 02621 02622 // Pattern: (extld:i32 xaddr:i32:$src, srcvalue:Other:$dummy, i1:Other) 02623 // Emits: (LBZX:i32 xaddr:i32:$src) 02624 // Pattern complexity = 8 cost = 1 02625 if (SelectAddrIdx(N1, Tmp0, Tmp1)) { 02626 Select(Tmp0, Tmp0); 02627 Select(Tmp1, Tmp1); 02628 Select(Chain, Chain); 02629 ResNode = CurDAG->getTargetNode(PPC::LBZX, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain); 02630 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02631 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 02632 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 02633 Result = SDOperand(ResNode, N.ResNo); 02634 return; 02635 } 02636 } 02637 if (cast<VTSDNode>(N3)->getVT() == MVT::i8 && 02638 N.Val->getValueType(0) == MVT::i32) { 02639 02640 // Pattern: (extld:i32 iaddr:i32:$src, srcvalue:Other:$dummy, i8:Other) 02641 // Emits: (LBZ:i32 iaddr:i32:$src) 02642 // Pattern complexity = 8 cost = 1 02643 if (SelectAddrImm(N1, Tmp0, Tmp1)) { 02644 Select(Tmp0, Tmp0); 02645 Select(Tmp1, Tmp1); 02646 Select(Chain, Chain); 02647 ResNode = CurDAG->getTargetNode(PPC::LBZ, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain); 02648 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02649 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 02650 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 02651 Result = SDOperand(ResNode, N.ResNo); 02652 return; 02653 } 02654 02655 // Pattern: (extld:i32 xaddr:i32:$src, srcvalue:Other:$dummy, i8:Other) 02656 // Emits: (LBZX:i32 xaddr:i32:$src) 02657 // Pattern complexity = 8 cost = 1 02658 if (SelectAddrIdx(N1, Tmp0, Tmp1)) { 02659 Select(Tmp0, Tmp0); 02660 Select(Tmp1, Tmp1); 02661 Select(Chain, Chain); 02662 ResNode = CurDAG->getTargetNode(PPC::LBZX, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain); 02663 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02664 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 02665 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 02666 Result = SDOperand(ResNode, N.ResNo); 02667 return; 02668 } 02669 } 02670 if (cast<VTSDNode>(N3)->getVT() == MVT::i16 && 02671 N.Val->getValueType(0) == MVT::i32) { 02672 02673 // Pattern: (extld:i32 iaddr:i32:$src, srcvalue:Other:$dummy, i16:Other) 02674 // Emits: (LHZ:i32 iaddr:i32:$src) 02675 // Pattern complexity = 8 cost = 1 02676 if (SelectAddrImm(N1, Tmp0, Tmp1)) { 02677 Select(Tmp0, Tmp0); 02678 Select(Tmp1, Tmp1); 02679 Select(Chain, Chain); 02680 ResNode = CurDAG->getTargetNode(PPC::LHZ, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain); 02681 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02682 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 02683 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 02684 Result = SDOperand(ResNode, N.ResNo); 02685 return; 02686 } 02687 02688 // Pattern: (extld:i32 xaddr:i32:$src, srcvalue:Other:$dummy, i16:Other) 02689 // Emits: (LHZX:i32 xaddr:i32:$src) 02690 // Pattern complexity = 8 cost = 1 02691 if (SelectAddrIdx(N1, Tmp0, Tmp1)) { 02692 Select(Tmp0, Tmp0); 02693 Select(Tmp1, Tmp1); 02694 Select(Chain, Chain); 02695 ResNode = CurDAG->getTargetNode(PPC::LHZX, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain); 02696 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02697 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 02698 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 02699 Result = SDOperand(ResNode, N.ResNo); 02700 return; 02701 } 02702 } 02703 if (cast<VTSDNode>(N3)->getVT() == MVT::f32 && 02704 N.Val->getValueType(0) == MVT::f64) { 02705 02706 // Pattern: (extld:f64 iaddr:i32:$src, srcvalue:Other:$dummy, f32:Other) 02707 // Emits: (FMRSD:f64 (LFS:f32 iaddr:i32:$src)) 02708 // Pattern complexity = 8 cost = 2 02709 if (SelectAddrImm(N1, Tmp0, Tmp1)) { 02710 Select(Tmp0, Tmp0); 02711 Select(Tmp1, Tmp1); 02712 Tmp2 = SDOperand(CurDAG->getTargetNode(PPC::LFS, MVT::f32, Tmp0, Tmp1), 0); 02713 Select(Chain, Chain); 02714 ResNode = CurDAG->getTargetNode(PPC::FMRSD, MVT::f64, MVT::Other, Tmp2, Chain); 02715 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02716 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 02717 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 02718 Result = SDOperand(ResNode, N.ResNo); 02719 return; 02720 } 02721 02722 // Pattern: (extld:f64 xaddr:i32:$src, srcvalue:Other:$dummy, f32:Other) 02723 // Emits: (FMRSD:f64 (LFSX:f32 xaddr:i32:$src)) 02724 // Pattern complexity = 8 cost = 2 02725 if (SelectAddrIdx(N1, Tmp0, Tmp1)) { 02726 Select(Tmp0, Tmp0); 02727 Select(Tmp1, Tmp1); 02728 Tmp2 = SDOperand(CurDAG->getTargetNode(PPC::LFSX, MVT::f32, Tmp0, Tmp1), 0); 02729 Select(Chain, Chain); 02730 ResNode = CurDAG->getTargetNode(PPC::FMRSD, MVT::f64, MVT::Other, Tmp2, Chain); 02731 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02732 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 02733 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 02734 Result = SDOperand(ResNode, N.ResNo); 02735 return; 02736 } 02737 } 02738 std::cerr << "Cannot yet select: "; 02739 N.Val->dump(CurDAG); 02740 std::cerr << '\n'; 02741 abort(); 02742 } 02743 02744 void Select_fabs(SDOperand &Result, SDOperand N) { 02745 SDOperand N0(0, 0); 02746 SDOperand Tmp0(0, 0); 02747 SDNode *ResNode; 02748 N0 = N.getOperand(0); 02749 02750 // Pattern: (fabs:f32 F4RC:f32:$frB) 02751 // Emits: (FABSS:f32 F4RC:f32:$frB) 02752 // Pattern complexity = 2 cost = 1 02753 if (N.Val->getValueType(0) == MVT::f32) { 02754 Select(Tmp0, N0); 02755 if (N.Val->hasOneUse()) { 02756 Result = CurDAG->SelectNodeTo(N.Val, PPC::FABSS, MVT::f32, Tmp0); 02757 } else { 02758 ResNode = CurDAG->getTargetNode(PPC::FABSS, MVT::f32, Tmp0); 02759 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02760 Result = SDOperand(ResNode, 0); 02761 } 02762 return; 02763 } 02764 02765 // Pattern: (fabs:f64 F8RC:f64:$frB) 02766 // Emits: (FABSD:f64 F8RC:f64:$frB) 02767 // Pattern complexity = 2 cost = 1 02768 if (N.Val->getValueType(0) == MVT::f64) { 02769 Select(Tmp0, N0); 02770 if (N.Val->hasOneUse()) { 02771 Result = CurDAG->SelectNodeTo(N.Val, PPC::FABSD, MVT::f64, Tmp0); 02772 } else { 02773 ResNode = CurDAG->getTargetNode(PPC::FABSD, MVT::f64, Tmp0); 02774 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02775 Result = SDOperand(ResNode, 0); 02776 } 02777 return; 02778 } 02779 std::cerr << "Cannot yet select: "; 02780 N.Val->dump(CurDAG); 02781 std::cerr << '\n'; 02782 abort(); 02783 } 02784 02785 void Select_fadd(SDOperand &Result, SDOperand N) { 02786 SDOperand N0(0, 0); 02787 SDOperand N00(0, 0); 02788 SDOperand N01(0, 0); 02789 SDOperand N1(0, 0); 02790 SDOperand N10(0, 0); 02791 SDOperand N11(0, 0); 02792 SDOperand Tmp0(0, 0); 02793 SDOperand Tmp1(0, 0); 02794 SDOperand Tmp2(0, 0); 02795 SDNode *ResNode; 02796 if ((!NoExcessFPPrecision)) { 02797 N0 = N.getOperand(0); 02798 if (N0.getOpcode() == ISD::FMUL) { 02799 N00 = N0.getOperand(0); 02800 N01 = N0.getOperand(1); 02801 N1 = N.getOperand(1); 02802 02803 // Pattern: (fadd:f64 (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRC), F8RC:f64:$FRB) 02804 // Emits: (FMADD:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB) 02805 // Pattern complexity = 4 cost = 1 02806 if (N.Val->getValueType(0) == MVT::f64) { 02807 Select(Tmp0, N00); 02808 Select(Tmp1, N01); 02809 Select(Tmp2, N1); 02810 if (N.Val->hasOneUse()) { 02811 Result = CurDAG->SelectNodeTo(N.Val, PPC::FMADD, MVT::f64, Tmp0, Tmp1, Tmp2); 02812 } else { 02813 ResNode = CurDAG->getTargetNode(PPC::FMADD, MVT::f64, Tmp0, Tmp1, Tmp2); 02814 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02815 Result = SDOperand(ResNode, 0); 02816 } 02817 return; 02818 } 02819 02820 // Pattern: (fadd:f32 (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRC), F4RC:f32:$FRB) 02821 // Emits: (FMADDS:f32 F4RC:f32:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB) 02822 // Pattern complexity = 4 cost = 1 02823 if (N.Val->getValueType(0) == MVT::f32) { 02824 Select(Tmp0, N00); 02825 Select(Tmp1, N01); 02826 Select(Tmp2, N1); 02827 if (N.Val->hasOneUse()) { 02828 Result = CurDAG->SelectNodeTo(N.Val, PPC::FMADDS, MVT::f32, Tmp0, Tmp1, Tmp2); 02829 } else { 02830 ResNode = CurDAG->getTargetNode(PPC::FMADDS, MVT::f32, Tmp0, Tmp1, Tmp2); 02831 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02832 Result = SDOperand(ResNode, 0); 02833 } 02834 return; 02835 } 02836 02837 // Pattern: (fadd:v4f32 (fmul:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vC), VRRC:v4f32:$vB) 02838 // Emits: (VMADDFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vC, VRRC:v4f32:$vB) 02839 // Pattern complexity = 4 cost = 1 02840 if (N.Val->getValueType(0) == MVT::v4f32) { 02841 Select(Tmp0, N00); 02842 Select(Tmp1, N01); 02843 Select(Tmp2, N1); 02844 if (N.Val->hasOneUse()) { 02845 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMADDFP, MVT::v4f32, Tmp0, Tmp1, Tmp2); 02846 } else { 02847 ResNode = CurDAG->getTargetNode(PPC::VMADDFP, MVT::v4f32, Tmp0, Tmp1, Tmp2); 02848 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02849 Result = SDOperand(ResNode, 0); 02850 } 02851 return; 02852 } 02853 } 02854 N1 = N.getOperand(1); 02855 if (N1.getOpcode() == ISD::FMUL) { 02856 N10 = N1.getOperand(0); 02857 N11 = N1.getOperand(1); 02858 02859 // Pattern: (fadd:f64 F8RC:f64:$FRB, (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRC)) 02860 // Emits: (FMADD:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB) 02861 // Pattern complexity = 4 cost = 1 02862 if (N.Val->getValueType(0) == MVT::f64) { 02863 Select(Tmp0, N10); 02864 Select(Tmp1, N11); 02865 Select(Tmp2, N0); 02866 if (N.Val->hasOneUse()) { 02867 Result = CurDAG->SelectNodeTo(N.Val, PPC::FMADD, MVT::f64, Tmp0, Tmp1, Tmp2); 02868 } else { 02869 ResNode = CurDAG->getTargetNode(PPC::FMADD, MVT::f64, Tmp0, Tmp1, Tmp2); 02870 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02871 Result = SDOperand(ResNode, 0); 02872 } 02873 return; 02874 } 02875 02876 // Pattern: (fadd:f32 F4RC:f32:$FRB, (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRC)) 02877 // Emits: (FMADDS:f32 F4RC:f32:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB) 02878 // Pattern complexity = 4 cost = 1 02879 if (N.Val->getValueType(0) == MVT::f32) { 02880 Select(Tmp0, N10); 02881 Select(Tmp1, N11); 02882 Select(Tmp2, N0); 02883 if (N.Val->hasOneUse()) { 02884 Result = CurDAG->SelectNodeTo(N.Val, PPC::FMADDS, MVT::f32, Tmp0, Tmp1, Tmp2); 02885 } else { 02886 ResNode = CurDAG->getTargetNode(PPC::FMADDS, MVT::f32, Tmp0, Tmp1, Tmp2); 02887 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02888 Result = SDOperand(ResNode, 0); 02889 } 02890 return; 02891 } 02892 02893 // Pattern: (fadd:v4f32 VRRC:v4f32:$vB, (fmul:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vC)) 02894 // Emits: (VMADDFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vC, VRRC:v4f32:$vB) 02895 // Pattern complexity = 4 cost = 1 02896 if (N.Val->getValueType(0) == MVT::v4f32) { 02897 Select(Tmp0, N10); 02898 Select(Tmp1, N11); 02899 Select(Tmp2, N0); 02900 if (N.Val->hasOneUse()) { 02901 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMADDFP, MVT::v4f32, Tmp0, Tmp1, Tmp2); 02902 } else { 02903 ResNode = CurDAG->getTargetNode(PPC::VMADDFP, MVT::v4f32, Tmp0, Tmp1, Tmp2); 02904 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02905 Result = SDOperand(ResNode, 0); 02906 } 02907 return; 02908 } 02909 } 02910 } 02911 N0 = N.getOperand(0); 02912 N1 = N.getOperand(1); 02913 02914 // Pattern: (fadd:f64 F8RC:f64:$FRA, F8RC:f64:$FRB) 02915 // Emits: (FADD:f64 F8RC:f64:$FRA, F8RC:f64:$FRB) 02916 // Pattern complexity = 2 cost = 1 02917 if (N.Val->getValueType(0) == MVT::f64) { 02918 Select(Tmp0, N0); 02919 Select(Tmp1, N1); 02920 if (N.Val->hasOneUse()) { 02921 Result = CurDAG->SelectNodeTo(N.Val, PPC::FADD, MVT::f64, Tmp0, Tmp1); 02922 } else { 02923 ResNode = CurDAG->getTargetNode(PPC::FADD, MVT::f64, Tmp0, Tmp1); 02924 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02925 Result = SDOperand(ResNode, 0); 02926 } 02927 return; 02928 } 02929 02930 // Pattern: (fadd:f32 F4RC:f32:$FRA, F4RC:f32:$FRB) 02931 // Emits: (FADDS:f32 F4RC:f32:$FRA, F4RC:f32:$FRB) 02932 // Pattern complexity = 2 cost = 1 02933 if (N.Val->getValueType(0) == MVT::f32) { 02934 Select(Tmp0, N0); 02935 Select(Tmp1, N1); 02936 if (N.Val->hasOneUse()) { 02937 Result = CurDAG->SelectNodeTo(N.Val, PPC::FADDS, MVT::f32, Tmp0, Tmp1); 02938 } else { 02939 ResNode = CurDAG->getTargetNode(PPC::FADDS, MVT::f32, Tmp0, Tmp1); 02940 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02941 Result = SDOperand(ResNode, 0); 02942 } 02943 return; 02944 } 02945 02946 // Pattern: (fadd:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 02947 // Emits: (VADDFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 02948 // Pattern complexity = 2 cost = 1 02949 if (N.Val->getValueType(0) == MVT::v4f32) { 02950 Select(Tmp0, N0); 02951 Select(Tmp1, N1); 02952 if (N.Val->hasOneUse()) { 02953 Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDFP, MVT::v4f32, Tmp0, Tmp1); 02954 } else { 02955 ResNode = CurDAG->getTargetNode(PPC::VADDFP, MVT::v4f32, Tmp0, Tmp1); 02956 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02957 Result = SDOperand(ResNode, 0); 02958 } 02959 return; 02960 } 02961 std::cerr << "Cannot yet select: "; 02962 N.Val->dump(CurDAG); 02963 std::cerr << '\n'; 02964 abort(); 02965 } 02966 02967 void Select_fdiv(SDOperand &Result, SDOperand N) { 02968 SDOperand N0(0, 0); 02969 SDOperand N1(0, 0); 02970 SDOperand Tmp0(0, 0); 02971 SDOperand Tmp1(0, 0); 02972 SDNode *ResNode; 02973 N0 = N.getOperand(0); 02974 N1 = N.getOperand(1); 02975 02976 // Pattern: (fdiv:f64 F8RC:f64:$FRA, F8RC:f64:$FRB) 02977 // Emits: (FDIV:f64 F8RC:f64:$FRA, F8RC:f64:$FRB) 02978 // Pattern complexity = 2 cost = 1 02979 if (N.Val->getValueType(0) == MVT::f64) { 02980 Select(Tmp0, N0); 02981 Select(Tmp1, N1); 02982 if (N.Val->hasOneUse()) { 02983 Result = CurDAG->SelectNodeTo(N.Val, PPC::FDIV, MVT::f64, Tmp0, Tmp1); 02984 } else { 02985 ResNode = CurDAG->getTargetNode(PPC::FDIV, MVT::f64, Tmp0, Tmp1); 02986 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02987 Result = SDOperand(ResNode, 0); 02988 } 02989 return; 02990 } 02991 02992 // Pattern: (fdiv:f32 F4RC:f32:$FRA, F4RC:f32:$FRB) 02993 // Emits: (FDIVS:f32 F4RC:f32:$FRA, F4RC:f32:$FRB) 02994 // Pattern complexity = 2 cost = 1 02995 if (N.Val->getValueType(0) == MVT::f32) { 02996 Select(Tmp0, N0); 02997 Select(Tmp1, N1); 02998 if (N.Val->hasOneUse()) { 02999 Result = CurDAG->SelectNodeTo(N.Val, PPC::FDIVS, MVT::f32, Tmp0, Tmp1); 03000 } else { 03001 ResNode = CurDAG->getTargetNode(PPC::FDIVS, MVT::f32, Tmp0, Tmp1); 03002 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03003 Result = SDOperand(ResNode, 0); 03004 } 03005 return; 03006 } 03007 std::cerr << "Cannot yet select: "; 03008 N.Val->dump(CurDAG); 03009 std::cerr << '\n'; 03010 abort(); 03011 } 03012 03013 void Select_fextend(SDOperand &Result, SDOperand N) { 03014 SDOperand N0(0, 0); 03015 SDOperand Tmp0(0, 0); 03016 SDNode *ResNode; 03017 N0 = N.getOperand(0); 03018 if (N.Val->getValueType(0) == MVT::f64 && 03019 N0.Val->getValueType(0) == MVT::f32) { 03020 Select(Tmp0, N0); 03021 if (N.Val->hasOneUse()) { 03022 Result = CurDAG->SelectNodeTo(N.Val, PPC::FMRSD, MVT::f64, Tmp0); 03023 } else { 03024 ResNode = CurDAG->getTargetNode(PPC::FMRSD, MVT::f64, Tmp0); 03025 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03026 Result = SDOperand(ResNode, 0); 03027 } 03028 return; 03029 } 03030 std::cerr << "Cannot yet select: "; 03031 N.Val->dump(CurDAG); 03032 std::cerr << '\n'; 03033 abort(); 03034 } 03035 03036 void Select_fmul(SDOperand &Result, SDOperand N) { 03037 SDOperand N0(0, 0); 03038 SDOperand N1(0, 0); 03039 SDOperand Tmp0(0, 0); 03040 SDOperand Tmp1(0, 0); 03041 SDOperand Tmp2(0, 0); 03042 SDNode *ResNode; 03043 N0 = N.getOperand(0); 03044 N1 = N.getOperand(1); 03045 03046 // Pattern: (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRB) 03047 // Emits: (FMUL:f64 F8RC:f64:$FRA, F8RC:f64:$FRB) 03048 // Pattern complexity = 2 cost = 1 03049 if (N.Val->getValueType(0) == MVT::f64) { 03050 Select(Tmp0, N0); 03051 Select(Tmp1, N1); 03052 if (N.Val->hasOneUse()) { 03053 Result = CurDAG->SelectNodeTo(N.Val, PPC::FMUL, MVT::f64, Tmp0, Tmp1); 03054 } else { 03055 ResNode = CurDAG->getTargetNode(PPC::FMUL, MVT::f64, Tmp0, Tmp1); 03056 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03057 Result = SDOperand(ResNode, 0); 03058 } 03059 return; 03060 } 03061 03062 // Pattern: (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRB) 03063 // Emits: (FMULS:f32 F4RC:f32:$FRA, F4RC:f32:$FRB) 03064 // Pattern complexity = 2 cost = 1 03065 if (N.Val->getValueType(0) == MVT::f32) { 03066 Select(Tmp0, N0); 03067 Select(Tmp1, N1); 03068 if (N.Val->hasOneUse()) { 03069 Result = CurDAG->SelectNodeTo(N.Val, PPC::FMULS, MVT::f32, Tmp0, Tmp1); 03070 } else { 03071 ResNode = CurDAG->getTargetNode(PPC::FMULS, MVT::f32, Tmp0, Tmp1); 03072 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03073 Result = SDOperand(ResNode, 0); 03074 } 03075 return; 03076 } 03077 03078 // Pattern: (fmul:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 03079 // Emits: (VMADDFP:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (V_SET0:v4i32)) 03080 // Pattern complexity = 2 cost = 2 03081 if (N.Val->getValueType(0) == MVT::v4f32) { 03082 Select(Tmp0, N0); 03083 Select(Tmp1, N1); 03084 Tmp2 = SDOperand(CurDAG->getTargetNode(PPC::V_SET0, MVT::v4i32), 0); 03085 if (N.Val->hasOneUse()) { 03086 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMADDFP, MVT::v16i8, Tmp0, Tmp1, Tmp2); 03087 } else { 03088 ResNode = CurDAG->getTargetNode(PPC::VMADDFP, MVT::v16i8, Tmp0, Tmp1, Tmp2); 03089 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03090 Result = SDOperand(ResNode, 0); 03091 } 03092 return; 03093 } 03094 std::cerr << "Cannot yet select: "; 03095 N.Val->dump(CurDAG); 03096 std::cerr << '\n'; 03097 abort(); 03098 } 03099 03100 void Select_fneg(SDOperand &Result, SDOperand N) { 03101 SDOperand N0(0, 0); 03102 SDOperand N00(0, 0); 03103 SDOperand N000(0, 0); 03104 SDOperand N001(0, 0); 03105 SDOperand N01(0, 0); 03106 SDOperand N010(0, 0); 03107 SDOperand N011(0, 0); 03108 SDOperand Tmp0(0, 0); 03109 SDOperand Tmp1(0, 0); 03110 SDOperand Tmp2(0, 0); 03111 SDNode *ResNode; 03112 if ((!NoExcessFPPrecision)) { 03113 N0 = N.getOperand(0); 03114 if (N0.getOpcode() == ISD::FADD) { 03115 N00 = N0.getOperand(0); 03116 if (N00.getOpcode() == ISD::FMUL) { 03117 N000 = N00.getOperand(0); 03118 N001 = N00.getOperand(1); 03119 N01 = N0.getOperand(1); 03120 03121 // Pattern: (fneg:f64 (fadd:f64 (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRC), F8RC:f64:$FRB)) 03122 // Emits: (FNMADD:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB) 03123 // Pattern complexity = 6 cost = 1 03124 if (N.Val->getValueType(0) == MVT::f64) { 03125 Select(Tmp0, N000); 03126 Select(Tmp1, N001); 03127 Select(Tmp2, N01); 03128 if (N.Val->hasOneUse()) { 03129 Result = CurDAG->SelectNodeTo(N.Val, PPC::FNMADD, MVT::f64, Tmp0, Tmp1, Tmp2); 03130 } else { 03131 ResNode = CurDAG->getTargetNode(PPC::FNMADD, MVT::f64, Tmp0, Tmp1, Tmp2); 03132 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03133 Result = SDOperand(ResNode, 0); 03134 } 03135 return; 03136 } 03137 03138 // Pattern: (fneg:f32 (fadd:f32 (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRC), F4RC:f32:$FRB)) 03139 // Emits: (FNMADDS:f32 F4RC:f32:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB) 03140 // Pattern complexity = 6 cost = 1 03141 if (N.Val->getValueType(0) == MVT::f32) { 03142 Select(Tmp0, N000); 03143 Select(Tmp1, N001); 03144 Select(Tmp2, N01); 03145 if (N.Val->hasOneUse()) { 03146 Result = CurDAG->SelectNodeTo(N.Val, PPC::FNMADDS, MVT::f32, Tmp0, Tmp1, Tmp2); 03147 } else { 03148 ResNode = CurDAG->getTargetNode(PPC::FNMADDS, MVT::f32, Tmp0, Tmp1, Tmp2); 03149 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03150 Result = SDOperand(ResNode, 0); 03151 } 03152 return; 03153 } 03154 } 03155 } 03156 if (N0.getOpcode() == ISD::FSUB) { 03157 N00 = N0.getOperand(0); 03158 if (N00.getOpcode() == ISD::FMUL) { 03159 N000 = N00.getOperand(0); 03160 N001 = N00.getOperand(1); 03161 N01 = N0.getOperand(1); 03162 03163 // Pattern: (fneg:f64 (fsub:f64 (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRC), F8RC:f64:$FRB)) 03164 // Emits: (FNMSUB:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB) 03165 // Pattern complexity = 6 cost = 1 03166 if (N.Val->getValueType(0) == MVT::f64) { 03167 Select(Tmp0, N000); 03168 Select(Tmp1, N001); 03169 Select(Tmp2, N01); 03170 if (N.Val->hasOneUse()) { 03171 Result = CurDAG->SelectNodeTo(N.Val, PPC::FNMSUB, MVT::f64, Tmp0, Tmp1, Tmp2); 03172 } else { 03173 ResNode = CurDAG->getTargetNode(PPC::FNMSUB, MVT::f64, Tmp0, Tmp1, Tmp2); 03174 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03175 Result = SDOperand(ResNode, 0); 03176 } 03177 return; 03178 } 03179 03180 // Pattern: (fneg:f32 (fsub:f32 (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRC), F4RC:f32:$FRB)) 03181 // Emits: (FNMSUBS:f32 F4RC:f32:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB) 03182 // Pattern complexity = 6 cost = 1 03183 if (N.Val->getValueType(0) == MVT::f32) { 03184 Select(Tmp0, N000); 03185 Select(Tmp1, N001); 03186 Select(Tmp2, N01); 03187 if (N.Val->hasOneUse()) { 03188 Result = CurDAG->SelectNodeTo(N.Val, PPC::FNMSUBS, MVT::f32, Tmp0, Tmp1, Tmp2); 03189 } else { 03190 ResNode = CurDAG->getTargetNode(PPC::FNMSUBS, MVT::f32, Tmp0, Tmp1, Tmp2); 03191 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03192 Result = SDOperand(ResNode, 0); 03193 } 03194 return; 03195 } 03196 03197 // Pattern: (fneg:v4f32 (fsub:v4f32 (fmul:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vC), VRRC:v4f32:$vB)) 03198 // Emits: (VNMSUBFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vC, VRRC:v4f32:$vB) 03199 // Pattern complexity = 6 cost = 1 03200 if (N.Val->getValueType(0) == MVT::v4f32) { 03201 Select(Tmp0, N000); 03202 Select(Tmp1, N001); 03203 Select(Tmp2, N01); 03204 if (N.Val->hasOneUse()) { 03205 Result = CurDAG->SelectNodeTo(N.Val, PPC::VNMSUBFP, MVT::v4f32, Tmp0, Tmp1, Tmp2); 03206 } else { 03207 ResNode = CurDAG->getTargetNode(PPC::VNMSUBFP, MVT::v4f32, Tmp0, Tmp1, Tmp2); 03208 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03209 Result = SDOperand(ResNode, 0); 03210 } 03211 return; 03212 } 03213 } 03214 } 03215 if (N0.getOpcode() == ISD::FADD) { 03216 N00 = N0.getOperand(0); 03217 N01 = N0.getOperand(1); 03218 if (N01.getOpcode() == ISD::FMUL) { 03219 N010 = N01.getOperand(0); 03220 N011 = N01.getOperand(1); 03221 03222 // Pattern: (fneg:f64 (fadd:f64 F8RC:f64:$FRB, (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRC))) 03223 // Emits: (FNMADD:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB) 03224 // Pattern complexity = 6 cost = 1 03225 if (N.Val->getValueType(0) == MVT::f64) { 03226 Select(Tmp0, N010); 03227 Select(Tmp1, N011); 03228 Select(Tmp2, N00); 03229 if (N.Val->hasOneUse()) { 03230 Result = CurDAG->SelectNodeTo(N.Val, PPC::FNMADD, MVT::f64, Tmp0, Tmp1, Tmp2); 03231 } else { 03232 ResNode = CurDAG->getTargetNode(PPC::FNMADD, MVT::f64, Tmp0, Tmp1, Tmp2); 03233 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03234 Result = SDOperand(ResNode, 0); 03235 } 03236 return; 03237 } 03238 03239 // Pattern: (fneg:f32 (fadd:f32 F4RC:f32:$FRB, (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRC))) 03240 // Emits: (FNMADDS:f32 F4RC:f32:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB) 03241 // Pattern complexity = 6 cost = 1 03242 if (N.Val->getValueType(0) == MVT::f32) { 03243 Select(Tmp0, N010); 03244 Select(Tmp1, N011); 03245 Select(Tmp2, N00); 03246 if (N.Val->hasOneUse()) { 03247 Result = CurDAG->SelectNodeTo(N.Val, PPC::FNMADDS, MVT::f32, Tmp0, Tmp1, Tmp2); 03248 } else { 03249 ResNode = CurDAG->getTargetNode(PPC::FNMADDS, MVT::f32, Tmp0, Tmp1, Tmp2); 03250 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03251 Result = SDOperand(ResNode, 0); 03252 } 03253 return; 03254 } 03255 } 03256 } 03257 } 03258 N0 = N.getOperand(0); 03259 if (N0.getOpcode() == ISD::FABS) { 03260 N00 = N0.getOperand(0); 03261 03262 // Pattern: (fneg:f32 (fabs:f32 F4RC:f32:$frB)) 03263 // Emits: (FNABSS:f32 F4RC:f32:$frB) 03264 // Pattern complexity = 4 cost = 1 03265 if (N.Val->getValueType(0) == MVT::f32) { 03266 Select(Tmp0, N00); 03267 if (N.Val->hasOneUse()) { 03268 Result = CurDAG->SelectNodeTo(N.Val, PPC::FNABSS, MVT::f32, Tmp0); 03269 } else { 03270 ResNode = CurDAG->getTargetNode(PPC::FNABSS, MVT::f32, Tmp0); 03271 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03272 Result = SDOperand(ResNode, 0); 03273 } 03274 return; 03275 } 03276 03277 // Pattern: (fneg:f64 (fabs:f64 F8RC:f64:$frB)) 03278 // Emits: (FNABSD:f64 F8RC:f64:$frB) 03279 // Pattern complexity = 4 cost = 1 03280 if (N.Val->getValueType(0) == MVT::f64) { 03281 Select(Tmp0, N00); 03282 if (N.Val->hasOneUse()) { 03283 Result = CurDAG->SelectNodeTo(N.Val, PPC::FNABSD, MVT::f64, Tmp0); 03284 } else { 03285 ResNode = CurDAG->getTargetNode(PPC::FNABSD, MVT::f64, Tmp0); 03286 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03287 Result = SDOperand(ResNode, 0); 03288 } 03289 return; 03290 } 03291 } 03292 03293 // Pattern: (fneg:f32 F4RC:f32:$frB) 03294 // Emits: (FNEGS:f32 F4RC:f32:$frB) 03295 // Pattern complexity = 2 cost = 1 03296 if (N.Val->getValueType(0) == MVT::f32) { 03297 Select(Tmp0, N0); 03298 if (N.Val->hasOneUse()) { 03299 Result = CurDAG->SelectNodeTo(N.Val, PPC::FNEGS, MVT::f32, Tmp0); 03300 } else { 03301 ResNode = CurDAG->getTargetNode(PPC::FNEGS, MVT::f32, Tmp0); 03302 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03303 Result = SDOperand(ResNode, 0); 03304 } 03305 return; 03306 } 03307 03308 // Pattern: (fneg:f64 F8RC:f64:$frB) 03309 // Emits: (FNEGD:f64 F8RC:f64:$frB) 03310 // Pattern complexity = 2 cost = 1 03311 if (N.Val->getValueType(0) == MVT::f64) { 03312 Select(Tmp0, N0); 03313 if (N.Val->hasOneUse()) { 03314 Result = CurDAG->SelectNodeTo(N.Val, PPC::FNEGD, MVT::f64, Tmp0); 03315 } else { 03316 ResNode = CurDAG->getTargetNode(PPC::FNEGD, MVT::f64, Tmp0); 03317 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03318 Result = SDOperand(ResNode, 0); 03319 } 03320 return; 03321 } 03322 std::cerr << "Cannot yet select: "; 03323 N.Val->dump(CurDAG); 03324 std::cerr << '\n'; 03325 abort(); 03326 } 03327 03328 void Select_fround(SDOperand &Result, SDOperand N) { 03329 SDOperand N0(0, 0); 03330 SDOperand Tmp0(0, 0); 03331 SDNode *ResNode; 03332 N0 = N.getOperand(0); 03333 if (N.Val->getValueType(0) == MVT::f32 && 03334 N0.Val->getValueType(0) == MVT::f64) { 03335 Select(Tmp0, N0); 03336 if (N.Val->hasOneUse()) { 03337 Result = CurDAG->SelectNodeTo(N.Val, PPC::FRSP, MVT::f32, Tmp0); 03338 } else { 03339 ResNode = CurDAG->getTargetNode(PPC::FRSP, MVT::f32, Tmp0); 03340 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03341 Result = SDOperand(ResNode, 0); 03342 } 03343 return; 03344 } 03345 std::cerr << "Cannot yet select: "; 03346 N.Val->dump(CurDAG); 03347 std::cerr << '\n'; 03348 abort(); 03349 } 03350 03351 void Select_fsqrt(SDOperand &Result, SDOperand N) { 03352 SDOperand N0(0, 0); 03353 SDOperand Tmp0(0, 0); 03354 SDNode *ResNode; 03355 N0 = N.getOperand(0); 03356 03357 // Pattern: (fsqrt:f64 F8RC:f64:$frB) 03358 // Emits: (FSQRT:f64 F8RC:f64:$frB) 03359 // Pattern complexity = 2 cost = 1 03360 if (N.Val->getValueType(0) == MVT::f64) { 03361 Select(Tmp0, N0); 03362 if (N.Val->hasOneUse()) { 03363 Result = CurDAG->SelectNodeTo(N.Val, PPC::FSQRT, MVT::f64, Tmp0); 03364 } else { 03365 ResNode = CurDAG->getTargetNode(PPC::FSQRT, MVT::f64, Tmp0); 03366 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03367 Result = SDOperand(ResNode, 0); 03368 } 03369 return; 03370 } 03371 03372 // Pattern: (fsqrt:f32 F4RC:f32:$frB) 03373 // Emits: (FSQRTS:f32 F4RC:f32:$frB) 03374 // Pattern complexity = 2 cost = 1 03375 if (N.Val->getValueType(0) == MVT::f32) { 03376 Select(Tmp0, N0); 03377 if (N.Val->hasOneUse()) { 03378 Result = CurDAG->SelectNodeTo(N.Val, PPC::FSQRTS, MVT::f32, Tmp0); 03379 } else { 03380 ResNode = CurDAG->getTargetNode(PPC::FSQRTS, MVT::f32, Tmp0); 03381 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03382 Result = SDOperand(ResNode, 0); 03383 } 03384 return; 03385 } 03386 std::cerr << "Cannot yet select: "; 03387 N.Val->dump(CurDAG); 03388 std::cerr << '\n'; 03389 abort(); 03390 } 03391 03392 void Select_fsub(SDOperand &Result, SDOperand N) { 03393 SDOperand N0(0, 0); 03394 SDOperand N00(0, 0); 03395 SDOperand N01(0, 0); 03396 SDOperand N1(0, 0); 03397 SDOperand N10(0, 0); 03398 SDOperand N11(0, 0); 03399 SDOperand Tmp0(0, 0); 03400 SDOperand Tmp1(0, 0); 03401 SDOperand Tmp2(0, 0); 03402 SDNode *ResNode; 03403 if ((!NoExcessFPPrecision)) { 03404 N0 = N.getOperand(0); 03405 if (N0.getOpcode() == ISD::FMUL) { 03406 N00 = N0.getOperand(0); 03407 N01 = N0.getOperand(1); 03408 N1 = N.getOperand(1); 03409 03410 // Pattern: (fsub:f64 (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRC), F8RC:f64:$FRB) 03411 // Emits: (FMSUB:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB) 03412 // Pattern complexity = 4 cost = 1 03413 if (N.Val->getValueType(0) == MVT::f64) { 03414 Select(Tmp0, N00); 03415 Select(Tmp1, N01); 03416 Select(Tmp2, N1); 03417 if (N.Val->hasOneUse()) { 03418 Result = CurDAG->SelectNodeTo(N.Val, PPC::FMSUB, MVT::f64, Tmp0, Tmp1, Tmp2); 03419 } else { 03420 ResNode = CurDAG->getTargetNode(PPC::FMSUB, MVT::f64, Tmp0, Tmp1, Tmp2); 03421 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03422 Result = SDOperand(ResNode, 0); 03423 } 03424 return; 03425 } 03426 03427 // Pattern: (fsub:f32 (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRC), F4RC:f32:$FRB) 03428 // Emits: (FMSUBS:f32 F4RC:f32:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB) 03429 // Pattern complexity = 4 cost = 1 03430 if (N.Val->getValueType(0) == MVT::f32) { 03431 Select(Tmp0, N00); 03432 Select(Tmp1, N01); 03433 Select(Tmp2, N1); 03434 if (N.Val->hasOneUse()) { 03435 Result = CurDAG->SelectNodeTo(N.Val, PPC::FMSUBS, MVT::f32, Tmp0, Tmp1, Tmp2); 03436 } else { 03437 ResNode = CurDAG->getTargetNode(PPC::FMSUBS, MVT::f32, Tmp0, Tmp1, Tmp2); 03438 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03439 Result = SDOperand(ResNode, 0); 03440 } 03441 return; 03442 } 03443 } 03444 N1 = N.getOperand(1); 03445 if (N1.getOpcode() == ISD::FMUL) { 03446 N10 = N1.getOperand(0); 03447 N11 = N1.getOperand(1); 03448 03449 // Pattern: (fsub:f64 F8RC:f64:$B, (fmul:f64 F8RC:f64:$A, F8RC:f64:$C)) 03450 // Emits: (FNMSUB:f64 F8RC:f64:$A, F8RC:f64:$C, F8RC:f64:$B) 03451 // Pattern complexity = 4 cost = 1 03452 if (N.Val->getValueType(0) == MVT::f64) { 03453 Select(Tmp0, N10); 03454 Select(Tmp1, N11); 03455 Select(Tmp2, N0); 03456 if (N.Val->hasOneUse()) { 03457 Result = CurDAG->SelectNodeTo(N.Val, PPC::FNMSUB, MVT::f64, Tmp0, Tmp1, Tmp2); 03458 } else { 03459 ResNode = CurDAG->getTargetNode(PPC::FNMSUB, MVT::f64, Tmp0, Tmp1, Tmp2); 03460 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03461 Result = SDOperand(ResNode, 0); 03462 } 03463 return; 03464 } 03465 03466 // Pattern: (fsub:f32 F4RC:f32:$B, (fmul:f32 F4RC:f32:$A, F4RC:f32:$C)) 03467 // Emits: (FNMSUBS:f32 F4RC:f32:$A, F4RC:f32:$C, F4RC:f32:$B) 03468 // Pattern complexity = 4 cost = 1 03469 if (N.Val->getValueType(0) == MVT::f32) { 03470 Select(Tmp0, N10); 03471 Select(Tmp1, N11); 03472 Select(Tmp2, N0); 03473 if (N.Val->hasOneUse()) { 03474 Result = CurDAG->SelectNodeTo(N.Val, PPC::FNMSUBS, MVT::f32, Tmp0, Tmp1, Tmp2); 03475 } else { 03476 ResNode = CurDAG->getTargetNode(PPC::FNMSUBS, MVT::f32, Tmp0, Tmp1, Tmp2); 03477 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03478 Result = SDOperand(ResNode, 0); 03479 } 03480 return; 03481 } 03482 } 03483 } 03484 N0 = N.getOperand(0); 03485 N1 = N.getOperand(1); 03486 03487 // Pattern: (fsub:f64 F8RC:f64:$FRA, F8RC:f64:$FRB) 03488 // Emits: (FSUB:f64 F8RC:f64:$FRA, F8RC:f64:$FRB) 03489 // Pattern complexity = 2 cost = 1 03490 if (N.Val->getValueType(0) == MVT::f64) { 03491 Select(Tmp0, N0); 03492 Select(Tmp1, N1); 03493 if (N.Val->hasOneUse()) { 03494 Result = CurDAG->SelectNodeTo(N.Val, PPC::FSUB, MVT::f64, Tmp0, Tmp1); 03495 } else { 03496 ResNode = CurDAG->getTargetNode(PPC::FSUB, MVT::f64, Tmp0, Tmp1); 03497 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03498 Result = SDOperand(ResNode, 0); 03499 } 03500 return; 03501 } 03502 03503 // Pattern: (fsub:f32 F4RC:f32:$FRA, F4RC:f32:$FRB) 03504 // Emits: (FSUBS:f32 F4RC:f32:$FRA, F4RC:f32:$FRB) 03505 // Pattern complexity = 2 cost = 1 03506 if (N.Val->getValueType(0) == MVT::f32) { 03507 Select(Tmp0, N0); 03508 Select(Tmp1, N1); 03509 if (N.Val->hasOneUse()) { 03510 Result = CurDAG->SelectNodeTo(N.Val, PPC::FSUBS, MVT::f32, Tmp0, Tmp1); 03511 } else { 03512 ResNode = CurDAG->getTargetNode(PPC::FSUBS, MVT::f32, Tmp0, Tmp1); 03513 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03514 Result = SDOperand(ResNode, 0); 03515 } 03516 return; 03517 } 03518 03519 // Pattern: (fsub:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 03520 // Emits: (VSUBFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 03521 // Pattern complexity = 2 cost = 1 03522 if (N.Val->getValueType(0) == MVT::v4f32) { 03523 Select(Tmp0, N0); 03524 Select(Tmp1, N1); 03525 if (N.Val->hasOneUse()) { 03526 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBFP, MVT::v4f32, Tmp0, Tmp1); 03527 } else { 03528 ResNode = CurDAG->getTargetNode(PPC::VSUBFP, MVT::v4f32, Tmp0, Tmp1); 03529 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03530 Result = SDOperand(ResNode, 0); 03531 } 03532 return; 03533 } 03534 std::cerr << "Cannot yet select: "; 03535 N.Val->dump(CurDAG); 03536 std::cerr << '\n'; 03537 abort(); 03538 } 03539 03540 void Select_imm(SDOperand &Result, SDOperand N) { 03541 SDOperand Tmp0(0, 0); 03542 SDOperand Tmp1(0, 0); 03543 SDOperand Tmp2(0, 0); 03544 SDOperand Tmp3(0, 0); 03545 SDNode *ResNode; 03546 03547 // Pattern: (imm:i32)<<P:Predicate_immSExt16>>:$imm 03548 // Emits: (LI:i32 (imm:i32):$imm) 03549 // Pattern complexity = 3 cost = 1 03550 if (Predicate_immSExt16(N.Val) && 03551 N.Val->getValueType(0) == MVT::i32) { 03552 unsigned Tmp0C = (unsigned)cast<ConstantSDNode>(N)->getValue(); 03553 Tmp0 = CurDAG->getTargetConstant(Tmp0C, MVT::i32); 03554 if (N.Val->hasOneUse()) { 03555 Result = CurDAG->SelectNodeTo(N.Val, PPC::LI, MVT::i32, Tmp0); 03556 } else { 03557 ResNode = CurDAG->getTargetNode(PPC::LI, MVT::i32, Tmp0); 03558 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03559 Result = SDOperand(ResNode, 0); 03560 } 03561 return; 03562 } 03563 03564 // Pattern: (imm:i32)<<P:Predicate_imm16Shifted>><<X:HI16>>:$imm 03565 // Emits: (LIS:i32 (HI16:i32 (imm:i32):$imm)) 03566 // Pattern complexity = 3 cost = 1 03567 if (Predicate_imm16Shifted(N.Val) && 03568 N.Val->getValueType(0) == MVT::i32) { 03569 unsigned Tmp0C = (unsigned)cast<ConstantSDNode>(N)->getValue(); 03570 Tmp0 = CurDAG->getTargetConstant(Tmp0C, MVT::i32); 03571 Tmp1 = Transform_HI16(Tmp0.Val); 03572 if (N.Val->hasOneUse()) { 03573 Result = CurDAG->SelectNodeTo(N.Val, PPC::LIS, MVT::i32, Tmp1); 03574 } else { 03575 ResNode = CurDAG->getTargetNode(PPC::LIS, MVT::i32, Tmp1); 03576 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03577 Result = SDOperand(ResNode, 0); 03578 } 03579 return; 03580 } 03581 03582 // Pattern: (imm:i32):$imm 03583 // Emits: (ORI:i32 (LIS:i32 (HI16:i32 (imm:i32):$imm)), (LO16:i32 (imm:i32):$imm)) 03584 // Pattern complexity = 2 cost = 2 03585 if (N.Val->getValueType(0) == MVT::i32) { 03586 unsigned Tmp0C = (unsigned)cast<ConstantSDNode>(N)->getValue(); 03587 Tmp0 = CurDAG->getTargetConstant(Tmp0C, MVT::i32); 03588 Tmp1 = Transform_HI16(Tmp0.Val); 03589 Tmp2 = SDOperand(CurDAG->getTargetNode(PPC::LIS, MVT::i32, Tmp1), 0); 03590 Tmp3 = Transform_LO16(Tmp0.Val); 03591 if (N.Val->hasOneUse()) { 03592 Result = CurDAG->SelectNodeTo(N.Val, PPC::ORI, MVT::i32, Tmp2, Tmp3); 03593 } else { 03594 ResNode = CurDAG->getTargetNode(PPC::ORI, MVT::i32, Tmp2, Tmp3); 03595 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03596 Result = SDOperand(ResNode, 0); 03597 } 03598 return; 03599 } 03600 std::cerr << "Cannot yet select: "; 03601 N.Val->dump(CurDAG); 03602 std::cerr << '\n'; 03603 abort(); 03604 } 03605 03606 void Select_intrinsic_void(SDOperand &Result, SDOperand N) { 03607 SDOperand Chain(0, 0); 03608 SDOperand N1(0, 0); 03609 SDOperand N2(0, 0); 03610 SDOperand N3(0, 0); 03611 SDOperand N4(0, 0); 03612 SDOperand Tmp1(0, 0); 03613 SDOperand Tmp2(0, 0); 03614 SDOperand Tmp3(0, 0); 03615 SDOperand Tmp4(0, 0); 03616 SDNode *ResNode; 03617 Chain = N.getOperand(0); 03618 N1 = N.getOperand(1); 03619 if (isa<ConstantSDNode>(N1)) { 03620 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 03621 03622 // Pattern: (intrinsic_void:void 50:i32, VRRC:v16i8:$rS, xoaddr:i32:$dst) 03623 // Emits: (STVEBX:void VRRC:v16i8:$rS, xoaddr:i32:$dst) 03624 // Pattern complexity = 11 cost = 1 03625 if (CN0 == 50) { 03626 N2 = N.getOperand(2); 03627 N3 = N.getOperand(3); 03628 if (SelectAddrIdxOnly(N3, Tmp1, Tmp2)) { 03629 Select(Tmp1, Tmp1); 03630 Select(Tmp2, Tmp2); 03631 Select(Tmp3, N2); 03632 Select(Chain, Chain); 03633 ResNode = CurDAG->getTargetNode(PPC::STVEBX, MVT::Other, Tmp3, Tmp1, Tmp2, Chain); 03634 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03635 Result = SDOperand(ResNode, N.ResNo); 03636 return; 03637 } 03638 } 03639 03640 // Pattern: (intrinsic_void:void 51:i32, VRRC:v8i16:$rS, xoaddr:i32:$dst) 03641 // Emits: (STVEHX:void VRRC:v8i16:$rS, xoaddr:i32:$dst) 03642 // Pattern complexity = 11 cost = 1 03643 if (CN0 == 51) { 03644 N2 = N.getOperand(2); 03645 N3 = N.getOperand(3); 03646 if (SelectAddrIdxOnly(N3, Tmp1, Tmp2)) { 03647 Select(Tmp1, Tmp1); 03648 Select(Tmp2, Tmp2); 03649 Select(Tmp3, N2); 03650 Select(Chain, Chain); 03651 ResNode = CurDAG->getTargetNode(PPC::STVEHX, MVT::Other, Tmp3, Tmp1, Tmp2, Chain); 03652 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03653 Result = SDOperand(ResNode, N.ResNo); 03654 return; 03655 } 03656 } 03657 03658 // Pattern: (intrinsic_void:void 52:i32, VRRC:v4i32:$rS, xoaddr:i32:$dst) 03659 // Emits: (STVEWX:void VRRC:v4i32:$rS, xoaddr:i32:$dst) 03660 // Pattern complexity = 11 cost = 1 03661 if (CN0 == 52) { 03662 N2 = N.getOperand(2); 03663 N3 = N.getOperand(3); 03664 if (SelectAddrIdxOnly(N3, Tmp1, Tmp2)) { 03665 Select(Tmp1, Tmp1); 03666 Select(Tmp2, Tmp2); 03667 Select(Tmp3, N2); 03668 Select(Chain, Chain); 03669 ResNode = CurDAG->getTargetNode(PPC::STVEWX, MVT::Other, Tmp3, Tmp1, Tmp2, Chain); 03670 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03671 Result = SDOperand(ResNode, N.ResNo); 03672 return; 03673 } 03674 } 03675 03676 // Pattern: (intrinsic_void:void 53:i32, VRRC:v4i32:$rS, xoaddr:i32:$dst) 03677 // Emits: (STVX:void VRRC:v4i32:$rS, xoaddr:i32:$dst) 03678 // Pattern complexity = 11 cost = 1 03679 if (CN0 == 53) { 03680 N2 = N.getOperand(2); 03681 N3 = N.getOperand(3); 03682 if (SelectAddrIdxOnly(N3, Tmp1, Tmp2)) { 03683 Select(Tmp1, Tmp1); 03684 Select(Tmp2, Tmp2); 03685 Select(Tmp3, N2); 03686 Select(Chain, Chain); 03687 ResNode = CurDAG->getTargetNode(PPC::STVX, MVT::Other, Tmp3, Tmp1, Tmp2, Chain); 03688 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03689 Result = SDOperand(ResNode, N.ResNo); 03690 return; 03691 } 03692 } 03693 03694 // Pattern: (intrinsic_void:void 54:i32, VRRC:v4i32:$rS, xoaddr:i32:$dst) 03695 // Emits: (STVXL:void VRRC:v4i32:$rS, xoaddr:i32:$dst) 03696 // Pattern complexity = 11 cost = 1 03697 if (CN0 == 54) { 03698 N2 = N.getOperand(2); 03699 N3 = N.getOperand(3); 03700 if (SelectAddrIdxOnly(N3, Tmp1, Tmp2)) { 03701 Select(Tmp1, Tmp1); 03702 Select(Tmp2, Tmp2); 03703 Select(Tmp3, N2); 03704 Select(Chain, Chain); 03705 ResNode = CurDAG->getTargetNode(PPC::STVXL, MVT::Other, Tmp3, Tmp1, Tmp2, Chain); 03706 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03707 Result = SDOperand(ResNode, N.ResNo); 03708 return; 03709 } 03710 } 03711 03712 // Pattern: (intrinsic_void:void 35:i32, (imm:i32):$STRM) 03713 // Emits: (DSS:void 0:i32, (imm:i32):$STRM, 0:i32, 0:i32) 03714 // Pattern complexity = 7 cost = 1 03715 if (CN0 == 35) { 03716 N2 = N.getOperand(2); 03717 if (N2.getOpcode() == ISD::Constant) { 03718 Tmp1 = CurDAG->getTargetConstant(0, MVT::i32); 03719 unsigned Tmp2C = (unsigned)cast<ConstantSDNode>(N2)->getValue(); 03720 Tmp2 = CurDAG->getTargetConstant(Tmp2C, MVT::i32); 03721 Tmp3 = CurDAG->getTargetConstant(0, MVT::i32); 03722 Tmp4 = CurDAG->getTargetConstant(0, MVT::i32); 03723 Select(Chain, Chain); 03724 ResNode = CurDAG->getTargetNode(PPC::DSS, MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4, Chain); 03725 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03726 Result = SDOperand(ResNode, N.ResNo); 03727 return; 03728 } 03729 } 03730 03731 // Pattern: (intrinsic_void:void 37:i32, GPRC:i32:$rA, GPRC:i32:$rB, (imm:i32):$STRM) 03732 // Emits: (DST:void 0:i32, (imm:i32):$STRM, GPRC:i32:$rA, GPRC:i32:$rB) 03733 // Pattern complexity = 7 cost = 1 03734 if (CN0 == 37) { 03735 N2 = N.getOperand(2); 03736 N3 = N.getOperand(3); 03737 N4 = N.getOperand(4); 03738 if (N4.getOpcode() == ISD::Constant) { 03739 Tmp1 = CurDAG->getTargetConstant(0, MVT::i32); 03740 unsigned Tmp2C = (unsigned)cast<ConstantSDNode>(N4)->getValue(); 03741 Tmp2 = CurDAG->getTargetConstant(Tmp2C, MVT::i32); 03742 Select(Tmp3, N2); 03743 Select(Tmp4, N3); 03744 Select(Chain, Chain); 03745 ResNode = CurDAG->getTargetNode(PPC::DST, MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4, Chain); 03746 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03747 Result = SDOperand(ResNode, N.ResNo); 03748 return; 03749 } 03750 } 03751 03752 // Pattern: (intrinsic_void:void 40:i32, GPRC:i32:$rA, GPRC:i32:$rB, (imm:i32):$STRM) 03753 // Emits: (DST:void 1:i32, (imm:i32):$STRM, GPRC:i32:$rA, GPRC:i32:$rB) 03754 // Pattern complexity = 7 cost = 1 03755 if (CN0 == 40) { 03756 N2 = N.getOperand(2); 03757 N3 = N.getOperand(3); 03758 N4 = N.getOperand(4); 03759 if (N4.getOpcode() == ISD::Constant) { 03760 Tmp1 = CurDAG->getTargetConstant(1, MVT::i32); 03761 unsigned Tmp2C = (unsigned)cast<ConstantSDNode>(N4)->getValue(); 03762 Tmp2 = CurDAG->getTargetConstant(Tmp2C, MVT::i32); 03763 Select(Tmp3, N2); 03764 Select(Tmp4, N3); 03765 Select(Chain, Chain); 03766 ResNode = CurDAG->getTargetNode(PPC::DST, MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4, Chain); 03767 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03768 Result = SDOperand(ResNode, N.ResNo); 03769 return; 03770 } 03771 } 03772 03773 // Pattern: (intrinsic_void:void 38:i32, GPRC:i32:$rA, GPRC:i32:$rB, (imm:i32):$STRM) 03774 // Emits: (DSTST:void 0:i32, (imm:i32):$STRM, GPRC:i32:$rA, GPRC:i32:$rB) 03775 // Pattern complexity = 7 cost = 1 03776 if (CN0 == 38) { 03777 N2 = N.getOperand(2); 03778 N3 = N.getOperand(3); 03779 N4 = N.getOperand(4); 03780 if (N4.getOpcode() == ISD::Constant) { 03781 Tmp1 = CurDAG->getTargetConstant(0, MVT::i32); 03782 unsigned Tmp2C = (unsigned)cast<ConstantSDNode>(N4)->getValue(); 03783 Tmp2 = CurDAG->getTargetConstant(Tmp2C, MVT::i32); 03784 Select(Tmp3, N2); 03785 Select(Tmp4, N3); 03786 Select(Chain, Chain); 03787 ResNode = CurDAG->getTargetNode(PPC::DSTST, MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4, Chain); 03788 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03789 Result = SDOperand(ResNode, N.ResNo); 03790 return; 03791 } 03792 } 03793 03794 // Pattern: (intrinsic_void:void 39:i32, GPRC:i32:$rA, GPRC:i32:$rB, (imm:i32):$STRM) 03795 // Emits: (DSTST:void 1:i32, (imm:i32):$STRM, GPRC:i32:$rA, GPRC:i32:$rB) 03796 // Pattern complexity = 7 cost = 1 03797 if (CN0 == 39) { 03798 N2 = N.getOperand(2); 03799 N3 = N.getOperand(3); 03800 N4 = N.getOperand(4); 03801 if (N4.getOpcode() == ISD::Constant) { 03802 Tmp1 = CurDAG->getTargetConstant(1, MVT::i32); 03803 unsigned Tmp2C = (unsigned)cast<ConstantSDNode>(N4)->getValue(); 03804 Tmp2 = CurDAG->getTargetConstant(Tmp2C, MVT::i32); 03805 Select(Tmp3, N2); 03806 Select(Tmp4, N3); 03807 Select(Chain, Chain); 03808 ResNode = CurDAG->getTargetNode(PPC::DSTST, MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4, Chain); 03809 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03810 Result = SDOperand(ResNode, N.ResNo); 03811 return; 03812 } 03813 } 03814 03815 // Pattern: (intrinsic_void:void 49:i32, VRRC:v4i32:$vB) 03816 // Emits: (MTVSCR:void VRRC:v4i32:$vB) 03817 // Pattern complexity = 5 cost = 1 03818 if (CN0 == 49) { 03819 N2 = N.getOperand(2); 03820 Select(Tmp1, N2); 03821 Select(Chain, Chain); 03822 ResNode = CurDAG->getTargetNode(PPC::MTVSCR, MVT::Other, Tmp1, Chain); 03823 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03824 Result = SDOperand(ResNode, N.ResNo); 03825 return; 03826 } 03827 03828 // Pattern: (intrinsic_void:void 36:i32) 03829 // Emits: (DSS:void 1:i32, 0:i32, 0:i32, 0:i32) 03830 // Pattern complexity = 5 cost = 1 03831 if (CN0 == 36) { 03832 Tmp1 = CurDAG->getTargetConstant(1, MVT::i32); 03833 Tmp2 = CurDAG->getTargetConstant(0, MVT::i32); 03834 Tmp3 = CurDAG->getTargetConstant(0, MVT::i32); 03835 Tmp4 = CurDAG->getTargetConstant(0, MVT::i32); 03836 Select(Chain, Chain); 03837 ResNode = CurDAG->getTargetNode(PPC::DSS, MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4, Chain); 03838 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03839 Result = SDOperand(ResNode, N.ResNo); 03840 return; 03841 } 03842 } 03843 std::cerr << "Cannot yet select: "; 03844 unsigned iid = cast<ConstantSDNode>(N.getOperand(N.getOperand(0).getValueType() == MVT::Other))->getValue(); 03845 std::cerr << "intrinsic %"<< Intrinsic::getName((Intrinsic::ID)iid); 03846 std::cerr << '\n'; 03847 abort(); 03848 } 03849 03850 void Select_intrinsic_w_chain(SDOperand &Result, SDOperand N) { 03851 if (N.ResNo == 1 && N.getValue(0).hasOneUse()) { 03852 SDOperand Dummy = CurDAG->getNode(ISD::HANDLENODE, MVT::Other, N); 03853 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Dummy.Val, 0); 03854 SelectionDAG::InsertISelMapEntry(HandleMap, N.Val, 1, Dummy.Val, 0); 03855 Result = Dummy; 03856 return; 03857 } 03858 SDOperand Chain(0, 0); 03859 SDOperand N1(0, 0); 03860 SDOperand N2(0, 0); 03861 SDOperand Tmp1(0, 0); 03862 SDOperand Tmp2(0, 0); 03863 SDNode *ResNode; 03864 Chain = N.getOperand(0); 03865 N1 = N.getOperand(1); 03866 if (isa<ConstantSDNode>(N1)) { 03867 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 03868 03869 // Pattern: (intrinsic_w_chain:v16i8 41:i32, xoaddr:i32:$src) 03870 // Emits: (LVEBX:v16i8 xoaddr:i32:$src) 03871 // Pattern complexity = 11 cost = 1 03872 if (CN0 == 41) { 03873 N2 = N.getOperand(2); 03874 if (SelectAddrIdxOnly(N2, Tmp1, Tmp2)) { 03875 Select(Tmp1, Tmp1); 03876 Select(Tmp2, Tmp2); 03877 Select(Chain, Chain); 03878 ResNode = CurDAG->getTargetNode(PPC::LVEBX, MVT::v16i8, MVT::Other, Tmp1, Tmp2, Chain); 03879 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03880 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 03881 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 03882 Result = SDOperand(ResNode, N.ResNo); 03883 return; 03884 } 03885 } 03886 03887 // Pattern: (intrinsic_w_chain:v8i16 42:i32, xoaddr:i32:$src) 03888 // Emits: (LVEHX:v8i16 xoaddr:i32:$src) 03889 // Pattern complexity = 11 cost = 1 03890 if (CN0 == 42) { 03891 N2 = N.getOperand(2); 03892 if (SelectAddrIdxOnly(N2, Tmp1, Tmp2)) { 03893 Select(Tmp1, Tmp1); 03894 Select(Tmp2, Tmp2); 03895 Select(Chain, Chain); 03896 ResNode = CurDAG->getTargetNode(PPC::LVEHX, MVT::v8i16, MVT::Other, Tmp1, Tmp2, Chain); 03897 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03898 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 03899 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 03900 Result = SDOperand(ResNode, N.ResNo); 03901 return; 03902 } 03903 } 03904 03905 // Pattern: (intrinsic_w_chain:v4i32 43:i32, xoaddr:i32:$src) 03906 // Emits: (LVEWX:v4i32 xoaddr:i32:$src) 03907 // Pattern complexity = 11 cost = 1 03908 if (CN0 == 43) { 03909 N2 = N.getOperand(2); 03910 if (SelectAddrIdxOnly(N2, Tmp1, Tmp2)) { 03911 Select(Tmp1, Tmp1); 03912 Select(Tmp2, Tmp2); 03913 Select(Chain, Chain); 03914 ResNode = CurDAG->getTargetNode(PPC::LVEWX, MVT::v4i32, MVT::Other, Tmp1, Tmp2, Chain); 03915 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03916 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 03917 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 03918 Result = SDOperand(ResNode, N.ResNo); 03919 return; 03920 } 03921 } 03922 03923 // Pattern: (intrinsic_w_chain:v4i32 46:i32, xoaddr:i32:$src) 03924 // Emits: (LVX:v4i32 xoaddr:i32:$src) 03925 // Pattern complexity = 11 cost = 1 03926 if (CN0 == 46) { 03927 N2 = N.getOperand(2); 03928 if (SelectAddrIdxOnly(N2, Tmp1, Tmp2)) { 03929 Select(Tmp1, Tmp1); 03930 Select(Tmp2, Tmp2); 03931 Select(Chain, Chain); 03932 ResNode = CurDAG->getTargetNode(PPC::LVX, MVT::v4i32, MVT::Other, Tmp1, Tmp2, Chain); 03933 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03934 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 03935 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 03936 Result = SDOperand(ResNode, N.ResNo); 03937 return; 03938 } 03939 } 03940 03941 // Pattern: (intrinsic_w_chain:v4i32 47:i32, xoaddr:i32:$src) 03942 // Emits: (LVXL:v4i32 xoaddr:i32:$src) 03943 // Pattern complexity = 11 cost = 1 03944 if (CN0 == 47) { 03945 N2 = N.getOperand(2); 03946 if (SelectAddrIdxOnly(N2, Tmp1, Tmp2)) { 03947 Select(Tmp1, Tmp1); 03948 Select(Tmp2, Tmp2); 03949 Select(Chain, Chain); 03950 ResNode = CurDAG->getTargetNode(PPC::LVXL, MVT::v4i32, MVT::Other, Tmp1, Tmp2, Chain); 03951 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03952 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 03953 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 03954 Result = SDOperand(ResNode, N.ResNo); 03955 return; 03956 } 03957 } 03958 03959 // Pattern: (intrinsic_w_chain:v8i16 48:i32) 03960 // Emits: (MFVSCR:v8i16) 03961 // Pattern complexity = 5 cost = 1 03962 if (CN0 == 48) { 03963 Select(Chain, Chain); 03964 ResNode = CurDAG->getTargetNode(PPC::MFVSCR, MVT::v8i16, MVT::Other, Chain); 03965 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03966 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 03967 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 03968 Result = SDOperand(ResNode, N.ResNo); 03969 return; 03970 } 03971 } 03972 std::cerr << "Cannot yet select: "; 03973 unsigned iid = cast<ConstantSDNode>(N.getOperand(N.getOperand(0).getValueType() == MVT::Other))->getValue(); 03974 std::cerr << "intrinsic %"<< Intrinsic::getName((Intrinsic::ID)iid); 03975 std::cerr << '\n'; 03976 abort(); 03977 } 03978 03979 void Select_intrinsic_wo_chain(SDOperand &Result, SDOperand N) { 03980 SDOperand N0(0, 0); 03981 SDOperand N1(0, 0); 03982 SDOperand N2(0, 0); 03983 SDOperand N3(0, 0); 03984 SDOperand Tmp1(0, 0); 03985 SDOperand Tmp2(0, 0); 03986 SDOperand Tmp3(0, 0); 03987 SDNode *ResNode; 03988 N0 = N.getOperand(0); 03989 if (isa<ConstantSDNode>(N0)) { 03990 int64_t CN0 = cast<ConstantSDNode>(N0)->getSignExtended(); 03991 03992 // Pattern: (intrinsic_wo_chain:v16i8 44:i32, xoaddr:i32:$src) 03993 // Emits: (LVSL:v16i8 xoaddr:i32:$src) 03994 // Pattern complexity = 11 cost = 1 03995 if (CN0 == 44) { 03996 N1 = N.getOperand(1); 03997 if (SelectAddrIdxOnly(N1, Tmp1, Tmp2)) { 03998 Select(Tmp1, Tmp1); 03999 Select(Tmp2, Tmp2); 04000 if (N.Val->hasOneUse()) { 04001 Result = CurDAG->SelectNodeTo(N.Val, PPC::LVSL, MVT::v16i8, Tmp1, Tmp2); 04002 } else { 04003 ResNode = CurDAG->getTargetNode(PPC::LVSL, MVT::v16i8, Tmp1, Tmp2); 04004 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04005 Result = SDOperand(ResNode, 0); 04006 } 04007 return; 04008 } 04009 } 04010 04011 // Pattern: (intrinsic_wo_chain:v16i8 45:i32, xoaddr:i32:$src) 04012 // Emits: (LVSR:v16i8 xoaddr:i32:$src) 04013 // Pattern complexity = 11 cost = 1 04014 if (CN0 == 45) { 04015 N1 = N.getOperand(1); 04016 if (SelectAddrIdxOnly(N1, Tmp1, Tmp2)) { 04017 Select(Tmp1, Tmp1); 04018 Select(Tmp2, Tmp2); 04019 if (N.Val->hasOneUse()) { 04020 Result = CurDAG->SelectNodeTo(N.Val, PPC::LVSR, MVT::v16i8, Tmp1, Tmp2); 04021 } else { 04022 ResNode = CurDAG->getTargetNode(PPC::LVSR, MVT::v16i8, Tmp1, Tmp2); 04023 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04024 Result = SDOperand(ResNode, 0); 04025 } 04026 return; 04027 } 04028 } 04029 04030 // Pattern: (intrinsic_wo_chain:v4f32 68:i32, VRRC:v4i32:$vB, (imm:i32):$UIMM) 04031 // Emits: (VCFSX:v4f32 (imm:i32):$UIMM, VRRC:v4i32:$vB) 04032 // Pattern complexity = 7 cost = 1 04033 if (CN0 == 68) { 04034 N1 = N.getOperand(1); 04035 N2 = N.getOperand(2); 04036 if (N2.getOpcode() == ISD::Constant) { 04037 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N2)->getValue(); 04038 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 04039 Select(Tmp2, N1); 04040 if (N.Val->hasOneUse()) { 04041 Result = CurDAG->SelectNodeTo(N.Val, PPC::VCFSX, MVT::v4f32, Tmp1, Tmp2); 04042 } else { 04043 ResNode = CurDAG->getTargetNode(PPC::VCFSX, MVT::v4f32, Tmp1, Tmp2); 04044 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04045 Result = SDOperand(ResNode, 0); 04046 } 04047 return; 04048 } 04049 } 04050 04051 // Pattern: (intrinsic_wo_chain:v4f32 69:i32, VRRC:v4i32:$vB, (imm:i32):$UIMM) 04052 // Emits: (VCFUX:v4f32 (imm:i32):$UIMM, VRRC:v4i32:$vB) 04053 // Pattern complexity = 7 cost = 1 04054 if (CN0 == 69) { 04055 N1 = N.getOperand(1); 04056 N2 = N.getOperand(2); 04057 if (N2.getOpcode() == ISD::Constant) { 04058 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N2)->getValue(); 04059 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 04060 Select(Tmp2, N1); 04061 if (N.Val->hasOneUse()) { 04062 Result = CurDAG->SelectNodeTo(N.Val, PPC::VCFUX, MVT::v4f32, Tmp1, Tmp2); 04063 } else { 04064 ResNode = CurDAG->getTargetNode(PPC::VCFUX, MVT::v4f32, Tmp1, Tmp2); 04065 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04066 Result = SDOperand(ResNode, 0); 04067 } 04068 return; 04069 } 04070 } 04071 04072 // Pattern: (intrinsic_wo_chain:v4i32 96:i32, VRRC:v4f32:$vB, (imm:i32):$UIMM) 04073 // Emits: (VCTSXS:v4i32 (imm:i32):$UIMM, VRRC:v4f32:$vB) 04074 // Pattern complexity = 7 cost = 1 04075 if (CN0 == 96) { 04076 N1 = N.getOperand(1); 04077 N2 = N.getOperand(2); 04078 if (N2.getOpcode() == ISD::Constant) { 04079 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N2)->getValue(); 04080 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 04081 Select(Tmp2, N1); 04082 if (N.Val->hasOneUse()) { 04083 Result = CurDAG->SelectNodeTo(N.Val, PPC::VCTSXS, MVT::v4i32, Tmp1, Tmp2); 04084 } else { 04085 ResNode = CurDAG->getTargetNode(PPC::VCTSXS, MVT::v4i32, Tmp1, Tmp2); 04086 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04087 Result = SDOperand(ResNode, 0); 04088 } 04089 return; 04090 } 04091 } 04092 04093 // Pattern: (intrinsic_wo_chain:v4i32 97:i32, VRRC:v4f32:$vB, (imm:i32):$UIMM) 04094 // Emits: (VCTUXS:v4i32 (imm:i32):$UIMM, VRRC:v4f32:$vB) 04095 // Pattern complexity = 7 cost = 1 04096 if (CN0 == 97) { 04097 N1 = N.getOperand(1); 04098 N2 = N.getOperand(2); 04099 if (N2.getOpcode() == ISD::Constant) { 04100 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N2)->getValue(); 04101 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 04102 Select(Tmp2, N1); 04103 if (N.Val->hasOneUse()) { 04104 Result = CurDAG->SelectNodeTo(N.Val, PPC::VCTUXS, MVT::v4i32, Tmp1, Tmp2); 04105 } else { 04106 ResNode = CurDAG->getTargetNode(PPC::VCTUXS, MVT::v4i32, Tmp1, Tmp2); 04107 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04108 Result = SDOperand(ResNode, 0); 04109 } 04110 return; 04111 } 04112 } 04113 04114 // Pattern: (intrinsic_wo_chain:v8i16 108:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v8i16:$vC) 04115 // Emits: (VMHADDSHS:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v8i16:$vC) 04116 // Pattern complexity = 5 cost = 1 04117 if (CN0 == 108) { 04118 N1 = N.getOperand(1); 04119 N2 = N.getOperand(2); 04120 N3 = N.getOperand(3); 04121 Select(Tmp1, N1); 04122 Select(Tmp2, N2); 04123 Select(Tmp3, N3); 04124 if (N.Val->hasOneUse()) { 04125 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMHADDSHS, MVT::v8i16, Tmp1, Tmp2, Tmp3); 04126 } else { 04127 ResNode = CurDAG->getTargetNode(PPC::VMHADDSHS, MVT::v8i16, Tmp1, Tmp2, Tmp3); 04128 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04129 Result = SDOperand(ResNode, 0); 04130 } 04131 return; 04132 } 04133 04134 // Pattern: (intrinsic_wo_chain:v8i16 109:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v8i16:$vC) 04135 // Emits: (VMHRADDSHS:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v8i16:$vC) 04136 // Pattern complexity = 5 cost = 1 04137 if (CN0 == 109) { 04138 N1 = N.getOperand(1); 04139 N2 = N.getOperand(2); 04140 N3 = N.getOperand(3); 04141 Select(Tmp1, N1); 04142 Select(Tmp2, N2); 04143 Select(Tmp3, N3); 04144 if (N.Val->hasOneUse()) { 04145 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMHRADDSHS, MVT::v8i16, Tmp1, Tmp2, Tmp3); 04146 } else { 04147 ResNode = CurDAG->getTargetNode(PPC::VMHRADDSHS, MVT::v8i16, Tmp1, Tmp2, Tmp3); 04148 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04149 Result = SDOperand(ResNode, 0); 04150 } 04151 return; 04152 } 04153 04154 // Pattern: (intrinsic_wo_chain:v8i16 117:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v8i16:$vC) 04155 // Emits: (VMLADDUHM:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v8i16:$vC) 04156 // Pattern complexity = 5 cost = 1 04157 if (CN0 == 117) { 04158 N1 = N.getOperand(1); 04159 N2 = N.getOperand(2); 04160 N3 = N.getOperand(3); 04161 Select(Tmp1, N1); 04162 Select(Tmp2, N2); 04163 Select(Tmp3, N3); 04164 if (N.Val->hasOneUse()) { 04165 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMLADDUHM, MVT::v8i16, Tmp1, Tmp2, Tmp3); 04166 } else { 04167 ResNode = CurDAG->getTargetNode(PPC::VMLADDUHM, MVT::v8i16, Tmp1, Tmp2, Tmp3); 04168 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04169 Result = SDOperand(ResNode, 0); 04170 } 04171 return; 04172 } 04173 04174 // Pattern: (intrinsic_wo_chain:v4i32 133:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB, VRRC:v16i8:$vC) 04175 // Emits: (VPERM:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, VRRC:v16i8:$vC) 04176 // Pattern complexity = 5 cost = 1 04177 if (CN0 == 133) { 04178 N1 = N.getOperand(1); 04179 N2 = N.getOperand(2); 04180 N3 = N.getOperand(3); 04181 Select(Tmp1, N1); 04182 Select(Tmp2, N2); 04183 Select(Tmp3, N3); 04184 if (N.Val->hasOneUse()) { 04185 Result = CurDAG->SelectNodeTo(N.Val, PPC::VPERM, MVT::v4i32, Tmp1, Tmp2, Tmp3); 04186 } else { 04187 ResNode = CurDAG->getTargetNode(PPC::VPERM, MVT::v4i32, Tmp1, Tmp2, Tmp3); 04188 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04189 Result = SDOperand(ResNode, 0); 04190 } 04191 return; 04192 } 04193 04194 // Pattern: (intrinsic_wo_chain:v4i32 150:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB, VRRC:v4i32:$vC) 04195 // Emits: (VSEL:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, VRRC:v4i32:$vC) 04196 // Pattern complexity = 5 cost = 1 04197 if (CN0 == 150) { 04198 N1 = N.getOperand(1); 04199 N2 = N.getOperand(2); 04200 N3 = N.getOperand(3); 04201 Select(Tmp1, N1); 04202 Select(Tmp2, N2); 04203 Select(Tmp3, N3); 04204 if (N.Val->hasOneUse()) { 04205 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSEL, MVT::v4i32, Tmp1, Tmp2, Tmp3); 04206 } else { 04207 ResNode = CurDAG->getTargetNode(PPC::VSEL, MVT::v4i32, Tmp1, Tmp2, Tmp3); 04208 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04209 Result = SDOperand(ResNode, 0); 04210 } 04211 return; 04212 } 04213 04214 // Pattern: (intrinsic_wo_chain:v4i32 55:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04215 // Emits: (VADDCUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04216 // Pattern complexity = 5 cost = 1 04217 if (CN0 == 55) { 04218 N1 = N.getOperand(1); 04219 N2 = N.getOperand(2); 04220 Select(Tmp1, N1); 04221 Select(Tmp2, N2); 04222 if (N.Val->hasOneUse()) { 04223 Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDCUW, MVT::v4i32, Tmp1, Tmp2); 04224 } else { 04225 ResNode = CurDAG->getTargetNode(PPC::VADDCUW, MVT::v4i32, Tmp1, Tmp2); 04226 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04227 Result = SDOperand(ResNode, 0); 04228 } 04229 return; 04230 } 04231 04232 // Pattern: (intrinsic_wo_chain:v16i8 56:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04233 // Emits: (VADDSBS:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04234 // Pattern complexity = 5 cost = 1 04235 if (CN0 == 56) { 04236 N1 = N.getOperand(1); 04237 N2 = N.getOperand(2); 04238 Select(Tmp1, N1); 04239 Select(Tmp2, N2); 04240 if (N.Val->hasOneUse()) { 04241 Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDSBS, MVT::v16i8, Tmp1, Tmp2); 04242 } else { 04243 ResNode = CurDAG->getTargetNode(PPC::VADDSBS, MVT::v16i8, Tmp1, Tmp2); 04244 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04245 Result = SDOperand(ResNode, 0); 04246 } 04247 return; 04248 } 04249 04250 // Pattern: (intrinsic_wo_chain:v8i16 57:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04251 // Emits: (VADDSHS:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04252 // Pattern complexity = 5 cost = 1 04253 if (CN0 == 57) { 04254 N1 = N.getOperand(1); 04255 N2 = N.getOperand(2); 04256 Select(Tmp1, N1); 04257 Select(Tmp2, N2); 04258 if (N.Val->hasOneUse()) { 04259 Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDSHS, MVT::v8i16, Tmp1, Tmp2); 04260 } else { 04261 ResNode = CurDAG->getTargetNode(PPC::VADDSHS, MVT::v8i16, Tmp1, Tmp2); 04262 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04263 Result = SDOperand(ResNode, 0); 04264 } 04265 return; 04266 } 04267 04268 // Pattern: (intrinsic_wo_chain:v4i32 58:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04269 // Emits: (VADDSWS:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04270 // Pattern complexity = 5 cost = 1 04271 if (CN0 == 58) { 04272 N1 = N.getOperand(1); 04273 N2 = N.getOperand(2); 04274 Select(Tmp1, N1); 04275 Select(Tmp2, N2); 04276 if (N.Val->hasOneUse()) { 04277 Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDSWS, MVT::v4i32, Tmp1, Tmp2); 04278 } else { 04279 ResNode = CurDAG->getTargetNode(PPC::VADDSWS, MVT::v4i32, Tmp1, Tmp2); 04280 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04281 Result = SDOperand(ResNode, 0); 04282 } 04283 return; 04284 } 04285 04286 // Pattern: (intrinsic_wo_chain:v16i8 59:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04287 // Emits: (VADDUBS:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04288 // Pattern complexity = 5 cost = 1 04289 if (CN0 == 59) { 04290 N1 = N.getOperand(1); 04291 N2 = N.getOperand(2); 04292 Select(Tmp1, N1); 04293 Select(Tmp2, N2); 04294 if (N.Val->hasOneUse()) { 04295 Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDUBS, MVT::v16i8, Tmp1, Tmp2); 04296 } else { 04297 ResNode = CurDAG->getTargetNode(PPC::VADDUBS, MVT::v16i8, Tmp1, Tmp2); 04298 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04299 Result = SDOperand(ResNode, 0); 04300 } 04301 return; 04302 } 04303 04304 // Pattern: (intrinsic_wo_chain:v8i16 60:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04305 // Emits: (VADDUHS:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04306 // Pattern complexity = 5 cost = 1 04307 if (CN0 == 60) { 04308 N1 = N.getOperand(1); 04309 N2 = N.getOperand(2); 04310 Select(Tmp1, N1); 04311 Select(Tmp2, N2); 04312 if (N.Val->hasOneUse()) { 04313 Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDUHS, MVT::v8i16, Tmp1, Tmp2); 04314 } else { 04315 ResNode = CurDAG->getTargetNode(PPC::VADDUHS, MVT::v8i16, Tmp1, Tmp2); 04316 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04317 Result = SDOperand(ResNode, 0); 04318 } 04319 return; 04320 } 04321 04322 // Pattern: (intrinsic_wo_chain:v4i32 61:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04323 // Emits: (VADDUWS:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04324 // Pattern complexity = 5 cost = 1 04325 if (CN0 == 61) { 04326 N1 = N.getOperand(1); 04327 N2 = N.getOperand(2); 04328 Select(Tmp1, N1); 04329 Select(Tmp2, N2); 04330 if (N.Val->hasOneUse()) { 04331 Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDUWS, MVT::v4i32, Tmp1, Tmp2); 04332 } else { 04333 ResNode = CurDAG->getTargetNode(PPC::VADDUWS, MVT::v4i32, Tmp1, Tmp2); 04334 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04335 Result = SDOperand(ResNode, 0); 04336 } 04337 return; 04338 } 04339 04340 // Pattern: (intrinsic_wo_chain:v4f32 98:i32, VRRC:v4f32:$vB) 04341 // Emits: (VEXPTEFP:v4f32 VRRC:v4f32:$vB) 04342 // Pattern complexity = 5 cost = 1 04343 if (CN0 == 98) { 04344 N1 = N.getOperand(1); 04345 Select(Tmp1, N1); 04346 if (N.Val->hasOneUse()) { 04347 Result = CurDAG->SelectNodeTo(N.Val, PPC::VEXPTEFP, MVT::v4f32, Tmp1); 04348 } else { 04349 ResNode = CurDAG->getTargetNode(PPC::VEXPTEFP, MVT::v4f32, Tmp1); 04350 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04351 Result = SDOperand(ResNode, 0); 04352 } 04353 return; 04354 } 04355 04356 // Pattern: (intrinsic_wo_chain:v4f32 99:i32, VRRC:v4f32:$vB) 04357 // Emits: (VLOGEFP:v4f32 VRRC:v4f32:$vB) 04358 // Pattern complexity = 5 cost = 1 04359 if (CN0 == 99) { 04360 N1 = N.getOperand(1); 04361 Select(Tmp1, N1); 04362 if (N.Val->hasOneUse()) { 04363 Result = CurDAG->SelectNodeTo(N.Val, PPC::VLOGEFP, MVT::v4f32, Tmp1); 04364 } else { 04365 ResNode = CurDAG->getTargetNode(PPC::VLOGEFP, MVT::v4f32, Tmp1); 04366 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04367 Result = SDOperand(ResNode, 0); 04368 } 04369 return; 04370 } 04371 04372 // Pattern: (intrinsic_wo_chain:v16i8 62:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04373 // Emits: (VAVGSB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04374 // Pattern complexity = 5 cost = 1 04375 if (CN0 == 62) { 04376 N1 = N.getOperand(1); 04377 N2 = N.getOperand(2); 04378 Select(Tmp1, N1); 04379 Select(Tmp2, N2); 04380 if (N.Val->hasOneUse()) { 04381 Result = CurDAG->SelectNodeTo(N.Val, PPC::VAVGSB, MVT::v16i8, Tmp1, Tmp2); 04382 } else { 04383 ResNode = CurDAG->getTargetNode(PPC::VAVGSB, MVT::v16i8, Tmp1, Tmp2); 04384 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04385 Result = SDOperand(ResNode, 0); 04386 } 04387 return; 04388 } 04389 04390 // Pattern: (intrinsic_wo_chain:v8i16 63:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04391 // Emits: (VAVGSH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04392 // Pattern complexity = 5 cost = 1 04393 if (CN0 == 63) { 04394 N1 = N.getOperand(1); 04395 N2 = N.getOperand(2); 04396 Select(Tmp1, N1); 04397 Select(Tmp2, N2); 04398 if (N.Val->hasOneUse()) { 04399 Result = CurDAG->SelectNodeTo(N.Val, PPC::VAVGSH, MVT::v8i16, Tmp1, Tmp2); 04400 } else { 04401 ResNode = CurDAG->getTargetNode(PPC::VAVGSH, MVT::v8i16, Tmp1, Tmp2); 04402 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04403 Result = SDOperand(ResNode, 0); 04404 } 04405 return; 04406 } 04407 04408 // Pattern: (intrinsic_wo_chain:v4i32 64:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04409 // Emits: (VAVGSW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04410 // Pattern complexity = 5 cost = 1 04411 if (CN0 == 64) { 04412 N1 = N.getOperand(1); 04413 N2 = N.getOperand(2); 04414 Select(Tmp1, N1); 04415 Select(Tmp2, N2); 04416 if (N.Val->hasOneUse()) { 04417 Result = CurDAG->SelectNodeTo(N.Val, PPC::VAVGSW, MVT::v4i32, Tmp1, Tmp2); 04418 } else { 04419 ResNode = CurDAG->getTargetNode(PPC::VAVGSW, MVT::v4i32, Tmp1, Tmp2); 04420 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04421 Result = SDOperand(ResNode, 0); 04422 } 04423 return; 04424 } 04425 04426 // Pattern: (intrinsic_wo_chain:v16i8 65:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04427 // Emits: (VAVGUB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04428 // Pattern complexity = 5 cost = 1 04429 if (CN0 == 65) { 04430 N1 = N.getOperand(1); 04431 N2 = N.getOperand(2); 04432 Select(Tmp1, N1); 04433 Select(Tmp2, N2); 04434 if (N.Val->hasOneUse()) { 04435 Result = CurDAG->SelectNodeTo(N.Val, PPC::VAVGUB, MVT::v16i8, Tmp1, Tmp2); 04436 } else { 04437 ResNode = CurDAG->getTargetNode(PPC::VAVGUB, MVT::v16i8, Tmp1, Tmp2); 04438 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04439 Result = SDOperand(ResNode, 0); 04440 } 04441 return; 04442 } 04443 04444 // Pattern: (intrinsic_wo_chain:v8i16 66:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04445 // Emits: (VAVGUH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04446 // Pattern complexity = 5 cost = 1 04447 if (CN0 == 66) { 04448 N1 = N.getOperand(1); 04449 N2 = N.getOperand(2); 04450 Select(Tmp1, N1); 04451 Select(Tmp2, N2); 04452 if (N.Val->hasOneUse()) { 04453 Result = CurDAG->SelectNodeTo(N.Val, PPC::VAVGUH, MVT::v8i16, Tmp1, Tmp2); 04454 } else { 04455 ResNode = CurDAG->getTargetNode(PPC::VAVGUH, MVT::v8i16, Tmp1, Tmp2); 04456 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04457 Result = SDOperand(ResNode, 0); 04458 } 04459 return; 04460 } 04461 04462 // Pattern: (intrinsic_wo_chain:v4i32 67:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04463 // Emits: (VAVGUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04464 // Pattern complexity = 5 cost = 1 04465 if (CN0 == 67) { 04466 N1 = N.getOperand(1); 04467 N2 = N.getOperand(2); 04468 Select(Tmp1, N1); 04469 Select(Tmp2, N2); 04470 if (N.Val->hasOneUse()) { 04471 Result = CurDAG->SelectNodeTo(N.Val, PPC::VAVGUW, MVT::v4i32, Tmp1, Tmp2); 04472 } else { 04473 ResNode = CurDAG->getTargetNode(PPC::VAVGUW, MVT::v4i32, Tmp1, Tmp2); 04474 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04475 Result = SDOperand(ResNode, 0); 04476 } 04477 return; 04478 } 04479 04480 // Pattern: (intrinsic_wo_chain:v4f32 101:i32, VRRC:v4f32:$vA, VRRC:v4f32:$vB) 04481 // Emits: (VMAXFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 04482 // Pattern complexity = 5 cost = 1 04483 if (CN0 == 101) { 04484 N1 = N.getOperand(1); 04485 N2 = N.getOperand(2); 04486 Select(Tmp1, N1); 04487 Select(Tmp2, N2); 04488 if (N.Val->hasOneUse()) { 04489 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMAXFP, MVT::v4f32, Tmp1, Tmp2); 04490 } else { 04491 ResNode = CurDAG->getTargetNode(PPC::VMAXFP, MVT::v4f32, Tmp1, Tmp2); 04492 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04493 Result = SDOperand(ResNode, 0); 04494 } 04495 return; 04496 } 04497 04498 // Pattern: (intrinsic_wo_chain:v16i8 102:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04499 // Emits: (VMAXSB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04500 // Pattern complexity = 5 cost = 1 04501 if (CN0 == 102) { 04502 N1 = N.getOperand(1); 04503 N2 = N.getOperand(2); 04504 Select(Tmp1, N1); 04505 Select(Tmp2, N2); 04506 if (N.Val->hasOneUse()) { 04507 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMAXSB, MVT::v16i8, Tmp1, Tmp2); 04508 } else { 04509 ResNode = CurDAG->getTargetNode(PPC::VMAXSB, MVT::v16i8, Tmp1, Tmp2); 04510 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04511 Result = SDOperand(ResNode, 0); 04512 } 04513 return; 04514 } 04515 04516 // Pattern: (intrinsic_wo_chain:v8i16 103:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04517 // Emits: (VMAXSH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04518 // Pattern complexity = 5 cost = 1 04519 if (CN0 == 103) { 04520 N1 = N.getOperand(1); 04521 N2 = N.getOperand(2); 04522 Select(Tmp1, N1); 04523 Select(Tmp2, N2); 04524 if (N.Val->hasOneUse()) { 04525 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMAXSH, MVT::v8i16, Tmp1, Tmp2); 04526 } else { 04527 ResNode = CurDAG->getTargetNode(PPC::VMAXSH, MVT::v8i16, Tmp1, Tmp2); 04528 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04529 Result = SDOperand(ResNode, 0); 04530 } 04531 return; 04532 } 04533 04534 // Pattern: (intrinsic_wo_chain:v4i32 104:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04535 // Emits: (VMAXSW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04536 // Pattern complexity = 5 cost = 1 04537 if (CN0 == 104) { 04538 N1 = N.getOperand(1); 04539 N2 = N.getOperand(2); 04540 Select(Tmp1, N1); 04541 Select(Tmp2, N2); 04542 if (N.Val->hasOneUse()) { 04543 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMAXSW, MVT::v4i32, Tmp1, Tmp2); 04544 } else { 04545 ResNode = CurDAG->getTargetNode(PPC::VMAXSW, MVT::v4i32, Tmp1, Tmp2); 04546 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04547 Result = SDOperand(ResNode, 0); 04548 } 04549 return; 04550 } 04551 04552 // Pattern: (intrinsic_wo_chain:v16i8 105:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04553 // Emits: (VMAXUB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04554 // Pattern complexity = 5 cost = 1 04555 if (CN0 == 105) { 04556 N1 = N.getOperand(1); 04557 N2 = N.getOperand(2); 04558 Select(Tmp1, N1); 04559 Select(Tmp2, N2); 04560 if (N.Val->hasOneUse()) { 04561 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMAXUB, MVT::v16i8, Tmp1, Tmp2); 04562 } else { 04563 ResNode = CurDAG->getTargetNode(PPC::VMAXUB, MVT::v16i8, Tmp1, Tmp2); 04564 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04565 Result = SDOperand(ResNode, 0); 04566 } 04567 return; 04568 } 04569 04570 // Pattern: (intrinsic_wo_chain:v8i16 106:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04571 // Emits: (VMAXUH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04572 // Pattern complexity = 5 cost = 1 04573 if (CN0 == 106) { 04574 N1 = N.getOperand(1); 04575 N2 = N.getOperand(2); 04576 Select(Tmp1, N1); 04577 Select(Tmp2, N2); 04578 if (N.Val->hasOneUse()) { 04579 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMAXUH, MVT::v8i16, Tmp1, Tmp2); 04580 } else { 04581 ResNode = CurDAG->getTargetNode(PPC::VMAXUH, MVT::v8i16, Tmp1, Tmp2); 04582 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04583 Result = SDOperand(ResNode, 0); 04584 } 04585 return; 04586 } 04587 04588 // Pattern: (intrinsic_wo_chain:v4i32 107:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04589 // Emits: (VMAXUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04590 // Pattern complexity = 5 cost = 1 04591 if (CN0 == 107) { 04592 N1 = N.getOperand(1); 04593 N2 = N.getOperand(2); 04594 Select(Tmp1, N1); 04595 Select(Tmp2, N2); 04596 if (N.Val->hasOneUse()) { 04597 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMAXUW, MVT::v4i32, Tmp1, Tmp2); 04598 } else { 04599 ResNode = CurDAG->getTargetNode(PPC::VMAXUW, MVT::v4i32, Tmp1, Tmp2); 04600 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04601 Result = SDOperand(ResNode, 0); 04602 } 04603 return; 04604 } 04605 04606 // Pattern: (intrinsic_wo_chain:v4f32 110:i32, VRRC:v4f32:$vA, VRRC:v4f32:$vB) 04607 // Emits: (VMINFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 04608 // Pattern complexity = 5 cost = 1 04609 if (CN0 == 110) { 04610 N1 = N.getOperand(1); 04611 N2 = N.getOperand(2); 04612 Select(Tmp1, N1); 04613 Select(Tmp2, N2); 04614 if (N.Val->hasOneUse()) { 04615 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMINFP, MVT::v4f32, Tmp1, Tmp2); 04616 } else { 04617 ResNode = CurDAG->getTargetNode(PPC::VMINFP, MVT::v4f32, Tmp1, Tmp2); 04618 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04619 Result = SDOperand(ResNode, 0); 04620 } 04621 return; 04622 } 04623 04624 // Pattern: (intrinsic_wo_chain:v16i8 111:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04625 // Emits: (VMINSB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04626 // Pattern complexity = 5 cost = 1 04627 if (CN0 == 111) { 04628 N1 = N.getOperand(1); 04629 N2 = N.getOperand(2); 04630 Select(Tmp1, N1); 04631 Select(Tmp2, N2); 04632 if (N.Val->hasOneUse()) { 04633 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMINSB, MVT::v16i8, Tmp1, Tmp2); 04634 } else { 04635 ResNode = CurDAG->getTargetNode(PPC::VMINSB, MVT::v16i8, Tmp1, Tmp2); 04636 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04637 Result = SDOperand(ResNode, 0); 04638 } 04639 return; 04640 } 04641 04642 // Pattern: (intrinsic_wo_chain:v8i16 112:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04643 // Emits: (VMINSH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04644 // Pattern complexity = 5 cost = 1 04645 if (CN0 == 112) { 04646 N1 = N.getOperand(1); 04647 N2 = N.getOperand(2); 04648 Select(Tmp1, N1); 04649 Select(Tmp2, N2); 04650 if (N.Val->hasOneUse()) { 04651 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMINSH, MVT::v8i16, Tmp1, Tmp2); 04652 } else { 04653 ResNode = CurDAG->getTargetNode(PPC::VMINSH, MVT::v8i16, Tmp1, Tmp2); 04654 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04655 Result = SDOperand(ResNode, 0); 04656 } 04657 return; 04658 } 04659 04660 // Pattern: (intrinsic_wo_chain:v4i32 113:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04661 // Emits: (VMINSW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04662 // Pattern complexity = 5 cost = 1 04663 if (CN0 == 113) { 04664 N1 = N.getOperand(1); 04665 N2 = N.getOperand(2); 04666 Select(Tmp1, N1); 04667 Select(Tmp2, N2); 04668 if (N.Val->hasOneUse()) { 04669 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMINSW, MVT::v4i32, Tmp1, Tmp2); 04670 } else { 04671 ResNode = CurDAG->getTargetNode(PPC::VMINSW, MVT::v4i32, Tmp1, Tmp2); 04672 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04673 Result = SDOperand(ResNode, 0); 04674 } 04675 return; 04676 } 04677 04678 // Pattern: (intrinsic_wo_chain:v16i8 114:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04679 // Emits: (VMINUB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04680 // Pattern complexity = 5 cost = 1 04681 if (CN0 == 114) { 04682 N1 = N.getOperand(1); 04683 N2 = N.getOperand(2); 04684 Select(Tmp1, N1); 04685 Select(Tmp2, N2); 04686 if (N.Val->hasOneUse()) { 04687 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMINUB, MVT::v16i8, Tmp1, Tmp2); 04688 } else { 04689 ResNode = CurDAG->getTargetNode(PPC::VMINUB, MVT::v16i8, Tmp1, Tmp2); 04690 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04691 Result = SDOperand(ResNode, 0); 04692 } 04693 return; 04694 } 04695 04696 // Pattern: (intrinsic_wo_chain:v8i16 115:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04697 // Emits: (VMINUH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04698 // Pattern complexity = 5 cost = 1 04699 if (CN0 == 115) { 04700 N1 = N.getOperand(1); 04701 N2 = N.getOperand(2); 04702 Select(Tmp1, N1); 04703 Select(Tmp2, N2); 04704 if (N.Val->hasOneUse()) { 04705 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMINUH, MVT::v8i16, Tmp1, Tmp2); 04706 } else { 04707 ResNode = CurDAG->getTargetNode(PPC::VMINUH, MVT::v8i16, Tmp1, Tmp2); 04708 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04709 Result = SDOperand(ResNode, 0); 04710 } 04711 return; 04712 } 04713 04714 // Pattern: (intrinsic_wo_chain:v4i32 116:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04715 // Emits: (VMINUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04716 // Pattern complexity = 5 cost = 1 04717 if (CN0 == 116) { 04718 N1 = N.getOperand(1); 04719 N2 = N.getOperand(2); 04720 Select(Tmp1, N1); 04721 Select(Tmp2, N2); 04722 if (N.Val->hasOneUse()) { 04723 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMINUW, MVT::v4i32, Tmp1, Tmp2); 04724 } else { 04725 ResNode = CurDAG->getTargetNode(PPC::VMINUW, MVT::v4i32, Tmp1, Tmp2); 04726 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04727 Result = SDOperand(ResNode, 0); 04728 } 04729 return; 04730 } 04731 04732 // Pattern: (intrinsic_wo_chain:v4i32 118:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB, VRRC:v4i32:$vC) 04733 // Emits: (VMSUMMBM:v4i32 VRRC:v16i8:$vA, VRRC:v16i8:$vB, VRRC:v4i32:$vC) 04734 // Pattern complexity = 5 cost = 1 04735 if (CN0 == 118) { 04736 N1 = N.getOperand(1); 04737 N2 = N.getOperand(2); 04738 N3 = N.getOperand(3); 04739 Select(Tmp1, N1); 04740 Select(Tmp2, N2); 04741 Select(Tmp3, N3); 04742 if (N.Val->hasOneUse()) { 04743 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMSUMMBM, MVT::v4i32, Tmp1, Tmp2, Tmp3); 04744 } else { 04745 ResNode = CurDAG->getTargetNode(PPC::VMSUMMBM, MVT::v4i32, Tmp1, Tmp2, Tmp3); 04746 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04747 Result = SDOperand(ResNode, 0); 04748 } 04749 return; 04750 } 04751 04752 // Pattern: (intrinsic_wo_chain:v4i32 119:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC) 04753 // Emits: (VMSUMSHM:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC) 04754 // Pattern complexity = 5 cost = 1 04755 if (CN0 == 119) { 04756 N1 = N.getOperand(1); 04757 N2 = N.getOperand(2); 04758 N3 = N.getOperand(3); 04759 Select(Tmp1, N1); 04760 Select(Tmp2, N2); 04761 Select(Tmp3, N3); 04762 if (N.Val->hasOneUse()) { 04763 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMSUMSHM, MVT::v4i32, Tmp1, Tmp2, Tmp3); 04764 } else { 04765 ResNode = CurDAG->getTargetNode(PPC::VMSUMSHM, MVT::v4i32, Tmp1, Tmp2, Tmp3); 04766 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04767 Result = SDOperand(ResNode, 0); 04768 } 04769 return; 04770 } 04771 04772 // Pattern: (intrinsic_wo_chain:v4i32 120:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC) 04773 // Emits: (VMSUMSHS:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC) 04774 // Pattern complexity = 5 cost = 1 04775 if (CN0 == 120) { 04776 N1 = N.getOperand(1); 04777 N2 = N.getOperand(2); 04778 N3 = N.getOperand(3); 04779 Select(Tmp1, N1); 04780 Select(Tmp2, N2); 04781 Select(Tmp3, N3); 04782 if (N.Val->hasOneUse()) { 04783 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMSUMSHS, MVT::v4i32, Tmp1, Tmp2, Tmp3); 04784 } else { 04785 ResNode = CurDAG->getTargetNode(PPC::VMSUMSHS, MVT::v4i32, Tmp1, Tmp2, Tmp3); 04786 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04787 Result = SDOperand(ResNode, 0); 04788 } 04789 return; 04790 } 04791 04792 // Pattern: (intrinsic_wo_chain:v4i32 121:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB, VRRC:v4i32:$vC) 04793 // Emits: (VMSUMUBM:v4i32 VRRC:v16i8:$vA, VRRC:v16i8:$vB, VRRC:v4i32:$vC) 04794 // Pattern complexity = 5 cost = 1 04795 if (CN0 == 121) { 04796 N1 = N.getOperand(1); 04797 N2 = N.getOperand(2); 04798 N3 = N.getOperand(3); 04799 Select(Tmp1, N1); 04800 Select(Tmp2, N2); 04801 Select(Tmp3, N3); 04802 if (N.Val->hasOneUse()) { 04803 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMSUMUBM, MVT::v4i32, Tmp1, Tmp2, Tmp3); 04804 } else { 04805 ResNode = CurDAG->getTargetNode(PPC::VMSUMUBM, MVT::v4i32, Tmp1, Tmp2, Tmp3); 04806 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04807 Result = SDOperand(ResNode, 0); 04808 } 04809 return; 04810 } 04811 04812 // Pattern: (intrinsic_wo_chain:v4i32 122:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC) 04813 // Emits: (VMSUMUHM:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC) 04814 // Pattern complexity = 5 cost = 1 04815 if (CN0 == 122) { 04816 N1 = N.getOperand(1); 04817 N2 = N.getOperand(2); 04818 N3 = N.getOperand(3); 04819 Select(Tmp1, N1); 04820 Select(Tmp2, N2); 04821 Select(Tmp3, N3); 04822 if (N.Val->hasOneUse()) { 04823 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMSUMUHM, MVT::v4i32, Tmp1, Tmp2, Tmp3); 04824 } else { 04825 ResNode = CurDAG->getTargetNode(PPC::VMSUMUHM, MVT::v4i32, Tmp1, Tmp2, Tmp3); 04826 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04827 Result = SDOperand(ResNode, 0); 04828 } 04829 return; 04830 } 04831 04832 // Pattern: (intrinsic_wo_chain:v4i32 123:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC) 04833 // Emits: (VMSUMUHS:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC) 04834 // Pattern complexity = 5 cost = 1 04835 if (CN0 == 123) { 04836 N1 = N.getOperand(1); 04837 N2 = N.getOperand(2); 04838 N3 = N.getOperand(3); 04839 Select(Tmp1, N1); 04840 Select(Tmp2, N2); 04841 Select(Tmp3, N3); 04842 if (N.Val->hasOneUse()) { 04843 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMSUMUHS, MVT::v4i32, Tmp1, Tmp2, Tmp3); 04844 } else { 04845 ResNode = CurDAG->getTargetNode(PPC::VMSUMUHS, MVT::v4i32, Tmp1, Tmp2, Tmp3); 04846 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04847 Result = SDOperand(ResNode, 0); 04848 } 04849 return; 04850 } 04851 04852 // Pattern: (intrinsic_wo_chain:v8i16 124:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04853 // Emits: (VMULESB:v8i16 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04854 // Pattern complexity = 5 cost = 1 04855 if (CN0 == 124) { 04856 N1 = N.getOperand(1); 04857 N2 = N.getOperand(2); 04858 Select(Tmp1, N1); 04859 Select(Tmp2, N2); 04860 if (N.Val->hasOneUse()) { 04861 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMULESB, MVT::v8i16, Tmp1, Tmp2); 04862 } else { 04863 ResNode = CurDAG->getTargetNode(PPC::VMULESB, MVT::v8i16, Tmp1, Tmp2); 04864 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04865 Result = SDOperand(ResNode, 0); 04866 } 04867 return; 04868 } 04869 04870 // Pattern: (intrinsic_wo_chain:v4i32 125:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04871 // Emits: (VMULESH:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04872 // Pattern complexity = 5 cost = 1 04873 if (CN0 == 125) { 04874 N1 = N.getOperand(1); 04875 N2 = N.getOperand(2); 04876 Select(Tmp1, N1); 04877 Select(Tmp2, N2); 04878 if (N.Val->hasOneUse()) { 04879 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMULESH, MVT::v4i32, Tmp1, Tmp2); 04880 } else { 04881 ResNode = CurDAG->getTargetNode(PPC::VMULESH, MVT::v4i32, Tmp1, Tmp2); 04882 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04883 Result = SDOperand(ResNode, 0); 04884 } 04885 return; 04886 } 04887 04888 // Pattern: (intrinsic_wo_chain:v8i16 126:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04889 // Emits: (VMULEUB:v8i16 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04890 // Pattern complexity = 5 cost = 1 04891 if (CN0 == 126) { 04892 N1 = N.getOperand(1); 04893 N2 = N.getOperand(2); 04894 Select(Tmp1, N1); 04895 Select(Tmp2, N2); 04896 if (N.Val->hasOneUse()) { 04897 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMULEUB, MVT::v8i16, Tmp1, Tmp2); 04898 } else { 04899 ResNode = CurDAG->getTargetNode(PPC::VMULEUB, MVT::v8i16, Tmp1, Tmp2); 04900 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04901 Result = SDOperand(ResNode, 0); 04902 } 04903 return; 04904 } 04905 04906 // Pattern: (intrinsic_wo_chain:v4i32 127:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04907 // Emits: (VMULEUH:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04908 // Pattern complexity = 5 cost = 1 04909 if (CN0 == 127) { 04910 N1 = N.getOperand(1); 04911 N2 = N.getOperand(2); 04912 Select(Tmp1, N1); 04913 Select(Tmp2, N2); 04914 if (N.Val->hasOneUse()) { 04915 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMULEUH, MVT::v4i32, Tmp1, Tmp2); 04916 } else { 04917 ResNode = CurDAG->getTargetNode(PPC::VMULEUH, MVT::v4i32, Tmp1, Tmp2); 04918 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04919 Result = SDOperand(ResNode, 0); 04920 } 04921 return; 04922 } 04923 04924 // Pattern: (intrinsic_wo_chain:v8i16 128:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04925 // Emits: (VMULOSB:v8i16 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04926 // Pattern complexity = 5 cost = 1 04927 if (CN0 == 128) { 04928 N1 = N.getOperand(1); 04929 N2 = N.getOperand(2); 04930 Select(Tmp1, N1); 04931 Select(Tmp2, N2); 04932 if (N.Val->hasOneUse()) { 04933 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMULOSB, MVT::v8i16, Tmp1, Tmp2); 04934 } else { 04935 ResNode = CurDAG->getTargetNode(PPC::VMULOSB, MVT::v8i16, Tmp1, Tmp2); 04936 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04937 Result = SDOperand(ResNode, 0); 04938 } 04939 return; 04940 } 04941 04942 // Pattern: (intrinsic_wo_chain:v4i32 129:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04943 // Emits: (VMULOSH:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04944 // Pattern complexity = 5 cost = 1 04945 if (CN0 == 129) { 04946 N1 = N.getOperand(1); 04947 N2 = N.getOperand(2); 04948 Select(Tmp1, N1); 04949 Select(Tmp2, N2); 04950 if (N.Val->hasOneUse()) { 04951 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMULOSH, MVT::v4i32, Tmp1, Tmp2); 04952 } else { 04953 ResNode = CurDAG->getTargetNode(PPC::VMULOSH, MVT::v4i32, Tmp1, Tmp2); 04954 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04955 Result = SDOperand(ResNode, 0); 04956 } 04957 return; 04958 } 04959 04960 // Pattern: (intrinsic_wo_chain:v8i16 130:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04961 // Emits: (VMULOUB:v8i16 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04962 // Pattern complexity = 5 cost = 1 04963 if (CN0 == 130) { 04964 N1 = N.getOperand(1); 04965 N2 = N.getOperand(2); 04966 Select(Tmp1, N1); 04967 Select(Tmp2, N2); 04968 if (N.Val->hasOneUse()) { 04969 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMULOUB, MVT::v8i16, Tmp1, Tmp2); 04970 } else { 04971 ResNode = CurDAG->getTargetNode(PPC::VMULOUB, MVT::v8i16, Tmp1, Tmp2); 04972 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04973 Result = SDOperand(ResNode, 0); 04974 } 04975 return; 04976 } 04977 04978 // Pattern: (intrinsic_wo_chain:v4i32 131:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04979 // Emits: (VMULOUH:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 04980 // Pattern complexity = 5 cost = 1 04981 if (CN0 == 131) { 04982 N1 = N.getOperand(1); 04983 N2 = N.getOperand(2); 04984 Select(Tmp1, N1); 04985 Select(Tmp2, N2); 04986 if (N.Val->hasOneUse()) { 04987 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMULOUH, MVT::v4i32, Tmp1, Tmp2); 04988 } else { 04989 ResNode = CurDAG->getTargetNode(PPC::VMULOUH, MVT::v4i32, Tmp1, Tmp2); 04990 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04991 Result = SDOperand(ResNode, 0); 04992 } 04993 return; 04994 } 04995 04996 // Pattern: (intrinsic_wo_chain:v4f32 141:i32, VRRC:v4f32:$vB) 04997 // Emits: (VREFP:v4f32 VRRC:v4f32:$vB) 04998 // Pattern complexity = 5 cost = 1 04999 if (CN0 == 141) { 05000 N1 = N.getOperand(1); 05001 Select(Tmp1, N1); 05002 if (N.Val->hasOneUse()) { 05003 Result = CurDAG->SelectNodeTo(N.Val, PPC::VREFP, MVT::v4f32, Tmp1); 05004 } else { 05005 ResNode = CurDAG->getTargetNode(PPC::VREFP, MVT::v4f32, Tmp1); 05006 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05007 Result = SDOperand(ResNode, 0); 05008 } 05009 return; 05010 } 05011 05012 // Pattern: (intrinsic_wo_chain:v4f32 142:i32, VRRC:v4f32:$vB) 05013 // Emits: (VRFIM:v4f32 VRRC:v4f32:$vB) 05014 // Pattern complexity = 5 cost = 1 05015 if (CN0 == 142) { 05016 N1 = N.getOperand(1); 05017 Select(Tmp1, N1); 05018 if (N.Val->hasOneUse()) { 05019 Result = CurDAG->SelectNodeTo(N.Val, PPC::VRFIM, MVT::v4f32, Tmp1); 05020 } else { 05021 ResNode = CurDAG->getTargetNode(PPC::VRFIM, MVT::v4f32, Tmp1); 05022 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05023 Result = SDOperand(ResNode, 0); 05024 } 05025 return; 05026 } 05027 05028 // Pattern: (intrinsic_wo_chain:v4f32 143:i32, VRRC:v4f32:$vB) 05029 // Emits: (VRFIN:v4f32 VRRC:v4f32:$vB) 05030 // Pattern complexity = 5 cost = 1 05031 if (CN0 == 143) { 05032 N1 = N.getOperand(1); 05033 Select(Tmp1, N1); 05034 if (N.Val->hasOneUse()) { 05035 Result = CurDAG->SelectNodeTo(N.Val, PPC::VRFIN, MVT::v4f32, Tmp1); 05036 } else { 05037 ResNode = CurDAG->getTargetNode(PPC::VRFIN, MVT::v4f32, Tmp1); 05038 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05039 Result = SDOperand(ResNode, 0); 05040 } 05041 return; 05042 } 05043 05044 // Pattern: (intrinsic_wo_chain:v4f32 144:i32, VRRC:v4f32:$vB) 05045 // Emits: (VRFIP:v4f32 VRRC:v4f32:$vB) 05046 // Pattern complexity = 5 cost = 1 05047 if (CN0 == 144) { 05048 N1 = N.getOperand(1); 05049 Select(Tmp1, N1); 05050 if (N.Val->hasOneUse()) { 05051 Result = CurDAG->SelectNodeTo(N.Val, PPC::VRFIP, MVT::v4f32, Tmp1); 05052 } else { 05053 ResNode = CurDAG->getTargetNode(PPC::VRFIP, MVT::v4f32, Tmp1); 05054 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05055 Result = SDOperand(ResNode, 0); 05056 } 05057 return; 05058 } 05059 05060 // Pattern: (intrinsic_wo_chain:v4f32 145:i32, VRRC:v4f32:$vB) 05061 // Emits: (VRFIZ:v4f32 VRRC:v4f32:$vB) 05062 // Pattern complexity = 5 cost = 1 05063 if (CN0 == 145) { 05064 N1 = N.getOperand(1); 05065 Select(Tmp1, N1); 05066 if (N.Val->hasOneUse()) { 05067 Result = CurDAG->SelectNodeTo(N.Val, PPC::VRFIZ, MVT::v4f32, Tmp1); 05068 } else { 05069 ResNode = CurDAG->getTargetNode(PPC::VRFIZ, MVT::v4f32, Tmp1); 05070 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05071 Result = SDOperand(ResNode, 0); 05072 } 05073 return; 05074 } 05075 05076 // Pattern: (intrinsic_wo_chain:v4f32 149:i32, VRRC:v4f32:$vB) 05077 // Emits: (VRSQRTEFP:v4f32 VRRC:v4f32:$vB) 05078 // Pattern complexity = 5 cost = 1 05079 if (CN0 == 149) { 05080 N1 = N.getOperand(1); 05081 Select(Tmp1, N1); 05082 if (N.Val->hasOneUse()) { 05083 Result = CurDAG->SelectNodeTo(N.Val, PPC::VRSQRTEFP, MVT::v4f32, Tmp1); 05084 } else { 05085 ResNode = CurDAG->getTargetNode(PPC::VRSQRTEFP, MVT::v4f32, Tmp1); 05086 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05087 Result = SDOperand(ResNode, 0); 05088 } 05089 return; 05090 } 05091 05092 // Pattern: (intrinsic_wo_chain:v4i32 164:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05093 // Emits: (VSUBCUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05094 // Pattern complexity = 5 cost = 1 05095 if (CN0 == 164) { 05096 N1 = N.getOperand(1); 05097 N2 = N.getOperand(2); 05098 Select(Tmp1, N1); 05099 Select(Tmp2, N2); 05100 if (N.Val->hasOneUse()) { 05101 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBCUW, MVT::v4i32, Tmp1, Tmp2); 05102 } else { 05103 ResNode = CurDAG->getTargetNode(PPC::VSUBCUW, MVT::v4i32, Tmp1, Tmp2); 05104 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05105 Result = SDOperand(ResNode, 0); 05106 } 05107 return; 05108 } 05109 05110 // Pattern: (intrinsic_wo_chain:v16i8 165:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05111 // Emits: (VSUBSBS:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05112 // Pattern complexity = 5 cost = 1 05113 if (CN0 == 165) { 05114 N1 = N.getOperand(1); 05115 N2 = N.getOperand(2); 05116 Select(Tmp1, N1); 05117 Select(Tmp2, N2); 05118 if (N.Val->hasOneUse()) { 05119 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBSBS, MVT::v16i8, Tmp1, Tmp2); 05120 } else { 05121 ResNode = CurDAG->getTargetNode(PPC::VSUBSBS, MVT::v16i8, Tmp1, Tmp2); 05122 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05123 Result = SDOperand(ResNode, 0); 05124 } 05125 return; 05126 } 05127 05128 // Pattern: (intrinsic_wo_chain:v8i16 166:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05129 // Emits: (VSUBSHS:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05130 // Pattern complexity = 5 cost = 1 05131 if (CN0 == 166) { 05132 N1 = N.getOperand(1); 05133 N2 = N.getOperand(2); 05134 Select(Tmp1, N1); 05135 Select(Tmp2, N2); 05136 if (N.Val->hasOneUse()) { 05137 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBSHS, MVT::v8i16, Tmp1, Tmp2); 05138 } else { 05139 ResNode = CurDAG->getTargetNode(PPC::VSUBSHS, MVT::v8i16, Tmp1, Tmp2); 05140 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05141 Result = SDOperand(ResNode, 0); 05142 } 05143 return; 05144 } 05145 05146 // Pattern: (intrinsic_wo_chain:v4i32 167:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05147 // Emits: (VSUBSWS:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05148 // Pattern complexity = 5 cost = 1 05149 if (CN0 == 167) { 05150 N1 = N.getOperand(1); 05151 N2 = N.getOperand(2); 05152 Select(Tmp1, N1); 05153 Select(Tmp2, N2); 05154 if (N.Val->hasOneUse()) { 05155 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBSWS, MVT::v4i32, Tmp1, Tmp2); 05156 } else { 05157 ResNode = CurDAG->getTargetNode(PPC::VSUBSWS, MVT::v4i32, Tmp1, Tmp2); 05158 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05159 Result = SDOperand(ResNode, 0); 05160 } 05161 return; 05162 } 05163 05164 // Pattern: (intrinsic_wo_chain:v16i8 168:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05165 // Emits: (VSUBUBS:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05166 // Pattern complexity = 5 cost = 1 05167 if (CN0 == 168) { 05168 N1 = N.getOperand(1); 05169 N2 = N.getOperand(2); 05170 Select(Tmp1, N1); 05171 Select(Tmp2, N2); 05172 if (N.Val->hasOneUse()) { 05173 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBUBS, MVT::v16i8, Tmp1, Tmp2); 05174 } else { 05175 ResNode = CurDAG->getTargetNode(PPC::VSUBUBS, MVT::v16i8, Tmp1, Tmp2); 05176 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05177 Result = SDOperand(ResNode, 0); 05178 } 05179 return; 05180 } 05181 05182 // Pattern: (intrinsic_wo_chain:v8i16 169:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05183 // Emits: (VSUBUHS:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05184 // Pattern complexity = 5 cost = 1 05185 if (CN0 == 169) { 05186 N1 = N.getOperand(1); 05187 N2 = N.getOperand(2); 05188 Select(Tmp1, N1); 05189 Select(Tmp2, N2); 05190 if (N.Val->hasOneUse()) { 05191 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBUHS, MVT::v8i16, Tmp1, Tmp2); 05192 } else { 05193 ResNode = CurDAG->getTargetNode(PPC::VSUBUHS, MVT::v8i16, Tmp1, Tmp2); 05194 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05195 Result = SDOperand(ResNode, 0); 05196 } 05197 return; 05198 } 05199 05200 // Pattern: (intrinsic_wo_chain:v4i32 170:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05201 // Emits: (VSUBUWS:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05202 // Pattern complexity = 5 cost = 1 05203 if (CN0 == 170) { 05204 N1 = N.getOperand(1); 05205 N2 = N.getOperand(2); 05206 Select(Tmp1, N1); 05207 Select(Tmp2, N2); 05208 if (N.Val->hasOneUse()) { 05209 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBUWS, MVT::v4i32, Tmp1, Tmp2); 05210 } else { 05211 ResNode = CurDAG->getTargetNode(PPC::VSUBUWS, MVT::v4i32, Tmp1, Tmp2); 05212 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05213 Result = SDOperand(ResNode, 0); 05214 } 05215 return; 05216 } 05217 05218 // Pattern: (intrinsic_wo_chain:v4i32 175:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05219 // Emits: (VSUMSWS:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05220 // Pattern complexity = 5 cost = 1 05221 if (CN0 == 175) { 05222 N1 = N.getOperand(1); 05223 N2 = N.getOperand(2); 05224 Select(Tmp1, N1); 05225 Select(Tmp2, N2); 05226 if (N.Val->hasOneUse()) { 05227 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUMSWS, MVT::v4i32, Tmp1, Tmp2); 05228 } else { 05229 ResNode = CurDAG->getTargetNode(PPC::VSUMSWS, MVT::v4i32, Tmp1, Tmp2); 05230 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05231 Result = SDOperand(ResNode, 0); 05232 } 05233 return; 05234 } 05235 05236 // Pattern: (intrinsic_wo_chain:v4i32 171:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05237 // Emits: (VSUM2SWS:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05238 // Pattern complexity = 5 cost = 1 05239 if (CN0 == 171) { 05240 N1 = N.getOperand(1); 05241 N2 = N.getOperand(2); 05242 Select(Tmp1, N1); 05243 Select(Tmp2, N2); 05244 if (N.Val->hasOneUse()) { 05245 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUM2SWS, MVT::v4i32, Tmp1, Tmp2); 05246 } else { 05247 ResNode = CurDAG->getTargetNode(PPC::VSUM2SWS, MVT::v4i32, Tmp1, Tmp2); 05248 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05249 Result = SDOperand(ResNode, 0); 05250 } 05251 return; 05252 } 05253 05254 // Pattern: (intrinsic_wo_chain:v4i32 172:i32, VRRC:v16i8:$vA, VRRC:v4i32:$vB) 05255 // Emits: (VSUM4SBS:v4i32 VRRC:v16i8:$vA, VRRC:v4i32:$vB) 05256 // Pattern complexity = 5 cost = 1 05257 if (CN0 == 172) { 05258 N1 = N.getOperand(1); 05259 N2 = N.getOperand(2); 05260 Select(Tmp1, N1); 05261 Select(Tmp2, N2); 05262 if (N.Val->hasOneUse()) { 05263 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUM4SBS, MVT::v4i32, Tmp1, Tmp2); 05264 } else { 05265 ResNode = CurDAG->getTargetNode(PPC::VSUM4SBS, MVT::v4i32, Tmp1, Tmp2); 05266 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05267 Result = SDOperand(ResNode, 0); 05268 } 05269 return; 05270 } 05271 05272 // Pattern: (intrinsic_wo_chain:v4i32 173:i32, VRRC:v8i16:$vA, VRRC:v4i32:$vB) 05273 // Emits: (VSUM4SHS:v4i32 VRRC:v8i16:$vA, VRRC:v4i32:$vB) 05274 // Pattern complexity = 5 cost = 1 05275 if (CN0 == 173) { 05276 N1 = N.getOperand(1); 05277 N2 = N.getOperand(2); 05278 Select(Tmp1, N1); 05279 Select(Tmp2, N2); 05280 if (N.Val->hasOneUse()) { 05281 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUM4SHS, MVT::v4i32, Tmp1, Tmp2); 05282 } else { 05283 ResNode = CurDAG->getTargetNode(PPC::VSUM4SHS, MVT::v4i32, Tmp1, Tmp2); 05284 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05285 Result = SDOperand(ResNode, 0); 05286 } 05287 return; 05288 } 05289 05290 // Pattern: (intrinsic_wo_chain:v4i32 174:i32, VRRC:v16i8:$vA, VRRC:v4i32:$vB) 05291 // Emits: (VSUM4UBS:v4i32 VRRC:v16i8:$vA, VRRC:v4i32:$vB) 05292 // Pattern complexity = 5 cost = 1 05293 if (CN0 == 174) { 05294 N1 = N.getOperand(1); 05295 N2 = N.getOperand(2); 05296 Select(Tmp1, N1); 05297 Select(Tmp2, N2); 05298 if (N.Val->hasOneUse()) { 05299 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUM4UBS, MVT::v4i32, Tmp1, Tmp2); 05300 } else { 05301 ResNode = CurDAG->getTargetNode(PPC::VSUM4UBS, MVT::v4i32, Tmp1, Tmp2); 05302 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05303 Result = SDOperand(ResNode, 0); 05304 } 05305 return; 05306 } 05307 05308 // Pattern: (intrinsic_wo_chain:v16i8 146:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05309 // Emits: (VRLB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05310 // Pattern complexity = 5 cost = 1 05311 if (CN0 == 146) { 05312 N1 = N.getOperand(1); 05313 N2 = N.getOperand(2); 05314 Select(Tmp1, N1); 05315 Select(Tmp2, N2); 05316 if (N.Val->hasOneUse()) { 05317 Result = CurDAG->SelectNodeTo(N.Val, PPC::VRLB, MVT::v16i8, Tmp1, Tmp2); 05318 } else { 05319 ResNode = CurDAG->getTargetNode(PPC::VRLB, MVT::v16i8, Tmp1, Tmp2); 05320 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05321 Result = SDOperand(ResNode, 0); 05322 } 05323 return; 05324 } 05325 05326 // Pattern: (intrinsic_wo_chain:v8i16 147:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05327 // Emits: (VRLH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05328 // Pattern complexity = 5 cost = 1 05329 if (CN0 == 147) { 05330 N1 = N.getOperand(1); 05331 N2 = N.getOperand(2); 05332 Select(Tmp1, N1); 05333 Select(Tmp2, N2); 05334 if (N.Val->hasOneUse()) { 05335 Result = CurDAG->SelectNodeTo(N.Val, PPC::VRLH, MVT::v8i16, Tmp1, Tmp2); 05336 } else { 05337 ResNode = CurDAG->getTargetNode(PPC::VRLH, MVT::v8i16, Tmp1, Tmp2); 05338 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05339 Result = SDOperand(ResNode, 0); 05340 } 05341 return; 05342 } 05343 05344 // Pattern: (intrinsic_wo_chain:v4i32 148:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05345 // Emits: (VRLW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05346 // Pattern complexity = 5 cost = 1 05347 if (CN0 == 148) { 05348 N1 = N.getOperand(1); 05349 N2 = N.getOperand(2); 05350 Select(Tmp1, N1); 05351 Select(Tmp2, N2); 05352 if (N.Val->hasOneUse()) { 05353 Result = CurDAG->SelectNodeTo(N.Val, PPC::VRLW, MVT::v4i32, Tmp1, Tmp2); 05354 } else { 05355 ResNode = CurDAG->getTargetNode(PPC::VRLW, MVT::v4i32, Tmp1, Tmp2); 05356 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05357 Result = SDOperand(ResNode, 0); 05358 } 05359 return; 05360 } 05361 05362 // Pattern: (intrinsic_wo_chain:v4i32 151:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05363 // Emits: (VSL:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05364 // Pattern complexity = 5 cost = 1 05365 if (CN0 == 151) { 05366 N1 = N.getOperand(1); 05367 N2 = N.getOperand(2); 05368 Select(Tmp1, N1); 05369 Select(Tmp2, N2); 05370 if (N.Val->hasOneUse()) { 05371 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSL, MVT::v4i32, Tmp1, Tmp2); 05372 } else { 05373 ResNode = CurDAG->getTargetNode(PPC::VSL, MVT::v4i32, Tmp1, Tmp2); 05374 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05375 Result = SDOperand(ResNode, 0); 05376 } 05377 return; 05378 } 05379 05380 // Pattern: (intrinsic_wo_chain:v4i32 154:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05381 // Emits: (VSLO:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05382 // Pattern complexity = 5 cost = 1 05383 if (CN0 == 154) { 05384 N1 = N.getOperand(1); 05385 N2 = N.getOperand(2); 05386 Select(Tmp1, N1); 05387 Select(Tmp2, N2); 05388 if (N.Val->hasOneUse()) { 05389 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSLO, MVT::v4i32, Tmp1, Tmp2); 05390 } else { 05391 ResNode = CurDAG->getTargetNode(PPC::VSLO, MVT::v4i32, Tmp1, Tmp2); 05392 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05393 Result = SDOperand(ResNode, 0); 05394 } 05395 return; 05396 } 05397 05398 // Pattern: (intrinsic_wo_chain:v16i8 152:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05399 // Emits: (VSLB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05400 // Pattern complexity = 5 cost = 1 05401 if (CN0 == 152) { 05402 N1 = N.getOperand(1); 05403 N2 = N.getOperand(2); 05404 Select(Tmp1, N1); 05405 Select(Tmp2, N2); 05406 if (N.Val->hasOneUse()) { 05407 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSLB, MVT::v16i8, Tmp1, Tmp2); 05408 } else { 05409 ResNode = CurDAG->getTargetNode(PPC::VSLB, MVT::v16i8, Tmp1, Tmp2); 05410 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05411 Result = SDOperand(ResNode, 0); 05412 } 05413 return; 05414 } 05415 05416 // Pattern: (intrinsic_wo_chain:v8i16 153:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05417 // Emits: (VSLH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05418 // Pattern complexity = 5 cost = 1 05419 if (CN0 == 153) { 05420 N1 = N.getOperand(1); 05421 N2 = N.getOperand(2); 05422 Select(Tmp1, N1); 05423 Select(Tmp2, N2); 05424 if (N.Val->hasOneUse()) { 05425 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSLH, MVT::v8i16, Tmp1, Tmp2); 05426 } else { 05427 ResNode = CurDAG->getTargetNode(PPC::VSLH, MVT::v8i16, Tmp1, Tmp2); 05428 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05429 Result = SDOperand(ResNode, 0); 05430 } 05431 return; 05432 } 05433 05434 // Pattern: (intrinsic_wo_chain:v4i32 155:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05435 // Emits: (VSLW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05436 // Pattern complexity = 5 cost = 1 05437 if (CN0 == 155) { 05438 N1 = N.getOperand(1); 05439 N2 = N.getOperand(2); 05440 Select(Tmp1, N1); 05441 Select(Tmp2, N2); 05442 if (N.Val->hasOneUse()) { 05443 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSLW, MVT::v4i32, Tmp1, Tmp2); 05444 } else { 05445 ResNode = CurDAG->getTargetNode(PPC::VSLW, MVT::v4i32, Tmp1, Tmp2); 05446 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05447 Result = SDOperand(ResNode, 0); 05448 } 05449 return; 05450 } 05451 05452 // Pattern: (intrinsic_wo_chain:v4i32 156:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05453 // Emits: (VSR:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05454 // Pattern complexity = 5 cost = 1 05455 if (CN0 == 156) { 05456 N1 = N.getOperand(1); 05457 N2 = N.getOperand(2); 05458 Select(Tmp1, N1); 05459 Select(Tmp2, N2); 05460 if (N.Val->hasOneUse()) { 05461 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSR, MVT::v4i32, Tmp1, Tmp2); 05462 } else { 05463 ResNode = CurDAG->getTargetNode(PPC::VSR, MVT::v4i32, Tmp1, Tmp2); 05464 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05465 Result = SDOperand(ResNode, 0); 05466 } 05467 return; 05468 } 05469 05470 // Pattern: (intrinsic_wo_chain:v4i32 162:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05471 // Emits: (VSRO:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05472 // Pattern complexity = 5 cost = 1 05473 if (CN0 == 162) { 05474 N1 = N.getOperand(1); 05475 N2 = N.getOperand(2); 05476 Select(Tmp1, N1); 05477 Select(Tmp2, N2); 05478 if (N.Val->hasOneUse()) { 05479 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSRO, MVT::v4i32, Tmp1, Tmp2); 05480 } else { 05481 ResNode = CurDAG->getTargetNode(PPC::VSRO, MVT::v4i32, Tmp1, Tmp2); 05482 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05483 Result = SDOperand(ResNode, 0); 05484 } 05485 return; 05486 } 05487 05488 // Pattern: (intrinsic_wo_chain:v16i8 157:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05489 // Emits: (VSRAB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05490 // Pattern complexity = 5 cost = 1 05491 if (CN0 == 157) { 05492 N1 = N.getOperand(1); 05493 N2 = N.getOperand(2); 05494 Select(Tmp1, N1); 05495 Select(Tmp2, N2); 05496 if (N.Val->hasOneUse()) { 05497 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSRAB, MVT::v16i8, Tmp1, Tmp2); 05498 } else { 05499 ResNode = CurDAG->getTargetNode(PPC::VSRAB, MVT::v16i8, Tmp1, Tmp2); 05500 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05501 Result = SDOperand(ResNode, 0); 05502 } 05503 return; 05504 } 05505 05506 // Pattern: (intrinsic_wo_chain:v8i16 158:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05507 // Emits: (VSRAH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05508 // Pattern complexity = 5 cost = 1 05509 if (CN0 == 158) { 05510 N1 = N.getOperand(1); 05511 N2 = N.getOperand(2); 05512 Select(Tmp1, N1); 05513 Select(Tmp2, N2); 05514 if (N.Val->hasOneUse()) { 05515 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSRAH, MVT::v8i16, Tmp1, Tmp2); 05516 } else { 05517 ResNode = CurDAG->getTargetNode(PPC::VSRAH, MVT::v8i16, Tmp1, Tmp2); 05518 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05519 Result = SDOperand(ResNode, 0); 05520 } 05521 return; 05522 } 05523 05524 // Pattern: (intrinsic_wo_chain:v4i32 159:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05525 // Emits: (VSRAW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05526 // Pattern complexity = 5 cost = 1 05527 if (CN0 == 159) { 05528 N1 = N.getOperand(1); 05529 N2 = N.getOperand(2); 05530 Select(Tmp1, N1); 05531 Select(Tmp2, N2); 05532 if (N.Val->hasOneUse()) { 05533 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSRAW, MVT::v4i32, Tmp1, Tmp2); 05534 } else { 05535 ResNode = CurDAG->getTargetNode(PPC::VSRAW, MVT::v4i32, Tmp1, Tmp2); 05536 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05537 Result = SDOperand(ResNode, 0); 05538 } 05539 return; 05540 } 05541 05542 // Pattern: (intrinsic_wo_chain:v16i8 160:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05543 // Emits: (VSRB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05544 // Pattern complexity = 5 cost = 1 05545 if (CN0 == 160) { 05546 N1 = N.getOperand(1); 05547 N2 = N.getOperand(2); 05548 Select(Tmp1, N1); 05549 Select(Tmp2, N2); 05550 if (N.Val->hasOneUse()) { 05551 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSRB, MVT::v16i8, Tmp1, Tmp2); 05552 } else { 05553 ResNode = CurDAG->getTargetNode(PPC::VSRB, MVT::v16i8, Tmp1, Tmp2); 05554 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05555 Result = SDOperand(ResNode, 0); 05556 } 05557 return; 05558 } 05559 05560 // Pattern: (intrinsic_wo_chain:v8i16 161:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05561 // Emits: (VSRH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05562 // Pattern complexity = 5 cost = 1 05563 if (CN0 == 161) { 05564 N1 = N.getOperand(1); 05565 N2 = N.getOperand(2); 05566 Select(Tmp1, N1); 05567 Select(Tmp2, N2); 05568 if (N.Val->hasOneUse()) { 05569 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSRH, MVT::v8i16, Tmp1, Tmp2); 05570 } else { 05571 ResNode = CurDAG->getTargetNode(PPC::VSRH, MVT::v8i16, Tmp1, Tmp2); 05572 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05573 Result = SDOperand(ResNode, 0); 05574 } 05575 return; 05576 } 05577 05578 // Pattern: (intrinsic_wo_chain:v4i32 163:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05579 // Emits: (VSRW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05580 // Pattern complexity = 5 cost = 1 05581 if (CN0 == 163) { 05582 N1 = N.getOperand(1); 05583 N2 = N.getOperand(2); 05584 Select(Tmp1, N1); 05585 Select(Tmp2, N2); 05586 if (N.Val->hasOneUse()) { 05587 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSRW, MVT::v4i32, Tmp1, Tmp2); 05588 } else { 05589 ResNode = CurDAG->getTargetNode(PPC::VSRW, MVT::v4i32, Tmp1, Tmp2); 05590 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05591 Result = SDOperand(ResNode, 0); 05592 } 05593 return; 05594 } 05595 05596 // Pattern: (intrinsic_wo_chain:v8i16 134:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05597 // Emits: (VPKPX:v8i16 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05598 // Pattern complexity = 5 cost = 1 05599 if (CN0 == 134) { 05600 N1 = N.getOperand(1); 05601 N2 = N.getOperand(2); 05602 Select(Tmp1, N1); 05603 Select(Tmp2, N2); 05604 if (N.Val->hasOneUse()) { 05605 Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKPX, MVT::v8i16, Tmp1, Tmp2); 05606 } else { 05607 ResNode = CurDAG->getTargetNode(PPC::VPKPX, MVT::v8i16, Tmp1, Tmp2); 05608 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05609 Result = SDOperand(ResNode, 0); 05610 } 05611 return; 05612 } 05613 05614 // Pattern: (intrinsic_wo_chain:v16i8 135:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05615 // Emits: (VPKSHSS:v16i8 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05616 // Pattern complexity = 5 cost = 1 05617 if (CN0 == 135) { 05618 N1 = N.getOperand(1); 05619 N2 = N.getOperand(2); 05620 Select(Tmp1, N1); 05621 Select(Tmp2, N2); 05622 if (N.Val->hasOneUse()) { 05623 Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKSHSS, MVT::v16i8, Tmp1, Tmp2); 05624 } else { 05625 ResNode = CurDAG->getTargetNode(PPC::VPKSHSS, MVT::v16i8, Tmp1, Tmp2); 05626 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05627 Result = SDOperand(ResNode, 0); 05628 } 05629 return; 05630 } 05631 05632 // Pattern: (intrinsic_wo_chain:v16i8 136:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05633 // Emits: (VPKSHUS:v16i8 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05634 // Pattern complexity = 5 cost = 1 05635 if (CN0 == 136) { 05636 N1 = N.getOperand(1); 05637 N2 = N.getOperand(2); 05638 Select(Tmp1, N1); 05639 Select(Tmp2, N2); 05640 if (N.Val->hasOneUse()) { 05641 Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKSHUS, MVT::v16i8, Tmp1, Tmp2); 05642 } else { 05643 ResNode = CurDAG->getTargetNode(PPC::VPKSHUS, MVT::v16i8, Tmp1, Tmp2); 05644 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05645 Result = SDOperand(ResNode, 0); 05646 } 05647 return; 05648 } 05649 05650 // Pattern: (intrinsic_wo_chain:v16i8 137:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05651 // Emits: (VPKSWSS:v16i8 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05652 // Pattern complexity = 5 cost = 1 05653 if (CN0 == 137) { 05654 N1 = N.getOperand(1); 05655 N2 = N.getOperand(2); 05656 Select(Tmp1, N1); 05657 Select(Tmp2, N2); 05658 if (N.Val->hasOneUse()) { 05659 Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKSWSS, MVT::v16i8, Tmp1, Tmp2); 05660 } else { 05661 ResNode = CurDAG->getTargetNode(PPC::VPKSWSS, MVT::v16i8, Tmp1, Tmp2); 05662 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05663 Result = SDOperand(ResNode, 0); 05664 } 05665 return; 05666 } 05667 05668 // Pattern: (intrinsic_wo_chain:v8i16 138:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05669 // Emits: (VPKSWUS:v8i16 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05670 // Pattern complexity = 5 cost = 1 05671 if (CN0 == 138) { 05672 N1 = N.getOperand(1); 05673 N2 = N.getOperand(2); 05674 Select(Tmp1, N1); 05675 Select(Tmp2, N2); 05676 if (N.Val->hasOneUse()) { 05677 Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKSWUS, MVT::v8i16, Tmp1, Tmp2); 05678 } else { 05679 ResNode = CurDAG->getTargetNode(PPC::VPKSWUS, MVT::v8i16, Tmp1, Tmp2); 05680 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05681 Result = SDOperand(ResNode, 0); 05682 } 05683 return; 05684 } 05685 05686 // Pattern: (intrinsic_wo_chain:v16i8 139:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05687 // Emits: (VPKUHUS:v16i8 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05688 // Pattern complexity = 5 cost = 1 05689 if (CN0 == 139) { 05690 N1 = N.getOperand(1); 05691 N2 = N.getOperand(2); 05692 Select(Tmp1, N1); 05693 Select(Tmp2, N2); 05694 if (N.Val->hasOneUse()) { 05695 Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKUHUS, MVT::v16i8, Tmp1, Tmp2); 05696 } else { 05697 ResNode = CurDAG->getTargetNode(PPC::VPKUHUS, MVT::v16i8, Tmp1, Tmp2); 05698 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05699 Result = SDOperand(ResNode, 0); 05700 } 05701 return; 05702 } 05703 05704 // Pattern: (intrinsic_wo_chain:v16i8 140:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05705 // Emits: (VPKUWUS:v16i8 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05706 // Pattern complexity = 5 cost = 1 05707 if (CN0 == 140) { 05708 N1 = N.getOperand(1); 05709 N2 = N.getOperand(2); 05710 Select(Tmp1, N1); 05711 Select(Tmp2, N2); 05712 if (N.Val->hasOneUse()) { 05713 Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKUWUS, MVT::v16i8, Tmp1, Tmp2); 05714 } else { 05715 ResNode = CurDAG->getTargetNode(PPC::VPKUWUS, MVT::v16i8, Tmp1, Tmp2); 05716 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05717 Result = SDOperand(ResNode, 0); 05718 } 05719 return; 05720 } 05721 05722 // Pattern: (intrinsic_wo_chain:v4i32 176:i32, VRRC:v8i16:$vB) 05723 // Emits: (VUPKHPX:v4i32 VRRC:v8i16:$vB) 05724 // Pattern complexity = 5 cost = 1 05725 if (CN0 == 176) { 05726 N1 = N.getOperand(1); 05727 Select(Tmp1, N1); 05728 if (N.Val->hasOneUse()) { 05729 Result = CurDAG->SelectNodeTo(N.Val, PPC::VUPKHPX, MVT::v4i32, Tmp1); 05730 } else { 05731 ResNode = CurDAG->getTargetNode(PPC::VUPKHPX, MVT::v4i32, Tmp1); 05732 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05733 Result = SDOperand(ResNode, 0); 05734 } 05735 return; 05736 } 05737 05738 // Pattern: (intrinsic_wo_chain:v8i16 177:i32, VRRC:v16i8:$vB) 05739 // Emits: (VUPKHSB:v8i16 VRRC:v16i8:$vB) 05740 // Pattern complexity = 5 cost = 1 05741 if (CN0 == 177) { 05742 N1 = N.getOperand(1); 05743 Select(Tmp1, N1); 05744 if (N.Val->hasOneUse()) { 05745 Result = CurDAG->SelectNodeTo(N.Val, PPC::VUPKHSB, MVT::v8i16, Tmp1); 05746 } else { 05747 ResNode = CurDAG->getTargetNode(PPC::VUPKHSB, MVT::v8i16, Tmp1); 05748 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05749 Result = SDOperand(ResNode, 0); 05750 } 05751 return; 05752 } 05753 05754 // Pattern: (intrinsic_wo_chain:v4i32 178:i32, VRRC:v8i16:$vB) 05755 // Emits: (VUPKHSH:v4i32 VRRC:v8i16:$vB) 05756 // Pattern complexity = 5 cost = 1 05757 if (CN0 == 178) { 05758 N1 = N.getOperand(1); 05759 Select(Tmp1, N1); 05760 if (N.Val->hasOneUse()) { 05761 Result = CurDAG->SelectNodeTo(N.Val, PPC::VUPKHSH, MVT::v4i32, Tmp1); 05762 } else { 05763 ResNode = CurDAG->getTargetNode(PPC::VUPKHSH, MVT::v4i32, Tmp1); 05764 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05765 Result = SDOperand(ResNode, 0); 05766 } 05767 return; 05768 } 05769 05770 // Pattern: (intrinsic_wo_chain:v4i32 179:i32, VRRC:v8i16:$vB) 05771 // Emits: (VUPKLPX:v4i32 VRRC:v8i16:$vB) 05772 // Pattern complexity = 5 cost = 1 05773 if (CN0 == 179) { 05774 N1 = N.getOperand(1); 05775 Select(Tmp1, N1); 05776 if (N.Val->hasOneUse()) { 05777 Result = CurDAG->SelectNodeTo(N.Val, PPC::VUPKLPX, MVT::v4i32, Tmp1); 05778 } else { 05779 ResNode = CurDAG->getTargetNode(PPC::VUPKLPX, MVT::v4i32, Tmp1); 05780 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05781 Result = SDOperand(ResNode, 0); 05782 } 05783 return; 05784 } 05785 05786 // Pattern: (intrinsic_wo_chain:v8i16 180:i32, VRRC:v16i8:$vB) 05787 // Emits: (VUPKLSB:v8i16 VRRC:v16i8:$vB) 05788 // Pattern complexity = 5 cost = 1 05789 if (CN0 == 180) { 05790 N1 = N.getOperand(1); 05791 Select(Tmp1, N1); 05792 if (N.Val->hasOneUse()) { 05793 Result = CurDAG->SelectNodeTo(N.Val, PPC::VUPKLSB, MVT::v8i16, Tmp1); 05794 } else { 05795 ResNode = CurDAG->getTargetNode(PPC::VUPKLSB, MVT::v8i16, Tmp1); 05796 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05797 Result = SDOperand(ResNode, 0); 05798 } 05799 return; 05800 } 05801 05802 // Pattern: (intrinsic_wo_chain:v4i32 181:i32, VRRC:v8i16:$vB) 05803 // Emits: (VUPKLSH:v4i32 VRRC:v8i16:$vB) 05804 // Pattern complexity = 5 cost = 1 05805 if (CN0 == 181) { 05806 N1 = N.getOperand(1); 05807 Select(Tmp1, N1); 05808 if (N.Val->hasOneUse()) { 05809 Result = CurDAG->SelectNodeTo(N.Val, PPC::VUPKLSH, MVT::v4i32, Tmp1); 05810 } else { 05811 ResNode = CurDAG->getTargetNode(PPC::VUPKLSH, MVT::v4i32, Tmp1); 05812 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05813 Result = SDOperand(ResNode, 0); 05814 } 05815 return; 05816 } 05817 05818 // Pattern: (intrinsic_wo_chain:v4f32 100:i32, VRRC:v4f32:$A, VRRC:v4f32:$B, VRRC:v4f32:$C) 05819 // Emits: (VMADDFP:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B, VRRC:v16i8:$C) 05820 // Pattern complexity = 5 cost = 1 05821 if (CN0 == 100) { 05822 N1 = N.getOperand(1); 05823 N2 = N.getOperand(2); 05824 N3 = N.getOperand(3); 05825 Select(Tmp1, N1); 05826 Select(Tmp2, N2); 05827 Select(Tmp3, N3); 05828 if (N.Val->hasOneUse()) { 05829 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMADDFP, MVT::v16i8, Tmp1, Tmp2, Tmp3); 05830 } else { 05831 ResNode = CurDAG->getTargetNode(PPC::VMADDFP, MVT::v16i8, Tmp1, Tmp2, Tmp3); 05832 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05833 Result = SDOperand(ResNode, 0); 05834 } 05835 return; 05836 } 05837 05838 // Pattern: (intrinsic_wo_chain:v4f32 132:i32, VRRC:v4f32:$A, VRRC:v4f32:$B, VRRC:v4f32:$C) 05839 // Emits: (VNMSUBFP:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B, VRRC:v16i8:$C) 05840 // Pattern complexity = 5 cost = 1 05841 if (CN0 == 132) { 05842 N1 = N.getOperand(1); 05843 N2 = N.getOperand(2); 05844 N3 = N.getOperand(3); 05845 Select(Tmp1, N1); 05846 Select(Tmp2, N2); 05847 Select(Tmp3, N3); 05848 if (N.Val->hasOneUse()) { 05849 Result = CurDAG->SelectNodeTo(N.Val, PPC::VNMSUBFP, MVT::v16i8, Tmp1, Tmp2, Tmp3); 05850 } else { 05851 ResNode = CurDAG->getTargetNode(PPC::VNMSUBFP, MVT::v16i8, Tmp1, Tmp2, Tmp3); 05852 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05853 Result = SDOperand(ResNode, 0); 05854 } 05855 return; 05856 } 05857 } 05858 std::cerr << "Cannot yet select: "; 05859 unsigned iid = cast<ConstantSDNode>(N.getOperand(N.getOperand(0).getValueType() == MVT::Other))->getValue(); 05860 std::cerr << "intrinsic %"<< Intrinsic::getName((Intrinsic::ID)iid); 05861 std::cerr << '\n'; 05862 abort(); 05863 } 05864 05865 void Select_load(SDOperand &Result, SDOperand N) { 05866 if (N.ResNo == 1 && N.getValue(0).hasOneUse()) { 05867 SDOperand Dummy = CurDAG->getNode(ISD::HANDLENODE, MVT::Other, N); 05868 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Dummy.Val, 0); 05869 SelectionDAG::InsertISelMapEntry(HandleMap, N.Val, 1, Dummy.Val, 0); 05870 Result = Dummy; 05871 return; 05872 } 05873 SDOperand Chain(0, 0); 05874 SDOperand N1(0, 0); 05875 SDOperand Tmp0(0, 0); 05876 SDOperand Tmp1(0, 0); 05877 SDNode *ResNode; 05878 Chain = N.getOperand(0); 05879 N1 = N.getOperand(1); 05880 05881 // Pattern: (load:i32 iaddr:i32:$src) 05882 // Emits: (LWZ:i32 iaddr:i32:$src) 05883 // Pattern complexity = 8 cost = 1 05884 if (N.Val->getValueType(0) == MVT::i32 && 05885 SelectAddrImm(N1, Tmp0, Tmp1)) { 05886 Select(Tmp0, Tmp0); 05887 Select(Tmp1, Tmp1); 05888 Select(Chain, Chain); 05889 ResNode = CurDAG->getTargetNode(PPC::LWZ, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain); 05890 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 05891 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 05892 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 05893 Result = SDOperand(ResNode, N.ResNo); 05894 return; 05895 } 05896 05897 // Pattern: (load:f32 iaddr:i32:$src) 05898 // Emits: (LFS:f32 iaddr:i32:$src) 05899 // Pattern complexity = 8 cost = 1 05900 if (N.Val->getValueType(0) == MVT::f32 && 05901 SelectAddrImm(N1, Tmp0, Tmp1)) { 05902 Select(Tmp0, Tmp0); 05903 Select(Tmp1, Tmp1); 05904 Select(Chain, Chain); 05905 ResNode = CurDAG->getTargetNode(PPC::LFS, MVT::f32, MVT::Other, Tmp0, Tmp1, Chain); 05906 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 05907 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 05908 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 05909 Result = SDOperand(ResNode, N.ResNo); 05910 return; 05911 } 05912 05913 // Pattern: (load:f64 iaddr:i32:$src) 05914 // Emits: (LFD:f64 iaddr:i32:$src) 05915 // Pattern complexity = 8 cost = 1 05916 if (N.Val->getValueType(0) == MVT::f64 && 05917 SelectAddrImm(N1, Tmp0, Tmp1)) { 05918 Select(Tmp0, Tmp0); 05919 Select(Tmp1, Tmp1); 05920 Select(Chain, Chain); 05921 ResNode = CurDAG->getTargetNode(PPC::LFD, MVT::f64, MVT::Other, Tmp0, Tmp1, Chain); 05922 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 05923 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 05924 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 05925 Result = SDOperand(ResNode, N.ResNo); 05926 return; 05927 } 05928 05929 // Pattern: (load:i32 xaddr:i32:$src) 05930 // Emits: (LWZX:i32 xaddr:i32:$src) 05931 // Pattern complexity = 8 cost = 1 05932 if (N.Val->getValueType(0) == MVT::i32 && 05933 SelectAddrIdx(N1, Tmp0, Tmp1)) { 05934 Select(Tmp0, Tmp0); 05935 Select(Tmp1, Tmp1); 05936 Select(Chain, Chain); 05937 ResNode = CurDAG->getTargetNode(PPC::LWZX, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain); 05938 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 05939 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 05940 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 05941 Result = SDOperand(ResNode, N.ResNo); 05942 return; 05943 } 05944 05945 // Pattern: (load:i64 xaddr:i32:$src) 05946 // Emits: (LDX:i64 xaddr:i32:$src) 05947 // Pattern complexity = 8 cost = 1 05948 if (N.Val->getValueType(0) == MVT::i64 && 05949 SelectAddrIdx(N1, Tmp0, Tmp1)) { 05950 Select(Tmp0, Tmp0); 05951 Select(Tmp1, Tmp1); 05952 Select(Chain, Chain); 05953 ResNode = CurDAG->getTargetNode(PPC::LDX, MVT::i64, MVT::Other, Tmp0, Tmp1, Chain); 05954 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 05955 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 05956 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 05957 Result = SDOperand(ResNode, N.ResNo); 05958 return; 05959 } 05960 05961 // Pattern: (load:f32 xaddr:i32:$src) 05962 // Emits: (LFSX:f32 xaddr:i32:$src) 05963 // Pattern complexity = 8 cost = 1 05964 if (N.Val->getValueType(0) == MVT::f32 && 05965 SelectAddrIdx(N1, Tmp0, Tmp1)) { 05966 Select(Tmp0, Tmp0); 05967 Select(Tmp1, Tmp1); 05968 Select(Chain, Chain); 05969 ResNode = CurDAG->getTargetNode(PPC::LFSX, MVT::f32, MVT::Other, Tmp0, Tmp1, Chain); 05970 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 05971 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 05972 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 05973 Result = SDOperand(ResNode, N.ResNo); 05974 return; 05975 } 05976 05977 // Pattern: (load:f64 xaddr:i32:$src) 05978 // Emits: (LFDX:f64 xaddr:i32:$src) 05979 // Pattern complexity = 8 cost = 1 05980 if (N.Val->getValueType(0) == MVT::f64 && 05981 SelectAddrIdx(N1, Tmp0, Tmp1)) { 05982 Select(Tmp0, Tmp0); 05983 Select(Tmp1, Tmp1); 05984 Select(Chain, Chain); 05985 ResNode = CurDAG->getTargetNode(PPC::LFDX, MVT::f64, MVT::Other, Tmp0, Tmp1, Chain); 05986 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 05987 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 05988 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 05989 Result = SDOperand(ResNode, N.ResNo); 05990 return; 05991 } 05992 05993 // Pattern: (load:v16i8 xoaddr:i32:$src) 05994 // Emits: (LVX:v16i8 xoaddr:i32:$src) 05995 // Pattern complexity = 8 cost = 1 05996 if (N.Val->getValueType(0) == MVT::v16i8 && 05997 SelectAddrIdxOnly(N1, Tmp0, Tmp1)) { 05998 Select(Tmp0, Tmp0); 05999 Select(Tmp1, Tmp1); 06000 Select(Chain, Chain); 06001 ResNode = CurDAG->getTargetNode(PPC::LVX, MVT::v16i8, MVT::Other, Tmp0, Tmp1, Chain); 06002 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 06003 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 06004 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 06005 Result = SDOperand(ResNode, N.ResNo); 06006 return; 06007 } 06008 06009 // Pattern: (load:v8i16 xoaddr:i32:$src) 06010 // Emits: (LVX:v8i16 xoaddr:i32:$src) 06011 // Pattern complexity = 8 cost = 1 06012 if (N.Val->getValueType(0) == MVT::v8i16 && 06013 SelectAddrIdxOnly(N1, Tmp0, Tmp1)) { 06014 Select(Tmp0, Tmp0); 06015 Select(Tmp1, Tmp1); 06016 Select(Chain, Chain); 06017 ResNode = CurDAG->getTargetNode(PPC::LVX, MVT::v8i16, MVT::Other, Tmp0, Tmp1, Chain); 06018 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 06019 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 06020 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 06021 Result = SDOperand(ResNode, N.ResNo); 06022 return; 06023 } 06024 06025 // Pattern: (load:v4i32 xoaddr:i32:$src) 06026 // Emits: (LVX:v4i32 xoaddr:i32:$src) 06027 // Pattern complexity = 8 cost = 1 06028 if (N.Val->getValueType(0) == MVT::v4i32 && 06029 SelectAddrIdxOnly(N1, Tmp0, Tmp1)) { 06030 Select(Tmp0, Tmp0); 06031 Select(Tmp1, Tmp1); 06032 Select(Chain, Chain); 06033 ResNode = CurDAG->getTargetNode(PPC::LVX, MVT::v4i32, MVT::Other, Tmp0, Tmp1, Chain); 06034 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 06035 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 06036 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 06037 Result = SDOperand(ResNode, N.ResNo); 06038 return; 06039 } 06040 06041 // Pattern: (load:v4f32 xoaddr:i32:$src) 06042 // Emits: (LVX:v4f32 xoaddr:i32:$src) 06043 // Pattern complexity = 8 cost = 1 06044 if (N.Val->getValueType(0) == MVT::v4f32 && 06045 SelectAddrIdxOnly(N1, Tmp0, Tmp1)) { 06046 Select(Tmp0, Tmp0); 06047 Select(Tmp1, Tmp1); 06048 Select(Chain, Chain); 06049 ResNode = CurDAG->getTargetNode(PPC::LVX, MVT::v4f32, MVT::Other, Tmp0, Tmp1, Chain); 06050 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 06051 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 06052 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 06053 Result = SDOperand(ResNode, N.ResNo); 06054 return; 06055 } 06056 std::cerr << "Cannot yet select: "; 06057 N.Val->dump(CurDAG); 06058 std::cerr << '\n'; 06059 abort(); 06060 } 06061 06062 void Select_mul(SDOperand &Result, SDOperand N) { 06063 SDOperand N0(0, 0); 06064 SDOperand N1(0, 0); 06065 SDOperand Tmp0(0, 0); 06066 SDOperand Tmp1(0, 0); 06067 SDNode *ResNode; 06068 N0 = N.getOperand(0); 06069 N1 = N.getOperand(1); 06070 06071 // Pattern: (mul:i32 GPRC:i32:$rA, (imm:i32)<<P:Predicate_immSExt16>>:$imm) 06072 // Emits: (MULLI:i32 GPRC:i32:$rA, (imm:i32):$imm) 06073 // Pattern complexity = 5 cost = 1 06074 if (N1.getOpcode() == ISD::Constant && 06075 Predicate_immSExt16(N1.Val) && 06076 N.Val->getValueType(0) == MVT::i32) { 06077 Select(Tmp0, N0); 06078 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 06079 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 06080 if (N.Val->hasOneUse()) { 06081 Result = CurDAG->SelectNodeTo(N.Val, PPC::MULLI, MVT::i32, Tmp0, Tmp1); 06082 } else { 06083 ResNode = CurDAG->getTargetNode(PPC::MULLI, MVT::i32, Tmp0, Tmp1); 06084 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06085 Result = SDOperand(ResNode, 0); 06086 } 06087 return; 06088 } 06089 06090 // Pattern: (mul:i64 G8RC:i64:$rA, G8RC:i64:$rB) 06091 // Emits: (MULLD:i64 G8RC:i64:$rA, G8RC:i64:$rB) 06092 // Pattern complexity = 2 cost = 1 06093 if (N.Val->getValueType(0) == MVT::i64) { 06094 Select(Tmp0, N0); 06095 Select(Tmp1, N1); 06096 if (N.Val->hasOneUse()) { 06097 Result = CurDAG->SelectNodeTo(N.Val, PPC::MULLD, MVT::i64, Tmp0, Tmp1); 06098 } else { 06099 ResNode = CurDAG->getTargetNode(PPC::MULLD, MVT::i64, Tmp0, Tmp1); 06100 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06101 Result = SDOperand(ResNode, 0); 06102 } 06103 return; 06104 } 06105 06106 // Pattern: (mul:i32 GPRC:i32:$rA, GPRC:i32:$rB) 06107 // Emits: (MULLW:i32 GPRC:i32:$rA, GPRC:i32:$rB) 06108 // Pattern complexity = 2 cost = 1 06109 if (N.Val->getValueType(0) == MVT::i32) { 06110 Select(Tmp0, N0); 06111 Select(Tmp1, N1); 06112 if (N.Val->hasOneUse()) { 06113 Result = CurDAG->SelectNodeTo(N.Val, PPC::MULLW, MVT::i32, Tmp0, Tmp1); 06114 } else { 06115 ResNode = CurDAG->getTargetNode(PPC::MULLW, MVT::i32, Tmp0, Tmp1); 06116 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06117 Result = SDOperand(ResNode, 0); 06118 } 06119 return; 06120 } 06121 std::cerr << "Cannot yet select: "; 06122 N.Val->dump(CurDAG); 06123 std::cerr << '\n'; 06124 abort(); 06125 } 06126 06127 void Select_mulhs(SDOperand &Result, SDOperand N) { 06128 SDOperand N0(0, 0); 06129 SDOperand N1(0, 0); 06130 SDOperand Tmp0(0, 0); 06131 SDOperand Tmp1(0, 0); 06132 SDNode *ResNode; 06133 N0 = N.getOperand(0); 06134 N1 = N.getOperand(1); 06135 06136 // Pattern: (mulhs:i64 G8RC:i64:$rA, G8RC:i64:$rB) 06137 // Emits: (MULHD:i64 G8RC:i64:$rA, G8RC:i64:$rB) 06138 // Pattern complexity = 2 cost = 1 06139 if (N.Val->getValueType(0) == MVT::i64) { 06140 Select(Tmp0, N0); 06141 Select(Tmp1, N1); 06142 if (N.Val->hasOneUse()) { 06143 Result = CurDAG->SelectNodeTo(N.Val, PPC::MULHD, MVT::i64, Tmp0, Tmp1); 06144 } else { 06145 ResNode = CurDAG->getTargetNode(PPC::MULHD, MVT::i64, Tmp0, Tmp1); 06146 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06147 Result = SDOperand(ResNode, 0); 06148 } 06149 return; 06150 } 06151 06152 // Pattern: (mulhs:i32 GPRC:i32:$rA, GPRC:i32:$rB) 06153 // Emits: (MULHW:i32 GPRC:i32:$rA, GPRC:i32:$rB) 06154 // Pattern complexity = 2 cost = 1 06155 if (N.Val->getValueType(0) == MVT::i32) { 06156 Select(Tmp0, N0); 06157 Select(Tmp1, N1); 06158 if (N.Val->hasOneUse()) { 06159 Result = CurDAG->SelectNodeTo(N.Val, PPC::MULHW, MVT::i32, Tmp0, Tmp1); 06160 } else { 06161 ResNode = CurDAG->getTargetNode(PPC::MULHW, MVT::i32, Tmp0, Tmp1); 06162 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06163 Result = SDOperand(ResNode, 0); 06164 } 06165 return; 06166 } 06167 std::cerr << "Cannot yet select: "; 06168 N.Val->dump(CurDAG); 06169 std::cerr << '\n'; 06170 abort(); 06171 } 06172 06173 void Select_mulhu(SDOperand &Result, SDOperand N) { 06174 SDOperand N0(0, 0); 06175 SDOperand N1(0, 0); 06176 SDOperand Tmp0(0, 0); 06177 SDOperand Tmp1(0, 0); 06178 SDNode *ResNode; 06179 N0 = N.getOperand(0); 06180 N1 = N.getOperand(1); 06181 06182 // Pattern: (mulhu:i64 G8RC:i64:$rA, G8RC:i64:$rB) 06183 // Emits: (MULHDU:i64 G8RC:i64:$rA, G8RC:i64:$rB) 06184 // Pattern complexity = 2 cost = 1 06185 if (N.Val->getValueType(0) == MVT::i64) { 06186 Select(Tmp0, N0); 06187 Select(Tmp1, N1); 06188 if (N.Val->hasOneUse()) { 06189 Result = CurDAG->SelectNodeTo(N.Val, PPC::MULHDU, MVT::i64, Tmp0, Tmp1); 06190 } else { 06191 ResNode = CurDAG->getTargetNode(PPC::MULHDU, MVT::i64, Tmp0, Tmp1); 06192 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06193 Result = SDOperand(ResNode, 0); 06194 } 06195 return; 06196 } 06197 06198 // Pattern: (mulhu:i32 GPRC:i32:$rA, GPRC:i32:$rB) 06199 // Emits: (MULHWU:i32 GPRC:i32:$rA, GPRC:i32:$rB) 06200 // Pattern complexity = 2 cost = 1 06201 if (N.Val->getValueType(0) == MVT::i32) { 06202 Select(Tmp0, N0); 06203 Select(Tmp1, N1); 06204 if (N.Val->hasOneUse()) { 06205 Result = CurDAG->SelectNodeTo(N.Val, PPC::MULHWU, MVT::i32, Tmp0, Tmp1); 06206 } else { 06207 ResNode = CurDAG->getTargetNode(PPC::MULHWU, MVT::i32, Tmp0, Tmp1); 06208 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06209 Result = SDOperand(ResNode, 0); 06210 } 06211 return; 06212 } 06213 std::cerr << "Cannot yet select: "; 06214 N.Val->dump(CurDAG); 06215 std::cerr << '\n'; 06216 abort(); 06217 } 06218 06219 void Select_or(SDOperand &Result, SDOperand N) { 06220 SDOperand N0(0, 0); 06221 SDOperand N00(0, 0); 06222 SDOperand N01(0, 0); 06223 SDOperand N1(0, 0); 06224 SDOperand N10(0, 0); 06225 SDOperand N11(0, 0); 06226 SDOperand Tmp0(0, 0); 06227 SDOperand Tmp1(0, 0); 06228 SDOperand Tmp2(0, 0); 06229 SDOperand Tmp3(0, 0); 06230 SDOperand Tmp4(0, 0); 06231 SDNode *ResNode; 06232 N0 = N.getOperand(0); 06233 06234 // Pattern: (or:i32 GPRC:i32:$rS, (xor:i32 GPRC:i32:$rB, (imm:i32)<<P:Predicate_immAllOnes>>)) 06235 // Emits: (ORC:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06236 // Pattern complexity = 7 cost = 1 06237 { 06238 N1 = N.getOperand(1); 06239 if (N1.getOpcode() == ISD::XOR) { 06240 N10 = N1.getOperand(0); 06241 N11 = N1.getOperand(1); 06242 if (N11.getOpcode() == ISD::Constant && 06243 Predicate_immAllOnes(N11.Val) && 06244 N.Val->getValueType(0) == MVT::i32) { 06245 Select(Tmp0, N0); 06246 Select(Tmp1, N10); 06247 if (N.Val->hasOneUse()) { 06248 Result = CurDAG->SelectNodeTo(N.Val, PPC::ORC, MVT::i32, Tmp0, Tmp1); 06249 } else { 06250 ResNode = CurDAG->getTargetNode(PPC::ORC, MVT::i32, Tmp0, Tmp1); 06251 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06252 Result = SDOperand(ResNode, 0); 06253 } 06254 return; 06255 } 06256 } 06257 } 06258 06259 // Pattern: (or:i32 (xor:i32 GPRC:i32:$rB, (imm:i32)<<P:Predicate_immAllOnes>>), GPRC:i32:$rS) 06260 // Emits: (ORC:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06261 // Pattern complexity = 7 cost = 1 06262 if (N0.getOpcode() == ISD::XOR) { 06263 N00 = N0.getOperand(0); 06264 N01 = N0.getOperand(1); 06265 if (N01.getOpcode() == ISD::Constant && 06266 Predicate_immAllOnes(N01.Val)) { 06267 N1 = N.getOperand(1); 06268 if (N.Val->getValueType(0) == MVT::i32) { 06269 Select(Tmp0, N1); 06270 Select(Tmp1, N00); 06271 if (N.Val->hasOneUse()) { 06272 Result = CurDAG->SelectNodeTo(N.Val, PPC::ORC, MVT::i32, Tmp0, Tmp1); 06273 } else { 06274 ResNode = CurDAG->getTargetNode(PPC::ORC, MVT::i32, Tmp0, Tmp1); 06275 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06276 Result = SDOperand(ResNode, 0); 06277 } 06278 return; 06279 } 06280 } 06281 } 06282 N1 = N.getOperand(1); 06283 if (N1.getOpcode() == ISD::Constant) { 06284 06285 // Pattern: (or:i32 GPRC:i32:$src1, (imm:i32)<<P:Predicate_immZExt16>><<X:LO16>>:$src2) 06286 // Emits: (ORI:i32 GPRC:i32:$src1, (LO16:i32 (imm:i32):$src2)) 06287 // Pattern complexity = 5 cost = 1 06288 if (Predicate_immZExt16(N1.Val) && 06289 N.Val->getValueType(0) == MVT::i32) { 06290 Select(Tmp0, N0); 06291 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 06292 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 06293 Tmp2 = Transform_LO16(Tmp1.Val); 06294 if (N.Val->hasOneUse()) { 06295 Result = CurDAG->SelectNodeTo(N.Val, PPC::ORI, MVT::i32, Tmp0, Tmp2); 06296 } else { 06297 ResNode = CurDAG->getTargetNode(PPC::ORI, MVT::i32, Tmp0, Tmp2); 06298 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06299 Result = SDOperand(ResNode, 0); 06300 } 06301 return; 06302 } 06303 06304 // Pattern: (or:i32 GPRC:i32:$src1, (imm:i32)<<P:Predicate_imm16Shifted>><<X:HI16>>:$src2) 06305 // Emits: (ORIS:i32 GPRC:i32:$src1, (HI16:i32 (imm:i32):$src2)) 06306 // Pattern complexity = 5 cost = 1 06307 if (Predicate_imm16Shifted(N1.Val) && 06308 N.Val->getValueType(0) == MVT::i32) { 06309 Select(Tmp0, N0); 06310 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 06311 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 06312 Tmp2 = Transform_HI16(Tmp1.Val); 06313 if (N.Val->hasOneUse()) { 06314 Result = CurDAG->SelectNodeTo(N.Val, PPC::ORIS, MVT::i32, Tmp0, Tmp2); 06315 } else { 06316 ResNode = CurDAG->getTargetNode(PPC::ORIS, MVT::i32, Tmp0, Tmp2); 06317 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06318 Result = SDOperand(ResNode, 0); 06319 } 06320 return; 06321 } 06322 06323 // Pattern: (or:i32 GPRC:i32:$in, (imm:i32):$imm) 06324 // Emits: (ORIS:i32 (ORI:i32 GPRC:i32:$in, (LO16:i32 (imm:i32):$imm)), (HI16:i32 (imm:i32):$imm)) 06325 // Pattern complexity = 4 cost = 2 06326 if (N.Val->getValueType(0) == MVT::i32) { 06327 Select(Tmp0, N0); 06328 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 06329 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 06330 Tmp2 = Transform_LO16(Tmp1.Val); 06331 Tmp3 = SDOperand(CurDAG->getTargetNode(PPC::ORI, MVT::i32, Tmp0, Tmp2), 0); 06332 Tmp4 = Transform_HI16(Tmp1.Val); 06333 if (N.Val->hasOneUse()) { 06334 Result = CurDAG->SelectNodeTo(N.Val, PPC::ORIS, MVT::i32, Tmp3, Tmp4); 06335 } else { 06336 ResNode = CurDAG->getTargetNode(PPC::ORIS, MVT::i32, Tmp3, Tmp4); 06337 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06338 Result = SDOperand(ResNode, 0); 06339 } 06340 return; 06341 } 06342 } 06343 06344 // Pattern: (or:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06345 // Emits: (OR4:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06346 // Pattern complexity = 2 cost = 1 06347 if (N.Val->getValueType(0) == MVT::i32) { 06348 Select(Tmp0, N0); 06349 Select(Tmp1, N1); 06350 if (N.Val->hasOneUse()) { 06351 Result = CurDAG->SelectNodeTo(N.Val, PPC::OR4, MVT::i32, Tmp0, Tmp1); 06352 } else { 06353 ResNode = CurDAG->getTargetNode(PPC::OR4, MVT::i32, Tmp0, Tmp1); 06354 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06355 Result = SDOperand(ResNode, 0); 06356 } 06357 return; 06358 } 06359 06360 // Pattern: (or:i64 G8RC:i64:$rS, G8RC:i64:$rB) 06361 // Emits: (OR8:i64 G8RC:i64:$rS, G8RC:i64:$rB) 06362 // Pattern complexity = 2 cost = 1 06363 if (N.Val->getValueType(0) == MVT::i64) { 06364 Select(Tmp0, N0); 06365 Select(Tmp1, N1); 06366 if (N.Val->hasOneUse()) { 06367 Result = CurDAG->SelectNodeTo(N.Val, PPC::OR8, MVT::i64, Tmp0, Tmp1); 06368 } else { 06369 ResNode = CurDAG->getTargetNode(PPC::OR8, MVT::i64, Tmp0, Tmp1); 06370 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06371 Result = SDOperand(ResNode, 0); 06372 } 06373 return; 06374 } 06375 06376 // Pattern: (or:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 06377 // Emits: (VOR:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 06378 // Pattern complexity = 2 cost = 1 06379 if (N.Val->getValueType(0) == MVT::v4i32) { 06380 Select(Tmp0, N0); 06381 Select(Tmp1, N1); 06382 if (N.Val->hasOneUse()) { 06383 Result = CurDAG->SelectNodeTo(N.Val, PPC::VOR, MVT::v4i32, Tmp0, Tmp1); 06384 } else { 06385 ResNode = CurDAG->getTargetNode(PPC::VOR, MVT::v4i32, Tmp0, Tmp1); 06386 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06387 Result = SDOperand(ResNode, 0); 06388 } 06389 return; 06390 } 06391 06392 // Pattern: (or:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B) 06393 // Emits: (VOR:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B) 06394 // Pattern complexity = 2 cost = 1 06395 if (N.Val->getValueType(0) == MVT::v16i8) { 06396 Select(Tmp0, N0); 06397 Select(Tmp1, N1); 06398 if (N.Val->hasOneUse()) { 06399 Result = CurDAG->SelectNodeTo(N.Val, PPC::VOR, MVT::v16i8, Tmp0, Tmp1); 06400 } else { 06401 ResNode = CurDAG->getTargetNode(PPC::VOR, MVT::v16i8, Tmp0, Tmp1); 06402 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06403 Result = SDOperand(ResNode, 0); 06404 } 06405 return; 06406 } 06407 06408 // Pattern: (or:v8i16 VRRC:v8i16:$A, VRRC:v8i16:$B) 06409 // Emits: (VOR:v8i16 VRRC:v16i8:$A, VRRC:v16i8:$B) 06410 // Pattern complexity = 2 cost = 1 06411 if (N.Val->getValueType(0) == MVT::v8i16) { 06412 Select(Tmp0, N0); 06413 Select(Tmp1, N1); 06414 if (N.Val->hasOneUse()) { 06415 Result = CurDAG->SelectNodeTo(N.Val, PPC::VOR, MVT::v8i16, Tmp0, Tmp1); 06416 } else { 06417 ResNode = CurDAG->getTargetNode(PPC::VOR, MVT::v8i16, Tmp0, Tmp1); 06418 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06419 Result = SDOperand(ResNode, 0); 06420 } 06421 return; 06422 } 06423 std::cerr << "Cannot yet select: "; 06424 N.Val->dump(CurDAG); 06425 std::cerr << '\n'; 06426 abort(); 06427 } 06428 06429 void Select_ret(SDOperand &Result, SDOperand N) { 06430 SDOperand Chain(0, 0); 06431 SDNode *ResNode; 06432 Chain = N.getOperand(0); 06433 Select(Chain, Chain); 06434 ResNode = CurDAG->getTargetNode(PPC::BLR, MVT::Other, Chain); 06435 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 06436 Result = SDOperand(ResNode, N.ResNo); 06437 return; 06438 } 06439 06440 void Select_retflag(SDOperand &Result, SDOperand N) { 06441 SDOperand Chain(0, 0); 06442 SDOperand InFlag(0, 0); 06443 SDNode *ResNode; 06444 Chain = N.getOperand(0); 06445 bool HasOptInFlag = false; 06446 Select(Chain, Chain); 06447 if (N.getNumOperands() == 2) { 06448 Select(InFlag, N.getOperand(1)); 06449 HasOptInFlag = true; 06450 } 06451 if (HasOptInFlag) 06452 ResNode = CurDAG->getTargetNode(PPC::BLR, MVT::Other, Chain, InFlag); 06453 else 06454 ResNode = CurDAG->getTargetNode(PPC::BLR, MVT::Other, Chain); 06455 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 06456 Result = SDOperand(ResNode, N.ResNo); 06457 return; 06458 } 06459 06460 void Select_rotl(SDOperand &Result, SDOperand N) { 06461 SDOperand N0(0, 0); 06462 SDOperand N1(0, 0); 06463 SDOperand Tmp0(0, 0); 06464 SDOperand Tmp1(0, 0); 06465 SDOperand Tmp2(0, 0); 06466 SDOperand Tmp3(0, 0); 06467 SDNode *ResNode; 06468 N0 = N.getOperand(0); 06469 N1 = N.getOperand(1); 06470 06471 // Pattern: (rotl:i32 GPRC:i32:$in, (imm:i32):$imm) 06472 // Emits: (RLWINM:i32 GPRC:i32:$in, (imm:i32):$imm, 0:i32, 31:i32) 06473 // Pattern complexity = 4 cost = 1 06474 if (N1.getOpcode() == ISD::Constant && 06475 N.Val->getValueType(0) == MVT::i32 && 06476 N1.Val->getValueType(0) == MVT::i32) { 06477 Select(Tmp0, N0); 06478 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 06479 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 06480 Tmp2 = CurDAG->getTargetConstant(0, MVT::i32); 06481 Tmp3 = CurDAG->getTargetConstant(31, MVT::i32); 06482 if (N.Val->hasOneUse()) { 06483 Result = CurDAG->SelectNodeTo(N.Val, PPC::RLWINM, MVT::i32, Tmp0, Tmp1, Tmp2, Tmp3); 06484 } else { 06485 ResNode = CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Tmp0, Tmp1, Tmp2, Tmp3); 06486 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06487 Result = SDOperand(ResNode, 0); 06488 } 06489 return; 06490 } 06491 06492 // Pattern: (rotl:i32 GPRC:i32:$in, GPRC:i32:$sh) 06493 // Emits: (RLWNM:i32 GPRC:i32:$in, GPRC:i32:$sh, 0:i32, 31:i32) 06494 // Pattern complexity = 2 cost = 1 06495 if (N.Val->getValueType(0) == MVT::i32 && 06496 N1.Val->getValueType(0) == MVT::i32) { 06497 Select(Tmp0, N0); 06498 Select(Tmp1, N1); 06499 Tmp2 = CurDAG->getTargetConstant(0, MVT::i32); 06500 Tmp3 = CurDAG->getTargetConstant(31, MVT::i32); 06501 if (N.Val->hasOneUse()) { 06502 Result = CurDAG->SelectNodeTo(N.Val, PPC::RLWNM, MVT::i32, Tmp0, Tmp1, Tmp2, Tmp3); 06503 } else { 06504 ResNode = CurDAG->getTargetNode(PPC::RLWNM, MVT::i32, Tmp0, Tmp1, Tmp2, Tmp3); 06505 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06506 Result = SDOperand(ResNode, 0); 06507 } 06508 return; 06509 } 06510 std::cerr << "Cannot yet select: "; 06511 N.Val->dump(CurDAG); 06512 std::cerr << '\n'; 06513 abort(); 06514 } 06515 06516 void Select_sdiv(SDOperand &Result, SDOperand N) { 06517 SDOperand N0(0, 0); 06518 SDOperand N1(0, 0); 06519 SDOperand Tmp0(0, 0); 06520 SDOperand Tmp1(0, 0); 06521 SDNode *ResNode; 06522 N0 = N.getOperand(0); 06523 N1 = N.getOperand(1); 06524 06525 // Pattern: (sdiv:i64 G8RC:i64:$rA, G8RC:i64:$rB) 06526 // Emits: (DIVD:i64 G8RC:i64:$rA, G8RC:i64:$rB) 06527 // Pattern complexity = 2 cost = 1 06528 if (N.Val->getValueType(0) == MVT::i64) { 06529 Select(Tmp0, N0); 06530 Select(Tmp1, N1); 06531 if (N.Val->hasOneUse()) { 06532 Result = CurDAG->SelectNodeTo(N.Val, PPC::DIVD, MVT::i64, Tmp0, Tmp1); 06533 } else { 06534 ResNode = CurDAG->getTargetNode(PPC::DIVD, MVT::i64, Tmp0, Tmp1); 06535 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06536 Result = SDOperand(ResNode, 0); 06537 } 06538 return; 06539 } 06540 06541 // Pattern: (sdiv:i32 GPRC:i32:$rA, GPRC:i32:$rB) 06542 // Emits: (DIVW:i32 GPRC:i32:$rA, GPRC:i32:$rB) 06543 // Pattern complexity = 2 cost = 1 06544 if (N.Val->getValueType(0) == MVT::i32) { 06545 Select(Tmp0, N0); 06546 Select(Tmp1, N1); 06547 if (N.Val->hasOneUse()) { 06548 Result = CurDAG->SelectNodeTo(N.Val, PPC::DIVW, MVT::i32, Tmp0, Tmp1); 06549 } else { 06550 ResNode = CurDAG->getTargetNode(PPC::DIVW, MVT::i32, Tmp0, Tmp1); 06551 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06552 Result = SDOperand(ResNode, 0); 06553 } 06554 return; 06555 } 06556 std::cerr << "Cannot yet select: "; 06557 N.Val->dump(CurDAG); 06558 std::cerr << '\n'; 06559 abort(); 06560 } 06561 06562 void Select_sext_inreg(SDOperand &Result, SDOperand N) { 06563 SDOperand N0(0, 0); 06564 SDOperand N1(0, 0); 06565 SDOperand Tmp0(0, 0); 06566 SDNode *ResNode; 06567 N0 = N.getOperand(0); 06568 N1 = N.getOperand(1); 06569 06570 // Pattern: (sext_inreg:i32 GPRC:i32:$rS, i8:Other) 06571 // Emits: (EXTSB:i32 GPRC:i32:$rS) 06572 // Pattern complexity = 2 cost = 1 06573 if (cast<VTSDNode>(N1)->getVT() == MVT::i8 && 06574 N.Val->getValueType(0) == MVT::i32) { 06575 Select(Tmp0, N0); 06576 if (N.Val->hasOneUse()) { 06577 Result = CurDAG->SelectNodeTo(N.Val, PPC::EXTSB, MVT::i32, Tmp0); 06578 } else { 06579 ResNode = CurDAG->getTargetNode(PPC::EXTSB, MVT::i32, Tmp0); 06580 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06581 Result = SDOperand(ResNode, 0); 06582 } 06583 return; 06584 } 06585 06586 // Pattern: (sext_inreg:i32 GPRC:i32:$rS, i16:Other) 06587 // Emits: (EXTSH:i32 GPRC:i32:$rS) 06588 // Pattern complexity = 2 cost = 1 06589 if (cast<VTSDNode>(N1)->getVT() == MVT::i16 && 06590 N.Val->getValueType(0) == MVT::i32) { 06591 Select(Tmp0, N0); 06592 if (N.Val->hasOneUse()) { 06593 Result = CurDAG->SelectNodeTo(N.Val, PPC::EXTSH, MVT::i32, Tmp0); 06594 } else { 06595 ResNode = CurDAG->getTargetNode(PPC::EXTSH, MVT::i32, Tmp0); 06596 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06597 Result = SDOperand(ResNode, 0); 06598 } 06599 return; 06600 } 06601 06602 // Pattern: (sext_inreg:i64 G8RC:i64:$rS, i32:Other) 06603 // Emits: (EXTSW:i64 G8RC:i64:$rS) 06604 // Pattern complexity = 2 cost = 1 06605 if (cast<VTSDNode>(N1)->getVT() == MVT::i32 && 06606 N.Val->getValueType(0) == MVT::i64) { 06607 Select(Tmp0, N0); 06608 if (N.Val->hasOneUse()) { 06609 Result = CurDAG->SelectNodeTo(N.Val, PPC::EXTSW, MVT::i64, Tmp0); 06610 } else { 06611 ResNode = CurDAG->getTargetNode(PPC::EXTSW, MVT::i64, Tmp0); 06612 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06613 Result = SDOperand(ResNode, 0); 06614 } 06615 return; 06616 } 06617 std::cerr << "Cannot yet select: "; 06618 N.Val->dump(CurDAG); 06619 std::cerr << '\n'; 06620 abort(); 06621 } 06622 06623 void Select_sextld(SDOperand &Result, SDOperand N) { 06624 if (N.ResNo == 1 && N.getValue(0).hasOneUse()) { 06625 SDOperand Dummy = CurDAG->getNode(ISD::HANDLENODE, MVT::Other, N); 06626 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Dummy.Val, 0); 06627 SelectionDAG::InsertISelMapEntry(HandleMap, N.Val, 1, Dummy.Val, 0); 06628 Result = Dummy; 06629 return; 06630 } 06631 SDOperand Chain(0, 0); 06632 SDOperand N1(0, 0); 06633 SDOperand N2(0, 0); 06634 SDOperand N3(0, 0); 06635 SDOperand Tmp0(0, 0); 06636 SDOperand Tmp1(0, 0); 06637 SDNode *ResNode; 06638 Chain = N.getOperand(0); 06639 N1 = N.getOperand(1); 06640 N2 = N.getOperand(2); 06641 N3 = N.getOperand(3); 06642 if (cast<VTSDNode>(N3)->getVT() == MVT::i16 && 06643 N.Val->getValueType(0) == MVT::i32) { 06644 06645 // Pattern: (sextld:i32 iaddr:i32:$src, srcvalue:Other:$dummy, i16:Other) 06646 // Emits: (LHA:i32 iaddr:i32:$src) 06647 // Pattern complexity = 8 cost = 1 06648 if (SelectAddrImm(N1, Tmp0, Tmp1)) { 06649 Select(Tmp0, Tmp0); 06650 Select(Tmp1, Tmp1); 06651 Select(Chain, Chain); 06652 ResNode = CurDAG->getTargetNode(PPC::LHA, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain); 06653 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 06654 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 06655 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 06656 Result = SDOperand(ResNode, N.ResNo); 06657 return; 06658 } 06659 06660 // Pattern: (sextld:i32 xaddr:i32:$src, srcvalue:Other:$dummy, i16:Other) 06661 // Emits: (LHAX:i32 xaddr:i32:$src) 06662 // Pattern complexity = 8 cost = 1 06663 if (SelectAddrIdx(N1, Tmp0, Tmp1)) { 06664 Select(Tmp0, Tmp0); 06665 Select(Tmp1, Tmp1); 06666 Select(Chain, Chain); 06667 ResNode = CurDAG->getTargetNode(PPC::LHAX, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain); 06668 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 06669 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 06670 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 06671 Result = SDOperand(ResNode, N.ResNo); 06672 return; 06673 } 06674 } 06675 06676 // Pattern: (sextld:i64 xaddr:i32:$src, srcvalue:Other:$dummy, i32:Other) 06677 // Emits: (LWAX:i64 xaddr:i32:$src) 06678 // Pattern complexity = 8 cost = 1 06679 if (cast<VTSDNode>(N3)->getVT() == MVT::i32 && 06680 N.Val->getValueType(0) == MVT::i64 && 06681 SelectAddrIdx(N1, Tmp0, Tmp1)) { 06682 Select(Tmp0, Tmp0); 06683 Select(Tmp1, Tmp1); 06684 Select(Chain, Chain); 06685 ResNode = CurDAG->getTargetNode(PPC::LWAX, MVT::i64, MVT::Other, Tmp0, Tmp1, Chain); 06686 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 06687 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 06688 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 06689 Result = SDOperand(ResNode, N.ResNo); 06690 return; 06691 } 06692 std::cerr << "Cannot yet select: "; 06693 N.Val->dump(CurDAG); 06694 std::cerr << '\n'; 06695 abort(); 06696 } 06697 06698 void Select_shl(SDOperand &Result, SDOperand N) { 06699 SDOperand N0(0, 0); 06700 SDOperand N1(0, 0); 06701 SDOperand Tmp0(0, 0); 06702 SDOperand Tmp1(0, 0); 06703 SDOperand Tmp2(0, 0); 06704 SDOperand Tmp3(0, 0); 06705 SDNode *ResNode; 06706 N0 = N.getOperand(0); 06707 N1 = N.getOperand(1); 06708 if (N1.getOpcode() == ISD::Constant) { 06709 06710 // Pattern: (shl:i64 G8RC:i64:$in, (imm:i64):$imm) 06711 // Emits: (RLDICR:i64 G8RC:i64:$in, (imm:i32):$imm, (SHL64:i32 (imm:i32):$imm)) 06712 // Pattern complexity = 4 cost = 1 06713 if (N.Val->getValueType(0) == MVT::i64 && 06714 N1.Val->getValueType(0) == MVT::i64) { 06715 Select(Tmp0, N0); 06716 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 06717 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 06718 Tmp2 = Transform_SHL64(Tmp1.Val); 06719 if (N.Val->hasOneUse()) { 06720 Result = CurDAG->SelectNodeTo(N.Val, PPC::RLDICR, MVT::i64, Tmp0, Tmp1, Tmp2); 06721 } else { 06722 ResNode = CurDAG->getTargetNode(PPC::RLDICR, MVT::i64, Tmp0, Tmp1, Tmp2); 06723 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06724 Result = SDOperand(ResNode, 0); 06725 } 06726 return; 06727 } 06728 06729 // Pattern: (shl:i32 GPRC:i32:$in, (imm:i32):$imm) 06730 // Emits: (RLWINM:i32 GPRC:i32:$in, (imm:i32):$imm, 0:i32, (SHL32:i32 (imm:i32):$imm)) 06731 // Pattern complexity = 4 cost = 1 06732 if (N.Val->getValueType(0) == MVT::i32 && 06733 N1.Val->getValueType(0) == MVT::i32) { 06734 Select(Tmp0, N0); 06735 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 06736 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 06737 Tmp2 = CurDAG->getTargetConstant(0, MVT::i32); 06738 Tmp3 = Transform_SHL32(Tmp1.Val); 06739 if (N.Val->hasOneUse()) { 06740 Result = CurDAG->SelectNodeTo(N.Val, PPC::RLWINM, MVT::i32, Tmp0, Tmp1, Tmp2, Tmp3); 06741 } else { 06742 ResNode = CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Tmp0, Tmp1, Tmp2, Tmp3); 06743 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06744 Result = SDOperand(ResNode, 0); 06745 } 06746 return; 06747 } 06748 } 06749 06750 // Pattern: (shl:i64 G8RC:i64:$rS, G8RC:i64:$rB) 06751 // Emits: (SLD:i64 G8RC:i64:$rS, G8RC:i64:$rB) 06752 // Pattern complexity = 2 cost = 1 06753 if (N.Val->getValueType(0) == MVT::i64 && 06754 N1.Val->getValueType(0) == MVT::i64) { 06755 Select(Tmp0, N0); 06756 Select(Tmp1, N1); 06757 if (N.Val->hasOneUse()) { 06758 Result = CurDAG->SelectNodeTo(N.Val, PPC::SLD, MVT::i64, Tmp0, Tmp1); 06759 } else { 06760 ResNode = CurDAG->getTargetNode(PPC::SLD, MVT::i64, Tmp0, Tmp1); 06761 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06762 Result = SDOperand(ResNode, 0); 06763 } 06764 return; 06765 } 06766 06767 // Pattern: (shl:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06768 // Emits: (SLW:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06769 // Pattern complexity = 2 cost = 1 06770 if (N.Val->getValueType(0) == MVT::i32 && 06771 N1.Val->getValueType(0) == MVT::i32) { 06772 Select(Tmp0, N0); 06773 Select(Tmp1, N1); 06774 if (N.Val->hasOneUse()) { 06775 Result = CurDAG->SelectNodeTo(N.Val, PPC::SLW, MVT::i32, Tmp0, Tmp1); 06776 } else { 06777 ResNode = CurDAG->getTargetNode(PPC::SLW, MVT::i32, Tmp0, Tmp1); 06778 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06779 Result = SDOperand(ResNode, 0); 06780 } 06781 return; 06782 } 06783 std::cerr << "Cannot yet select: "; 06784 N.Val->dump(CurDAG); 06785 std::cerr << '\n'; 06786 abort(); 06787 } 06788 06789 void Select_sra(SDOperand &Result, SDOperand N) { 06790 SDOperand N0(0, 0); 06791 SDOperand N1(0, 0); 06792 SDOperand Tmp0(0, 0); 06793 SDOperand Tmp1(0, 0); 06794 SDNode *ResNode; 06795 N0 = N.getOperand(0); 06796 N1 = N.getOperand(1); 06797 06798 // Pattern: (sra:i32 GPRC:i32:$rS, (imm:i32):$SH) 06799 // Emits: (SRAWI:i32 GPRC:i32:$rS, (imm:i32):$SH) 06800 // Pattern complexity = 4 cost = 1 06801 if (N1.getOpcode() == ISD::Constant && 06802 N.Val->getValueType(0) == MVT::i32 && 06803 N1.Val->getValueType(0) == MVT::i32) { 06804 Select(Tmp0, N0); 06805 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 06806 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 06807 if (N.Val->hasOneUse()) { 06808 Result = CurDAG->SelectNodeTo(N.Val, PPC::SRAWI, MVT::i32, Tmp0, Tmp1); 06809 } else { 06810 ResNode = CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, Tmp0, Tmp1); 06811 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06812 Result = SDOperand(ResNode, 0); 06813 } 06814 return; 06815 } 06816 06817 // Pattern: (sra:i64 G8RC:i64:$rS, G8RC:i64:$rB) 06818 // Emits: (SRAD:i64 G8RC:i64:$rS, G8RC:i64:$rB) 06819 // Pattern complexity = 2 cost = 1 06820 if (N.Val->getValueType(0) == MVT::i64 && 06821 N1.Val->getValueType(0) == MVT::i64) { 06822 Select(Tmp0, N0); 06823 Select(Tmp1, N1); 06824 if (N.Val->hasOneUse()) { 06825 Result = CurDAG->SelectNodeTo(N.Val, PPC::SRAD, MVT::i64, Tmp0, Tmp1); 06826 } else { 06827 ResNode = CurDAG->getTargetNode(PPC::SRAD, MVT::i64, Tmp0, Tmp1); 06828 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06829 Result = SDOperand(ResNode, 0); 06830 } 06831 return; 06832 } 06833 06834 // Pattern: (sra:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06835 // Emits: (SRAW:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06836 // Pattern complexity = 2 cost = 1 06837 if (N.Val->getValueType(0) == MVT::i32 && 06838 N1.Val->getValueType(0) == MVT::i32) { 06839 Select(Tmp0, N0); 06840 Select(Tmp1, N1); 06841 if (N.Val->hasOneUse()) { 06842 Result = CurDAG->SelectNodeTo(N.Val, PPC::SRAW, MVT::i32, Tmp0, Tmp1); 06843 } else { 06844 ResNode = CurDAG->getTargetNode(PPC::SRAW, MVT::i32, Tmp0, Tmp1); 06845 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06846 Result = SDOperand(ResNode, 0); 06847 } 06848 return; 06849 } 06850 std::cerr << "Cannot yet select: "; 06851 N.Val->dump(CurDAG); 06852 std::cerr << '\n'; 06853 abort(); 06854 } 06855 06856 void Select_srl(SDOperand &Result, SDOperand N) { 06857 SDOperand N0(0, 0); 06858 SDOperand N1(0, 0); 06859 SDOperand Tmp0(0, 0); 06860 SDOperand Tmp1(0, 0); 06861 SDOperand Tmp2(0, 0); 06862 SDOperand Tmp3(0, 0); 06863 SDNode *ResNode; 06864 N0 = N.getOperand(0); 06865 N1 = N.getOperand(1); 06866 if (N1.getOpcode() == ISD::Constant) { 06867 06868 // Pattern: (srl:i32 GPRC:i32:$in, (imm:i32):$imm) 06869 // Emits: (RLWINM:i32 GPRC:i32:$in, (SRL32:i32 (imm:i32):$imm), (imm:i32):$imm, 31:i32) 06870 // Pattern complexity = 4 cost = 1 06871 if (N.Val->getValueType(0) == MVT::i32 && 06872 N1.Val->getValueType(0) == MVT::i32) { 06873 Select(Tmp0, N0); 06874 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 06875 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 06876 Tmp2 = Transform_SRL32(Tmp1.Val); 06877 Tmp3 = CurDAG->getTargetConstant(31, MVT::i32); 06878 if (N.Val->hasOneUse()) { 06879 Result = CurDAG->SelectNodeTo(N.Val, PPC::RLWINM, MVT::i32, Tmp0, Tmp2, Tmp1, Tmp3); 06880 } else { 06881 ResNode = CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Tmp0, Tmp2, Tmp1, Tmp3); 06882 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06883 Result = SDOperand(ResNode, 0); 06884 } 06885 return; 06886 } 06887 06888 // Pattern: (srl:i64 G8RC:i64:$in, (imm:i64):$imm) 06889 // Emits: (RLDICL:i64 G8RC:i64:$in, (SRL64:i32 (imm:i32):$imm), (imm:i32):$imm) 06890 // Pattern complexity = 4 cost = 1 06891 if (N.Val->getValueType(0) == MVT::i64 && 06892 N1.Val->getValueType(0) == MVT::i64) { 06893 Select(Tmp0, N0); 06894 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 06895 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 06896 Tmp2 = Transform_SRL64(Tmp1.Val); 06897 if (N.Val->hasOneUse()) { 06898 Result = CurDAG->SelectNodeTo(N.Val, PPC::RLDICL, MVT::i64, Tmp0, Tmp2, Tmp1); 06899 } else { 06900 ResNode = CurDAG->getTargetNode(PPC::RLDICL, MVT::i64, Tmp0, Tmp2, Tmp1); 06901 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06902 Result = SDOperand(ResNode, 0); 06903 } 06904 return; 06905 } 06906 } 06907 06908 // Pattern: (srl:i64 G8RC:i64:$rS, G8RC:i64:$rB) 06909 // Emits: (SRD:i64 G8RC:i64:$rS, G8RC:i64:$rB) 06910 // Pattern complexity = 2 cost = 1 06911 if (N.Val->getValueType(0) == MVT::i64 && 06912 N1.Val->getValueType(0) == MVT::i64) { 06913 Select(Tmp0, N0); 06914 Select(Tmp1, N1); 06915 if (N.Val->hasOneUse()) { 06916 Result = CurDAG->SelectNodeTo(N.Val, PPC::SRD, MVT::i64, Tmp0, Tmp1); 06917 } else { 06918 ResNode = CurDAG->getTargetNode(PPC::SRD, MVT::i64, Tmp0, Tmp1); 06919 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06920 Result = SDOperand(ResNode, 0); 06921 } 06922 return; 06923 } 06924 06925 // Pattern: (srl:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06926 // Emits: (SRW:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06927 // Pattern complexity = 2 cost = 1 06928 if (N.Val->getValueType(0) == MVT::i32 && 06929 N1.Val->getValueType(0) == MVT::i32) { 06930 Select(Tmp0, N0); 06931 Select(Tmp1, N1); 06932 if (N.Val->hasOneUse()) { 06933 Result = CurDAG->SelectNodeTo(N.Val, PPC::SRW, MVT::i32, Tmp0, Tmp1); 06934 } else { 06935 ResNode = CurDAG->getTargetNode(PPC::SRW, MVT::i32, Tmp0, Tmp1); 06936 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06937 Result = SDOperand(ResNode, 0); 06938 } 06939 return; 06940 } 06941 std::cerr << "Cannot yet select: "; 06942 N.Val->dump(CurDAG); 06943 std::cerr << '\n'; 06944 abort(); 06945 } 06946 06947 void Select_store(SDOperand &Result, SDOperand N) { 06948 SDOperand Chain(0, 0); 06949 SDOperand N1(0, 0); 06950 SDOperand N2(0, 0); 06951 SDOperand Tmp0(0, 0); 06952 SDOperand Tmp1(0, 0); 06953 SDOperand Tmp2(0, 0); 06954 SDNode *ResNode; 06955 Chain = N.getOperand(0); 06956 N1 = N.getOperand(1); 06957 N2 = N.getOperand(2); 06958 06959 // Pattern: (store:void GPRC:i32:$rS, iaddr:i32:$src) 06960 // Emits: (STW:void GPRC:i32:$rS, iaddr:i32:$src) 06961 // Pattern complexity = 8 cost = 1 06962 if (N1.Val->getValueType(0) == MVT::i32 && 06963 SelectAddrImm(N2, Tmp0, Tmp1)) { 06964 Select(Tmp0, Tmp0); 06965 Select(Tmp1, Tmp1); 06966 Select(Tmp2, N1); 06967 Select(Chain, Chain); 06968 ResNode = CurDAG->getTargetNode(PPC::STW, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 06969 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 06970 Result = SDOperand(ResNode, N.ResNo); 06971 return; 06972 } 06973 06974 // Pattern: (store:void F4RC:f32:$rS, iaddr:i32:$dst) 06975 // Emits: (STFS:void F4RC:f32:$rS, iaddr:i32:$dst) 06976 // Pattern complexity = 8 cost = 1 06977 if (N1.Val->getValueType(0) == MVT::f32 && 06978 SelectAddrImm(N2, Tmp0, Tmp1)) { 06979 Select(Tmp0, Tmp0); 06980 Select(Tmp1, Tmp1); 06981 Select(Tmp2, N1); 06982 Select(Chain, Chain); 06983 ResNode = CurDAG->getTargetNode(PPC::STFS, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 06984 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 06985 Result = SDOperand(ResNode, N.ResNo); 06986 return; 06987 } 06988 06989 // Pattern: (store:void F8RC:f64:$rS, iaddr:i32:$dst) 06990 // Emits: (STFD:void F8RC:f64:$rS, iaddr:i32:$dst) 06991 // Pattern complexity = 8 cost = 1 06992 if (N1.Val->getValueType(0) == MVT::f64 && 06993 SelectAddrImm(N2, Tmp0, Tmp1)) { 06994 Select(Tmp0, Tmp0); 06995 Select(Tmp1, Tmp1); 06996 Select(Tmp2, N1); 06997 Select(Chain, Chain); 06998 ResNode = CurDAG->getTargetNode(PPC::STFD, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 06999 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07000 Result = SDOperand(ResNode, N.ResNo); 07001 return; 07002 } 07003 07004 // Pattern: (store:void GPRC:i32:$rS, xaddr:i32:$dst) 07005 // Emits: (STWX:void GPRC:i32:$rS, xaddr:i32:$dst) 07006 // Pattern complexity = 8 cost = 1 07007 if (N1.Val->getValueType(0) == MVT::i32 && 07008 SelectAddrIdx(N2, Tmp0, Tmp1)) { 07009 Select(Tmp0, Tmp0); 07010 Select(Tmp1, Tmp1); 07011 Select(Tmp2, N1); 07012 Select(Chain, Chain); 07013 ResNode = CurDAG->getTargetNode(PPC::STWX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 07014 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07015 Result = SDOperand(ResNode, N.ResNo); 07016 return; 07017 } 07018 07019 // Pattern: (store:void F4RC:f32:$frS, xaddr:i32:$dst) 07020 // Emits: (STFSX:void F4RC:f32:$frS, xaddr:i32:$dst) 07021 // Pattern complexity = 8 cost = 1 07022 if (N1.Val->getValueType(0) == MVT::f32 && 07023 SelectAddrIdx(N2, Tmp0, Tmp1)) { 07024 Select(Tmp0, Tmp0); 07025 Select(Tmp1, Tmp1); 07026 Select(Tmp2, N1); 07027 Select(Chain, Chain); 07028 ResNode = CurDAG->getTargetNode(PPC::STFSX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 07029 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07030 Result = SDOperand(ResNode, N.ResNo); 07031 return; 07032 } 07033 07034 // Pattern: (store:void F8RC:f64:$frS, xaddr:i32:$dst) 07035 // Emits: (STFDX:void F8RC:f64:$frS, xaddr:i32:$dst) 07036 // Pattern complexity = 8 cost = 1 07037 if (N1.Val->getValueType(0) == MVT::f64 && 07038 SelectAddrIdx(N2, Tmp0, Tmp1)) { 07039 Select(Tmp0, Tmp0); 07040 Select(Tmp1, Tmp1); 07041 Select(Tmp2, N1); 07042 Select(Chain, Chain); 07043 ResNode = CurDAG->getTargetNode(PPC::STFDX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 07044 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07045 Result = SDOperand(ResNode, N.ResNo); 07046 return; 07047 } 07048 07049 // Pattern: (store:void VRRC:v16i8:$rS, xoaddr:i32:$dst) 07050 // Emits: (STVX:void VRRC:v16i8:$rS, xoaddr:i32:$dst) 07051 // Pattern complexity = 8 cost = 1 07052 if (N1.Val->getValueType(0) == MVT::v16i8 && 07053 SelectAddrIdxOnly(N2, Tmp0, Tmp1)) { 07054 Select(Tmp0, Tmp0); 07055 Select(Tmp1, Tmp1); 07056 Select(Tmp2, N1); 07057 Select(Chain, Chain); 07058 ResNode = CurDAG->getTargetNode(PPC::STVX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 07059 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07060 Result = SDOperand(ResNode, N.ResNo); 07061 return; 07062 } 07063 07064 // Pattern: (store:void VRRC:v8i16:$rS, xoaddr:i32:$dst) 07065 // Emits: (STVX:void VRRC:v8i16:$rS, xoaddr:i32:$dst) 07066 // Pattern complexity = 8 cost = 1 07067 if (N1.Val->getValueType(0) == MVT::v8i16 && 07068 SelectAddrIdxOnly(N2, Tmp0, Tmp1)) { 07069 Select(Tmp0, Tmp0); 07070 Select(Tmp1, Tmp1); 07071 Select(Tmp2, N1); 07072 Select(Chain, Chain); 07073 ResNode = CurDAG->getTargetNode(PPC::STVX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 07074 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07075 Result = SDOperand(ResNode, N.ResNo); 07076 return; 07077 } 07078 07079 // Pattern: (store:void VRRC:v4i32:$rS, xoaddr:i32:$dst) 07080 // Emits: (STVX:void VRRC:v4i32:$rS, xoaddr:i32:$dst) 07081 // Pattern complexity = 8 cost = 1 07082 if (N1.Val->getValueType(0) == MVT::v4i32 && 07083 SelectAddrIdxOnly(N2, Tmp0, Tmp1)) { 07084 Select(Tmp0, Tmp0); 07085 Select(Tmp1, Tmp1); 07086 Select(Tmp2, N1); 07087 Select(Chain, Chain); 07088 ResNode = CurDAG->getTargetNode(PPC::STVX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 07089 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07090 Result = SDOperand(ResNode, N.ResNo); 07091 return; 07092 } 07093 07094 // Pattern: (store:void VRRC:v4f32:$rS, xoaddr:i32:$dst) 07095 // Emits: (STVX:void VRRC:v4f32:$rS, xoaddr:i32:$dst) 07096 // Pattern complexity = 8 cost = 1 07097 if (N1.Val->getValueType(0) == MVT::v4f32 && 07098 SelectAddrIdxOnly(N2, Tmp0, Tmp1)) { 07099 Select(Tmp0, Tmp0); 07100 Select(Tmp1, Tmp1); 07101 Select(Tmp2, N1); 07102 Select(Chain, Chain); 07103 ResNode = CurDAG->getTargetNode(PPC::STVX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 07104 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07105 Result = SDOperand(ResNode, N.ResNo); 07106 return; 07107 } 07108 std::cerr << "Cannot yet select: "; 07109 N.Val->dump(CurDAG); 07110 std::cerr << '\n'; 07111 abort(); 07112 } 07113 07114 void Select_sub(SDOperand &Result, SDOperand N) { 07115 SDOperand N0(0, 0); 07116 SDOperand N1(0, 0); 07117 SDOperand Tmp0(0, 0); 07118 SDOperand Tmp1(0, 0); 07119 SDNode *ResNode; 07120 N0 = N.getOperand(0); 07121 07122 // Pattern: (sub:i32 0:i32, GPRC:i32:$rA) 07123 // Emits: (NEG:i32 GPRC:i32:$rA) 07124 // Pattern complexity = 5 cost = 1 07125 if (isa<ConstantSDNode>(N0)) { 07126 int64_t CN0 = cast<ConstantSDNode>(N0)->getSignExtended(); 07127 if (CN0 == 0) { 07128 N1 = N.getOperand(1); 07129 if (N.Val->getValueType(0) == MVT::i32) { 07130 Select(Tmp1, N1); 07131 if (N.Val->hasOneUse()) { 07132 Result = CurDAG->SelectNodeTo(N.Val, PPC::NEG, MVT::i32, Tmp1); 07133 } else { 07134 ResNode = CurDAG->getTargetNode(PPC::NEG, MVT::i32, Tmp1); 07135 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07136 Result = SDOperand(ResNode, 0); 07137 } 07138 return; 07139 } 07140 } 07141 } 07142 07143 // Pattern: (sub:i32 (imm:i32)<<P:Predicate_immSExt16>>:$imm, GPRC:i32:$in) 07144 // Emits: (SUBFIC:i32 GPRC:i32:$in, (imm:i32):$imm) 07145 // Pattern complexity = 5 cost = 1 07146 if (N0.getOpcode() == ISD::Constant && 07147 Predicate_immSExt16(N0.Val)) { 07148 N1 = N.getOperand(1); 07149 if (N.Val->getValueType(0) == MVT::i32) { 07150 Select(Tmp0, N1); 07151 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N0)->getValue(); 07152 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 07153 if (N.Val->hasOneUse()) { 07154 Result = CurDAG->SelectNodeTo(N.Val, PPC::SUBFIC, MVT::i32, Tmp0, Tmp1); 07155 } else { 07156 ResNode = CurDAG->getTargetNode(PPC::SUBFIC, MVT::i32, Tmp0, Tmp1); 07157 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07158 Result = SDOperand(ResNode, 0); 07159 } 07160 return; 07161 } 07162 } 07163 N1 = N.getOperand(1); 07164 07165 // Pattern: (sub:i32 GPRC:i32:$rB, GPRC:i32:$rA) 07166 // Emits: (SUBF:i32 GPRC:i32:$rA, GPRC:i32:$rB) 07167 // Pattern complexity = 2 cost = 1 07168 if (N.Val->getValueType(0) == MVT::i32) { 07169 Select(Tmp0, N1); 07170 Select(Tmp1, N0); 07171 if (N.Val->hasOneUse()) { 07172 Result = CurDAG->SelectNodeTo(N.Val, PPC::SUBF, MVT::i32, Tmp0, Tmp1); 07173 } else { 07174 ResNode = CurDAG->getTargetNode(PPC::SUBF, MVT::i32, Tmp0, Tmp1); 07175 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07176 Result = SDOperand(ResNode, 0); 07177 } 07178 return; 07179 } 07180 07181 // Pattern: (sub:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 07182 // Emits: (VSUBUBM:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 07183 // Pattern complexity = 2 cost = 1 07184 if (N.Val->getValueType(0) == MVT::v16i8) { 07185 Select(Tmp0, N0); 07186 Select(Tmp1, N1); 07187 if (N.Val->hasOneUse()) { 07188 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBUBM, MVT::v16i8, Tmp0, Tmp1); 07189 } else { 07190 ResNode = CurDAG->getTargetNode(PPC::VSUBUBM, MVT::v16i8, Tmp0, Tmp1); 07191 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07192 Result = SDOperand(ResNode, 0); 07193 } 07194 return; 07195 } 07196 07197 // Pattern: (sub:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 07198 // Emits: (VSUBUHM:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 07199 // Pattern complexity = 2 cost = 1 07200 if (N.Val->getValueType(0) == MVT::v8i16) { 07201 Select(Tmp0, N0); 07202 Select(Tmp1, N1); 07203 if (N.Val->hasOneUse()) { 07204 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBUHM, MVT::v8i16, Tmp0, Tmp1); 07205 } else { 07206 ResNode = CurDAG->getTargetNode(PPC::VSUBUHM, MVT::v8i16, Tmp0, Tmp1); 07207 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07208 Result = SDOperand(ResNode, 0); 07209 } 07210 return; 07211 } 07212 07213 // Pattern: (sub:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 07214 // Emits: (VSUBUWM:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 07215 // Pattern complexity = 2 cost = 1 07216 if (N.Val->getValueType(0) == MVT::v4i32) { 07217 Select(Tmp0, N0); 07218 Select(Tmp1, N1); 07219 if (N.Val->hasOneUse()) { 07220 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBUWM, MVT::v4i32, Tmp0, Tmp1); 07221 } else { 07222 ResNode = CurDAG->getTargetNode(PPC::VSUBUWM, MVT::v4i32, Tmp0, Tmp1); 07223 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07224 Result = SDOperand(ResNode, 0); 07225 } 07226 return; 07227 } 07228 std::cerr << "Cannot yet select: "; 07229 N.Val->dump(CurDAG); 07230 std::cerr << '\n'; 07231 abort(); 07232 } 07233 07234 void Select_subc(SDOperand &Result, SDOperand N) { 07235 SDOperand InFlag(0, 0); 07236 SDOperand N0(0, 0); 07237 SDOperand N1(0, 0); 07238 SDOperand Tmp0(0, 0); 07239 SDOperand Tmp1(0, 0); 07240 SDNode *ResNode; 07241 N0 = N.getOperand(0); 07242 07243 // Pattern: (subc:i32 (imm:i32)<<P:Predicate_immSExt16>>:$imm, GPRC:i32:$rA) 07244 // Emits: (SUBFIC:i32 GPRC:i32:$rA, (imm:i32):$imm) 07245 // Pattern complexity = 5 cost = 1 07246 if (N0.getOpcode() == ISD::Constant && 07247 Predicate_immSExt16(N0.Val)) { 07248 N1 = N.getOperand(1); 07249 if (N.Val->getValueType(0) == MVT::i32) { 07250 Select(Tmp0, N1); 07251 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N0)->getValue(); 07252 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 07253 ResNode = CurDAG->getTargetNode(PPC::SUBFIC, MVT::i32, MVT::Flag, Tmp0, Tmp1); 07254 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07255 InFlag = SDOperand(ResNode, 1); 07256 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 07257 Result = SDOperand(ResNode, N.ResNo); 07258 return; 07259 } 07260 } 07261 07262 // Pattern: (subc:i32 GPRC:i32:$rB, GPRC:i32:$rA) 07263 // Emits: (SUBFC:i32 GPRC:i32:$rA, GPRC:i32:$rB) 07264 // Pattern complexity = 2 cost = 1 07265 N1 = N.getOperand(1); 07266 if (N.Val->getValueType(0) == MVT::i32) { 07267 Select(Tmp0, N1); 07268 Select(Tmp1, N0); 07269 ResNode = CurDAG->getTargetNode(PPC::SUBFC, MVT::i32, MVT::Flag, Tmp0, Tmp1); 07270 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07271 InFlag = SDOperand(ResNode, 1); 07272 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 07273 Result = SDOperand(ResNode, N.ResNo); 07274 return; 07275 } 07276 std::cerr << "Cannot yet select: "; 07277 N.Val->dump(CurDAG); 07278 std::cerr << '\n'; 07279 abort(); 07280 } 07281 07282 void Select_sube(SDOperand &Result, SDOperand N) { 07283 SDOperand InFlag(0, 0); 07284 SDOperand N0(0, 0); 07285 SDOperand N1(0, 0); 07286 SDOperand Tmp0(0, 0); 07287 SDOperand Tmp1(0, 0); 07288 SDNode *ResNode; 07289 N0 = N.getOperand(0); 07290 07291 // Pattern: (sube:i32 (imm:i32)<<P:Predicate_immAllOnes>>, GPRC:i32:$rA) 07292 // Emits: (SUBFME:i32 GPRC:i32:$rA) 07293 // Pattern complexity = 5 cost = 1 07294 if (N0.getOpcode() == ISD::Constant && 07295 Predicate_immAllOnes(N0.Val)) { 07296 N1 = N.getOperand(1); 07297 if (N.Val->getValueType(0) == MVT::i32) { 07298 Select(Tmp0, N1); 07299 Select(InFlag, N.getOperand(2)); 07300 ResNode = CurDAG->getTargetNode(PPC::SUBFME, MVT::i32, MVT::Flag, Tmp0, InFlag); 07301 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07302 InFlag = SDOperand(ResNode, 1); 07303 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 07304 Result = SDOperand(ResNode, N.ResNo); 07305 return; 07306 } 07307 } 07308 07309 // Pattern: (sube:i32 0:i32, GPRC:i32:$rA) 07310 // Emits: (SUBFZE:i32 GPRC:i32:$rA) 07311 // Pattern complexity = 5 cost = 1 07312 if (isa<ConstantSDNode>(N0)) { 07313 int64_t CN0 = cast<ConstantSDNode>(N0)->getSignExtended(); 07314 if (CN0 == 0) { 07315 N1 = N.getOperand(1); 07316 if (N.Val->getValueType(0) == MVT::i32) { 07317 Select(Tmp1, N1); 07318 Select(InFlag, N.getOperand(2)); 07319 ResNode = CurDAG->getTargetNode(PPC::SUBFZE, MVT::i32, MVT::Flag, Tmp1, InFlag); 07320 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07321 InFlag = SDOperand(ResNode, 1); 07322 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 07323 Result = SDOperand(ResNode, N.ResNo); 07324 return; 07325 } 07326 } 07327 } 07328 07329 // Pattern: (sube:i32 GPRC:i32:$rB, GPRC:i32:$rA) 07330 // Emits: (SUBFE:i32 GPRC:i32:$rA, GPRC:i32:$rB) 07331 // Pattern complexity = 2 cost = 1 07332 N1 = N.getOperand(1); 07333 if (N.Val->getValueType(0) == MVT::i32) { 07334 Select(Tmp0, N1); 07335 Select(Tmp1, N0); 07336 Select(InFlag, N.getOperand(2)); 07337 ResNode = CurDAG->getTargetNode(PPC::SUBFE, MVT::i32, MVT::Flag, Tmp0, Tmp1, InFlag); 07338 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07339 InFlag = SDOperand(ResNode, 1); 07340 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 07341 Result = SDOperand(ResNode, N.ResNo); 07342 return; 07343 } 07344 std::cerr << "Cannot yet select: "; 07345 N.Val->dump(CurDAG); 07346 std::cerr << '\n'; 07347 abort(); 07348 } 07349 07350 void Select_trunc(SDOperand &Result, SDOperand N) { 07351 SDOperand N0(0, 0); 07352 SDOperand Tmp0(0, 0); 07353 SDNode *ResNode; 07354 N0 = N.getOperand(0); 07355 if (N.Val->getValueType(0) == MVT::i32 && 07356 N0.Val->getValueType(0) == MVT::i64) { 07357 Select(Tmp0, N0); 07358 if (N.Val->hasOneUse()) { 07359 Result = CurDAG->SelectNodeTo(N.Val, PPC::OR8To4, MVT::i32, Tmp0, Tmp0); 07360 } else { 07361 ResNode = CurDAG->getTargetNode(PPC::OR8To4, MVT::i32, Tmp0, Tmp0); 07362 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07363 Result = SDOperand(ResNode, 0); 07364 } 07365 return; 07366 } 07367 std::cerr << "Cannot yet select: "; 07368 N.Val->dump(CurDAG); 07369 std::cerr << '\n'; 07370 abort(); 07371 } 07372 07373 void Select_truncst(SDOperand &Result, SDOperand N) { 07374 SDOperand Chain(0, 0); 07375 SDOperand N1(0, 0); 07376 SDOperand N2(0, 0); 07377 SDOperand N3(0, 0); 07378 SDOperand N4(0, 0); 07379 SDOperand Tmp0(0, 0); 07380 SDOperand Tmp1(0, 0); 07381 SDOperand Tmp2(0, 0); 07382 SDNode *ResNode; 07383 Chain = N.getOperand(0); 07384 N1 = N.getOperand(1); 07385 N2 = N.getOperand(2); 07386 N3 = N.getOperand(3); 07387 N4 = N.getOperand(4); 07388 07389 // Pattern: (truncst:void GPRC:i32:$rS, iaddr:i32:$src, srcvalue:Other:$dummy, i8:Other) 07390 // Emits: (STB:void GPRC:i32:$rS, iaddr:i32:$src) 07391 // Pattern complexity = 8 cost = 1 07392 if (cast<VTSDNode>(N4)->getVT() == MVT::i8 && 07393 N1.Val->getValueType(0) == MVT::i32 && 07394 SelectAddrImm(N2, Tmp0, Tmp1)) { 07395 Select(Tmp0, Tmp0); 07396 Select(Tmp1, Tmp1); 07397 Select(Tmp2, N1); 07398 Select(Chain, Chain); 07399 ResNode = CurDAG->getTargetNode(PPC::STB, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 07400 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07401 Result = SDOperand(ResNode, N.ResNo); 07402 return; 07403 } 07404 07405 // Pattern: (truncst:void GPRC:i32:$rS, iaddr:i32:$src, srcvalue:Other:$dummy, i16:Other) 07406 // Emits: (STH:void GPRC:i32:$rS, iaddr:i32:$src) 07407 // Pattern complexity = 8 cost = 1 07408 if (cast<VTSDNode>(N4)->getVT() == MVT::i16 && 07409 N1.Val->getValueType(0) == MVT::i32 && 07410 SelectAddrImm(N2, Tmp0, Tmp1)) { 07411 Select(Tmp0, Tmp0); 07412 Select(Tmp1, Tmp1); 07413 Select(Tmp2, N1); 07414 Select(Chain, Chain); 07415 ResNode = CurDAG->getTargetNode(PPC::STH, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 07416 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07417 Result = SDOperand(ResNode, N.ResNo); 07418 return; 07419 } 07420 07421 // Pattern: (truncst:void GPRC:i32:$rS, xaddr:i32:$dst, srcvalue:Other:$dummy, i8:Other) 07422 // Emits: (STBX:void GPRC:i32:$rS, xaddr:i32:$dst) 07423 // Pattern complexity = 8 cost = 1 07424 if (cast<VTSDNode>(N4)->getVT() == MVT::i8 && 07425 N1.Val->getValueType(0) == MVT::i32 && 07426 SelectAddrIdx(N2, Tmp0, Tmp1)) { 07427 Select(Tmp0, Tmp0); 07428 Select(Tmp1, Tmp1); 07429 Select(Tmp2, N1); 07430 Select(Chain, Chain); 07431 ResNode = CurDAG->getTargetNode(PPC::STBX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 07432 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07433 Result = SDOperand(ResNode, N.ResNo); 07434 return; 07435 } 07436 07437 // Pattern: (truncst:void GPRC:i32:$rS, xaddr:i32:$dst, srcvalue:Other:$dummy, i16:Other) 07438 // Emits: (STHX:void GPRC:i32:$rS, xaddr:i32:$dst) 07439 // Pattern complexity = 8 cost = 1 07440 if (cast<VTSDNode>(N4)->getVT() == MVT::i16 && 07441 N1.Val->getValueType(0) == MVT::i32 && 07442 SelectAddrIdx(N2, Tmp0, Tmp1)) { 07443 Select(Tmp0, Tmp0); 07444 Select(Tmp1, Tmp1); 07445 Select(Tmp2, N1); 07446 Select(Chain, Chain); 07447 ResNode = CurDAG->getTargetNode(PPC::STHX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 07448 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07449 Result = SDOperand(ResNode, N.ResNo); 07450 return; 07451 } 07452 std::cerr << "Cannot yet select: "; 07453 N.Val->dump(CurDAG); 07454 std::cerr << '\n'; 07455 abort(); 07456 } 07457 07458 void Select_udiv(SDOperand &Result, SDOperand N) { 07459 SDOperand N0(0, 0); 07460 SDOperand N1(0, 0); 07461 SDOperand Tmp0(0, 0); 07462 SDOperand Tmp1(0, 0); 07463 SDNode *ResNode; 07464 N0 = N.getOperand(0); 07465 N1 = N.getOperand(1); 07466 07467 // Pattern: (udiv:i64 G8RC:i64:$rA, G8RC:i64:$rB) 07468 // Emits: (DIVDU:i64 G8RC:i64:$rA, G8RC:i64:$rB) 07469 // Pattern complexity = 2 cost = 1 07470 if (N.Val->getValueType(0) == MVT::i64) { 07471 Select(Tmp0, N0); 07472 Select(Tmp1, N1); 07473 if (N.Val->hasOneUse()) { 07474 Result = CurDAG->SelectNodeTo(N.Val, PPC::DIVDU, MVT::i64, Tmp0, Tmp1); 07475 } else { 07476 ResNode = CurDAG->getTargetNode(PPC::DIVDU, MVT::i64, Tmp0, Tmp1); 07477 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07478 Result = SDOperand(ResNode, 0); 07479 } 07480 return; 07481 } 07482 07483 // Pattern: (udiv:i32 GPRC:i32:$rA, GPRC:i32:$rB) 07484 // Emits: (DIVWU:i32 GPRC:i32:$rA, GPRC:i32:$rB) 07485 // Pattern complexity = 2 cost = 1 07486 if (N.Val->getValueType(0) == MVT::i32) { 07487 Select(Tmp0, N0); 07488 Select(Tmp1, N1); 07489 if (N.Val->hasOneUse()) { 07490 Result = CurDAG->SelectNodeTo(N.Val, PPC::DIVWU, MVT::i32, Tmp0, Tmp1); 07491 } else { 07492 ResNode = CurDAG->getTargetNode(PPC::DIVWU, MVT::i32, Tmp0, Tmp1); 07493 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07494 Result = SDOperand(ResNode, 0); 07495 } 07496 return; 07497 } 07498 std::cerr << "Cannot yet select: "; 07499 N.Val->dump(CurDAG); 07500 std::cerr << '\n'; 07501 abort(); 07502 } 07503 07504 void Select_undef(SDOperand &Result, SDOperand N) { 07505 SDNode *ResNode; 07506 07507 // Pattern: (undef:i32) 07508 // Emits: (IMPLICIT_DEF_GPR:i32) 07509 // Pattern complexity = 2 cost = 1 07510 if (N.Val->getValueType(0) == MVT::i32) { 07511 if (N.Val->hasOneUse()) { 07512 Result = CurDAG->SelectNodeTo(N.Val, PPC::IMPLICIT_DEF_GPR, MVT::i32); 07513 } else { 07514 ResNode = CurDAG->getTargetNode(PPC::IMPLICIT_DEF_GPR, MVT::i32); 07515 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07516 Result = SDOperand(ResNode, 0); 07517 } 07518 return; 07519 } 07520 07521 // Pattern: (undef:f64) 07522 // Emits: (IMPLICIT_DEF_F8:f64) 07523 // Pattern complexity = 2 cost = 1 07524 if (N.Val->getValueType(0) == MVT::f64) { 07525 if (N.Val->hasOneUse()) { 07526 Result = CurDAG->SelectNodeTo(N.Val, PPC::IMPLICIT_DEF_F8, MVT::f64); 07527 } else { 07528 ResNode = CurDAG->getTargetNode(PPC::IMPLICIT_DEF_F8, MVT::f64); 07529 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07530 Result = SDOperand(ResNode, 0); 07531 } 07532 return; 07533 } 07534 07535 // Pattern: (undef:f32) 07536 // Emits: (IMPLICIT_DEF_F4:f32) 07537 // Pattern complexity = 2 cost = 1 07538 if (N.Val->getValueType(0) == MVT::f32) { 07539 if (N.Val->hasOneUse()) { 07540 Result = CurDAG->SelectNodeTo(N.Val, PPC::IMPLICIT_DEF_F4, MVT::f32); 07541 } else { 07542 ResNode = CurDAG->getTargetNode(PPC::IMPLICIT_DEF_F4, MVT::f32); 07543 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07544 Result = SDOperand(ResNode, 0); 07545 } 07546 return; 07547 } 07548 07549 // Pattern: (undef:v4f32) 07550 // Emits: (IMPLICIT_DEF_VRRC:v4f32) 07551 // Pattern complexity = 2 cost = 1 07552 if (N.Val->getValueType(0) == MVT::v4f32) { 07553 if (N.Val->hasOneUse()) { 07554 Result = CurDAG->SelectNodeTo(N.Val, PPC::IMPLICIT_DEF_VRRC, MVT::v4f32); 07555 } else { 07556 ResNode = CurDAG->getTargetNode(PPC::IMPLICIT_DEF_VRRC, MVT::v4f32); 07557 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07558 Result = SDOperand(ResNode, 0); 07559 } 07560 return; 07561 } 07562 07563 // Pattern: (undef:v16i8) 07564 // Emits: (IMPLICIT_DEF_VRRC:v16i8) 07565 // Pattern complexity = 2 cost = 1 07566 if (N.Val->getValueType(0) == MVT::v16i8) { 07567 if (N.Val->hasOneUse()) { 07568 Result = CurDAG->SelectNodeTo(N.Val, PPC::IMPLICIT_DEF_VRRC, MVT::v16i8); 07569 } else { 07570 ResNode = CurDAG->getTargetNode(PPC::IMPLICIT_DEF_VRRC, MVT::v16i8); 07571 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07572 Result = SDOperand(ResNode, 0); 07573 } 07574 return; 07575 } 07576 07577 // Pattern: (undef:v8i16) 07578 // Emits: (IMPLICIT_DEF_VRRC:v8i16) 07579 // Pattern complexity = 2 cost = 1 07580 if (N.Val->getValueType(0) == MVT::v8i16) { 07581 if (N.Val->hasOneUse()) { 07582 Result = CurDAG->SelectNodeTo(N.Val, PPC::IMPLICIT_DEF_VRRC, MVT::v8i16); 07583 } else { 07584 ResNode = CurDAG->getTargetNode(PPC::IMPLICIT_DEF_VRRC, MVT::v8i16); 07585 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07586 Result = SDOperand(ResNode, 0); 07587 } 07588 return; 07589 } 07590 07591 // Pattern: (undef:v4i32) 07592 // Emits: (IMPLICIT_DEF_VRRC:v4i32) 07593 // Pattern complexity = 2 cost = 1 07594 if (N.Val->getValueType(0) == MVT::v4i32) { 07595 if (N.Val->hasOneUse()) { 07596 Result = CurDAG->SelectNodeTo(N.Val, PPC::IMPLICIT_DEF_VRRC, MVT::v4i32); 07597 } else { 07598 ResNode = CurDAG->getTargetNode(PPC::IMPLICIT_DEF_VRRC, MVT::v4i32); 07599 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07600 Result = SDOperand(ResNode, 0); 07601 } 07602 return; 07603 } 07604 std::cerr << "Cannot yet select: "; 07605 N.Val->dump(CurDAG); 07606 std::cerr << '\n'; 07607 abort(); 07608 } 07609 07610 void Select_vector_shuffle(SDOperand &Result, SDOperand N) { 07611 SDOperand N0(0, 0); 07612 SDOperand N1(0, 0); 07613 SDOperand N2(0, 0); 07614 SDOperand Tmp0(0, 0); 07615 SDOperand Tmp1(0, 0); 07616 SDOperand Tmp2(0, 0); 07617 SDOperand Tmp3(0, 0); 07618 SDNode *ResNode; 07619 N0 = N.getOperand(0); 07620 N1 = N.getOperand(1); 07621 if (N1.getOpcode() == ISD::UNDEF) { 07622 N2 = N.getOperand(2); 07623 if (N2.getOpcode() == ISD::BUILD_VECTOR) { 07624 07625 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vB, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VSPLTB_shuffle_mask>><<X:VSPLTB_get_imm>>:$UIMM) 07626 // Emits: (VSPLTB:v16i8 (VSPLTB_get_imm:i32 (build_vector:v16i8):$UIMM), VRRC:v16i8:$vB) 07627 // Pattern complexity = 7 cost = 1 07628 if (Predicate_VSPLTB_shuffle_mask(N2.Val) && 07629 N.Val->getValueType(0) == MVT::v16i8) { 07630 Tmp0 = N2; 07631 Tmp1 = Transform_VSPLTB_get_imm(Tmp0.Val); 07632 Select(Tmp2, N0); 07633 if (N.Val->hasOneUse()) { 07634 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSPLTB, MVT::v16i8, Tmp1, Tmp2); 07635 } else { 07636 ResNode = CurDAG->getTargetNode(PPC::VSPLTB, MVT::v16i8, Tmp1, Tmp2); 07637 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07638 Result = SDOperand(ResNode, 0); 07639 } 07640 return; 07641 } 07642 07643 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vB, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VSPLTH_shuffle_mask>><<X:VSPLTH_get_imm>>:$UIMM) 07644 // Emits: (VSPLTH:v16i8 (VSPLTH_get_imm:i32 (build_vector:v16i8):$UIMM), VRRC:v16i8:$vB) 07645 // Pattern complexity = 7 cost = 1 07646 if (Predicate_VSPLTH_shuffle_mask(N2.Val) && 07647 N.Val->getValueType(0) == MVT::v16i8) { 07648 Tmp0 = N2; 07649 Tmp1 = Transform_VSPLTH_get_imm(Tmp0.Val); 07650 Select(Tmp2, N0); 07651 if (N.Val->hasOneUse()) { 07652 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSPLTH, MVT::v16i8, Tmp1, Tmp2); 07653 } else { 07654 ResNode = CurDAG->getTargetNode(PPC::VSPLTH, MVT::v16i8, Tmp1, Tmp2); 07655 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07656 Result = SDOperand(ResNode, 0); 07657 } 07658 return; 07659 } 07660 07661 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vB, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VSPLTW_shuffle_mask>><<X:VSPLTW_get_imm>>:$UIMM) 07662 // Emits: (VSPLTW:v16i8 (VSPLTW_get_imm:i32 (build_vector:v16i8):$UIMM), VRRC:v16i8:$vB) 07663 // Pattern complexity = 7 cost = 1 07664 if (Predicate_VSPLTW_shuffle_mask(N2.Val) && 07665 N.Val->getValueType(0) == MVT::v16i8) { 07666 Tmp0 = N2; 07667 Tmp1 = Transform_VSPLTW_get_imm(Tmp0.Val); 07668 Select(Tmp2, N0); 07669 if (N.Val->hasOneUse()) { 07670 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSPLTW, MVT::v16i8, Tmp1, Tmp2); 07671 } else { 07672 ResNode = CurDAG->getTargetNode(PPC::VSPLTW, MVT::v16i8, Tmp1, Tmp2); 07673 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07674 Result = SDOperand(ResNode, 0); 07675 } 07676 return; 07677 } 07678 07679 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VSLDOI_unary_shuffle_mask>><<X:VSLDOI_unary_get_imm>>:$in) 07680 // Emits: (VSLDOI:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA, (VSLDOI_unary_get_imm:i32 (build_vector:i32)<<P:Predicate_VSLDOI_unary_shuffle_mask>>:$in)) 07681 // Pattern complexity = 7 cost = 1 07682 if (Predicate_VSLDOI_unary_shuffle_mask(N2.Val) && 07683 N.Val->getValueType(0) == MVT::v16i8) { 07684 Select(Tmp0, N0); 07685 Tmp1 = N2; 07686 Tmp2 = Transform_VSLDOI_unary_get_imm(Tmp1.Val); 07687 if (N.Val->hasOneUse()) { 07688 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSLDOI, MVT::v16i8, Tmp0, Tmp0, Tmp2); 07689 } else { 07690 ResNode = CurDAG->getTargetNode(PPC::VSLDOI, MVT::v16i8, Tmp0, Tmp0, Tmp2); 07691 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07692 Result = SDOperand(ResNode, 0); 07693 } 07694 return; 07695 } 07696 07697 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VPKUWUM_unary_shuffle_mask>>:$in) 07698 // Emits: (VPKUWUM:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 07699 // Pattern complexity = 7 cost = 1 07700 if (Predicate_VPKUWUM_unary_shuffle_mask(N2.Val) && 07701 N.Val->getValueType(0) == MVT::v16i8) { 07702 Select(Tmp0, N0); 07703 if (N.Val->hasOneUse()) { 07704 Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKUWUM, MVT::v16i8, Tmp0, Tmp0); 07705 } else { 07706 ResNode = CurDAG->getTargetNode(PPC::VPKUWUM, MVT::v16i8, Tmp0, Tmp0); 07707 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07708 Result = SDOperand(ResNode, 0); 07709 } 07710 return; 07711 } 07712 07713 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VPKUHUM_unary_shuffle_mask>>:$in) 07714 // Emits: (VPKUHUM:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 07715 // Pattern complexity = 7 cost = 1 07716 if (Predicate_VPKUHUM_unary_shuffle_mask(N2.Val) && 07717 N.Val->getValueType(0) == MVT::v16i8) { 07718 Select(Tmp0, N0); 07719 if (N.Val->hasOneUse()) { 07720 Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKUHUM, MVT::v16i8, Tmp0, Tmp0); 07721 } else { 07722 ResNode = CurDAG->getTargetNode(PPC::VPKUHUM, MVT::v16i8, Tmp0, Tmp0); 07723 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07724 Result = SDOperand(ResNode, 0); 07725 } 07726 return; 07727 } 07728 07729 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VMRGLB_unary_shuffle_mask>>:$in) 07730 // Emits: (VMRGLB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 07731 // Pattern complexity = 7 cost = 1 07732 if (Predicate_VMRGLB_unary_shuffle_mask(N2.Val) && 07733 N.Val->getValueType(0) == MVT::v16i8) { 07734 Select(Tmp0, N0); 07735 if (N.Val->hasOneUse()) { 07736 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGLB, MVT::v16i8, Tmp0, Tmp0); 07737 } else { 07738 ResNode = CurDAG->getTargetNode(PPC::VMRGLB, MVT::v16i8, Tmp0, Tmp0); 07739 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07740 Result = SDOperand(ResNode, 0); 07741 } 07742 return; 07743 } 07744 07745 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VMRGLH_unary_shuffle_mask>>:$in) 07746 // Emits: (VMRGLH:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 07747 // Pattern complexity = 7 cost = 1 07748 if (Predicate_VMRGLH_unary_shuffle_mask(N2.Val) && 07749 N.Val->getValueType(0) == MVT::v16i8) { 07750 Select(Tmp0, N0); 07751 if (N.Val->hasOneUse()) { 07752 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGLH, MVT::v16i8, Tmp0, Tmp0); 07753 } else { 07754 ResNode = CurDAG->getTargetNode(PPC::VMRGLH, MVT::v16i8, Tmp0, Tmp0); 07755 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07756 Result = SDOperand(ResNode, 0); 07757 } 07758 return; 07759 } 07760 07761 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VMRGLW_unary_shuffle_mask>>:$in) 07762 // Emits: (VMRGLW:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 07763 // Pattern complexity = 7 cost = 1 07764 if (Predicate_VMRGLW_unary_shuffle_mask(N2.Val) && 07765 N.Val->getValueType(0) == MVT::v16i8) { 07766 Select(Tmp0, N0); 07767 if (N.Val->hasOneUse()) { 07768 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGLW, MVT::v16i8, Tmp0, Tmp0); 07769 } else { 07770 ResNode = CurDAG->getTargetNode(PPC::VMRGLW, MVT::v16i8, Tmp0, Tmp0); 07771 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07772 Result = SDOperand(ResNode, 0); 07773 } 07774 return; 07775 } 07776 07777 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VMRGHB_unary_shuffle_mask>>:$in) 07778 // Emits: (VMRGHB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 07779 // Pattern complexity = 7 cost = 1 07780 if (Predicate_VMRGHB_unary_shuffle_mask(N2.Val) && 07781 N.Val->getValueType(0) == MVT::v16i8) { 07782 Select(Tmp0, N0); 07783 if (N.Val->hasOneUse()) { 07784 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGHB, MVT::v16i8, Tmp0, Tmp0); 07785 } else { 07786 ResNode = CurDAG->getTargetNode(PPC::VMRGHB, MVT::v16i8, Tmp0, Tmp0); 07787 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07788 Result = SDOperand(ResNode, 0); 07789 } 07790 return; 07791 } 07792 07793 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VMRGHH_unary_shuffle_mask>>:$in) 07794 // Emits: (VMRGHH:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 07795 // Pattern complexity = 7 cost = 1 07796 if (Predicate_VMRGHH_unary_shuffle_mask(N2.Val) && 07797 N.Val->getValueType(0) == MVT::v16i8) { 07798 Select(Tmp0, N0); 07799 if (N.Val->hasOneUse()) { 07800 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGHH, MVT::v16i8, Tmp0, Tmp0); 07801 } else { 07802 ResNode = CurDAG->getTargetNode(PPC::VMRGHH, MVT::v16i8, Tmp0, Tmp0); 07803 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07804 Result = SDOperand(ResNode, 0); 07805 } 07806 return; 07807 } 07808 07809 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VMRGHW_unary_shuffle_mask>>:$in) 07810 // Emits: (VMRGHW:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 07811 // Pattern complexity = 7 cost = 1 07812 if (Predicate_VMRGHW_unary_shuffle_mask(N2.Val) && 07813 N.Val->getValueType(0) == MVT::v16i8) { 07814 Select(Tmp0, N0); 07815 if (N.Val->hasOneUse()) { 07816 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGHW, MVT::v16i8, Tmp0, Tmp0); 07817 } else { 07818 ResNode = CurDAG->getTargetNode(PPC::VMRGHW, MVT::v16i8, Tmp0, Tmp0); 07819 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07820 Result = SDOperand(ResNode, 0); 07821 } 07822 return; 07823 } 07824 } 07825 } 07826 N2 = N.getOperand(2); 07827 if (N2.getOpcode() == ISD::BUILD_VECTOR) { 07828 07829 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VSLDOI_shuffle_mask>><<X:VSLDOI_get_imm>>:$SH) 07830 // Emits: (VSLDOI:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (VSLDOI_get_imm:i32 (build_vector:v16i8):$SH)) 07831 // Pattern complexity = 5 cost = 1 07832 if (Predicate_VSLDOI_shuffle_mask(N2.Val) && 07833 N.Val->getValueType(0) == MVT::v16i8) { 07834 Select(Tmp0, N0); 07835 Select(Tmp1, N1); 07836 Tmp2 = N2; 07837 Tmp3 = Transform_VSLDOI_get_imm(Tmp2.Val); 07838 if (N.Val->hasOneUse()) { 07839 Result = CurDAG->SelectNodeTo(N.Val, PPC::VSLDOI, MVT::v16i8, Tmp0, Tmp1, Tmp3); 07840 } else { 07841 ResNode = CurDAG->getTargetNode(PPC::VSLDOI, MVT::v16i8, Tmp0, Tmp1, Tmp3); 07842 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07843 Result = SDOperand(ResNode, 0); 07844 } 07845 return; 07846 } 07847 07848 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VMRGHB_shuffle_mask>>) 07849 // Emits: (VMRGHB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 07850 // Pattern complexity = 5 cost = 1 07851 if (Predicate_VMRGHB_shuffle_mask(N2.Val) && 07852 N.Val->getValueType(0) == MVT::v16i8) { 07853 Select(Tmp0, N0); 07854 Select(Tmp1, N1); 07855 if (N.Val->hasOneUse()) { 07856 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGHB, MVT::v16i8, Tmp0, Tmp1); 07857 } else { 07858 ResNode = CurDAG->getTargetNode(PPC::VMRGHB, MVT::v16i8, Tmp0, Tmp1); 07859 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07860 Result = SDOperand(ResNode, 0); 07861 } 07862 return; 07863 } 07864 07865 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VMRGHH_shuffle_mask>>) 07866 // Emits: (VMRGHH:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 07867 // Pattern complexity = 5 cost = 1 07868 if (Predicate_VMRGHH_shuffle_mask(N2.Val) && 07869 N.Val->getValueType(0) == MVT::v16i8) { 07870 Select(Tmp0, N0); 07871 Select(Tmp1, N1); 07872 if (N.Val->hasOneUse()) { 07873 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGHH, MVT::v16i8, Tmp0, Tmp1); 07874 } else { 07875 ResNode = CurDAG->getTargetNode(PPC::VMRGHH, MVT::v16i8, Tmp0, Tmp1); 07876 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07877 Result = SDOperand(ResNode, 0); 07878 } 07879 return; 07880 } 07881 07882 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VMRGHW_shuffle_mask>>) 07883 // Emits: (VMRGHW:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 07884 // Pattern complexity = 5 cost = 1 07885 if (Predicate_VMRGHW_shuffle_mask(N2.Val) && 07886 N.Val->getValueType(0) == MVT::v16i8) { 07887 Select(Tmp0, N0); 07888 Select(Tmp1, N1); 07889 if (N.Val->hasOneUse()) { 07890 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGHW, MVT::v16i8, Tmp0, Tmp1); 07891 } else { 07892 ResNode = CurDAG->getTargetNode(PPC::VMRGHW, MVT::v16i8, Tmp0, Tmp1); 07893 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07894 Result = SDOperand(ResNode, 0); 07895 } 07896 return; 07897 } 07898 07899 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VMRGLB_shuffle_mask>>) 07900 // Emits: (VMRGLB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 07901 // Pattern complexity = 5 cost = 1 07902 if (Predicate_VMRGLB_shuffle_mask(N2.Val) && 07903 N.Val->getValueType(0) == MVT::v16i8) { 07904 Select(Tmp0, N0); 07905 Select(Tmp1, N1); 07906 if (N.Val->hasOneUse()) { 07907 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGLB, MVT::v16i8, Tmp0, Tmp1); 07908 } else { 07909 ResNode = CurDAG->getTargetNode(PPC::VMRGLB, MVT::v16i8, Tmp0, Tmp1); 07910 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07911 Result = SDOperand(ResNode, 0); 07912 } 07913 return; 07914 } 07915 07916 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VMRGLH_shuffle_mask>>) 07917 // Emits: (VMRGLH:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 07918 // Pattern complexity = 5 cost = 1 07919 if (Predicate_VMRGLH_shuffle_mask(N2.Val) && 07920 N.Val->getValueType(0) == MVT::v16i8) { 07921 Select(Tmp0, N0); 07922 Select(Tmp1, N1); 07923 if (N.Val->hasOneUse()) { 07924 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGLH, MVT::v16i8, Tmp0, Tmp1); 07925 } else { 07926 ResNode = CurDAG->getTargetNode(PPC::VMRGLH, MVT::v16i8, Tmp0, Tmp1); 07927 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07928 Result = SDOperand(ResNode, 0); 07929 } 07930 return; 07931 } 07932 07933 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VMRGLW_shuffle_mask>>) 07934 // Emits: (VMRGLW:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 07935 // Pattern complexity = 5 cost = 1 07936 if (Predicate_VMRGLW_shuffle_mask(N2.Val) && 07937 N.Val->getValueType(0) == MVT::v16i8) { 07938 Select(Tmp0, N0); 07939 Select(Tmp1, N1); 07940 if (N.Val->hasOneUse()) { 07941 Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGLW, MVT::v16i8, Tmp0, Tmp1); 07942 } else { 07943 ResNode = CurDAG->getTargetNode(PPC::VMRGLW, MVT::v16i8, Tmp0, Tmp1); 07944 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07945 Result = SDOperand(ResNode, 0); 07946 } 07947 return; 07948 } 07949 07950 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VPKUHUM_shuffle_mask>>) 07951 // Emits: (VPKUHUM:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 07952 // Pattern complexity = 5 cost = 1 07953 if (Predicate_VPKUHUM_shuffle_mask(N2.Val) && 07954 N.Val->getValueType(0) == MVT::v16i8) { 07955 Select(Tmp0, N0); 07956 Select(Tmp1, N1); 07957 if (N.Val->hasOneUse()) { 07958 Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKUHUM, MVT::v16i8, Tmp0, Tmp1); 07959 } else { 07960 ResNode = CurDAG->getTargetNode(PPC::VPKUHUM, MVT::v16i8, Tmp0, Tmp1); 07961 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07962 Result = SDOperand(ResNode, 0); 07963 } 07964 return; 07965 } 07966 07967 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VPKUWUM_shuffle_mask>>) 07968 // Emits: (VPKUWUM:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 07969 // Pattern complexity = 5 cost = 1 07970 if (Predicate_VPKUWUM_shuffle_mask(N2.Val) && 07971 N.Val->getValueType(0) == MVT::v16i8) { 07972 Select(Tmp0, N0); 07973 Select(Tmp1, N1); 07974 if (N.Val->hasOneUse()) { 07975 Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKUWUM, MVT::v16i8, Tmp0, Tmp1); 07976 } else { 07977 ResNode = CurDAG->getTargetNode(PPC::VPKUWUM, MVT::v16i8, Tmp0, Tmp1); 07978 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07979 Result = SDOperand(ResNode, 0); 07980 } 07981 return; 07982 } 07983 } 07984 std::cerr << "Cannot yet select: "; 07985 N.Val->dump(CurDAG); 07986 std::cerr << '\n'; 07987 abort(); 07988 } 07989 07990 void Select_xor(SDOperand &Result, SDOperand N) { 07991 SDOperand N0(0, 0); 07992 SDOperand N00(0, 0); 07993 SDOperand N01(0, 0); 07994 SDOperand N1(0, 0); 07995 SDOperand N10(0, 0); 07996 SDOperand N11(0, 0); 07997 SDOperand Tmp0(0, 0); 07998 SDOperand Tmp1(0, 0); 07999 SDOperand Tmp2(0, 0); 08000 SDOperand Tmp3(0, 0); 08001 SDOperand Tmp4(0, 0); 08002 SDNode *ResNode; 08003 N0 = N.getOperand(0); 08004 08005 // Pattern: (xor:i32 (and:i32 GPRC:i32:$rS, GPRC:i32:$rB), (imm:i32)<<P:Predicate_immAllOnes>>) 08006 // Emits: (NAND:i32 GPRC:i32:$rS, GPRC:i32:$rB) 08007 // Pattern complexity = 7 cost = 1 08008 if (N0.getOpcode() == ISD::AND) { 08009 N00 = N0.getOperand(0); 08010 N01 = N0.getOperand(1); 08011 N1 = N.getOperand(1); 08012 if (N1.getOpcode() == ISD::Constant && 08013 Predicate_immAllOnes(N1.Val) && 08014 N.Val->getValueType(0) == MVT::i32) { 08015 Select(Tmp0, N00); 08016 Select(Tmp1, N01); 08017 if (N.Val->hasOneUse()) { 08018 Result = CurDAG->SelectNodeTo(N.Val, PPC::NAND, MVT::i32, Tmp0, Tmp1); 08019 } else { 08020 ResNode = CurDAG->getTargetNode(PPC::NAND, MVT::i32, Tmp0, Tmp1); 08021 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08022 Result = SDOperand(ResNode, 0); 08023 } 08024 return; 08025 } 08026 } 08027 08028 // Pattern: (xor:i32 (or:i32 GPRC:i32:$rS, GPRC:i32:$rB), (imm:i32)<<P:Predicate_immAllOnes>>) 08029 // Emits: (NOR:i32 GPRC:i32:$rS, GPRC:i32:$rB) 08030 // Pattern complexity = 7 cost = 1 08031 if (N0.getOpcode() == ISD::OR) { 08032 N00 = N0.getOperand(0); 08033 N01 = N0.getOperand(1); 08034 N1 = N.getOperand(1); 08035 if (N1.getOpcode() == ISD::Constant && 08036 Predicate_immAllOnes(N1.Val) && 08037 N.Val->getValueType(0) == MVT::i32) { 08038 Select(Tmp0, N00); 08039 Select(Tmp1, N01); 08040 if (N.Val->hasOneUse()) { 08041 Result = CurDAG->SelectNodeTo(N.Val, PPC::NOR, MVT::i32, Tmp0, Tmp1); 08042 } else { 08043 ResNode = CurDAG->getTargetNode(PPC::NOR, MVT::i32, Tmp0, Tmp1); 08044 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08045 Result = SDOperand(ResNode, 0); 08046 } 08047 return; 08048 } 08049 } 08050 08051 // Pattern: (xor:i32 (xor:i32 GPRC:i32:$rS, GPRC:i32:$rB), (imm:i32)<<P:Predicate_immAllOnes>>) 08052 // Emits: (EQV:i32 GPRC:i32:$rS, GPRC:i32:$rB) 08053 // Pattern complexity = 7 cost = 1 08054 if (N0.getOpcode() == ISD::XOR) { 08055 N00 = N0.getOperand(0); 08056 N01 = N0.getOperand(1); 08057 N1 = N.getOperand(1); 08058 if (N1.getOpcode() == ISD::Constant && 08059 Predicate_immAllOnes(N1.Val) && 08060 N.Val->getValueType(0) == MVT::i32) { 08061 Select(Tmp0, N00); 08062 Select(Tmp1, N01); 08063 if (N.Val->hasOneUse()) { 08064 Result = CurDAG->SelectNodeTo(N.Val, PPC::EQV, MVT::i32, Tmp0, Tmp1); 08065 } else { 08066 ResNode = CurDAG->getTargetNode(PPC::EQV, MVT::i32, Tmp0, Tmp1); 08067 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08068 Result = SDOperand(ResNode, 0); 08069 } 08070 return; 08071 } 08072 } 08073 if (N0.getOpcode() == ISD::OR) { 08074 N00 = N0.getOperand(0); 08075 N01 = N0.getOperand(1); 08076 N1 = N.getOperand(1); 08077 if (N1.getOpcode() == ISD::BUILD_VECTOR && 08078 Predicate_immAllOnesV(N1.Val)) { 08079 08080 // Pattern: (xor:v4i32 (or:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB), (build_vector:v4i32)<<P:Predicate_immAllOnesV>>) 08081 // Emits: (VNOR:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 08082 // Pattern complexity = 7 cost = 1 08083 if (N.Val->getValueType(0) == MVT::v4i32) { 08084 Select(Tmp0, N00); 08085 Select(Tmp1, N01); 08086 if (N.Val->hasOneUse()) { 08087 Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v4i32, Tmp0, Tmp1); 08088 } else { 08089 ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v4i32, Tmp0, Tmp1); 08090 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08091 Result = SDOperand(ResNode, 0); 08092 } 08093 return; 08094 } 08095 08096 // Pattern: (xor:v16i8 (or:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B), (build_vector:v16i8)<<P:Predicate_immAllOnesV>>) 08097 // Emits: (VNOR:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B) 08098 // Pattern complexity = 7 cost = 1 08099 if (N.Val->getValueType(0) == MVT::v16i8) { 08100 Select(Tmp0, N00); 08101 Select(Tmp1, N01); 08102 if (N.Val->hasOneUse()) { 08103 Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v16i8, Tmp0, Tmp1); 08104 } else { 08105 ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v16i8, Tmp0, Tmp1); 08106 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08107 Result = SDOperand(ResNode, 0); 08108 } 08109 return; 08110 } 08111 08112 // Pattern: (xor:v8i16 (or:v8i16 VRRC:v8i16:$A, VRRC:v8i16:$B), (build_vector:v8i16)<<P:Predicate_immAllOnesV>>) 08113 // Emits: (VNOR:v8i16 VRRC:v16i8:$A, VRRC:v16i8:$B) 08114 // Pattern complexity = 7 cost = 1 08115 if (N.Val->getValueType(0) == MVT::v8i16) { 08116 Select(Tmp0, N00); 08117 Select(Tmp1, N01); 08118 if (N.Val->hasOneUse()) { 08119 Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v8i16, Tmp0, Tmp1); 08120 } else { 08121 ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v8i16, Tmp0, Tmp1); 08122 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08123 Result = SDOperand(ResNode, 0); 08124 } 08125 return; 08126 } 08127 } 08128 } 08129 08130 // Pattern: (xor:i32 (xor:i32 GPRC:i32:$rS, (imm:i32)<<P:Predicate_immAllOnes>>), GPRC:i32:$rB) 08131 // Emits: (EQV:i32 GPRC:i32:$rS, GPRC:i32:$rB) 08132 // Pattern complexity = 7 cost = 1 08133 if (N0.getOpcode() == ISD::XOR) { 08134 N00 = N0.getOperand(0); 08135 N01 = N0.getOperand(1); 08136 if (N01.getOpcode() == ISD::Constant && 08137 Predicate_immAllOnes(N01.Val)) { 08138 N1 = N.getOperand(1); 08139 if (N.Val->getValueType(0) == MVT::i32) { 08140 Select(Tmp0, N00); 08141 Select(Tmp1, N1); 08142 if (N.Val->hasOneUse()) { 08143 Result = CurDAG->SelectNodeTo(N.Val, PPC::EQV, MVT::i32, Tmp0, Tmp1); 08144 } else { 08145 ResNode = CurDAG->getTargetNode(PPC::EQV, MVT::i32, Tmp0, Tmp1); 08146 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08147 Result = SDOperand(ResNode, 0); 08148 } 08149 return; 08150 } 08151 } 08152 } 08153 08154 // Pattern: (xor:i32 GPRC:i32:$rB, (xor:i32 GPRC:i32:$rS, (imm:i32)<<P:Predicate_immAllOnes>>)) 08155 // Emits: (EQV:i32 GPRC:i32:$rS, GPRC:i32:$rB) 08156 // Pattern complexity = 7 cost = 1 08157 { 08158 N1 = N.getOperand(1); 08159 if (N1.getOpcode() == ISD::XOR) { 08160 N10 = N1.getOperand(0); 08161 N11 = N1.getOperand(1); 08162 if (N11.getOpcode() == ISD::Constant && 08163 Predicate_immAllOnes(N11.Val) && 08164 N.Val->getValueType(0) == MVT::i32) { 08165 Select(Tmp0, N10); 08166 Select(Tmp1, N0); 08167 if (N.Val->hasOneUse()) { 08168 Result = CurDAG->SelectNodeTo(N.Val, PPC::EQV, MVT::i32, Tmp0, Tmp1); 08169 } else { 08170 ResNode = CurDAG->getTargetNode(PPC::EQV, MVT::i32, Tmp0, Tmp1); 08171 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08172 Result = SDOperand(ResNode, 0); 08173 } 08174 return; 08175 } 08176 } 08177 } 08178 if (N0.getOpcode() == ISD::BUILD_VECTOR && 08179 Predicate_immAllOnesV(N0.Val)) { 08180 N1 = N.getOperand(1); 08181 if (N1.getOpcode() == ISD::OR) { 08182 N10 = N1.getOperand(0); 08183 N11 = N1.getOperand(1); 08184 08185 // Pattern: (xor:v4i32 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>, (or:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)) 08186 // Emits: (VNOR:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 08187 // Pattern complexity = 7 cost = 1 08188 if (N.Val->getValueType(0) == MVT::v4i32) { 08189 Select(Tmp0, N10); 08190 Select(Tmp1, N11); 08191 if (N.Val->hasOneUse()) { 08192 Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v4i32, Tmp0, Tmp1); 08193 } else { 08194 ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v4i32, Tmp0, Tmp1); 08195 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08196 Result = SDOperand(ResNode, 0); 08197 } 08198 return; 08199 } 08200 08201 // Pattern: (xor:v16i8 (build_vector:v16i8)<<P:Predicate_immAllOnesV>>, (or:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B)) 08202 // Emits: (VNOR:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B) 08203 // Pattern complexity = 7 cost = 1 08204 if (N.Val->getValueType(0) == MVT::v16i8) { 08205 Select(Tmp0, N10); 08206 Select(Tmp1, N11); 08207 if (N.Val->hasOneUse()) { 08208 Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v16i8, Tmp0, Tmp1); 08209 } else { 08210 ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v16i8, Tmp0, Tmp1); 08211 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08212 Result = SDOperand(ResNode, 0); 08213 } 08214 return; 08215 } 08216 08217 // Pattern: (xor:v8i16 (build_vector:v8i16)<<P:Predicate_immAllOnesV>>, (or:v8i16 VRRC:v8i16:$A, VRRC:v8i16:$B)) 08218 // Emits: (VNOR:v8i16 VRRC:v16i8:$A, VRRC:v16i8:$B) 08219 // Pattern complexity = 7 cost = 1 08220 if (N.Val->getValueType(0) == MVT::v8i16) { 08221 Select(Tmp0, N10); 08222 Select(Tmp1, N11); 08223 if (N.Val->hasOneUse()) { 08224 Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v8i16, Tmp0, Tmp1); 08225 } else { 08226 ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v8i16, Tmp0, Tmp1); 08227 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08228 Result = SDOperand(ResNode, 0); 08229 } 08230 return; 08231 } 08232 } 08233 } 08234 { 08235 N1 = N.getOperand(1); 08236 if (N1.getOpcode() == ISD::Constant) { 08237 08238 // Pattern: (xor:i32 GPRC:i32:$src1, (imm:i32)<<P:Predicate_immZExt16>><<X:LO16>>:$src2) 08239 // Emits: (XORI:i32 GPRC:i32:$src1, (LO16:i32 (imm:i32):$src2)) 08240 // Pattern complexity = 5 cost = 1 08241 if (Predicate_immZExt16(N1.Val) && 08242 N.Val->getValueType(0) == MVT::i32) { 08243 Select(Tmp0, N0); 08244 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 08245 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 08246 Tmp2 = Transform_LO16(Tmp1.Val); 08247 if (N.Val->hasOneUse()) { 08248 Result = CurDAG->SelectNodeTo(N.Val, PPC::XORI, MVT::i32, Tmp0, Tmp2); 08249 } else { 08250 ResNode = CurDAG->getTargetNode(PPC::XORI, MVT::i32, Tmp0, Tmp2); 08251 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08252 Result = SDOperand(ResNode, 0); 08253 } 08254 return; 08255 } 08256 08257 // Pattern: (xor:i32 GPRC:i32:$src1, (imm:i32)<<P:Predicate_imm16Shifted>><<X:HI16>>:$src2) 08258 // Emits: (XORIS:i32 GPRC:i32:$src1, (HI16:i32 (imm:i32):$src2)) 08259 // Pattern complexity = 5 cost = 1 08260 if (Predicate_imm16Shifted(N1.Val) && 08261 N.Val->getValueType(0) == MVT::i32) { 08262 Select(Tmp0, N0); 08263 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 08264 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 08265 Tmp2 = Transform_HI16(Tmp1.Val); 08266 if (N.Val->hasOneUse()) { 08267 Result = CurDAG->SelectNodeTo(N.Val, PPC::XORIS, MVT::i32, Tmp0, Tmp2); 08268 } else { 08269 ResNode = CurDAG->getTargetNode(PPC::XORIS, MVT::i32, Tmp0, Tmp2); 08270 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08271 Result = SDOperand(ResNode, 0); 08272 } 08273 return; 08274 } 08275 08276 // Pattern: (xor:i32 GPRC:i32:$in, (imm:i32)<<P:Predicate_immAllOnes>>) 08277 // Emits: (NOR:i32 GPRC:i32:$in, GPRC:i32:$in) 08278 // Pattern complexity = 5 cost = 1 08279 if (Predicate_immAllOnes(N1.Val) && 08280 N.Val->getValueType(0) == MVT::i32) { 08281 Select(Tmp0, N0); 08282 if (N.Val->hasOneUse()) { 08283 Result = CurDAG->SelectNodeTo(N.Val, PPC::NOR, MVT::i32, Tmp0, Tmp0); 08284 } else { 08285 ResNode = CurDAG->getTargetNode(PPC::NOR, MVT::i32, Tmp0, Tmp0); 08286 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08287 Result = SDOperand(ResNode, 0); 08288 } 08289 return; 08290 } 08291 } 08292 if (N1.getOpcode() == ISD::BUILD_VECTOR && 08293 Predicate_immAllOnesV(N1.Val)) { 08294 08295 // Pattern: (xor:v16i8 VRRC:v16i8:$vA, (build_vector:v16i8)<<P:Predicate_immAllOnesV>>) 08296 // Emits: (VNOR:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 08297 // Pattern complexity = 5 cost = 1 08298 if (N.Val->getValueType(0) == MVT::v16i8) { 08299 Select(Tmp0, N0); 08300 if (N.Val->hasOneUse()) { 08301 Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v16i8, Tmp0, Tmp0); 08302 } else { 08303 ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v16i8, Tmp0, Tmp0); 08304 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08305 Result = SDOperand(ResNode, 0); 08306 } 08307 return; 08308 } 08309 08310 // Pattern: (xor:v8i16 VRRC:v8i16:$vA, (build_vector:v8i16)<<P:Predicate_immAllOnesV>>) 08311 // Emits: (VNOR:v8i16 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 08312 // Pattern complexity = 5 cost = 1 08313 if (N.Val->getValueType(0) == MVT::v8i16) { 08314 Select(Tmp0, N0); 08315 if (N.Val->hasOneUse()) { 08316 Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v8i16, Tmp0, Tmp0); 08317 } else { 08318 ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v8i16, Tmp0, Tmp0); 08319 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08320 Result = SDOperand(ResNode, 0); 08321 } 08322 return; 08323 } 08324 08325 // Pattern: (xor:v4i32 VRRC:v4i32:$vA, (build_vector:v4i32)<<P:Predicate_immAllOnesV>>) 08326 // Emits: (VNOR:v4i32 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 08327 // Pattern complexity = 5 cost = 1 08328 if (N.Val->getValueType(0) == MVT::v4i32) { 08329 Select(Tmp0, N0); 08330 if (N.Val->hasOneUse()) { 08331 Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v4i32, Tmp0, Tmp0); 08332 } else { 08333 ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v4i32, Tmp0, Tmp0); 08334 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08335 Result = SDOperand(ResNode, 0); 08336 } 08337 return; 08338 } 08339 } 08340 } 08341 if (N0.getOpcode() == ISD::BUILD_VECTOR && 08342 Predicate_immAllOnesV(N0.Val)) { 08343 N1 = N.getOperand(1); 08344 08345 // Pattern: (xor:v16i8 (build_vector:v16i8)<<P:Predicate_immAllOnesV>>, VRRC:v16i8:$vA) 08346 // Emits: (VNOR:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 08347 // Pattern complexity = 5 cost = 1 08348 if (N.Val->getValueType(0) == MVT::v16i8) { 08349 Select(Tmp0, N1); 08350 if (N.Val->hasOneUse()) { 08351 Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v16i8, Tmp0, Tmp0); 08352 } else { 08353 ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v16i8, Tmp0, Tmp0); 08354 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08355 Result = SDOperand(ResNode, 0); 08356 } 08357 return; 08358 } 08359 08360 // Pattern: (xor:v8i16 (build_vector:v8i16)<<P:Predicate_immAllOnesV>>, VRRC:v8i16:$vA) 08361 // Emits: (VNOR:v8i16 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 08362 // Pattern complexity = 5 cost = 1 08363 if (N.Val->getValueType(0) == MVT::v8i16) { 08364 Select(Tmp0, N1); 08365 if (N.Val->hasOneUse()) { 08366 Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v8i16, Tmp0, Tmp0); 08367 } else { 08368 ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v8i16, Tmp0, Tmp0); 08369 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08370 Result = SDOperand(ResNode, 0); 08371 } 08372 return; 08373 } 08374 08375 // Pattern: (xor:v4i32 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>, VRRC:v4i32:$vA) 08376 // Emits: (VNOR:v4i32 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 08377 // Pattern complexity = 5 cost = 1 08378 if (N.Val->getValueType(0) == MVT::v4i32) { 08379 Select(Tmp0, N1); 08380 if (N.Val->hasOneUse()) { 08381 Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v4i32, Tmp0, Tmp0); 08382 } else { 08383 ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v4i32, Tmp0, Tmp0); 08384 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08385 Result = SDOperand(ResNode, 0); 08386 } 08387 return; 08388 } 08389 } 08390 N1 = N.getOperand(1); 08391 08392 // Pattern: (xor:i32 GPRC:i32:$in, (imm:i32):$imm) 08393 // Emits: (XORIS:i32 (XORI:i32 GPRC:i32:$in, (LO16:i32 (imm:i32):$imm)), (HI16:i32 (imm:i32):$imm)) 08394 // Pattern complexity = 4 cost = 2 08395 if (N1.getOpcode() == ISD::Constant && 08396 N.Val->getValueType(0) == MVT::i32) { 08397 Select(Tmp0, N0); 08398 unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue(); 08399 Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32); 08400 Tmp2 = Transform_LO16(Tmp1.Val); 08401 Tmp3 = SDOperand(CurDAG->getTargetNode(PPC::XORI, MVT::i32, Tmp0, Tmp2), 0); 08402 Tmp4 = Transform_HI16(Tmp1.Val); 08403 if (N.Val->hasOneUse()) { 08404 Result = CurDAG->SelectNodeTo(N.Val, PPC::XORIS, MVT::i32, Tmp3, Tmp4); 08405 } else { 08406 ResNode = CurDAG->getTargetNode(PPC::XORIS, MVT::i32, Tmp3, Tmp4); 08407 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08408 Result = SDOperand(ResNode, 0); 08409 } 08410 return; 08411 } 08412 08413 // Pattern: (xor:i32 GPRC:i32:$rS, GPRC:i32:$rB) 08414 // Emits: (XOR:i32 GPRC:i32:$rS, GPRC:i32:$rB) 08415 // Pattern complexity = 2 cost = 1 08416 if (N.Val->getValueType(0) == MVT::i32) { 08417 Select(Tmp0, N0); 08418 Select(Tmp1, N1); 08419 if (N.Val->hasOneUse()) { 08420 Result = CurDAG->SelectNodeTo(N.Val, PPC::XOR, MVT::i32, Tmp0, Tmp1); 08421 } else { 08422 ResNode = CurDAG->getTargetNode(PPC::XOR, MVT::i32, Tmp0, Tmp1); 08423 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08424 Result = SDOperand(ResNode, 0); 08425 } 08426 return; 08427 } 08428 08429 // Pattern: (xor:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 08430 // Emits: (VXOR:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 08431 // Pattern complexity = 2 cost = 1 08432 if (N.Val->getValueType(0) == MVT::v4i32) { 08433 Select(Tmp0, N0); 08434 Select(Tmp1, N1); 08435 if (N.Val->hasOneUse()) { 08436 Result = CurDAG->SelectNodeTo(N.Val, PPC::VXOR, MVT::v4i32, Tmp0, Tmp1); 08437 } else { 08438 ResNode = CurDAG->getTargetNode(PPC::VXOR, MVT::v4i32, Tmp0, Tmp1); 08439 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08440 Result = SDOperand(ResNode, 0); 08441 } 08442 return; 08443 } 08444 08445 // Pattern: (xor:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B) 08446 // Emits: (VXOR:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B) 08447 // Pattern complexity = 2 cost = 1 08448 if (N.Val->getValueType(0) == MVT::v16i8) { 08449 Select(Tmp0, N0); 08450 Select(Tmp1, N1); 08451 if (N.Val->hasOneUse()) { 08452 Result = CurDAG->SelectNodeTo(N.Val, PPC::VXOR, MVT::v16i8, Tmp0, Tmp1); 08453 } else { 08454 ResNode = CurDAG->getTargetNode(PPC::VXOR, MVT::v16i8, Tmp0, Tmp1); 08455 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08456 Result = SDOperand(ResNode, 0); 08457 } 08458 return; 08459 } 08460 08461 // Pattern: (xor:v8i16 VRRC:v8i16:$A, VRRC:v8i16:$B) 08462 // Emits: (VXOR:v8i16 VRRC:v16i8:$A, VRRC:v16i8:$B) 08463 // Pattern complexity = 2 cost = 1 08464 if (N.Val->getValueType(0) == MVT::v8i16) { 08465 Select(Tmp0, N0); 08466 Select(Tmp1, N1); 08467 if (N.Val->hasOneUse()) { 08468 Result = CurDAG->SelectNodeTo(N.Val, PPC::VXOR, MVT::v8i16, Tmp0, Tmp1); 08469 } else { 08470 ResNode = CurDAG->getTargetNode(PPC::VXOR, MVT::v8i16, Tmp0, Tmp1); 08471 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08472 Result = SDOperand(ResNode, 0); 08473 } 08474 return; 08475 } 08476 std::cerr << "Cannot yet select: "; 08477 N.Val->dump(CurDAG); 08478 std::cerr << '\n'; 08479 abort(); 08480 } 08481 08482 void Select_zext(SDOperand &Result, SDOperand N) { 08483 SDOperand N0(0, 0); 08484 SDOperand Tmp0(0, 0); 08485 SDOperand Tmp1(0, 0); 08486 SDOperand Tmp2(0, 0); 08487 SDOperand Tmp3(0, 0); 08488 SDNode *ResNode; 08489 N0 = N.getOperand(0); 08490 if (N.Val->getValueType(0) == MVT::i64 && 08491 N0.Val->getValueType(0) == MVT::i32) { 08492 Select(Tmp0, N0); 08493 Tmp1 = SDOperand(CurDAG->getTargetNode(PPC::OR4To8, MVT::i64, Tmp0, Tmp0), 0); 08494 Tmp2 = CurDAG->getTargetConstant(0, MVT::i32); 08495 Tmp3 = CurDAG->getTargetConstant(32, MVT::i32); 08496 if (N.Val->hasOneUse()) { 08497 Result = CurDAG->SelectNodeTo(N.Val, PPC::RLDICL, MVT::i64, Tmp1, Tmp2, Tmp3); 08498 } else { 08499 ResNode = CurDAG->getTargetNode(PPC::RLDICL, MVT::i64, Tmp1, Tmp2, Tmp3); 08500 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08501 Result = SDOperand(ResNode, 0); 08502 } 08503 return; 08504 } 08505 std::cerr << "Cannot yet select: "; 08506 N.Val->dump(CurDAG); 08507 std::cerr << '\n'; 08508 abort(); 08509 } 08510 08511 void Select_zextld(SDOperand &Result, SDOperand N) { 08512 if (N.ResNo == 1 && N.getValue(0).hasOneUse()) { 08513 SDOperand Dummy = CurDAG->getNode(ISD::HANDLENODE, MVT::Other, N); 08514 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Dummy.Val, 0); 08515 SelectionDAG::InsertISelMapEntry(HandleMap, N.Val, 1, Dummy.Val, 0); 08516 Result = Dummy; 08517 return; 08518 } 08519 SDOperand Chain(0, 0); 08520 SDOperand N1(0, 0); 08521 SDOperand N2(0, 0); 08522 SDOperand N3(0, 0); 08523 SDOperand Tmp0(0, 0); 08524 SDOperand Tmp1(0, 0); 08525 SDNode *ResNode; 08526 Chain = N.getOperand(0); 08527 N1 = N.getOperand(1); 08528 N2 = N.getOperand(2); 08529 N3 = N.getOperand(3); 08530 08531 // Pattern: (zextld:i32 iaddr:i32:$src, srcvalue:Other:$dummy, i8:Other) 08532 // Emits: (LBZ:i32 iaddr:i32:$src) 08533 // Pattern complexity = 8 cost = 1 08534 if (cast<VTSDNode>(N3)->getVT() == MVT::i8 && 08535 N.Val->getValueType(0) == MVT::i32 && 08536 SelectAddrImm(N1, Tmp0, Tmp1)) { 08537 Select(Tmp0, Tmp0); 08538 Select(Tmp1, Tmp1); 08539 Select(Chain, Chain); 08540 ResNode = CurDAG->getTargetNode(PPC::LBZ, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain); 08541 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 08542 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 08543 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 08544 Result = SDOperand(ResNode, N.ResNo); 08545 return; 08546 } 08547 08548 // Pattern: (zextld:i32 iaddr:i32:$src, srcvalue:Other:$dummy, i16:Other) 08549 // Emits: (LHZ:i32 iaddr:i32:$src) 08550 // Pattern complexity = 8 cost = 1 08551 if (cast<VTSDNode>(N3)->getVT() == MVT::i16 && 08552 N.Val->getValueType(0) == MVT::i32 && 08553 SelectAddrImm(N1, Tmp0, Tmp1)) { 08554 Select(Tmp0, Tmp0); 08555 Select(Tmp1, Tmp1); 08556 Select(Chain, Chain); 08557 ResNode = CurDAG->getTargetNode(PPC::LHZ, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain); 08558 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 08559 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 08560 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 08561 Result = SDOperand(ResNode, N.ResNo); 08562 return; 08563 } 08564 08565 // Pattern: (zextld:i32 xaddr:i32:$src, srcvalue:Other:$dummy, i8:Other) 08566 // Emits: (LBZX:i32 xaddr:i32:$src) 08567 // Pattern complexity = 8 cost = 1 08568 if (cast<VTSDNode>(N3)->getVT() == MVT::i8 && 08569 N.Val->getValueType(0) == MVT::i32 && 08570 SelectAddrIdx(N1, Tmp0, Tmp1)) { 08571 Select(Tmp0, Tmp0); 08572 Select(Tmp1, Tmp1); 08573 Select(Chain, Chain); 08574 ResNode = CurDAG->getTargetNode(PPC::LBZX, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain); 08575 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 08576 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 08577 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 08578 Result = SDOperand(ResNode, N.ResNo); 08579 return; 08580 } 08581 08582 // Pattern: (zextld:i32 xaddr:i32:$src, srcvalue:Other:$dummy, i16:Other) 08583 // Emits: (LHZX:i32 xaddr:i32:$src) 08584 // Pattern complexity = 8 cost = 1 08585 if (cast<VTSDNode>(N3)->getVT() == MVT::i16 && 08586 N.Val->getValueType(0) == MVT::i32 && 08587 SelectAddrIdx(N1, Tmp0, Tmp1)) { 08588 Select(Tmp0, Tmp0); 08589 Select(Tmp1, Tmp1); 08590 Select(Chain, Chain); 08591 ResNode = CurDAG->getTargetNode(PPC::LHZX, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain); 08592 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 08593 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 08594 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 08595 Result = SDOperand(ResNode, N.ResNo); 08596 return; 08597 } 08598 if (cast<VTSDNode>(N3)->getVT() == MVT::i1 && 08599 N.Val->getValueType(0) == MVT::i32) { 08600 08601 // Pattern: (zextld:i32 iaddr:i32:$src, srcvalue:Other:$dummy, i1:Other) 08602 // Emits: (LBZ:i32 iaddr:i32:$src) 08603 // Pattern complexity = 8 cost = 1 08604 if (SelectAddrImm(N1, Tmp0, Tmp1)) { 08605 Select(Tmp0, Tmp0); 08606 Select(Tmp1, Tmp1); 08607 Select(Chain, Chain); 08608 ResNode = CurDAG->getTargetNode(PPC::LBZ, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain); 08609 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 08610 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 08611 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 08612 Result = SDOperand(ResNode, N.ResNo); 08613 return; 08614 } 08615 08616 // Pattern: (zextld:i32 xaddr:i32:$src, srcvalue:Other:$dummy, i1:Other) 08617 // Emits: (LBZX:i32 xaddr:i32:$src) 08618 // Pattern complexity = 8 cost = 1 08619 if (SelectAddrIdx(N1, Tmp0, Tmp1)) { 08620 Select(Tmp0, Tmp0); 08621 Select(Tmp1, Tmp1); 08622 Select(Chain, Chain); 08623 ResNode = CurDAG->getTargetNode(PPC::LBZX, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain); 08624 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 08625 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1); 08626 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1); 08627 Result = SDOperand(ResNode, N.ResNo); 08628 return; 08629 } 08630 } 08631 std::cerr << "Cannot yet select: "; 08632 N.Val->dump(CurDAG); 08633 std::cerr << '\n'; 08634 abort(); 08635 } 08636 08637 void Select_INLINEASM(SDOperand& Result, SDOperand N) { 08638 std::vector<SDOperand> Ops(N.Val->op_begin(), N.Val->op_end()); 08639 Select(Ops[0], N.getOperand(0)); // Select the chain. 08640 08641 // Select the flag operand. 08642 if (Ops.back().getValueType() == MVT::Flag) 08643 Select(Ops.back(), Ops.back()); 08644 SelectInlineAsmMemoryOperands(Ops, *CurDAG); 08645 std::vector<MVT::ValueType> VTs; 08646 VTs.push_back(MVT::Other); 08647 VTs.push_back(MVT::Flag); 08648 SDOperand New = CurDAG->getNode(ISD::INLINEASM, VTs, Ops); 08649 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, New.Val, 0); 08650 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, New.Val, 1); 08651 Result = New.getValue(N.ResNo); 08652 return; 08653 } 08654 08655 // The main instruction selector code. 08656 void SelectCode(SDOperand &Result, SDOperand N) { 08657 if (N.getOpcode() >= ISD::BUILTIN_OP_END && 08658 N.getOpcode() < (ISD::BUILTIN_OP_END+PPC::INSTRUCTION_LIST_END)) { 08659 Result = N; 08660 return; // Already selected. 08661 } 08662 08663 std::map<SDOperand, SDOperand>::iterator CGMI = CodeGenMap.find(N); 08664 if (CGMI != CodeGenMap.end()) { 08665 Result = CGMI->second; 08666 return; 08667 } 08668 08669 switch (N.getOpcode()) { 08670 default: break; 08671 case ISD::EntryToken: // These leaves remain the same. 08672 case ISD::BasicBlock: 08673 case ISD::Register: 08674 case ISD::HANDLENODE: 08675 case ISD::TargetConstant: 08676 case ISD::TargetConstantPool: 08677 case ISD::TargetFrameIndex: 08678 case ISD::TargetGlobalAddress: { 08679 Result = N; 08680 return; 08681 } 08682 case ISD::AssertSext: 08683 case ISD::AssertZext: { 08684 SDOperand Tmp0; 08685 Select(Tmp0, N.getOperand(0)); 08686 if (!N.Val->hasOneUse()) 08687 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, Tmp0.Val, Tmp0.ResNo); 08688 Result = Tmp0; 08689 return; 08690 } 08691 case ISD::TokenFactor: 08692 if (N.getNumOperands() == 2) { 08693 SDOperand Op0, Op1; 08694 Select(Op0, N.getOperand(0)); 08695 Select(Op1, N.getOperand(1)); 08696 Result = 08697 CurDAG->getNode(ISD::TokenFactor, MVT::Other, Op0, Op1); 08698 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, Result.Val, Result.ResNo); 08699 } else { 08700 std::vector<SDOperand> Ops; 08701 for (unsigned i = 0, e = N.getNumOperands(); i != e; ++i) { 08702 SDOperand Val; 08703 Select(Val, N.getOperand(i)); 08704 Ops.push_back(Val); 08705 } 08706 Result = 08707 CurDAG->getNode(ISD::TokenFactor, MVT::Other, Ops); 08708 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, Result.Val, Result.ResNo); 08709 } 08710 return; 08711 case ISD::CopyFromReg: { 08712 SDOperand Chain; 08713 Select(Chain, N.getOperand(0)); 08714 unsigned Reg = cast<RegisterSDNode>(N.getOperand(1))->getReg(); 08715 MVT::ValueType VT = N.Val->getValueType(0); 08716 if (N.Val->getNumValues() == 2) { 08717 if (Chain == N.getOperand(0)) { 08718 Result = N; // No change 08719 return; 08720 } 08721 SDOperand New = CurDAG->getCopyFromReg(Chain, Reg, VT); 08722 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, New.Val, 0); 08723 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, New.Val, 1); 08724 Result = New.getValue(N.ResNo); 08725 return; 08726 } else { 08727 SDOperand Flag; 08728 if (N.getNumOperands() == 3) Select(Flag, N.getOperand(2)); 08729 if (Chain == N.getOperand(0) && 08730 (N.getNumOperands() == 2 || Flag == N.getOperand(2))) { 08731 Result = N; // No change 08732 return; 08733 } 08734 SDOperand New = CurDAG->getCopyFromReg(Chain, Reg, VT, Flag); 08735 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, New.Val, 0); 08736 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, New.Val, 1); 08737 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 2, New.Val, 2); 08738 Result = New.getValue(N.ResNo); 08739 return; 08740 } 08741 } 08742 case ISD::CopyToReg: { 08743 SDOperand Chain; 08744 Select(Chain, N.getOperand(0)); 08745 unsigned Reg = cast<RegisterSDNode>(N.getOperand(1))->getReg(); 08746 SDOperand Val; 08747 Select(Val, N.getOperand(2)); 08748 Result = N; 08749 if (N.Val->getNumValues() == 1) { 08750 if (Chain != N.getOperand(0) || Val != N.getOperand(2)) 08751 Result = CurDAG->getCopyToReg(Chain, Reg, Val); 08752 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Result.Val, 0); 08753 } else { 08754 SDOperand Flag(0, 0); 08755 if (N.getNumOperands() == 4) Select(Flag, N.getOperand(3)); 08756 if (Chain != N.getOperand(0) || Val != N.getOperand(2) || 08757 (N.getNumOperands() == 4 && Flag != N.getOperand(3))) 08758 Result = CurDAG->getCopyToReg(Chain, Reg, Val, Flag); 08759 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Result.Val, 0); 08760 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Result.Val, 1); 08761 Result = Result.getValue(N.ResNo); 08762 } 08763 return; 08764 } 08765 case ISD::INLINEASM: Select_INLINEASM(Result, N); return; 08766 case PPCISD::EXTSW_32: Select_PPCextsw_32(Result, N); return; 08767 case PPCISD::FCFID: Select_PPCfcfid(Result, N); return; 08768 case PPCISD::FCTIDZ: Select_PPCfctidz(Result, N); return; 08769 case PPCISD::FCTIWZ: Select_PPCfctiwz(Result, N); return; 08770 case PPCISD::FSEL: Select_PPCfsel(Result, N); return; 08771 case PPCISD::Hi: Select_PPChi(Result, N); return; 08772 case PPCISD::Lo: Select_PPClo(Result, N); return; 08773 case PPCISD::SHL: Select_PPCshl(Result, N); return; 08774 case PPCISD::SRA: Select_PPCsra(Result, N); return; 08775 case PPCISD::SRL: Select_PPCsrl(Result, N); return; 08776 case PPCISD::STD_32: Select_PPCstd_32(Result, N); return; 08777 case PPCISD::STFIWX: Select_PPCstfiwx(Result, N); return; 08778 case PPCISD::VCMP: Select_PPCvcmp(Result, N); return; 08779 case PPCISD::VCMPo: Select_PPCvcmp_o(Result, N); return; 08780 case PPCISD::VMADDFP: Select_PPCvmaddfp(Result, N); return; 08781 case PPCISD::VNMSUBFP: Select_PPCvnmsubfp(Result, N); return; 08782 case PPCISD::VPERM: Select_PPCvperm(Result, N); return; 08783 case ISD::ADD: Select_add(Result, N); return; 08784 case ISD::ADDC: Select_addc(Result, N); return; 08785 case ISD::ADDE: Select_adde(Result, N); return; 08786 case ISD::AND: Select_and(Result, N); return; 08787 case ISD::ANY_EXTEND: Select_anyext(Result, N); return; 08788 case ISD::BIT_CONVERT: Select_bitconvert(Result, N); return; 08789 case ISD::BR: Select_br(Result, N); return; 08790 case ISD::BUILD_VECTOR: Select_build_vector(Result, N); return; 08791 case ISD::CALLSEQ_END: Select_callseq_end(Result, N); return; 08792 case ISD::CALLSEQ_START: Select_callseq_start(Result, N); return; 08793 case ISD::CTLZ: Select_ctlz(Result, N); return; 08794 case ISD::DEBUG_LABEL: Select_dwarf_label(Result, N); return; 08795 case ISD::DEBUG_LOC: Select_dwarf_loc(Result, N); return; 08796 case ISD::EXTLOAD: Select_extld(Result, N); return; 08797 case ISD::FABS: Select_fabs(Result, N); return; 08798 case ISD::FADD: Select_fadd(Result, N); return; 08799 case ISD::FDIV: Select_fdiv(Result, N); return; 08800 case ISD::FP_EXTEND: Select_fextend(Result, N); return; 08801 case ISD::FMUL: Select_fmul(Result, N); return; 08802 case ISD::FNEG: Select_fneg(Result, N); return; 08803 case ISD::FP_ROUND: Select_fround(Result, N); return; 08804 case ISD::FSQRT: Select_fsqrt(Result, N); return; 08805 case ISD::FSUB: Select_fsub(Result, N); return; 08806 case ISD::Constant: Select_imm(Result, N); return; 08807 case ISD::INTRINSIC_VOID: Select_intrinsic_void(Result, N); return; 08808 case ISD::INTRINSIC_W_CHAIN: Select_intrinsic_w_chain(Result, N); return; 08809 case ISD::INTRINSIC_WO_CHAIN: Select_intrinsic_wo_chain(Result, N); return; 08810 case ISD::LOAD: Select_load(Result, N); return; 08811 case ISD::MUL: Select_mul(Result, N); return; 08812 case ISD::MULHS: Select_mulhs(Result, N); return; 08813 case ISD::MULHU: Select_mulhu(Result, N); return; 08814 case ISD::OR: Select_or(Result, N); return; 08815 case ISD::RET: Select_ret(Result, N); return; 08816 case PPCISD::RET_FLAG: Select_retflag(Result, N); return; 08817 case ISD::ROTL: Select_rotl(Result, N); return; 08818 case ISD::SDIV: Select_sdiv(Result, N); return; 08819 case ISD::SIGN_EXTEND_INREG: Select_sext_inreg(Result, N); return; 08820 case ISD::SEXTLOAD: Select_sextld(Result, N); return; 08821 case ISD::SHL: Select_shl(Result, N); return; 08822 case ISD::SRA: Select_sra(Result, N); return; 08823 case ISD::SRL: Select_srl(Result, N); return; 08824 case ISD::STORE: Select_store(Result, N); return; 08825 case ISD::SUB: Select_sub(Result, N); return; 08826 case ISD::SUBC: Select_subc(Result, N); return; 08827 case ISD::SUBE: Select_sube(Result, N); return; 08828 case ISD::TRUNCATE: Select_trunc(Result, N); return; 08829 case ISD::TRUNCSTORE: Select_truncst(Result, N); return; 08830 case ISD::UDIV: Select_udiv(Result, N); return; 08831 case ISD::UNDEF: Select_undef(Result, N); return; 08832 case ISD::VECTOR_SHUFFLE: Select_vector_shuffle(Result, N); return; 08833 case ISD::XOR: Select_xor(Result, N); return; 08834 case ISD::ZERO_EXTEND: Select_zext(Result, N); return; 08835 case ISD::ZEXTLOAD: Select_zextld(Result, N); return; 08836 } // end of big switch. 08837 08838 std::cerr << "Cannot yet select: "; 08839 if (N.getOpcode() != ISD::INTRINSIC_W_CHAIN && 08840 N.getOpcode() != ISD::INTRINSIC_WO_CHAIN && 08841 N.getOpcode() != ISD::INTRINSIC_VOID) { 08842 N.Val->dump(CurDAG); 08843 } else { 08844 unsigned iid = cast<ConstantSDNode>(N.getOperand(N.getOperand(0).getValueType() == MVT::Other))->getValue(); 08845 std::cerr << "intrinsic %"<< Intrinsic::getName((Intrinsic::ID)iid); 08846 } 08847 std::cerr << '\n'; 08848 abort(); 08849 }