LLVM API Documentation

PPCGenDAGISel.inc

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