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 #if defined(__GNUC__) && \ 00013 ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))) 00014 #define NOINLINE __attribute__((noinline)) 00015 #else 00016 00017 #define NOINLINE 00018 00019 #endif 00020 00021 // Instance var to keep track of multiply used nodes that have 00022 // already been selected. 00023 std::map<SDOperand, SDOperand> CodeGenMap; 00024 // Instance var to keep track of mapping of chain generating nodes 00025 // and their place handle nodes. 00026 std::map<SDOperand, SDOperand> HandleMap; 00027 // Instance var to keep track of mapping of place handle nodes 00028 // and their replacement nodes. 00029 std::map<SDOperand, SDOperand> ReplaceMap; 00030 // Keep track of nodes that are currently being selecte and therefore 00031 // should not be folded. 00032 std::set<SDNode*> InFlightSet; 00033 00034 static void findNonImmUse(SDNode* Use, SDNode* Def, bool &found, std::set<SDNode *> &Visited) { 00035 if (found || !Visited.insert(Use).second) return; 00036 for (unsigned i = 0, e = Use->getNumOperands(); i != e; ++i) { 00037 SDNode *N = Use->getOperand(i).Val; 00038 if (N != Def) { 00039 findNonImmUse(N, Def, found, Visited); 00040 } else { 00041 found = true; 00042 break; 00043 } 00044 } 00045 } 00046 00047 static bool isNonImmUse(SDNode* Use, SDNode* Def) { 00048 std::set<SDNode *> Visited; 00049 bool found = false; 00050 for (unsigned i = 0, e = Use->getNumOperands(); i != e; ++i) { 00051 SDNode *N = Use->getOperand(i).Val; 00052 if (N != Def) { 00053 findNonImmUse(N, Def, found, Visited); 00054 if (found) break; 00055 } 00056 } 00057 return found; 00058 } 00059 00060 // AddHandleReplacement - Note the pending replacement node for a 00061 // handle node in ReplaceMap. 00062 void AddHandleReplacement(SDNode *H, unsigned HNum, SDNode *R, unsigned RNum) { 00063 SDOperand N(H, HNum); 00064 std::map<SDOperand, SDOperand>::iterator HMI = HandleMap.find(N); 00065 if (HMI != HandleMap.end()) { 00066 ReplaceMap[HMI->second] = SDOperand(R, RNum); 00067 HandleMap.erase(N); 00068 } 00069 } 00070 00071 // SelectDanglingHandles - Select replacements for all `dangling` 00072 // handles.Some handles do not yet have replacements because the 00073 // nodes they replacements have only dead readers. 00074 void SelectDanglingHandles() { 00075 for (std::map<SDOperand, SDOperand>::iterator I = HandleMap.begin(), 00076 E = HandleMap.end(); I != E; ++I) { 00077 SDOperand N = I->first; 00078 SDOperand R; 00079 Select(R, N.getValue(0)); 00080 AddHandleReplacement(N.Val, N.ResNo, R.Val, R.ResNo); 00081 } 00082 } 00083 00084 // ReplaceHandles - Replace all the handles with the real target 00085 // specific nodes. 00086 void ReplaceHandles() { 00087 for (std::map<SDOperand, SDOperand>::iterator I = ReplaceMap.begin(), 00088 E = ReplaceMap.end(); I != E; ++I) { 00089 SDOperand From = I->first; 00090 SDOperand To = I->second; 00091 for (SDNode::use_iterator UI = From.Val->use_begin(), E = From.Val->use_end(); UI != E; ++UI) { 00092 SDNode *Use = *UI; 00093 std::vector<SDOperand> Ops; 00094 for (unsigned i = 0, e = Use->getNumOperands(); i != e; ++i){ 00095 SDOperand O = Use->getOperand(i); 00096 if (O.Val == From.Val) 00097 Ops.push_back(To); 00098 else 00099 Ops.push_back(O); 00100 } 00101 SDOperand U = SDOperand(Use, 0); 00102 CurDAG->UpdateNodeOperands(U, Ops); 00103 } 00104 } 00105 } 00106 00107 // SelectRoot - Top level entry to DAG isel. 00108 SDOperand SelectRoot(SDOperand N) { 00109 SDOperand ResNode; 00110 Select(ResNode, N); 00111 SelectDanglingHandles(); 00112 ReplaceHandles(); 00113 ReplaceMap.clear(); 00114 return ResNode; 00115 } 00116 00117 // Node transformations. 00118 inline SDOperand Transform_VSPLTW_get_imm(SDNode *N) { 00119 00120 return getI32Imm(PPC::getVSPLTImmediate(N, 4)); 00121 00122 } 00123 inline SDOperand Transform_VSPLTISW_get_imm(SDNode *N) { 00124 00125 return PPC::get_VSPLTI_elt(N, 4, *CurDAG); 00126 00127 } 00128 inline SDOperand Transform_VSPLTISH_get_imm(SDNode *N) { 00129 00130 return PPC::get_VSPLTI_elt(N, 2, *CurDAG); 00131 00132 } 00133 inline SDOperand Transform_VSPLTISB_get_imm(SDNode *N) { 00134 00135 return PPC::get_VSPLTI_elt(N, 1, *CurDAG); 00136 00137 } 00138 inline SDOperand Transform_VSPLTH_get_imm(SDNode *N) { 00139 00140 return getI32Imm(PPC::getVSPLTImmediate(N, 2)); 00141 00142 } 00143 inline SDOperand Transform_VSPLTB_get_imm(SDNode *N) { 00144 00145 return getI32Imm(PPC::getVSPLTImmediate(N, 1)); 00146 00147 } 00148 inline SDOperand Transform_VSLDOI_unary_get_imm(SDNode *N) { 00149 00150 return getI32Imm(PPC::isVSLDOIShuffleMask(N, true)); 00151 00152 } 00153 inline SDOperand Transform_VSLDOI_get_imm(SDNode *N) { 00154 00155 return getI32Imm(PPC::isVSLDOIShuffleMask(N, false)); 00156 00157 } 00158 inline SDOperand Transform_SRL64(SDNode *inN) { 00159 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00160 00161 // Transformation function: 64 - imm 00162 return N->getValue() ? getI32Imm(64 - N->getValue()) : getI32Imm(0); 00163 00164 } 00165 inline SDOperand Transform_SRL32(SDNode *inN) { 00166 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00167 00168 // Transformation function: 32 - imm 00169 return N->getValue() ? getI32Imm(32 - N->getValue()) : getI32Imm(0); 00170 00171 } 00172 inline SDOperand Transform_SHL64(SDNode *inN) { 00173 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00174 00175 // Transformation function: 63 - imm 00176 return getI32Imm(63 - N->getValue()); 00177 00178 } 00179 inline SDOperand Transform_SHL32(SDNode *inN) { 00180 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00181 00182 // Transformation function: 31 - imm 00183 return getI32Imm(31 - N->getValue()); 00184 00185 } 00186 inline SDOperand Transform_LO16(SDNode *inN) { 00187 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00188 00189 // Transformation function: get the low 16 bits. 00190 return getI32Imm((unsigned short)N->getValue()); 00191 00192 } 00193 inline SDOperand Transform_HI48_64(SDNode *inN) { 00194 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00195 00196 // Transformation function: shift the immediate value down into the low bits. 00197 return getI32Imm((unsigned short)(N->getValue() >> 48)); 00198 00199 } 00200 inline SDOperand Transform_HI32_48(SDNode *inN) { 00201 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00202 00203 // Transformation function: shift the immediate value down into the low bits. 00204 return getI32Imm((unsigned short)(N->getValue() >> 32)); 00205 00206 } 00207 inline SDOperand Transform_HI16(SDNode *inN) { 00208 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00209 00210 // Transformation function: shift the immediate value down into the low bits. 00211 return getI32Imm((unsigned)N->getValue() >> 16); 00212 00213 } 00214 inline SDOperand Transform_HA16(SDNode *inN) { 00215 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00216 00217 // Transformation function: shift the immediate value down into the low bits. 00218 signed int Val = N->getValue(); 00219 return getI32Imm((Val - (signed short)Val) >> 16); 00220 00221 } 00222 00223 // Predicate functions. 00224 inline bool Predicate_VMRGHB_shuffle_mask(SDNode *N) { 00225 00226 return PPC::isVMRGHShuffleMask(N, 1, false); 00227 00228 } 00229 inline bool Predicate_VMRGHB_unary_shuffle_mask(SDNode *N) { 00230 00231 return PPC::isVMRGHShuffleMask(N, 1, true); 00232 00233 } 00234 inline bool Predicate_VMRGHH_shuffle_mask(SDNode *N) { 00235 00236 return PPC::isVMRGHShuffleMask(N, 2, false); 00237 00238 } 00239 inline bool Predicate_VMRGHH_unary_shuffle_mask(SDNode *N) { 00240 00241 return PPC::isVMRGHShuffleMask(N, 2, true); 00242 00243 } 00244 inline bool Predicate_VMRGHW_shuffle_mask(SDNode *N) { 00245 00246 return PPC::isVMRGHShuffleMask(N, 4, false); 00247 00248 } 00249 inline bool Predicate_VMRGHW_unary_shuffle_mask(SDNode *N) { 00250 00251 return PPC::isVMRGHShuffleMask(N, 4, true); 00252 00253 } 00254 inline bool Predicate_VMRGLB_shuffle_mask(SDNode *N) { 00255 00256 return PPC::isVMRGLShuffleMask(N, 1, false); 00257 00258 } 00259 inline bool Predicate_VMRGLB_unary_shuffle_mask(SDNode *N) { 00260 00261 return PPC::isVMRGLShuffleMask(N, 1, true); 00262 00263 } 00264 inline bool Predicate_VMRGLH_shuffle_mask(SDNode *N) { 00265 00266 return PPC::isVMRGLShuffleMask(N, 2, false); 00267 00268 } 00269 inline bool Predicate_VMRGLH_unary_shuffle_mask(SDNode *N) { 00270 00271 return PPC::isVMRGLShuffleMask(N, 2, true); 00272 00273 } 00274 inline bool Predicate_VMRGLW_shuffle_mask(SDNode *N) { 00275 00276 return PPC::isVMRGLShuffleMask(N, 4, false); 00277 00278 } 00279 inline bool Predicate_VMRGLW_unary_shuffle_mask(SDNode *N) { 00280 00281 return PPC::isVMRGLShuffleMask(N, 4, true); 00282 00283 } 00284 inline bool Predicate_VPKUHUM_shuffle_mask(SDNode *N) { 00285 00286 return PPC::isVPKUHUMShuffleMask(N, false); 00287 00288 } 00289 inline bool Predicate_VPKUHUM_unary_shuffle_mask(SDNode *N) { 00290 00291 return PPC::isVPKUHUMShuffleMask(N, true); 00292 00293 } 00294 inline bool Predicate_VPKUWUM_shuffle_mask(SDNode *N) { 00295 00296 return PPC::isVPKUWUMShuffleMask(N, false); 00297 00298 } 00299 inline bool Predicate_VPKUWUM_unary_shuffle_mask(SDNode *N) { 00300 00301 return PPC::isVPKUWUMShuffleMask(N, true); 00302 00303 } 00304 inline bool Predicate_VSLDOI_shuffle_mask(SDNode *N) { 00305 00306 return PPC::isVSLDOIShuffleMask(N, false) != -1; 00307 00308 } 00309 inline bool Predicate_VSLDOI_unary_shuffle_mask(SDNode *N) { 00310 00311 return PPC::isVSLDOIShuffleMask(N, true) != -1; 00312 00313 } 00314 inline bool Predicate_VSPLTB_shuffle_mask(SDNode *N) { 00315 00316 return PPC::isSplatShuffleMask(N, 1); 00317 00318 } 00319 inline bool Predicate_VSPLTH_shuffle_mask(SDNode *N) { 00320 00321 return PPC::isSplatShuffleMask(N, 2); 00322 00323 } 00324 inline bool Predicate_VSPLTW_shuffle_mask(SDNode *N) { 00325 00326 return PPC::isSplatShuffleMask(N, 4); 00327 00328 } 00329 inline bool Predicate_imm16ShiftedSExt(SDNode *inN) { 00330 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00331 00332 // imm16ShiftedSExt predicate - True if only bits in the top 16-bits of the 00333 // immediate are set. Used by instructions like 'addis'. Identical to 00334 // imm16ShiftedZExt in 32-bit mode. 00335 if (N->getValue() & 0xFFFF) return false; 00336 if (N->getValueType(0) == MVT::i32) 00337 return true; 00338 // For 64-bit, make sure it is sext right. 00339 return N->getValue() == (uint64_t)(int)N->getValue(); 00340 00341 } 00342 inline bool Predicate_imm16ShiftedZExt(SDNode *inN) { 00343 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00344 00345 // imm16ShiftedZExt predicate - True if only bits in the top 16-bits of the 00346 // immediate are set. Used by instructions like 'xoris'. 00347 return (N->getValue() & ~uint64_t(0xFFFF0000)) == 0; 00348 00349 } 00350 inline bool Predicate_immAllOnes(SDNode *inN) { 00351 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00352 return N->isAllOnesValue(); 00353 } 00354 inline bool Predicate_immAllOnesV(SDNode *N) { 00355 00356 return ISD::isBuildVectorAllOnes(N); 00357 00358 } 00359 inline bool Predicate_immAllOnesV_bc(SDNode *N) { 00360 00361 return ISD::isBuildVectorAllOnes(N); 00362 00363 } 00364 inline bool Predicate_immAllZerosV(SDNode *N) { 00365 00366 return ISD::isBuildVectorAllZeros(N); 00367 00368 } 00369 inline bool Predicate_immSExt16(SDNode *inN) { 00370 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00371 00372 // immSExt16 predicate - True if the immediate fits in a 16-bit sign extended 00373 // field. Used by instructions like 'addi'. 00374 if (N->getValueType(0) == MVT::i32) 00375 return (int32_t)N->getValue() == (short)N->getValue(); 00376 else 00377 return (int64_t)N->getValue() == (short)N->getValue(); 00378 00379 } 00380 inline bool Predicate_immZExt16(SDNode *inN) { 00381 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00382 00383 // immZExt16 predicate - True if the immediate fits in a 16-bit zero extended 00384 // field. Used by instructions like 'ori'. 00385 return (uint64_t)N->getValue() == (unsigned short)N->getValue(); 00386 00387 } 00388 inline bool Predicate_sext_0x0000_0000_FFFF_FFFF_i16(SDNode *inN) { 00389 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00390 00391 return N->getValue() == (uint64_t)(int32_t)N->getValue(); 00392 00393 } 00394 inline bool Predicate_vecspltisb(SDNode *N) { 00395 00396 return PPC::get_VSPLTI_elt(N, 1, *CurDAG).Val != 0; 00397 00398 } 00399 inline bool Predicate_vecspltish(SDNode *N) { 00400 00401 return PPC::get_VSPLTI_elt(N, 2, *CurDAG).Val != 0; 00402 00403 } 00404 inline bool Predicate_vecspltisw(SDNode *N) { 00405 00406 return PPC::get_VSPLTI_elt(N, 4, *CurDAG).Val != 0; 00407 00408 } 00409 inline bool Predicate_vtFP(SDNode *inN) { 00410 VTSDNode *N = cast<VTSDNode>(inN); 00411 return MVT::isFloatingPoint(N->getVT()); 00412 } 00413 inline bool Predicate_vtInt(SDNode *inN) { 00414 VTSDNode *N = cast<VTSDNode>(inN); 00415 return MVT::isInteger(N->getVT()); 00416 } 00417 inline bool Predicate_zext_0x0000_0000_FFFF_7FFF_i16(SDNode *inN) { 00418 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00419 00420 return (N->getValue() & 0xFFFFFFFF00008000ULL) == 0; 00421 00422 } 00423 inline bool Predicate_zext_0x0000_0000_FFFF_FFFF_i16(SDNode *inN) { 00424 ConstantSDNode *N = cast<ConstantSDNode>(inN); 00425 00426 return (N->getValue() & 0xFFFFFFFF00000000ULL) == 0; 00427 00428 } 00429 00430 00431 void Emit_0(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &Chain, bool HasInFlag) NOINLINE { 00432 SDOperand InFlag(0, 0); 00433 SDNode *ResNode = NULL; 00434 Chain = N.getOperand(0); 00435 HasInFlag = (N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag); 00436 std::vector<SDOperand> Ops; 00437 Select(Chain, Chain); 00438 if (HasInFlag) 00439 Select(InFlag, N.getOperand(N.getNumOperands()-1)); 00440 for (unsigned i = 2, e = N.getNumOperands()-(HasInFlag?1:0); i != e; ++i) { 00441 SDOperand VarOp(0, 0); 00442 Select(VarOp, N.getOperand(i)); 00443 Ops.push_back(VarOp); 00444 } 00445 Ops.push_back(Chain); 00446 if (HasInFlag) 00447 Ops.push_back(InFlag); 00448 ResNode = CurDAG->getTargetNode(Opc0, MVT::Other, MVT::Flag, Ops); 00449 Chain = SDOperand(ResNode, 0); 00450 InFlag = SDOperand(ResNode, 1); 00451 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 00452 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 00453 Result = SDOperand(ResNode, N.ResNo); 00454 return; 00455 } 00456 void Select_PPCbctrl(SDOperand &Result, SDOperand N) { 00457 SDOperand Chain(0, 0); 00458 SDOperand InFlag(0, 0); 00459 SDNode *ResNode = NULL; 00460 bool HasInFlag = false; 00461 Emit_0(Result, N, PPC::BCTRL, Chain, HasInFlag); 00462 return; 00463 } 00464 00465 void Emit_1(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &Chain, SDOperand &N1, bool HasInFlag) NOINLINE { 00466 SDOperand InFlag(0, 0); 00467 SDOperand Tmp0(0, 0); 00468 SDNode *ResNode = NULL; 00469 HasInFlag = (N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag); 00470 std::vector<SDOperand> Ops; 00471 Tmp0 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getValue()), MVT::i32); 00472 Select(Chain, Chain); 00473 if (HasInFlag) 00474 Select(InFlag, N.getOperand(N.getNumOperands()-1)); 00475 Ops.push_back(Tmp0); 00476 for (unsigned i = 2, e = N.getNumOperands()-(HasInFlag?1:0); i != e; ++i) { 00477 SDOperand VarOp(0, 0); 00478 Select(VarOp, N.getOperand(i)); 00479 Ops.push_back(VarOp); 00480 } 00481 Ops.push_back(Chain); 00482 if (HasInFlag) 00483 Ops.push_back(InFlag); 00484 ResNode = CurDAG->getTargetNode(Opc0, MVT::Other, MVT::Flag, Ops); 00485 Chain = SDOperand(ResNode, 0); 00486 InFlag = SDOperand(ResNode, 1); 00487 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 00488 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 00489 Result = SDOperand(ResNode, N.ResNo); 00490 return; 00491 } 00492 void Emit_2(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &Chain, SDOperand &N1, bool HasInFlag) NOINLINE { 00493 SDOperand InFlag(0, 0); 00494 SDOperand Tmp0(0, 0); 00495 SDNode *ResNode = NULL; 00496 HasInFlag = (N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag); 00497 std::vector<SDOperand> Ops; 00498 Tmp0 = N1; 00499 Select(Chain, Chain); 00500 if (HasInFlag) 00501 Select(InFlag, N.getOperand(N.getNumOperands()-1)); 00502 Ops.push_back(Tmp0); 00503 for (unsigned i = 2, e = N.getNumOperands()-(HasInFlag?1:0); i != e; ++i) { 00504 SDOperand VarOp(0, 0); 00505 Select(VarOp, N.getOperand(i)); 00506 Ops.push_back(VarOp); 00507 } 00508 Ops.push_back(Chain); 00509 if (HasInFlag) 00510 Ops.push_back(InFlag); 00511 ResNode = CurDAG->getTargetNode(Opc0, MVT::Other, MVT::Flag, Ops); 00512 Chain = SDOperand(ResNode, 0); 00513 InFlag = SDOperand(ResNode, 1); 00514 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 00515 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 00516 Result = SDOperand(ResNode, N.ResNo); 00517 return; 00518 } 00519 void Select_PPCcall(SDOperand &Result, SDOperand N) { 00520 SDOperand Chain(0, 0); 00521 SDOperand InFlag(0, 0); 00522 SDOperand N1(0, 0); 00523 SDOperand Tmp0(0, 0); 00524 SDNode *ResNode = NULL; 00525 bool HasInFlag = false; 00526 Chain = N.getOperand(0); 00527 N1 = N.getOperand(1); 00528 00529 // Pattern: (PPCcall:void (imm:i32):$func) 00530 // Emits: (BLA:void (imm:i32):$func) 00531 // Pattern complexity = 4 cost = 1 size = 0 00532 if (N1.getOpcode() == ISD::Constant && 00533 N1.Val->getValueType(0) == MVT::i32) { 00534 Emit_1(Result, N, PPC::BLA, Chain, N1, HasInFlag); 00535 return; 00536 } 00537 00538 // Pattern: (PPCcall:void (tglobaladdr:iPTR):$dst) 00539 // Emits: (BL:void (tglobaladdr:iPTR):$dst) 00540 // Pattern complexity = 4 cost = 1 size = 0 00541 if (N1.getOpcode() == ISD::TargetGlobalAddress) { 00542 Emit_2(Result, N, PPC::BL, Chain, N1, HasInFlag); 00543 return; 00544 } 00545 00546 // Pattern: (PPCcall:void (texternalsym:iPTR):$dst) 00547 // Emits: (BL:void (texternalsym:iPTR):$dst) 00548 // Pattern complexity = 4 cost = 1 00549 if (N1.getOpcode() == ISD::TargetExternalSymbol) { 00550 Emit_2(Result, N, PPC::BL, Chain, N1, HasInFlag); 00551 return; 00552 } 00553 std::cerr << "Cannot yet select: "; 00554 N.Val->dump(CurDAG); 00555 std::cerr << '\n'; 00556 abort(); 00557 } 00558 00559 void Emit_3(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &Chain, SDOperand &N1, SDOperand &N2, SDOperand &N3, bool HasInFlag) NOINLINE { 00560 SDOperand InFlag(0, 0); 00561 SDOperand Tmp0(0, 0); 00562 SDOperand Tmp1(0, 0); 00563 SDOperand Tmp2(0, 0); 00564 SDNode *ResNode = NULL; 00565 HasInFlag = (N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag); 00566 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 00567 Select(Tmp0, N1); 00568 Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N2)->getValue()), MVT::i32); 00569 Select(Tmp2, N3); 00570 Select(Chain, Chain); 00571 if (HasInFlag) 00572 Select(InFlag, N.getOperand(N.getNumOperands()-1)); 00573 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 00574 ResNode = HasInFlag ? CurDAG->getTargetNode(Opc0, MVT::Other, Tmp0, Tmp1, Tmp2, Chain, InFlag) : CurDAG->getTargetNode(Opc0, MVT::Other, Tmp0, Tmp1, Tmp2, Chain); 00575 Chain = SDOperand(ResNode, 0); 00576 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 00577 Result = SDOperand(ResNode, N.ResNo); 00578 return; 00579 } 00580 void Select_PPCcondbranch(SDOperand &Result, SDOperand N) { 00581 SDOperand Chain(0, 0); 00582 SDOperand InFlag(0, 0); 00583 SDOperand N1(0, 0); 00584 SDOperand N2(0, 0); 00585 SDOperand N3(0, 0); 00586 SDOperand Tmp0(0, 0); 00587 SDOperand Tmp1(0, 0); 00588 SDOperand Tmp2(0, 0); 00589 SDNode *ResNode = NULL; 00590 bool HasInFlag = false; 00591 Chain = N.getOperand(0); 00592 N1 = N.getOperand(1); 00593 N2 = N.getOperand(2); 00594 if (N2.getOpcode() == ISD::Constant) { 00595 N3 = N.getOperand(3); 00596 if (N3.getOpcode() == ISD::BasicBlock && 00597 N1.Val->getValueType(0) == MVT::i32) { 00598 Emit_3(Result, N, PPC::COND_BRANCH, Chain, N1, N2, N3, HasInFlag); 00599 return; 00600 } 00601 } 00602 std::cerr << "Cannot yet select: "; 00603 N.Val->dump(CurDAG); 00604 std::cerr << '\n'; 00605 abort(); 00606 } 00607 00608 void Emit_4(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0) NOINLINE { 00609 SDOperand Tmp0(0, 0); 00610 SDNode *ResNode = NULL; 00611 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 00612 Select(Tmp0, N0); 00613 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 00614 if (N.Val->hasOneUse()) { 00615 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0); 00616 } else { 00617 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0); 00618 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00619 Result = SDOperand(ResNode, 0); 00620 } 00621 return; 00622 } 00623 void Select_PPCextsw_32(SDOperand &Result, SDOperand N) { 00624 SDOperand N0(0, 0); 00625 SDOperand Tmp0(0, 0); 00626 SDNode *ResNode = NULL; 00627 N0 = N.getOperand(0); 00628 if (N.Val->getValueType(0) == MVT::i32) { 00629 Emit_4(Result, N, PPC::EXTSW_32, MVT::i32, N0); 00630 return; 00631 } 00632 std::cerr << "Cannot yet select: "; 00633 N.Val->dump(CurDAG); 00634 std::cerr << '\n'; 00635 abort(); 00636 } 00637 00638 void Select_PPCfcfid(SDOperand &Result, SDOperand N) { 00639 SDOperand N0(0, 0); 00640 SDOperand Tmp0(0, 0); 00641 SDNode *ResNode = NULL; 00642 N0 = N.getOperand(0); 00643 if (N.Val->getValueType(0) == MVT::f64) { 00644 Emit_4(Result, N, PPC::FCFID, MVT::f64, N0); 00645 return; 00646 } 00647 std::cerr << "Cannot yet select: "; 00648 N.Val->dump(CurDAG); 00649 std::cerr << '\n'; 00650 abort(); 00651 } 00652 00653 void Select_PPCfctidz(SDOperand &Result, SDOperand N) { 00654 SDOperand N0(0, 0); 00655 SDOperand Tmp0(0, 0); 00656 SDNode *ResNode = NULL; 00657 N0 = N.getOperand(0); 00658 if (N.Val->getValueType(0) == MVT::f64) { 00659 Emit_4(Result, N, PPC::FCTIDZ, MVT::f64, N0); 00660 return; 00661 } 00662 std::cerr << "Cannot yet select: "; 00663 N.Val->dump(CurDAG); 00664 std::cerr << '\n'; 00665 abort(); 00666 } 00667 00668 void Select_PPCfctiwz(SDOperand &Result, SDOperand N) { 00669 SDOperand N0(0, 0); 00670 SDOperand Tmp0(0, 0); 00671 SDNode *ResNode = NULL; 00672 N0 = N.getOperand(0); 00673 if (N.Val->getValueType(0) == MVT::f64) { 00674 Emit_4(Result, N, PPC::FCTIWZ, MVT::f64, N0); 00675 return; 00676 } 00677 std::cerr << "Cannot yet select: "; 00678 N.Val->dump(CurDAG); 00679 std::cerr << '\n'; 00680 abort(); 00681 } 00682 00683 void Emit_5(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N2) NOINLINE { 00684 SDOperand Tmp0(0, 0); 00685 SDOperand Tmp1(0, 0); 00686 SDOperand Tmp2(0, 0); 00687 SDNode *ResNode = NULL; 00688 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 00689 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 00690 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N2.Val); 00691 Select(Tmp0, N0); 00692 Select(Tmp1, N1); 00693 Select(Tmp2, N2); 00694 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 00695 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 00696 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N2.Val); 00697 if (N.Val->hasOneUse()) { 00698 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1, Tmp2); 00699 } else { 00700 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1, Tmp2); 00701 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00702 Result = SDOperand(ResNode, 0); 00703 } 00704 return; 00705 } 00706 void Select_PPCfsel(SDOperand &Result, SDOperand N) { 00707 SDOperand N0(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 = NULL; 00714 N0 = N.getOperand(0); 00715 N1 = N.getOperand(1); 00716 N2 = N.getOperand(2); 00717 00718 // Pattern: (PPCfsel:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB) 00719 // Emits: (FSELD:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB) 00720 // Pattern complexity = 2 cost = 1 size = 0 00721 if (N.Val->getValueType(0) == MVT::f64) { 00722 Emit_5(Result, N, PPC::FSELD, MVT::f64, N0, N1, N2); 00723 return; 00724 } 00725 00726 // Pattern: (PPCfsel:f32 F8RC:f64:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB) 00727 // Emits: (FSELS:f32 F8RC:f64:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB) 00728 // Pattern complexity = 2 cost = 1 00729 if (N.Val->getValueType(0) == MVT::f32) { 00730 Emit_5(Result, N, PPC::FSELS, MVT::f32, N0, N1, N2); 00731 return; 00732 } 00733 std::cerr << "Cannot yet select: "; 00734 N.Val->dump(CurDAG); 00735 std::cerr << '\n'; 00736 abort(); 00737 } 00738 00739 void Emit_6(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 00740 SDOperand Tmp1(0, 0); 00741 SDNode *ResNode = NULL; 00742 Select(Tmp1, N0); 00743 if (N.Val->hasOneUse()) { 00744 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1); 00745 } else { 00746 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1); 00747 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00748 Result = SDOperand(ResNode, 0); 00749 } 00750 return; 00751 } 00752 void Emit_7(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 00753 SDOperand Tmp1(0, 0); 00754 SDNode *ResNode = NULL; 00755 Tmp1 = N0; 00756 if (N.Val->hasOneUse()) { 00757 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1); 00758 } else { 00759 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1); 00760 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 00761 Result = SDOperand(ResNode, 0); 00762 } 00763 return; 00764 } 00765 void Select_PPChi(SDOperand &Result, SDOperand N) { 00766 SDOperand N0(0, 0); 00767 SDOperand N1(0, 0); 00768 SDOperand Tmp1(0, 0); 00769 SDNode *ResNode = NULL; 00770 N0 = N.getOperand(0); 00771 00772 // Pattern: (PPChi:i64 (tjumptable:i64):$in, 0:i64) 00773 // Emits: (LIS8:i64 (tjumptable:i64):$in) 00774 // Pattern complexity = 7 cost = 1 size = 0 00775 if (N0.getOpcode() == ISD::TargetJumpTable) { 00776 N1 = N.getOperand(1); 00777 if (isa<ConstantSDNode>(N1)) { 00778 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 00779 if (CN0 == 0 && 00780 N.Val->getValueType(0) == MVT::i64) { 00781 Emit_6(Result, N, PPC::LIS8, MVT::i64, N0, N1); 00782 return; 00783 } 00784 } 00785 } 00786 00787 // Pattern: (PPChi:i32 (tglobaladdr:i32):$in, 0:i32) 00788 // Emits: (LIS:i32 (tglobaladdr:i32):$in) 00789 // Pattern complexity = 7 cost = 1 size = 0 00790 if (N0.getOpcode() == ISD::TargetGlobalAddress) { 00791 N1 = N.getOperand(1); 00792 if (isa<ConstantSDNode>(N1)) { 00793 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 00794 if (CN0 == 0 && 00795 N.Val->getValueType(0) == MVT::i32) { 00796 Emit_7(Result, N, PPC::LIS, MVT::i32, N0, N1); 00797 return; 00798 } 00799 } 00800 } 00801 00802 // Pattern: (PPChi:i32 (tconstpool:i32):$in, 0:i32) 00803 // Emits: (LIS:i32 (tconstpool:i32):$in) 00804 // Pattern complexity = 7 cost = 1 size = 0 00805 if (N0.getOpcode() == ISD::TargetConstantPool) { 00806 N1 = N.getOperand(1); 00807 if (isa<ConstantSDNode>(N1)) { 00808 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 00809 if (CN0 == 0 && 00810 N.Val->getValueType(0) == MVT::i32) { 00811 Emit_7(Result, N, PPC::LIS, MVT::i32, N0, N1); 00812 return; 00813 } 00814 } 00815 } 00816 00817 // Pattern: (PPChi:i32 (tjumptable:i32):$in, 0:i32) 00818 // Emits: (LIS:i32 (tjumptable:i32):$in) 00819 // Pattern complexity = 7 cost = 1 size = 0 00820 if (N0.getOpcode() == ISD::TargetJumpTable) { 00821 N1 = N.getOperand(1); 00822 if (isa<ConstantSDNode>(N1)) { 00823 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 00824 if (CN0 == 0 && 00825 N.Val->getValueType(0) == MVT::i32) { 00826 Emit_6(Result, N, PPC::LIS, MVT::i32, N0, N1); 00827 return; 00828 } 00829 } 00830 } 00831 00832 // Pattern: (PPChi:i64 (tglobaladdr:i64):$in, 0:i64) 00833 // Emits: (LIS8:i64 (tglobaladdr:i64):$in) 00834 // Pattern complexity = 7 cost = 1 size = 0 00835 if (N0.getOpcode() == ISD::TargetGlobalAddress) { 00836 N1 = N.getOperand(1); 00837 if (isa<ConstantSDNode>(N1)) { 00838 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 00839 if (CN0 == 0 && 00840 N.Val->getValueType(0) == MVT::i64) { 00841 Emit_7(Result, N, PPC::LIS8, MVT::i64, N0, N1); 00842 return; 00843 } 00844 } 00845 } 00846 00847 // Pattern: (PPChi:i64 (tconstpool:i64):$in, 0:i64) 00848 // Emits: (LIS8:i64 (tconstpool:i64):$in) 00849 // Pattern complexity = 7 cost = 1 00850 if (N0.getOpcode() == ISD::TargetConstantPool) { 00851 N1 = N.getOperand(1); 00852 if (isa<ConstantSDNode>(N1)) { 00853 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 00854 if (CN0 == 0 && 00855 N.Val->getValueType(0) == MVT::i64) { 00856 Emit_7(Result, N, PPC::LIS8, MVT::i64, N0, N1); 00857 return; 00858 } 00859 } 00860 } 00861 std::cerr << "Cannot yet select: "; 00862 N.Val->dump(CurDAG); 00863 std::cerr << '\n'; 00864 abort(); 00865 } 00866 00867 void Emit_8(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &CPTmp0, SDOperand &CPTmp1, SDOperand &Chain, SDOperand &N1, SDOperand &N2, SDOperand &N3) NOINLINE { 00868 SDOperand Tmp0(0, 0); 00869 SDOperand Tmp1(0, 0); 00870 SDNode *ResNode = NULL; 00871 SelectionDAG::InsertInFlightSetEntry(InFlightSet, CPTmp0.Val); 00872 SelectionDAG::InsertInFlightSetEntry(InFlightSet, CPTmp1.Val); 00873 Select(Tmp0, CPTmp0); 00874 Select(Tmp1, CPTmp1); 00875 Select(Chain, Chain); 00876 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, CPTmp0.Val); 00877 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, CPTmp1.Val); 00878 ResNode = CurDAG->getTargetNode(Opc0, VT0, MVT::Other, Tmp0, Tmp1, Chain); 00879 Chain = SDOperand(ResNode, 1); 00880 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 00881 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Chain.Val, Chain.ResNo); 00882 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, Chain.Val, Chain.ResNo); 00883 Result = SDOperand(ResNode, N.ResNo); 00884 return; 00885 } 00886 void Select_PPClbrx(SDOperand &Result, SDOperand N) { 00887 if (N.ResNo == 1 && N.getValue(0).hasOneUse()) { 00888 SDOperand Dummy = CurDAG->getNode(ISD::HANDLENODE, MVT::Other, N); 00889 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Dummy.Val, 0); 00890 SelectionDAG::InsertISelMapEntry(HandleMap, N.Val, 1, Dummy.Val, 0); 00891 Result = Dummy; 00892 return; 00893 } 00894 SDOperand CPTmp0(0, 0); 00895 SDOperand CPTmp1(0, 0); 00896 SDOperand Chain(0, 0); 00897 SDOperand N1(0, 0); 00898 SDOperand N2(0, 0); 00899 SDOperand N3(0, 0); 00900 SDOperand Tmp0(0, 0); 00901 SDOperand Tmp1(0, 0); 00902 SDNode *ResNode = NULL; 00903 Chain = N.getOperand(0); 00904 N1 = N.getOperand(1); 00905 N2 = N.getOperand(2); 00906 N3 = N.getOperand(3); 00907 00908 // Pattern: (PPClbrx:i32 xoaddr:iPTR:$src, srcvalue:Other:$sv, i16:Other) 00909 // Emits: (LHBRX:i32 xoaddr:iPTR:$src) 00910 // Pattern complexity = 8 cost = 1 size = 0 00911 if (cast<VTSDNode>(N3)->getVT() == MVT::i16) { 00912 bool Match = SelectAddrIdxOnly(N1, CPTmp0, CPTmp1); 00913 if (Match) { 00914 Emit_8(Result, N, PPC::LHBRX, MVT::i32, CPTmp0, CPTmp1, Chain, N1, N2, N3); 00915 return; 00916 } 00917 } 00918 00919 // Pattern: (PPClbrx:i32 xoaddr:iPTR:$src, srcvalue:Other:$sv, i32:Other) 00920 // Emits: (LWBRX:i32 xoaddr:iPTR:$src) 00921 // Pattern complexity = 8 cost = 1 00922 if (cast<VTSDNode>(N3)->getVT() == MVT::i32) { 00923 bool Match = SelectAddrIdxOnly(N1, CPTmp0, CPTmp1); 00924 if (Match) { 00925 Emit_8(Result, N, PPC::LWBRX, MVT::i32, CPTmp0, CPTmp1, Chain, N1, N2, N3); 00926 return; 00927 } 00928 } 00929 std::cerr << "Cannot yet select: "; 00930 N.Val->dump(CurDAG); 00931 std::cerr << '\n'; 00932 abort(); 00933 } 00934 00935 void Select_PPClo(SDOperand &Result, SDOperand N) { 00936 SDOperand N0(0, 0); 00937 SDOperand N1(0, 0); 00938 SDOperand Tmp1(0, 0); 00939 SDNode *ResNode = NULL; 00940 N0 = N.getOperand(0); 00941 00942 // Pattern: (PPClo:i64 (tconstpool:i64):$in, 0:i64) 00943 // Emits: (LI8:i64 (tconstpool:i64):$in) 00944 // Pattern complexity = 7 cost = 1 size = 0 00945 if (N0.getOpcode() == ISD::TargetConstantPool) { 00946 N1 = N.getOperand(1); 00947 if (isa<ConstantSDNode>(N1)) { 00948 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 00949 if (CN0 == 0 && 00950 N.Val->getValueType(0) == MVT::i64) { 00951 Emit_7(Result, N, PPC::LI8, MVT::i64, N0, N1); 00952 return; 00953 } 00954 } 00955 } 00956 00957 // Pattern: (PPClo:i64 (tjumptable:i64):$in, 0:i64) 00958 // Emits: (LI8:i64 (tjumptable:i64):$in) 00959 // Pattern complexity = 7 cost = 1 size = 0 00960 if (N0.getOpcode() == ISD::TargetJumpTable) { 00961 N1 = N.getOperand(1); 00962 if (isa<ConstantSDNode>(N1)) { 00963 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 00964 if (CN0 == 0 && 00965 N.Val->getValueType(0) == MVT::i64) { 00966 Emit_6(Result, N, PPC::LI8, MVT::i64, N0, N1); 00967 return; 00968 } 00969 } 00970 } 00971 00972 // Pattern: (PPClo:i32 (tglobaladdr:i32):$in, 0:i32) 00973 // Emits: (LI:i32 (tglobaladdr:i32):$in) 00974 // Pattern complexity = 7 cost = 1 size = 0 00975 if (N0.getOpcode() == ISD::TargetGlobalAddress) { 00976 N1 = N.getOperand(1); 00977 if (isa<ConstantSDNode>(N1)) { 00978 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 00979 if (CN0 == 0 && 00980 N.Val->getValueType(0) == MVT::i32) { 00981 Emit_7(Result, N, PPC::LI, MVT::i32, N0, N1); 00982 return; 00983 } 00984 } 00985 } 00986 00987 // Pattern: (PPClo:i32 (tconstpool:i32):$in, 0:i32) 00988 // Emits: (LI:i32 (tconstpool:i32):$in) 00989 // Pattern complexity = 7 cost = 1 size = 0 00990 if (N0.getOpcode() == ISD::TargetConstantPool) { 00991 N1 = N.getOperand(1); 00992 if (isa<ConstantSDNode>(N1)) { 00993 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 00994 if (CN0 == 0 && 00995 N.Val->getValueType(0) == MVT::i32) { 00996 Emit_7(Result, N, PPC::LI, MVT::i32, N0, N1); 00997 return; 00998 } 00999 } 01000 } 01001 01002 // Pattern: (PPClo:i32 (tjumptable:i32):$in, 0:i32) 01003 // Emits: (LI:i32 (tjumptable:i32):$in) 01004 // Pattern complexity = 7 cost = 1 size = 0 01005 if (N0.getOpcode() == ISD::TargetJumpTable) { 01006 N1 = N.getOperand(1); 01007 if (isa<ConstantSDNode>(N1)) { 01008 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 01009 if (CN0 == 0 && 01010 N.Val->getValueType(0) == MVT::i32) { 01011 Emit_6(Result, N, PPC::LI, MVT::i32, N0, N1); 01012 return; 01013 } 01014 } 01015 } 01016 01017 // Pattern: (PPClo:i64 (tglobaladdr:i64):$in, 0:i64) 01018 // Emits: (LI8:i64 (tglobaladdr:i64):$in) 01019 // Pattern complexity = 7 cost = 1 01020 if (N0.getOpcode() == ISD::TargetGlobalAddress) { 01021 N1 = N.getOperand(1); 01022 if (isa<ConstantSDNode>(N1)) { 01023 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 01024 if (CN0 == 0 && 01025 N.Val->getValueType(0) == MVT::i64) { 01026 Emit_7(Result, N, PPC::LI8, MVT::i64, N0, N1); 01027 return; 01028 } 01029 } 01030 } 01031 std::cerr << "Cannot yet select: "; 01032 N.Val->dump(CurDAG); 01033 std::cerr << '\n'; 01034 abort(); 01035 } 01036 01037 void Emit_9(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &Chain, SDOperand &N1, bool HasInFlag) NOINLINE { 01038 SDOperand InFlag(0, 0); 01039 SDOperand Tmp0(0, 0); 01040 SDNode *ResNode = NULL; 01041 HasInFlag = (N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag); 01042 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 01043 Select(Tmp0, N1); 01044 Select(Chain, Chain); 01045 if (HasInFlag) 01046 Select(InFlag, N.getOperand(N.getNumOperands()-1)); 01047 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 01048 ResNode = HasInFlag ? CurDAG->getTargetNode(Opc0, MVT::Other, MVT::Flag, Tmp0, Chain, InFlag) : CurDAG->getTargetNode(Opc0, MVT::Other, MVT::Flag, Tmp0, Chain); 01049 Chain = SDOperand(ResNode, 0); 01050 InFlag = SDOperand(ResNode, 1); 01051 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 01052 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01053 Result = SDOperand(ResNode, N.ResNo); 01054 return; 01055 } 01056 void Select_PPCmtctr(SDOperand &Result, SDOperand N) { 01057 SDOperand Chain(0, 0); 01058 SDOperand InFlag(0, 0); 01059 SDOperand N1(0, 0); 01060 SDOperand Tmp0(0, 0); 01061 SDNode *ResNode = NULL; 01062 bool HasInFlag = false; 01063 Chain = N.getOperand(0); 01064 N1 = N.getOperand(1); 01065 01066 // Pattern: (PPCmtctr:void GPRC:i32:$rS) 01067 // Emits: (MTCTR:void GPRC:i32:$rS) 01068 // Pattern complexity = 2 cost = 1 size = 0 01069 if (N1.Val->getValueType(0) == MVT::i32) { 01070 Emit_9(Result, N, PPC::MTCTR, Chain, N1, HasInFlag); 01071 return; 01072 } 01073 01074 // Pattern: (PPCmtctr:void G8RC:i64:$rS) 01075 // Emits: (MTCTR8:void G8RC:i64:$rS) 01076 // Pattern complexity = 2 cost = 1 01077 if (N1.Val->getValueType(0) == MVT::i64) { 01078 Emit_9(Result, N, PPC::MTCTR8, Chain, N1, HasInFlag); 01079 return; 01080 } 01081 std::cerr << "Cannot yet select: "; 01082 N.Val->dump(CurDAG); 01083 std::cerr << '\n'; 01084 abort(); 01085 } 01086 01087 void Emit_10(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 01088 SDOperand Tmp0(0, 0); 01089 SDOperand Tmp1(0, 0); 01090 SDNode *ResNode = NULL; 01091 N0 = N.getOperand(0); 01092 N1 = N.getOperand(1); 01093 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 01094 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 01095 Select(Tmp0, N0); 01096 Select(Tmp1, N1); 01097 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 01098 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 01099 if (N.Val->hasOneUse()) { 01100 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1); 01101 } else { 01102 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1); 01103 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01104 Result = SDOperand(ResNode, 0); 01105 } 01106 return; 01107 } 01108 void Select_PPCshl(SDOperand &Result, SDOperand N) { 01109 SDOperand N0(0, 0); 01110 SDOperand N1(0, 0); 01111 SDOperand Tmp0(0, 0); 01112 SDOperand Tmp1(0, 0); 01113 SDNode *ResNode = NULL; 01114 Emit_10(Result, N, PPC::SLW, MVT::i32, N0, N1); 01115 return; 01116 } 01117 01118 void Select_PPCsra(SDOperand &Result, SDOperand N) { 01119 SDOperand N0(0, 0); 01120 SDOperand N1(0, 0); 01121 SDOperand Tmp0(0, 0); 01122 SDOperand Tmp1(0, 0); 01123 SDNode *ResNode = NULL; 01124 Emit_10(Result, N, PPC::SRAW, MVT::i32, N0, N1); 01125 return; 01126 } 01127 01128 void Select_PPCsrl(SDOperand &Result, SDOperand N) { 01129 SDOperand N0(0, 0); 01130 SDOperand N1(0, 0); 01131 SDOperand Tmp0(0, 0); 01132 SDOperand Tmp1(0, 0); 01133 SDNode *ResNode = NULL; 01134 Emit_10(Result, N, PPC::SRW, MVT::i32, N0, N1); 01135 return; 01136 } 01137 01138 void Emit_11(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &CPTmp0, SDOperand &CPTmp1, SDOperand &Chain, SDOperand &N1, SDOperand &N2, SDOperand &N3, SDOperand &N4) NOINLINE { 01139 SDOperand Tmp0(0, 0); 01140 SDOperand Tmp1(0, 0); 01141 SDOperand Tmp2(0, 0); 01142 SDNode *ResNode = NULL; 01143 SelectionDAG::InsertInFlightSetEntry(InFlightSet, CPTmp0.Val); 01144 SelectionDAG::InsertInFlightSetEntry(InFlightSet, CPTmp1.Val); 01145 Select(Tmp0, CPTmp0); 01146 Select(Tmp1, CPTmp1); 01147 Select(Tmp2, N1); 01148 Select(Chain, Chain); 01149 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 01150 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, CPTmp0.Val); 01151 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, CPTmp1.Val); 01152 ResNode = CurDAG->getTargetNode(Opc0, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 01153 Chain = SDOperand(ResNode, 0); 01154 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 01155 Result = SDOperand(ResNode, N.ResNo); 01156 return; 01157 } 01158 void Select_PPCstbrx(SDOperand &Result, SDOperand N) { 01159 SDOperand CPTmp0(0, 0); 01160 SDOperand CPTmp1(0, 0); 01161 SDOperand Chain(0, 0); 01162 SDOperand N1(0, 0); 01163 SDOperand N2(0, 0); 01164 SDOperand N3(0, 0); 01165 SDOperand N4(0, 0); 01166 SDOperand Tmp0(0, 0); 01167 SDOperand Tmp1(0, 0); 01168 SDOperand Tmp2(0, 0); 01169 SDNode *ResNode = NULL; 01170 Chain = N.getOperand(0); 01171 N1 = N.getOperand(1); 01172 N2 = N.getOperand(2); 01173 N3 = N.getOperand(3); 01174 N4 = N.getOperand(4); 01175 01176 // Pattern: (PPCstbrx:void GPRC:i32:$rS, xoaddr:iPTR:$dst, srcvalue:Other:$dummy, i16:Other) 01177 // Emits: (STHBRX:void GPRC:i32:$rS, xoaddr:iPTR:$dst) 01178 // Pattern complexity = 8 cost = 1 size = 0 01179 if (cast<VTSDNode>(N4)->getVT() == MVT::i16) { 01180 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 01181 bool Match = SelectAddrIdxOnly(N2, CPTmp0, CPTmp1); 01182 if (!Match) { 01183 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 01184 } 01185 if (Match) { 01186 Emit_11(Result, N, PPC::STHBRX, CPTmp0, CPTmp1, Chain, N1, N2, N3, N4); 01187 return; 01188 } 01189 } 01190 01191 // Pattern: (PPCstbrx:void GPRC:i32:$rS, xoaddr:iPTR:$dst, srcvalue:Other:$dummy, i32:Other) 01192 // Emits: (STWBRX:void GPRC:i32:$rS, xoaddr:iPTR:$dst) 01193 // Pattern complexity = 8 cost = 1 01194 if (cast<VTSDNode>(N4)->getVT() == MVT::i32) { 01195 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 01196 bool Match = SelectAddrIdxOnly(N2, CPTmp0, CPTmp1); 01197 if (!Match) { 01198 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 01199 } 01200 if (Match) { 01201 Emit_11(Result, N, PPC::STWBRX, CPTmp0, CPTmp1, Chain, N1, N2, N3, N4); 01202 return; 01203 } 01204 } 01205 std::cerr << "Cannot yet select: "; 01206 N.Val->dump(CurDAG); 01207 std::cerr << '\n'; 01208 abort(); 01209 } 01210 01211 void Emit_12(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &CPTmp0, SDOperand &CPTmp1, SDOperand &Chain, SDOperand &N1, SDOperand &N2) NOINLINE { 01212 SDOperand Tmp0(0, 0); 01213 SDOperand Tmp1(0, 0); 01214 SDOperand Tmp2(0, 0); 01215 SDNode *ResNode = NULL; 01216 SelectionDAG::InsertInFlightSetEntry(InFlightSet, CPTmp0.Val); 01217 SelectionDAG::InsertInFlightSetEntry(InFlightSet, CPTmp1.Val); 01218 Select(Tmp0, CPTmp0); 01219 Select(Tmp1, CPTmp1); 01220 Select(Tmp2, N1); 01221 Select(Chain, Chain); 01222 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 01223 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, CPTmp0.Val); 01224 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, CPTmp1.Val); 01225 ResNode = CurDAG->getTargetNode(Opc0, MVT::Other, Tmp2, Tmp0, Tmp1, Chain); 01226 Chain = SDOperand(ResNode, 0); 01227 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 01228 Result = SDOperand(ResNode, N.ResNo); 01229 return; 01230 } 01231 void Select_PPCstd_32(SDOperand &Result, SDOperand N) { 01232 SDOperand CPTmp0(0, 0); 01233 SDOperand CPTmp1(0, 0); 01234 SDOperand Chain(0, 0); 01235 SDOperand N1(0, 0); 01236 SDOperand N2(0, 0); 01237 SDOperand Tmp0(0, 0); 01238 SDOperand Tmp1(0, 0); 01239 SDOperand Tmp2(0, 0); 01240 SDNode *ResNode = NULL; 01241 Chain = N.getOperand(0); 01242 N1 = N.getOperand(1); 01243 N2 = N.getOperand(2); 01244 if (N1.Val->getValueType(0) == MVT::i32) { 01245 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 01246 01247 // Pattern: (PPCstd_32:void GPRC:i32:$rT, ixaddr:iPTR:$dst) 01248 // Emits: (STD_32:void GPRC:i32:$rT, ixaddr:iPTR:$dst) 01249 // Pattern complexity = 8 cost = 1 size = 0 01250 { 01251 bool Match = SelectAddrImmShift(N2, CPTmp0, CPTmp1); 01252 if (!Match) { 01253 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 01254 } 01255 if (Match) { 01256 Emit_12(Result, N, PPC::STD_32, CPTmp0, CPTmp1, Chain, N1, N2); 01257 return; 01258 } 01259 } 01260 01261 // Pattern: (PPCstd_32:void GPRC:i32:$rT, xaddr:iPTR:$dst) 01262 // Emits: (STDX_32:void GPRC:i32:$rT, xaddr:iPTR:$dst) 01263 // Pattern complexity = 8 cost = 1 01264 bool Match = SelectAddrIdx(N2, CPTmp0, CPTmp1); 01265 if (!Match) { 01266 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 01267 } 01268 if (Match) { 01269 Emit_12(Result, N, PPC::STDX_32, CPTmp0, CPTmp1, Chain, N1, N2); 01270 return; 01271 } 01272 } 01273 std::cerr << "Cannot yet select: "; 01274 N.Val->dump(CurDAG); 01275 std::cerr << '\n'; 01276 abort(); 01277 } 01278 01279 void Select_PPCstfiwx(SDOperand &Result, SDOperand N) { 01280 SDOperand CPTmp0(0, 0); 01281 SDOperand CPTmp1(0, 0); 01282 SDOperand Chain(0, 0); 01283 SDOperand N1(0, 0); 01284 SDOperand N2(0, 0); 01285 SDOperand Tmp0(0, 0); 01286 SDOperand Tmp1(0, 0); 01287 SDOperand Tmp2(0, 0); 01288 SDNode *ResNode = NULL; 01289 Chain = N.getOperand(0); 01290 N1 = N.getOperand(1); 01291 N2 = N.getOperand(2); 01292 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 01293 bool Match = SelectAddrIdxOnly(N2, CPTmp0, CPTmp1); 01294 if (!Match) { 01295 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 01296 } 01297 if (Match) { 01298 Emit_12(Result, N, PPC::STFIWX, CPTmp0, CPTmp1, Chain, N1, N2); 01299 return; 01300 } 01301 std::cerr << "Cannot yet select: "; 01302 N.Val->dump(CurDAG); 01303 std::cerr << '\n'; 01304 abort(); 01305 } 01306 01307 void Emit_13(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N2) NOINLINE { 01308 SDOperand Tmp1(0, 0); 01309 SDOperand Tmp2(0, 0); 01310 SDNode *ResNode = NULL; 01311 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 01312 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 01313 Select(Tmp1, N0); 01314 Select(Tmp2, N1); 01315 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 01316 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 01317 if (N.Val->hasOneUse()) { 01318 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1, Tmp2); 01319 } else { 01320 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1, Tmp2); 01321 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01322 Result = SDOperand(ResNode, 0); 01323 } 01324 return; 01325 } 01326 void Select_PPCvcmp(SDOperand &Result, SDOperand N) { 01327 SDOperand N0(0, 0); 01328 SDOperand N1(0, 0); 01329 SDOperand N2(0, 0); 01330 SDOperand Tmp1(0, 0); 01331 SDOperand Tmp2(0, 0); 01332 SDNode *ResNode = NULL; 01333 N0 = N.getOperand(0); 01334 N1 = N.getOperand(1); 01335 N2 = N.getOperand(2); 01336 if (isa<ConstantSDNode>(N2)) { 01337 int64_t CN0 = cast<ConstantSDNode>(N2)->getSignExtended(); 01338 01339 // Pattern: (PPCvcmp:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 966:i32) 01340 // Emits: (VCMPBFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 01341 // Pattern complexity = 5 cost = 1 size = 0 01342 if (CN0 == 966 && 01343 N.Val->getValueType(0) == MVT::v4f32) { 01344 Emit_13(Result, N, PPC::VCMPBFP, MVT::v4f32, N0, N1, N2); 01345 return; 01346 } 01347 01348 // Pattern: (PPCvcmp:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 198:i32) 01349 // Emits: (VCMPEQFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 01350 // Pattern complexity = 5 cost = 1 size = 0 01351 if (CN0 == 198 && 01352 N.Val->getValueType(0) == MVT::v4f32) { 01353 Emit_13(Result, N, PPC::VCMPEQFP, MVT::v4f32, N0, N1, N2); 01354 return; 01355 } 01356 01357 // Pattern: (PPCvcmp:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 454:i32) 01358 // Emits: (VCMPGEFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 01359 // Pattern complexity = 5 cost = 1 size = 0 01360 if (CN0 == 454 && 01361 N.Val->getValueType(0) == MVT::v4f32) { 01362 Emit_13(Result, N, PPC::VCMPGEFP, MVT::v4f32, N0, N1, N2); 01363 return; 01364 } 01365 01366 // Pattern: (PPCvcmp:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 710:i32) 01367 // Emits: (VCMPGTFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 01368 // Pattern complexity = 5 cost = 1 size = 0 01369 if (CN0 == 710 && 01370 N.Val->getValueType(0) == MVT::v4f32) { 01371 Emit_13(Result, N, PPC::VCMPGTFP, MVT::v4f32, N0, N1, N2); 01372 return; 01373 } 01374 01375 // Pattern: (PPCvcmp:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, 6:i32) 01376 // Emits: (VCMPEQUB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 01377 // Pattern complexity = 5 cost = 1 size = 0 01378 if (CN0 == 6 && 01379 N.Val->getValueType(0) == MVT::v16i8) { 01380 Emit_13(Result, N, PPC::VCMPEQUB, MVT::v16i8, N0, N1, N2); 01381 return; 01382 } 01383 01384 // Pattern: (PPCvcmp:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, 774:i32) 01385 // Emits: (VCMPGTSB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 01386 // Pattern complexity = 5 cost = 1 size = 0 01387 if (CN0 == 774 && 01388 N.Val->getValueType(0) == MVT::v16i8) { 01389 Emit_13(Result, N, PPC::VCMPGTSB, MVT::v16i8, N0, N1, N2); 01390 return; 01391 } 01392 01393 // Pattern: (PPCvcmp:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, 518:i32) 01394 // Emits: (VCMPGTUB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 01395 // Pattern complexity = 5 cost = 1 size = 0 01396 if (CN0 == 518 && 01397 N.Val->getValueType(0) == MVT::v16i8) { 01398 Emit_13(Result, N, PPC::VCMPGTUB, MVT::v16i8, N0, N1, N2); 01399 return; 01400 } 01401 01402 // Pattern: (PPCvcmp:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, 70:i32) 01403 // Emits: (VCMPEQUH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 01404 // Pattern complexity = 5 cost = 1 size = 0 01405 if (CN0 == 70 && 01406 N.Val->getValueType(0) == MVT::v8i16) { 01407 Emit_13(Result, N, PPC::VCMPEQUH, MVT::v8i16, N0, N1, N2); 01408 return; 01409 } 01410 01411 // Pattern: (PPCvcmp:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, 838:i32) 01412 // Emits: (VCMPGTSH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 01413 // Pattern complexity = 5 cost = 1 size = 0 01414 if (CN0 == 838 && 01415 N.Val->getValueType(0) == MVT::v8i16) { 01416 Emit_13(Result, N, PPC::VCMPGTSH, MVT::v8i16, N0, N1, N2); 01417 return; 01418 } 01419 01420 // Pattern: (PPCvcmp:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, 582:i32) 01421 // Emits: (VCMPGTUH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 01422 // Pattern complexity = 5 cost = 1 size = 0 01423 if (CN0 == 582 && 01424 N.Val->getValueType(0) == MVT::v8i16) { 01425 Emit_13(Result, N, PPC::VCMPGTUH, MVT::v8i16, N0, N1, N2); 01426 return; 01427 } 01428 01429 // Pattern: (PPCvcmp:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, 134:i32) 01430 // Emits: (VCMPEQUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 01431 // Pattern complexity = 5 cost = 1 size = 0 01432 if (CN0 == 134 && 01433 N.Val->getValueType(0) == MVT::v4i32) { 01434 Emit_13(Result, N, PPC::VCMPEQUW, MVT::v4i32, N0, N1, N2); 01435 return; 01436 } 01437 01438 // Pattern: (PPCvcmp:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, 902:i32) 01439 // Emits: (VCMPGTSW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 01440 // Pattern complexity = 5 cost = 1 size = 0 01441 if (CN0 == 902 && 01442 N.Val->getValueType(0) == MVT::v4i32) { 01443 Emit_13(Result, N, PPC::VCMPGTSW, MVT::v4i32, N0, N1, N2); 01444 return; 01445 } 01446 01447 // Pattern: (PPCvcmp:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, 646:i32) 01448 // Emits: (VCMPGTUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 01449 // Pattern complexity = 5 cost = 1 01450 if (CN0 == 646 && 01451 N.Val->getValueType(0) == MVT::v4i32) { 01452 Emit_13(Result, N, PPC::VCMPGTUW, MVT::v4i32, N0, N1, N2); 01453 return; 01454 } 01455 } 01456 std::cerr << "Cannot yet select: "; 01457 N.Val->dump(CurDAG); 01458 std::cerr << '\n'; 01459 abort(); 01460 } 01461 01462 void Emit_14(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N2) NOINLINE { 01463 SDOperand InFlag(0, 0); 01464 SDOperand Tmp1(0, 0); 01465 SDOperand Tmp2(0, 0); 01466 SDNode *ResNode = NULL; 01467 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 01468 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 01469 Select(Tmp1, N0); 01470 Select(Tmp2, N1); 01471 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 01472 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 01473 ResNode = CurDAG->getTargetNode(Opc0, VT0, MVT::Flag, Tmp1, Tmp2); 01474 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 01475 InFlag = SDOperand(ResNode, 1); 01476 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 01477 Result = SDOperand(ResNode, N.ResNo); 01478 return; 01479 } 01480 void Select_PPCvcmp_o(SDOperand &Result, SDOperand N) { 01481 SDOperand InFlag(0, 0); 01482 SDOperand N0(0, 0); 01483 SDOperand N1(0, 0); 01484 SDOperand N2(0, 0); 01485 SDOperand Tmp1(0, 0); 01486 SDOperand Tmp2(0, 0); 01487 SDNode *ResNode = NULL; 01488 N0 = N.getOperand(0); 01489 N1 = N.getOperand(1); 01490 N2 = N.getOperand(2); 01491 if (isa<ConstantSDNode>(N2)) { 01492 int64_t CN0 = cast<ConstantSDNode>(N2)->getSignExtended(); 01493 01494 // Pattern: (PPCvcmp_o:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 966:i32) 01495 // Emits: (VCMPBFPo:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 01496 // Pattern complexity = 5 cost = 1 size = 0 01497 if (CN0 == 966 && 01498 N.Val->getValueType(0) == MVT::v4f32) { 01499 Emit_14(Result, N, PPC::VCMPBFPo, MVT::v4f32, N0, N1, N2); 01500 return; 01501 } 01502 01503 // Pattern: (PPCvcmp_o:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 198:i32) 01504 // Emits: (VCMPEQFPo:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 01505 // Pattern complexity = 5 cost = 1 size = 0 01506 if (CN0 == 198 && 01507 N.Val->getValueType(0) == MVT::v4f32) { 01508 Emit_14(Result, N, PPC::VCMPEQFPo, MVT::v4f32, N0, N1, N2); 01509 return; 01510 } 01511 01512 // Pattern: (PPCvcmp_o:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 454:i32) 01513 // Emits: (VCMPGEFPo:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 01514 // Pattern complexity = 5 cost = 1 size = 0 01515 if (CN0 == 454 && 01516 N.Val->getValueType(0) == MVT::v4f32) { 01517 Emit_14(Result, N, PPC::VCMPGEFPo, MVT::v4f32, N0, N1, N2); 01518 return; 01519 } 01520 01521 // Pattern: (PPCvcmp_o:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 710:i32) 01522 // Emits: (VCMPGTFPo:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 01523 // Pattern complexity = 5 cost = 1 size = 0 01524 if (CN0 == 710 && 01525 N.Val->getValueType(0) == MVT::v4f32) { 01526 Emit_14(Result, N, PPC::VCMPGTFPo, MVT::v4f32, N0, N1, N2); 01527 return; 01528 } 01529 01530 // Pattern: (PPCvcmp_o:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, 6:i32) 01531 // Emits: (VCMPEQUBo:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 01532 // Pattern complexity = 5 cost = 1 size = 0 01533 if (CN0 == 6 && 01534 N.Val->getValueType(0) == MVT::v16i8) { 01535 Emit_14(Result, N, PPC::VCMPEQUBo, MVT::v16i8, N0, N1, N2); 01536 return; 01537 } 01538 01539 // Pattern: (PPCvcmp_o:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, 774:i32) 01540 // Emits: (VCMPGTSBo:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 01541 // Pattern complexity = 5 cost = 1 size = 0 01542 if (CN0 == 774 && 01543 N.Val->getValueType(0) == MVT::v16i8) { 01544 Emit_14(Result, N, PPC::VCMPGTSBo, MVT::v16i8, N0, N1, N2); 01545 return; 01546 } 01547 01548 // Pattern: (PPCvcmp_o:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, 518:i32) 01549 // Emits: (VCMPGTUBo:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 01550 // Pattern complexity = 5 cost = 1 size = 0 01551 if (CN0 == 518 && 01552 N.Val->getValueType(0) == MVT::v16i8) { 01553 Emit_14(Result, N, PPC::VCMPGTUBo, MVT::v16i8, N0, N1, N2); 01554 return; 01555 } 01556 01557 // Pattern: (PPCvcmp_o:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, 70:i32) 01558 // Emits: (VCMPEQUHo:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 01559 // Pattern complexity = 5 cost = 1 size = 0 01560 if (CN0 == 70 && 01561 N.Val->getValueType(0) == MVT::v8i16) { 01562 Emit_14(Result, N, PPC::VCMPEQUHo, MVT::v8i16, N0, N1, N2); 01563 return; 01564 } 01565 01566 // Pattern: (PPCvcmp_o:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, 838:i32) 01567 // Emits: (VCMPGTSHo:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 01568 // Pattern complexity = 5 cost = 1 size = 0 01569 if (CN0 == 838 && 01570 N.Val->getValueType(0) == MVT::v8i16) { 01571 Emit_14(Result, N, PPC::VCMPGTSHo, MVT::v8i16, N0, N1, N2); 01572 return; 01573 } 01574 01575 // Pattern: (PPCvcmp_o:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, 582:i32) 01576 // Emits: (VCMPGTUHo:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 01577 // Pattern complexity = 5 cost = 1 size = 0 01578 if (CN0 == 582 && 01579 N.Val->getValueType(0) == MVT::v8i16) { 01580 Emit_14(Result, N, PPC::VCMPGTUHo, MVT::v8i16, N0, N1, N2); 01581 return; 01582 } 01583 01584 // Pattern: (PPCvcmp_o:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, 134:i32) 01585 // Emits: (VCMPEQUWo:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 01586 // Pattern complexity = 5 cost = 1 size = 0 01587 if (CN0 == 134 && 01588 N.Val->getValueType(0) == MVT::v4i32) { 01589 Emit_14(Result, N, PPC::VCMPEQUWo, MVT::v4i32, N0, N1, N2); 01590 return; 01591 } 01592 01593 // Pattern: (PPCvcmp_o:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, 902:i32) 01594 // Emits: (VCMPGTSWo:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 01595 // Pattern complexity = 5 cost = 1 size = 0 01596 if (CN0 == 902 && 01597 N.Val->getValueType(0) == MVT::v4i32) { 01598 Emit_14(Result, N, PPC::VCMPGTSWo, MVT::v4i32, N0, N1, N2); 01599 return; 01600 } 01601 01602 // Pattern: (PPCvcmp_o:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, 646:i32) 01603 // Emits: (VCMPGTUWo:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 01604 // Pattern complexity = 5 cost = 1 01605 if (CN0 == 646 && 01606 N.Val->getValueType(0) == MVT::v4i32) { 01607 Emit_14(Result, N, PPC::VCMPGTUWo, MVT::v4i32, N0, N1, N2); 01608 return; 01609 } 01610 } 01611 std::cerr << "Cannot yet select: "; 01612 N.Val->dump(CurDAG); 01613 std::cerr << '\n'; 01614 abort(); 01615 } 01616 01617 void Select_PPCvmaddfp(SDOperand &Result, SDOperand N) { 01618 SDOperand N0(0, 0); 01619 SDOperand N1(0, 0); 01620 SDOperand N2(0, 0); 01621 SDOperand Tmp0(0, 0); 01622 SDOperand Tmp1(0, 0); 01623 SDOperand Tmp2(0, 0); 01624 SDNode *ResNode = NULL; 01625 N0 = N.getOperand(0); 01626 N1 = N.getOperand(1); 01627 N2 = N.getOperand(2); 01628 if (N.Val->getValueType(0) == MVT::v4f32) { 01629 Emit_5(Result, N, PPC::VMADDFP, MVT::v4f32, N0, N1, N2); 01630 return; 01631 } 01632 std::cerr << "Cannot yet select: "; 01633 N.Val->dump(CurDAG); 01634 std::cerr << '\n'; 01635 abort(); 01636 } 01637 01638 void Select_PPCvnmsubfp(SDOperand &Result, SDOperand N) { 01639 SDOperand N0(0, 0); 01640 SDOperand N1(0, 0); 01641 SDOperand N2(0, 0); 01642 SDOperand Tmp0(0, 0); 01643 SDOperand Tmp1(0, 0); 01644 SDOperand Tmp2(0, 0); 01645 SDNode *ResNode = NULL; 01646 N0 = N.getOperand(0); 01647 N1 = N.getOperand(1); 01648 N2 = N.getOperand(2); 01649 if (N.Val->getValueType(0) == MVT::v4f32) { 01650 Emit_5(Result, N, PPC::VNMSUBFP, MVT::v4f32, N0, N1, N2); 01651 return; 01652 } 01653 std::cerr << "Cannot yet select: "; 01654 N.Val->dump(CurDAG); 01655 std::cerr << '\n'; 01656 abort(); 01657 } 01658 01659 void Select_PPCvperm(SDOperand &Result, SDOperand N) { 01660 SDOperand N0(0, 0); 01661 SDOperand N1(0, 0); 01662 SDOperand N2(0, 0); 01663 SDOperand Tmp0(0, 0); 01664 SDOperand Tmp1(0, 0); 01665 SDOperand Tmp2(0, 0); 01666 SDNode *ResNode = NULL; 01667 N0 = N.getOperand(0); 01668 N1 = N.getOperand(1); 01669 N2 = N.getOperand(2); 01670 if (N.Val->getValueType(0) == MVT::v16i8) { 01671 Emit_5(Result, N, PPC::VPERM, MVT::v16i8, N0, N1, N2); 01672 return; 01673 } 01674 std::cerr << "Cannot yet select: "; 01675 N.Val->dump(CurDAG); 01676 std::cerr << '\n'; 01677 abort(); 01678 } 01679 01680 void Emit_15(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N10, SDOperand &N11) NOINLINE { 01681 SDOperand Tmp1(0, 0); 01682 SDOperand Tmp2(0, 0); 01683 SDNode *ResNode = NULL; 01684 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 01685 Select(Tmp1, N0); 01686 Tmp2 = N10; 01687 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 01688 if (N.Val->hasOneUse()) { 01689 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1, Tmp2); 01690 } else { 01691 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1, Tmp2); 01692 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01693 Result = SDOperand(ResNode, 0); 01694 } 01695 return; 01696 } 01697 void Emit_16(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N10, SDOperand &N11) NOINLINE { 01698 SDOperand Tmp1(0, 0); 01699 SDOperand Tmp2(0, 0); 01700 SDNode *ResNode = NULL; 01701 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 01702 Select(Tmp1, N0); 01703 Select(Tmp2, N10); 01704 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 01705 if (N.Val->hasOneUse()) { 01706 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1, Tmp2); 01707 } else { 01708 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1, Tmp2); 01709 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01710 Result = SDOperand(ResNode, 0); 01711 } 01712 return; 01713 } 01714 void Emit_17(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N00, SDOperand &N01, SDOperand &N1) NOINLINE { 01715 SDOperand Tmp1(0, 0); 01716 SDOperand Tmp2(0, 0); 01717 SDNode *ResNode = NULL; 01718 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 01719 Select(Tmp1, N1); 01720 Tmp2 = N00; 01721 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 01722 if (N.Val->hasOneUse()) { 01723 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1, Tmp2); 01724 } else { 01725 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1, Tmp2); 01726 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01727 Result = SDOperand(ResNode, 0); 01728 } 01729 return; 01730 } 01731 void Emit_18(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N00, SDOperand &N01, SDOperand &N1) NOINLINE { 01732 SDOperand Tmp1(0, 0); 01733 SDOperand Tmp2(0, 0); 01734 SDNode *ResNode = NULL; 01735 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 01736 Select(Tmp1, N1); 01737 Select(Tmp2, N00); 01738 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 01739 if (N.Val->hasOneUse()) { 01740 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1, Tmp2); 01741 } else { 01742 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1, Tmp2); 01743 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01744 Result = SDOperand(ResNode, 0); 01745 } 01746 return; 01747 } 01748 void Emit_19(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 01749 SDOperand Tmp0(0, 0); 01750 SDOperand Tmp1(0, 0); 01751 SDNode *ResNode = NULL; 01752 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 01753 Select(Tmp0, N0); 01754 Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getValue()), MVT::i32); 01755 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 01756 if (N.Val->hasOneUse()) { 01757 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1); 01758 } else { 01759 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1); 01760 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01761 Result = SDOperand(ResNode, 0); 01762 } 01763 return; 01764 } 01765 void Emit_20(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 01766 SDOperand Tmp0(0, 0); 01767 SDOperand Tmp1(0, 0); 01768 SDOperand Tmp2(0, 0); 01769 SDNode *ResNode = NULL; 01770 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 01771 Select(Tmp0, N0); 01772 Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getValue()), MVT::i32); 01773 Tmp2 = Transform_HI16(Tmp1.Val); 01774 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 01775 if (N.Val->hasOneUse()) { 01776 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp2); 01777 } else { 01778 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp2); 01779 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01780 Result = SDOperand(ResNode, 0); 01781 } 01782 return; 01783 } 01784 void Emit_21(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 01785 SDOperand Tmp0(0, 0); 01786 SDOperand Tmp1(0, 0); 01787 SDNode *ResNode = NULL; 01788 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 01789 Select(Tmp0, N0); 01790 Tmp1 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N1)->getValue()), MVT::i64); 01791 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 01792 if (N.Val->hasOneUse()) { 01793 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1); 01794 } else { 01795 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1); 01796 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01797 Result = SDOperand(ResNode, 0); 01798 } 01799 return; 01800 } 01801 void Emit_22(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 01802 SDOperand Tmp0(0, 0); 01803 SDOperand Tmp1(0, 0); 01804 SDOperand Tmp2(0, 0); 01805 SDNode *ResNode = NULL; 01806 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 01807 Select(Tmp0, N0); 01808 Tmp1 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N1)->getValue()), MVT::i64); 01809 Tmp2 = Transform_HI16(Tmp1.Val); 01810 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 01811 if (N.Val->hasOneUse()) { 01812 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp2); 01813 } else { 01814 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp2); 01815 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01816 Result = SDOperand(ResNode, 0); 01817 } 01818 return; 01819 } 01820 void Emit_23(SDOperand &Result, SDOperand &N, unsigned Opc0, unsigned Opc1, MVT::ValueType VT0, MVT::ValueType VT1, SDOperand &N0, SDOperand &N1) NOINLINE { 01821 SDOperand Tmp0(0, 0); 01822 SDOperand Tmp1(0, 0); 01823 SDOperand Tmp2(0, 0); 01824 SDOperand Tmp3(0, 0); 01825 SDOperand Tmp4(0, 0); 01826 SDNode *ResNode = NULL; 01827 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 01828 Select(Tmp0, N0); 01829 Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getValue()), MVT::i32); 01830 Tmp2 = Transform_LO16(Tmp1.Val); 01831 Tmp3 = SDOperand(CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp2), 0); 01832 Tmp4 = Transform_HA16(Tmp1.Val); 01833 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 01834 if (N.Val->hasOneUse()) { 01835 Result = CurDAG->SelectNodeTo(N.Val, Opc1, VT1, Tmp3, Tmp4); 01836 } else { 01837 ResNode = CurDAG->getTargetNode(Opc1, VT1, Tmp3, Tmp4); 01838 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01839 Result = SDOperand(ResNode, 0); 01840 } 01841 return; 01842 } 01843 void Emit_24(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 01844 SDOperand Tmp0(0, 0); 01845 SDOperand Tmp1(0, 0); 01846 SDNode *ResNode = NULL; 01847 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 01848 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 01849 Select(Tmp0, N0); 01850 Select(Tmp1, N1); 01851 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 01852 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 01853 if (N.Val->hasOneUse()) { 01854 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1); 01855 } else { 01856 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1); 01857 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 01858 Result = SDOperand(ResNode, 0); 01859 } 01860 return; 01861 } 01862 void Select_add(SDOperand &Result, SDOperand N) { 01863 SDOperand N0(0, 0); 01864 SDOperand N00(0, 0); 01865 SDOperand N01(0, 0); 01866 SDOperand N1(0, 0); 01867 SDOperand N10(0, 0); 01868 SDOperand N11(0, 0); 01869 SDOperand Tmp0(0, 0); 01870 SDOperand Tmp1(0, 0); 01871 SDOperand Tmp2(0, 0); 01872 SDOperand Tmp3(0, 0); 01873 SDOperand Tmp4(0, 0); 01874 SDNode *ResNode = NULL; 01875 N0 = N.getOperand(0); 01876 { 01877 N1 = N.getOperand(1); 01878 01879 // Pattern: (add:i32 GPRC:i32:$rA, (PPClo:i32 (tglobaladdr:i32):$sym, 0:i32)) 01880 // Emits: (LA:i32 GPRC:i32:$rA, (tglobaladdr:i32):$sym) 01881 // Pattern complexity = 9 cost = 1 size = 0 01882 if (N1.getOpcode() == PPCISD::Lo) { 01883 N10 = N1.getOperand(0); 01884 if (N10.getOpcode() == ISD::TargetGlobalAddress) { 01885 N11 = N1.getOperand(1); 01886 if (isa<ConstantSDNode>(N11)) { 01887 int64_t CN0 = cast<ConstantSDNode>(N11)->getSignExtended(); 01888 if (CN0 == 0 && 01889 N.Val->getValueType(0) == MVT::i32) { 01890 Emit_15(Result, N, PPC::LA, MVT::i32, N0, N1, N10, N11); 01891 return; 01892 } 01893 } 01894 } 01895 } 01896 if (N1.getOpcode() == PPCISD::Hi) { 01897 N10 = N1.getOperand(0); 01898 01899 // Pattern: (add:i64 G8RC:i64:$in, (PPChi:i64 (tglobaladdr:i64):$g, 0:i64)) 01900 // Emits: (ADDIS8:i64 G8RC:i64:$in, (tglobaladdr:i64):$g) 01901 // Pattern complexity = 9 cost = 1 size = 0 01902 if (N10.getOpcode() == ISD::TargetGlobalAddress) { 01903 N11 = N1.getOperand(1); 01904 if (isa<ConstantSDNode>(N11)) { 01905 int64_t CN0 = cast<ConstantSDNode>(N11)->getSignExtended(); 01906 if (CN0 == 0 && 01907 N.Val->getValueType(0) == MVT::i64) { 01908 Emit_15(Result, N, PPC::ADDIS8, MVT::i64, N0, N1, N10, N11); 01909 return; 01910 } 01911 } 01912 } 01913 01914 // Pattern: (add:i64 G8RC:i64:$in, (PPChi:i64 (tconstpool:i64):$g, 0:i64)) 01915 // Emits: (ADDIS8:i64 G8RC:i64:$in, (tconstpool:i64):$g) 01916 // Pattern complexity = 9 cost = 1 size = 0 01917 if (N10.getOpcode() == ISD::TargetConstantPool) { 01918 N11 = N1.getOperand(1); 01919 if (isa<ConstantSDNode>(N11)) { 01920 int64_t CN0 = cast<ConstantSDNode>(N11)->getSignExtended(); 01921 if (CN0 == 0 && 01922 N.Val->getValueType(0) == MVT::i64) { 01923 Emit_15(Result, N, PPC::ADDIS8, MVT::i64, N0, N1, N10, N11); 01924 return; 01925 } 01926 } 01927 } 01928 01929 // Pattern: (add:i64 G8RC:i64:$in, (PPChi:i64 (tjumptable:i64):$g, 0:i64)) 01930 // Emits: (ADDIS8:i64 G8RC:i64:$in, (tjumptable:i64):$g) 01931 // Pattern complexity = 9 cost = 1 size = 0 01932 if (N10.getOpcode() == ISD::TargetJumpTable) { 01933 N11 = N1.getOperand(1); 01934 if (isa<ConstantSDNode>(N11)) { 01935 int64_t CN0 = cast<ConstantSDNode>(N11)->getSignExtended(); 01936 if (CN0 == 0 && 01937 N.Val->getValueType(0) == MVT::i64) { 01938 Emit_16(Result, N, PPC::ADDIS8, MVT::i64, N0, N1, N10, N11); 01939 return; 01940 } 01941 } 01942 } 01943 01944 // Pattern: (add:i32 GPRC:i32:$in, (PPChi:i32 (tglobaladdr:i32):$g, 0:i32)) 01945 // Emits: (ADDIS:i32 GPRC:i32:$in, (tglobaladdr:i32):$g) 01946 // Pattern complexity = 9 cost = 1 size = 0 01947 if (N10.getOpcode() == ISD::TargetGlobalAddress) { 01948 N11 = N1.getOperand(1); 01949 if (isa<ConstantSDNode>(N11)) { 01950 int64_t CN0 = cast<ConstantSDNode>(N11)->getSignExtended(); 01951 if (CN0 == 0 && 01952 N.Val->getValueType(0) == MVT::i32) { 01953 Emit_15(Result, N, PPC::ADDIS, MVT::i32, N0, N1, N10, N11); 01954 return; 01955 } 01956 } 01957 } 01958 01959 // Pattern: (add:i32 GPRC:i32:$in, (PPChi:i32 (tconstpool:i32):$g, 0:i32)) 01960 // Emits: (ADDIS:i32 GPRC:i32:$in, (tconstpool:i32):$g) 01961 // Pattern complexity = 9 cost = 1 size = 0 01962 if (N10.getOpcode() == ISD::TargetConstantPool) { 01963 N11 = N1.getOperand(1); 01964 if (isa<ConstantSDNode>(N11)) { 01965 int64_t CN0 = cast<ConstantSDNode>(N11)->getSignExtended(); 01966 if (CN0 == 0 && 01967 N.Val->getValueType(0) == MVT::i32) { 01968 Emit_15(Result, N, PPC::ADDIS, MVT::i32, N0, N1, N10, N11); 01969 return; 01970 } 01971 } 01972 } 01973 01974 // Pattern: (add:i32 GPRC:i32:$in, (PPChi:i32 (tjumptable:i32):$g, 0:i32)) 01975 // Emits: (ADDIS:i32 GPRC:i32:$in, (tjumptable:i32):$g) 01976 // Pattern complexity = 9 cost = 1 01977 if (N10.getOpcode() == ISD::TargetJumpTable) { 01978 N11 = N1.getOperand(1); 01979 if (isa<ConstantSDNode>(N11)) { 01980 int64_t CN0 = cast<ConstantSDNode>(N11)->getSignExtended(); 01981 if (CN0 == 0 && 01982 N.Val->getValueType(0) == MVT::i32) { 01983 Emit_16(Result, N, PPC::ADDIS, MVT::i32, N0, N1, N10, N11); 01984 return; 01985 } 01986 } 01987 } 01988 } 01989 } 01990 01991 // Pattern: (add:i32 (PPClo:i32 (tglobaladdr:i32):$sym, 0:i32), GPRC:i32:$rA) 01992 // Emits: (LA:i32 GPRC:i32:$rA, (tglobaladdr:i32):$sym) 01993 // Pattern complexity = 9 cost = 1 size = 0 01994 if (N0.getOpcode() == PPCISD::Lo) { 01995 N00 = N0.getOperand(0); 01996 if (N00.getOpcode() == ISD::TargetGlobalAddress) { 01997 N01 = N0.getOperand(1); 01998 if (isa<ConstantSDNode>(N01)) { 01999 int64_t CN0 = cast<ConstantSDNode>(N01)->getSignExtended(); 02000 if (CN0 == 0) { 02001 N1 = N.getOperand(1); 02002 if (N.Val->getValueType(0) == MVT::i32) { 02003 Emit_17(Result, N, PPC::LA, MVT::i32, N0, N00, N01, N1); 02004 return; 02005 } 02006 } 02007 } 02008 } 02009 } 02010 if (N0.getOpcode() == PPCISD::Hi) { 02011 N00 = N0.getOperand(0); 02012 02013 // Pattern: (add:i64 (PPChi:i64 (tglobaladdr:i64):$g, 0:i64), G8RC:i64:$in) 02014 // Emits: (ADDIS8:i64 G8RC:i64:$in, (tglobaladdr:i64):$g) 02015 // Pattern complexity = 9 cost = 1 size = 0 02016 if (N00.getOpcode() == ISD::TargetGlobalAddress) { 02017 N01 = N0.getOperand(1); 02018 if (isa<ConstantSDNode>(N01)) { 02019 int64_t CN0 = cast<ConstantSDNode>(N01)->getSignExtended(); 02020 if (CN0 == 0) { 02021 N1 = N.getOperand(1); 02022 if (N.Val->getValueType(0) == MVT::i64) { 02023 Emit_17(Result, N, PPC::ADDIS8, MVT::i64, N0, N00, N01, N1); 02024 return; 02025 } 02026 } 02027 } 02028 } 02029 02030 // Pattern: (add:i64 (PPChi:i64 (tconstpool:i64):$g, 0:i64), G8RC:i64:$in) 02031 // Emits: (ADDIS8:i64 G8RC:i64:$in, (tconstpool:i64):$g) 02032 // Pattern complexity = 9 cost = 1 size = 0 02033 if (N00.getOpcode() == ISD::TargetConstantPool) { 02034 N01 = N0.getOperand(1); 02035 if (isa<ConstantSDNode>(N01)) { 02036 int64_t CN0 = cast<ConstantSDNode>(N01)->getSignExtended(); 02037 if (CN0 == 0) { 02038 N1 = N.getOperand(1); 02039 if (N.Val->getValueType(0) == MVT::i64) { 02040 Emit_17(Result, N, PPC::ADDIS8, MVT::i64, N0, N00, N01, N1); 02041 return; 02042 } 02043 } 02044 } 02045 } 02046 02047 // Pattern: (add:i64 (PPChi:i64 (tjumptable:i64):$g, 0:i64), G8RC:i64:$in) 02048 // Emits: (ADDIS8:i64 G8RC:i64:$in, (tjumptable:i64):$g) 02049 // Pattern complexity = 9 cost = 1 size = 0 02050 if (N00.getOpcode() == ISD::TargetJumpTable) { 02051 N01 = N0.getOperand(1); 02052 if (isa<ConstantSDNode>(N01)) { 02053 int64_t CN0 = cast<ConstantSDNode>(N01)->getSignExtended(); 02054 if (CN0 == 0) { 02055 N1 = N.getOperand(1); 02056 if (N.Val->getValueType(0) == MVT::i64) { 02057 Emit_18(Result, N, PPC::ADDIS8, MVT::i64, N0, N00, N01, N1); 02058 return; 02059 } 02060 } 02061 } 02062 } 02063 02064 // Pattern: (add:i32 (PPChi:i32 (tglobaladdr:i32):$g, 0:i32), GPRC:i32:$in) 02065 // Emits: (ADDIS:i32 GPRC:i32:$in, (tglobaladdr:i32):$g) 02066 // Pattern complexity = 9 cost = 1 size = 0 02067 if (N00.getOpcode() == ISD::TargetGlobalAddress) { 02068 N01 = N0.getOperand(1); 02069 if (isa<ConstantSDNode>(N01)) { 02070 int64_t CN0 = cast<ConstantSDNode>(N01)->getSignExtended(); 02071 if (CN0 == 0) { 02072 N1 = N.getOperand(1); 02073 if (N.Val->getValueType(0) == MVT::i32) { 02074 Emit_17(Result, N, PPC::ADDIS, MVT::i32, N0, N00, N01, N1); 02075 return; 02076 } 02077 } 02078 } 02079 } 02080 02081 // Pattern: (add:i32 (PPChi:i32 (tconstpool:i32):$g, 0:i32), GPRC:i32:$in) 02082 // Emits: (ADDIS:i32 GPRC:i32:$in, (tconstpool:i32):$g) 02083 // Pattern complexity = 9 cost = 1 size = 0 02084 if (N00.getOpcode() == ISD::TargetConstantPool) { 02085 N01 = N0.getOperand(1); 02086 if (isa<ConstantSDNode>(N01)) { 02087 int64_t CN0 = cast<ConstantSDNode>(N01)->getSignExtended(); 02088 if (CN0 == 0) { 02089 N1 = N.getOperand(1); 02090 if (N.Val->getValueType(0) == MVT::i32) { 02091 Emit_17(Result, N, PPC::ADDIS, MVT::i32, N0, N00, N01, N1); 02092 return; 02093 } 02094 } 02095 } 02096 } 02097 02098 // Pattern: (add:i32 (PPChi:i32 (tjumptable:i32):$g, 0:i32), GPRC:i32:$in) 02099 // Emits: (ADDIS:i32 GPRC:i32:$in, (tjumptable:i32):$g) 02100 // Pattern complexity = 9 cost = 1 02101 if (N00.getOpcode() == ISD::TargetJumpTable) { 02102 N01 = N0.getOperand(1); 02103 if (isa<ConstantSDNode>(N01)) { 02104 int64_t CN0 = cast<ConstantSDNode>(N01)->getSignExtended(); 02105 if (CN0 == 0) { 02106 N1 = N.getOperand(1); 02107 if (N.Val->getValueType(0) == MVT::i32) { 02108 Emit_18(Result, N, PPC::ADDIS, MVT::i32, N0, N00, N01, N1); 02109 return; 02110 } 02111 } 02112 } 02113 } 02114 } 02115 N1 = N.getOperand(1); 02116 if (N1.getOpcode() == ISD::Constant) { 02117 02118 // Pattern: (add:i32 GPRC:i32:$rA, (imm:i32)<<P:Predicate_immSExt16>>:$imm) 02119 // Emits: (ADDI:i32 GPRC:i32:$rA, (imm:i32):$imm) 02120 // Pattern complexity = 5 cost = 1 size = 0 02121 if (Predicate_immSExt16(N1.Val) && 02122 N.Val->getValueType(0) == MVT::i32) { 02123 Emit_19(Result, N, PPC::ADDI, MVT::i32, N0, N1); 02124 return; 02125 } 02126 02127 // Pattern: (add:i32 GPRC:i32:$rA, (imm:i32)<<P:Predicate_imm16ShiftedSExt>><<X:HI16>>:$imm) 02128 // Emits: (ADDIS:i32 GPRC:i32:$rA, (HI16:i32 (imm:i32):$imm)) 02129 // Pattern complexity = 5 cost = 1 size = 0 02130 if (Predicate_imm16ShiftedSExt(N1.Val) && 02131 N.Val->getValueType(0) == MVT::i32) { 02132 Emit_20(Result, N, PPC::ADDIS, MVT::i32, N0, N1); 02133 return; 02134 } 02135 02136 // Pattern: (add:i64 G8RC:i64:$rA, (imm:i64)<<P:Predicate_immSExt16>>:$imm) 02137 // Emits: (ADDI8:i64 G8RC:i64:$rA, (imm:i64):$imm) 02138 // Pattern complexity = 5 cost = 1 size = 0 02139 if (Predicate_immSExt16(N1.Val) && 02140 N.Val->getValueType(0) == MVT::i64) { 02141 Emit_21(Result, N, PPC::ADDI8, MVT::i64, N0, N1); 02142 return; 02143 } 02144 02145 // Pattern: (add:i64 G8RC:i64:$rA, (imm:i64)<<P:Predicate_imm16ShiftedSExt>><<X:HI16>>:$imm) 02146 // Emits: (ADDIS8:i64 G8RC:i64:$rA, (HI16:i64 (imm:i64):$imm)) 02147 // Pattern complexity = 5 cost = 1 size = 0 02148 if (Predicate_imm16ShiftedSExt(N1.Val) && 02149 N.Val->getValueType(0) == MVT::i64) { 02150 Emit_22(Result, N, PPC::ADDIS8, MVT::i64, N0, N1); 02151 return; 02152 } 02153 02154 // Pattern: (add:i32 GPRC:i32:$in, (imm:i32):$imm) 02155 // Emits: (ADDIS:i32 (ADDI:i32 GPRC:i32:$in, (LO16:i32 (imm:i32):$imm)), (HA16:i32 (imm:i32):$imm)) 02156 // Pattern complexity = 4 cost = 2 02157 if (N.Val->getValueType(0) == MVT::i32) { 02158 Emit_23(Result, N, PPC::ADDI, PPC::ADDIS, MVT::i32, MVT::i32, N0, N1); 02159 return; 02160 } 02161 } 02162 02163 // Pattern: (add:i32 GPRC:i32:$rA, GPRC:i32:$rB) 02164 // Emits: (ADD4:i32 GPRC:i32:$rA, GPRC:i32:$rB) 02165 // Pattern complexity = 2 cost = 1 size = 0 02166 if (N.Val->getValueType(0) == MVT::i32) { 02167 Emit_24(Result, N, PPC::ADD4, MVT::i32, N0, N1); 02168 return; 02169 } 02170 02171 // Pattern: (add:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 02172 // Emits: (VADDUBM:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 02173 // Pattern complexity = 2 cost = 1 size = 0 02174 if (N.Val->getValueType(0) == MVT::v16i8) { 02175 Emit_24(Result, N, PPC::VADDUBM, MVT::v16i8, N0, N1); 02176 return; 02177 } 02178 02179 // Pattern: (add:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 02180 // Emits: (VADDUHM:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 02181 // Pattern complexity = 2 cost = 1 size = 0 02182 if (N.Val->getValueType(0) == MVT::v8i16) { 02183 Emit_24(Result, N, PPC::VADDUHM, MVT::v8i16, N0, N1); 02184 return; 02185 } 02186 02187 // Pattern: (add:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 02188 // Emits: (VADDUWM:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 02189 // Pattern complexity = 2 cost = 1 size = 0 02190 if (N.Val->getValueType(0) == MVT::v4i32) { 02191 Emit_24(Result, N, PPC::VADDUWM, MVT::v4i32, N0, N1); 02192 return; 02193 } 02194 02195 // Pattern: (add:i64 G8RC:i64:$rA, G8RC:i64:$rB) 02196 // Emits: (ADD8:i64 G8RC:i64:$rA, G8RC:i64:$rB) 02197 // Pattern complexity = 2 cost = 1 02198 if (N.Val->getValueType(0) == MVT::i64) { 02199 Emit_24(Result, N, PPC::ADD8, MVT::i64, N0, N1); 02200 return; 02201 } 02202 std::cerr << "Cannot yet select: "; 02203 N.Val->dump(CurDAG); 02204 std::cerr << '\n'; 02205 abort(); 02206 } 02207 02208 void Emit_25(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 02209 SDOperand InFlag(0, 0); 02210 SDOperand Tmp0(0, 0); 02211 SDOperand Tmp1(0, 0); 02212 SDNode *ResNode = NULL; 02213 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 02214 Select(Tmp0, N0); 02215 Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getValue()), MVT::i32); 02216 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 02217 ResNode = CurDAG->getTargetNode(Opc0, VT0, MVT::Flag, Tmp0, Tmp1); 02218 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02219 InFlag = SDOperand(ResNode, 1); 02220 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 02221 Result = SDOperand(ResNode, N.ResNo); 02222 return; 02223 } 02224 void Emit_26(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 02225 SDOperand InFlag(0, 0); 02226 SDOperand Tmp0(0, 0); 02227 SDOperand Tmp1(0, 0); 02228 SDNode *ResNode = NULL; 02229 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 02230 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 02231 Select(Tmp0, N0); 02232 Select(Tmp1, N1); 02233 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 02234 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 02235 ResNode = CurDAG->getTargetNode(Opc0, VT0, MVT::Flag, Tmp0, Tmp1); 02236 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02237 InFlag = SDOperand(ResNode, 1); 02238 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 02239 Result = SDOperand(ResNode, N.ResNo); 02240 return; 02241 } 02242 void Select_addc(SDOperand &Result, SDOperand N) { 02243 SDOperand InFlag(0, 0); 02244 SDOperand N0(0, 0); 02245 SDOperand N1(0, 0); 02246 SDOperand Tmp0(0, 0); 02247 SDOperand Tmp1(0, 0); 02248 SDNode *ResNode = NULL; 02249 N0 = N.getOperand(0); 02250 N1 = N.getOperand(1); 02251 02252 // Pattern: (addc:i32 GPRC:i32:$rA, (imm:i32)<<P:Predicate_immSExt16>>:$imm) 02253 // Emits: (ADDIC:i32 GPRC:i32:$rA, (imm:i32):$imm) 02254 // Pattern complexity = 5 cost = 1 size = 0 02255 if (N1.getOpcode() == ISD::Constant && 02256 Predicate_immSExt16(N1.Val) && 02257 N.Val->getValueType(0) == MVT::i32) { 02258 Emit_25(Result, N, PPC::ADDIC, MVT::i32, N0, N1); 02259 return; 02260 } 02261 02262 // Pattern: (addc:i32 GPRC:i32:$rA, GPRC:i32:$rB) 02263 // Emits: (ADDC:i32 GPRC:i32:$rA, GPRC:i32:$rB) 02264 // Pattern complexity = 2 cost = 1 02265 if (N.Val->getValueType(0) == MVT::i32) { 02266 Emit_26(Result, N, PPC::ADDC, MVT::i32, N0, N1); 02267 return; 02268 } 02269 std::cerr << "Cannot yet select: "; 02270 N.Val->dump(CurDAG); 02271 std::cerr << '\n'; 02272 abort(); 02273 } 02274 02275 void Emit_27(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 02276 SDOperand InFlag(0, 0); 02277 SDOperand Tmp0(0, 0); 02278 SDNode *ResNode = NULL; 02279 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 02280 Select(Tmp0, N0); 02281 Select(InFlag, N.getOperand(2)); 02282 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 02283 ResNode = CurDAG->getTargetNode(Opc0, VT0, MVT::Flag, Tmp0, InFlag); 02284 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02285 InFlag = SDOperand(ResNode, 1); 02286 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 02287 Result = SDOperand(ResNode, N.ResNo); 02288 return; 02289 } 02290 void Emit_28(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 02291 SDOperand InFlag(0, 0); 02292 SDOperand Tmp1(0, 0); 02293 SDNode *ResNode = NULL; 02294 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 02295 Select(Tmp1, N0); 02296 Select(InFlag, N.getOperand(2)); 02297 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 02298 ResNode = CurDAG->getTargetNode(Opc0, VT0, MVT::Flag, Tmp1, InFlag); 02299 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02300 InFlag = SDOperand(ResNode, 1); 02301 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 02302 Result = SDOperand(ResNode, N.ResNo); 02303 return; 02304 } 02305 void Emit_29(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 02306 SDOperand InFlag(0, 0); 02307 SDOperand Tmp1(0, 0); 02308 SDNode *ResNode = NULL; 02309 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 02310 Select(Tmp1, N1); 02311 Select(InFlag, N.getOperand(2)); 02312 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 02313 ResNode = CurDAG->getTargetNode(Opc0, VT0, MVT::Flag, Tmp1, InFlag); 02314 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02315 InFlag = SDOperand(ResNode, 1); 02316 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 02317 Result = SDOperand(ResNode, N.ResNo); 02318 return; 02319 } 02320 void Emit_30(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 02321 SDOperand InFlag(0, 0); 02322 SDOperand Tmp0(0, 0); 02323 SDOperand Tmp1(0, 0); 02324 SDNode *ResNode = NULL; 02325 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 02326 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 02327 Select(Tmp0, N0); 02328 Select(Tmp1, N1); 02329 Select(InFlag, N.getOperand(2)); 02330 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 02331 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 02332 ResNode = CurDAG->getTargetNode(Opc0, VT0, MVT::Flag, Tmp0, Tmp1, InFlag); 02333 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 02334 InFlag = SDOperand(ResNode, 1); 02335 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 02336 Result = SDOperand(ResNode, N.ResNo); 02337 return; 02338 } 02339 void Select_adde(SDOperand &Result, SDOperand N) { 02340 SDOperand InFlag(0, 0); 02341 SDOperand N0(0, 0); 02342 SDOperand N1(0, 0); 02343 SDOperand Tmp0(0, 0); 02344 SDOperand Tmp1(0, 0); 02345 SDNode *ResNode = NULL; 02346 N0 = N.getOperand(0); 02347 { 02348 N1 = N.getOperand(1); 02349 02350 // Pattern: (adde:i32 GPRC:i32:$rA, (imm:i32)<<P:Predicate_immAllOnes>>) 02351 // Emits: (ADDME:i32 GPRC:i32:$rA) 02352 // Pattern complexity = 5 cost = 1 size = 0 02353 if (N1.getOpcode() == ISD::Constant && 02354 Predicate_immAllOnes(N1.Val) && 02355 N.Val->getValueType(0) == MVT::i32) { 02356 Emit_27(Result, N, PPC::ADDME, MVT::i32, N0, N1); 02357 return; 02358 } 02359 02360 // Pattern: (adde:i32 GPRC:i32:$rA, 0:i32) 02361 // Emits: (ADDZE:i32 GPRC:i32:$rA) 02362 // Pattern complexity = 5 cost = 1 02363 if (isa<ConstantSDNode>(N1)) { 02364 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 02365 if (CN0 == 0 && 02366 N.Val->getValueType(0) == MVT::i32) { 02367 Emit_28(Result, N, PPC::ADDZE, MVT::i32, N0, N1); 02368 return; 02369 } 02370 } 02371 } 02372 02373 // Pattern: (adde:i32 0:i32, GPRC:i32:$rA) 02374 // Emits: (ADDZE:i32 GPRC:i32:$rA) 02375 // Pattern complexity = 5 cost = 1 size = 0 02376 if (isa<ConstantSDNode>(N0)) { 02377 int64_t CN0 = cast<ConstantSDNode>(N0)->getSignExtended(); 02378 if (CN0 == 0) { 02379 N1 = N.getOperand(1); 02380 if (N.Val->getValueType(0) == MVT::i32) { 02381 Emit_29(Result, N, PPC::ADDZE, MVT::i32, N0, N1); 02382 return; 02383 } 02384 } 02385 } 02386 02387 // Pattern: (adde:i32 GPRC:i32:$rA, GPRC:i32:$rB) 02388 // Emits: (ADDE:i32 GPRC:i32:$rA, GPRC:i32:$rB) 02389 // Pattern complexity = 2 cost = 1 02390 N1 = N.getOperand(1); 02391 if (N.Val->getValueType(0) == MVT::i32) { 02392 Emit_30(Result, N, PPC::ADDE, MVT::i32, N0, N1); 02393 return; 02394 } 02395 std::cerr << "Cannot yet select: "; 02396 N.Val->dump(CurDAG); 02397 std::cerr << '\n'; 02398 abort(); 02399 } 02400 02401 void Emit_31(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N10, SDOperand &N11) NOINLINE { 02402 SDOperand Tmp0(0, 0); 02403 SDOperand Tmp1(0, 0); 02404 SDNode *ResNode = NULL; 02405 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 02406 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N10.Val); 02407 Select(Tmp0, N0); 02408 Select(Tmp1, N10); 02409 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 02410 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N10.Val); 02411 if (N.Val->hasOneUse()) { 02412 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1); 02413 } else { 02414 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1); 02415 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02416 Result = SDOperand(ResNode, 0); 02417 } 02418 return; 02419 } 02420 void Emit_32(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N00, SDOperand &N01, SDOperand &N1) NOINLINE { 02421 SDOperand Tmp0(0, 0); 02422 SDOperand Tmp1(0, 0); 02423 SDNode *ResNode = NULL; 02424 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 02425 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N00.Val); 02426 Select(Tmp0, N1); 02427 Select(Tmp1, N00); 02428 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 02429 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N00.Val); 02430 if (N.Val->hasOneUse()) { 02431 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1); 02432 } else { 02433 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1); 02434 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02435 Result = SDOperand(ResNode, 0); 02436 } 02437 return; 02438 } 02439 void Emit_33(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N10, SDOperand &N11) NOINLINE { 02440 SDOperand Tmp0(0, 0); 02441 SDOperand Tmp1(0, 0); 02442 SDNode *ResNode = NULL; 02443 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 02444 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N11.Val); 02445 Select(Tmp0, N0); 02446 Select(Tmp1, N11); 02447 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 02448 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N11.Val); 02449 if (N.Val->hasOneUse()) { 02450 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1); 02451 } else { 02452 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1); 02453 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02454 Result = SDOperand(ResNode, 0); 02455 } 02456 return; 02457 } 02458 void Emit_34(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N00, SDOperand &N01, SDOperand &N1) NOINLINE { 02459 SDOperand Tmp0(0, 0); 02460 SDOperand Tmp1(0, 0); 02461 SDNode *ResNode = NULL; 02462 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 02463 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N01.Val); 02464 Select(Tmp0, N1); 02465 Select(Tmp1, N01); 02466 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 02467 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N01.Val); 02468 if (N.Val->hasOneUse()) { 02469 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1); 02470 } else { 02471 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1); 02472 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02473 Result = SDOperand(ResNode, 0); 02474 } 02475 return; 02476 } 02477 void Emit_35(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 02478 SDOperand Tmp0(0, 0); 02479 SDOperand Tmp1(0, 0); 02480 SDOperand Tmp2(0, 0); 02481 SDNode *ResNode = NULL; 02482 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 02483 Select(Tmp0, N0); 02484 Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getValue()), MVT::i32); 02485 Tmp2 = Transform_LO16(Tmp1.Val); 02486 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 02487 if (N.Val->hasOneUse()) { 02488 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp2); 02489 } else { 02490 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp2); 02491 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02492 Result = SDOperand(ResNode, 0); 02493 } 02494 return; 02495 } 02496 void Emit_36(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 02497 SDOperand Tmp0(0, 0); 02498 SDOperand Tmp1(0, 0); 02499 SDOperand Tmp2(0, 0); 02500 SDNode *ResNode = NULL; 02501 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 02502 Select(Tmp0, N0); 02503 Tmp1 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N1)->getValue()), MVT::i64); 02504 Tmp2 = Transform_LO16(Tmp1.Val); 02505 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 02506 if (N.Val->hasOneUse()) { 02507 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp2); 02508 } else { 02509 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp2); 02510 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02511 Result = SDOperand(ResNode, 0); 02512 } 02513 return; 02514 } 02515 void Select_and(SDOperand &Result, SDOperand N) { 02516 SDOperand N0(0, 0); 02517 SDOperand N00(0, 0); 02518 SDOperand N01(0, 0); 02519 SDOperand N1(0, 0); 02520 SDOperand N10(0, 0); 02521 SDOperand N11(0, 0); 02522 SDOperand Tmp0(0, 0); 02523 SDOperand Tmp1(0, 0); 02524 SDOperand Tmp2(0, 0); 02525 SDNode *ResNode = NULL; 02526 N0 = N.getOperand(0); 02527 { 02528 N1 = N.getOperand(1); 02529 if (N1.getOpcode() == ISD::XOR) { 02530 N10 = N1.getOperand(0); 02531 N11 = N1.getOperand(1); 02532 02533 // Pattern: (and:i32 GPRC:i32:$rS, (xor:i32 GPRC:i32:$rB, (imm:i32)<<P:Predicate_immAllOnes>>)) 02534 // Emits: (ANDC:i32 GPRC:i32:$rS, GPRC:i32:$rB) 02535 // Pattern complexity = 7 cost = 1 size = 0 02536 if (N11.getOpcode() == ISD::Constant && 02537 Predicate_immAllOnes(N11.Val) && 02538 N.Val->getValueType(0) == MVT::i32) { 02539 Emit_31(Result, N, PPC::ANDC, MVT::i32, N0, N1, N10, N11); 02540 return; 02541 } 02542 02543 // Pattern: (and:v4i32 VRRC:v4i32:$vA, (xor:v4i32 VRRC:v4i32:$vB, (build_vector:v4i32)<<P:Predicate_immAllOnesV>>)) 02544 // Emits: (VANDC:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 02545 // Pattern complexity = 7 cost = 1 size = 0 02546 if (N11.getOpcode() == ISD::BUILD_VECTOR && 02547 Predicate_immAllOnesV(N11.Val) && 02548 N.Val->getValueType(0) == MVT::v4i32) { 02549 Emit_31(Result, N, PPC::VANDC, MVT::v4i32, N0, N1, N10, N11); 02550 return; 02551 } 02552 02553 // Pattern: (and:i64 G8RC:i64:$rS, (xor:i64 G8RC:i64:$rB, (imm:i64)<<P:Predicate_immAllOnes>>)) 02554 // Emits: (ANDC8:i64 G8RC:i64:$rS, G8RC:i64:$rB) 02555 // Pattern complexity = 7 cost = 1 size = 0 02556 if (N11.getOpcode() == ISD::Constant && 02557 Predicate_immAllOnes(N11.Val) && 02558 N.Val->getValueType(0) == MVT::i64) { 02559 Emit_31(Result, N, PPC::ANDC8, MVT::i64, N0, N1, N10, N11); 02560 return; 02561 } 02562 02563 // Pattern: (and:v4i32 VRRC:v4i32:$A, (xor:v4i32 VRRC:v4i32:$B, (bitconvert:v4i32)<<P:Predicate_immAllOnesV_bc>>)) 02564 // Emits: (VANDC:v4i32 VRRC:v16i8:$A, VRRC:v16i8:$B) 02565 // Pattern complexity = 7 cost = 1 02566 if (N11.getOpcode() == ISD::BIT_CONVERT && 02567 Predicate_immAllOnesV_bc(N11.Val) && 02568 N.Val->getValueType(0) == MVT::v4i32) { 02569 Emit_31(Result, N, PPC::VANDC, MVT::v4i32, N0, N1, N10, N11); 02570 return; 02571 } 02572 } 02573 } 02574 02575 // Pattern: (and:i32 (xor:i32 GPRC:i32:$rB, (imm:i32)<<P:Predicate_immAllOnes>>), GPRC:i32:$rS) 02576 // Emits: (ANDC:i32 GPRC:i32:$rS, GPRC:i32:$rB) 02577 // Pattern complexity = 7 cost = 1 size = 0 02578 if (N0.getOpcode() == ISD::XOR) { 02579 N00 = N0.getOperand(0); 02580 N01 = N0.getOperand(1); 02581 if (N01.getOpcode() == ISD::Constant && 02582 Predicate_immAllOnes(N01.Val)) { 02583 N1 = N.getOperand(1); 02584 if (N.Val->getValueType(0) == MVT::i32) { 02585 Emit_32(Result, N, PPC::ANDC, MVT::i32, N0, N00, N01, N1); 02586 return; 02587 } 02588 } 02589 } 02590 02591 // Pattern: (and:v4i32 VRRC:v4i32:$vA, (xor:v4i32 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>, VRRC:v4i32:$vB)) 02592 // Emits: (VANDC:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 02593 // Pattern complexity = 7 cost = 1 size = 0 02594 { 02595 N1 = N.getOperand(1); 02596 if (N1.getOpcode() == ISD::XOR) { 02597 N10 = N1.getOperand(0); 02598 if (N10.getOpcode() == ISD::BUILD_VECTOR && 02599 Predicate_immAllOnesV(N10.Val)) { 02600 N11 = N1.getOperand(1); 02601 if (N.Val->getValueType(0) == MVT::v4i32) { 02602 Emit_33(Result, N, PPC::VANDC, MVT::v4i32, N0, N1, N10, N11); 02603 return; 02604 } 02605 } 02606 } 02607 } 02608 if (N0.getOpcode() == ISD::XOR) { 02609 N00 = N0.getOperand(0); 02610 02611 // Pattern: (and:v4i32 (xor:v4i32 VRRC:v4i32:$vB, (build_vector:v4i32)<<P:Predicate_immAllOnesV>>), VRRC:v4i32:$vA) 02612 // Emits: (VANDC:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 02613 // Pattern complexity = 7 cost = 1 size = 0 02614 { 02615 N01 = N0.getOperand(1); 02616 if (N01.getOpcode() == ISD::BUILD_VECTOR && 02617 Predicate_immAllOnesV(N01.Val)) { 02618 N1 = N.getOperand(1); 02619 if (N.Val->getValueType(0) == MVT::v4i32) { 02620 Emit_32(Result, N, PPC::VANDC, MVT::v4i32, N0, N00, N01, N1); 02621 return; 02622 } 02623 } 02624 } 02625 02626 // Pattern: (and:v4i32 (xor:v4i32 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>, VRRC:v4i32:$vB), VRRC:v4i32:$vA) 02627 // Emits: (VANDC:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 02628 // Pattern complexity = 7 cost = 1 size = 0 02629 if (N00.getOpcode() == ISD::BUILD_VECTOR && 02630 Predicate_immAllOnesV(N00.Val)) { 02631 N01 = N0.getOperand(1); 02632 N1 = N.getOperand(1); 02633 if (N.Val->getValueType(0) == MVT::v4i32) { 02634 Emit_34(Result, N, PPC::VANDC, MVT::v4i32, N0, N00, N01, N1); 02635 return; 02636 } 02637 } 02638 02639 // Pattern: (and:i64 (xor:i64 G8RC:i64:$rB, (imm:i64)<<P:Predicate_immAllOnes>>), G8RC:i64:$rS) 02640 // Emits: (ANDC8:i64 G8RC:i64:$rS, G8RC:i64:$rB) 02641 // Pattern complexity = 7 cost = 1 02642 N01 = N0.getOperand(1); 02643 if (N01.getOpcode() == ISD::Constant && 02644 Predicate_immAllOnes(N01.Val)) { 02645 N1 = N.getOperand(1); 02646 if (N.Val->getValueType(0) == MVT::i64) { 02647 Emit_32(Result, N, PPC::ANDC8, MVT::i64, N0, N00, N01, N1); 02648 return; 02649 } 02650 } 02651 } 02652 02653 // Pattern: (and:v4i32 VRRC:v4i32:$A, (xor:v4i32 (bitconvert:v4i32)<<P:Predicate_immAllOnesV_bc>>, VRRC:v4i32:$B)) 02654 // Emits: (VANDC:v4i32 VRRC:v16i8:$A, VRRC:v16i8:$B) 02655 // Pattern complexity = 7 cost = 1 size = 0 02656 { 02657 N1 = N.getOperand(1); 02658 if (N1.getOpcode() == ISD::XOR) { 02659 N10 = N1.getOperand(0); 02660 if (N10.getOpcode() == ISD::BIT_CONVERT && 02661 Predicate_immAllOnesV_bc(N10.Val)) { 02662 N11 = N1.getOperand(1); 02663 if (N.Val->getValueType(0) == MVT::v4i32) { 02664 Emit_33(Result, N, PPC::VANDC, MVT::v4i32, N0, N1, N10, N11); 02665 return; 02666 } 02667 } 02668 } 02669 } 02670 if (N0.getOpcode() == ISD::XOR) { 02671 N00 = N0.getOperand(0); 02672 02673 // Pattern: (and:v4i32 (xor:v4i32 VRRC:v4i32:$B, (bitconvert:v4i32)<<P:Predicate_immAllOnesV_bc>>), VRRC:v4i32:$A) 02674 // Emits: (VANDC:v4i32 VRRC:v16i8:$A, VRRC:v16i8:$B) 02675 // Pattern complexity = 7 cost = 1 size = 0 02676 { 02677 N01 = N0.getOperand(1); 02678 if (N01.getOpcode() == ISD::BIT_CONVERT && 02679 Predicate_immAllOnesV_bc(N01.Val)) { 02680 N1 = N.getOperand(1); 02681 if (N.Val->getValueType(0) == MVT::v4i32) { 02682 Emit_32(Result, N, PPC::VANDC, MVT::v4i32, N0, N00, N01, N1); 02683 return; 02684 } 02685 } 02686 } 02687 02688 // Pattern: (and:v4i32 (xor:v4i32 (bitconvert:v4i32)<<P:Predicate_immAllOnesV_bc>>, VRRC:v4i32:$B), VRRC:v4i32:$A) 02689 // Emits: (VANDC:v4i32 VRRC:v16i8:$A, VRRC:v16i8:$B) 02690 // Pattern complexity = 7 cost = 1 02691 if (N00.getOpcode() == ISD::BIT_CONVERT && 02692 Predicate_immAllOnesV_bc(N00.Val)) { 02693 N01 = N0.getOperand(1); 02694 N1 = N.getOperand(1); 02695 if (N.Val->getValueType(0) == MVT::v4i32) { 02696 Emit_34(Result, N, PPC::VANDC, MVT::v4i32, N0, N00, N01, N1); 02697 return; 02698 } 02699 } 02700 } 02701 N1 = N.getOperand(1); 02702 if (N1.getOpcode() == ISD::Constant) { 02703 02704 // Pattern: (and:i32 GPRC:i32:$src1, (imm:i32)<<P:Predicate_immZExt16>><<X:LO16>>:$src2) 02705 // Emits: (ANDIo:i32 GPRC:i32:$src1, (LO16:i32 (imm:i32):$src2)) 02706 // Pattern complexity = 5 cost = 1 size = 0 02707 if (Predicate_immZExt16(N1.Val) && 02708 N.Val->getValueType(0) == MVT::i32) { 02709 Emit_35(Result, N, PPC::ANDIo, MVT::i32, N0, N1); 02710 return; 02711 } 02712 02713 // Pattern: (and:i32 GPRC:i32:$src1, (imm:i32)<<P:Predicate_imm16ShiftedZExt>><<X:HI16>>:$src2) 02714 // Emits: (ANDISo:i32 GPRC:i32:$src1, (HI16:i32 (imm:i32):$src2)) 02715 // Pattern complexity = 5 cost = 1 size = 0 02716 if (Predicate_imm16ShiftedZExt(N1.Val) && 02717 N.Val->getValueType(0) == MVT::i32) { 02718 Emit_20(Result, N, PPC::ANDISo, MVT::i32, N0, N1); 02719 return; 02720 } 02721 02722 // Pattern: (and:i64 G8RC:i64:$src1, (imm:i64)<<P:Predicate_immZExt16>><<X:LO16>>:$src2) 02723 // Emits: (ANDIo8:i64 G8RC:i64:$src1, (LO16:i32 (imm:i64):$src2)) 02724 // Pattern complexity = 5 cost = 1 size = 0 02725 if (Predicate_immZExt16(N1.Val) && 02726 N.Val->getValueType(0) == MVT::i64) { 02727 Emit_36(Result, N, PPC::ANDIo8, MVT::i64, N0, N1); 02728 return; 02729 } 02730 02731 // Pattern: (and:i64 G8RC:i64:$src1, (imm:i64)<<P:Predicate_imm16ShiftedZExt>><<X:HI16>>:$src2) 02732 // Emits: (ANDISo8:i64 G8RC:i64:$src1, (HI16:i32 (imm:i64):$src2)) 02733 // Pattern complexity = 5 cost = 1 02734 if (Predicate_imm16ShiftedZExt(N1.Val) && 02735 N.Val->getValueType(0) == MVT::i64) { 02736 Emit_22(Result, N, PPC::ANDISo8, MVT::i64, N0, N1); 02737 return; 02738 } 02739 } 02740 02741 // Pattern: (and:i32 GPRC:i32:$rS, GPRC:i32:$rB) 02742 // Emits: (AND:i32 GPRC:i32:$rS, GPRC:i32:$rB) 02743 // Pattern complexity = 2 cost = 1 size = 0 02744 if (N.Val->getValueType(0) == MVT::i32) { 02745 Emit_24(Result, N, PPC::AND, MVT::i32, N0, N1); 02746 return; 02747 } 02748 02749 // Pattern: (and:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 02750 // Emits: (VAND:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 02751 // Pattern complexity = 2 cost = 1 size = 0 02752 if (N.Val->getValueType(0) == MVT::v4i32) { 02753 Emit_24(Result, N, PPC::VAND, MVT::v4i32, N0, N1); 02754 return; 02755 } 02756 02757 // Pattern: (and:i64 G8RC:i64:$rS, G8RC:i64:$rB) 02758 // Emits: (AND8:i64 G8RC:i64:$rS, G8RC:i64:$rB) 02759 // Pattern complexity = 2 cost = 1 02760 if (N.Val->getValueType(0) == MVT::i64) { 02761 Emit_24(Result, N, PPC::AND8, MVT::i64, N0, N1); 02762 return; 02763 } 02764 std::cerr << "Cannot yet select: "; 02765 N.Val->dump(CurDAG); 02766 std::cerr << '\n'; 02767 abort(); 02768 } 02769 02770 void Emit_37(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0) NOINLINE { 02771 SDOperand Tmp0(0, 0); 02772 SDNode *ResNode = NULL; 02773 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 02774 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 02775 Select(Tmp0, N0); 02776 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 02777 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 02778 if (N.Val->hasOneUse()) { 02779 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp0); 02780 } else { 02781 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp0); 02782 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02783 Result = SDOperand(ResNode, 0); 02784 } 02785 return; 02786 } 02787 void Select_anyext(SDOperand &Result, SDOperand N) { 02788 SDOperand N0(0, 0); 02789 SDOperand Tmp0(0, 0); 02790 SDNode *ResNode = NULL; 02791 N0 = N.getOperand(0); 02792 if (N.Val->getValueType(0) == MVT::i64 && 02793 N0.Val->getValueType(0) == MVT::i32) { 02794 Emit_37(Result, N, PPC::OR4To8, MVT::i64, N0); 02795 return; 02796 } 02797 std::cerr << "Cannot yet select: "; 02798 N.Val->dump(CurDAG); 02799 std::cerr << '\n'; 02800 abort(); 02801 } 02802 02803 void Emit_38(SDOperand &Result, SDOperand &N, SDOperand &N0) NOINLINE { 02804 SDOperand Tmp0(0, 0); 02805 Select(Tmp0, N0); 02806 Result = Tmp0; 02807 return; 02808 } 02809 void Select_bitconvert(SDOperand &Result, SDOperand N) { 02810 SDOperand N0(0, 0); 02811 SDOperand Tmp0(0, 0); 02812 N0 = N.getOperand(0); 02813 if (N.Val->getValueType(0) == MVT::v16i8) { 02814 02815 // Pattern: (bitconvert:v16i8 VRRC:v8i16:$src) 02816 // Emits: VRRC:v16i8:$src 02817 // Pattern complexity = 2 cost = 0 size = 0 02818 if (N0.Val->getValueType(0) == MVT::v8i16) { 02819 Emit_38(Result, N, N0); 02820 return; 02821 } 02822 02823 // Pattern: (bitconvert:v16i8 VRRC:v4i32:$src) 02824 // Emits: VRRC:v16i8:$src 02825 // Pattern complexity = 2 cost = 0 size = 0 02826 if (N0.Val->getValueType(0) == MVT::v4i32) { 02827 Emit_38(Result, N, N0); 02828 return; 02829 } 02830 02831 // Pattern: (bitconvert:v16i8 VRRC:v4f32:$src) 02832 // Emits: VRRC:v16i8:$src 02833 // Pattern complexity = 2 cost = 0 02834 if (N0.Val->getValueType(0) == MVT::v4f32) { 02835 Emit_38(Result, N, N0); 02836 return; 02837 } 02838 } 02839 if (N.Val->getValueType(0) == MVT::v8i16) { 02840 02841 // Pattern: (bitconvert:v8i16 VRRC:v16i8:$src) 02842 // Emits: VRRC:v8i16:$src 02843 // Pattern complexity = 2 cost = 0 size = 0 02844 if (N0.Val->getValueType(0) == MVT::v16i8) { 02845 Emit_38(Result, N, N0); 02846 return; 02847 } 02848 02849 // Pattern: (bitconvert:v8i16 VRRC:v4i32:$src) 02850 // Emits: VRRC:v8i16:$src 02851 // Pattern complexity = 2 cost = 0 size = 0 02852 if (N0.Val->getValueType(0) == MVT::v4i32) { 02853 Emit_38(Result, N, N0); 02854 return; 02855 } 02856 02857 // Pattern: (bitconvert:v8i16 VRRC:v4f32:$src) 02858 // Emits: VRRC:v8i16:$src 02859 // Pattern complexity = 2 cost = 0 02860 if (N0.Val->getValueType(0) == MVT::v4f32) { 02861 Emit_38(Result, N, N0); 02862 return; 02863 } 02864 } 02865 if (N.Val->getValueType(0) == MVT::v4i32) { 02866 02867 // Pattern: (bitconvert:v4i32 VRRC:v16i8:$src) 02868 // Emits: VRRC:v4i32:$src 02869 // Pattern complexity = 2 cost = 0 size = 0 02870 if (N0.Val->getValueType(0) == MVT::v16i8) { 02871 Emit_38(Result, N, N0); 02872 return; 02873 } 02874 02875 // Pattern: (bitconvert:v4i32 VRRC:v8i16:$src) 02876 // Emits: VRRC:v4i32:$src 02877 // Pattern complexity = 2 cost = 0 size = 0 02878 if (N0.Val->getValueType(0) == MVT::v8i16) { 02879 Emit_38(Result, N, N0); 02880 return; 02881 } 02882 02883 // Pattern: (bitconvert:v4i32 VRRC:v4f32:$src) 02884 // Emits: VRRC:v4i32:$src 02885 // Pattern complexity = 2 cost = 0 02886 if (N0.Val->getValueType(0) == MVT::v4f32) { 02887 Emit_38(Result, N, N0); 02888 return; 02889 } 02890 } 02891 if (N.Val->getValueType(0) == MVT::v4f32) { 02892 02893 // Pattern: (bitconvert:v4f32 VRRC:v16i8:$src) 02894 // Emits: VRRC:v4f32:$src 02895 // Pattern complexity = 2 cost = 0 size = 0 02896 if (N0.Val->getValueType(0) == MVT::v16i8) { 02897 Emit_38(Result, N, N0); 02898 return; 02899 } 02900 02901 // Pattern: (bitconvert:v4f32 VRRC:v8i16:$src) 02902 // Emits: VRRC:v4f32:$src 02903 // Pattern complexity = 2 cost = 0 size = 0 02904 if (N0.Val->getValueType(0) == MVT::v8i16) { 02905 Emit_38(Result, N, N0); 02906 return; 02907 } 02908 02909 // Pattern: (bitconvert:v4f32 VRRC:v4i32:$src) 02910 // Emits: VRRC:v4f32:$src 02911 // Pattern complexity = 2 cost = 0 02912 if (N0.Val->getValueType(0) == MVT::v4i32) { 02913 Emit_38(Result, N, N0); 02914 return; 02915 } 02916 } 02917 std::cerr << "Cannot yet select: "; 02918 N.Val->dump(CurDAG); 02919 std::cerr << '\n'; 02920 abort(); 02921 } 02922 02923 void Emit_39(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &Chain, SDOperand &N1) NOINLINE { 02924 SDOperand Tmp0(0, 0); 02925 SDNode *ResNode = NULL; 02926 Select(Tmp0, N1); 02927 Select(Chain, Chain); 02928 ResNode = CurDAG->getTargetNode(Opc0, MVT::Other, Tmp0, Chain); 02929 Chain = SDOperand(ResNode, 0); 02930 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 02931 Result = SDOperand(ResNode, N.ResNo); 02932 return; 02933 } 02934 void Select_br(SDOperand &Result, SDOperand N) { 02935 SDOperand Chain(0, 0); 02936 SDOperand N1(0, 0); 02937 SDOperand Tmp0(0, 0); 02938 SDNode *ResNode = NULL; 02939 Chain = N.getOperand(0); 02940 N1 = N.getOperand(1); 02941 if (N1.getOpcode() == ISD::BasicBlock) { 02942 Emit_39(Result, N, PPC::B, Chain, N1); 02943 return; 02944 } 02945 std::cerr << "Cannot yet select: "; 02946 N.Val->dump(CurDAG); 02947 std::cerr << '\n'; 02948 abort(); 02949 } 02950 02951 void Emit_40(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0) NOINLINE { 02952 SDOperand Tmp0(0, 0); 02953 SDOperand Tmp1(0, 0); 02954 SDNode *ResNode = NULL; 02955 Tmp0 = N; 02956 Tmp1 = Transform_VSPLTISB_get_imm(Tmp0.Val); 02957 if (N.Val->hasOneUse()) { 02958 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1); 02959 } else { 02960 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1); 02961 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02962 Result = SDOperand(ResNode, 0); 02963 } 02964 return; 02965 } 02966 void Emit_41(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0) NOINLINE { 02967 SDOperand Tmp0(0, 0); 02968 SDOperand Tmp1(0, 0); 02969 SDNode *ResNode = NULL; 02970 Tmp0 = N; 02971 Tmp1 = Transform_VSPLTISH_get_imm(Tmp0.Val); 02972 if (N.Val->hasOneUse()) { 02973 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1); 02974 } else { 02975 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1); 02976 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02977 Result = SDOperand(ResNode, 0); 02978 } 02979 return; 02980 } 02981 void Emit_42(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0) NOINLINE { 02982 SDOperand Tmp0(0, 0); 02983 SDOperand Tmp1(0, 0); 02984 SDNode *ResNode = NULL; 02985 Tmp0 = N; 02986 Tmp1 = Transform_VSPLTISW_get_imm(Tmp0.Val); 02987 if (N.Val->hasOneUse()) { 02988 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1); 02989 } else { 02990 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1); 02991 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 02992 Result = SDOperand(ResNode, 0); 02993 } 02994 return; 02995 } 02996 void Emit_43(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0) NOINLINE { 02997 SDNode *ResNode = NULL; 02998 if (N.Val->hasOneUse()) { 02999 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0); 03000 } else { 03001 ResNode = CurDAG->getTargetNode(Opc0, VT0); 03002 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03003 Result = SDOperand(ResNode, 0); 03004 } 03005 return; 03006 } 03007 void Select_build_vector(SDOperand &Result, SDOperand N) { 03008 SDOperand Tmp0(0, 0); 03009 SDOperand Tmp1(0, 0); 03010 SDNode *ResNode = NULL; 03011 03012 // Pattern: (build_vector:v16i8)<<P:Predicate_vecspltisb>><<X:VSPLTISB_get_imm>>:$SIMM 03013 // Emits: (VSPLTISB:v16i8 (VSPLTISB_get_imm:i32 (build_vector:v16i8):$SIMM)) 03014 // Pattern complexity = 3 cost = 1 size = 0 03015 if (Predicate_vecspltisb(N.Val) && 03016 N.Val->getValueType(0) == MVT::v16i8) { 03017 Emit_40(Result, N, PPC::VSPLTISB, MVT::v16i8); 03018 return; 03019 } 03020 03021 // Pattern: (build_vector:v8i16)<<P:Predicate_vecspltish>><<X:VSPLTISH_get_imm>>:$SIMM 03022 // Emits: (VSPLTISH:v8i16 (VSPLTISH_get_imm:i32 (build_vector:v8i16):$SIMM)) 03023 // Pattern complexity = 3 cost = 1 size = 0 03024 if (Predicate_vecspltish(N.Val) && 03025 N.Val->getValueType(0) == MVT::v8i16) { 03026 Emit_41(Result, N, PPC::VSPLTISH, MVT::v8i16); 03027 return; 03028 } 03029 03030 // Pattern: (build_vector:v4i32)<<P:Predicate_vecspltisw>><<X:VSPLTISW_get_imm>>:$SIMM 03031 // Emits: (VSPLTISW:v4i32 (VSPLTISW_get_imm:i32 (build_vector:v4i32):$SIMM)) 03032 // Pattern complexity = 3 cost = 1 size = 0 03033 if (Predicate_vecspltisw(N.Val) && 03034 N.Val->getValueType(0) == MVT::v4i32) { 03035 Emit_42(Result, N, PPC::VSPLTISW, MVT::v4i32); 03036 return; 03037 } 03038 03039 // Pattern: (build_vector:v4i32)<<P:Predicate_immAllZerosV>> 03040 // Emits: (V_SET0:v4i32) 03041 // Pattern complexity = 3 cost = 1 03042 if (Predicate_immAllZerosV(N.Val) && 03043 N.Val->getValueType(0) == MVT::v4i32) { 03044 Emit_43(Result, N, PPC::V_SET0, MVT::v4i32); 03045 return; 03046 } 03047 std::cerr << "Cannot yet select: "; 03048 N.Val->dump(CurDAG); 03049 std::cerr << '\n'; 03050 abort(); 03051 } 03052 03053 void Emit_44(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &Chain, SDOperand &N1) NOINLINE { 03054 SDOperand Tmp0(0, 0); 03055 SDNode *ResNode = NULL; 03056 Tmp0 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getValue()), MVT::i32); 03057 Select(Chain, Chain); 03058 ResNode = CurDAG->getTargetNode(Opc0, MVT::Other, Tmp0, Chain); 03059 Chain = SDOperand(ResNode, 0); 03060 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 03061 Result = SDOperand(ResNode, N.ResNo); 03062 return; 03063 } 03064 void Select_callseq_end(SDOperand &Result, SDOperand N) { 03065 SDOperand Chain(0, 0); 03066 SDOperand N1(0, 0); 03067 SDOperand Tmp0(0, 0); 03068 SDNode *ResNode = NULL; 03069 Chain = N.getOperand(0); 03070 N1 = N.getOperand(1); 03071 if (N1.getOpcode() == ISD::Constant) { 03072 Emit_44(Result, N, PPC::ADJCALLSTACKUP, Chain, N1); 03073 return; 03074 } 03075 std::cerr << "Cannot yet select: "; 03076 N.Val->dump(CurDAG); 03077 std::cerr << '\n'; 03078 abort(); 03079 } 03080 03081 void Select_callseq_start(SDOperand &Result, SDOperand N) { 03082 SDOperand Chain(0, 0); 03083 SDOperand N1(0, 0); 03084 SDOperand Tmp0(0, 0); 03085 SDNode *ResNode = NULL; 03086 Chain = N.getOperand(0); 03087 N1 = N.getOperand(1); 03088 if (N1.getOpcode() == ISD::Constant) { 03089 Emit_44(Result, N, PPC::ADJCALLSTACKDOWN, Chain, N1); 03090 return; 03091 } 03092 std::cerr << "Cannot yet select: "; 03093 N.Val->dump(CurDAG); 03094 std::cerr << '\n'; 03095 abort(); 03096 } 03097 03098 void Select_ctlz(SDOperand &Result, SDOperand N) { 03099 SDOperand N0(0, 0); 03100 SDOperand Tmp0(0, 0); 03101 SDNode *ResNode = NULL; 03102 N0 = N.getOperand(0); 03103 if (N.Val->getValueType(0) == MVT::i32) { 03104 Emit_4(Result, N, PPC::CNTLZW, MVT::i32, N0); 03105 return; 03106 } 03107 std::cerr << "Cannot yet select: "; 03108 N.Val->dump(CurDAG); 03109 std::cerr << '\n'; 03110 abort(); 03111 } 03112 03113 void Select_dwarf_label(SDOperand &Result, SDOperand N) { 03114 SDOperand Chain(0, 0); 03115 SDOperand N1(0, 0); 03116 SDOperand Tmp0(0, 0); 03117 SDNode *ResNode = NULL; 03118 Chain = N.getOperand(0); 03119 N1 = N.getOperand(1); 03120 if (N1.getOpcode() == ISD::Constant && 03121 N1.Val->getValueType(0) == MVT::i32) { 03122 Emit_44(Result, N, PPC::DWARF_LABEL, Chain, N1); 03123 return; 03124 } 03125 std::cerr << "Cannot yet select: "; 03126 N.Val->dump(CurDAG); 03127 std::cerr << '\n'; 03128 abort(); 03129 } 03130 03131 void Emit_45(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &Chain, SDOperand &N1, SDOperand &N2, SDOperand &N3) NOINLINE { 03132 SDOperand Tmp0(0, 0); 03133 SDOperand Tmp1(0, 0); 03134 SDOperand Tmp2(0, 0); 03135 SDNode *ResNode = NULL; 03136 Tmp0 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getValue()), MVT::i32); 03137 Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N2)->getValue()), MVT::i32); 03138 Tmp2 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N3)->getValue()), MVT::i32); 03139 Select(Chain, Chain); 03140 ResNode = CurDAG->getTargetNode(Opc0, MVT::Other, Tmp0, Tmp1, Tmp2, Chain); 03141 Chain = SDOperand(ResNode, 0); 03142 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 03143 Result = SDOperand(ResNode, N.ResNo); 03144 return; 03145 } 03146 void Select_dwarf_loc(SDOperand &Result, SDOperand N) { 03147 SDOperand Chain(0, 0); 03148 SDOperand N1(0, 0); 03149 SDOperand N2(0, 0); 03150 SDOperand N3(0, 0); 03151 SDOperand Tmp0(0, 0); 03152 SDOperand Tmp1(0, 0); 03153 SDOperand Tmp2(0, 0); 03154 SDNode *ResNode = NULL; 03155 Chain = N.getOperand(0); 03156 N1 = N.getOperand(1); 03157 if (N1.getOpcode() == ISD::Constant) { 03158 N2 = N.getOperand(2); 03159 if (N2.getOpcode() == ISD::Constant) { 03160 N3 = N.getOperand(3); 03161 if (N3.getOpcode() == ISD::Constant && 03162 N1.Val->getValueType(0) == MVT::i32 && 03163 N2.Val->getValueType(0) == MVT::i32 && 03164 N3.Val->getValueType(0) == MVT::i32) { 03165 Emit_45(Result, N, PPC::DWARF_LOC, Chain, N1, N2, N3); 03166 return; 03167 } 03168 } 03169 } 03170 std::cerr << "Cannot yet select: "; 03171 N.Val->dump(CurDAG); 03172 std::cerr << '\n'; 03173 abort(); 03174 } 03175 03176 void Emit_46(SDOperand &Result, SDOperand &N, unsigned Opc0, unsigned Opc1, MVT::ValueType VT0, MVT::ValueType VT1, SDOperand &CPTmp0, SDOperand &CPTmp1, SDOperand &Chain, SDOperand &N1, SDOperand &N2, SDOperand &N3) NOINLINE { 03177 SDOperand Tmp0(0, 0); 03178 SDOperand Tmp1(0, 0); 03179 SDOperand Tmp2(0, 0); 03180 SDNode *ResNode = NULL; 03181 SelectionDAG::InsertInFlightSetEntry(InFlightSet, CPTmp0.Val); 03182 SelectionDAG::InsertInFlightSetEntry(InFlightSet, CPTmp1.Val); 03183 Select(Tmp0, CPTmp0); 03184 Select(Tmp1, CPTmp1); 03185 Select(Chain, Chain); 03186 Tmp2 = SDOperand(CurDAG->getTargetNode(Opc0, VT0, MVT::Other, Tmp0, Tmp1, Chain), 0); 03187 Chain = SDOperand(Tmp2.Val, 1); 03188 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, CPTmp0.Val); 03189 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, CPTmp1.Val); 03190 ResNode = CurDAG->getTargetNode(Opc1, VT1, Tmp2); 03191 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 03192 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Chain.Val, Chain.ResNo); 03193 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, Chain.Val, Chain.ResNo); 03194 if (N.ResNo < 1) 03195 Result = SDOperand(ResNode, N.ResNo); 03196 else 03197 Result = SDOperand(Chain.Val, Chain.ResNo); 03198 return; 03199 } 03200 void Select_extld(SDOperand &Result, SDOperand N) { 03201 if (N.ResNo == 1 && N.getValue(0).hasOneUse()) { 03202 SDOperand Dummy = CurDAG->getNode(ISD::HANDLENODE, MVT::Other, N); 03203 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Dummy.Val, 0); 03204 SelectionDAG::InsertISelMapEntry(HandleMap, N.Val, 1, Dummy.Val, 0); 03205 Result = Dummy; 03206 return; 03207 } 03208 SDOperand CPTmp0(0, 0); 03209 SDOperand CPTmp1(0, 0); 03210 SDOperand Chain(0, 0); 03211 SDOperand N1(0, 0); 03212 SDOperand N2(0, 0); 03213 SDOperand N3(0, 0); 03214 SDOperand Tmp0(0, 0); 03215 SDOperand Tmp1(0, 0); 03216 SDOperand Tmp2(0, 0); 03217 SDNode *ResNode = NULL; 03218 Chain = N.getOperand(0); 03219 N1 = N.getOperand(1); 03220 N2 = N.getOperand(2); 03221 N3 = N.getOperand(3); 03222 if (cast<VTSDNode>(N3)->getVT() == MVT::i1 && 03223 N.Val->getValueType(0) == MVT::i32) { 03224 03225 // Pattern: (extld:i32 iaddr:iPTR:$src, srcvalue:Other:$dummy, i1:Other) 03226 // Emits: (LBZ:i32 iaddr:iPTR:$src) 03227 // Pattern complexity = 8 cost = 1 size = 0 03228 { 03229 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 03230 if (Match) { 03231 Emit_8(Result, N, PPC::LBZ, MVT::i32, CPTmp0, CPTmp1, Chain, N1, N2, N3); 03232 return; 03233 } 03234 } 03235 03236 // Pattern: (extld:i32 xaddr:iPTR:$src, srcvalue:Other:$dummy, i1:Other) 03237 // Emits: (LBZX:i32 xaddr:iPTR:$src) 03238 // Pattern complexity = 8 cost = 1 03239 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 03240 if (Match) { 03241 Emit_8(Result, N, PPC::LBZX, MVT::i32, CPTmp0, CPTmp1, Chain, N1, N2, N3); 03242 return; 03243 } 03244 } 03245 if (cast<VTSDNode>(N3)->getVT() == MVT::i8 && 03246 N.Val->getValueType(0) == MVT::i32) { 03247 03248 // Pattern: (extld:i32 iaddr:iPTR:$src, srcvalue:Other:$dummy, i8:Other) 03249 // Emits: (LBZ:i32 iaddr:iPTR:$src) 03250 // Pattern complexity = 8 cost = 1 size = 0 03251 { 03252 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 03253 if (Match) { 03254 Emit_8(Result, N, PPC::LBZ, MVT::i32, CPTmp0, CPTmp1, Chain, N1, N2, N3); 03255 return; 03256 } 03257 } 03258 03259 // Pattern: (extld:i32 xaddr:iPTR:$src, srcvalue:Other:$dummy, i8:Other) 03260 // Emits: (LBZX:i32 xaddr:iPTR:$src) 03261 // Pattern complexity = 8 cost = 1 03262 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 03263 if (Match) { 03264 Emit_8(Result, N, PPC::LBZX, MVT::i32, CPTmp0, CPTmp1, Chain, N1, N2, N3); 03265 return; 03266 } 03267 } 03268 if (cast<VTSDNode>(N3)->getVT() == MVT::i16 && 03269 N.Val->getValueType(0) == MVT::i32) { 03270 03271 // Pattern: (extld:i32 iaddr:iPTR:$src, srcvalue:Other:$dummy, i16:Other) 03272 // Emits: (LHZ:i32 iaddr:iPTR:$src) 03273 // Pattern complexity = 8 cost = 1 size = 0 03274 { 03275 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 03276 if (Match) { 03277 Emit_8(Result, N, PPC::LHZ, MVT::i32, CPTmp0, CPTmp1, Chain, N1, N2, N3); 03278 return; 03279 } 03280 } 03281 03282 // Pattern: (extld:i32 xaddr:iPTR:$src, srcvalue:Other:$dummy, i16:Other) 03283 // Emits: (LHZX:i32 xaddr:iPTR:$src) 03284 // Pattern complexity = 8 cost = 1 03285 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 03286 if (Match) { 03287 Emit_8(Result, N, PPC::LHZX, MVT::i32, CPTmp0, CPTmp1, Chain, N1, N2, N3); 03288 return; 03289 } 03290 } 03291 if (cast<VTSDNode>(N3)->getVT() == MVT::i1 && 03292 N.Val->getValueType(0) == MVT::i64) { 03293 03294 // Pattern: (extld:i64 iaddr:iPTR:$src, srcvalue:Other:$dummy, i1:Other) 03295 // Emits: (LBZ8:i64 iaddr:iPTR:$src) 03296 // Pattern complexity = 8 cost = 1 size = 0 03297 { 03298 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 03299 if (Match) { 03300 Emit_8(Result, N, PPC::LBZ8, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 03301 return; 03302 } 03303 } 03304 03305 // Pattern: (extld:i64 xaddr:iPTR:$src, srcvalue:Other:$dummy, i1:Other) 03306 // Emits: (LBZX8:i64 xaddr:iPTR:$src) 03307 // Pattern complexity = 8 cost = 1 03308 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 03309 if (Match) { 03310 Emit_8(Result, N, PPC::LBZX8, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 03311 return; 03312 } 03313 } 03314 if (cast<VTSDNode>(N3)->getVT() == MVT::i8 && 03315 N.Val->getValueType(0) == MVT::i64) { 03316 03317 // Pattern: (extld:i64 iaddr:iPTR:$src, srcvalue:Other:$dummy, i8:Other) 03318 // Emits: (LBZ8:i64 iaddr:iPTR:$src) 03319 // Pattern complexity = 8 cost = 1 size = 0 03320 { 03321 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 03322 if (Match) { 03323 Emit_8(Result, N, PPC::LBZ8, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 03324 return; 03325 } 03326 } 03327 03328 // Pattern: (extld:i64 xaddr:iPTR:$src, srcvalue:Other:$dummy, i8:Other) 03329 // Emits: (LBZX8:i64 xaddr:iPTR:$src) 03330 // Pattern complexity = 8 cost = 1 03331 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 03332 if (Match) { 03333 Emit_8(Result, N, PPC::LBZX8, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 03334 return; 03335 } 03336 } 03337 if (cast<VTSDNode>(N3)->getVT() == MVT::i16 && 03338 N.Val->getValueType(0) == MVT::i64) { 03339 03340 // Pattern: (extld:i64 iaddr:iPTR:$src, srcvalue:Other:$dummy, i16:Other) 03341 // Emits: (LHZ8:i64 iaddr:iPTR:$src) 03342 // Pattern complexity = 8 cost = 1 size = 0 03343 { 03344 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 03345 if (Match) { 03346 Emit_8(Result, N, PPC::LHZ8, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 03347 return; 03348 } 03349 } 03350 03351 // Pattern: (extld:i64 xaddr:iPTR:$src, srcvalue:Other:$dummy, i16:Other) 03352 // Emits: (LHZX8:i64 xaddr:iPTR:$src) 03353 // Pattern complexity = 8 cost = 1 03354 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 03355 if (Match) { 03356 Emit_8(Result, N, PPC::LHZX8, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 03357 return; 03358 } 03359 } 03360 if (cast<VTSDNode>(N3)->getVT() == MVT::i32 && 03361 N.Val->getValueType(0) == MVT::i64) { 03362 03363 // Pattern: (extld:i64 iaddr:iPTR:$src, srcvalue:Other:$dummy, i32:Other) 03364 // Emits: (LWZ8:i64 iaddr:iPTR:$src) 03365 // Pattern complexity = 8 cost = 1 size = 0 03366 { 03367 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 03368 if (Match) { 03369 Emit_8(Result, N, PPC::LWZ8, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 03370 return; 03371 } 03372 } 03373 03374 // Pattern: (extld:i64 xaddr:iPTR:$src, srcvalue:Other:$dummy, i32:Other) 03375 // Emits: (LWZX8:i64 xaddr:iPTR:$src) 03376 // Pattern complexity = 8 cost = 1 03377 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 03378 if (Match) { 03379 Emit_8(Result, N, PPC::LWZX8, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 03380 return; 03381 } 03382 } 03383 if (cast<VTSDNode>(N3)->getVT() == MVT::f32 && 03384 N.Val->getValueType(0) == MVT::f64) { 03385 03386 // Pattern: (extld:f64 iaddr:iPTR:$src, srcvalue:Other:$dummy, f32:Other) 03387 // Emits: (FMRSD:f64 (LFS:f32 iaddr:iPTR:$src)) 03388 // Pattern complexity = 8 cost = 2 size = 0 03389 { 03390 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 03391 if (Match) { 03392 Emit_46(Result, N, PPC::LFS, PPC::FMRSD, MVT::f32, MVT::f64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 03393 return; 03394 } 03395 } 03396 03397 // Pattern: (extld:f64 xaddr:iPTR:$src, srcvalue:Other:$dummy, f32:Other) 03398 // Emits: (FMRSD:f64 (LFSX:f32 xaddr:iPTR:$src)) 03399 // Pattern complexity = 8 cost = 2 03400 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 03401 if (Match) { 03402 Emit_46(Result, N, PPC::LFSX, PPC::FMRSD, MVT::f32, MVT::f64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 03403 return; 03404 } 03405 } 03406 std::cerr << "Cannot yet select: "; 03407 N.Val->dump(CurDAG); 03408 std::cerr << '\n'; 03409 abort(); 03410 } 03411 03412 void Select_fabs(SDOperand &Result, SDOperand N) { 03413 SDOperand N0(0, 0); 03414 SDOperand Tmp0(0, 0); 03415 SDNode *ResNode = NULL; 03416 N0 = N.getOperand(0); 03417 03418 // Pattern: (fabs:f32 F4RC:f32:$frB) 03419 // Emits: (FABSS:f32 F4RC:f32:$frB) 03420 // Pattern complexity = 2 cost = 1 size = 0 03421 if (N.Val->getValueType(0) == MVT::f32) { 03422 Emit_4(Result, N, PPC::FABSS, MVT::f32, N0); 03423 return; 03424 } 03425 03426 // Pattern: (fabs:f64 F8RC:f64:$frB) 03427 // Emits: (FABSD:f64 F8RC:f64:$frB) 03428 // Pattern complexity = 2 cost = 1 03429 if (N.Val->getValueType(0) == MVT::f64) { 03430 Emit_4(Result, N, PPC::FABSD, MVT::f64, N0); 03431 return; 03432 } 03433 std::cerr << "Cannot yet select: "; 03434 N.Val->dump(CurDAG); 03435 std::cerr << '\n'; 03436 abort(); 03437 } 03438 03439 void Emit_47(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N00, SDOperand &N01, SDOperand &N1) NOINLINE { 03440 SDOperand Tmp0(0, 0); 03441 SDOperand Tmp1(0, 0); 03442 SDOperand Tmp2(0, 0); 03443 SDNode *ResNode = NULL; 03444 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N00.Val); 03445 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N01.Val); 03446 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 03447 Select(Tmp0, N00); 03448 Select(Tmp1, N01); 03449 Select(Tmp2, N1); 03450 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N00.Val); 03451 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N01.Val); 03452 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 03453 if (N.Val->hasOneUse()) { 03454 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1, Tmp2); 03455 } else { 03456 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1, Tmp2); 03457 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03458 Result = SDOperand(ResNode, 0); 03459 } 03460 return; 03461 } 03462 void Emit_48(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N10, SDOperand &N11) NOINLINE { 03463 SDOperand Tmp0(0, 0); 03464 SDOperand Tmp1(0, 0); 03465 SDOperand Tmp2(0, 0); 03466 SDNode *ResNode = NULL; 03467 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N10.Val); 03468 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N11.Val); 03469 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 03470 Select(Tmp0, N10); 03471 Select(Tmp1, N11); 03472 Select(Tmp2, N0); 03473 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N10.Val); 03474 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N11.Val); 03475 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 03476 if (N.Val->hasOneUse()) { 03477 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1, Tmp2); 03478 } else { 03479 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1, Tmp2); 03480 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03481 Result = SDOperand(ResNode, 0); 03482 } 03483 return; 03484 } 03485 void Select_fadd(SDOperand &Result, SDOperand N) { 03486 SDOperand N0(0, 0); 03487 SDOperand N00(0, 0); 03488 SDOperand N01(0, 0); 03489 SDOperand N1(0, 0); 03490 SDOperand N10(0, 0); 03491 SDOperand N11(0, 0); 03492 SDOperand Tmp0(0, 0); 03493 SDOperand Tmp1(0, 0); 03494 SDOperand Tmp2(0, 0); 03495 SDNode *ResNode = NULL; 03496 if ((!NoExcessFPPrecision)) { 03497 N0 = N.getOperand(0); 03498 if (N0.getOpcode() == ISD::FMUL) { 03499 N00 = N0.getOperand(0); 03500 N01 = N0.getOperand(1); 03501 N1 = N.getOperand(1); 03502 03503 // Pattern: (fadd:f64 (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRC), F8RC:f64:$FRB) 03504 // Emits: (FMADD:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB) 03505 // Pattern complexity = 4 cost = 1 size = 0 03506 if (N.Val->getValueType(0) == MVT::f64) { 03507 Emit_47(Result, N, PPC::FMADD, MVT::f64, N0, N00, N01, N1); 03508 return; 03509 } 03510 03511 // Pattern: (fadd:f32 (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRC), F4RC:f32:$FRB) 03512 // Emits: (FMADDS:f32 F4RC:f32:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB) 03513 // Pattern complexity = 4 cost = 1 size = 0 03514 if (N.Val->getValueType(0) == MVT::f32) { 03515 Emit_47(Result, N, PPC::FMADDS, MVT::f32, N0, N00, N01, N1); 03516 return; 03517 } 03518 03519 // Pattern: (fadd:v4f32 (fmul:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vC), VRRC:v4f32:$vB) 03520 // Emits: (VMADDFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vC, VRRC:v4f32:$vB) 03521 // Pattern complexity = 4 cost = 1 03522 if (N.Val->getValueType(0) == MVT::v4f32) { 03523 Emit_47(Result, N, PPC::VMADDFP, MVT::v4f32, N0, N00, N01, N1); 03524 return; 03525 } 03526 } 03527 N1 = N.getOperand(1); 03528 if (N1.getOpcode() == ISD::FMUL) { 03529 N10 = N1.getOperand(0); 03530 N11 = N1.getOperand(1); 03531 03532 // Pattern: (fadd:f64 F8RC:f64:$FRB, (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRC)) 03533 // Emits: (FMADD:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB) 03534 // Pattern complexity = 4 cost = 1 size = 0 03535 if (N.Val->getValueType(0) == MVT::f64) { 03536 Emit_48(Result, N, PPC::FMADD, MVT::f64, N0, N1, N10, N11); 03537 return; 03538 } 03539 03540 // Pattern: (fadd:f32 F4RC:f32:$FRB, (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRC)) 03541 // Emits: (FMADDS:f32 F4RC:f32:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB) 03542 // Pattern complexity = 4 cost = 1 size = 0 03543 if (N.Val->getValueType(0) == MVT::f32) { 03544 Emit_48(Result, N, PPC::FMADDS, MVT::f32, N0, N1, N10, N11); 03545 return; 03546 } 03547 03548 // Pattern: (fadd:v4f32 VRRC:v4f32:$vB, (fmul:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vC)) 03549 // Emits: (VMADDFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vC, VRRC:v4f32:$vB) 03550 // Pattern complexity = 4 cost = 1 03551 if (N.Val->getValueType(0) == MVT::v4f32) { 03552 Emit_48(Result, N, PPC::VMADDFP, MVT::v4f32, N0, N1, N10, N11); 03553 return; 03554 } 03555 } 03556 } 03557 N0 = N.getOperand(0); 03558 N1 = N.getOperand(1); 03559 03560 // Pattern: (fadd:f64 F8RC:f64:$FRA, F8RC:f64:$FRB) 03561 // Emits: (FADD:f64 F8RC:f64:$FRA, F8RC:f64:$FRB) 03562 // Pattern complexity = 2 cost = 1 size = 0 03563 if (N.Val->getValueType(0) == MVT::f64) { 03564 Emit_24(Result, N, PPC::FADD, MVT::f64, N0, N1); 03565 return; 03566 } 03567 03568 // Pattern: (fadd:f32 F4RC:f32:$FRA, F4RC:f32:$FRB) 03569 // Emits: (FADDS:f32 F4RC:f32:$FRA, F4RC:f32:$FRB) 03570 // Pattern complexity = 2 cost = 1 size = 0 03571 if (N.Val->getValueType(0) == MVT::f32) { 03572 Emit_24(Result, N, PPC::FADDS, MVT::f32, N0, N1); 03573 return; 03574 } 03575 03576 // Pattern: (fadd:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 03577 // Emits: (VADDFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 03578 // Pattern complexity = 2 cost = 1 03579 if (N.Val->getValueType(0) == MVT::v4f32) { 03580 Emit_24(Result, N, PPC::VADDFP, MVT::v4f32, N0, N1); 03581 return; 03582 } 03583 std::cerr << "Cannot yet select: "; 03584 N.Val->dump(CurDAG); 03585 std::cerr << '\n'; 03586 abort(); 03587 } 03588 03589 void Select_fdiv(SDOperand &Result, SDOperand N) { 03590 SDOperand N0(0, 0); 03591 SDOperand N1(0, 0); 03592 SDOperand Tmp0(0, 0); 03593 SDOperand Tmp1(0, 0); 03594 SDNode *ResNode = NULL; 03595 N0 = N.getOperand(0); 03596 N1 = N.getOperand(1); 03597 03598 // Pattern: (fdiv:f64 F8RC:f64:$FRA, F8RC:f64:$FRB) 03599 // Emits: (FDIV:f64 F8RC:f64:$FRA, F8RC:f64:$FRB) 03600 // Pattern complexity = 2 cost = 1 size = 0 03601 if (N.Val->getValueType(0) == MVT::f64) { 03602 Emit_24(Result, N, PPC::FDIV, MVT::f64, N0, N1); 03603 return; 03604 } 03605 03606 // Pattern: (fdiv:f32 F4RC:f32:$FRA, F4RC:f32:$FRB) 03607 // Emits: (FDIVS:f32 F4RC:f32:$FRA, F4RC:f32:$FRB) 03608 // Pattern complexity = 2 cost = 1 03609 if (N.Val->getValueType(0) == MVT::f32) { 03610 Emit_24(Result, N, PPC::FDIVS, MVT::f32, N0, N1); 03611 return; 03612 } 03613 std::cerr << "Cannot yet select: "; 03614 N.Val->dump(CurDAG); 03615 std::cerr << '\n'; 03616 abort(); 03617 } 03618 03619 void Select_fextend(SDOperand &Result, SDOperand N) { 03620 SDOperand N0(0, 0); 03621 SDOperand Tmp0(0, 0); 03622 SDNode *ResNode = NULL; 03623 N0 = N.getOperand(0); 03624 if (N.Val->getValueType(0) == MVT::f64 && 03625 N0.Val->getValueType(0) == MVT::f32) { 03626 Emit_4(Result, N, PPC::FMRSD, MVT::f64, N0); 03627 return; 03628 } 03629 std::cerr << "Cannot yet select: "; 03630 N.Val->dump(CurDAG); 03631 std::cerr << '\n'; 03632 abort(); 03633 } 03634 03635 void Emit_49(SDOperand &Result, SDOperand &N, unsigned Opc0, unsigned Opc1, MVT::ValueType VT0, MVT::ValueType VT1, SDOperand &N0, SDOperand &N1) NOINLINE { 03636 SDOperand Tmp0(0, 0); 03637 SDOperand Tmp1(0, 0); 03638 SDOperand Tmp2(0, 0); 03639 SDNode *ResNode = NULL; 03640 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 03641 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 03642 Select(Tmp0, N0); 03643 Select(Tmp1, N1); 03644 Tmp2 = SDOperand(CurDAG->getTargetNode(Opc0, VT0), 0); 03645 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 03646 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 03647 if (N.Val->hasOneUse()) { 03648 Result = CurDAG->SelectNodeTo(N.Val, Opc1, VT1, Tmp0, Tmp1, Tmp2); 03649 } else { 03650 ResNode = CurDAG->getTargetNode(Opc1, VT1, Tmp0, Tmp1, Tmp2); 03651 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03652 Result = SDOperand(ResNode, 0); 03653 } 03654 return; 03655 } 03656 void Select_fmul(SDOperand &Result, SDOperand N) { 03657 SDOperand N0(0, 0); 03658 SDOperand N1(0, 0); 03659 SDOperand Tmp0(0, 0); 03660 SDOperand Tmp1(0, 0); 03661 SDOperand Tmp2(0, 0); 03662 SDNode *ResNode = NULL; 03663 N0 = N.getOperand(0); 03664 N1 = N.getOperand(1); 03665 03666 // Pattern: (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRB) 03667 // Emits: (FMUL:f64 F8RC:f64:$FRA, F8RC:f64:$FRB) 03668 // Pattern complexity = 2 cost = 1 size = 0 03669 if (N.Val->getValueType(0) == MVT::f64) { 03670 Emit_24(Result, N, PPC::FMUL, MVT::f64, N0, N1); 03671 return; 03672 } 03673 03674 // Pattern: (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRB) 03675 // Emits: (FMULS:f32 F4RC:f32:$FRA, F4RC:f32:$FRB) 03676 // Pattern complexity = 2 cost = 1 size = 0 03677 if (N.Val->getValueType(0) == MVT::f32) { 03678 Emit_24(Result, N, PPC::FMULS, MVT::f32, N0, N1); 03679 return; 03680 } 03681 03682 // Pattern: (fmul:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 03683 // Emits: (VMADDFP:v4f32 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (V_SET0:v4i32)) 03684 // Pattern complexity = 2 cost = 2 03685 if (N.Val->getValueType(0) == MVT::v4f32) { 03686 Emit_49(Result, N, PPC::V_SET0, PPC::VMADDFP, MVT::v4i32, MVT::v4f32, N0, N1); 03687 return; 03688 } 03689 std::cerr << "Cannot yet select: "; 03690 N.Val->dump(CurDAG); 03691 std::cerr << '\n'; 03692 abort(); 03693 } 03694 03695 void Emit_50(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N00, SDOperand &N000, SDOperand &N001, SDOperand &N01) NOINLINE { 03696 SDOperand Tmp0(0, 0); 03697 SDOperand Tmp1(0, 0); 03698 SDOperand Tmp2(0, 0); 03699 SDNode *ResNode = NULL; 03700 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N000.Val); 03701 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N001.Val); 03702 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N01.Val); 03703 Select(Tmp0, N000); 03704 Select(Tmp1, N001); 03705 Select(Tmp2, N01); 03706 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N000.Val); 03707 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N001.Val); 03708 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N01.Val); 03709 if (N.Val->hasOneUse()) { 03710 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1, Tmp2); 03711 } else { 03712 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1, Tmp2); 03713 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03714 Result = SDOperand(ResNode, 0); 03715 } 03716 return; 03717 } 03718 void Emit_51(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N00, SDOperand &N01, SDOperand &N010, SDOperand &N011) NOINLINE { 03719 SDOperand Tmp0(0, 0); 03720 SDOperand Tmp1(0, 0); 03721 SDOperand Tmp2(0, 0); 03722 SDNode *ResNode = NULL; 03723 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N010.Val); 03724 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N011.Val); 03725 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N00.Val); 03726 Select(Tmp0, N010); 03727 Select(Tmp1, N011); 03728 Select(Tmp2, N00); 03729 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N010.Val); 03730 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N011.Val); 03731 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N00.Val); 03732 if (N.Val->hasOneUse()) { 03733 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1, Tmp2); 03734 } else { 03735 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1, Tmp2); 03736 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03737 Result = SDOperand(ResNode, 0); 03738 } 03739 return; 03740 } 03741 void Emit_52(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N00) NOINLINE { 03742 SDOperand Tmp0(0, 0); 03743 SDNode *ResNode = NULL; 03744 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N00.Val); 03745 Select(Tmp0, N00); 03746 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N00.Val); 03747 if (N.Val->hasOneUse()) { 03748 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0); 03749 } else { 03750 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0); 03751 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 03752 Result = SDOperand(ResNode, 0); 03753 } 03754 return; 03755 } 03756 void Select_fneg(SDOperand &Result, SDOperand N) { 03757 SDOperand N0(0, 0); 03758 SDOperand N00(0, 0); 03759 SDOperand N000(0, 0); 03760 SDOperand N001(0, 0); 03761 SDOperand N01(0, 0); 03762 SDOperand N010(0, 0); 03763 SDOperand N011(0, 0); 03764 SDOperand Tmp0(0, 0); 03765 SDOperand Tmp1(0, 0); 03766 SDOperand Tmp2(0, 0); 03767 SDNode *ResNode = NULL; 03768 if ((!NoExcessFPPrecision)) { 03769 N0 = N.getOperand(0); 03770 if (N0.getOpcode() == ISD::FADD) { 03771 N00 = N0.getOperand(0); 03772 if (N00.getOpcode() == ISD::FMUL) { 03773 N000 = N00.getOperand(0); 03774 N001 = N00.getOperand(1); 03775 N01 = N0.getOperand(1); 03776 03777 // Pattern: (fneg:f64 (fadd:f64 (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRC), F8RC:f64:$FRB)) 03778 // Emits: (FNMADD:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB) 03779 // Pattern complexity = 6 cost = 1 size = 0 03780 if (N.Val->getValueType(0) == MVT::f64) { 03781 Emit_50(Result, N, PPC::FNMADD, MVT::f64, N0, N00, N000, N001, N01); 03782 return; 03783 } 03784 03785 // Pattern: (fneg:f32 (fadd:f32 (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRC), F4RC:f32:$FRB)) 03786 // Emits: (FNMADDS:f32 F4RC:f32:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB) 03787 // Pattern complexity = 6 cost = 1 03788 if (N.Val->getValueType(0) == MVT::f32) { 03789 Emit_50(Result, N, PPC::FNMADDS, MVT::f32, N0, N00, N000, N001, N01); 03790 return; 03791 } 03792 } 03793 } 03794 if (N0.getOpcode() == ISD::FSUB) { 03795 N00 = N0.getOperand(0); 03796 if (N00.getOpcode() == ISD::FMUL) { 03797 N000 = N00.getOperand(0); 03798 N001 = N00.getOperand(1); 03799 N01 = N0.getOperand(1); 03800 03801 // Pattern: (fneg:f64 (fsub:f64 (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRC), F8RC:f64:$FRB)) 03802 // Emits: (FNMSUB:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB) 03803 // Pattern complexity = 6 cost = 1 size = 0 03804 if (N.Val->getValueType(0) == MVT::f64) { 03805 Emit_50(Result, N, PPC::FNMSUB, MVT::f64, N0, N00, N000, N001, N01); 03806 return; 03807 } 03808 03809 // Pattern: (fneg:f32 (fsub:f32 (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRC), F4RC:f32:$FRB)) 03810 // Emits: (FNMSUBS:f32 F4RC:f32:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB) 03811 // Pattern complexity = 6 cost = 1 size = 0 03812 if (N.Val->getValueType(0) == MVT::f32) { 03813 Emit_50(Result, N, PPC::FNMSUBS, MVT::f32, N0, N00, N000, N001, N01); 03814 return; 03815 } 03816 03817 // Pattern: (fneg:v4f32 (fsub:v4f32 (fmul:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vC), VRRC:v4f32:$vB)) 03818 // Emits: (VNMSUBFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vC, VRRC:v4f32:$vB) 03819 // Pattern complexity = 6 cost = 1 03820 if (N.Val->getValueType(0) == MVT::v4f32) { 03821 Emit_50(Result, N, PPC::VNMSUBFP, MVT::v4f32, N0, N00, N000, N001, N01); 03822 return; 03823 } 03824 } 03825 } 03826 if (N0.getOpcode() == ISD::FADD) { 03827 N00 = N0.getOperand(0); 03828 N01 = N0.getOperand(1); 03829 if (N01.getOpcode() == ISD::FMUL) { 03830 N010 = N01.getOperand(0); 03831 N011 = N01.getOperand(1); 03832 03833 // Pattern: (fneg:f64 (fadd:f64 F8RC:f64:$FRB, (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRC))) 03834 // Emits: (FNMADD:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB) 03835 // Pattern complexity = 6 cost = 1 size = 0 03836 if (N.Val->getValueType(0) == MVT::f64) { 03837 Emit_51(Result, N, PPC::FNMADD, MVT::f64, N0, N00, N01, N010, N011); 03838 return; 03839 } 03840 03841 // Pattern: (fneg:f32 (fadd:f32 F4RC:f32:$FRB, (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRC))) 03842 // Emits: (FNMADDS:f32 F4RC:f32:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB) 03843 // Pattern complexity = 6 cost = 1 03844 if (N.Val->getValueType(0) == MVT::f32) { 03845 Emit_51(Result, N, PPC::FNMADDS, MVT::f32, N0, N00, N01, N010, N011); 03846 return; 03847 } 03848 } 03849 } 03850 } 03851 N0 = N.getOperand(0); 03852 if (N0.getOpcode() == ISD::FABS) { 03853 N00 = N0.getOperand(0); 03854 03855 // Pattern: (fneg:f32 (fabs:f32 F4RC:f32:$frB)) 03856 // Emits: (FNABSS:f32 F4RC:f32:$frB) 03857 // Pattern complexity = 4 cost = 1 size = 0 03858 if (N.Val->getValueType(0) == MVT::f32) { 03859 Emit_52(Result, N, PPC::FNABSS, MVT::f32, N0, N00); 03860 return; 03861 } 03862 03863 // Pattern: (fneg:f64 (fabs:f64 F8RC:f64:$frB)) 03864 // Emits: (FNABSD:f64 F8RC:f64:$frB) 03865 // Pattern complexity = 4 cost = 1 03866 if (N.Val->getValueType(0) == MVT::f64) { 03867 Emit_52(Result, N, PPC::FNABSD, MVT::f64, N0, N00); 03868 return; 03869 } 03870 } 03871 03872 // Pattern: (fneg:f32 F4RC:f32:$frB) 03873 // Emits: (FNEGS:f32 F4RC:f32:$frB) 03874 // Pattern complexity = 2 cost = 1 size = 0 03875 if (N.Val->getValueType(0) == MVT::f32) { 03876 Emit_4(Result, N, PPC::FNEGS, MVT::f32, N0); 03877 return; 03878 } 03879 03880 // Pattern: (fneg:f64 F8RC:f64:$frB) 03881 // Emits: (FNEGD:f64 F8RC:f64:$frB) 03882 // Pattern complexity = 2 cost = 1 03883 if (N.Val->getValueType(0) == MVT::f64) { 03884 Emit_4(Result, N, PPC::FNEGD, MVT::f64, N0); 03885 return; 03886 } 03887 std::cerr << "Cannot yet select: "; 03888 N.Val->dump(CurDAG); 03889 std::cerr << '\n'; 03890 abort(); 03891 } 03892 03893 void Select_fround(SDOperand &Result, SDOperand N) { 03894 SDOperand N0(0, 0); 03895 SDOperand Tmp0(0, 0); 03896 SDNode *ResNode = NULL; 03897 N0 = N.getOperand(0); 03898 if (N.Val->getValueType(0) == MVT::f32 && 03899 N0.Val->getValueType(0) == MVT::f64) { 03900 Emit_4(Result, N, PPC::FRSP, MVT::f32, N0); 03901 return; 03902 } 03903 std::cerr << "Cannot yet select: "; 03904 N.Val->dump(CurDAG); 03905 std::cerr << '\n'; 03906 abort(); 03907 } 03908 03909 void Select_fsqrt(SDOperand &Result, SDOperand N) { 03910 SDOperand N0(0, 0); 03911 SDOperand Tmp0(0, 0); 03912 SDNode *ResNode = NULL; 03913 N0 = N.getOperand(0); 03914 03915 // Pattern: (fsqrt:f64 F8RC:f64:$frB) 03916 // Emits: (FSQRT:f64 F8RC:f64:$frB) 03917 // Pattern complexity = 2 cost = 1 size = 0 03918 if (N.Val->getValueType(0) == MVT::f64) { 03919 Emit_4(Result, N, PPC::FSQRT, MVT::f64, N0); 03920 return; 03921 } 03922 03923 // Pattern: (fsqrt:f32 F4RC:f32:$frB) 03924 // Emits: (FSQRTS:f32 F4RC:f32:$frB) 03925 // Pattern complexity = 2 cost = 1 03926 if (N.Val->getValueType(0) == MVT::f32) { 03927 Emit_4(Result, N, PPC::FSQRTS, MVT::f32, N0); 03928 return; 03929 } 03930 std::cerr << "Cannot yet select: "; 03931 N.Val->dump(CurDAG); 03932 std::cerr << '\n'; 03933 abort(); 03934 } 03935 03936 void Select_fsub(SDOperand &Result, SDOperand N) { 03937 SDOperand N0(0, 0); 03938 SDOperand N00(0, 0); 03939 SDOperand N01(0, 0); 03940 SDOperand N1(0, 0); 03941 SDOperand N10(0, 0); 03942 SDOperand N11(0, 0); 03943 SDOperand Tmp0(0, 0); 03944 SDOperand Tmp1(0, 0); 03945 SDOperand Tmp2(0, 0); 03946 SDNode *ResNode = NULL; 03947 if ((!NoExcessFPPrecision)) { 03948 N0 = N.getOperand(0); 03949 if (N0.getOpcode() == ISD::FMUL) { 03950 N00 = N0.getOperand(0); 03951 N01 = N0.getOperand(1); 03952 N1 = N.getOperand(1); 03953 03954 // Pattern: (fsub:f64 (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRC), F8RC:f64:$FRB) 03955 // Emits: (FMSUB:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB) 03956 // Pattern complexity = 4 cost = 1 size = 0 03957 if (N.Val->getValueType(0) == MVT::f64) { 03958 Emit_47(Result, N, PPC::FMSUB, MVT::f64, N0, N00, N01, N1); 03959 return; 03960 } 03961 03962 // Pattern: (fsub:f32 (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRC), F4RC:f32:$FRB) 03963 // Emits: (FMSUBS:f32 F4RC:f32:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB) 03964 // Pattern complexity = 4 cost = 1 03965 if (N.Val->getValueType(0) == MVT::f32) { 03966 Emit_47(Result, N, PPC::FMSUBS, MVT::f32, N0, N00, N01, N1); 03967 return; 03968 } 03969 } 03970 N1 = N.getOperand(1); 03971 if (N1.getOpcode() == ISD::FMUL) { 03972 N10 = N1.getOperand(0); 03973 N11 = N1.getOperand(1); 03974 03975 // Pattern: (fsub:f64 F8RC:f64:$B, (fmul:f64 F8RC:f64:$A, F8RC:f64:$C)) 03976 // Emits: (FNMSUB:f64 F8RC:f64:$A, F8RC:f64:$C, F8RC:f64:$B) 03977 // Pattern complexity = 4 cost = 1 size = 0 03978 if (N.Val->getValueType(0) == MVT::f64) { 03979 Emit_48(Result, N, PPC::FNMSUB, MVT::f64, N0, N1, N10, N11); 03980 return; 03981 } 03982 03983 // Pattern: (fsub:f32 F4RC:f32:$B, (fmul:f32 F4RC:f32:$A, F4RC:f32:$C)) 03984 // Emits: (FNMSUBS:f32 F4RC:f32:$A, F4RC:f32:$C, F4RC:f32:$B) 03985 // Pattern complexity = 4 cost = 1 03986 if (N.Val->getValueType(0) == MVT::f32) { 03987 Emit_48(Result, N, PPC::FNMSUBS, MVT::f32, N0, N1, N10, N11); 03988 return; 03989 } 03990 } 03991 } 03992 N0 = N.getOperand(0); 03993 N1 = N.getOperand(1); 03994 03995 // Pattern: (fsub:f64 F8RC:f64:$FRA, F8RC:f64:$FRB) 03996 // Emits: (FSUB:f64 F8RC:f64:$FRA, F8RC:f64:$FRB) 03997 // Pattern complexity = 2 cost = 1 size = 0 03998 if (N.Val->getValueType(0) == MVT::f64) { 03999 Emit_24(Result, N, PPC::FSUB, MVT::f64, N0, N1); 04000 return; 04001 } 04002 04003 // Pattern: (fsub:f32 F4RC:f32:$FRA, F4RC:f32:$FRB) 04004 // Emits: (FSUBS:f32 F4RC:f32:$FRA, F4RC:f32:$FRB) 04005 // Pattern complexity = 2 cost = 1 size = 0 04006 if (N.Val->getValueType(0) == MVT::f32) { 04007 Emit_24(Result, N, PPC::FSUBS, MVT::f32, N0, N1); 04008 return; 04009 } 04010 04011 // Pattern: (fsub:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 04012 // Emits: (VSUBFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 04013 // Pattern complexity = 2 cost = 1 04014 if (N.Val->getValueType(0) == MVT::v4f32) { 04015 Emit_24(Result, N, PPC::VSUBFP, MVT::v4f32, N0, N1); 04016 return; 04017 } 04018 std::cerr << "Cannot yet select: "; 04019 N.Val->dump(CurDAG); 04020 std::cerr << '\n'; 04021 abort(); 04022 } 04023 04024 void Emit_53(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0) NOINLINE { 04025 SDOperand Tmp0(0, 0); 04026 SDNode *ResNode = NULL; 04027 Tmp0 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N)->getValue()), MVT::i32); 04028 if (N.Val->hasOneUse()) { 04029 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0); 04030 } else { 04031 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0); 04032 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04033 Result = SDOperand(ResNode, 0); 04034 } 04035 return; 04036 } 04037 void Emit_54(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0) NOINLINE { 04038 SDOperand Tmp0(0, 0); 04039 SDOperand Tmp1(0, 0); 04040 SDNode *ResNode = NULL; 04041 Tmp0 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N)->getValue()), MVT::i32); 04042 Tmp1 = Transform_HI16(Tmp0.Val); 04043 if (N.Val->hasOneUse()) { 04044 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1); 04045 } else { 04046 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1); 04047 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04048 Result = SDOperand(ResNode, 0); 04049 } 04050 return; 04051 } 04052 void Emit_55(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0) NOINLINE { 04053 SDOperand Tmp0(0, 0); 04054 SDNode *ResNode = NULL; 04055 Tmp0 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N)->getValue()), MVT::i64); 04056 if (N.Val->hasOneUse()) { 04057 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0); 04058 } else { 04059 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0); 04060 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04061 Result = SDOperand(ResNode, 0); 04062 } 04063 return; 04064 } 04065 void Emit_56(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0) NOINLINE { 04066 SDOperand Tmp0(0, 0); 04067 SDOperand Tmp1(0, 0); 04068 SDNode *ResNode = NULL; 04069 Tmp0 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N)->getValue()), MVT::i64); 04070 Tmp1 = Transform_HI16(Tmp0.Val); 04071 if (N.Val->hasOneUse()) { 04072 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1); 04073 } else { 04074 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1); 04075 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04076 Result = SDOperand(ResNode, 0); 04077 } 04078 return; 04079 } 04080 void Emit_57(SDOperand &Result, SDOperand &N, unsigned Opc0, unsigned Opc1, MVT::ValueType VT0, MVT::ValueType VT1) NOINLINE { 04081 SDOperand Tmp0(0, 0); 04082 SDOperand Tmp1(0, 0); 04083 SDOperand Tmp2(0, 0); 04084 SDOperand Tmp3(0, 0); 04085 SDNode *ResNode = NULL; 04086 Tmp0 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N)->getValue()), MVT::i64); 04087 Tmp1 = Transform_HI16(Tmp0.Val); 04088 Tmp2 = SDOperand(CurDAG->getTargetNode(Opc0, VT0, Tmp1), 0); 04089 Tmp3 = Transform_LO16(Tmp0.Val); 04090 if (N.Val->hasOneUse()) { 04091 Result = CurDAG->SelectNodeTo(N.Val, Opc1, VT1, Tmp2, Tmp3); 04092 } else { 04093 ResNode = CurDAG->getTargetNode(Opc1, VT1, Tmp2, Tmp3); 04094 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04095 Result = SDOperand(ResNode, 0); 04096 } 04097 return; 04098 } 04099 void Emit_58(SDOperand &Result, SDOperand &N, unsigned Opc0, unsigned Opc1, MVT::ValueType VT0, MVT::ValueType VT1) NOINLINE { 04100 SDOperand Tmp0(0, 0); 04101 SDOperand Tmp1(0, 0); 04102 SDOperand Tmp2(0, 0); 04103 SDOperand Tmp3(0, 0); 04104 SDNode *ResNode = NULL; 04105 Tmp0 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N)->getValue()), MVT::i64); 04106 Tmp1 = Transform_LO16(Tmp0.Val); 04107 Tmp2 = SDOperand(CurDAG->getTargetNode(Opc0, VT0, Tmp1), 0); 04108 Tmp3 = Transform_HI16(Tmp0.Val); 04109 if (N.Val->hasOneUse()) { 04110 Result = CurDAG->SelectNodeTo(N.Val, Opc1, VT1, Tmp2, Tmp3); 04111 } else { 04112 ResNode = CurDAG->getTargetNode(Opc1, VT1, Tmp2, Tmp3); 04113 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04114 Result = SDOperand(ResNode, 0); 04115 } 04116 return; 04117 } 04118 void Emit_59(SDOperand &Result, SDOperand &N, unsigned Opc0, unsigned Opc1, unsigned Opc2, MVT::ValueType VT0, MVT::ValueType VT1, MVT::ValueType VT2) NOINLINE { 04119 SDOperand Tmp0(0, 0); 04120 SDOperand Tmp1(0, 0); 04121 SDOperand Tmp2(0, 0); 04122 SDOperand Tmp3(0, 0); 04123 SDOperand Tmp4(0, 0); 04124 SDOperand Tmp5(0, 0); 04125 SDNode *ResNode = NULL; 04126 Tmp0 = CurDAG->getTargetConstant(0, MVT::i64); 04127 Tmp1 = SDOperand(CurDAG->getTargetNode(Opc0, VT0, Tmp0), 0); 04128 Tmp2 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N)->getValue()), MVT::i32); 04129 Tmp3 = Transform_LO16(Tmp2.Val); 04130 Tmp4 = SDOperand(CurDAG->getTargetNode(Opc1, VT1, Tmp1, Tmp3), 0); 04131 Tmp5 = Transform_HI16(Tmp2.Val); 04132 if (N.Val->hasOneUse()) { 04133 Result = CurDAG->SelectNodeTo(N.Val, Opc2, VT2, Tmp4, Tmp5); 04134 } else { 04135 ResNode = CurDAG->getTargetNode(Opc2, VT2, Tmp4, Tmp5); 04136 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04137 Result = SDOperand(ResNode, 0); 04138 } 04139 return; 04140 } 04141 void Emit_60(SDOperand &Result, SDOperand &N, unsigned Opc0, unsigned Opc1, MVT::ValueType VT0, MVT::ValueType VT1) NOINLINE { 04142 SDOperand Tmp0(0, 0); 04143 SDOperand Tmp1(0, 0); 04144 SDOperand Tmp2(0, 0); 04145 SDOperand Tmp3(0, 0); 04146 SDNode *ResNode = NULL; 04147 Tmp0 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N)->getValue()), MVT::i32); 04148 Tmp1 = Transform_HI16(Tmp0.Val); 04149 Tmp2 = SDOperand(CurDAG->getTargetNode(Opc0, VT0, Tmp1), 0); 04150 Tmp3 = Transform_LO16(Tmp0.Val); 04151 if (N.Val->hasOneUse()) { 04152 Result = CurDAG->SelectNodeTo(N.Val, Opc1, VT1, Tmp2, Tmp3); 04153 } else { 04154 ResNode = CurDAG->getTargetNode(Opc1, VT1, Tmp2, Tmp3); 04155 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04156 Result = SDOperand(ResNode, 0); 04157 } 04158 return; 04159 } 04160 void Emit_61(SDOperand &Result, SDOperand &N, unsigned Opc0, unsigned Opc1, unsigned Opc2, unsigned Opc3, unsigned Opc4, MVT::ValueType VT0, MVT::ValueType VT1, MVT::ValueType VT2, MVT::ValueType VT3, MVT::ValueType VT4) NOINLINE { 04161 SDOperand Tmp0(0, 0); 04162 SDOperand Tmp1(0, 0); 04163 SDOperand Tmp10(0, 0); 04164 SDOperand Tmp2(0, 0); 04165 SDOperand Tmp3(0, 0); 04166 SDOperand Tmp4(0, 0); 04167 SDOperand Tmp5(0, 0); 04168 SDOperand Tmp6(0, 0); 04169 SDOperand Tmp7(0, 0); 04170 SDOperand Tmp8(0, 0); 04171 SDOperand Tmp9(0, 0); 04172 SDNode *ResNode = NULL; 04173 Tmp0 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N)->getValue()), MVT::i64); 04174 Tmp1 = Transform_HI48_64(Tmp0.Val); 04175 Tmp2 = SDOperand(CurDAG->getTargetNode(Opc0, VT0, Tmp1), 0); 04176 Tmp3 = Transform_HI32_48(Tmp0.Val); 04177 Tmp4 = SDOperand(CurDAG->getTargetNode(Opc1, VT1, Tmp2, Tmp3), 0); 04178 Tmp5 = CurDAG->getTargetConstant(32, MVT::i32); 04179 Tmp6 = CurDAG->getTargetConstant(31, MVT::i32); 04180 Tmp7 = SDOperand(CurDAG->getTargetNode(Opc2, VT2, Tmp4, Tmp5, Tmp6), 0); 04181 Tmp8 = Transform_HI16(Tmp0.Val); 04182 Tmp9 = SDOperand(CurDAG->getTargetNode(Opc3, VT3, Tmp7, Tmp8), 0); 04183 Tmp10 = Transform_LO16(Tmp0.Val); 04184 if (N.Val->hasOneUse()) { 04185 Result = CurDAG->SelectNodeTo(N.Val, Opc4, VT4, Tmp9, Tmp10); 04186 } else { 04187 ResNode = CurDAG->getTargetNode(Opc4, VT4, Tmp9, Tmp10); 04188 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04189 Result = SDOperand(ResNode, 0); 04190 } 04191 return; 04192 } 04193 void Select_imm(SDOperand &Result, SDOperand N) { 04194 SDOperand Tmp0(0, 0); 04195 SDOperand Tmp1(0, 0); 04196 SDOperand Tmp10(0, 0); 04197 SDOperand Tmp2(0, 0); 04198 SDOperand Tmp3(0, 0); 04199 SDOperand Tmp4(0, 0); 04200 SDOperand Tmp5(0, 0); 04201 SDOperand Tmp6(0, 0); 04202 SDOperand Tmp7(0, 0); 04203 SDOperand Tmp8(0, 0); 04204 SDOperand Tmp9(0, 0); 04205 SDNode *ResNode = NULL; 04206 04207 // Pattern: (imm:i32)<<P:Predicate_immSExt16>>:$imm 04208 // Emits: (LI:i32 (imm:i32):$imm) 04209 // Pattern complexity = 3 cost = 1 size = 0 04210 if (Predicate_immSExt16(N.Val) && 04211 N.Val->getValueType(0) == MVT::i32) { 04212 Emit_53(Result, N, PPC::LI, MVT::i32); 04213 return; 04214 } 04215 04216 // Pattern: (imm:i32)<<P:Predicate_imm16ShiftedSExt>><<X:HI16>>:$imm 04217 // Emits: (LIS:i32 (HI16:i32 (imm:i32):$imm)) 04218 // Pattern complexity = 3 cost = 1 size = 0 04219 if (Predicate_imm16ShiftedSExt(N.Val) && 04220 N.Val->getValueType(0) == MVT::i32) { 04221 Emit_54(Result, N, PPC::LIS, MVT::i32); 04222 return; 04223 } 04224 04225 // Pattern: (imm:i64)<<P:Predicate_immSExt16>>:$imm 04226 // Emits: (LI8:i64 (imm:i64):$imm) 04227 // Pattern complexity = 3 cost = 1 size = 0 04228 if (Predicate_immSExt16(N.Val) && 04229 N.Val->getValueType(0) == MVT::i64) { 04230 Emit_55(Result, N, PPC::LI8, MVT::i64); 04231 return; 04232 } 04233 04234 // Pattern: (imm:i64)<<P:Predicate_imm16ShiftedSExt>><<X:HI16>>:$imm 04235 // Emits: (LIS8:i64 (HI16:i64 (imm:i64):$imm)) 04236 // Pattern complexity = 3 cost = 1 size = 0 04237 if (Predicate_imm16ShiftedSExt(N.Val) && 04238 N.Val->getValueType(0) == MVT::i64) { 04239 Emit_56(Result, N, PPC::LIS8, MVT::i64); 04240 return; 04241 } 04242 04243 // Pattern: (imm:i64)<<P:Predicate_sext_0x0000_0000_FFFF_FFFF_i16>>:$imm 04244 // Emits: (ORI8:i64 (LIS8:i64 (HI16:i64 (imm:i64):$imm)), (LO16:i32 (imm:i32):$imm)) 04245 // Pattern complexity = 3 cost = 2 size = 0 04246 if (Predicate_sext_0x0000_0000_FFFF_FFFF_i16(N.Val) && 04247 N.Val->getValueType(0) == MVT::i64) { 04248 Emit_57(Result, N, PPC::LIS8, PPC::ORI8, MVT::i64, MVT::i64); 04249 return; 04250 } 04251 04252 // Pattern: (imm:i64)<<P:Predicate_zext_0x0000_0000_FFFF_7FFF_i16>>:$imm 04253 // Emits: (ORIS8:i64 (LI8:i64 (LO16:i64 (imm:i64):$imm)), (HI16:i32 (imm:i32):$imm)) 04254 // Pattern complexity = 3 cost = 2 size = 0 04255 if (Predicate_zext_0x0000_0000_FFFF_7FFF_i16(N.Val) && 04256 N.Val->getValueType(0) == MVT::i64) { 04257 Emit_58(Result, N, PPC::LI8, PPC::ORIS8, MVT::i64, MVT::i64); 04258 return; 04259 } 04260 04261 // Pattern: (imm:i64)<<P:Predicate_zext_0x0000_0000_FFFF_FFFF_i16>>:$imm 04262 // Emits: (ORIS8:i64 (ORI8:i64 (LI8:i64 0:i64), (LO16:i32 (imm:i32):$imm)), (HI16:i32 (imm:i32):$imm)) 04263 // Pattern complexity = 3 cost = 3 size = 0 04264 if (Predicate_zext_0x0000_0000_FFFF_FFFF_i16(N.Val) && 04265 N.Val->getValueType(0) == MVT::i64) { 04266 Emit_59(Result, N, PPC::LI8, PPC::ORI8, PPC::ORIS8, MVT::i64, MVT::i64, MVT::i64); 04267 return; 04268 } 04269 04270 // Pattern: (imm:i32):$imm 04271 // Emits: (ORI:i32 (LIS:i32 (HI16:i32 (imm:i32):$imm)), (LO16:i32 (imm:i32):$imm)) 04272 // Pattern complexity = 2 cost = 2 size = 0 04273 if (N.Val->getValueType(0) == MVT::i32) { 04274 Emit_60(Result, N, PPC::LIS, PPC::ORI, MVT::i32, MVT::i32); 04275 return; 04276 } 04277 04278 // Pattern: (imm:i64):$imm 04279 // Emits: (ORI8:i64 (ORIS8:i64 (RLDICR:i64 (ORI8:i64 (LIS8:i64 (HI48_64:i64 (imm:i64):$imm)), (HI32_48:i32 (imm:i32):$imm)), 32:i32, 31:i32), (HI16:i32 (imm:i32):$imm)), (LO16:i32 (imm:i32):$imm)) 04280 // Pattern complexity = 2 cost = 5 04281 if (N.Val->getValueType(0) == MVT::i64) { 04282 Emit_61(Result, N, PPC::LIS8, PPC::ORI8, PPC::RLDICR, PPC::ORIS8, PPC::ORI8, MVT::i64, MVT::i64, MVT::i64, MVT::i64, MVT::i64); 04283 return; 04284 } 04285 std::cerr << "Cannot yet select: "; 04286 N.Val->dump(CurDAG); 04287 std::cerr << '\n'; 04288 abort(); 04289 } 04290 04291 void Emit_62(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &CPTmp1, SDOperand &CPTmp2, SDOperand &Chain, SDOperand &N1, SDOperand &N2) NOINLINE { 04292 SDOperand Tmp1(0, 0); 04293 SDOperand Tmp2(0, 0); 04294 SDNode *ResNode = NULL; 04295 SelectionDAG::InsertInFlightSetEntry(InFlightSet, CPTmp1.Val); 04296 SelectionDAG::InsertInFlightSetEntry(InFlightSet, CPTmp2.Val); 04297 Select(Tmp1, CPTmp1); 04298 Select(Tmp2, CPTmp2); 04299 Select(Chain, Chain); 04300 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, CPTmp1.Val); 04301 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, CPTmp2.Val); 04302 ResNode = CurDAG->getTargetNode(Opc0, MVT::Other, Tmp1, Tmp2, Chain); 04303 Chain = SDOperand(ResNode, 0); 04304 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 04305 Result = SDOperand(ResNode, N.ResNo); 04306 return; 04307 } 04308 void Emit_63(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &CPTmp1, SDOperand &CPTmp2, SDOperand &Chain, SDOperand &N1, SDOperand &N2, SDOperand &N3) NOINLINE { 04309 SDOperand Tmp1(0, 0); 04310 SDOperand Tmp2(0, 0); 04311 SDOperand Tmp3(0, 0); 04312 SDNode *ResNode = NULL; 04313 SelectionDAG::InsertInFlightSetEntry(InFlightSet, CPTmp1.Val); 04314 SelectionDAG::InsertInFlightSetEntry(InFlightSet, CPTmp2.Val); 04315 Select(Tmp1, CPTmp1); 04316 Select(Tmp2, CPTmp2); 04317 Select(Tmp3, N2); 04318 Select(Chain, Chain); 04319 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N2.Val); 04320 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, CPTmp1.Val); 04321 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, CPTmp2.Val); 04322 ResNode = CurDAG->getTargetNode(Opc0, MVT::Other, Tmp3, Tmp1, Tmp2, Chain); 04323 Chain = SDOperand(ResNode, 0); 04324 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 04325 Result = SDOperand(ResNode, N.ResNo); 04326 return; 04327 } 04328 void Emit_64(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &Chain, SDOperand &N1, SDOperand &N2) NOINLINE { 04329 SDOperand Tmp1(0, 0); 04330 SDOperand Tmp2(0, 0); 04331 SDOperand Tmp3(0, 0); 04332 SDOperand Tmp4(0, 0); 04333 SDNode *ResNode = NULL; 04334 Tmp1 = CurDAG->getTargetConstant(0, MVT::i32); 04335 Tmp2 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N2)->getValue()), MVT::i32); 04336 Tmp3 = CurDAG->getTargetConstant(0, MVT::i32); 04337 Tmp4 = CurDAG->getTargetConstant(0, MVT::i32); 04338 Select(Chain, Chain); 04339 ResNode = CurDAG->getTargetNode(Opc0, MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4, Chain); 04340 Chain = SDOperand(ResNode, 0); 04341 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 04342 Result = SDOperand(ResNode, N.ResNo); 04343 return; 04344 } 04345 void Emit_65(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &Chain, SDOperand &N1, SDOperand &N2, SDOperand &N3, SDOperand &N4) NOINLINE { 04346 SDOperand Tmp1(0, 0); 04347 SDOperand Tmp2(0, 0); 04348 SDOperand Tmp3(0, 0); 04349 SDOperand Tmp4(0, 0); 04350 SDNode *ResNode = NULL; 04351 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N2.Val); 04352 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N3.Val); 04353 Tmp1 = CurDAG->getTargetConstant(0, MVT::i32); 04354 Tmp2 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N4)->getValue()), MVT::i32); 04355 Select(Tmp3, N2); 04356 Select(Tmp4, N3); 04357 Select(Chain, Chain); 04358 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N2.Val); 04359 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N3.Val); 04360 ResNode = CurDAG->getTargetNode(Opc0, MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4, Chain); 04361 Chain = SDOperand(ResNode, 0); 04362 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 04363 Result = SDOperand(ResNode, N.ResNo); 04364 return; 04365 } 04366 void Emit_66(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &Chain, SDOperand &N1, SDOperand &N2, SDOperand &N3, SDOperand &N4) NOINLINE { 04367 SDOperand Tmp1(0, 0); 04368 SDOperand Tmp2(0, 0); 04369 SDOperand Tmp3(0, 0); 04370 SDOperand Tmp4(0, 0); 04371 SDNode *ResNode = NULL; 04372 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N2.Val); 04373 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N3.Val); 04374 Tmp1 = CurDAG->getTargetConstant(1, MVT::i32); 04375 Tmp2 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N4)->getValue()), MVT::i32); 04376 Select(Tmp3, N2); 04377 Select(Tmp4, N3); 04378 Select(Chain, Chain); 04379 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N2.Val); 04380 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N3.Val); 04381 ResNode = CurDAG->getTargetNode(Opc0, MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4, Chain); 04382 Chain = SDOperand(ResNode, 0); 04383 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 04384 Result = SDOperand(ResNode, N.ResNo); 04385 return; 04386 } 04387 void Emit_67(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &Chain, SDOperand &N1, SDOperand &N2) NOINLINE { 04388 SDOperand Tmp1(0, 0); 04389 SDNode *ResNode = NULL; 04390 N2 = N.getOperand(2); 04391 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N2.Val); 04392 Select(Tmp1, N2); 04393 Select(Chain, Chain); 04394 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N2.Val); 04395 ResNode = CurDAG->getTargetNode(Opc0, MVT::Other, Tmp1, Chain); 04396 Chain = SDOperand(ResNode, 0); 04397 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 04398 Result = SDOperand(ResNode, N.ResNo); 04399 return; 04400 } 04401 void Emit_68(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &Chain, SDOperand &N1) NOINLINE { 04402 SDOperand Tmp1(0, 0); 04403 SDOperand Tmp2(0, 0); 04404 SDOperand Tmp3(0, 0); 04405 SDOperand Tmp4(0, 0); 04406 SDNode *ResNode = NULL; 04407 Tmp1 = CurDAG->getTargetConstant(1, MVT::i32); 04408 Tmp2 = CurDAG->getTargetConstant(0, MVT::i32); 04409 Tmp3 = CurDAG->getTargetConstant(0, MVT::i32); 04410 Tmp4 = CurDAG->getTargetConstant(0, MVT::i32); 04411 Select(Chain, Chain); 04412 ResNode = CurDAG->getTargetNode(Opc0, MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4, Chain); 04413 Chain = SDOperand(ResNode, 0); 04414 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 04415 Result = SDOperand(ResNode, N.ResNo); 04416 return; 04417 } 04418 void Select_intrinsic_void(SDOperand &Result, SDOperand N) { 04419 SDOperand CPTmp1(0, 0); 04420 SDOperand CPTmp2(0, 0); 04421 SDOperand Chain(0, 0); 04422 SDOperand N1(0, 0); 04423 SDOperand N2(0, 0); 04424 SDOperand N3(0, 0); 04425 SDOperand N4(0, 0); 04426 SDOperand Tmp1(0, 0); 04427 SDOperand Tmp2(0, 0); 04428 SDOperand Tmp3(0, 0); 04429 SDOperand Tmp4(0, 0); 04430 SDNode *ResNode = NULL; 04431 Chain = N.getOperand(0); 04432 N1 = N.getOperand(1); 04433 if (isa<ConstantSDNode>(N1)) { 04434 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 04435 04436 // Pattern: (intrinsic_void:void 182:iPTR, xoaddr:iPTR:$dst) 04437 // Emits: (DCBZ:void xoaddr:iPTR:$dst) 04438 // Pattern complexity = 11 cost = 1 size = 0 04439 if (CN0 == 182) { 04440 N2 = N.getOperand(2); 04441 bool Match = SelectAddrIdxOnly(N2, CPTmp1, CPTmp2); 04442 if (Match) { 04443 Emit_62(Result, N, PPC::DCBZ, CPTmp1, CPTmp2, Chain, N1, N2); 04444 return; 04445 } 04446 } 04447 04448 // Pattern: (intrinsic_void:void 183:iPTR, xoaddr:iPTR:$dst) 04449 // Emits: (DCBZL:void xoaddr:iPTR:$dst) 04450 // Pattern complexity = 11 cost = 1 size = 0 04451 if (CN0 == 183) { 04452 N2 = N.getOperand(2); 04453 bool Match = SelectAddrIdxOnly(N2, CPTmp1, CPTmp2); 04454 if (Match) { 04455 Emit_62(Result, N, PPC::DCBZL, CPTmp1, CPTmp2, Chain, N1, N2); 04456 return; 04457 } 04458 } 04459 04460 // Pattern: (intrinsic_void:void 50:iPTR, VRRC:v16i8:$rS, xoaddr:iPTR:$dst) 04461 // Emits: (STVEBX:void VRRC:v16i8:$rS, xoaddr:iPTR:$dst) 04462 // Pattern complexity = 11 cost = 1 size = 0 04463 if (CN0 == 50) { 04464 N2 = N.getOperand(2); 04465 N3 = N.getOperand(3); 04466 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N2.Val); 04467 bool Match = SelectAddrIdxOnly(N3, CPTmp1, CPTmp2); 04468 if (!Match) { 04469 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N2.Val); 04470 } 04471 if (Match) { 04472 Emit_63(Result, N, PPC::STVEBX, CPTmp1, CPTmp2, Chain, N1, N2, N3); 04473 return; 04474 } 04475 } 04476 04477 // Pattern: (intrinsic_void:void 51:iPTR, VRRC:v8i16:$rS, xoaddr:iPTR:$dst) 04478 // Emits: (STVEHX:void VRRC:v8i16:$rS, xoaddr:iPTR:$dst) 04479 // Pattern complexity = 11 cost = 1 size = 0 04480 if (CN0 == 51) { 04481 N2 = N.getOperand(2); 04482 N3 = N.getOperand(3); 04483 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N2.Val); 04484 bool Match = SelectAddrIdxOnly(N3, CPTmp1, CPTmp2); 04485 if (!Match) { 04486 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N2.Val); 04487 } 04488 if (Match) { 04489 Emit_63(Result, N, PPC::STVEHX, CPTmp1, CPTmp2, Chain, N1, N2, N3); 04490 return; 04491 } 04492 } 04493 04494 // Pattern: (intrinsic_void:void 52:iPTR, VRRC:v4i32:$rS, xoaddr:iPTR:$dst) 04495 // Emits: (STVEWX:void VRRC:v4i32:$rS, xoaddr:iPTR:$dst) 04496 // Pattern complexity = 11 cost = 1 size = 0 04497 if (CN0 == 52) { 04498 N2 = N.getOperand(2); 04499 N3 = N.getOperand(3); 04500 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N2.Val); 04501 bool Match = SelectAddrIdxOnly(N3, CPTmp1, CPTmp2); 04502 if (!Match) { 04503 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N2.Val); 04504 } 04505 if (Match) { 04506 Emit_63(Result, N, PPC::STVEWX, CPTmp1, CPTmp2, Chain, N1, N2, N3); 04507 return; 04508 } 04509 } 04510 04511 // Pattern: (intrinsic_void:void 53:iPTR, VRRC:v4i32:$rS, xoaddr:iPTR:$dst) 04512 // Emits: (STVX:void VRRC:v4i32:$rS, xoaddr:iPTR:$dst) 04513 // Pattern complexity = 11 cost = 1 size = 0 04514 if (CN0 == 53) { 04515 N2 = N.getOperand(2); 04516 N3 = N.getOperand(3); 04517 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N2.Val); 04518 bool Match = SelectAddrIdxOnly(N3, CPTmp1, CPTmp2); 04519 if (!Match) { 04520 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N2.Val); 04521 } 04522 if (Match) { 04523 Emit_63(Result, N, PPC::STVX, CPTmp1, CPTmp2, Chain, N1, N2, N3); 04524 return; 04525 } 04526 } 04527 04528 // Pattern: (intrinsic_void:void 54:iPTR, VRRC:v4i32:$rS, xoaddr:iPTR:$dst) 04529 // Emits: (STVXL:void VRRC:v4i32:$rS, xoaddr:iPTR:$dst) 04530 // Pattern complexity = 11 cost = 1 size = 0 04531 if (CN0 == 54) { 04532 N2 = N.getOperand(2); 04533 N3 = N.getOperand(3); 04534 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N2.Val); 04535 bool Match = SelectAddrIdxOnly(N3, CPTmp1, CPTmp2); 04536 if (!Match) { 04537 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N2.Val); 04538 } 04539 if (Match) { 04540 Emit_63(Result, N, PPC::STVXL, CPTmp1, CPTmp2, Chain, N1, N2, N3); 04541 return; 04542 } 04543 } 04544 04545 // Pattern: (intrinsic_void:void 35:iPTR, (imm:i32):$STRM) 04546 // Emits: (DSS:void 0:i32, (imm:i32):$STRM, 0:i32, 0:i32) 04547 // Pattern complexity = 7 cost = 1 size = 0 04548 if (CN0 == 35) { 04549 N2 = N.getOperand(2); 04550 if (N2.getOpcode() == ISD::Constant) { 04551 Emit_64(Result, N, PPC::DSS, Chain, N1, N2); 04552 return; 04553 } 04554 } 04555 04556 // Pattern: (intrinsic_void:void 37:iPTR, GPRC:i32:$rA, GPRC:i32:$rB, (imm:i32):$STRM) 04557 // Emits: (DST:void 0:i32, (imm:i32):$STRM, GPRC:i32:$rA, GPRC:i32:$rB) 04558 // Pattern complexity = 7 cost = 1 size = 0 04559 if (CN0 == 37) { 04560 N2 = N.getOperand(2); 04561 N3 = N.getOperand(3); 04562 N4 = N.getOperand(4); 04563 if (N4.getOpcode() == ISD::Constant && 04564 N2.Val->getValueType(0) == MVT::i32) { 04565 Emit_65(Result, N, PPC::DST, Chain, N1, N2, N3, N4); 04566 return; 04567 } 04568 } 04569 04570 // Pattern: (intrinsic_void:void 40:iPTR, GPRC:i32:$rA, GPRC:i32:$rB, (imm:i32):$STRM) 04571 // Emits: (DST:void 1:i32, (imm:i32):$STRM, GPRC:i32:$rA, GPRC:i32:$rB) 04572 // Pattern complexity = 7 cost = 1 size = 0 04573 if (CN0 == 40) { 04574 N2 = N.getOperand(2); 04575 N3 = N.getOperand(3); 04576 N4 = N.getOperand(4); 04577 if (N4.getOpcode() == ISD::Constant && 04578 N2.Val->getValueType(0) == MVT::i32) { 04579 Emit_66(Result, N, PPC::DST, Chain, N1, N2, N3, N4); 04580 return; 04581 } 04582 } 04583 04584 // Pattern: (intrinsic_void:void 38:iPTR, GPRC:i32:$rA, GPRC:i32:$rB, (imm:i32):$STRM) 04585 // Emits: (DSTST:void 0:i32, (imm:i32):$STRM, GPRC:i32:$rA, GPRC:i32:$rB) 04586 // Pattern complexity = 7 cost = 1 size = 0 04587 if (CN0 == 38) { 04588 N2 = N.getOperand(2); 04589 N3 = N.getOperand(3); 04590 N4 = N.getOperand(4); 04591 if (N4.getOpcode() == ISD::Constant && 04592 N2.Val->getValueType(0) == MVT::i32) { 04593 Emit_65(Result, N, PPC::DSTST, Chain, N1, N2, N3, N4); 04594 return; 04595 } 04596 } 04597 04598 // Pattern: (intrinsic_void:void 39:iPTR, GPRC:i32:$rA, GPRC:i32:$rB, (imm:i32):$STRM) 04599 // Emits: (DSTST:void 1:i32, (imm:i32):$STRM, GPRC:i32:$rA, GPRC:i32:$rB) 04600 // Pattern complexity = 7 cost = 1 size = 0 04601 if (CN0 == 39) { 04602 N2 = N.getOperand(2); 04603 N3 = N.getOperand(3); 04604 N4 = N.getOperand(4); 04605 if (N4.getOpcode() == ISD::Constant && 04606 N2.Val->getValueType(0) == MVT::i32) { 04607 Emit_66(Result, N, PPC::DSTST, Chain, N1, N2, N3, N4); 04608 return; 04609 } 04610 } 04611 04612 // Pattern: (intrinsic_void:void 49:iPTR, VRRC:v4i32:$vB) 04613 // Emits: (MTVSCR:void VRRC:v4i32:$vB) 04614 // Pattern complexity = 5 cost = 1 size = 0 04615 if (CN0 == 49) { 04616 Emit_67(Result, N, PPC::MTVSCR, Chain, N1, N2); 04617 return; 04618 } 04619 04620 // Pattern: (intrinsic_void:void 36:iPTR) 04621 // Emits: (DSS:void 1:i32, 0:i32, 0:i32, 0:i32) 04622 // Pattern complexity = 5 cost = 1 04623 if (CN0 == 36) { 04624 Emit_68(Result, N, PPC::DSS, Chain, N1); 04625 return; 04626 } 04627 } 04628 std::cerr << "Cannot yet select: "; 04629 unsigned iid = cast<ConstantSDNode>(N.getOperand(N.getOperand(0).getValueType() == MVT::Other))->getValue(); 04630 std::cerr << "intrinsic %"<< Intrinsic::getName((Intrinsic::ID)iid); 04631 std::cerr << '\n'; 04632 abort(); 04633 } 04634 04635 void Emit_69(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &CPTmp1, SDOperand &CPTmp2, SDOperand &Chain, SDOperand &N1, SDOperand &N2) NOINLINE { 04636 SDOperand Tmp1(0, 0); 04637 SDOperand Tmp2(0, 0); 04638 SDNode *ResNode = NULL; 04639 SelectionDAG::InsertInFlightSetEntry(InFlightSet, CPTmp1.Val); 04640 SelectionDAG::InsertInFlightSetEntry(InFlightSet, CPTmp2.Val); 04641 Select(Tmp1, CPTmp1); 04642 Select(Tmp2, CPTmp2); 04643 Select(Chain, Chain); 04644 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, CPTmp1.Val); 04645 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, CPTmp2.Val); 04646 ResNode = CurDAG->getTargetNode(Opc0, VT0, MVT::Other, Tmp1, Tmp2, Chain); 04647 Chain = SDOperand(ResNode, 1); 04648 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 04649 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Chain.Val, Chain.ResNo); 04650 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, Chain.Val, Chain.ResNo); 04651 Result = SDOperand(ResNode, N.ResNo); 04652 return; 04653 } 04654 void Emit_70(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &Chain, SDOperand &N1) NOINLINE { 04655 SDNode *ResNode = NULL; 04656 Select(Chain, Chain); 04657 ResNode = CurDAG->getTargetNode(Opc0, VT0, MVT::Other, Chain); 04658 Chain = SDOperand(ResNode, 1); 04659 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 04660 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Chain.Val, Chain.ResNo); 04661 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, Chain.Val, Chain.ResNo); 04662 Result = SDOperand(ResNode, N.ResNo); 04663 return; 04664 } 04665 void Select_intrinsic_w_chain(SDOperand &Result, SDOperand N) { 04666 if (N.ResNo == 1 && N.getValue(0).hasOneUse()) { 04667 SDOperand Dummy = CurDAG->getNode(ISD::HANDLENODE, MVT::Other, N); 04668 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Dummy.Val, 0); 04669 SelectionDAG::InsertISelMapEntry(HandleMap, N.Val, 1, Dummy.Val, 0); 04670 Result = Dummy; 04671 return; 04672 } 04673 SDOperand CPTmp1(0, 0); 04674 SDOperand CPTmp2(0, 0); 04675 SDOperand Chain(0, 0); 04676 SDOperand N1(0, 0); 04677 SDOperand N2(0, 0); 04678 SDOperand Tmp1(0, 0); 04679 SDOperand Tmp2(0, 0); 04680 SDNode *ResNode = NULL; 04681 Chain = N.getOperand(0); 04682 N1 = N.getOperand(1); 04683 if (isa<ConstantSDNode>(N1)) { 04684 int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended(); 04685 04686 // Pattern: (intrinsic_w_chain:v16i8 41:iPTR, xoaddr:iPTR:$src) 04687 // Emits: (LVEBX:v16i8 xoaddr:iPTR:$src) 04688 // Pattern complexity = 11 cost = 1 size = 0 04689 if (CN0 == 41) { 04690 N2 = N.getOperand(2); 04691 bool Match = SelectAddrIdxOnly(N2, CPTmp1, CPTmp2); 04692 if (Match) { 04693 Emit_69(Result, N, PPC::LVEBX, MVT::v16i8, CPTmp1, CPTmp2, Chain, N1, N2); 04694 return; 04695 } 04696 } 04697 04698 // Pattern: (intrinsic_w_chain:v8i16 42:iPTR, xoaddr:iPTR:$src) 04699 // Emits: (LVEHX:v8i16 xoaddr:iPTR:$src) 04700 // Pattern complexity = 11 cost = 1 size = 0 04701 if (CN0 == 42) { 04702 N2 = N.getOperand(2); 04703 bool Match = SelectAddrIdxOnly(N2, CPTmp1, CPTmp2); 04704 if (Match) { 04705 Emit_69(Result, N, PPC::LVEHX, MVT::v8i16, CPTmp1, CPTmp2, Chain, N1, N2); 04706 return; 04707 } 04708 } 04709 04710 // Pattern: (intrinsic_w_chain:v4i32 43:iPTR, xoaddr:iPTR:$src) 04711 // Emits: (LVEWX:v4i32 xoaddr:iPTR:$src) 04712 // Pattern complexity = 11 cost = 1 size = 0 04713 if (CN0 == 43) { 04714 N2 = N.getOperand(2); 04715 bool Match = SelectAddrIdxOnly(N2, CPTmp1, CPTmp2); 04716 if (Match) { 04717 Emit_69(Result, N, PPC::LVEWX, MVT::v4i32, CPTmp1, CPTmp2, Chain, N1, N2); 04718 return; 04719 } 04720 } 04721 04722 // Pattern: (intrinsic_w_chain:v4i32 46:iPTR, xoaddr:iPTR:$src) 04723 // Emits: (LVX:v4i32 xoaddr:iPTR:$src) 04724 // Pattern complexity = 11 cost = 1 size = 0 04725 if (CN0 == 46) { 04726 N2 = N.getOperand(2); 04727 bool Match = SelectAddrIdxOnly(N2, CPTmp1, CPTmp2); 04728 if (Match) { 04729 Emit_69(Result, N, PPC::LVX, MVT::v4i32, CPTmp1, CPTmp2, Chain, N1, N2); 04730 return; 04731 } 04732 } 04733 04734 // Pattern: (intrinsic_w_chain:v4i32 47:iPTR, xoaddr:iPTR:$src) 04735 // Emits: (LVXL:v4i32 xoaddr:iPTR:$src) 04736 // Pattern complexity = 11 cost = 1 size = 0 04737 if (CN0 == 47) { 04738 N2 = N.getOperand(2); 04739 bool Match = SelectAddrIdxOnly(N2, CPTmp1, CPTmp2); 04740 if (Match) { 04741 Emit_69(Result, N, PPC::LVXL, MVT::v4i32, CPTmp1, CPTmp2, Chain, N1, N2); 04742 return; 04743 } 04744 } 04745 04746 // Pattern: (intrinsic_w_chain:v8i16 48:iPTR) 04747 // Emits: (MFVSCR:v8i16) 04748 // Pattern complexity = 5 cost = 1 04749 if (CN0 == 48) { 04750 Emit_70(Result, N, PPC::MFVSCR, MVT::v8i16, Chain, N1); 04751 return; 04752 } 04753 } 04754 std::cerr << "Cannot yet select: "; 04755 unsigned iid = cast<ConstantSDNode>(N.getOperand(N.getOperand(0).getValueType() == MVT::Other))->getValue(); 04756 std::cerr << "intrinsic %"<< Intrinsic::getName((Intrinsic::ID)iid); 04757 std::cerr << '\n'; 04758 abort(); 04759 } 04760 04761 void Emit_71(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &CPTmp1, SDOperand &CPTmp2, SDOperand &N0, SDOperand &N1) NOINLINE { 04762 SDOperand Tmp1(0, 0); 04763 SDOperand Tmp2(0, 0); 04764 SDNode *ResNode = NULL; 04765 SelectionDAG::InsertInFlightSetEntry(InFlightSet, CPTmp1.Val); 04766 SelectionDAG::InsertInFlightSetEntry(InFlightSet, CPTmp2.Val); 04767 Select(Tmp1, CPTmp1); 04768 Select(Tmp2, CPTmp2); 04769 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, CPTmp1.Val); 04770 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, CPTmp2.Val); 04771 if (N.Val->hasOneUse()) { 04772 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1, Tmp2); 04773 } else { 04774 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1, Tmp2); 04775 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04776 Result = SDOperand(ResNode, 0); 04777 } 04778 return; 04779 } 04780 void Emit_72(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N2) NOINLINE { 04781 SDOperand Tmp1(0, 0); 04782 SDOperand Tmp2(0, 0); 04783 SDNode *ResNode = NULL; 04784 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 04785 Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N2)->getValue()), MVT::i32); 04786 Select(Tmp2, N1); 04787 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 04788 if (N.Val->hasOneUse()) { 04789 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1, Tmp2); 04790 } else { 04791 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1, Tmp2); 04792 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04793 Result = SDOperand(ResNode, 0); 04794 } 04795 return; 04796 } 04797 void Emit_73(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N2, SDOperand &N3) NOINLINE { 04798 SDOperand Tmp1(0, 0); 04799 SDOperand Tmp2(0, 0); 04800 SDOperand Tmp3(0, 0); 04801 SDNode *ResNode = NULL; 04802 N1 = N.getOperand(1); 04803 N2 = N.getOperand(2); 04804 N3 = N.getOperand(3); 04805 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 04806 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N2.Val); 04807 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N3.Val); 04808 Select(Tmp1, N1); 04809 Select(Tmp2, N2); 04810 Select(Tmp3, N3); 04811 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 04812 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N2.Val); 04813 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N3.Val); 04814 if (N.Val->hasOneUse()) { 04815 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1, Tmp2, Tmp3); 04816 } else { 04817 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1, Tmp2, Tmp3); 04818 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04819 Result = SDOperand(ResNode, 0); 04820 } 04821 return; 04822 } 04823 void Emit_74(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N2) NOINLINE { 04824 SDOperand Tmp1(0, 0); 04825 SDOperand Tmp2(0, 0); 04826 SDNode *ResNode = NULL; 04827 N1 = N.getOperand(1); 04828 N2 = N.getOperand(2); 04829 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 04830 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N2.Val); 04831 Select(Tmp1, N1); 04832 Select(Tmp2, N2); 04833 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 04834 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N2.Val); 04835 if (N.Val->hasOneUse()) { 04836 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1, Tmp2); 04837 } else { 04838 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1, Tmp2); 04839 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04840 Result = SDOperand(ResNode, 0); 04841 } 04842 return; 04843 } 04844 void Emit_75(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 04845 SDOperand Tmp1(0, 0); 04846 SDNode *ResNode = NULL; 04847 N1 = N.getOperand(1); 04848 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 04849 Select(Tmp1, N1); 04850 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 04851 if (N.Val->hasOneUse()) { 04852 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1); 04853 } else { 04854 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1); 04855 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 04856 Result = SDOperand(ResNode, 0); 04857 } 04858 return; 04859 } 04860 void Select_intrinsic_wo_chain(SDOperand &Result, SDOperand N) { 04861 SDOperand CPTmp1(0, 0); 04862 SDOperand CPTmp2(0, 0); 04863 SDOperand N0(0, 0); 04864 SDOperand N1(0, 0); 04865 SDOperand N2(0, 0); 04866 SDOperand N3(0, 0); 04867 SDOperand Tmp1(0, 0); 04868 SDOperand Tmp2(0, 0); 04869 SDOperand Tmp3(0, 0); 04870 SDNode *ResNode = NULL; 04871 N0 = N.getOperand(0); 04872 if (isa<ConstantSDNode>(N0)) { 04873 int64_t CN0 = cast<ConstantSDNode>(N0)->getSignExtended(); 04874 04875 // Pattern: (intrinsic_wo_chain:v16i8 44:iPTR, xoaddr:iPTR:$src) 04876 // Emits: (LVSL:v16i8 xoaddr:iPTR:$src) 04877 // Pattern complexity = 11 cost = 1 size = 0 04878 if (CN0 == 44) { 04879 N1 = N.getOperand(1); 04880 bool Match = SelectAddrIdxOnly(N1, CPTmp1, CPTmp2); 04881 if (Match) { 04882 Emit_71(Result, N, PPC::LVSL, MVT::v16i8, CPTmp1, CPTmp2, N0, N1); 04883 return; 04884 } 04885 } 04886 04887 // Pattern: (intrinsic_wo_chain:v16i8 45:iPTR, xoaddr:iPTR:$src) 04888 // Emits: (LVSR:v16i8 xoaddr:iPTR:$src) 04889 // Pattern complexity = 11 cost = 1 size = 0 04890 if (CN0 == 45) { 04891 N1 = N.getOperand(1); 04892 bool Match = SelectAddrIdxOnly(N1, CPTmp1, CPTmp2); 04893 if (Match) { 04894 Emit_71(Result, N, PPC::LVSR, MVT::v16i8, CPTmp1, CPTmp2, N0, N1); 04895 return; 04896 } 04897 } 04898 04899 // Pattern: (intrinsic_wo_chain:v4f32 68:iPTR, VRRC:v4i32:$vB, (imm:i32):$UIMM) 04900 // Emits: (VCFSX:v4f32 (imm:i32):$UIMM, VRRC:v4i32:$vB) 04901 // Pattern complexity = 7 cost = 1 size = 0 04902 if (CN0 == 68) { 04903 N1 = N.getOperand(1); 04904 N2 = N.getOperand(2); 04905 if (N2.getOpcode() == ISD::Constant) { 04906 Emit_72(Result, N, PPC::VCFSX, MVT::v4f32, N0, N1, N2); 04907 return; 04908 } 04909 } 04910 04911 // Pattern: (intrinsic_wo_chain:v4f32 69:iPTR, VRRC:v4i32:$vB, (imm:i32):$UIMM) 04912 // Emits: (VCFUX:v4f32 (imm:i32):$UIMM, VRRC:v4i32:$vB) 04913 // Pattern complexity = 7 cost = 1 size = 0 04914 if (CN0 == 69) { 04915 N1 = N.getOperand(1); 04916 N2 = N.getOperand(2); 04917 if (N2.getOpcode() == ISD::Constant) { 04918 Emit_72(Result, N, PPC::VCFUX, MVT::v4f32, N0, N1, N2); 04919 return; 04920 } 04921 } 04922 04923 // Pattern: (intrinsic_wo_chain:v4i32 96:iPTR, VRRC:v4f32:$vB, (imm:i32):$UIMM) 04924 // Emits: (VCTSXS:v4i32 (imm:i32):$UIMM, VRRC:v4f32:$vB) 04925 // Pattern complexity = 7 cost = 1 size = 0 04926 if (CN0 == 96) { 04927 N1 = N.getOperand(1); 04928 N2 = N.getOperand(2); 04929 if (N2.getOpcode() == ISD::Constant) { 04930 Emit_72(Result, N, PPC::VCTSXS, MVT::v4i32, N0, N1, N2); 04931 return; 04932 } 04933 } 04934 04935 // Pattern: (intrinsic_wo_chain:v4i32 97:iPTR, VRRC:v4f32:$vB, (imm:i32):$UIMM) 04936 // Emits: (VCTUXS:v4i32 (imm:i32):$UIMM, VRRC:v4f32:$vB) 04937 // Pattern complexity = 7 cost = 1 size = 0 04938 if (CN0 == 97) { 04939 N1 = N.getOperand(1); 04940 N2 = N.getOperand(2); 04941 if (N2.getOpcode() == ISD::Constant) { 04942 Emit_72(Result, N, PPC::VCTUXS, MVT::v4i32, N0, N1, N2); 04943 return; 04944 } 04945 } 04946 04947 // Pattern: (intrinsic_wo_chain:v8i16 108:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v8i16:$vC) 04948 // Emits: (VMHADDSHS:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v8i16:$vC) 04949 // Pattern complexity = 5 cost = 1 size = 0 04950 if (CN0 == 108) { 04951 Emit_73(Result, N, PPC::VMHADDSHS, MVT::v8i16, N0, N1, N2, N3); 04952 return; 04953 } 04954 04955 // Pattern: (intrinsic_wo_chain:v8i16 109:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v8i16:$vC) 04956 // Emits: (VMHRADDSHS:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v8i16:$vC) 04957 // Pattern complexity = 5 cost = 1 size = 0 04958 if (CN0 == 109) { 04959 Emit_73(Result, N, PPC::VMHRADDSHS, MVT::v8i16, N0, N1, N2, N3); 04960 return; 04961 } 04962 04963 // Pattern: (intrinsic_wo_chain:v8i16 117:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v8i16:$vC) 04964 // Emits: (VMLADDUHM:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v8i16:$vC) 04965 // Pattern complexity = 5 cost = 1 size = 0 04966 if (CN0 == 117) { 04967 Emit_73(Result, N, PPC::VMLADDUHM, MVT::v8i16, N0, N1, N2, N3); 04968 return; 04969 } 04970 04971 // Pattern: (intrinsic_wo_chain:v4i32 133:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB, VRRC:v16i8:$vC) 04972 // Emits: (VPERM:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, VRRC:v16i8:$vC) 04973 // Pattern complexity = 5 cost = 1 size = 0 04974 if (CN0 == 133) { 04975 Emit_73(Result, N, PPC::VPERM, MVT::v4i32, N0, N1, N2, N3); 04976 return; 04977 } 04978 04979 // Pattern: (intrinsic_wo_chain:v4i32 150:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB, VRRC:v4i32:$vC) 04980 // Emits: (VSEL:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, VRRC:v4i32:$vC) 04981 // Pattern complexity = 5 cost = 1 size = 0 04982 if (CN0 == 150) { 04983 Emit_73(Result, N, PPC::VSEL, MVT::v4i32, N0, N1, N2, N3); 04984 return; 04985 } 04986 04987 // Pattern: (intrinsic_wo_chain:v4i32 55:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04988 // Emits: (VADDCUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 04989 // Pattern complexity = 5 cost = 1 size = 0 04990 if (CN0 == 55) { 04991 Emit_74(Result, N, PPC::VADDCUW, MVT::v4i32, N0, N1, N2); 04992 return; 04993 } 04994 04995 // Pattern: (intrinsic_wo_chain:v16i8 56:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04996 // Emits: (VADDSBS:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 04997 // Pattern complexity = 5 cost = 1 size = 0 04998 if (CN0 == 56) { 04999 Emit_74(Result, N, PPC::VADDSBS, MVT::v16i8, N0, N1, N2); 05000 return; 05001 } 05002 05003 // Pattern: (intrinsic_wo_chain:v8i16 57:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05004 // Emits: (VADDSHS:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05005 // Pattern complexity = 5 cost = 1 size = 0 05006 if (CN0 == 57) { 05007 Emit_74(Result, N, PPC::VADDSHS, MVT::v8i16, N0, N1, N2); 05008 return; 05009 } 05010 05011 // Pattern: (intrinsic_wo_chain:v4i32 58:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05012 // Emits: (VADDSWS:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05013 // Pattern complexity = 5 cost = 1 size = 0 05014 if (CN0 == 58) { 05015 Emit_74(Result, N, PPC::VADDSWS, MVT::v4i32, N0, N1, N2); 05016 return; 05017 } 05018 05019 // Pattern: (intrinsic_wo_chain:v16i8 59:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05020 // Emits: (VADDUBS:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05021 // Pattern complexity = 5 cost = 1 size = 0 05022 if (CN0 == 59) { 05023 Emit_74(Result, N, PPC::VADDUBS, MVT::v16i8, N0, N1, N2); 05024 return; 05025 } 05026 05027 // Pattern: (intrinsic_wo_chain:v8i16 60:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05028 // Emits: (VADDUHS:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05029 // Pattern complexity = 5 cost = 1 size = 0 05030 if (CN0 == 60) { 05031 Emit_74(Result, N, PPC::VADDUHS, MVT::v8i16, N0, N1, N2); 05032 return; 05033 } 05034 05035 // Pattern: (intrinsic_wo_chain:v4i32 61:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05036 // Emits: (VADDUWS:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05037 // Pattern complexity = 5 cost = 1 size = 0 05038 if (CN0 == 61) { 05039 Emit_74(Result, N, PPC::VADDUWS, MVT::v4i32, N0, N1, N2); 05040 return; 05041 } 05042 05043 // Pattern: (intrinsic_wo_chain:v4f32 98:iPTR, VRRC:v4f32:$vB) 05044 // Emits: (VEXPTEFP:v4f32 VRRC:v4f32:$vB) 05045 // Pattern complexity = 5 cost = 1 size = 0 05046 if (CN0 == 98) { 05047 Emit_75(Result, N, PPC::VEXPTEFP, MVT::v4f32, N0, N1); 05048 return; 05049 } 05050 05051 // Pattern: (intrinsic_wo_chain:v4f32 99:iPTR, VRRC:v4f32:$vB) 05052 // Emits: (VLOGEFP:v4f32 VRRC:v4f32:$vB) 05053 // Pattern complexity = 5 cost = 1 size = 0 05054 if (CN0 == 99) { 05055 Emit_75(Result, N, PPC::VLOGEFP, MVT::v4f32, N0, N1); 05056 return; 05057 } 05058 05059 // Pattern: (intrinsic_wo_chain:v16i8 62:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05060 // Emits: (VAVGSB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05061 // Pattern complexity = 5 cost = 1 size = 0 05062 if (CN0 == 62) { 05063 Emit_74(Result, N, PPC::VAVGSB, MVT::v16i8, N0, N1, N2); 05064 return; 05065 } 05066 05067 // Pattern: (intrinsic_wo_chain:v8i16 63:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05068 // Emits: (VAVGSH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05069 // Pattern complexity = 5 cost = 1 size = 0 05070 if (CN0 == 63) { 05071 Emit_74(Result, N, PPC::VAVGSH, MVT::v8i16, N0, N1, N2); 05072 return; 05073 } 05074 05075 // Pattern: (intrinsic_wo_chain:v4i32 64:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05076 // Emits: (VAVGSW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05077 // Pattern complexity = 5 cost = 1 size = 0 05078 if (CN0 == 64) { 05079 Emit_74(Result, N, PPC::VAVGSW, MVT::v4i32, N0, N1, N2); 05080 return; 05081 } 05082 05083 // Pattern: (intrinsic_wo_chain:v16i8 65:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05084 // Emits: (VAVGUB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05085 // Pattern complexity = 5 cost = 1 size = 0 05086 if (CN0 == 65) { 05087 Emit_74(Result, N, PPC::VAVGUB, MVT::v16i8, N0, N1, N2); 05088 return; 05089 } 05090 05091 // Pattern: (intrinsic_wo_chain:v8i16 66:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05092 // Emits: (VAVGUH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05093 // Pattern complexity = 5 cost = 1 size = 0 05094 if (CN0 == 66) { 05095 Emit_74(Result, N, PPC::VAVGUH, MVT::v8i16, N0, N1, N2); 05096 return; 05097 } 05098 05099 // Pattern: (intrinsic_wo_chain:v4i32 67:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05100 // Emits: (VAVGUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05101 // Pattern complexity = 5 cost = 1 size = 0 05102 if (CN0 == 67) { 05103 Emit_74(Result, N, PPC::VAVGUW, MVT::v4i32, N0, N1, N2); 05104 return; 05105 } 05106 05107 // Pattern: (intrinsic_wo_chain:v4f32 101:iPTR, VRRC:v4f32:$vA, VRRC:v4f32:$vB) 05108 // Emits: (VMAXFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 05109 // Pattern complexity = 5 cost = 1 size = 0 05110 if (CN0 == 101) { 05111 Emit_74(Result, N, PPC::VMAXFP, MVT::v4f32, N0, N1, N2); 05112 return; 05113 } 05114 05115 // Pattern: (intrinsic_wo_chain:v16i8 102:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05116 // Emits: (VMAXSB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05117 // Pattern complexity = 5 cost = 1 size = 0 05118 if (CN0 == 102) { 05119 Emit_74(Result, N, PPC::VMAXSB, MVT::v16i8, N0, N1, N2); 05120 return; 05121 } 05122 05123 // Pattern: (intrinsic_wo_chain:v8i16 103:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05124 // Emits: (VMAXSH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05125 // Pattern complexity = 5 cost = 1 size = 0 05126 if (CN0 == 103) { 05127 Emit_74(Result, N, PPC::VMAXSH, MVT::v8i16, N0, N1, N2); 05128 return; 05129 } 05130 05131 // Pattern: (intrinsic_wo_chain:v4i32 104:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05132 // Emits: (VMAXSW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05133 // Pattern complexity = 5 cost = 1 size = 0 05134 if (CN0 == 104) { 05135 Emit_74(Result, N, PPC::VMAXSW, MVT::v4i32, N0, N1, N2); 05136 return; 05137 } 05138 05139 // Pattern: (intrinsic_wo_chain:v16i8 105:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05140 // Emits: (VMAXUB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05141 // Pattern complexity = 5 cost = 1 size = 0 05142 if (CN0 == 105) { 05143 Emit_74(Result, N, PPC::VMAXUB, MVT::v16i8, N0, N1, N2); 05144 return; 05145 } 05146 05147 // Pattern: (intrinsic_wo_chain:v8i16 106:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05148 // Emits: (VMAXUH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05149 // Pattern complexity = 5 cost = 1 size = 0 05150 if (CN0 == 106) { 05151 Emit_74(Result, N, PPC::VMAXUH, MVT::v8i16, N0, N1, N2); 05152 return; 05153 } 05154 05155 // Pattern: (intrinsic_wo_chain:v4i32 107:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05156 // Emits: (VMAXUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05157 // Pattern complexity = 5 cost = 1 size = 0 05158 if (CN0 == 107) { 05159 Emit_74(Result, N, PPC::VMAXUW, MVT::v4i32, N0, N1, N2); 05160 return; 05161 } 05162 05163 // Pattern: (intrinsic_wo_chain:v4f32 110:iPTR, VRRC:v4f32:$vA, VRRC:v4f32:$vB) 05164 // Emits: (VMINFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB) 05165 // Pattern complexity = 5 cost = 1 size = 0 05166 if (CN0 == 110) { 05167 Emit_74(Result, N, PPC::VMINFP, MVT::v4f32, N0, N1, N2); 05168 return; 05169 } 05170 05171 // Pattern: (intrinsic_wo_chain:v16i8 111:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05172 // Emits: (VMINSB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05173 // Pattern complexity = 5 cost = 1 size = 0 05174 if (CN0 == 111) { 05175 Emit_74(Result, N, PPC::VMINSB, MVT::v16i8, N0, N1, N2); 05176 return; 05177 } 05178 05179 // Pattern: (intrinsic_wo_chain:v8i16 112:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05180 // Emits: (VMINSH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05181 // Pattern complexity = 5 cost = 1 size = 0 05182 if (CN0 == 112) { 05183 Emit_74(Result, N, PPC::VMINSH, MVT::v8i16, N0, N1, N2); 05184 return; 05185 } 05186 05187 // Pattern: (intrinsic_wo_chain:v4i32 113:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05188 // Emits: (VMINSW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05189 // Pattern complexity = 5 cost = 1 size = 0 05190 if (CN0 == 113) { 05191 Emit_74(Result, N, PPC::VMINSW, MVT::v4i32, N0, N1, N2); 05192 return; 05193 } 05194 05195 // Pattern: (intrinsic_wo_chain:v16i8 114:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05196 // Emits: (VMINUB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05197 // Pattern complexity = 5 cost = 1 size = 0 05198 if (CN0 == 114) { 05199 Emit_74(Result, N, PPC::VMINUB, MVT::v16i8, N0, N1, N2); 05200 return; 05201 } 05202 05203 // Pattern: (intrinsic_wo_chain:v8i16 115:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05204 // Emits: (VMINUH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05205 // Pattern complexity = 5 cost = 1 size = 0 05206 if (CN0 == 115) { 05207 Emit_74(Result, N, PPC::VMINUH, MVT::v8i16, N0, N1, N2); 05208 return; 05209 } 05210 05211 // Pattern: (intrinsic_wo_chain:v4i32 116:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05212 // Emits: (VMINUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05213 // Pattern complexity = 5 cost = 1 size = 0 05214 if (CN0 == 116) { 05215 Emit_74(Result, N, PPC::VMINUW, MVT::v4i32, N0, N1, N2); 05216 return; 05217 } 05218 05219 // Pattern: (intrinsic_wo_chain:v4i32 118:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB, VRRC:v4i32:$vC) 05220 // Emits: (VMSUMMBM:v4i32 VRRC:v16i8:$vA, VRRC:v16i8:$vB, VRRC:v4i32:$vC) 05221 // Pattern complexity = 5 cost = 1 size = 0 05222 if (CN0 == 118) { 05223 Emit_73(Result, N, PPC::VMSUMMBM, MVT::v4i32, N0, N1, N2, N3); 05224 return; 05225 } 05226 05227 // Pattern: (intrinsic_wo_chain:v4i32 119:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC) 05228 // Emits: (VMSUMSHM:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC) 05229 // Pattern complexity = 5 cost = 1 size = 0 05230 if (CN0 == 119) { 05231 Emit_73(Result, N, PPC::VMSUMSHM, MVT::v4i32, N0, N1, N2, N3); 05232 return; 05233 } 05234 05235 // Pattern: (intrinsic_wo_chain:v4i32 120:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC) 05236 // Emits: (VMSUMSHS:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC) 05237 // Pattern complexity = 5 cost = 1 size = 0 05238 if (CN0 == 120) { 05239 Emit_73(Result, N, PPC::VMSUMSHS, MVT::v4i32, N0, N1, N2, N3); 05240 return; 05241 } 05242 05243 // Pattern: (intrinsic_wo_chain:v4i32 121:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB, VRRC:v4i32:$vC) 05244 // Emits: (VMSUMUBM:v4i32 VRRC:v16i8:$vA, VRRC:v16i8:$vB, VRRC:v4i32:$vC) 05245 // Pattern complexity = 5 cost = 1 size = 0 05246 if (CN0 == 121) { 05247 Emit_73(Result, N, PPC::VMSUMUBM, MVT::v4i32, N0, N1, N2, N3); 05248 return; 05249 } 05250 05251 // Pattern: (intrinsic_wo_chain:v4i32 122:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC) 05252 // Emits: (VMSUMUHM:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC) 05253 // Pattern complexity = 5 cost = 1 size = 0 05254 if (CN0 == 122) { 05255 Emit_73(Result, N, PPC::VMSUMUHM, MVT::v4i32, N0, N1, N2, N3); 05256 return; 05257 } 05258 05259 // Pattern: (intrinsic_wo_chain:v4i32 123:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC) 05260 // Emits: (VMSUMUHS:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC) 05261 // Pattern complexity = 5 cost = 1 size = 0 05262 if (CN0 == 123) { 05263 Emit_73(Result, N, PPC::VMSUMUHS, MVT::v4i32, N0, N1, N2, N3); 05264 return; 05265 } 05266 05267 // Pattern: (intrinsic_wo_chain:v8i16 124:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05268 // Emits: (VMULESB:v8i16 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05269 // Pattern complexity = 5 cost = 1 size = 0 05270 if (CN0 == 124) { 05271 Emit_74(Result, N, PPC::VMULESB, MVT::v8i16, N0, N1, N2); 05272 return; 05273 } 05274 05275 // Pattern: (intrinsic_wo_chain:v4i32 125:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05276 // Emits: (VMULESH:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05277 // Pattern complexity = 5 cost = 1 size = 0 05278 if (CN0 == 125) { 05279 Emit_74(Result, N, PPC::VMULESH, MVT::v4i32, N0, N1, N2); 05280 return; 05281 } 05282 05283 // Pattern: (intrinsic_wo_chain:v8i16 126:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05284 // Emits: (VMULEUB:v8i16 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05285 // Pattern complexity = 5 cost = 1 size = 0 05286 if (CN0 == 126) { 05287 Emit_74(Result, N, PPC::VMULEUB, MVT::v8i16, N0, N1, N2); 05288 return; 05289 } 05290 05291 // Pattern: (intrinsic_wo_chain:v4i32 127:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05292 // Emits: (VMULEUH:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05293 // Pattern complexity = 5 cost = 1 size = 0 05294 if (CN0 == 127) { 05295 Emit_74(Result, N, PPC::VMULEUH, MVT::v4i32, N0, N1, N2); 05296 return; 05297 } 05298 05299 // Pattern: (intrinsic_wo_chain:v8i16 128:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05300 // Emits: (VMULOSB:v8i16 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05301 // Pattern complexity = 5 cost = 1 size = 0 05302 if (CN0 == 128) { 05303 Emit_74(Result, N, PPC::VMULOSB, MVT::v8i16, N0, N1, N2); 05304 return; 05305 } 05306 05307 // Pattern: (intrinsic_wo_chain:v4i32 129:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05308 // Emits: (VMULOSH:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05309 // Pattern complexity = 5 cost = 1 size = 0 05310 if (CN0 == 129) { 05311 Emit_74(Result, N, PPC::VMULOSH, MVT::v4i32, N0, N1, N2); 05312 return; 05313 } 05314 05315 // Pattern: (intrinsic_wo_chain:v8i16 130:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05316 // Emits: (VMULOUB:v8i16 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05317 // Pattern complexity = 5 cost = 1 size = 0 05318 if (CN0 == 130) { 05319 Emit_74(Result, N, PPC::VMULOUB, MVT::v8i16, N0, N1, N2); 05320 return; 05321 } 05322 05323 // Pattern: (intrinsic_wo_chain:v4i32 131:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05324 // Emits: (VMULOUH:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05325 // Pattern complexity = 5 cost = 1 size = 0 05326 if (CN0 == 131) { 05327 Emit_74(Result, N, PPC::VMULOUH, MVT::v4i32, N0, N1, N2); 05328 return; 05329 } 05330 05331 // Pattern: (intrinsic_wo_chain:v4f32 141:iPTR, VRRC:v4f32:$vB) 05332 // Emits: (VREFP:v4f32 VRRC:v4f32:$vB) 05333 // Pattern complexity = 5 cost = 1 size = 0 05334 if (CN0 == 141) { 05335 Emit_75(Result, N, PPC::VREFP, MVT::v4f32, N0, N1); 05336 return; 05337 } 05338 05339 // Pattern: (intrinsic_wo_chain:v4f32 142:iPTR, VRRC:v4f32:$vB) 05340 // Emits: (VRFIM:v4f32 VRRC:v4f32:$vB) 05341 // Pattern complexity = 5 cost = 1 size = 0 05342 if (CN0 == 142) { 05343 Emit_75(Result, N, PPC::VRFIM, MVT::v4f32, N0, N1); 05344 return; 05345 } 05346 05347 // Pattern: (intrinsic_wo_chain:v4f32 143:iPTR, VRRC:v4f32:$vB) 05348 // Emits: (VRFIN:v4f32 VRRC:v4f32:$vB) 05349 // Pattern complexity = 5 cost = 1 size = 0 05350 if (CN0 == 143) { 05351 Emit_75(Result, N, PPC::VRFIN, MVT::v4f32, N0, N1); 05352 return; 05353 } 05354 05355 // Pattern: (intrinsic_wo_chain:v4f32 144:iPTR, VRRC:v4f32:$vB) 05356 // Emits: (VRFIP:v4f32 VRRC:v4f32:$vB) 05357 // Pattern complexity = 5 cost = 1 size = 0 05358 if (CN0 == 144) { 05359 Emit_75(Result, N, PPC::VRFIP, MVT::v4f32, N0, N1); 05360 return; 05361 } 05362 05363 // Pattern: (intrinsic_wo_chain:v4f32 145:iPTR, VRRC:v4f32:$vB) 05364 // Emits: (VRFIZ:v4f32 VRRC:v4f32:$vB) 05365 // Pattern complexity = 5 cost = 1 size = 0 05366 if (CN0 == 145) { 05367 Emit_75(Result, N, PPC::VRFIZ, MVT::v4f32, N0, N1); 05368 return; 05369 } 05370 05371 // Pattern: (intrinsic_wo_chain:v4f32 149:iPTR, VRRC:v4f32:$vB) 05372 // Emits: (VRSQRTEFP:v4f32 VRRC:v4f32:$vB) 05373 // Pattern complexity = 5 cost = 1 size = 0 05374 if (CN0 == 149) { 05375 Emit_75(Result, N, PPC::VRSQRTEFP, MVT::v4f32, N0, N1); 05376 return; 05377 } 05378 05379 // Pattern: (intrinsic_wo_chain:v4i32 164:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05380 // Emits: (VSUBCUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05381 // Pattern complexity = 5 cost = 1 size = 0 05382 if (CN0 == 164) { 05383 Emit_74(Result, N, PPC::VSUBCUW, MVT::v4i32, N0, N1, N2); 05384 return; 05385 } 05386 05387 // Pattern: (intrinsic_wo_chain:v16i8 165:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05388 // Emits: (VSUBSBS:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05389 // Pattern complexity = 5 cost = 1 size = 0 05390 if (CN0 == 165) { 05391 Emit_74(Result, N, PPC::VSUBSBS, MVT::v16i8, N0, N1, N2); 05392 return; 05393 } 05394 05395 // Pattern: (intrinsic_wo_chain:v8i16 166:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05396 // Emits: (VSUBSHS:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05397 // Pattern complexity = 5 cost = 1 size = 0 05398 if (CN0 == 166) { 05399 Emit_74(Result, N, PPC::VSUBSHS, MVT::v8i16, N0, N1, N2); 05400 return; 05401 } 05402 05403 // Pattern: (intrinsic_wo_chain:v4i32 167:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05404 // Emits: (VSUBSWS:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05405 // Pattern complexity = 5 cost = 1 size = 0 05406 if (CN0 == 167) { 05407 Emit_74(Result, N, PPC::VSUBSWS, MVT::v4i32, N0, N1, N2); 05408 return; 05409 } 05410 05411 // Pattern: (intrinsic_wo_chain:v16i8 168:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05412 // Emits: (VSUBUBS:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05413 // Pattern complexity = 5 cost = 1 size = 0 05414 if (CN0 == 168) { 05415 Emit_74(Result, N, PPC::VSUBUBS, MVT::v16i8, N0, N1, N2); 05416 return; 05417 } 05418 05419 // Pattern: (intrinsic_wo_chain:v8i16 169:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05420 // Emits: (VSUBUHS:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05421 // Pattern complexity = 5 cost = 1 size = 0 05422 if (CN0 == 169) { 05423 Emit_74(Result, N, PPC::VSUBUHS, MVT::v8i16, N0, N1, N2); 05424 return; 05425 } 05426 05427 // Pattern: (intrinsic_wo_chain:v4i32 170:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05428 // Emits: (VSUBUWS:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05429 // Pattern complexity = 5 cost = 1 size = 0 05430 if (CN0 == 170) { 05431 Emit_74(Result, N, PPC::VSUBUWS, MVT::v4i32, N0, N1, N2); 05432 return; 05433 } 05434 05435 // Pattern: (intrinsic_wo_chain:v4i32 175:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05436 // Emits: (VSUMSWS:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05437 // Pattern complexity = 5 cost = 1 size = 0 05438 if (CN0 == 175) { 05439 Emit_74(Result, N, PPC::VSUMSWS, MVT::v4i32, N0, N1, N2); 05440 return; 05441 } 05442 05443 // Pattern: (intrinsic_wo_chain:v4i32 171:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05444 // Emits: (VSUM2SWS:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05445 // Pattern complexity = 5 cost = 1 size = 0 05446 if (CN0 == 171) { 05447 Emit_74(Result, N, PPC::VSUM2SWS, MVT::v4i32, N0, N1, N2); 05448 return; 05449 } 05450 05451 // Pattern: (intrinsic_wo_chain:v4i32 172:iPTR, VRRC:v16i8:$vA, VRRC:v4i32:$vB) 05452 // Emits: (VSUM4SBS:v4i32 VRRC:v16i8:$vA, VRRC:v4i32:$vB) 05453 // Pattern complexity = 5 cost = 1 size = 0 05454 if (CN0 == 172) { 05455 Emit_74(Result, N, PPC::VSUM4SBS, MVT::v4i32, N0, N1, N2); 05456 return; 05457 } 05458 05459 // Pattern: (intrinsic_wo_chain:v4i32 173:iPTR, VRRC:v8i16:$vA, VRRC:v4i32:$vB) 05460 // Emits: (VSUM4SHS:v4i32 VRRC:v8i16:$vA, VRRC:v4i32:$vB) 05461 // Pattern complexity = 5 cost = 1 size = 0 05462 if (CN0 == 173) { 05463 Emit_74(Result, N, PPC::VSUM4SHS, MVT::v4i32, N0, N1, N2); 05464 return; 05465 } 05466 05467 // Pattern: (intrinsic_wo_chain:v4i32 174:iPTR, VRRC:v16i8:$vA, VRRC:v4i32:$vB) 05468 // Emits: (VSUM4UBS:v4i32 VRRC:v16i8:$vA, VRRC:v4i32:$vB) 05469 // Pattern complexity = 5 cost = 1 size = 0 05470 if (CN0 == 174) { 05471 Emit_74(Result, N, PPC::VSUM4UBS, MVT::v4i32, N0, N1, N2); 05472 return; 05473 } 05474 05475 // Pattern: (intrinsic_wo_chain:v16i8 146:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05476 // Emits: (VRLB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05477 // Pattern complexity = 5 cost = 1 size = 0 05478 if (CN0 == 146) { 05479 Emit_74(Result, N, PPC::VRLB, MVT::v16i8, N0, N1, N2); 05480 return; 05481 } 05482 05483 // Pattern: (intrinsic_wo_chain:v8i16 147:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05484 // Emits: (VRLH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05485 // Pattern complexity = 5 cost = 1 size = 0 05486 if (CN0 == 147) { 05487 Emit_74(Result, N, PPC::VRLH, MVT::v8i16, N0, N1, N2); 05488 return; 05489 } 05490 05491 // Pattern: (intrinsic_wo_chain:v4i32 148:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05492 // Emits: (VRLW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05493 // Pattern complexity = 5 cost = 1 size = 0 05494 if (CN0 == 148) { 05495 Emit_74(Result, N, PPC::VRLW, MVT::v4i32, N0, N1, N2); 05496 return; 05497 } 05498 05499 // Pattern: (intrinsic_wo_chain:v4i32 151:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05500 // Emits: (VSL:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05501 // Pattern complexity = 5 cost = 1 size = 0 05502 if (CN0 == 151) { 05503 Emit_74(Result, N, PPC::VSL, MVT::v4i32, N0, N1, N2); 05504 return; 05505 } 05506 05507 // Pattern: (intrinsic_wo_chain:v4i32 154:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05508 // Emits: (VSLO:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05509 // Pattern complexity = 5 cost = 1 size = 0 05510 if (CN0 == 154) { 05511 Emit_74(Result, N, PPC::VSLO, MVT::v4i32, N0, N1, N2); 05512 return; 05513 } 05514 05515 // Pattern: (intrinsic_wo_chain:v16i8 152:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05516 // Emits: (VSLB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05517 // Pattern complexity = 5 cost = 1 size = 0 05518 if (CN0 == 152) { 05519 Emit_74(Result, N, PPC::VSLB, MVT::v16i8, N0, N1, N2); 05520 return; 05521 } 05522 05523 // Pattern: (intrinsic_wo_chain:v8i16 153:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05524 // Emits: (VSLH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05525 // Pattern complexity = 5 cost = 1 size = 0 05526 if (CN0 == 153) { 05527 Emit_74(Result, N, PPC::VSLH, MVT::v8i16, N0, N1, N2); 05528 return; 05529 } 05530 05531 // Pattern: (intrinsic_wo_chain:v4i32 155:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05532 // Emits: (VSLW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05533 // Pattern complexity = 5 cost = 1 size = 0 05534 if (CN0 == 155) { 05535 Emit_74(Result, N, PPC::VSLW, MVT::v4i32, N0, N1, N2); 05536 return; 05537 } 05538 05539 // Pattern: (intrinsic_wo_chain:v4i32 156:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05540 // Emits: (VSR:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05541 // Pattern complexity = 5 cost = 1 size = 0 05542 if (CN0 == 156) { 05543 Emit_74(Result, N, PPC::VSR, MVT::v4i32, N0, N1, N2); 05544 return; 05545 } 05546 05547 // Pattern: (intrinsic_wo_chain:v4i32 162:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05548 // Emits: (VSRO:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05549 // Pattern complexity = 5 cost = 1 size = 0 05550 if (CN0 == 162) { 05551 Emit_74(Result, N, PPC::VSRO, MVT::v4i32, N0, N1, N2); 05552 return; 05553 } 05554 05555 // Pattern: (intrinsic_wo_chain:v16i8 157:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05556 // Emits: (VSRAB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05557 // Pattern complexity = 5 cost = 1 size = 0 05558 if (CN0 == 157) { 05559 Emit_74(Result, N, PPC::VSRAB, MVT::v16i8, N0, N1, N2); 05560 return; 05561 } 05562 05563 // Pattern: (intrinsic_wo_chain:v8i16 158:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05564 // Emits: (VSRAH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05565 // Pattern complexity = 5 cost = 1 size = 0 05566 if (CN0 == 158) { 05567 Emit_74(Result, N, PPC::VSRAH, MVT::v8i16, N0, N1, N2); 05568 return; 05569 } 05570 05571 // Pattern: (intrinsic_wo_chain:v4i32 159:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05572 // Emits: (VSRAW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05573 // Pattern complexity = 5 cost = 1 size = 0 05574 if (CN0 == 159) { 05575 Emit_74(Result, N, PPC::VSRAW, MVT::v4i32, N0, N1, N2); 05576 return; 05577 } 05578 05579 // Pattern: (intrinsic_wo_chain:v16i8 160:iPTR, VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05580 // Emits: (VSRB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 05581 // Pattern complexity = 5 cost = 1 size = 0 05582 if (CN0 == 160) { 05583 Emit_74(Result, N, PPC::VSRB, MVT::v16i8, N0, N1, N2); 05584 return; 05585 } 05586 05587 // Pattern: (intrinsic_wo_chain:v8i16 161:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05588 // Emits: (VSRH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05589 // Pattern complexity = 5 cost = 1 size = 0 05590 if (CN0 == 161) { 05591 Emit_74(Result, N, PPC::VSRH, MVT::v8i16, N0, N1, N2); 05592 return; 05593 } 05594 05595 // Pattern: (intrinsic_wo_chain:v4i32 163:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05596 // Emits: (VSRW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05597 // Pattern complexity = 5 cost = 1 size = 0 05598 if (CN0 == 163) { 05599 Emit_74(Result, N, PPC::VSRW, MVT::v4i32, N0, N1, N2); 05600 return; 05601 } 05602 05603 // Pattern: (intrinsic_wo_chain:v8i16 134:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05604 // Emits: (VPKPX:v8i16 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05605 // Pattern complexity = 5 cost = 1 size = 0 05606 if (CN0 == 134) { 05607 Emit_74(Result, N, PPC::VPKPX, MVT::v8i16, N0, N1, N2); 05608 return; 05609 } 05610 05611 // Pattern: (intrinsic_wo_chain:v16i8 135:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05612 // Emits: (VPKSHSS:v16i8 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05613 // Pattern complexity = 5 cost = 1 size = 0 05614 if (CN0 == 135) { 05615 Emit_74(Result, N, PPC::VPKSHSS, MVT::v16i8, N0, N1, N2); 05616 return; 05617 } 05618 05619 // Pattern: (intrinsic_wo_chain:v16i8 136:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05620 // Emits: (VPKSHUS:v16i8 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05621 // Pattern complexity = 5 cost = 1 size = 0 05622 if (CN0 == 136) { 05623 Emit_74(Result, N, PPC::VPKSHUS, MVT::v16i8, N0, N1, N2); 05624 return; 05625 } 05626 05627 // Pattern: (intrinsic_wo_chain:v16i8 137:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05628 // Emits: (VPKSWSS:v16i8 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05629 // Pattern complexity = 5 cost = 1 size = 0 05630 if (CN0 == 137) { 05631 Emit_74(Result, N, PPC::VPKSWSS, MVT::v16i8, N0, N1, N2); 05632 return; 05633 } 05634 05635 // Pattern: (intrinsic_wo_chain:v8i16 138:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05636 // Emits: (VPKSWUS:v8i16 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05637 // Pattern complexity = 5 cost = 1 size = 0 05638 if (CN0 == 138) { 05639 Emit_74(Result, N, PPC::VPKSWUS, MVT::v8i16, N0, N1, N2); 05640 return; 05641 } 05642 05643 // Pattern: (intrinsic_wo_chain:v16i8 139:iPTR, VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05644 // Emits: (VPKUHUS:v16i8 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 05645 // Pattern complexity = 5 cost = 1 size = 0 05646 if (CN0 == 139) { 05647 Emit_74(Result, N, PPC::VPKUHUS, MVT::v16i8, N0, N1, N2); 05648 return; 05649 } 05650 05651 // Pattern: (intrinsic_wo_chain:v16i8 140:iPTR, VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05652 // Emits: (VPKUWUS:v16i8 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 05653 // Pattern complexity = 5 cost = 1 size = 0 05654 if (CN0 == 140) { 05655 Emit_74(Result, N, PPC::VPKUWUS, MVT::v16i8, N0, N1, N2); 05656 return; 05657 } 05658 05659 // Pattern: (intrinsic_wo_chain:v4i32 176:iPTR, VRRC:v8i16:$vB) 05660 // Emits: (VUPKHPX:v4i32 VRRC:v8i16:$vB) 05661 // Pattern complexity = 5 cost = 1 size = 0 05662 if (CN0 == 176) { 05663 Emit_75(Result, N, PPC::VUPKHPX, MVT::v4i32, N0, N1); 05664 return; 05665 } 05666 05667 // Pattern: (intrinsic_wo_chain:v8i16 177:iPTR, VRRC:v16i8:$vB) 05668 // Emits: (VUPKHSB:v8i16 VRRC:v16i8:$vB) 05669 // Pattern complexity = 5 cost = 1 size = 0 05670 if (CN0 == 177) { 05671 Emit_75(Result, N, PPC::VUPKHSB, MVT::v8i16, N0, N1); 05672 return; 05673 } 05674 05675 // Pattern: (intrinsic_wo_chain:v4i32 178:iPTR, VRRC:v8i16:$vB) 05676 // Emits: (VUPKHSH:v4i32 VRRC:v8i16:$vB) 05677 // Pattern complexity = 5 cost = 1 size = 0 05678 if (CN0 == 178) { 05679 Emit_75(Result, N, PPC::VUPKHSH, MVT::v4i32, N0, N1); 05680 return; 05681 } 05682 05683 // Pattern: (intrinsic_wo_chain:v4i32 179:iPTR, VRRC:v8i16:$vB) 05684 // Emits: (VUPKLPX:v4i32 VRRC:v8i16:$vB) 05685 // Pattern complexity = 5 cost = 1 size = 0 05686 if (CN0 == 179) { 05687 Emit_75(Result, N, PPC::VUPKLPX, MVT::v4i32, N0, N1); 05688 return; 05689 } 05690 05691 // Pattern: (intrinsic_wo_chain:v8i16 180:iPTR, VRRC:v16i8:$vB) 05692 // Emits: (VUPKLSB:v8i16 VRRC:v16i8:$vB) 05693 // Pattern complexity = 5 cost = 1 size = 0 05694 if (CN0 == 180) { 05695 Emit_75(Result, N, PPC::VUPKLSB, MVT::v8i16, N0, N1); 05696 return; 05697 } 05698 05699 // Pattern: (intrinsic_wo_chain:v4i32 181:iPTR, VRRC:v8i16:$vB) 05700 // Emits: (VUPKLSH:v4i32 VRRC:v8i16:$vB) 05701 // Pattern complexity = 5 cost = 1 size = 0 05702 if (CN0 == 181) { 05703 Emit_75(Result, N, PPC::VUPKLSH, MVT::v4i32, N0, N1); 05704 return; 05705 } 05706 05707 // Pattern: (intrinsic_wo_chain:v4f32 100:iPTR, VRRC:v4f32:$A, VRRC:v4f32:$B, VRRC:v4f32:$C) 05708 // Emits: (VMADDFP:v4f32 VRRC:v16i8:$A, VRRC:v16i8:$B, VRRC:v16i8:$C) 05709 // Pattern complexity = 5 cost = 1 size = 0 05710 if (CN0 == 100) { 05711 Emit_73(Result, N, PPC::VMADDFP, MVT::v4f32, N0, N1, N2, N3); 05712 return; 05713 } 05714 05715 // Pattern: (intrinsic_wo_chain:v4f32 132:iPTR, VRRC:v4f32:$A, VRRC:v4f32:$B, VRRC:v4f32:$C) 05716 // Emits: (VNMSUBFP:v4f32 VRRC:v16i8:$A, VRRC:v16i8:$B, VRRC:v16i8:$C) 05717 // Pattern complexity = 5 cost = 1 05718 if (CN0 == 132) { 05719 Emit_73(Result, N, PPC::VNMSUBFP, MVT::v4f32, N0, N1, N2, N3); 05720 return; 05721 } 05722 } 05723 std::cerr << "Cannot yet select: "; 05724 unsigned iid = cast<ConstantSDNode>(N.getOperand(N.getOperand(0).getValueType() == MVT::Other))->getValue(); 05725 std::cerr << "intrinsic %"<< Intrinsic::getName((Intrinsic::ID)iid); 05726 std::cerr << '\n'; 05727 abort(); 05728 } 05729 05730 void Emit_76(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &CPTmp0, SDOperand &CPTmp1, SDOperand &Chain, SDOperand &N1) NOINLINE { 05731 SDOperand Tmp0(0, 0); 05732 SDOperand Tmp1(0, 0); 05733 SDNode *ResNode = NULL; 05734 SelectionDAG::InsertInFlightSetEntry(InFlightSet, CPTmp0.Val); 05735 SelectionDAG::InsertInFlightSetEntry(InFlightSet, CPTmp1.Val); 05736 Select(Tmp0, CPTmp0); 05737 Select(Tmp1, CPTmp1); 05738 Select(Chain, Chain); 05739 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, CPTmp0.Val); 05740 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, CPTmp1.Val); 05741 ResNode = CurDAG->getTargetNode(Opc0, VT0, MVT::Other, Tmp0, Tmp1, Chain); 05742 Chain = SDOperand(ResNode, 1); 05743 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 05744 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Chain.Val, Chain.ResNo); 05745 if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, Chain.Val, Chain.ResNo); 05746 Result = SDOperand(ResNode, N.ResNo); 05747 return; 05748 } 05749 void Select_load(SDOperand &Result, SDOperand N) { 05750 if (N.ResNo == 1 && N.getValue(0).hasOneUse()) { 05751 SDOperand Dummy = CurDAG->getNode(ISD::HANDLENODE, MVT::Other, N); 05752 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Dummy.Val, 0); 05753 SelectionDAG::InsertISelMapEntry(HandleMap, N.Val, 1, Dummy.Val, 0); 05754 Result = Dummy; 05755 return; 05756 } 05757 SDOperand CPTmp0(0, 0); 05758 SDOperand CPTmp1(0, 0); 05759 SDOperand Chain(0, 0); 05760 SDOperand N1(0, 0); 05761 SDOperand Tmp0(0, 0); 05762 SDOperand Tmp1(0, 0); 05763 SDNode *ResNode = NULL; 05764 Chain = N.getOperand(0); 05765 N1 = N.getOperand(1); 05766 05767 // Pattern: (load:i32 iaddr:iPTR:$src) 05768 // Emits: (LWZ:i32 iaddr:iPTR:$src) 05769 // Pattern complexity = 8 cost = 1 size = 0 05770 if (N.Val->getValueType(0) == MVT::i32) { 05771 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 05772 if (Match) { 05773 Emit_76(Result, N, PPC::LWZ, MVT::i32, CPTmp0, CPTmp1, Chain, N1); 05774 return; 05775 } 05776 } 05777 05778 // Pattern: (load:f32 iaddr:iPTR:$src) 05779 // Emits: (LFS:f32 iaddr:iPTR:$src) 05780 // Pattern complexity = 8 cost = 1 size = 0 05781 if (N.Val->getValueType(0) == MVT::f32) { 05782 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 05783 if (Match) { 05784 Emit_76(Result, N, PPC::LFS, MVT::f32, CPTmp0, CPTmp1, Chain, N1); 05785 return; 05786 } 05787 } 05788 05789 // Pattern: (load:f64 iaddr:iPTR:$src) 05790 // Emits: (LFD:f64 iaddr:iPTR:$src) 05791 // Pattern complexity = 8 cost = 1 size = 0 05792 if (N.Val->getValueType(0) == MVT::f64) { 05793 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 05794 if (Match) { 05795 Emit_76(Result, N, PPC::LFD, MVT::f64, CPTmp0, CPTmp1, Chain, N1); 05796 return; 05797 } 05798 } 05799 05800 // Pattern: (load:i32 xaddr:iPTR:$src) 05801 // Emits: (LWZX:i32 xaddr:iPTR:$src) 05802 // Pattern complexity = 8 cost = 1 size = 0 05803 if (N.Val->getValueType(0) == MVT::i32) { 05804 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 05805 if (Match) { 05806 Emit_76(Result, N, PPC::LWZX, MVT::i32, CPTmp0, CPTmp1, Chain, N1); 05807 return; 05808 } 05809 } 05810 05811 // Pattern: (load:f32 xaddr:iPTR:$src) 05812 // Emits: (LFSX:f32 xaddr:iPTR:$src) 05813 // Pattern complexity = 8 cost = 1 size = 0 05814 if (N.Val->getValueType(0) == MVT::f32) { 05815 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 05816 if (Match) { 05817 Emit_76(Result, N, PPC::LFSX, MVT::f32, CPTmp0, CPTmp1, Chain, N1); 05818 return; 05819 } 05820 } 05821 05822 // Pattern: (load:f64 xaddr:iPTR:$src) 05823 // Emits: (LFDX:f64 xaddr:iPTR:$src) 05824 // Pattern complexity = 8 cost = 1 size = 0 05825 if (N.Val->getValueType(0) == MVT::f64) { 05826 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 05827 if (Match) { 05828 Emit_76(Result, N, PPC::LFDX, MVT::f64, CPTmp0, CPTmp1, Chain, N1); 05829 return; 05830 } 05831 } 05832 if (N.Val->getValueType(0) == MVT::i64) { 05833 05834 // Pattern: (load:i64 ixaddr:iPTR:$src) 05835 // Emits: (LD:i64 ixaddr:iPTR:$src) 05836 // Pattern complexity = 8 cost = 1 size = 0 05837 { 05838 bool Match = SelectAddrImmShift(N1, CPTmp0, CPTmp1); 05839 if (Match) { 05840 Emit_76(Result, N, PPC::LD, MVT::i64, CPTmp0, CPTmp1, Chain, N1); 05841 return; 05842 } 05843 } 05844 05845 // Pattern: (load:i64 xaddr:iPTR:$src) 05846 // Emits: (LDX:i64 xaddr:iPTR:$src) 05847 // Pattern complexity = 8 cost = 1 05848 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 05849 if (Match) { 05850 Emit_76(Result, N, PPC::LDX, MVT::i64, CPTmp0, CPTmp1, Chain, N1); 05851 return; 05852 } 05853 } 05854 05855 // Pattern: (load:v4i32 xoaddr:iPTR:$src) 05856 // Emits: (LVX:v4i32 xoaddr:iPTR:$src) 05857 // Pattern complexity = 8 cost = 1 05858 if (N.Val->getValueType(0) == MVT::v4i32) { 05859 bool Match = SelectAddrIdxOnly(N1, CPTmp0, CPTmp1); 05860 if (Match) { 05861 Emit_76(Result, N, PPC::LVX, MVT::v4i32, CPTmp0, CPTmp1, Chain, N1); 05862 return; 05863 } 05864 } 05865 std::cerr << "Cannot yet select: "; 05866 N.Val->dump(CurDAG); 05867 std::cerr << '\n'; 05868 abort(); 05869 } 05870 05871 void Select_mul(SDOperand &Result, SDOperand N) { 05872 SDOperand N0(0, 0); 05873 SDOperand N1(0, 0); 05874 SDOperand Tmp0(0, 0); 05875 SDOperand Tmp1(0, 0); 05876 SDNode *ResNode = NULL; 05877 N0 = N.getOperand(0); 05878 N1 = N.getOperand(1); 05879 05880 // Pattern: (mul:i32 GPRC:i32:$rA, (imm:i32)<<P:Predicate_immSExt16>>:$imm) 05881 // Emits: (MULLI:i32 GPRC:i32:$rA, (imm:i32):$imm) 05882 // Pattern complexity = 5 cost = 1 size = 0 05883 if (N1.getOpcode() == ISD::Constant && 05884 Predicate_immSExt16(N1.Val) && 05885 N.Val->getValueType(0) == MVT::i32) { 05886 Emit_19(Result, N, PPC::MULLI, MVT::i32, N0, N1); 05887 return; 05888 } 05889 05890 // Pattern: (mul:i32 GPRC:i32:$rA, GPRC:i32:$rB) 05891 // Emits: (MULLW:i32 GPRC:i32:$rA, GPRC:i32:$rB) 05892 // Pattern complexity = 2 cost = 1 size = 0 05893 if (N.Val->getValueType(0) == MVT::i32) { 05894 Emit_24(Result, N, PPC::MULLW, MVT::i32, N0, N1); 05895 return; 05896 } 05897 05898 // Pattern: (mul:i64 G8RC:i64:$rA, G8RC:i64:$rB) 05899 // Emits: (MULLD:i64 G8RC:i64:$rA, G8RC:i64:$rB) 05900 // Pattern complexity = 2 cost = 1 05901 if (N.Val->getValueType(0) == MVT::i64) { 05902 Emit_24(Result, N, PPC::MULLD, MVT::i64, N0, N1); 05903 return; 05904 } 05905 std::cerr << "Cannot yet select: "; 05906 N.Val->dump(CurDAG); 05907 std::cerr << '\n'; 05908 abort(); 05909 } 05910 05911 void Select_mulhs(SDOperand &Result, SDOperand N) { 05912 SDOperand N0(0, 0); 05913 SDOperand N1(0, 0); 05914 SDOperand Tmp0(0, 0); 05915 SDOperand Tmp1(0, 0); 05916 SDNode *ResNode = NULL; 05917 N0 = N.getOperand(0); 05918 N1 = N.getOperand(1); 05919 05920 // Pattern: (mulhs:i32 GPRC:i32:$rA, GPRC:i32:$rB) 05921 // Emits: (MULHW:i32 GPRC:i32:$rA, GPRC:i32:$rB) 05922 // Pattern complexity = 2 cost = 1 size = 0 05923 if (N.Val->getValueType(0) == MVT::i32) { 05924 Emit_24(Result, N, PPC::MULHW, MVT::i32, N0, N1); 05925 return; 05926 } 05927 05928 // Pattern: (mulhs:i64 G8RC:i64:$rA, G8RC:i64:$rB) 05929 // Emits: (MULHD:i64 G8RC:i64:$rA, G8RC:i64:$rB) 05930 // Pattern complexity = 2 cost = 1 05931 if (N.Val->getValueType(0) == MVT::i64) { 05932 Emit_24(Result, N, PPC::MULHD, MVT::i64, N0, N1); 05933 return; 05934 } 05935 std::cerr << "Cannot yet select: "; 05936 N.Val->dump(CurDAG); 05937 std::cerr << '\n'; 05938 abort(); 05939 } 05940 05941 void Select_mulhu(SDOperand &Result, SDOperand N) { 05942 SDOperand N0(0, 0); 05943 SDOperand N1(0, 0); 05944 SDOperand Tmp0(0, 0); 05945 SDOperand Tmp1(0, 0); 05946 SDNode *ResNode = NULL; 05947 N0 = N.getOperand(0); 05948 N1 = N.getOperand(1); 05949 05950 // Pattern: (mulhu:i32 GPRC:i32:$rA, GPRC:i32:$rB) 05951 // Emits: (MULHWU:i32 GPRC:i32:$rA, GPRC:i32:$rB) 05952 // Pattern complexity = 2 cost = 1 size = 0 05953 if (N.Val->getValueType(0) == MVT::i32) { 05954 Emit_24(Result, N, PPC::MULHWU, MVT::i32, N0, N1); 05955 return; 05956 } 05957 05958 // Pattern: (mulhu:i64 G8RC:i64:$rA, G8RC:i64:$rB) 05959 // Emits: (MULHDU:i64 G8RC:i64:$rA, G8RC:i64:$rB) 05960 // Pattern complexity = 2 cost = 1 05961 if (N.Val->getValueType(0) == MVT::i64) { 05962 Emit_24(Result, N, PPC::MULHDU, MVT::i64, N0, N1); 05963 return; 05964 } 05965 std::cerr << "Cannot yet select: "; 05966 N.Val->dump(CurDAG); 05967 std::cerr << '\n'; 05968 abort(); 05969 } 05970 05971 void Emit_77(SDOperand &Result, SDOperand &N, unsigned Opc0, unsigned Opc1, MVT::ValueType VT0, MVT::ValueType VT1, SDOperand &N0, SDOperand &N1) NOINLINE { 05972 SDOperand Tmp0(0, 0); 05973 SDOperand Tmp1(0, 0); 05974 SDOperand Tmp2(0, 0); 05975 SDOperand Tmp3(0, 0); 05976 SDOperand Tmp4(0, 0); 05977 SDNode *ResNode = NULL; 05978 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 05979 Select(Tmp0, N0); 05980 Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getValue()), MVT::i32); 05981 Tmp2 = Transform_LO16(Tmp1.Val); 05982 Tmp3 = SDOperand(CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp2), 0); 05983 Tmp4 = Transform_HI16(Tmp1.Val); 05984 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 05985 if (N.Val->hasOneUse()) { 05986 Result = CurDAG->SelectNodeTo(N.Val, Opc1, VT1, Tmp3, Tmp4); 05987 } else { 05988 ResNode = CurDAG->getTargetNode(Opc1, VT1, Tmp3, Tmp4); 05989 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 05990 Result = SDOperand(ResNode, 0); 05991 } 05992 return; 05993 } 05994 void Select_or(SDOperand &Result, SDOperand N) { 05995 SDOperand N0(0, 0); 05996 SDOperand N00(0, 0); 05997 SDOperand N01(0, 0); 05998 SDOperand N1(0, 0); 05999 SDOperand N10(0, 0); 06000 SDOperand N11(0, 0); 06001 SDOperand Tmp0(0, 0); 06002 SDOperand Tmp1(0, 0); 06003 SDOperand Tmp2(0, 0); 06004 SDOperand Tmp3(0, 0); 06005 SDOperand Tmp4(0, 0); 06006 SDNode *ResNode = NULL; 06007 N0 = N.getOperand(0); 06008 { 06009 N1 = N.getOperand(1); 06010 if (N1.getOpcode() == ISD::XOR) { 06011 N10 = N1.getOperand(0); 06012 N11 = N1.getOperand(1); 06013 if (N11.getOpcode() == ISD::Constant && 06014 Predicate_immAllOnes(N11.Val)) { 06015 06016 // Pattern: (or:i32 GPRC:i32:$rS, (xor:i32 GPRC:i32:$rB, (imm:i32)<<P:Predicate_immAllOnes>>)) 06017 // Emits: (ORC:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06018 // Pattern complexity = 7 cost = 1 size = 0 06019 if (N.Val->getValueType(0) == MVT::i32) { 06020 Emit_31(Result, N, PPC::ORC, MVT::i32, N0, N1, N10, N11); 06021 return; 06022 } 06023 06024 // Pattern: (or:i64 G8RC:i64:$rS, (xor:i64 G8RC:i64:$rB, (imm:i64)<<P:Predicate_immAllOnes>>)) 06025 // Emits: (ORC8:i64 G8RC:i64:$rS, G8RC:i64:$rB) 06026 // Pattern complexity = 7 cost = 1 06027 if (N.Val->getValueType(0) == MVT::i64) { 06028 Emit_31(Result, N, PPC::ORC8, MVT::i64, N0, N1, N10, N11); 06029 return; 06030 } 06031 } 06032 } 06033 } 06034 if (N0.getOpcode() == ISD::XOR) { 06035 N00 = N0.getOperand(0); 06036 N01 = N0.getOperand(1); 06037 if (N01.getOpcode() == ISD::Constant && 06038 Predicate_immAllOnes(N01.Val)) { 06039 N1 = N.getOperand(1); 06040 06041 // Pattern: (or:i32 (xor:i32 GPRC:i32:$rB, (imm:i32)<<P:Predicate_immAllOnes>>), GPRC:i32:$rS) 06042 // Emits: (ORC:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06043 // Pattern complexity = 7 cost = 1 size = 0 06044 if (N.Val->getValueType(0) == MVT::i32) { 06045 Emit_32(Result, N, PPC::ORC, MVT::i32, N0, N00, N01, N1); 06046 return; 06047 } 06048 06049 // Pattern: (or:i64 (xor:i64 G8RC:i64:$rB, (imm:i64)<<P:Predicate_immAllOnes>>), G8RC:i64:$rS) 06050 // Emits: (ORC8:i64 G8RC:i64:$rS, G8RC:i64:$rB) 06051 // Pattern complexity = 7 cost = 1 06052 if (N.Val->getValueType(0) == MVT::i64) { 06053 Emit_32(Result, N, PPC::ORC8, MVT::i64, N0, N00, N01, N1); 06054 return; 06055 } 06056 } 06057 } 06058 N1 = N.getOperand(1); 06059 if (N1.getOpcode() == ISD::Constant) { 06060 06061 // Pattern: (or:i32 GPRC:i32:$src1, (imm:i32)<<P:Predicate_immZExt16>><<X:LO16>>:$src2) 06062 // Emits: (ORI:i32 GPRC:i32:$src1, (LO16:i32 (imm:i32):$src2)) 06063 // Pattern complexity = 5 cost = 1 size = 0 06064 if (Predicate_immZExt16(N1.Val) && 06065 N.Val->getValueType(0) == MVT::i32) { 06066 Emit_35(Result, N, PPC::ORI, MVT::i32, N0, N1); 06067 return; 06068 } 06069 06070 // Pattern: (or:i32 GPRC:i32:$src1, (imm:i32)<<P:Predicate_imm16ShiftedZExt>><<X:HI16>>:$src2) 06071 // Emits: (ORIS:i32 GPRC:i32:$src1, (HI16:i32 (imm:i32):$src2)) 06072 // Pattern complexity = 5 cost = 1 size = 0 06073 if (Predicate_imm16ShiftedZExt(N1.Val) && 06074 N.Val->getValueType(0) == MVT::i32) { 06075 Emit_20(Result, N, PPC::ORIS, MVT::i32, N0, N1); 06076 return; 06077 } 06078 06079 // Pattern: (or:i64 G8RC:i64:$src1, (imm:i64)<<P:Predicate_immZExt16>><<X:LO16>>:$src2) 06080 // Emits: (ORI8:i64 G8RC:i64:$src1, (LO16:i32 (imm:i64):$src2)) 06081 // Pattern complexity = 5 cost = 1 size = 0 06082 if (Predicate_immZExt16(N1.Val) && 06083 N.Val->getValueType(0) == MVT::i64) { 06084 Emit_36(Result, N, PPC::ORI8, MVT::i64, N0, N1); 06085 return; 06086 } 06087 06088 // Pattern: (or:i64 G8RC:i64:$src1, (imm:i64)<<P:Predicate_imm16ShiftedZExt>><<X:HI16>>:$src2) 06089 // Emits: (ORIS8:i64 G8RC:i64:$src1, (HI16:i32 (imm:i64):$src2)) 06090 // Pattern complexity = 5 cost = 1 size = 0 06091 if (Predicate_imm16ShiftedZExt(N1.Val) && 06092 N.Val->getValueType(0) == MVT::i64) { 06093 Emit_22(Result, N, PPC::ORIS8, MVT::i64, N0, N1); 06094 return; 06095 } 06096 06097 // Pattern: (or:i32 GPRC:i32:$in, (imm:i32):$imm) 06098 // Emits: (ORIS:i32 (ORI:i32 GPRC:i32:$in, (LO16:i32 (imm:i32):$imm)), (HI16:i32 (imm:i32):$imm)) 06099 // Pattern complexity = 4 cost = 2 06100 if (N.Val->getValueType(0) == MVT::i32) { 06101 Emit_77(Result, N, PPC::ORI, PPC::ORIS, MVT::i32, MVT::i32, N0, N1); 06102 return; 06103 } 06104 } 06105 06106 // Pattern: (or:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06107 // Emits: (OR:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06108 // Pattern complexity = 2 cost = 1 size = 0 06109 if (N.Val->getValueType(0) == MVT::i32) { 06110 Emit_24(Result, N, PPC::OR, MVT::i32, N0, N1); 06111 return; 06112 } 06113 06114 // Pattern: (or:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 06115 // Emits: (VOR:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 06116 // Pattern complexity = 2 cost = 1 size = 0 06117 if (N.Val->getValueType(0) == MVT::v4i32) { 06118 Emit_24(Result, N, PPC::VOR, MVT::v4i32, N0, N1); 06119 return; 06120 } 06121 06122 // Pattern: (or:i64 G8RC:i64:$rS, G8RC:i64:$rB) 06123 // Emits: (OR8:i64 G8RC:i64:$rS, G8RC:i64:$rB) 06124 // Pattern complexity = 2 cost = 1 06125 if (N.Val->getValueType(0) == MVT::i64) { 06126 Emit_24(Result, N, PPC::OR8, MVT::i64, N0, N1); 06127 return; 06128 } 06129 std::cerr << "Cannot yet select: "; 06130 N.Val->dump(CurDAG); 06131 std::cerr << '\n'; 06132 abort(); 06133 } 06134 06135 void Emit_78(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &Chain) NOINLINE { 06136 SDNode *ResNode = NULL; 06137 Chain = N.getOperand(0); 06138 Select(Chain, Chain); 06139 ResNode = CurDAG->getTargetNode(Opc0, MVT::Other, Chain); 06140 Chain = SDOperand(ResNode, 0); 06141 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 06142 Result = SDOperand(ResNode, N.ResNo); 06143 return; 06144 } 06145 void Select_ret(SDOperand &Result, SDOperand N) { 06146 SDOperand Chain(0, 0); 06147 SDNode *ResNode = NULL; 06148 Emit_78(Result, N, PPC::BLR, Chain); 06149 return; 06150 } 06151 06152 void Emit_79(SDOperand &Result, SDOperand &N, unsigned Opc0, SDOperand &Chain, bool HasInFlag) NOINLINE { 06153 SDOperand InFlag(0, 0); 06154 SDNode *ResNode = NULL; 06155 Chain = N.getOperand(0); 06156 HasInFlag = (N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag); 06157 Select(Chain, Chain); 06158 if (HasInFlag) 06159 Select(InFlag, N.getOperand(N.getNumOperands()-1)); 06160 ResNode = HasInFlag ? CurDAG->getTargetNode(Opc0, MVT::Other, Chain, InFlag) : CurDAG->getTargetNode(Opc0, MVT::Other, Chain); 06161 Chain = SDOperand(ResNode, 0); 06162 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Chain.Val, Chain.ResNo); 06163 Result = SDOperand(ResNode, N.ResNo); 06164 return; 06165 } 06166 void Select_retflag(SDOperand &Result, SDOperand N) { 06167 SDOperand Chain(0, 0); 06168 SDOperand InFlag(0, 0); 06169 SDNode *ResNode = NULL; 06170 bool HasInFlag = false; 06171 Emit_79(Result, N, PPC::BLR, Chain, HasInFlag); 06172 return; 06173 } 06174 06175 void Emit_80(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 06176 SDOperand Tmp0(0, 0); 06177 SDOperand Tmp1(0, 0); 06178 SDOperand Tmp2(0, 0); 06179 SDOperand Tmp3(0, 0); 06180 SDNode *ResNode = NULL; 06181 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 06182 Select(Tmp0, N0); 06183 Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getValue()), MVT::i32); 06184 Tmp2 = CurDAG->getTargetConstant(0, MVT::i32); 06185 Tmp3 = CurDAG->getTargetConstant(31, MVT::i32); 06186 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 06187 if (N.Val->hasOneUse()) { 06188 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1, Tmp2, Tmp3); 06189 } else { 06190 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1, Tmp2, Tmp3); 06191 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06192 Result = SDOperand(ResNode, 0); 06193 } 06194 return; 06195 } 06196 void Emit_81(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 06197 SDOperand Tmp0(0, 0); 06198 SDOperand Tmp1(0, 0); 06199 SDOperand Tmp2(0, 0); 06200 SDOperand Tmp3(0, 0); 06201 SDNode *ResNode = NULL; 06202 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 06203 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 06204 Select(Tmp0, N0); 06205 Select(Tmp1, N1); 06206 Tmp2 = CurDAG->getTargetConstant(0, MVT::i32); 06207 Tmp3 = CurDAG->getTargetConstant(31, MVT::i32); 06208 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 06209 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 06210 if (N.Val->hasOneUse()) { 06211 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1, Tmp2, Tmp3); 06212 } else { 06213 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1, Tmp2, Tmp3); 06214 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06215 Result = SDOperand(ResNode, 0); 06216 } 06217 return; 06218 } 06219 void Select_rotl(SDOperand &Result, SDOperand N) { 06220 SDOperand N0(0, 0); 06221 SDOperand N1(0, 0); 06222 SDOperand Tmp0(0, 0); 06223 SDOperand Tmp1(0, 0); 06224 SDOperand Tmp2(0, 0); 06225 SDOperand Tmp3(0, 0); 06226 SDNode *ResNode = NULL; 06227 N0 = N.getOperand(0); 06228 N1 = N.getOperand(1); 06229 06230 // Pattern: (rotl:i32 GPRC:i32:$in, (imm:i32):$imm) 06231 // Emits: (RLWINM:i32 GPRC:i32:$in, (imm:i32):$imm, 0:i32, 31:i32) 06232 // Pattern complexity = 4 cost = 1 size = 0 06233 if (N1.getOpcode() == ISD::Constant && 06234 N.Val->getValueType(0) == MVT::i32 && 06235 N1.Val->getValueType(0) == MVT::i32) { 06236 Emit_80(Result, N, PPC::RLWINM, MVT::i32, N0, N1); 06237 return; 06238 } 06239 06240 // Pattern: (rotl:i32 GPRC:i32:$in, GPRC:i32:$sh) 06241 // Emits: (RLWNM:i32 GPRC:i32:$in, GPRC:i32:$sh, 0:i32, 31:i32) 06242 // Pattern complexity = 2 cost = 1 06243 if (N.Val->getValueType(0) == MVT::i32 && 06244 N1.Val->getValueType(0) == MVT::i32) { 06245 Emit_81(Result, N, PPC::RLWNM, MVT::i32, N0, N1); 06246 return; 06247 } 06248 std::cerr << "Cannot yet select: "; 06249 N.Val->dump(CurDAG); 06250 std::cerr << '\n'; 06251 abort(); 06252 } 06253 06254 void Select_sdiv(SDOperand &Result, SDOperand N) { 06255 SDOperand N0(0, 0); 06256 SDOperand N1(0, 0); 06257 SDOperand Tmp0(0, 0); 06258 SDOperand Tmp1(0, 0); 06259 SDNode *ResNode = NULL; 06260 N0 = N.getOperand(0); 06261 N1 = N.getOperand(1); 06262 06263 // Pattern: (sdiv:i32 GPRC:i32:$rA, GPRC:i32:$rB) 06264 // Emits: (DIVW:i32 GPRC:i32:$rA, GPRC:i32:$rB) 06265 // Pattern complexity = 2 cost = 1 size = 0 06266 if (N.Val->getValueType(0) == MVT::i32) { 06267 Emit_24(Result, N, PPC::DIVW, MVT::i32, N0, N1); 06268 return; 06269 } 06270 06271 // Pattern: (sdiv:i64 G8RC:i64:$rA, G8RC:i64:$rB) 06272 // Emits: (DIVD:i64 G8RC:i64:$rA, G8RC:i64:$rB) 06273 // Pattern complexity = 2 cost = 1 06274 if (N.Val->getValueType(0) == MVT::i64) { 06275 Emit_24(Result, N, PPC::DIVD, MVT::i64, N0, N1); 06276 return; 06277 } 06278 std::cerr << "Cannot yet select: "; 06279 N.Val->dump(CurDAG); 06280 std::cerr << '\n'; 06281 abort(); 06282 } 06283 06284 void Select_sext(SDOperand &Result, SDOperand N) { 06285 SDOperand N0(0, 0); 06286 SDOperand Tmp0(0, 0); 06287 SDNode *ResNode = NULL; 06288 N0 = N.getOperand(0); 06289 if (N.Val->getValueType(0) == MVT::i64 && 06290 N0.Val->getValueType(0) == MVT::i32) { 06291 Emit_4(Result, N, PPC::EXTSW_32_64, MVT::i64, N0); 06292 return; 06293 } 06294 std::cerr << "Cannot yet select: "; 06295 N.Val->dump(CurDAG); 06296 std::cerr << '\n'; 06297 abort(); 06298 } 06299 06300 void Emit_82(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 06301 SDOperand Tmp0(0, 0); 06302 SDNode *ResNode = NULL; 06303 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 06304 Select(Tmp0, N0); 06305 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 06306 if (N.Val->hasOneUse()) { 06307 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0); 06308 } else { 06309 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0); 06310 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06311 Result = SDOperand(ResNode, 0); 06312 } 06313 return; 06314 } 06315 void Select_sext_inreg(SDOperand &Result, SDOperand N) { 06316 SDOperand N0(0, 0); 06317 SDOperand N1(0, 0); 06318 SDOperand Tmp0(0, 0); 06319 SDNode *ResNode = NULL; 06320 N0 = N.getOperand(0); 06321 N1 = N.getOperand(1); 06322 06323 // Pattern: (sext_inreg:i32 GPRC:i32:$rS, i8:Other) 06324 // Emits: (EXTSB:i32 GPRC:i32:$rS) 06325 // Pattern complexity = 2 cost = 1 size = 0 06326 if (cast<VTSDNode>(N1)->getVT() == MVT::i8 && 06327 N.Val->getValueType(0) == MVT::i32) { 06328 Emit_82(Result, N, PPC::EXTSB, MVT::i32, N0, N1); 06329 return; 06330 } 06331 06332 // Pattern: (sext_inreg:i32 GPRC:i32:$rS, i16:Other) 06333 // Emits: (EXTSH:i32 GPRC:i32:$rS) 06334 // Pattern complexity = 2 cost = 1 size = 0 06335 if (cast<VTSDNode>(N1)->getVT() == MVT::i16 && 06336 N.Val->getValueType(0) == MVT::i32) { 06337 Emit_82(Result, N, PPC::EXTSH, MVT::i32, N0, N1); 06338 return; 06339 } 06340 06341 // Pattern: (sext_inreg:i64 G8RC:i64:$rS, i32:Other) 06342 // Emits: (EXTSW:i64 G8RC:i64:$rS) 06343 // Pattern complexity = 2 cost = 1 06344 if (cast<VTSDNode>(N1)->getVT() == MVT::i32 && 06345 N.Val->getValueType(0) == MVT::i64) { 06346 Emit_82(Result, N, PPC::EXTSW, MVT::i64, N0, N1); 06347 return; 06348 } 06349 std::cerr << "Cannot yet select: "; 06350 N.Val->dump(CurDAG); 06351 std::cerr << '\n'; 06352 abort(); 06353 } 06354 06355 void Select_sextld(SDOperand &Result, SDOperand N) { 06356 if (N.ResNo == 1 && N.getValue(0).hasOneUse()) { 06357 SDOperand Dummy = CurDAG->getNode(ISD::HANDLENODE, MVT::Other, N); 06358 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Dummy.Val, 0); 06359 SelectionDAG::InsertISelMapEntry(HandleMap, N.Val, 1, Dummy.Val, 0); 06360 Result = Dummy; 06361 return; 06362 } 06363 SDOperand CPTmp0(0, 0); 06364 SDOperand CPTmp1(0, 0); 06365 SDOperand Chain(0, 0); 06366 SDOperand N1(0, 0); 06367 SDOperand N2(0, 0); 06368 SDOperand N3(0, 0); 06369 SDOperand Tmp0(0, 0); 06370 SDOperand Tmp1(0, 0); 06371 SDNode *ResNode = NULL; 06372 Chain = N.getOperand(0); 06373 N1 = N.getOperand(1); 06374 N2 = N.getOperand(2); 06375 N3 = N.getOperand(3); 06376 if (cast<VTSDNode>(N3)->getVT() == MVT::i16) { 06377 if (N.Val->getValueType(0) == MVT::i32) { 06378 06379 // Pattern: (sextld:i32 iaddr:iPTR:$src, srcvalue:Other:$dummy, i16:Other) 06380 // Emits: (LHA:i32 iaddr:iPTR:$src) 06381 // Pattern complexity = 8 cost = 1 size = 0 06382 { 06383 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 06384 if (Match) { 06385 Emit_8(Result, N, PPC::LHA, MVT::i32, CPTmp0, CPTmp1, Chain, N1, N2, N3); 06386 return; 06387 } 06388 } 06389 06390 // Pattern: (sextld:i32 xaddr:iPTR:$src, srcvalue:Other:$dummy, i16:Other) 06391 // Emits: (LHAX:i32 xaddr:iPTR:$src) 06392 // Pattern complexity = 8 cost = 1 06393 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 06394 if (Match) { 06395 Emit_8(Result, N, PPC::LHAX, MVT::i32, CPTmp0, CPTmp1, Chain, N1, N2, N3); 06396 return; 06397 } 06398 } 06399 06400 // Pattern: (sextld:i64 iaddr:iPTR:$src, srcvalue:Other:$dummy, i16:Other) 06401 // Emits: (LHA8:i64 iaddr:iPTR:$src) 06402 // Pattern complexity = 8 cost = 1 06403 if (N.Val->getValueType(0) == MVT::i64) { 06404 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 06405 if (Match) { 06406 Emit_8(Result, N, PPC::LHA8, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 06407 return; 06408 } 06409 } 06410 } 06411 06412 // Pattern: (sextld:i64 ixaddr:iPTR:$src, srcvalue:Other:$dummy, i32:Other) 06413 // Emits: (LWA:i64 ixaddr:iPTR:$src) 06414 // Pattern complexity = 8 cost = 1 size = 0 06415 if (cast<VTSDNode>(N3)->getVT() == MVT::i32 && 06416 N.Val->getValueType(0) == MVT::i64) { 06417 bool Match = SelectAddrImmShift(N1, CPTmp0, CPTmp1); 06418 if (Match) { 06419 Emit_8(Result, N, PPC::LWA, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 06420 return; 06421 } 06422 } 06423 06424 // Pattern: (sextld:i64 xaddr:iPTR:$src, srcvalue:Other:$dummy, i16:Other) 06425 // Emits: (LHAX8:i64 xaddr:iPTR:$src) 06426 // Pattern complexity = 8 cost = 1 size = 0 06427 if (cast<VTSDNode>(N3)->getVT() == MVT::i16 && 06428 N.Val->getValueType(0) == MVT::i64) { 06429 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 06430 if (Match) { 06431 Emit_8(Result, N, PPC::LHAX8, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 06432 return; 06433 } 06434 } 06435 06436 // Pattern: (sextld:i64 xaddr:iPTR:$src, srcvalue:Other:$dummy, i32:Other) 06437 // Emits: (LWAX:i64 xaddr:iPTR:$src) 06438 // Pattern complexity = 8 cost = 1 06439 if (cast<VTSDNode>(N3)->getVT() == MVT::i32 && 06440 N.Val->getValueType(0) == MVT::i64) { 06441 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 06442 if (Match) { 06443 Emit_8(Result, N, PPC::LWAX, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 06444 return; 06445 } 06446 } 06447 std::cerr << "Cannot yet select: "; 06448 N.Val->dump(CurDAG); 06449 std::cerr << '\n'; 06450 abort(); 06451 } 06452 06453 void Emit_83(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 06454 SDOperand Tmp0(0, 0); 06455 SDOperand Tmp1(0, 0); 06456 SDOperand Tmp2(0, 0); 06457 SDOperand Tmp3(0, 0); 06458 SDNode *ResNode = NULL; 06459 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 06460 Select(Tmp0, N0); 06461 Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getValue()), MVT::i32); 06462 Tmp2 = CurDAG->getTargetConstant(0, MVT::i32); 06463 Tmp3 = Transform_SHL32(Tmp1.Val); 06464 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 06465 if (N.Val->hasOneUse()) { 06466 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1, Tmp2, Tmp3); 06467 } else { 06468 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1, Tmp2, Tmp3); 06469 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06470 Result = SDOperand(ResNode, 0); 06471 } 06472 return; 06473 } 06474 void Emit_84(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 06475 SDOperand Tmp0(0, 0); 06476 SDOperand Tmp1(0, 0); 06477 SDOperand Tmp2(0, 0); 06478 SDNode *ResNode = NULL; 06479 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 06480 Select(Tmp0, N0); 06481 Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getValue()), MVT::i32); 06482 Tmp2 = Transform_SHL64(Tmp1.Val); 06483 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 06484 if (N.Val->hasOneUse()) { 06485 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1, Tmp2); 06486 } else { 06487 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1, Tmp2); 06488 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06489 Result = SDOperand(ResNode, 0); 06490 } 06491 return; 06492 } 06493 void Select_shl(SDOperand &Result, SDOperand N) { 06494 SDOperand N0(0, 0); 06495 SDOperand N1(0, 0); 06496 SDOperand Tmp0(0, 0); 06497 SDOperand Tmp1(0, 0); 06498 SDOperand Tmp2(0, 0); 06499 SDOperand Tmp3(0, 0); 06500 SDNode *ResNode = NULL; 06501 N0 = N.getOperand(0); 06502 N1 = N.getOperand(1); 06503 if (N1.getOpcode() == ISD::Constant) { 06504 06505 // Pattern: (shl:i32 GPRC:i32:$in, (imm:i32):$imm) 06506 // Emits: (RLWINM:i32 GPRC:i32:$in, (imm:i32):$imm, 0:i32, (SHL32:i32 (imm:i32):$imm)) 06507 // Pattern complexity = 4 cost = 1 size = 0 06508 if (N.Val->getValueType(0) == MVT::i32 && 06509 N1.Val->getValueType(0) == MVT::i32) { 06510 Emit_83(Result, N, PPC::RLWINM, MVT::i32, N0, N1); 06511 return; 06512 } 06513 06514 // Pattern: (shl:i64 G8RC:i64:$in, (imm:i32):$imm) 06515 // Emits: (RLDICR:i64 G8RC:i64:$in, (imm:i32):$imm, (SHL64:i32 (imm:i32):$imm)) 06516 // Pattern complexity = 4 cost = 1 06517 if (N.Val->getValueType(0) == MVT::i64 && 06518 N1.Val->getValueType(0) == MVT::i32) { 06519 Emit_84(Result, N, PPC::RLDICR, MVT::i64, N0, N1); 06520 return; 06521 } 06522 } 06523 06524 // Pattern: (shl:i64 G8RC:i64:$rS, G8RC:i64:$rB) 06525 // Emits: (SLD:i64 G8RC:i64:$rS, G8RC:i64:$rB) 06526 // Pattern complexity = 2 cost = 1 size = 0 06527 if (N.Val->getValueType(0) == MVT::i64 && 06528 N1.Val->getValueType(0) == MVT::i64) { 06529 Emit_24(Result, N, PPC::SLD, MVT::i64, N0, N1); 06530 return; 06531 } 06532 06533 // Pattern: (shl:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06534 // Emits: (SLW:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06535 // Pattern complexity = 2 cost = 1 06536 if (N.Val->getValueType(0) == MVT::i32 && 06537 N1.Val->getValueType(0) == MVT::i32) { 06538 Emit_24(Result, N, PPC::SLW, MVT::i32, N0, N1); 06539 return; 06540 } 06541 std::cerr << "Cannot yet select: "; 06542 N.Val->dump(CurDAG); 06543 std::cerr << '\n'; 06544 abort(); 06545 } 06546 06547 void Select_sra(SDOperand &Result, SDOperand N) { 06548 SDOperand N0(0, 0); 06549 SDOperand N1(0, 0); 06550 SDOperand Tmp0(0, 0); 06551 SDOperand Tmp1(0, 0); 06552 SDNode *ResNode = NULL; 06553 N0 = N.getOperand(0); 06554 N1 = N.getOperand(1); 06555 if (N1.getOpcode() == ISD::Constant) { 06556 06557 // Pattern: (sra:i32 GPRC:i32:$rS, (imm:i32):$SH) 06558 // Emits: (SRAWI:i32 GPRC:i32:$rS, (imm:i32):$SH) 06559 // Pattern complexity = 4 cost = 1 size = 0 06560 if (N.Val->getValueType(0) == MVT::i32 && 06561 N1.Val->getValueType(0) == MVT::i32) { 06562 Emit_19(Result, N, PPC::SRAWI, MVT::i32, N0, N1); 06563 return; 06564 } 06565 06566 // Pattern: (sra:i64 G8RC:i64:$rS, (imm:i32):$SH) 06567 // Emits: (SRADI:i64 G8RC:i64:$rS, (imm:i32):$SH) 06568 // Pattern complexity = 4 cost = 1 06569 if (N.Val->getValueType(0) == MVT::i64 && 06570 N1.Val->getValueType(0) == MVT::i32) { 06571 Emit_19(Result, N, PPC::SRADI, MVT::i64, N0, N1); 06572 return; 06573 } 06574 } 06575 06576 // Pattern: (sra:i64 G8RC:i64:$rS, G8RC:i64:$rB) 06577 // Emits: (SRAD:i64 G8RC:i64:$rS, G8RC:i64:$rB) 06578 // Pattern complexity = 2 cost = 1 size = 0 06579 if (N.Val->getValueType(0) == MVT::i64 && 06580 N1.Val->getValueType(0) == MVT::i64) { 06581 Emit_24(Result, N, PPC::SRAD, MVT::i64, N0, N1); 06582 return; 06583 } 06584 06585 // Pattern: (sra:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06586 // Emits: (SRAW:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06587 // Pattern complexity = 2 cost = 1 06588 if (N.Val->getValueType(0) == MVT::i32 && 06589 N1.Val->getValueType(0) == MVT::i32) { 06590 Emit_24(Result, N, PPC::SRAW, MVT::i32, N0, N1); 06591 return; 06592 } 06593 std::cerr << "Cannot yet select: "; 06594 N.Val->dump(CurDAG); 06595 std::cerr << '\n'; 06596 abort(); 06597 } 06598 06599 void Emit_85(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 06600 SDOperand Tmp0(0, 0); 06601 SDOperand Tmp1(0, 0); 06602 SDOperand Tmp2(0, 0); 06603 SDOperand Tmp3(0, 0); 06604 SDNode *ResNode = NULL; 06605 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 06606 Select(Tmp0, N0); 06607 Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getValue()), MVT::i32); 06608 Tmp2 = Transform_SRL32(Tmp1.Val); 06609 Tmp3 = CurDAG->getTargetConstant(31, MVT::i32); 06610 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 06611 if (N.Val->hasOneUse()) { 06612 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp2, Tmp1, Tmp3); 06613 } else { 06614 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp2, Tmp1, Tmp3); 06615 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06616 Result = SDOperand(ResNode, 0); 06617 } 06618 return; 06619 } 06620 void Emit_86(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 06621 SDOperand Tmp0(0, 0); 06622 SDOperand Tmp1(0, 0); 06623 SDOperand Tmp2(0, 0); 06624 SDNode *ResNode = NULL; 06625 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 06626 Select(Tmp0, N0); 06627 Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N1)->getValue()), MVT::i32); 06628 Tmp2 = Transform_SRL64(Tmp1.Val); 06629 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 06630 if (N.Val->hasOneUse()) { 06631 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp2, Tmp1); 06632 } else { 06633 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp2, Tmp1); 06634 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06635 Result = SDOperand(ResNode, 0); 06636 } 06637 return; 06638 } 06639 void Select_srl(SDOperand &Result, SDOperand N) { 06640 SDOperand N0(0, 0); 06641 SDOperand N1(0, 0); 06642 SDOperand Tmp0(0, 0); 06643 SDOperand Tmp1(0, 0); 06644 SDOperand Tmp2(0, 0); 06645 SDOperand Tmp3(0, 0); 06646 SDNode *ResNode = NULL; 06647 N0 = N.getOperand(0); 06648 N1 = N.getOperand(1); 06649 if (N1.getOpcode() == ISD::Constant) { 06650 06651 // Pattern: (srl:i32 GPRC:i32:$in, (imm:i32):$imm) 06652 // Emits: (RLWINM:i32 GPRC:i32:$in, (SRL32:i32 (imm:i32):$imm), (imm:i32):$imm, 31:i32) 06653 // Pattern complexity = 4 cost = 1 size = 0 06654 if (N.Val->getValueType(0) == MVT::i32 && 06655 N1.Val->getValueType(0) == MVT::i32) { 06656 Emit_85(Result, N, PPC::RLWINM, MVT::i32, N0, N1); 06657 return; 06658 } 06659 06660 // Pattern: (srl:i64 G8RC:i64:$in, (imm:i32):$imm) 06661 // Emits: (RLDICL:i64 G8RC:i64:$in, (SRL64:i32 (imm:i32):$imm), (imm:i32):$imm) 06662 // Pattern complexity = 4 cost = 1 06663 if (N.Val->getValueType(0) == MVT::i64 && 06664 N1.Val->getValueType(0) == MVT::i32) { 06665 Emit_86(Result, N, PPC::RLDICL, MVT::i64, N0, N1); 06666 return; 06667 } 06668 } 06669 06670 // Pattern: (srl:i64 G8RC:i64:$rS, G8RC:i64:$rB) 06671 // Emits: (SRD:i64 G8RC:i64:$rS, G8RC:i64:$rB) 06672 // Pattern complexity = 2 cost = 1 size = 0 06673 if (N.Val->getValueType(0) == MVT::i64 && 06674 N1.Val->getValueType(0) == MVT::i64) { 06675 Emit_24(Result, N, PPC::SRD, MVT::i64, N0, N1); 06676 return; 06677 } 06678 06679 // Pattern: (srl:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06680 // Emits: (SRW:i32 GPRC:i32:$rS, GPRC:i32:$rB) 06681 // Pattern complexity = 2 cost = 1 06682 if (N.Val->getValueType(0) == MVT::i32 && 06683 N1.Val->getValueType(0) == MVT::i32) { 06684 Emit_24(Result, N, PPC::SRW, MVT::i32, N0, N1); 06685 return; 06686 } 06687 std::cerr << "Cannot yet select: "; 06688 N.Val->dump(CurDAG); 06689 std::cerr << '\n'; 06690 abort(); 06691 } 06692 06693 void Select_store(SDOperand &Result, SDOperand N) { 06694 SDOperand CPTmp0(0, 0); 06695 SDOperand CPTmp1(0, 0); 06696 SDOperand Chain(0, 0); 06697 SDOperand N1(0, 0); 06698 SDOperand N2(0, 0); 06699 SDOperand Tmp0(0, 0); 06700 SDOperand Tmp1(0, 0); 06701 SDOperand Tmp2(0, 0); 06702 SDNode *ResNode = NULL; 06703 Chain = N.getOperand(0); 06704 N1 = N.getOperand(1); 06705 N2 = N.getOperand(2); 06706 06707 // Pattern: (store:void GPRC:i32:$rS, iaddr:iPTR:$src) 06708 // Emits: (STW:void GPRC:i32:$rS, iaddr:iPTR:$src) 06709 // Pattern complexity = 8 cost = 1 size = 0 06710 if (N1.Val->getValueType(0) == MVT::i32) { 06711 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 06712 bool Match = SelectAddrImm(N2, CPTmp0, CPTmp1); 06713 if (!Match) { 06714 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 06715 } 06716 if (Match) { 06717 Emit_12(Result, N, PPC::STW, CPTmp0, CPTmp1, Chain, N1, N2); 06718 return; 06719 } 06720 } 06721 06722 // Pattern: (store:void F4RC:f32:$rS, iaddr:iPTR:$dst) 06723 // Emits: (STFS:void F4RC:f32:$rS, iaddr:iPTR:$dst) 06724 // Pattern complexity = 8 cost = 1 size = 0 06725 if (N1.Val->getValueType(0) == MVT::f32) { 06726 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 06727 bool Match = SelectAddrImm(N2, CPTmp0, CPTmp1); 06728 if (!Match) { 06729 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 06730 } 06731 if (Match) { 06732 Emit_12(Result, N, PPC::STFS, CPTmp0, CPTmp1, Chain, N1, N2); 06733 return; 06734 } 06735 } 06736 06737 // Pattern: (store:void F8RC:f64:$rS, iaddr:iPTR:$dst) 06738 // Emits: (STFD:void F8RC:f64:$rS, iaddr:iPTR:$dst) 06739 // Pattern complexity = 8 cost = 1 size = 0 06740 if (N1.Val->getValueType(0) == MVT::f64) { 06741 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 06742 bool Match = SelectAddrImm(N2, CPTmp0, CPTmp1); 06743 if (!Match) { 06744 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 06745 } 06746 if (Match) { 06747 Emit_12(Result, N, PPC::STFD, CPTmp0, CPTmp1, Chain, N1, N2); 06748 return; 06749 } 06750 } 06751 06752 // Pattern: (store:void GPRC:i32:$rS, xaddr:iPTR:$dst) 06753 // Emits: (STWX:void GPRC:i32:$rS, xaddr:iPTR:$dst) 06754 // Pattern complexity = 8 cost = 1 size = 0 06755 if (N1.Val->getValueType(0) == MVT::i32) { 06756 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 06757 bool Match = SelectAddrIdx(N2, CPTmp0, CPTmp1); 06758 if (!Match) { 06759 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 06760 } 06761 if (Match) { 06762 Emit_12(Result, N, PPC::STWX, CPTmp0, CPTmp1, Chain, N1, N2); 06763 return; 06764 } 06765 } 06766 06767 // Pattern: (store:void F4RC:f32:$frS, xaddr:iPTR:$dst) 06768 // Emits: (STFSX:void F4RC:f32:$frS, xaddr:iPTR:$dst) 06769 // Pattern complexity = 8 cost = 1 size = 0 06770 if (N1.Val->getValueType(0) == MVT::f32) { 06771 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 06772 bool Match = SelectAddrIdx(N2, CPTmp0, CPTmp1); 06773 if (!Match) { 06774 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 06775 } 06776 if (Match) { 06777 Emit_12(Result, N, PPC::STFSX, CPTmp0, CPTmp1, Chain, N1, N2); 06778 return; 06779 } 06780 } 06781 06782 // Pattern: (store:void F8RC:f64:$frS, xaddr:iPTR:$dst) 06783 // Emits: (STFDX:void F8RC:f64:$frS, xaddr:iPTR:$dst) 06784 // Pattern complexity = 8 cost = 1 size = 0 06785 if (N1.Val->getValueType(0) == MVT::f64) { 06786 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 06787 bool Match = SelectAddrIdx(N2, CPTmp0, CPTmp1); 06788 if (!Match) { 06789 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 06790 } 06791 if (Match) { 06792 Emit_12(Result, N, PPC::STFDX, CPTmp0, CPTmp1, Chain, N1, N2); 06793 return; 06794 } 06795 } 06796 if (N1.Val->getValueType(0) == MVT::i64) { 06797 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 06798 06799 // Pattern: (store:void G8RC:i64:$rS, ixaddr:iPTR:$dst) 06800 // Emits: (STD:void G8RC:i64:$rS, ixaddr:iPTR:$dst) 06801 // Pattern complexity = 8 cost = 1 size = 0 06802 { 06803 bool Match = SelectAddrImmShift(N2, CPTmp0, CPTmp1); 06804 if (!Match) { 06805 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 06806 } 06807 if (Match) { 06808 Emit_12(Result, N, PPC::STD, CPTmp0, CPTmp1, Chain, N1, N2); 06809 return; 06810 } 06811 } 06812 06813 // Pattern: (store:void G8RC:i64:$rS, xaddr:iPTR:$dst) 06814 // Emits: (STDX:void G8RC:i64:$rS, xaddr:iPTR:$dst) 06815 // Pattern complexity = 8 cost = 1 06816 bool Match = SelectAddrIdx(N2, CPTmp0, CPTmp1); 06817 if (!Match) { 06818 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 06819 } 06820 if (Match) { 06821 Emit_12(Result, N, PPC::STDX, CPTmp0, CPTmp1, Chain, N1, N2); 06822 return; 06823 } 06824 } 06825 06826 // Pattern: (store:void VRRC:v4i32:$rS, xoaddr:iPTR:$dst) 06827 // Emits: (STVX:void VRRC:v4i32:$rS, xoaddr:iPTR:$dst) 06828 // Pattern complexity = 8 cost = 1 06829 if (N1.Val->getValueType(0) == MVT::v4i32) { 06830 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 06831 bool Match = SelectAddrIdxOnly(N2, CPTmp0, CPTmp1); 06832 if (!Match) { 06833 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 06834 } 06835 if (Match) { 06836 Emit_12(Result, N, PPC::STVX, CPTmp0, CPTmp1, Chain, N1, N2); 06837 return; 06838 } 06839 } 06840 std::cerr << "Cannot yet select: "; 06841 N.Val->dump(CurDAG); 06842 std::cerr << '\n'; 06843 abort(); 06844 } 06845 06846 void Emit_87(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 06847 SDOperand Tmp1(0, 0); 06848 SDNode *ResNode = NULL; 06849 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 06850 Select(Tmp1, N1); 06851 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 06852 if (N.Val->hasOneUse()) { 06853 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1); 06854 } else { 06855 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1); 06856 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06857 Result = SDOperand(ResNode, 0); 06858 } 06859 return; 06860 } 06861 void Emit_88(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 06862 SDOperand Tmp0(0, 0); 06863 SDOperand Tmp1(0, 0); 06864 SDNode *ResNode = NULL; 06865 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 06866 Select(Tmp0, N1); 06867 Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N0)->getValue()), MVT::i32); 06868 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 06869 if (N.Val->hasOneUse()) { 06870 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1); 06871 } else { 06872 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1); 06873 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06874 Result = SDOperand(ResNode, 0); 06875 } 06876 return; 06877 } 06878 void Emit_89(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 06879 SDOperand Tmp0(0, 0); 06880 SDOperand Tmp1(0, 0); 06881 SDNode *ResNode = NULL; 06882 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 06883 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 06884 Select(Tmp0, N1); 06885 Select(Tmp1, N0); 06886 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 06887 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 06888 if (N.Val->hasOneUse()) { 06889 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1); 06890 } else { 06891 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1); 06892 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 06893 Result = SDOperand(ResNode, 0); 06894 } 06895 return; 06896 } 06897 void Select_sub(SDOperand &Result, SDOperand N) { 06898 SDOperand N0(0, 0); 06899 SDOperand N1(0, 0); 06900 SDOperand Tmp0(0, 0); 06901 SDOperand Tmp1(0, 0); 06902 SDNode *ResNode = NULL; 06903 N0 = N.getOperand(0); 06904 06905 // Pattern: (sub:i32 0:i32, GPRC:i32:$rA) 06906 // Emits: (NEG:i32 GPRC:i32:$rA) 06907 // Pattern complexity = 5 cost = 1 size = 0 06908 if (isa<ConstantSDNode>(N0)) { 06909 int64_t CN0 = cast<ConstantSDNode>(N0)->getSignExtended(); 06910 if (CN0 == 0) { 06911 N1 = N.getOperand(1); 06912 if (N.Val->getValueType(0) == MVT::i32) { 06913 Emit_87(Result, N, PPC::NEG, MVT::i32, N0, N1); 06914 return; 06915 } 06916 } 06917 } 06918 06919 // Pattern: (sub:i32 (imm:i32)<<P:Predicate_immSExt16>>:$imm, GPRC:i32:$in) 06920 // Emits: (SUBFIC:i32 GPRC:i32:$in, (imm:i32):$imm) 06921 // Pattern complexity = 5 cost = 1 size = 0 06922 if (N0.getOpcode() == ISD::Constant && 06923 Predicate_immSExt16(N0.Val)) { 06924 N1 = N.getOperand(1); 06925 if (N.Val->getValueType(0) == MVT::i32) { 06926 Emit_88(Result, N, PPC::SUBFIC, MVT::i32, N0, N1); 06927 return; 06928 } 06929 } 06930 N1 = N.getOperand(1); 06931 06932 // Pattern: (sub:i32 GPRC:i32:$rB, GPRC:i32:$rA) 06933 // Emits: (SUBF:i32 GPRC:i32:$rA, GPRC:i32:$rB) 06934 // Pattern complexity = 2 cost = 1 size = 0 06935 if (N.Val->getValueType(0) == MVT::i32) { 06936 Emit_89(Result, N, PPC::SUBF, MVT::i32, N0, N1); 06937 return; 06938 } 06939 06940 // Pattern: (sub:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 06941 // Emits: (VSUBUBM:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 06942 // Pattern complexity = 2 cost = 1 size = 0 06943 if (N.Val->getValueType(0) == MVT::v16i8) { 06944 Emit_24(Result, N, PPC::VSUBUBM, MVT::v16i8, N0, N1); 06945 return; 06946 } 06947 06948 // Pattern: (sub:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 06949 // Emits: (VSUBUHM:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB) 06950 // Pattern complexity = 2 cost = 1 size = 0 06951 if (N.Val->getValueType(0) == MVT::v8i16) { 06952 Emit_24(Result, N, PPC::VSUBUHM, MVT::v8i16, N0, N1); 06953 return; 06954 } 06955 06956 // Pattern: (sub:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 06957 // Emits: (VSUBUWM:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 06958 // Pattern complexity = 2 cost = 1 size = 0 06959 if (N.Val->getValueType(0) == MVT::v4i32) { 06960 Emit_24(Result, N, PPC::VSUBUWM, MVT::v4i32, N0, N1); 06961 return; 06962 } 06963 06964 // Pattern: (sub:i64 G8RC:i64:$rB, G8RC:i64:$rA) 06965 // Emits: (SUBF8:i64 G8RC:i64:$rA, G8RC:i64:$rB) 06966 // Pattern complexity = 2 cost = 1 06967 if (N.Val->getValueType(0) == MVT::i64) { 06968 Emit_89(Result, N, PPC::SUBF8, MVT::i64, N0, N1); 06969 return; 06970 } 06971 std::cerr << "Cannot yet select: "; 06972 N.Val->dump(CurDAG); 06973 std::cerr << '\n'; 06974 abort(); 06975 } 06976 06977 void Emit_90(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 06978 SDOperand InFlag(0, 0); 06979 SDOperand Tmp0(0, 0); 06980 SDOperand Tmp1(0, 0); 06981 SDNode *ResNode = NULL; 06982 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 06983 Select(Tmp0, N1); 06984 Tmp1 = CurDAG->getTargetConstant(((unsigned) cast<ConstantSDNode>(N0)->getValue()), MVT::i32); 06985 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 06986 ResNode = CurDAG->getTargetNode(Opc0, VT0, MVT::Flag, Tmp0, Tmp1); 06987 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 06988 InFlag = SDOperand(ResNode, 1); 06989 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 06990 Result = SDOperand(ResNode, N.ResNo); 06991 return; 06992 } 06993 void Emit_91(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 06994 SDOperand InFlag(0, 0); 06995 SDOperand Tmp0(0, 0); 06996 SDOperand Tmp1(0, 0); 06997 SDNode *ResNode = NULL; 06998 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 06999 Select(Tmp0, N1); 07000 Tmp1 = CurDAG->getTargetConstant(((uint64_t) cast<ConstantSDNode>(N0)->getValue()), MVT::i64); 07001 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07002 ResNode = CurDAG->getTargetNode(Opc0, VT0, MVT::Flag, Tmp0, Tmp1); 07003 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07004 InFlag = SDOperand(ResNode, 1); 07005 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 07006 Result = SDOperand(ResNode, N.ResNo); 07007 return; 07008 } 07009 void Emit_92(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 07010 SDOperand InFlag(0, 0); 07011 SDOperand Tmp0(0, 0); 07012 SDOperand Tmp1(0, 0); 07013 SDNode *ResNode = NULL; 07014 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 07015 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 07016 Select(Tmp0, N1); 07017 Select(Tmp1, N0); 07018 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07019 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 07020 ResNode = CurDAG->getTargetNode(Opc0, VT0, MVT::Flag, Tmp0, Tmp1); 07021 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07022 InFlag = SDOperand(ResNode, 1); 07023 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 07024 Result = SDOperand(ResNode, N.ResNo); 07025 return; 07026 } 07027 void Select_subc(SDOperand &Result, SDOperand N) { 07028 SDOperand InFlag(0, 0); 07029 SDOperand N0(0, 0); 07030 SDOperand N1(0, 0); 07031 SDOperand Tmp0(0, 0); 07032 SDOperand Tmp1(0, 0); 07033 SDNode *ResNode = NULL; 07034 N0 = N.getOperand(0); 07035 if (N0.getOpcode() == ISD::Constant && 07036 Predicate_immSExt16(N0.Val)) { 07037 N1 = N.getOperand(1); 07038 07039 // Pattern: (subc:i32 (imm:i32)<<P:Predicate_immSExt16>>:$imm, GPRC:i32:$rA) 07040 // Emits: (SUBFIC:i32 GPRC:i32:$rA, (imm:i32):$imm) 07041 // Pattern complexity = 5 cost = 1 size = 0 07042 if (N.Val->getValueType(0) == MVT::i32) { 07043 Emit_90(Result, N, PPC::SUBFIC, MVT::i32, N0, N1); 07044 return; 07045 } 07046 07047 // Pattern: (subc:i64 (imm:i64)<<P:Predicate_immSExt16>>:$imm, G8RC:i64:$rA) 07048 // Emits: (SUBFIC8:i64 G8RC:i64:$rA, (imm:i64):$imm) 07049 // Pattern complexity = 5 cost = 1 07050 if (N.Val->getValueType(0) == MVT::i64) { 07051 Emit_91(Result, N, PPC::SUBFIC8, MVT::i64, N0, N1); 07052 return; 07053 } 07054 } 07055 07056 // Pattern: (subc:i32 GPRC:i32:$rB, GPRC:i32:$rA) 07057 // Emits: (SUBFC:i32 GPRC:i32:$rA, GPRC:i32:$rB) 07058 // Pattern complexity = 2 cost = 1 07059 N1 = N.getOperand(1); 07060 if (N.Val->getValueType(0) == MVT::i32) { 07061 Emit_92(Result, N, PPC::SUBFC, MVT::i32, N0, N1); 07062 return; 07063 } 07064 std::cerr << "Cannot yet select: "; 07065 N.Val->dump(CurDAG); 07066 std::cerr << '\n'; 07067 abort(); 07068 } 07069 07070 void Emit_93(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 07071 SDOperand InFlag(0, 0); 07072 SDOperand Tmp0(0, 0); 07073 SDNode *ResNode = NULL; 07074 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 07075 Select(Tmp0, N1); 07076 Select(InFlag, N.getOperand(2)); 07077 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07078 ResNode = CurDAG->getTargetNode(Opc0, VT0, MVT::Flag, Tmp0, InFlag); 07079 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07080 InFlag = SDOperand(ResNode, 1); 07081 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 07082 Result = SDOperand(ResNode, N.ResNo); 07083 return; 07084 } 07085 void Emit_94(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 07086 SDOperand InFlag(0, 0); 07087 SDOperand Tmp0(0, 0); 07088 SDOperand Tmp1(0, 0); 07089 SDNode *ResNode = NULL; 07090 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 07091 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 07092 Select(Tmp0, N1); 07093 Select(Tmp1, N0); 07094 Select(InFlag, N.getOperand(2)); 07095 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07096 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 07097 ResNode = CurDAG->getTargetNode(Opc0, VT0, MVT::Flag, Tmp0, Tmp1, InFlag); 07098 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0); 07099 InFlag = SDOperand(ResNode, 1); 07100 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo); 07101 Result = SDOperand(ResNode, N.ResNo); 07102 return; 07103 } 07104 void Select_sube(SDOperand &Result, SDOperand N) { 07105 SDOperand InFlag(0, 0); 07106 SDOperand N0(0, 0); 07107 SDOperand N1(0, 0); 07108 SDOperand Tmp0(0, 0); 07109 SDOperand Tmp1(0, 0); 07110 SDNode *ResNode = NULL; 07111 N0 = N.getOperand(0); 07112 07113 // Pattern: (sube:i32 (imm:i32)<<P:Predicate_immAllOnes>>, GPRC:i32:$rA) 07114 // Emits: (SUBFME:i32 GPRC:i32:$rA) 07115 // Pattern complexity = 5 cost = 1 size = 0 07116 if (N0.getOpcode() == ISD::Constant && 07117 Predicate_immAllOnes(N0.Val)) { 07118 N1 = N.getOperand(1); 07119 if (N.Val->getValueType(0) == MVT::i32) { 07120 Emit_93(Result, N, PPC::SUBFME, MVT::i32, N0, N1); 07121 return; 07122 } 07123 } 07124 07125 // Pattern: (sube:i32 0:i32, GPRC:i32:$rA) 07126 // Emits: (SUBFZE:i32 GPRC:i32:$rA) 07127 // Pattern complexity = 5 cost = 1 size = 0 07128 if (isa<ConstantSDNode>(N0)) { 07129 int64_t CN0 = cast<ConstantSDNode>(N0)->getSignExtended(); 07130 if (CN0 == 0) { 07131 N1 = N.getOperand(1); 07132 if (N.Val->getValueType(0) == MVT::i32) { 07133 Emit_29(Result, N, PPC::SUBFZE, MVT::i32, N0, N1); 07134 return; 07135 } 07136 } 07137 } 07138 07139 // Pattern: (sube:i32 GPRC:i32:$rB, GPRC:i32:$rA) 07140 // Emits: (SUBFE:i32 GPRC:i32:$rA, GPRC:i32:$rB) 07141 // Pattern complexity = 2 cost = 1 07142 N1 = N.getOperand(1); 07143 if (N.Val->getValueType(0) == MVT::i32) { 07144 Emit_94(Result, N, PPC::SUBFE, MVT::i32, N0, N1); 07145 return; 07146 } 07147 std::cerr << "Cannot yet select: "; 07148 N.Val->dump(CurDAG); 07149 std::cerr << '\n'; 07150 abort(); 07151 } 07152 07153 void Select_trunc(SDOperand &Result, SDOperand N) { 07154 SDOperand N0(0, 0); 07155 SDOperand Tmp0(0, 0); 07156 SDNode *ResNode = NULL; 07157 N0 = N.getOperand(0); 07158 if (N.Val->getValueType(0) == MVT::i32 && 07159 N0.Val->getValueType(0) == MVT::i64) { 07160 Emit_37(Result, N, PPC::OR8To4, MVT::i32, N0); 07161 return; 07162 } 07163 std::cerr << "Cannot yet select: "; 07164 N.Val->dump(CurDAG); 07165 std::cerr << '\n'; 07166 abort(); 07167 } 07168 07169 void Select_truncst(SDOperand &Result, SDOperand N) { 07170 SDOperand CPTmp0(0, 0); 07171 SDOperand CPTmp1(0, 0); 07172 SDOperand Chain(0, 0); 07173 SDOperand N1(0, 0); 07174 SDOperand N2(0, 0); 07175 SDOperand N3(0, 0); 07176 SDOperand N4(0, 0); 07177 SDOperand Tmp0(0, 0); 07178 SDOperand Tmp1(0, 0); 07179 SDOperand Tmp2(0, 0); 07180 SDNode *ResNode = NULL; 07181 Chain = N.getOperand(0); 07182 N1 = N.getOperand(1); 07183 N2 = N.getOperand(2); 07184 N3 = N.getOperand(3); 07185 N4 = N.getOperand(4); 07186 07187 // Pattern: (truncst:void GPRC:i32:$rS, iaddr:iPTR:$src, srcvalue:Other:$dummy, i8:Other) 07188 // Emits: (STB:void GPRC:i32:$rS, iaddr:iPTR:$src) 07189 // Pattern complexity = 8 cost = 1 size = 0 07190 if (cast<VTSDNode>(N4)->getVT() == MVT::i8 && 07191 N1.Val->getValueType(0) == MVT::i32) { 07192 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 07193 bool Match = SelectAddrImm(N2, CPTmp0, CPTmp1); 07194 if (!Match) { 07195 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07196 } 07197 if (Match) { 07198 Emit_11(Result, N, PPC::STB, CPTmp0, CPTmp1, Chain, N1, N2, N3, N4); 07199 return; 07200 } 07201 } 07202 07203 // Pattern: (truncst:void GPRC:i32:$rS, iaddr:iPTR:$src, srcvalue:Other:$dummy, i16:Other) 07204 // Emits: (STH:void GPRC:i32:$rS, iaddr:iPTR:$src) 07205 // Pattern complexity = 8 cost = 1 size = 0 07206 if (cast<VTSDNode>(N4)->getVT() == MVT::i16 && 07207 N1.Val->getValueType(0) == MVT::i32) { 07208 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 07209 bool Match = SelectAddrImm(N2, CPTmp0, CPTmp1); 07210 if (!Match) { 07211 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07212 } 07213 if (Match) { 07214 Emit_11(Result, N, PPC::STH, CPTmp0, CPTmp1, Chain, N1, N2, N3, N4); 07215 return; 07216 } 07217 } 07218 07219 // Pattern: (truncst:void GPRC:i32:$rS, xaddr:iPTR:$dst, srcvalue:Other:$dummy, i8:Other) 07220 // Emits: (STBX:void GPRC:i32:$rS, xaddr:iPTR:$dst) 07221 // Pattern complexity = 8 cost = 1 size = 0 07222 if (cast<VTSDNode>(N4)->getVT() == MVT::i8 && 07223 N1.Val->getValueType(0) == MVT::i32) { 07224 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 07225 bool Match = SelectAddrIdx(N2, CPTmp0, CPTmp1); 07226 if (!Match) { 07227 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07228 } 07229 if (Match) { 07230 Emit_11(Result, N, PPC::STBX, CPTmp0, CPTmp1, Chain, N1, N2, N3, N4); 07231 return; 07232 } 07233 } 07234 07235 // Pattern: (truncst:void GPRC:i32:$rS, xaddr:iPTR:$dst, srcvalue:Other:$dummy, i16:Other) 07236 // Emits: (STHX:void GPRC:i32:$rS, xaddr:iPTR:$dst) 07237 // Pattern complexity = 8 cost = 1 size = 0 07238 if (cast<VTSDNode>(N4)->getVT() == MVT::i16 && 07239 N1.Val->getValueType(0) == MVT::i32) { 07240 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 07241 bool Match = SelectAddrIdx(N2, CPTmp0, CPTmp1); 07242 if (!Match) { 07243 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07244 } 07245 if (Match) { 07246 Emit_11(Result, N, PPC::STHX, CPTmp0, CPTmp1, Chain, N1, N2, N3, N4); 07247 return; 07248 } 07249 } 07250 07251 // Pattern: (truncst:void G8RC:i64:$rS, iaddr:iPTR:$src, srcvalue:Other:$dummy, i8:Other) 07252 // Emits: (STB8:void G8RC:i64:$rS, iaddr:iPTR:$src) 07253 // Pattern complexity = 8 cost = 1 size = 0 07254 if (cast<VTSDNode>(N4)->getVT() == MVT::i8 && 07255 N1.Val->getValueType(0) == MVT::i64) { 07256 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 07257 bool Match = SelectAddrImm(N2, CPTmp0, CPTmp1); 07258 if (!Match) { 07259 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07260 } 07261 if (Match) { 07262 Emit_11(Result, N, PPC::STB8, CPTmp0, CPTmp1, Chain, N1, N2, N3, N4); 07263 return; 07264 } 07265 } 07266 07267 // Pattern: (truncst:void G8RC:i64:$rS, iaddr:iPTR:$src, srcvalue:Other:$dummy, i16:Other) 07268 // Emits: (STH8:void G8RC:i64:$rS, iaddr:iPTR:$src) 07269 // Pattern complexity = 8 cost = 1 size = 0 07270 if (cast<VTSDNode>(N4)->getVT() == MVT::i16 && 07271 N1.Val->getValueType(0) == MVT::i64) { 07272 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 07273 bool Match = SelectAddrImm(N2, CPTmp0, CPTmp1); 07274 if (!Match) { 07275 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07276 } 07277 if (Match) { 07278 Emit_11(Result, N, PPC::STH8, CPTmp0, CPTmp1, Chain, N1, N2, N3, N4); 07279 return; 07280 } 07281 } 07282 07283 // Pattern: (truncst:void G8RC:i64:$rS, iaddr:iPTR:$src, srcvalue:Other:$dummy, i32:Other) 07284 // Emits: (STW8:void G8RC:i64:$rS, iaddr:iPTR:$src) 07285 // Pattern complexity = 8 cost = 1 size = 0 07286 if (cast<VTSDNode>(N4)->getVT() == MVT::i32 && 07287 N1.Val->getValueType(0) == MVT::i64) { 07288 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 07289 bool Match = SelectAddrImm(N2, CPTmp0, CPTmp1); 07290 if (!Match) { 07291 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07292 } 07293 if (Match) { 07294 Emit_11(Result, N, PPC::STW8, CPTmp0, CPTmp1, Chain, N1, N2, N3, N4); 07295 return; 07296 } 07297 } 07298 07299 // Pattern: (truncst:void G8RC:i64:$rS, xaddr:iPTR:$dst, srcvalue:Other:$dummy, i8:Other) 07300 // Emits: (STBX8:void G8RC:i64:$rS, xaddr:iPTR:$dst) 07301 // Pattern complexity = 8 cost = 1 size = 0 07302 if (cast<VTSDNode>(N4)->getVT() == MVT::i8 && 07303 N1.Val->getValueType(0) == MVT::i64) { 07304 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 07305 bool Match = SelectAddrIdx(N2, CPTmp0, CPTmp1); 07306 if (!Match) { 07307 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07308 } 07309 if (Match) { 07310 Emit_11(Result, N, PPC::STBX8, CPTmp0, CPTmp1, Chain, N1, N2, N3, N4); 07311 return; 07312 } 07313 } 07314 07315 // Pattern: (truncst:void G8RC:i64:$rS, xaddr:iPTR:$dst, srcvalue:Other:$dummy, i16:Other) 07316 // Emits: (STHX8:void G8RC:i64:$rS, xaddr:iPTR:$dst) 07317 // Pattern complexity = 8 cost = 1 size = 0 07318 if (cast<VTSDNode>(N4)->getVT() == MVT::i16 && 07319 N1.Val->getValueType(0) == MVT::i64) { 07320 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 07321 bool Match = SelectAddrIdx(N2, CPTmp0, CPTmp1); 07322 if (!Match) { 07323 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07324 } 07325 if (Match) { 07326 Emit_11(Result, N, PPC::STHX8, CPTmp0, CPTmp1, Chain, N1, N2, N3, N4); 07327 return; 07328 } 07329 } 07330 07331 // Pattern: (truncst:void G8RC:i64:$rS, xaddr:iPTR:$dst, srcvalue:Other:$dummy, i32:Other) 07332 // Emits: (STWX8:void G8RC:i64:$rS, xaddr:iPTR:$dst) 07333 // Pattern complexity = 8 cost = 1 07334 if (cast<VTSDNode>(N4)->getVT() == MVT::i32 && 07335 N1.Val->getValueType(0) == MVT::i64) { 07336 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 07337 bool Match = SelectAddrIdx(N2, CPTmp0, CPTmp1); 07338 if (!Match) { 07339 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07340 } 07341 if (Match) { 07342 Emit_11(Result, N, PPC::STWX8, CPTmp0, CPTmp1, Chain, N1, N2, N3, N4); 07343 return; 07344 } 07345 } 07346 std::cerr << "Cannot yet select: "; 07347 N.Val->dump(CurDAG); 07348 std::cerr << '\n'; 07349 abort(); 07350 } 07351 07352 void Select_udiv(SDOperand &Result, SDOperand N) { 07353 SDOperand N0(0, 0); 07354 SDOperand N1(0, 0); 07355 SDOperand Tmp0(0, 0); 07356 SDOperand Tmp1(0, 0); 07357 SDNode *ResNode = NULL; 07358 N0 = N.getOperand(0); 07359 N1 = N.getOperand(1); 07360 07361 // Pattern: (udiv:i32 GPRC:i32:$rA, GPRC:i32:$rB) 07362 // Emits: (DIVWU:i32 GPRC:i32:$rA, GPRC:i32:$rB) 07363 // Pattern complexity = 2 cost = 1 size = 0 07364 if (N.Val->getValueType(0) == MVT::i32) { 07365 Emit_24(Result, N, PPC::DIVWU, MVT::i32, N0, N1); 07366 return; 07367 } 07368 07369 // Pattern: (udiv:i64 G8RC:i64:$rA, G8RC:i64:$rB) 07370 // Emits: (DIVDU:i64 G8RC:i64:$rA, G8RC:i64:$rB) 07371 // Pattern complexity = 2 cost = 1 07372 if (N.Val->getValueType(0) == MVT::i64) { 07373 Emit_24(Result, N, PPC::DIVDU, MVT::i64, N0, N1); 07374 return; 07375 } 07376 std::cerr << "Cannot yet select: "; 07377 N.Val->dump(CurDAG); 07378 std::cerr << '\n'; 07379 abort(); 07380 } 07381 07382 void Select_undef(SDOperand &Result, SDOperand N) { 07383 SDNode *ResNode = NULL; 07384 07385 // Pattern: (undef:i32) 07386 // Emits: (IMPLICIT_DEF_GPRC:i32) 07387 // Pattern complexity = 2 cost = 1 size = 0 07388 if (N.Val->getValueType(0) == MVT::i32) { 07389 Emit_43(Result, N, PPC::IMPLICIT_DEF_GPRC, MVT::i32); 07390 return; 07391 } 07392 07393 // Pattern: (undef:f64) 07394 // Emits: (IMPLICIT_DEF_F8:f64) 07395 // Pattern complexity = 2 cost = 1 size = 0 07396 if (N.Val->getValueType(0) == MVT::f64) { 07397 Emit_43(Result, N, PPC::IMPLICIT_DEF_F8, MVT::f64); 07398 return; 07399 } 07400 07401 // Pattern: (undef:f32) 07402 // Emits: (IMPLICIT_DEF_F4:f32) 07403 // Pattern complexity = 2 cost = 1 size = 0 07404 if (N.Val->getValueType(0) == MVT::f32) { 07405 Emit_43(Result, N, PPC::IMPLICIT_DEF_F4, MVT::f32); 07406 return; 07407 } 07408 07409 // Pattern: (undef:v4i32) 07410 // Emits: (IMPLICIT_DEF_VRRC:v4i32) 07411 // Pattern complexity = 2 cost = 1 size = 0 07412 if (N.Val->getValueType(0) == MVT::v4i32) { 07413 Emit_43(Result, N, PPC::IMPLICIT_DEF_VRRC, MVT::v4i32); 07414 return; 07415 } 07416 07417 // Pattern: (undef:i64) 07418 // Emits: (IMPLICIT_DEF_G8RC:i64) 07419 // Pattern complexity = 2 cost = 1 size = 0 07420 if (N.Val->getValueType(0) == MVT::i64) { 07421 Emit_43(Result, N, PPC::IMPLICIT_DEF_G8RC, MVT::i64); 07422 return; 07423 } 07424 07425 // Pattern: (undef:v16i8) 07426 // Emits: (IMPLICIT_DEF_VRRC:v16i8) 07427 // Pattern complexity = 2 cost = 1 size = 0 07428 if (N.Val->getValueType(0) == MVT::v16i8) { 07429 Emit_43(Result, N, PPC::IMPLICIT_DEF_VRRC, MVT::v16i8); 07430 return; 07431 } 07432 07433 // Pattern: (undef:v8i16) 07434 // Emits: (IMPLICIT_DEF_VRRC:v8i16) 07435 // Pattern complexity = 2 cost = 1 size = 0 07436 if (N.Val->getValueType(0) == MVT::v8i16) { 07437 Emit_43(Result, N, PPC::IMPLICIT_DEF_VRRC, MVT::v8i16); 07438 return; 07439 } 07440 07441 // Pattern: (undef:v4f32) 07442 // Emits: (IMPLICIT_DEF_VRRC:v4f32) 07443 // Pattern complexity = 2 cost = 1 07444 if (N.Val->getValueType(0) == MVT::v4f32) { 07445 Emit_43(Result, N, PPC::IMPLICIT_DEF_VRRC, MVT::v4f32); 07446 return; 07447 } 07448 std::cerr << "Cannot yet select: "; 07449 N.Val->dump(CurDAG); 07450 std::cerr << '\n'; 07451 abort(); 07452 } 07453 07454 void Emit_95(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N2) NOINLINE { 07455 SDOperand Tmp0(0, 0); 07456 SDOperand Tmp1(0, 0); 07457 SDOperand Tmp2(0, 0); 07458 SDNode *ResNode = NULL; 07459 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 07460 Tmp0 = N2; 07461 Tmp1 = Transform_VSPLTB_get_imm(Tmp0.Val); 07462 Select(Tmp2, N0); 07463 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 07464 if (N.Val->hasOneUse()) { 07465 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1, Tmp2); 07466 } else { 07467 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1, Tmp2); 07468 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07469 Result = SDOperand(ResNode, 0); 07470 } 07471 return; 07472 } 07473 void Emit_96(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N2) NOINLINE { 07474 SDOperand Tmp0(0, 0); 07475 SDOperand Tmp1(0, 0); 07476 SDOperand Tmp2(0, 0); 07477 SDNode *ResNode = NULL; 07478 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 07479 Tmp0 = N2; 07480 Tmp1 = Transform_VSPLTH_get_imm(Tmp0.Val); 07481 Select(Tmp2, N0); 07482 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 07483 if (N.Val->hasOneUse()) { 07484 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1, Tmp2); 07485 } else { 07486 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1, Tmp2); 07487 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07488 Result = SDOperand(ResNode, 0); 07489 } 07490 return; 07491 } 07492 void Emit_97(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N2) NOINLINE { 07493 SDOperand Tmp0(0, 0); 07494 SDOperand Tmp1(0, 0); 07495 SDOperand Tmp2(0, 0); 07496 SDNode *ResNode = NULL; 07497 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 07498 Tmp0 = N2; 07499 Tmp1 = Transform_VSPLTW_get_imm(Tmp0.Val); 07500 Select(Tmp2, N0); 07501 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 07502 if (N.Val->hasOneUse()) { 07503 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp1, Tmp2); 07504 } else { 07505 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp1, Tmp2); 07506 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07507 Result = SDOperand(ResNode, 0); 07508 } 07509 return; 07510 } 07511 void Emit_98(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N2) NOINLINE { 07512 SDOperand Tmp0(0, 0); 07513 SDOperand Tmp1(0, 0); 07514 SDOperand Tmp2(0, 0); 07515 SDNode *ResNode = NULL; 07516 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 07517 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 07518 Select(Tmp0, N0); 07519 Tmp1 = N2; 07520 Tmp2 = Transform_VSLDOI_unary_get_imm(Tmp1.Val); 07521 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 07522 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 07523 if (N.Val->hasOneUse()) { 07524 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp0, Tmp2); 07525 } else { 07526 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp0, Tmp2); 07527 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07528 Result = SDOperand(ResNode, 0); 07529 } 07530 return; 07531 } 07532 void Emit_99(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N2) NOINLINE { 07533 SDOperand Tmp0(0, 0); 07534 SDNode *ResNode = NULL; 07535 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 07536 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 07537 Select(Tmp0, N0); 07538 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 07539 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 07540 if (N.Val->hasOneUse()) { 07541 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp0); 07542 } else { 07543 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp0); 07544 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07545 Result = SDOperand(ResNode, 0); 07546 } 07547 return; 07548 } 07549 void Emit_100(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N2) NOINLINE { 07550 SDOperand Tmp0(0, 0); 07551 SDOperand Tmp1(0, 0); 07552 SDOperand Tmp2(0, 0); 07553 SDOperand Tmp3(0, 0); 07554 SDNode *ResNode = NULL; 07555 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 07556 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 07557 Select(Tmp0, N0); 07558 Select(Tmp1, N1); 07559 Tmp2 = N2; 07560 Tmp3 = Transform_VSLDOI_get_imm(Tmp2.Val); 07561 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 07562 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07563 if (N.Val->hasOneUse()) { 07564 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1, Tmp3); 07565 } else { 07566 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1, Tmp3); 07567 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07568 Result = SDOperand(ResNode, 0); 07569 } 07570 return; 07571 } 07572 void Emit_101(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N2) NOINLINE { 07573 SDOperand Tmp0(0, 0); 07574 SDOperand Tmp1(0, 0); 07575 SDNode *ResNode = NULL; 07576 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 07577 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 07578 Select(Tmp0, N0); 07579 Select(Tmp1, N1); 07580 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 07581 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07582 if (N.Val->hasOneUse()) { 07583 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1); 07584 } else { 07585 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1); 07586 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07587 Result = SDOperand(ResNode, 0); 07588 } 07589 return; 07590 } 07591 void Select_vector_shuffle(SDOperand &Result, SDOperand N) { 07592 SDOperand N0(0, 0); 07593 SDOperand N1(0, 0); 07594 SDOperand N2(0, 0); 07595 SDOperand Tmp0(0, 0); 07596 SDOperand Tmp1(0, 0); 07597 SDOperand Tmp2(0, 0); 07598 SDOperand Tmp3(0, 0); 07599 SDNode *ResNode = NULL; 07600 N0 = N.getOperand(0); 07601 N1 = N.getOperand(1); 07602 if (N1.getOpcode() == ISD::UNDEF) { 07603 N2 = N.getOperand(2); 07604 if (N2.getOpcode() == ISD::BUILD_VECTOR) { 07605 07606 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vB, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VSPLTB_shuffle_mask>><<X:VSPLTB_get_imm>>:$UIMM) 07607 // Emits: (VSPLTB:v16i8 (VSPLTB_get_imm:i32 (build_vector:v16i8):$UIMM), VRRC:v16i8:$vB) 07608 // Pattern complexity = 7 cost = 1 size = 0 07609 if (Predicate_VSPLTB_shuffle_mask(N2.Val) && 07610 N.Val->getValueType(0) == MVT::v16i8) { 07611 Emit_95(Result, N, PPC::VSPLTB, MVT::v16i8, N0, N1, N2); 07612 return; 07613 } 07614 07615 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vB, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VSPLTH_shuffle_mask>><<X:VSPLTH_get_imm>>:$UIMM) 07616 // Emits: (VSPLTH:v16i8 (VSPLTH_get_imm:i32 (build_vector:v16i8):$UIMM), VRRC:v16i8:$vB) 07617 // Pattern complexity = 7 cost = 1 size = 0 07618 if (Predicate_VSPLTH_shuffle_mask(N2.Val) && 07619 N.Val->getValueType(0) == MVT::v16i8) { 07620 Emit_96(Result, N, PPC::VSPLTH, MVT::v16i8, N0, N1, N2); 07621 return; 07622 } 07623 07624 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vB, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VSPLTW_shuffle_mask>><<X:VSPLTW_get_imm>>:$UIMM) 07625 // Emits: (VSPLTW:v16i8 (VSPLTW_get_imm:i32 (build_vector:v16i8):$UIMM), VRRC:v16i8:$vB) 07626 // Pattern complexity = 7 cost = 1 size = 0 07627 if (Predicate_VSPLTW_shuffle_mask(N2.Val) && 07628 N.Val->getValueType(0) == MVT::v16i8) { 07629 Emit_97(Result, N, PPC::VSPLTW, MVT::v16i8, N0, N1, N2); 07630 return; 07631 } 07632 07633 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VSLDOI_unary_shuffle_mask>><<X:VSLDOI_unary_get_imm>>:$in) 07634 // Emits: (VSLDOI:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA, (VSLDOI_unary_get_imm:i32 (build_vector:i32)<<P:Predicate_VSLDOI_unary_shuffle_mask>>:$in)) 07635 // Pattern complexity = 7 cost = 1 size = 0 07636 if (Predicate_VSLDOI_unary_shuffle_mask(N2.Val) && 07637 N.Val->getValueType(0) == MVT::v16i8) { 07638 Emit_98(Result, N, PPC::VSLDOI, MVT::v16i8, N0, N1, N2); 07639 return; 07640 } 07641 07642 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VPKUWUM_unary_shuffle_mask>>:$in) 07643 // Emits: (VPKUWUM:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 07644 // Pattern complexity = 7 cost = 1 size = 0 07645 if (Predicate_VPKUWUM_unary_shuffle_mask(N2.Val) && 07646 N.Val->getValueType(0) == MVT::v16i8) { 07647 Emit_99(Result, N, PPC::VPKUWUM, MVT::v16i8, N0, N1, N2); 07648 return; 07649 } 07650 07651 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VPKUHUM_unary_shuffle_mask>>:$in) 07652 // Emits: (VPKUHUM:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 07653 // Pattern complexity = 7 cost = 1 size = 0 07654 if (Predicate_VPKUHUM_unary_shuffle_mask(N2.Val) && 07655 N.Val->getValueType(0) == MVT::v16i8) { 07656 Emit_99(Result, N, PPC::VPKUHUM, MVT::v16i8, N0, N1, N2); 07657 return; 07658 } 07659 07660 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VMRGLB_unary_shuffle_mask>>:$in) 07661 // Emits: (VMRGLB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 07662 // Pattern complexity = 7 cost = 1 size = 0 07663 if (Predicate_VMRGLB_unary_shuffle_mask(N2.Val) && 07664 N.Val->getValueType(0) == MVT::v16i8) { 07665 Emit_99(Result, N, PPC::VMRGLB, MVT::v16i8, N0, N1, N2); 07666 return; 07667 } 07668 07669 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VMRGLH_unary_shuffle_mask>>:$in) 07670 // Emits: (VMRGLH:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 07671 // Pattern complexity = 7 cost = 1 size = 0 07672 if (Predicate_VMRGLH_unary_shuffle_mask(N2.Val) && 07673 N.Val->getValueType(0) == MVT::v16i8) { 07674 Emit_99(Result, N, PPC::VMRGLH, MVT::v16i8, N0, N1, N2); 07675 return; 07676 } 07677 07678 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VMRGLW_unary_shuffle_mask>>:$in) 07679 // Emits: (VMRGLW:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 07680 // Pattern complexity = 7 cost = 1 size = 0 07681 if (Predicate_VMRGLW_unary_shuffle_mask(N2.Val) && 07682 N.Val->getValueType(0) == MVT::v16i8) { 07683 Emit_99(Result, N, PPC::VMRGLW, MVT::v16i8, N0, N1, N2); 07684 return; 07685 } 07686 07687 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VMRGHB_unary_shuffle_mask>>:$in) 07688 // Emits: (VMRGHB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 07689 // Pattern complexity = 7 cost = 1 size = 0 07690 if (Predicate_VMRGHB_unary_shuffle_mask(N2.Val) && 07691 N.Val->getValueType(0) == MVT::v16i8) { 07692 Emit_99(Result, N, PPC::VMRGHB, MVT::v16i8, N0, N1, N2); 07693 return; 07694 } 07695 07696 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VMRGHH_unary_shuffle_mask>>:$in) 07697 // Emits: (VMRGHH:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 07698 // Pattern complexity = 7 cost = 1 size = 0 07699 if (Predicate_VMRGHH_unary_shuffle_mask(N2.Val) && 07700 N.Val->getValueType(0) == MVT::v16i8) { 07701 Emit_99(Result, N, PPC::VMRGHH, MVT::v16i8, N0, N1, N2); 07702 return; 07703 } 07704 07705 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VMRGHW_unary_shuffle_mask>>:$in) 07706 // Emits: (VMRGHW:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 07707 // Pattern complexity = 7 cost = 1 07708 if (Predicate_VMRGHW_unary_shuffle_mask(N2.Val) && 07709 N.Val->getValueType(0) == MVT::v16i8) { 07710 Emit_99(Result, N, PPC::VMRGHW, MVT::v16i8, N0, N1, N2); 07711 return; 07712 } 07713 } 07714 } 07715 N2 = N.getOperand(2); 07716 if (N2.getOpcode() == ISD::BUILD_VECTOR) { 07717 07718 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VSLDOI_shuffle_mask>><<X:VSLDOI_get_imm>>:$SH) 07719 // Emits: (VSLDOI:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (VSLDOI_get_imm:i32 (build_vector:v16i8):$SH)) 07720 // Pattern complexity = 5 cost = 1 size = 0 07721 if (Predicate_VSLDOI_shuffle_mask(N2.Val) && 07722 N.Val->getValueType(0) == MVT::v16i8) { 07723 Emit_100(Result, N, PPC::VSLDOI, MVT::v16i8, N0, N1, N2); 07724 return; 07725 } 07726 07727 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VMRGHB_shuffle_mask>>) 07728 // Emits: (VMRGHB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 07729 // Pattern complexity = 5 cost = 1 size = 0 07730 if (Predicate_VMRGHB_shuffle_mask(N2.Val) && 07731 N.Val->getValueType(0) == MVT::v16i8) { 07732 Emit_101(Result, N, PPC::VMRGHB, MVT::v16i8, N0, N1, N2); 07733 return; 07734 } 07735 07736 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VMRGHH_shuffle_mask>>) 07737 // Emits: (VMRGHH:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 07738 // Pattern complexity = 5 cost = 1 size = 0 07739 if (Predicate_VMRGHH_shuffle_mask(N2.Val) && 07740 N.Val->getValueType(0) == MVT::v16i8) { 07741 Emit_101(Result, N, PPC::VMRGHH, MVT::v16i8, N0, N1, N2); 07742 return; 07743 } 07744 07745 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VMRGHW_shuffle_mask>>) 07746 // Emits: (VMRGHW:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 07747 // Pattern complexity = 5 cost = 1 size = 0 07748 if (Predicate_VMRGHW_shuffle_mask(N2.Val) && 07749 N.Val->getValueType(0) == MVT::v16i8) { 07750 Emit_101(Result, N, PPC::VMRGHW, MVT::v16i8, N0, N1, N2); 07751 return; 07752 } 07753 07754 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VMRGLB_shuffle_mask>>) 07755 // Emits: (VMRGLB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 07756 // Pattern complexity = 5 cost = 1 size = 0 07757 if (Predicate_VMRGLB_shuffle_mask(N2.Val) && 07758 N.Val->getValueType(0) == MVT::v16i8) { 07759 Emit_101(Result, N, PPC::VMRGLB, MVT::v16i8, N0, N1, N2); 07760 return; 07761 } 07762 07763 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VMRGLH_shuffle_mask>>) 07764 // Emits: (VMRGLH:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 07765 // Pattern complexity = 5 cost = 1 size = 0 07766 if (Predicate_VMRGLH_shuffle_mask(N2.Val) && 07767 N.Val->getValueType(0) == MVT::v16i8) { 07768 Emit_101(Result, N, PPC::VMRGLH, MVT::v16i8, N0, N1, N2); 07769 return; 07770 } 07771 07772 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VMRGLW_shuffle_mask>>) 07773 // Emits: (VMRGLW:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 07774 // Pattern complexity = 5 cost = 1 size = 0 07775 if (Predicate_VMRGLW_shuffle_mask(N2.Val) && 07776 N.Val->getValueType(0) == MVT::v16i8) { 07777 Emit_101(Result, N, PPC::VMRGLW, MVT::v16i8, N0, N1, N2); 07778 return; 07779 } 07780 07781 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VPKUHUM_shuffle_mask>>) 07782 // Emits: (VPKUHUM:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 07783 // Pattern complexity = 5 cost = 1 size = 0 07784 if (Predicate_VPKUHUM_shuffle_mask(N2.Val) && 07785 N.Val->getValueType(0) == MVT::v16i8) { 07786 Emit_101(Result, N, PPC::VPKUHUM, MVT::v16i8, N0, N1, N2); 07787 return; 07788 } 07789 07790 // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VPKUWUM_shuffle_mask>>) 07791 // Emits: (VPKUWUM:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB) 07792 // Pattern complexity = 5 cost = 1 07793 if (Predicate_VPKUWUM_shuffle_mask(N2.Val) && 07794 N.Val->getValueType(0) == MVT::v16i8) { 07795 Emit_101(Result, N, PPC::VPKUWUM, MVT::v16i8, N0, N1, N2); 07796 return; 07797 } 07798 } 07799 std::cerr << "Cannot yet select: "; 07800 N.Val->dump(CurDAG); 07801 std::cerr << '\n'; 07802 abort(); 07803 } 07804 07805 void Emit_102(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N00, SDOperand &N01, SDOperand &N1) NOINLINE { 07806 SDOperand Tmp0(0, 0); 07807 SDOperand Tmp1(0, 0); 07808 SDNode *ResNode = NULL; 07809 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N00.Val); 07810 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N01.Val); 07811 Select(Tmp0, N00); 07812 Select(Tmp1, N01); 07813 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N00.Val); 07814 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N01.Val); 07815 if (N.Val->hasOneUse()) { 07816 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1); 07817 } else { 07818 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1); 07819 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07820 Result = SDOperand(ResNode, 0); 07821 } 07822 return; 07823 } 07824 void Emit_103(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N00, SDOperand &N01, SDOperand &N1) NOINLINE { 07825 SDOperand Tmp0(0, 0); 07826 SDOperand Tmp1(0, 0); 07827 SDNode *ResNode = NULL; 07828 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N00.Val); 07829 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 07830 Select(Tmp0, N00); 07831 Select(Tmp1, N1); 07832 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N00.Val); 07833 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07834 if (N.Val->hasOneUse()) { 07835 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1); 07836 } else { 07837 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1); 07838 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07839 Result = SDOperand(ResNode, 0); 07840 } 07841 return; 07842 } 07843 void Emit_104(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N10, SDOperand &N11) NOINLINE { 07844 SDOperand Tmp0(0, 0); 07845 SDOperand Tmp1(0, 0); 07846 SDNode *ResNode = NULL; 07847 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N10.Val); 07848 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 07849 Select(Tmp0, N10); 07850 Select(Tmp1, N0); 07851 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N10.Val); 07852 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 07853 if (N.Val->hasOneUse()) { 07854 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1); 07855 } else { 07856 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1); 07857 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07858 Result = SDOperand(ResNode, 0); 07859 } 07860 return; 07861 } 07862 void Emit_105(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1, SDOperand &N10, SDOperand &N11) NOINLINE { 07863 SDOperand Tmp0(0, 0); 07864 SDOperand Tmp1(0, 0); 07865 SDNode *ResNode = NULL; 07866 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N10.Val); 07867 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N11.Val); 07868 Select(Tmp0, N10); 07869 Select(Tmp1, N11); 07870 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N10.Val); 07871 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N11.Val); 07872 if (N.Val->hasOneUse()) { 07873 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp1); 07874 } else { 07875 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp1); 07876 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07877 Result = SDOperand(ResNode, 0); 07878 } 07879 return; 07880 } 07881 void Emit_106(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 07882 SDOperand Tmp0(0, 0); 07883 SDNode *ResNode = NULL; 07884 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 07885 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 07886 Select(Tmp0, N0); 07887 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 07888 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 07889 if (N.Val->hasOneUse()) { 07890 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp0); 07891 } else { 07892 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp0); 07893 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07894 Result = SDOperand(ResNode, 0); 07895 } 07896 return; 07897 } 07898 void Emit_107(SDOperand &Result, SDOperand &N, unsigned Opc0, MVT::ValueType VT0, SDOperand &N0, SDOperand &N1) NOINLINE { 07899 SDOperand Tmp0(0, 0); 07900 SDNode *ResNode = NULL; 07901 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 07902 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N1.Val); 07903 Select(Tmp0, N1); 07904 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07905 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N1.Val); 07906 if (N.Val->hasOneUse()) { 07907 Result = CurDAG->SelectNodeTo(N.Val, Opc0, VT0, Tmp0, Tmp0); 07908 } else { 07909 ResNode = CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp0); 07910 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 07911 Result = SDOperand(ResNode, 0); 07912 } 07913 return; 07914 } 07915 void Select_xor(SDOperand &Result, SDOperand N) { 07916 SDOperand N0(0, 0); 07917 SDOperand N00(0, 0); 07918 SDOperand N01(0, 0); 07919 SDOperand N1(0, 0); 07920 SDOperand N10(0, 0); 07921 SDOperand N11(0, 0); 07922 SDOperand Tmp0(0, 0); 07923 SDOperand Tmp1(0, 0); 07924 SDOperand Tmp2(0, 0); 07925 SDOperand Tmp3(0, 0); 07926 SDOperand Tmp4(0, 0); 07927 SDNode *ResNode = NULL; 07928 N0 = N.getOperand(0); 07929 07930 // Pattern: (xor:i32 (and:i32 GPRC:i32:$rS, GPRC:i32:$rB), (imm:i32)<<P:Predicate_immAllOnes>>) 07931 // Emits: (NAND:i32 GPRC:i32:$rS, GPRC:i32:$rB) 07932 // Pattern complexity = 7 cost = 1 size = 0 07933 if (N0.getOpcode() == ISD::AND) { 07934 N00 = N0.getOperand(0); 07935 N01 = N0.getOperand(1); 07936 N1 = N.getOperand(1); 07937 if (N1.getOpcode() == ISD::Constant && 07938 Predicate_immAllOnes(N1.Val) && 07939 N.Val->getValueType(0) == MVT::i32) { 07940 Emit_102(Result, N, PPC::NAND, MVT::i32, N0, N00, N01, N1); 07941 return; 07942 } 07943 } 07944 07945 // Pattern: (xor:i32 (or:i32 GPRC:i32:$rS, GPRC:i32:$rB), (imm:i32)<<P:Predicate_immAllOnes>>) 07946 // Emits: (NOR:i32 GPRC:i32:$rS, GPRC:i32:$rB) 07947 // Pattern complexity = 7 cost = 1 size = 0 07948 if (N0.getOpcode() == ISD::OR) { 07949 N00 = N0.getOperand(0); 07950 N01 = N0.getOperand(1); 07951 N1 = N.getOperand(1); 07952 if (N1.getOpcode() == ISD::Constant && 07953 Predicate_immAllOnes(N1.Val) && 07954 N.Val->getValueType(0) == MVT::i32) { 07955 Emit_102(Result, N, PPC::NOR, MVT::i32, N0, N00, N01, N1); 07956 return; 07957 } 07958 } 07959 07960 // Pattern: (xor:i32 (xor:i32 GPRC:i32:$rS, GPRC:i32:$rB), (imm:i32)<<P:Predicate_immAllOnes>>) 07961 // Emits: (EQV:i32 GPRC:i32:$rS, GPRC:i32:$rB) 07962 // Pattern complexity = 7 cost = 1 size = 0 07963 if (N0.getOpcode() == ISD::XOR) { 07964 N00 = N0.getOperand(0); 07965 N01 = N0.getOperand(1); 07966 N1 = N.getOperand(1); 07967 if (N1.getOpcode() == ISD::Constant && 07968 Predicate_immAllOnes(N1.Val) && 07969 N.Val->getValueType(0) == MVT::i32) { 07970 Emit_102(Result, N, PPC::EQV, MVT::i32, N0, N00, N01, N1); 07971 return; 07972 } 07973 } 07974 07975 // Pattern: (xor:v4i32 (or:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB), (build_vector:v4i32)<<P:Predicate_immAllOnesV>>) 07976 // Emits: (VNOR:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 07977 // Pattern complexity = 7 cost = 1 size = 0 07978 if (N0.getOpcode() == ISD::OR) { 07979 N00 = N0.getOperand(0); 07980 N01 = N0.getOperand(1); 07981 N1 = N.getOperand(1); 07982 if (N1.getOpcode() == ISD::BUILD_VECTOR && 07983 Predicate_immAllOnesV(N1.Val) && 07984 N.Val->getValueType(0) == MVT::v4i32) { 07985 Emit_102(Result, N, PPC::VNOR, MVT::v4i32, N0, N00, N01, N1); 07986 return; 07987 } 07988 } 07989 07990 // Pattern: (xor:i64 (and:i64 G8RC:i64:$rS, G8RC:i64:$rB), (imm:i64)<<P:Predicate_immAllOnes>>) 07991 // Emits: (NAND8:i64 G8RC:i64:$rS, G8RC:i64:$rB) 07992 // Pattern complexity = 7 cost = 1 size = 0 07993 if (N0.getOpcode() == ISD::AND) { 07994 N00 = N0.getOperand(0); 07995 N01 = N0.getOperand(1); 07996 N1 = N.getOperand(1); 07997 if (N1.getOpcode() == ISD::Constant && 07998 Predicate_immAllOnes(N1.Val) && 07999 N.Val->getValueType(0) == MVT::i64) { 08000 Emit_102(Result, N, PPC::NAND8, MVT::i64, N0, N00, N01, N1); 08001 return; 08002 } 08003 } 08004 08005 // Pattern: (xor:i64 (or:i64 G8RC:i64:$rS, G8RC:i64:$rB), (imm:i64)<<P:Predicate_immAllOnes>>) 08006 // Emits: (NOR8:i64 G8RC:i64:$rS, G8RC:i64:$rB) 08007 // Pattern complexity = 7 cost = 1 size = 0 08008 if (N0.getOpcode() == ISD::OR) { 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::i64) { 08015 Emit_102(Result, N, PPC::NOR8, MVT::i64, N0, N00, N01, N1); 08016 return; 08017 } 08018 } 08019 08020 // Pattern: (xor:i64 (xor:i64 G8RC:i64:$rS, G8RC:i64:$rB), (imm:i64)<<P:Predicate_immAllOnes>>) 08021 // Emits: (EQV8:i64 G8RC:i64:$rS, G8RC:i64:$rB) 08022 // Pattern complexity = 7 cost = 1 size = 0 08023 if (N0.getOpcode() == ISD::XOR) { 08024 N00 = N0.getOperand(0); 08025 N01 = N0.getOperand(1); 08026 N1 = N.getOperand(1); 08027 if (N1.getOpcode() == ISD::Constant && 08028 Predicate_immAllOnes(N1.Val) && 08029 N.Val->getValueType(0) == MVT::i64) { 08030 Emit_102(Result, N, PPC::EQV8, MVT::i64, N0, N00, N01, N1); 08031 return; 08032 } 08033 } 08034 08035 // Pattern: (xor:v4i32 (or:v4i32 VRRC:v4i32:$A, VRRC:v4i32:$B), (bitconvert:v4i32)<<P:Predicate_immAllOnesV_bc>>) 08036 // Emits: (VNOR:v4i32 VRRC:v16i8:$A, VRRC:v16i8:$B) 08037 // Pattern complexity = 7 cost = 1 size = 0 08038 if (N0.getOpcode() == ISD::OR) { 08039 N00 = N0.getOperand(0); 08040 N01 = N0.getOperand(1); 08041 N1 = N.getOperand(1); 08042 if (N1.getOpcode() == ISD::BIT_CONVERT && 08043 Predicate_immAllOnesV_bc(N1.Val) && 08044 N.Val->getValueType(0) == MVT::v4i32) { 08045 Emit_102(Result, N, PPC::VNOR, MVT::v4i32, N0, N00, N01, N1); 08046 return; 08047 } 08048 } 08049 08050 // Pattern: (xor:i32 (xor:i32 GPRC:i32:$rS, (imm:i32)<<P:Predicate_immAllOnes>>), GPRC:i32:$rB) 08051 // Emits: (EQV:i32 GPRC:i32:$rS, GPRC:i32:$rB) 08052 // Pattern complexity = 7 cost = 1 size = 0 08053 if (N0.getOpcode() == ISD::XOR) { 08054 N00 = N0.getOperand(0); 08055 N01 = N0.getOperand(1); 08056 if (N01.getOpcode() == ISD::Constant && 08057 Predicate_immAllOnes(N01.Val)) { 08058 N1 = N.getOperand(1); 08059 if (N.Val->getValueType(0) == MVT::i32) { 08060 Emit_103(Result, N, PPC::EQV, MVT::i32, N0, N00, N01, N1); 08061 return; 08062 } 08063 } 08064 } 08065 08066 // Pattern: (xor:i32 GPRC:i32:$rB, (xor:i32 GPRC:i32:$rS, (imm:i32)<<P:Predicate_immAllOnes>>)) 08067 // Emits: (EQV:i32 GPRC:i32:$rS, GPRC:i32:$rB) 08068 // Pattern complexity = 7 cost = 1 size = 0 08069 { 08070 N1 = N.getOperand(1); 08071 if (N1.getOpcode() == ISD::XOR) { 08072 N10 = N1.getOperand(0); 08073 N11 = N1.getOperand(1); 08074 if (N11.getOpcode() == ISD::Constant && 08075 Predicate_immAllOnes(N11.Val) && 08076 N.Val->getValueType(0) == MVT::i32) { 08077 Emit_104(Result, N, PPC::EQV, MVT::i32, N0, N1, N10, N11); 08078 return; 08079 } 08080 } 08081 } 08082 08083 // Pattern: (xor:v4i32 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>, (or:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)) 08084 // Emits: (VNOR:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 08085 // Pattern complexity = 7 cost = 1 size = 0 08086 if (N0.getOpcode() == ISD::BUILD_VECTOR && 08087 Predicate_immAllOnesV(N0.Val)) { 08088 N1 = N.getOperand(1); 08089 if (N1.getOpcode() == ISD::OR) { 08090 N10 = N1.getOperand(0); 08091 N11 = N1.getOperand(1); 08092 if (N.Val->getValueType(0) == MVT::v4i32) { 08093 Emit_105(Result, N, PPC::VNOR, MVT::v4i32, N0, N1, N10, N11); 08094 return; 08095 } 08096 } 08097 } 08098 08099 // Pattern: (xor:i64 (xor:i64 G8RC:i64:$rS, (imm:i64)<<P:Predicate_immAllOnes>>), G8RC:i64:$rB) 08100 // Emits: (EQV8:i64 G8RC:i64:$rS, G8RC:i64:$rB) 08101 // Pattern complexity = 7 cost = 1 size = 0 08102 if (N0.getOpcode() == ISD::XOR) { 08103 N00 = N0.getOperand(0); 08104 N01 = N0.getOperand(1); 08105 if (N01.getOpcode() == ISD::Constant && 08106 Predicate_immAllOnes(N01.Val)) { 08107 N1 = N.getOperand(1); 08108 if (N.Val->getValueType(0) == MVT::i64) { 08109 Emit_103(Result, N, PPC::EQV8, MVT::i64, N0, N00, N01, N1); 08110 return; 08111 } 08112 } 08113 } 08114 08115 // Pattern: (xor:i64 G8RC:i64:$rB, (xor:i64 G8RC:i64:$rS, (imm:i64)<<P:Predicate_immAllOnes>>)) 08116 // Emits: (EQV8:i64 G8RC:i64:$rS, G8RC:i64:$rB) 08117 // Pattern complexity = 7 cost = 1 size = 0 08118 { 08119 N1 = N.getOperand(1); 08120 if (N1.getOpcode() == ISD::XOR) { 08121 N10 = N1.getOperand(0); 08122 N11 = N1.getOperand(1); 08123 if (N11.getOpcode() == ISD::Constant && 08124 Predicate_immAllOnes(N11.Val) && 08125 N.Val->getValueType(0) == MVT::i64) { 08126 Emit_104(Result, N, PPC::EQV8, MVT::i64, N0, N1, N10, N11); 08127 return; 08128 } 08129 } 08130 } 08131 08132 // Pattern: (xor:v4i32 (bitconvert:v4i32)<<P:Predicate_immAllOnesV_bc>>, (or:v4i32 VRRC:v4i32:$A, VRRC:v4i32:$B)) 08133 // Emits: (VNOR:v4i32 VRRC:v16i8:$A, VRRC:v16i8:$B) 08134 // Pattern complexity = 7 cost = 1 size = 0 08135 if (N0.getOpcode() == ISD::BIT_CONVERT && 08136 Predicate_immAllOnesV_bc(N0.Val)) { 08137 N1 = N.getOperand(1); 08138 if (N1.getOpcode() == ISD::OR) { 08139 N10 = N1.getOperand(0); 08140 N11 = N1.getOperand(1); 08141 if (N.Val->getValueType(0) == MVT::v4i32) { 08142 Emit_105(Result, N, PPC::VNOR, MVT::v4i32, N0, N1, N10, N11); 08143 return; 08144 } 08145 } 08146 } 08147 { 08148 N1 = N.getOperand(1); 08149 if (N1.getOpcode() == ISD::Constant) { 08150 08151 // Pattern: (xor:i32 GPRC:i32:$src1, (imm:i32)<<P:Predicate_immZExt16>><<X:LO16>>:$src2) 08152 // Emits: (XORI:i32 GPRC:i32:$src1, (LO16:i32 (imm:i32):$src2)) 08153 // Pattern complexity = 5 cost = 1 size = 0 08154 if (Predicate_immZExt16(N1.Val) && 08155 N.Val->getValueType(0) == MVT::i32) { 08156 Emit_35(Result, N, PPC::XORI, MVT::i32, N0, N1); 08157 return; 08158 } 08159 08160 // Pattern: (xor:i32 GPRC:i32:$src1, (imm:i32)<<P:Predicate_imm16ShiftedZExt>><<X:HI16>>:$src2) 08161 // Emits: (XORIS:i32 GPRC:i32:$src1, (HI16:i32 (imm:i32):$src2)) 08162 // Pattern complexity = 5 cost = 1 size = 0 08163 if (Predicate_imm16ShiftedZExt(N1.Val) && 08164 N.Val->getValueType(0) == MVT::i32) { 08165 Emit_20(Result, N, PPC::XORIS, MVT::i32, N0, N1); 08166 return; 08167 } 08168 08169 // Pattern: (xor:i64 G8RC:i64:$src1, (imm:i64)<<P:Predicate_immZExt16>><<X:LO16>>:$src2) 08170 // Emits: (XORI8:i64 G8RC:i64:$src1, (LO16:i32 (imm:i64):$src2)) 08171 // Pattern complexity = 5 cost = 1 size = 0 08172 if (Predicate_immZExt16(N1.Val) && 08173 N.Val->getValueType(0) == MVT::i64) { 08174 Emit_36(Result, N, PPC::XORI8, MVT::i64, N0, N1); 08175 return; 08176 } 08177 08178 // Pattern: (xor:i64 G8RC:i64:$src1, (imm:i64)<<P:Predicate_imm16ShiftedZExt>><<X:HI16>>:$src2) 08179 // Emits: (XORIS8:i64 G8RC:i64:$src1, (HI16:i32 (imm:i64):$src2)) 08180 // Pattern complexity = 5 cost = 1 size = 0 08181 if (Predicate_imm16ShiftedZExt(N1.Val) && 08182 N.Val->getValueType(0) == MVT::i64) { 08183 Emit_22(Result, N, PPC::XORIS8, MVT::i64, N0, N1); 08184 return; 08185 } 08186 08187 // Pattern: (xor:i32 GPRC:i32:$in, (imm:i32)<<P:Predicate_immAllOnes>>) 08188 // Emits: (NOR:i32 GPRC:i32:$in, GPRC:i32:$in) 08189 // Pattern complexity = 5 cost = 1 08190 if (Predicate_immAllOnes(N1.Val) && 08191 N.Val->getValueType(0) == MVT::i32) { 08192 Emit_106(Result, N, PPC::NOR, MVT::i32, N0, N1); 08193 return; 08194 } 08195 } 08196 08197 // Pattern: (xor:v4i32 VRRC:v4i32:$vA, (build_vector:v4i32)<<P:Predicate_immAllOnesV>>) 08198 // Emits: (VNOR:v4i32 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 08199 // Pattern complexity = 5 cost = 1 size = 0 08200 if (N1.getOpcode() == ISD::BUILD_VECTOR && 08201 Predicate_immAllOnesV(N1.Val) && 08202 N.Val->getValueType(0) == MVT::v4i32) { 08203 Emit_106(Result, N, PPC::VNOR, MVT::v4i32, N0, N1); 08204 return; 08205 } 08206 08207 // Pattern: (xor:v4i32 VRRC:v4i32:$vA, (bitconvert:v4i32)<<P:Predicate_immAllOnesV_bc>>) 08208 // Emits: (VNOR:v4i32 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 08209 // Pattern complexity = 5 cost = 1 08210 if (N1.getOpcode() == ISD::BIT_CONVERT && 08211 Predicate_immAllOnesV_bc(N1.Val) && 08212 N.Val->getValueType(0) == MVT::v4i32) { 08213 Emit_106(Result, N, PPC::VNOR, MVT::v4i32, N0, N1); 08214 return; 08215 } 08216 } 08217 08218 // Pattern: (xor:v4i32 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>, VRRC:v4i32:$vA) 08219 // Emits: (VNOR:v4i32 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 08220 // Pattern complexity = 5 cost = 1 size = 0 08221 if (N0.getOpcode() == ISD::BUILD_VECTOR && 08222 Predicate_immAllOnesV(N0.Val)) { 08223 N1 = N.getOperand(1); 08224 if (N.Val->getValueType(0) == MVT::v4i32) { 08225 Emit_107(Result, N, PPC::VNOR, MVT::v4i32, N0, N1); 08226 return; 08227 } 08228 } 08229 08230 // Pattern: (xor:v4i32 (bitconvert:v4i32)<<P:Predicate_immAllOnesV_bc>>, VRRC:v4i32:$vA) 08231 // Emits: (VNOR:v4i32 VRRC:v16i8:$vA, VRRC:v16i8:$vA) 08232 // Pattern complexity = 5 cost = 1 size = 0 08233 if (N0.getOpcode() == ISD::BIT_CONVERT && 08234 Predicate_immAllOnesV_bc(N0.Val)) { 08235 N1 = N.getOperand(1); 08236 if (N.Val->getValueType(0) == MVT::v4i32) { 08237 Emit_107(Result, N, PPC::VNOR, MVT::v4i32, N0, N1); 08238 return; 08239 } 08240 } 08241 N1 = N.getOperand(1); 08242 08243 // Pattern: (xor:i32 GPRC:i32:$in, (imm:i32):$imm) 08244 // Emits: (XORIS:i32 (XORI:i32 GPRC:i32:$in, (LO16:i32 (imm:i32):$imm)), (HI16:i32 (imm:i32):$imm)) 08245 // Pattern complexity = 4 cost = 2 size = 0 08246 if (N1.getOpcode() == ISD::Constant && 08247 N.Val->getValueType(0) == MVT::i32) { 08248 Emit_77(Result, N, PPC::XORI, PPC::XORIS, MVT::i32, MVT::i32, N0, N1); 08249 return; 08250 } 08251 08252 // Pattern: (xor:i32 GPRC:i32:$rS, GPRC:i32:$rB) 08253 // Emits: (XOR:i32 GPRC:i32:$rS, GPRC:i32:$rB) 08254 // Pattern complexity = 2 cost = 1 size = 0 08255 if (N.Val->getValueType(0) == MVT::i32) { 08256 Emit_24(Result, N, PPC::XOR, MVT::i32, N0, N1); 08257 return; 08258 } 08259 08260 // Pattern: (xor:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 08261 // Emits: (VXOR:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB) 08262 // Pattern complexity = 2 cost = 1 size = 0 08263 if (N.Val->getValueType(0) == MVT::v4i32) { 08264 Emit_24(Result, N, PPC::VXOR, MVT::v4i32, N0, N1); 08265 return; 08266 } 08267 08268 // Pattern: (xor:i64 G8RC:i64:$rS, G8RC:i64:$rB) 08269 // Emits: (XOR8:i64 G8RC:i64:$rS, G8RC:i64:$rB) 08270 // Pattern complexity = 2 cost = 1 08271 if (N.Val->getValueType(0) == MVT::i64) { 08272 Emit_24(Result, N, PPC::XOR8, MVT::i64, N0, N1); 08273 return; 08274 } 08275 std::cerr << "Cannot yet select: "; 08276 N.Val->dump(CurDAG); 08277 std::cerr << '\n'; 08278 abort(); 08279 } 08280 08281 void Emit_108(SDOperand &Result, SDOperand &N, unsigned Opc0, unsigned Opc1, MVT::ValueType VT0, MVT::ValueType VT1, SDOperand &N0) NOINLINE { 08282 SDOperand Tmp0(0, 0); 08283 SDOperand Tmp1(0, 0); 08284 SDOperand Tmp2(0, 0); 08285 SDOperand Tmp3(0, 0); 08286 SDNode *ResNode = NULL; 08287 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 08288 SelectionDAG::InsertInFlightSetEntry(InFlightSet, N0.Val); 08289 Select(Tmp0, N0); 08290 Tmp1 = SDOperand(CurDAG->getTargetNode(Opc0, VT0, Tmp0, Tmp0), 0); 08291 Tmp2 = CurDAG->getTargetConstant(0, MVT::i32); 08292 Tmp3 = CurDAG->getTargetConstant(32, MVT::i32); 08293 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 08294 SelectionDAG::RemoveInFlightSetEntry(InFlightSet, N0.Val); 08295 if (N.Val->hasOneUse()) { 08296 Result = CurDAG->SelectNodeTo(N.Val, Opc1, VT1, Tmp1, Tmp2, Tmp3); 08297 } else { 08298 ResNode = CurDAG->getTargetNode(Opc1, VT1, Tmp1, Tmp2, Tmp3); 08299 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0); 08300 Result = SDOperand(ResNode, 0); 08301 } 08302 return; 08303 } 08304 void Select_zext(SDOperand &Result, SDOperand N) { 08305 SDOperand N0(0, 0); 08306 SDOperand Tmp0(0, 0); 08307 SDOperand Tmp1(0, 0); 08308 SDOperand Tmp2(0, 0); 08309 SDOperand Tmp3(0, 0); 08310 SDNode *ResNode = NULL; 08311 N0 = N.getOperand(0); 08312 if (N.Val->getValueType(0) == MVT::i64 && 08313 N0.Val->getValueType(0) == MVT::i32) { 08314 Emit_108(Result, N, PPC::OR4To8, PPC::RLDICL, MVT::i64, MVT::i64, N0); 08315 return; 08316 } 08317 std::cerr << "Cannot yet select: "; 08318 N.Val->dump(CurDAG); 08319 std::cerr << '\n'; 08320 abort(); 08321 } 08322 08323 void Select_zextld(SDOperand &Result, SDOperand N) { 08324 if (N.ResNo == 1 && N.getValue(0).hasOneUse()) { 08325 SDOperand Dummy = CurDAG->getNode(ISD::HANDLENODE, MVT::Other, N); 08326 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Dummy.Val, 0); 08327 SelectionDAG::InsertISelMapEntry(HandleMap, N.Val, 1, Dummy.Val, 0); 08328 Result = Dummy; 08329 return; 08330 } 08331 SDOperand CPTmp0(0, 0); 08332 SDOperand CPTmp1(0, 0); 08333 SDOperand Chain(0, 0); 08334 SDOperand N1(0, 0); 08335 SDOperand N2(0, 0); 08336 SDOperand N3(0, 0); 08337 SDOperand Tmp0(0, 0); 08338 SDOperand Tmp1(0, 0); 08339 SDNode *ResNode = NULL; 08340 Chain = N.getOperand(0); 08341 N1 = N.getOperand(1); 08342 N2 = N.getOperand(2); 08343 N3 = N.getOperand(3); 08344 08345 // Pattern: (zextld:i32 iaddr:iPTR:$src, srcvalue:Other:$dummy, i8:Other) 08346 // Emits: (LBZ:i32 iaddr:iPTR:$src) 08347 // Pattern complexity = 8 cost = 1 size = 0 08348 if (cast<VTSDNode>(N3)->getVT() == MVT::i8 && 08349 N.Val->getValueType(0) == MVT::i32) { 08350 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 08351 if (Match) { 08352 Emit_8(Result, N, PPC::LBZ, MVT::i32, CPTmp0, CPTmp1, Chain, N1, N2, N3); 08353 return; 08354 } 08355 } 08356 08357 // Pattern: (zextld:i32 iaddr:iPTR:$src, srcvalue:Other:$dummy, i16:Other) 08358 // Emits: (LHZ:i32 iaddr:iPTR:$src) 08359 // Pattern complexity = 8 cost = 1 size = 0 08360 if (cast<VTSDNode>(N3)->getVT() == MVT::i16 && 08361 N.Val->getValueType(0) == MVT::i32) { 08362 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 08363 if (Match) { 08364 Emit_8(Result, N, PPC::LHZ, MVT::i32, CPTmp0, CPTmp1, Chain, N1, N2, N3); 08365 return; 08366 } 08367 } 08368 08369 // Pattern: (zextld:i32 xaddr:iPTR:$src, srcvalue:Other:$dummy, i8:Other) 08370 // Emits: (LBZX:i32 xaddr:iPTR:$src) 08371 // Pattern complexity = 8 cost = 1 size = 0 08372 if (cast<VTSDNode>(N3)->getVT() == MVT::i8 && 08373 N.Val->getValueType(0) == MVT::i32) { 08374 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 08375 if (Match) { 08376 Emit_8(Result, N, PPC::LBZX, MVT::i32, CPTmp0, CPTmp1, Chain, N1, N2, N3); 08377 return; 08378 } 08379 } 08380 08381 // Pattern: (zextld:i32 xaddr:iPTR:$src, srcvalue:Other:$dummy, i16:Other) 08382 // Emits: (LHZX:i32 xaddr:iPTR:$src) 08383 // Pattern complexity = 8 cost = 1 size = 0 08384 if (cast<VTSDNode>(N3)->getVT() == MVT::i16 && 08385 N.Val->getValueType(0) == MVT::i32) { 08386 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 08387 if (Match) { 08388 Emit_8(Result, N, PPC::LHZX, MVT::i32, CPTmp0, CPTmp1, Chain, N1, N2, N3); 08389 return; 08390 } 08391 } 08392 08393 // Pattern: (zextld:i64 iaddr:iPTR:$src, srcvalue:Other:$dummy, i8:Other) 08394 // Emits: (LBZ8:i64 iaddr:iPTR:$src) 08395 // Pattern complexity = 8 cost = 1 size = 0 08396 if (cast<VTSDNode>(N3)->getVT() == MVT::i8 && 08397 N.Val->getValueType(0) == MVT::i64) { 08398 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 08399 if (Match) { 08400 Emit_8(Result, N, PPC::LBZ8, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 08401 return; 08402 } 08403 } 08404 08405 // Pattern: (zextld:i64 iaddr:iPTR:$src, srcvalue:Other:$dummy, i16:Other) 08406 // Emits: (LHZ8:i64 iaddr:iPTR:$src) 08407 // Pattern complexity = 8 cost = 1 size = 0 08408 if (cast<VTSDNode>(N3)->getVT() == MVT::i16 && 08409 N.Val->getValueType(0) == MVT::i64) { 08410 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 08411 if (Match) { 08412 Emit_8(Result, N, PPC::LHZ8, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 08413 return; 08414 } 08415 } 08416 08417 // Pattern: (zextld:i64 iaddr:iPTR:$src, srcvalue:Other:$dummy, i32:Other) 08418 // Emits: (LWZ8:i64 iaddr:iPTR:$src) 08419 // Pattern complexity = 8 cost = 1 size = 0 08420 if (cast<VTSDNode>(N3)->getVT() == MVT::i32 && 08421 N.Val->getValueType(0) == MVT::i64) { 08422 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 08423 if (Match) { 08424 Emit_8(Result, N, PPC::LWZ8, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 08425 return; 08426 } 08427 } 08428 08429 // Pattern: (zextld:i64 xaddr:iPTR:$src, srcvalue:Other:$dummy, i8:Other) 08430 // Emits: (LBZX8:i64 xaddr:iPTR:$src) 08431 // Pattern complexity = 8 cost = 1 size = 0 08432 if (cast<VTSDNode>(N3)->getVT() == MVT::i8 && 08433 N.Val->getValueType(0) == MVT::i64) { 08434 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 08435 if (Match) { 08436 Emit_8(Result, N, PPC::LBZX8, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 08437 return; 08438 } 08439 } 08440 08441 // Pattern: (zextld:i64 xaddr:iPTR:$src, srcvalue:Other:$dummy, i16:Other) 08442 // Emits: (LHZX8:i64 xaddr:iPTR:$src) 08443 // Pattern complexity = 8 cost = 1 size = 0 08444 if (cast<VTSDNode>(N3)->getVT() == MVT::i16 && 08445 N.Val->getValueType(0) == MVT::i64) { 08446 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 08447 if (Match) { 08448 Emit_8(Result, N, PPC::LHZX8, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 08449 return; 08450 } 08451 } 08452 08453 // Pattern: (zextld:i64 xaddr:iPTR:$src, srcvalue:Other:$dummy, i32:Other) 08454 // Emits: (LWZX8:i64 xaddr:iPTR:$src) 08455 // Pattern complexity = 8 cost = 1 size = 0 08456 if (cast<VTSDNode>(N3)->getVT() == MVT::i32 && 08457 N.Val->getValueType(0) == MVT::i64) { 08458 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 08459 if (Match) { 08460 Emit_8(Result, N, PPC::LWZX8, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 08461 return; 08462 } 08463 } 08464 if (cast<VTSDNode>(N3)->getVT() == MVT::i1) { 08465 if (N.Val->getValueType(0) == MVT::i32) { 08466 08467 // Pattern: (zextld:i32 iaddr:iPTR:$src, srcvalue:Other:$dummy, i1:Other) 08468 // Emits: (LBZ:i32 iaddr:iPTR:$src) 08469 // Pattern complexity = 8 cost = 1 size = 0 08470 { 08471 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 08472 if (Match) { 08473 Emit_8(Result, N, PPC::LBZ, MVT::i32, CPTmp0, CPTmp1, Chain, N1, N2, N3); 08474 return; 08475 } 08476 } 08477 08478 // Pattern: (zextld:i32 xaddr:iPTR:$src, srcvalue:Other:$dummy, i1:Other) 08479 // Emits: (LBZX:i32 xaddr:iPTR:$src) 08480 // Pattern complexity = 8 cost = 1 08481 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 08482 if (Match) { 08483 Emit_8(Result, N, PPC::LBZX, MVT::i32, CPTmp0, CPTmp1, Chain, N1, N2, N3); 08484 return; 08485 } 08486 } 08487 if (N.Val->getValueType(0) == MVT::i64) { 08488 08489 // Pattern: (zextld:i64 iaddr:iPTR:$src, srcvalue:Other:$dummy, i1:Other) 08490 // Emits: (LBZ8:i64 iaddr:iPTR:$src) 08491 // Pattern complexity = 8 cost = 1 size = 0 08492 { 08493 bool Match = SelectAddrImm(N1, CPTmp0, CPTmp1); 08494 if (Match) { 08495 Emit_8(Result, N, PPC::LBZ8, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 08496 return; 08497 } 08498 } 08499 08500 // Pattern: (zextld:i64 xaddr:iPTR:$src, srcvalue:Other:$dummy, i1:Other) 08501 // Emits: (LBZX8:i64 xaddr:iPTR:$src) 08502 // Pattern complexity = 8 cost = 1 08503 bool Match = SelectAddrIdx(N1, CPTmp0, CPTmp1); 08504 if (Match) { 08505 Emit_8(Result, N, PPC::LBZX8, MVT::i64, CPTmp0, CPTmp1, Chain, N1, N2, N3); 08506 return; 08507 } 08508 } 08509 } 08510 std::cerr << "Cannot yet select: "; 08511 N.Val->dump(CurDAG); 08512 std::cerr << '\n'; 08513 abort(); 08514 } 08515 08516 void Select_INLINEASM(SDOperand& Result, SDOperand N) { 08517 std::vector<SDOperand> Ops(N.Val->op_begin(), N.Val->op_end()); 08518 Select(Ops[0], N.getOperand(0)); // Select the chain. 08519 08520 // Select the flag operand. 08521 if (Ops.back().getValueType() == MVT::Flag) 08522 Select(Ops.back(), Ops.back()); 08523 SelectInlineAsmMemoryOperands(Ops, *CurDAG); 08524 std::vector<MVT::ValueType> VTs; 08525 VTs.push_back(MVT::Other); 08526 VTs.push_back(MVT::Flag); 08527 SDOperand New = CurDAG->getNode(ISD::INLINEASM, VTs, Ops); 08528 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, New.Val, 0); 08529 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, New.Val, 1); 08530 Result = New.getValue(N.ResNo); 08531 return; 08532 } 08533 08534 // The main instruction selector code. 08535 void SelectCode(SDOperand &Result, SDOperand N) { 08536 if (N.getOpcode() >= ISD::BUILTIN_OP_END && 08537 N.getOpcode() < (ISD::BUILTIN_OP_END+PPC::INSTRUCTION_LIST_END)) { 08538 Result = N; 08539 return; // Already selected. 08540 } 08541 08542 std::map<SDOperand, SDOperand>::iterator CGMI = CodeGenMap.find(N); 08543 if (CGMI != CodeGenMap.end()) { 08544 Result = CGMI->second; 08545 return; 08546 } 08547 08548 switch (N.getOpcode()) { 08549 default: break; 08550 case ISD::EntryToken: // These leaves remain the same. 08551 case ISD::BasicBlock: 08552 case ISD::Register: 08553 case ISD::HANDLENODE: 08554 case ISD::TargetConstant: 08555 case ISD::TargetConstantPool: 08556 case ISD::TargetFrameIndex: 08557 case ISD::TargetJumpTable: 08558 case ISD::TargetGlobalAddress: { 08559 Result = N; 08560 return; 08561 } 08562 case ISD::AssertSext: 08563 case ISD::AssertZext: { 08564 SDOperand Tmp0; 08565 Select(Tmp0, N.getOperand(0)); 08566 if (!N.Val->hasOneUse()) 08567 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, Tmp0.Val, Tmp0.ResNo); 08568 Result = Tmp0; 08569 return; 08570 } 08571 case ISD::TokenFactor: 08572 if (N.getNumOperands() == 2) { 08573 SDOperand Op0, Op1; 08574 Select(Op0, N.getOperand(0)); 08575 Select(Op1, N.getOperand(1)); 08576 Result = 08577 CurDAG->getNode(ISD::TokenFactor, MVT::Other, Op0, Op1); 08578 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, Result.Val, Result.ResNo); 08579 } else { 08580 std::vector<SDOperand> Ops; 08581 for (unsigned i = 0, e = N.getNumOperands(); i != e; ++i) { 08582 SDOperand Val; 08583 Select(Val, N.getOperand(i)); 08584 Ops.push_back(Val); 08585 } 08586 Result = 08587 CurDAG->getNode(ISD::TokenFactor, MVT::Other, Ops); 08588 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, Result.Val, Result.ResNo); 08589 } 08590 return; 08591 case ISD::CopyFromReg: { 08592 SDOperand Chain; 08593 Select(Chain, N.getOperand(0)); 08594 unsigned Reg = cast<RegisterSDNode>(N.getOperand(1))->getReg(); 08595 MVT::ValueType VT = N.Val->getValueType(0); 08596 if (N.Val->getNumValues() == 2) { 08597 if (Chain == N.getOperand(0)) { 08598 Result = N; // No change 08599 return; 08600 } 08601 SDOperand New = CurDAG->getCopyFromReg(Chain, Reg, VT); 08602 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, New.Val, 0); 08603 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, New.Val, 1); 08604 Result = New.getValue(N.ResNo); 08605 return; 08606 } else { 08607 SDOperand Flag; 08608 if (N.getNumOperands() == 3) Select(Flag, N.getOperand(2)); 08609 if (Chain == N.getOperand(0) && 08610 (N.getNumOperands() == 2 || Flag == N.getOperand(2))) { 08611 Result = N; // No change 08612 return; 08613 } 08614 SDOperand New = CurDAG->getCopyFromReg(Chain, Reg, VT, Flag); 08615 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, New.Val, 0); 08616 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, New.Val, 1); 08617 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 2, New.Val, 2); 08618 Result = New.getValue(N.ResNo); 08619 return; 08620 } 08621 } 08622 case ISD::CopyToReg: { 08623 SDOperand Chain; 08624 Select(Chain, N.getOperand(0)); 08625 unsigned Reg = cast<RegisterSDNode>(N.getOperand(1))->getReg(); 08626 SDOperand Val; 08627 Select(Val, N.getOperand(2)); 08628 Result = N; 08629 if (N.Val->getNumValues() == 1) { 08630 if (Chain != N.getOperand(0) || Val != N.getOperand(2)) 08631 Result = CurDAG->getCopyToReg(Chain, Reg, Val); 08632 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Result.Val, 0); 08633 } else { 08634 SDOperand Flag(0, 0); 08635 if (N.getNumOperands() == 4) Select(Flag, N.getOperand(3)); 08636 if (Chain != N.getOperand(0) || Val != N.getOperand(2) || 08637 (N.getNumOperands() == 4 && Flag != N.getOperand(3))) 08638 Result = CurDAG->getCopyToReg(Chain, Reg, Val, Flag); 08639 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Result.Val, 0); 08640 SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Result.Val, 1); 08641 Result = Result.getValue(N.ResNo); 08642 } 08643 return; 08644 } 08645 case ISD::INLINEASM: Select_INLINEASM(Result, N); return; 08646 case PPCISD::BCTRL: Select_PPCbctrl(Result, N); return; 08647 case PPCISD::CALL: Select_PPCcall(Result, N); return; 08648 case PPCISD::COND_BRANCH: Select_PPCcondbranch(Result, N); return; 08649 case PPCISD::EXTSW_32: Select_PPCextsw_32(Result, N); return; 08650 case PPCISD::FCFID: Select_PPCfcfid(Result, N); return; 08651 case PPCISD::FCTIDZ: Select_PPCfctidz(Result, N); return; 08652 case PPCISD::FCTIWZ: Select_PPCfctiwz(Result, N); return; 08653 case PPCISD::FSEL: Select_PPCfsel(Result, N); return; 08654 case PPCISD::Hi: Select_PPChi(Result, N); return; 08655 case PPCISD::LBRX: Select_PPClbrx(Result, N); return; 08656 case PPCISD::Lo: Select_PPClo(Result, N); return; 08657 case PPCISD::MTCTR: Select_PPCmtctr(Result, N); return; 08658 case PPCISD::SHL: Select_PPCshl(Result, N); return; 08659 case PPCISD::SRA: Select_PPCsra(Result, N); return; 08660 case PPCISD::SRL: Select_PPCsrl(Result, N); return; 08661 case PPCISD::STBRX: Select_PPCstbrx(Result, N); return; 08662 case PPCISD::STD_32: Select_PPCstd_32(Result, N); return; 08663 case PPCISD::STFIWX: Select_PPCstfiwx(Result, N); return; 08664 case PPCISD::VCMP: Select_PPCvcmp(Result, N); return; 08665 case PPCISD::VCMPo: Select_PPCvcmp_o(Result, N); return; 08666 case PPCISD::VMADDFP: Select_PPCvmaddfp(Result, N); return; 08667 case PPCISD::VNMSUBFP: Select_PPCvnmsubfp(Result, N); return; 08668 case PPCISD::VPERM: Select_PPCvperm(Result, N); return; 08669 case ISD::ADD: Select_add(Result, N); return; 08670 case ISD::ADDC: Select_addc(Result, N); return; 08671 case ISD::ADDE: Select_adde(Result, N); return; 08672 case ISD::AND: Select_and(Result, N); return; 08673 case ISD::ANY_EXTEND: Select_anyext(Result, N); return; 08674 case ISD::BIT_CONVERT: Select_bitconvert(Result, N); return; 08675 case ISD::BR: Select_br(Result, N); return; 08676 case ISD::BUILD_VECTOR: Select_build_vector(Result, N); return; 08677 case ISD::CALLSEQ_END: Select_callseq_end(Result, N); return; 08678 case ISD::CALLSEQ_START: Select_callseq_start(Result, N); return; 08679 case ISD::CTLZ: Select_ctlz(Result, N); return; 08680 case ISD::DEBUG_LABEL: Select_dwarf_label(Result, N); return; 08681 case ISD::DEBUG_LOC: Select_dwarf_loc(Result, N); return; 08682 case ISD::EXTLOAD: Select_extld(Result, N); return; 08683 case ISD::FABS: Select_fabs(Result, N); return; 08684 case ISD::FADD: Select_fadd(Result, N); return; 08685 case ISD::FDIV: Select_fdiv(Result, N); return; 08686 case ISD::FP_EXTEND: Select_fextend(Result, N); return; 08687 case ISD::FMUL: Select_fmul(Result, N); return; 08688 case ISD::FNEG: Select_fneg(Result, N); return; 08689 case ISD::FP_ROUND: Select_fround(Result, N); return; 08690 case ISD::FSQRT: Select_fsqrt(Result, N); return; 08691 case ISD::FSUB: Select_fsub(Result, N); return; 08692 case ISD::Constant: Select_imm(Result, N); return; 08693 case ISD::INTRINSIC_VOID: Select_intrinsic_void(Result, N); return; 08694 case ISD::INTRINSIC_W_CHAIN: Select_intrinsic_w_chain(Result, N); return; 08695 case ISD::INTRINSIC_WO_CHAIN: Select_intrinsic_wo_chain(Result, N); return; 08696 case ISD::LOAD: Select_load(Result, N); return; 08697 case ISD::MUL: Select_mul(Result, N); return; 08698 case ISD::MULHS: Select_mulhs(Result, N); return; 08699 case ISD::MULHU: Select_mulhu(Result, N); return; 08700 case ISD::OR: Select_or(Result, N); return; 08701 case ISD::RET: Select_ret(Result, N); return; 08702 case PPCISD::RET_FLAG: Select_retflag(Result, N); return; 08703 case ISD::ROTL: Select_rotl(Result, N); return; 08704 case ISD::SDIV: Select_sdiv(Result, N); return; 08705 case ISD::SIGN_EXTEND: Select_sext(Result, N); return; 08706 case ISD::SIGN_EXTEND_INREG: Select_sext_inreg(Result, N); return; 08707 case ISD::SEXTLOAD: Select_sextld(Result, N); return; 08708 case ISD::SHL: Select_shl(Result, N); return; 08709 case ISD::SRA: Select_sra(Result, N); return; 08710 case ISD::SRL: Select_srl(Result, N); return; 08711 case ISD::STORE: Select_store(Result, N); return; 08712 case ISD::SUB: Select_sub(Result, N); return; 08713 case ISD::SUBC: Select_subc(Result, N); return; 08714 case ISD::SUBE: Select_sube(Result, N); return; 08715 case ISD::TRUNCATE: Select_trunc(Result, N); return; 08716 case ISD::TRUNCSTORE: Select_truncst(Result, N); return; 08717 case ISD::UDIV: Select_udiv(Result, N); return; 08718 case ISD::UNDEF: Select_undef(Result, N); return; 08719 case ISD::VECTOR_SHUFFLE: Select_vector_shuffle(Result, N); return; 08720 case ISD::XOR: Select_xor(Result, N); return; 08721 case ISD::ZERO_EXTEND: Select_zext(Result, N); return; 08722 case ISD::ZEXTLOAD: Select_zextld(Result, N); return; 08723 } // end of big switch. 08724 08725 std::cerr << "Cannot yet select: "; 08726 if (N.getOpcode() != ISD::INTRINSIC_W_CHAIN && 08727 N.getOpcode() != ISD::INTRINSIC_WO_CHAIN && 08728 N.getOpcode() != ISD::INTRINSIC_VOID) { 08729 N.Val->dump(CurDAG); 08730 } else { 08731 unsigned iid = cast<ConstantSDNode>(N.getOperand(N.getOperand(0).getValueType() == MVT::Other))->getValue(); 08732 std::cerr << "intrinsic %"<< Intrinsic::getName((Intrinsic::ID)iid); 08733 } 08734 std::cerr << '\n'; 08735 abort(); 08736 }