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 // Instance var to keep track of multiply used nodes that have 
00013 // already been selected.
00014 std::map<SDOperand, SDOperand> CodeGenMap;
00015 // Instance var to keep track of mapping of chain generating nodes
00016 // and their place handle nodes.
00017 std::map<SDOperand, SDOperand> HandleMap;
00018 // Instance var to keep track of mapping of place handle nodes
00019 // and their replacement nodes.
00020 std::map<SDOperand, SDOperand> ReplaceMap;
00021 
00022 static void findNonImmUse(SDNode* Use, SDNode* Def, bool &found, std::set<SDNode *> &Visited) {
00023   if (found || !Visited.insert(Use).second) return;
00024   for (unsigned i = 0, e = Use->getNumOperands(); i != e; ++i) {
00025     SDNode *N = Use->getOperand(i).Val;
00026     if (N->getNodeDepth() >= Def->getNodeDepth()) {
00027       if (N != Def) {
00028         findNonImmUse(N, Def, found, Visited);
00029       } else {
00030         found = true;
00031         break;
00032       }
00033     }
00034   }
00035 }
00036 
00037 static bool isNonImmUse(SDNode* Use, SDNode* Def) {
00038   std::set<SDNode *> Visited;
00039   bool found = false;
00040   for (unsigned i = 0, e = Use->getNumOperands(); i != e; ++i) {
00041     SDNode *N = Use->getOperand(i).Val;
00042     if (N != Def) {
00043       findNonImmUse(N, Def, found, Visited);
00044       if (found) break;
00045     }
00046   }
00047   return found;
00048 }
00049 
00050 // AddHandleReplacement - Note the pending replacement node for a
00051 // handle node in ReplaceMap.
00052 void AddHandleReplacement(SDNode *H, unsigned HNum, SDNode *R, unsigned RNum) {
00053   SDOperand N(H, HNum);
00054   std::map<SDOperand, SDOperand>::iterator HMI = HandleMap.find(N);
00055   if (HMI != HandleMap.end()) {
00056     ReplaceMap[HMI->second] = SDOperand(R, RNum);
00057     HandleMap.erase(N);
00058   }
00059 }
00060 
00061 // SelectDanglingHandles - Select replacements for all `dangling`
00062 // handles.Some handles do not yet have replacements because the
00063 // nodes they replacements have only dead readers.
00064 void SelectDanglingHandles() {
00065   for (std::map<SDOperand, SDOperand>::iterator I = HandleMap.begin(),
00066          E = HandleMap.end(); I != E; ++I) {
00067     SDOperand N = I->first;
00068     SDOperand R;
00069     Select(R, N.getValue(0));
00070     AddHandleReplacement(N.Val, N.ResNo, R.Val, R.ResNo);
00071   }
00072 }
00073 
00074 // ReplaceHandles - Replace all the handles with the real target
00075 // specific nodes.
00076 void ReplaceHandles() {
00077   for (std::map<SDOperand, SDOperand>::iterator I = ReplaceMap.begin(),
00078         E = ReplaceMap.end(); I != E; ++I) {
00079     SDOperand From = I->first;
00080     SDOperand To   = I->second;
00081     for (SDNode::use_iterator UI = From.Val->use_begin(), E = From.Val->use_end(); UI != E; ++UI) {
00082       SDNode *Use = *UI;
00083       std::vector<SDOperand> Ops;
00084       for (unsigned i = 0, e = Use->getNumOperands(); i != e; ++i) {
00085         SDOperand O = Use->getOperand(i);
00086         if (O.Val == From.Val)
00087           Ops.push_back(To);
00088         else
00089           Ops.push_back(O);
00090       }
00091       SDOperand U = SDOperand(Use, 0);
00092       CurDAG->UpdateNodeOperands(U, Ops);
00093     }
00094   }
00095 }
00096 
00097 // UpdateFoldedChain - return a SDOperand of the new chain created
00098 // if the folding were to happen. This is called when, for example,
00099 // a load is folded into a store. If the store's chain is the load,
00100 // then the resulting node's input chain would be the load's input
00101 // chain. If the store's chain is a TokenFactor and the load's
00102 // output chain feeds into in, then the new chain is a TokenFactor
00103 // with the other operands along with the input chain of the load.
00104 SDOperand UpdateFoldedChain(SelectionDAG *DAG, SDNode *N, SDNode *Chain, SDNode* &OldTF) {
00105   OldTF = NULL;
00106   if (N == Chain) {
00107     return N->getOperand(0);
00108   } else if (Chain->getOpcode() == ISD::TokenFactor &&
00109              N->isOperand(Chain)) {
00110     SDOperand Ch = SDOperand(Chain, 0);
00111     std::map<SDOperand, SDOperand>::iterator CGMI = CodeGenMap.find(Ch);
00112     if (CGMI != CodeGenMap.end())
00113       return SDOperand(0, 0);
00114     OldTF = Chain;
00115     std::vector<SDOperand> Ops;
00116     for (unsigned i = 0; i < Chain->getNumOperands(); ++i) {
00117       SDOperand Op = Chain->getOperand(i);
00118       if (Op.Val == N)
00119         Ops.push_back(N->getOperand(0));
00120       else
00121         Ops.push_back(Op);
00122     }
00123     return DAG->getNode(ISD::TokenFactor, MVT::Other, Ops);
00124   }
00125   return SDOperand(0, 0);
00126 }
00127 
00128 // SelectRoot - Top level entry to DAG isel.
00129 SDOperand SelectRoot(SDOperand N) {
00130   SDOperand ResNode;
00131   Select(ResNode, N);
00132   SelectDanglingHandles();
00133   ReplaceHandles();
00134   ReplaceMap.clear();
00135   return ResNode;
00136 }
00137 
00138 // Node transformations.
00139 inline SDOperand Transform_VSPLTW_get_imm(SDNode *N) {
00140 
00141   return getI32Imm(PPC::getVSPLTImmediate(N, 4));
00142 
00143 }
00144 inline SDOperand Transform_VSPLTISW_get_imm(SDNode *N) {
00145 
00146   return PPC::get_VSPLTI_elt(N, 4, *CurDAG);
00147 
00148 }
00149 inline SDOperand Transform_VSPLTISH_get_imm(SDNode *N) {
00150 
00151   return PPC::get_VSPLTI_elt(N, 2, *CurDAG);
00152 
00153 }
00154 inline SDOperand Transform_VSPLTISB_get_imm(SDNode *N) {
00155 
00156   return PPC::get_VSPLTI_elt(N, 1, *CurDAG);
00157 
00158 }
00159 inline SDOperand Transform_VSPLTH_get_imm(SDNode *N) {
00160 
00161   return getI32Imm(PPC::getVSPLTImmediate(N, 2));
00162 
00163 }
00164 inline SDOperand Transform_VSPLTB_get_imm(SDNode *N) {
00165 
00166   return getI32Imm(PPC::getVSPLTImmediate(N, 1));
00167 
00168 }
00169 inline SDOperand Transform_VSLDOI_unary_get_imm(SDNode *N) {
00170 
00171   return getI32Imm(PPC::isVSLDOIShuffleMask(N, true));
00172 
00173 }
00174 inline SDOperand Transform_VSLDOI_get_imm(SDNode *N) {
00175 
00176   return getI32Imm(PPC::isVSLDOIShuffleMask(N, false));
00177 
00178 }
00179 inline SDOperand Transform_SRL64(SDNode *inN) {
00180   ConstantSDNode *N = cast<ConstantSDNode>(inN);
00181 
00182   // Transformation function: 64 - imm
00183   return N->getValue() ? getI32Imm(64 - N->getValue()) : getI32Imm(0);
00184 
00185 }
00186 inline SDOperand Transform_SRL32(SDNode *inN) {
00187   ConstantSDNode *N = cast<ConstantSDNode>(inN);
00188 
00189   // Transformation function: 32 - imm
00190   return N->getValue() ? getI32Imm(32 - N->getValue()) : getI32Imm(0);
00191 
00192 }
00193 inline SDOperand Transform_SHL64(SDNode *inN) {
00194   ConstantSDNode *N = cast<ConstantSDNode>(inN);
00195 
00196   // Transformation function: 63 - imm
00197   return getI32Imm(63 - N->getValue());
00198 
00199 }
00200 inline SDOperand Transform_SHL32(SDNode *inN) {
00201   ConstantSDNode *N = cast<ConstantSDNode>(inN);
00202 
00203   // Transformation function: 31 - imm
00204   return getI32Imm(31 - N->getValue());
00205 
00206 }
00207 inline SDOperand Transform_LO16(SDNode *inN) {
00208   ConstantSDNode *N = cast<ConstantSDNode>(inN);
00209 
00210   // Transformation function: get the low 16 bits.
00211   return getI32Imm((unsigned short)N->getValue());
00212 
00213 }
00214 inline SDOperand Transform_HI16(SDNode *inN) {
00215   ConstantSDNode *N = cast<ConstantSDNode>(inN);
00216 
00217   // Transformation function: shift the immediate value down into the low bits.
00218   return getI32Imm((unsigned)N->getValue() >> 16);
00219 
00220 }
00221 inline SDOperand Transform_HA16(SDNode *inN) {
00222   ConstantSDNode *N = cast<ConstantSDNode>(inN);
00223 
00224   // Transformation function: shift the immediate value down into the low bits.
00225   signed int Val = N->getValue();
00226   return getI32Imm((Val - (signed short)Val) >> 16);
00227 
00228 }
00229 
00230 // Predicate functions.
00231 inline bool Predicate_VMRGHB_shuffle_mask(SDNode *N) {
00232 
00233   return PPC::isVMRGHShuffleMask(N, 1, false);
00234 
00235 }
00236 inline bool Predicate_VMRGHB_unary_shuffle_mask(SDNode *N) {
00237 
00238   return PPC::isVMRGHShuffleMask(N, 1, true);
00239 
00240 }
00241 inline bool Predicate_VMRGHH_shuffle_mask(SDNode *N) {
00242 
00243   return PPC::isVMRGHShuffleMask(N, 2, false);
00244 
00245 }
00246 inline bool Predicate_VMRGHH_unary_shuffle_mask(SDNode *N) {
00247 
00248   return PPC::isVMRGHShuffleMask(N, 2, true);
00249 
00250 }
00251 inline bool Predicate_VMRGHW_shuffle_mask(SDNode *N) {
00252 
00253   return PPC::isVMRGHShuffleMask(N, 4, false);
00254 
00255 }
00256 inline bool Predicate_VMRGHW_unary_shuffle_mask(SDNode *N) {
00257 
00258   return PPC::isVMRGHShuffleMask(N, 4, true);
00259 
00260 }
00261 inline bool Predicate_VMRGLB_shuffle_mask(SDNode *N) {
00262 
00263   return PPC::isVMRGLShuffleMask(N, 1, false);
00264 
00265 }
00266 inline bool Predicate_VMRGLB_unary_shuffle_mask(SDNode *N) {
00267 
00268   return PPC::isVMRGLShuffleMask(N, 1, true);
00269 
00270 }
00271 inline bool Predicate_VMRGLH_shuffle_mask(SDNode *N) {
00272 
00273   return PPC::isVMRGLShuffleMask(N, 2, false);
00274 
00275 }
00276 inline bool Predicate_VMRGLH_unary_shuffle_mask(SDNode *N) {
00277 
00278   return PPC::isVMRGLShuffleMask(N, 2, true);
00279 
00280 }
00281 inline bool Predicate_VMRGLW_shuffle_mask(SDNode *N) {
00282 
00283   return PPC::isVMRGLShuffleMask(N, 4, false);
00284 
00285 }
00286 inline bool Predicate_VMRGLW_unary_shuffle_mask(SDNode *N) {
00287 
00288   return PPC::isVMRGLShuffleMask(N, 4, true);
00289 
00290 }
00291 inline bool Predicate_VPKUHUM_shuffle_mask(SDNode *N) {
00292 
00293   return PPC::isVPKUHUMShuffleMask(N, false);
00294 
00295 }
00296 inline bool Predicate_VPKUHUM_unary_shuffle_mask(SDNode *N) {
00297 
00298   return PPC::isVPKUHUMShuffleMask(N, true);
00299 
00300 }
00301 inline bool Predicate_VPKUWUM_shuffle_mask(SDNode *N) {
00302 
00303   return PPC::isVPKUWUMShuffleMask(N, false);
00304 
00305 }
00306 inline bool Predicate_VPKUWUM_unary_shuffle_mask(SDNode *N) {
00307 
00308   return PPC::isVPKUWUMShuffleMask(N, true);
00309 
00310 }
00311 inline bool Predicate_VSLDOI_shuffle_mask(SDNode *N) {
00312 
00313   return PPC::isVSLDOIShuffleMask(N, false) != -1;
00314 
00315 }
00316 inline bool Predicate_VSLDOI_unary_shuffle_mask(SDNode *N) {
00317 
00318   return PPC::isVSLDOIShuffleMask(N, true) != -1;
00319 
00320 }
00321 inline bool Predicate_VSPLTB_shuffle_mask(SDNode *N) {
00322 
00323   return PPC::isSplatShuffleMask(N, 1);
00324 
00325 }
00326 inline bool Predicate_VSPLTH_shuffle_mask(SDNode *N) {
00327 
00328   return PPC::isSplatShuffleMask(N, 2);
00329 
00330 }
00331 inline bool Predicate_VSPLTW_shuffle_mask(SDNode *N) {
00332 
00333   return PPC::isSplatShuffleMask(N, 4);
00334 
00335 }
00336 inline bool Predicate_imm16Shifted(SDNode *inN) {
00337   ConstantSDNode *N = cast<ConstantSDNode>(inN);
00338 
00339   // imm16Shifted predicate - True if only bits in the top 16-bits of the
00340   // immediate are set.  Used by instructions like 'addis'.
00341   return ((unsigned)N->getValue() & 0xFFFF0000U) == (unsigned)N->getValue();
00342 
00343 }
00344 inline bool Predicate_immAllOnes(SDNode *inN) {
00345   ConstantSDNode *N = cast<ConstantSDNode>(inN);
00346  return N->isAllOnesValue(); 
00347 }
00348 inline bool Predicate_immAllOnesV(SDNode *N) {
00349 
00350   return ISD::isBuildVectorAllOnes(N);
00351 
00352 }
00353 inline bool Predicate_immAllZerosV(SDNode *N) {
00354 
00355   return ISD::isBuildVectorAllZeros(N);
00356 
00357 }
00358 inline bool Predicate_immSExt16(SDNode *inN) {
00359   ConstantSDNode *N = cast<ConstantSDNode>(inN);
00360 
00361   // immSExt16 predicate - True if the immediate fits in a 16-bit sign extended
00362   // field.  Used by instructions like 'addi'.
00363   return (int)N->getValue() == (short)N->getValue();
00364 
00365 }
00366 inline bool Predicate_immZExt16(SDNode *inN) {
00367   ConstantSDNode *N = cast<ConstantSDNode>(inN);
00368 
00369   // immZExt16 predicate - True if the immediate fits in a 16-bit zero extended
00370   // field.  Used by instructions like 'ori'.
00371   return (unsigned)N->getValue() == (unsigned short)N->getValue();
00372 
00373 }
00374 inline bool Predicate_vecspltisb(SDNode *N) {
00375 
00376   return PPC::get_VSPLTI_elt(N, 1, *CurDAG).Val != 0;
00377 
00378 }
00379 inline bool Predicate_vecspltish(SDNode *N) {
00380 
00381   return PPC::get_VSPLTI_elt(N, 2, *CurDAG).Val != 0;
00382 
00383 }
00384 inline bool Predicate_vecspltisw(SDNode *N) {
00385 
00386   return PPC::get_VSPLTI_elt(N, 4, *CurDAG).Val != 0;
00387 
00388 }
00389 inline bool Predicate_vtFP(SDNode *inN) {
00390   VTSDNode *N = cast<VTSDNode>(inN);
00391  return MVT::isFloatingPoint(N->getVT()); 
00392 }
00393 inline bool Predicate_vtInt(SDNode *inN) {
00394   VTSDNode *N = cast<VTSDNode>(inN);
00395  return MVT::isInteger(N->getVT()); 
00396 }
00397 
00398 
00399 void Select_PPCextsw_32(SDOperand &Result, SDOperand N) {
00400   SDOperand N0(0, 0);
00401   SDOperand Tmp0(0, 0);
00402   SDNode *ResNode;
00403   N0 = N.getOperand(0);
00404   if (N.Val->getValueType(0) == MVT::i32) {
00405     Select(Tmp0, N0);
00406     if (N.Val->hasOneUse()) {
00407       Result = CurDAG->SelectNodeTo(N.Val, PPC::EXTSW_32, MVT::i32, Tmp0);
00408     } else {
00409       ResNode = CurDAG->getTargetNode(PPC::EXTSW_32, MVT::i32, Tmp0);
00410       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00411       Result = SDOperand(ResNode, 0);
00412     }
00413     return;
00414   }
00415   std::cerr << "Cannot yet select: ";
00416   N.Val->dump(CurDAG);
00417   std::cerr << '\n';
00418   abort();
00419 }
00420 
00421 void Select_PPCfcfid(SDOperand &Result, SDOperand N) {
00422   SDOperand N0(0, 0);
00423   SDOperand Tmp0(0, 0);
00424   SDNode *ResNode;
00425   N0 = N.getOperand(0);
00426   if (N.Val->getValueType(0) == MVT::f64) {
00427     Select(Tmp0, N0);
00428     if (N.Val->hasOneUse()) {
00429       Result = CurDAG->SelectNodeTo(N.Val, PPC::FCFID, MVT::f64, Tmp0);
00430     } else {
00431       ResNode = CurDAG->getTargetNode(PPC::FCFID, MVT::f64, Tmp0);
00432       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00433       Result = SDOperand(ResNode, 0);
00434     }
00435     return;
00436   }
00437   std::cerr << "Cannot yet select: ";
00438   N.Val->dump(CurDAG);
00439   std::cerr << '\n';
00440   abort();
00441 }
00442 
00443 void Select_PPCfctidz(SDOperand &Result, SDOperand N) {
00444   SDOperand N0(0, 0);
00445   SDOperand Tmp0(0, 0);
00446   SDNode *ResNode;
00447   N0 = N.getOperand(0);
00448   if (N.Val->getValueType(0) == MVT::f64) {
00449     Select(Tmp0, N0);
00450     if (N.Val->hasOneUse()) {
00451       Result = CurDAG->SelectNodeTo(N.Val, PPC::FCTIDZ, MVT::f64, Tmp0);
00452     } else {
00453       ResNode = CurDAG->getTargetNode(PPC::FCTIDZ, MVT::f64, Tmp0);
00454       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00455       Result = SDOperand(ResNode, 0);
00456     }
00457     return;
00458   }
00459   std::cerr << "Cannot yet select: ";
00460   N.Val->dump(CurDAG);
00461   std::cerr << '\n';
00462   abort();
00463 }
00464 
00465 void Select_PPCfctiwz(SDOperand &Result, SDOperand N) {
00466   SDOperand N0(0, 0);
00467   SDOperand Tmp0(0, 0);
00468   SDNode *ResNode;
00469   N0 = N.getOperand(0);
00470   if (N.Val->getValueType(0) == MVT::f64) {
00471     Select(Tmp0, N0);
00472     if (N.Val->hasOneUse()) {
00473       Result = CurDAG->SelectNodeTo(N.Val, PPC::FCTIWZ, MVT::f64, Tmp0);
00474     } else {
00475       ResNode = CurDAG->getTargetNode(PPC::FCTIWZ, MVT::f64, Tmp0);
00476       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00477       Result = SDOperand(ResNode, 0);
00478     }
00479     return;
00480   }
00481   std::cerr << "Cannot yet select: ";
00482   N.Val->dump(CurDAG);
00483   std::cerr << '\n';
00484   abort();
00485 }
00486 
00487 void Select_PPCfsel(SDOperand &Result, SDOperand N) {
00488   SDOperand N0(0, 0);
00489   SDOperand N1(0, 0);
00490   SDOperand N2(0, 0);
00491   SDOperand Tmp0(0, 0);
00492   SDOperand Tmp1(0, 0);
00493   SDOperand Tmp2(0, 0);
00494   SDNode *ResNode;
00495   N0 = N.getOperand(0);
00496   N1 = N.getOperand(1);
00497   N2 = N.getOperand(2);
00498 
00499   // Pattern: (PPCfsel:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB)
00500   // Emits: (FSELD:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB)
00501   // Pattern complexity = 2  cost = 1
00502   if (N.Val->getValueType(0) == MVT::f64) {
00503     Select(Tmp0, N0);
00504     Select(Tmp1, N1);
00505     Select(Tmp2, N2);
00506     if (N.Val->hasOneUse()) {
00507       Result = CurDAG->SelectNodeTo(N.Val, PPC::FSELD, MVT::f64, Tmp0, Tmp1, Tmp2);
00508     } else {
00509       ResNode = CurDAG->getTargetNode(PPC::FSELD, MVT::f64, Tmp0, Tmp1, Tmp2);
00510       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00511       Result = SDOperand(ResNode, 0);
00512     }
00513     return;
00514   }
00515 
00516   // Pattern: (PPCfsel:f32 F8RC:f64:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB)
00517   // Emits: (FSELS:f32 F8RC:f64:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB)
00518   // Pattern complexity = 2  cost = 1
00519   if (N.Val->getValueType(0) == MVT::f32) {
00520     Select(Tmp0, N0);
00521     Select(Tmp1, N1);
00522     Select(Tmp2, N2);
00523     if (N.Val->hasOneUse()) {
00524       Result = CurDAG->SelectNodeTo(N.Val, PPC::FSELS, MVT::f32, Tmp0, Tmp1, Tmp2);
00525     } else {
00526       ResNode = CurDAG->getTargetNode(PPC::FSELS, MVT::f32, Tmp0, Tmp1, Tmp2);
00527       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00528       Result = SDOperand(ResNode, 0);
00529     }
00530     return;
00531   }
00532   std::cerr << "Cannot yet select: ";
00533   N.Val->dump(CurDAG);
00534   std::cerr << '\n';
00535   abort();
00536 }
00537 
00538 void Select_PPChi(SDOperand &Result, SDOperand N) {
00539   SDOperand N0(0, 0);
00540   SDOperand N1(0, 0);
00541   SDOperand Tmp1(0, 0);
00542   SDNode *ResNode;
00543   N0 = N.getOperand(0);
00544 
00545   // Pattern: (PPChi:i32 (tglobaladdr:i32):$in, 0:i32)
00546   // Emits: (LIS:i32 (tglobaladdr:i32):$in)
00547   // Pattern complexity = 7  cost = 1
00548   if (N0.getOpcode() == ISD::TargetGlobalAddress) {
00549     N1 = N.getOperand(1);
00550     if (isa<ConstantSDNode>(N1)) {
00551       int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended();
00552       if (CN0 == 0) {
00553         Tmp1 = N0;
00554         if (N.Val->hasOneUse()) {
00555           Result = CurDAG->SelectNodeTo(N.Val, PPC::LIS, MVT::i32, Tmp1);
00556         } else {
00557           ResNode = CurDAG->getTargetNode(PPC::LIS, MVT::i32, Tmp1);
00558           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00559           Result = SDOperand(ResNode, 0);
00560         }
00561         return;
00562       }
00563     }
00564   }
00565 
00566   // Pattern: (PPChi:i32 (tconstpool:i32):$in, 0:i32)
00567   // Emits: (LIS:i32 (tconstpool:i32):$in)
00568   // Pattern complexity = 7  cost = 1
00569   if (N0.getOpcode() == ISD::TargetConstantPool) {
00570     N1 = N.getOperand(1);
00571     if (isa<ConstantSDNode>(N1)) {
00572       int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended();
00573       if (CN0 == 0) {
00574         Tmp1 = N0;
00575         if (N.Val->hasOneUse()) {
00576           Result = CurDAG->SelectNodeTo(N.Val, PPC::LIS, MVT::i32, Tmp1);
00577         } else {
00578           ResNode = CurDAG->getTargetNode(PPC::LIS, MVT::i32, Tmp1);
00579           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00580           Result = SDOperand(ResNode, 0);
00581         }
00582         return;
00583       }
00584     }
00585   }
00586   std::cerr << "Cannot yet select: ";
00587   N.Val->dump(CurDAG);
00588   std::cerr << '\n';
00589   abort();
00590 }
00591 
00592 void Select_PPClo(SDOperand &Result, SDOperand N) {
00593   SDOperand N0(0, 0);
00594   SDOperand N1(0, 0);
00595   SDOperand Tmp1(0, 0);
00596   SDNode *ResNode;
00597   N0 = N.getOperand(0);
00598 
00599   // Pattern: (PPClo:i32 (tglobaladdr:i32):$in, 0:i32)
00600   // Emits: (LI:i32 (tglobaladdr:i32):$in)
00601   // Pattern complexity = 7  cost = 1
00602   if (N0.getOpcode() == ISD::TargetGlobalAddress) {
00603     N1 = N.getOperand(1);
00604     if (isa<ConstantSDNode>(N1)) {
00605       int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended();
00606       if (CN0 == 0) {
00607         Tmp1 = N0;
00608         if (N.Val->hasOneUse()) {
00609           Result = CurDAG->SelectNodeTo(N.Val, PPC::LI, MVT::i32, Tmp1);
00610         } else {
00611           ResNode = CurDAG->getTargetNode(PPC::LI, MVT::i32, Tmp1);
00612           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00613           Result = SDOperand(ResNode, 0);
00614         }
00615         return;
00616       }
00617     }
00618   }
00619 
00620   // Pattern: (PPClo:i32 (tconstpool:i32):$in, 0:i32)
00621   // Emits: (LI:i32 (tconstpool:i32):$in)
00622   // Pattern complexity = 7  cost = 1
00623   if (N0.getOpcode() == ISD::TargetConstantPool) {
00624     N1 = N.getOperand(1);
00625     if (isa<ConstantSDNode>(N1)) {
00626       int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended();
00627       if (CN0 == 0) {
00628         Tmp1 = N0;
00629         if (N.Val->hasOneUse()) {
00630           Result = CurDAG->SelectNodeTo(N.Val, PPC::LI, MVT::i32, Tmp1);
00631         } else {
00632           ResNode = CurDAG->getTargetNode(PPC::LI, MVT::i32, Tmp1);
00633           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00634           Result = SDOperand(ResNode, 0);
00635         }
00636         return;
00637       }
00638     }
00639   }
00640   std::cerr << "Cannot yet select: ";
00641   N.Val->dump(CurDAG);
00642   std::cerr << '\n';
00643   abort();
00644 }
00645 
00646 void Select_PPCshl(SDOperand &Result, SDOperand N) {
00647   SDOperand N0(0, 0);
00648   SDOperand N1(0, 0);
00649   SDOperand Tmp0(0, 0);
00650   SDOperand Tmp1(0, 0);
00651   SDNode *ResNode;
00652   N0 = N.getOperand(0);
00653   N1 = N.getOperand(1);
00654   Select(Tmp0, N0);
00655   Select(Tmp1, N1);
00656   if (N.Val->hasOneUse()) {
00657     Result = CurDAG->SelectNodeTo(N.Val, PPC::SLW, MVT::i32, Tmp0, Tmp1);
00658   } else {
00659     ResNode = CurDAG->getTargetNode(PPC::SLW, MVT::i32, Tmp0, Tmp1);
00660     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00661     Result = SDOperand(ResNode, 0);
00662   }
00663   return;
00664 }
00665 
00666 void Select_PPCsra(SDOperand &Result, SDOperand N) {
00667   SDOperand N0(0, 0);
00668   SDOperand N1(0, 0);
00669   SDOperand Tmp0(0, 0);
00670   SDOperand Tmp1(0, 0);
00671   SDNode *ResNode;
00672   N0 = N.getOperand(0);
00673   N1 = N.getOperand(1);
00674   Select(Tmp0, N0);
00675   Select(Tmp1, N1);
00676   if (N.Val->hasOneUse()) {
00677     Result = CurDAG->SelectNodeTo(N.Val, PPC::SRAW, MVT::i32, Tmp0, Tmp1);
00678   } else {
00679     ResNode = CurDAG->getTargetNode(PPC::SRAW, MVT::i32, Tmp0, Tmp1);
00680     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00681     Result = SDOperand(ResNode, 0);
00682   }
00683   return;
00684 }
00685 
00686 void Select_PPCsrl(SDOperand &Result, SDOperand N) {
00687   SDOperand N0(0, 0);
00688   SDOperand N1(0, 0);
00689   SDOperand Tmp0(0, 0);
00690   SDOperand Tmp1(0, 0);
00691   SDNode *ResNode;
00692   N0 = N.getOperand(0);
00693   N1 = N.getOperand(1);
00694   Select(Tmp0, N0);
00695   Select(Tmp1, N1);
00696   if (N.Val->hasOneUse()) {
00697     Result = CurDAG->SelectNodeTo(N.Val, PPC::SRW, MVT::i32, Tmp0, Tmp1);
00698   } else {
00699     ResNode = CurDAG->getTargetNode(PPC::SRW, MVT::i32, Tmp0, Tmp1);
00700     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00701     Result = SDOperand(ResNode, 0);
00702   }
00703   return;
00704 }
00705 
00706 void Select_PPCstd_32(SDOperand &Result, SDOperand N) {
00707   SDOperand Chain(0, 0);
00708   SDOperand N1(0, 0);
00709   SDOperand N2(0, 0);
00710   SDOperand Tmp0(0, 0);
00711   SDOperand Tmp1(0, 0);
00712   SDOperand Tmp2(0, 0);
00713   SDNode *ResNode;
00714   Chain = N.getOperand(0);
00715   N1 = N.getOperand(1);
00716   N2 = N.getOperand(2);
00717   if (N1.Val->getValueType(0) == MVT::i32) {
00718 
00719     // Pattern: (PPCstd_32:void GPRC:i32:$rT, ixaddr:i32:$dst)
00720     // Emits: (STD_32:void GPRC:i32:$rT, ixaddr:i32:$dst)
00721     // Pattern complexity = 8  cost = 1
00722     if (SelectAddrImmShift(N2, Tmp0, Tmp1)) {
00723       Select(Tmp0, Tmp0);
00724       Select(Tmp1, Tmp1);
00725       Select(Tmp2, N1);
00726       Select(Chain, Chain);
00727       ResNode = CurDAG->getTargetNode(PPC::STD_32, MVT::Other, Tmp2, Tmp0, Tmp1, Chain);
00728       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
00729       Result = SDOperand(ResNode, N.ResNo);
00730       return;
00731     }
00732 
00733     // Pattern: (PPCstd_32:void GPRC:i32:$rT, xaddr:i32:$dst)
00734     // Emits: (STDX_32:void GPRC:i32:$rT, xaddr:i32:$dst)
00735     // Pattern complexity = 8  cost = 1
00736     if (SelectAddrIdx(N2, Tmp0, Tmp1)) {
00737       Select(Tmp0, Tmp0);
00738       Select(Tmp1, Tmp1);
00739       Select(Tmp2, N1);
00740       Select(Chain, Chain);
00741       ResNode = CurDAG->getTargetNode(PPC::STDX_32, MVT::Other, Tmp2, Tmp0, Tmp1, Chain);
00742       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
00743       Result = SDOperand(ResNode, N.ResNo);
00744       return;
00745     }
00746   }
00747   std::cerr << "Cannot yet select: ";
00748   N.Val->dump(CurDAG);
00749   std::cerr << '\n';
00750   abort();
00751 }
00752 
00753 void Select_PPCstfiwx(SDOperand &Result, SDOperand N) {
00754   SDOperand Chain(0, 0);
00755   SDOperand N1(0, 0);
00756   SDOperand N2(0, 0);
00757   SDOperand Tmp0(0, 0);
00758   SDOperand Tmp1(0, 0);
00759   SDOperand Tmp2(0, 0);
00760   SDNode *ResNode;
00761   Chain = N.getOperand(0);
00762   N1 = N.getOperand(1);
00763   N2 = N.getOperand(2);
00764   if (SelectAddrIdxOnly(N2, Tmp0, Tmp1)) {
00765     Select(Tmp0, Tmp0);
00766     Select(Tmp1, Tmp1);
00767     Select(Tmp2, N1);
00768     Select(Chain, Chain);
00769     ResNode = CurDAG->getTargetNode(PPC::STFIWX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain);
00770     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
00771     Result = SDOperand(ResNode, N.ResNo);
00772     return;
00773   }
00774   std::cerr << "Cannot yet select: ";
00775   N.Val->dump(CurDAG);
00776   std::cerr << '\n';
00777   abort();
00778 }
00779 
00780 void Select_PPCvcmp(SDOperand &Result, SDOperand N) {
00781   SDOperand N0(0, 0);
00782   SDOperand N1(0, 0);
00783   SDOperand N2(0, 0);
00784   SDOperand Tmp1(0, 0);
00785   SDOperand Tmp2(0, 0);
00786   SDNode *ResNode;
00787   N0 = N.getOperand(0);
00788   N1 = N.getOperand(1);
00789   N2 = N.getOperand(2);
00790   if (isa<ConstantSDNode>(N2)) {
00791     int64_t CN0 = cast<ConstantSDNode>(N2)->getSignExtended();
00792 
00793     // Pattern: (PPCvcmp:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 966:i32)
00794     // Emits: (VCMPBFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB)
00795     // Pattern complexity = 5  cost = 1
00796     if (CN0 == 966 &&
00797         N.Val->getValueType(0) == MVT::v4f32) {
00798       Select(Tmp1, N0);
00799       Select(Tmp2, N1);
00800       if (N.Val->hasOneUse()) {
00801         Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPBFP, MVT::v4f32, Tmp1, Tmp2);
00802       } else {
00803         ResNode = CurDAG->getTargetNode(PPC::VCMPBFP, MVT::v4f32, Tmp1, Tmp2);
00804         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00805         Result = SDOperand(ResNode, 0);
00806       }
00807       return;
00808     }
00809 
00810     // Pattern: (PPCvcmp:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 198:i32)
00811     // Emits: (VCMPEQFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB)
00812     // Pattern complexity = 5  cost = 1
00813     if (CN0 == 198 &&
00814         N.Val->getValueType(0) == MVT::v4f32) {
00815       Select(Tmp1, N0);
00816       Select(Tmp2, N1);
00817       if (N.Val->hasOneUse()) {
00818         Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPEQFP, MVT::v4f32, Tmp1, Tmp2);
00819       } else {
00820         ResNode = CurDAG->getTargetNode(PPC::VCMPEQFP, MVT::v4f32, Tmp1, Tmp2);
00821         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00822         Result = SDOperand(ResNode, 0);
00823       }
00824       return;
00825     }
00826 
00827     // Pattern: (PPCvcmp:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 454:i32)
00828     // Emits: (VCMPGEFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB)
00829     // Pattern complexity = 5  cost = 1
00830     if (CN0 == 454 &&
00831         N.Val->getValueType(0) == MVT::v4f32) {
00832       Select(Tmp1, N0);
00833       Select(Tmp2, N1);
00834       if (N.Val->hasOneUse()) {
00835         Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPGEFP, MVT::v4f32, Tmp1, Tmp2);
00836       } else {
00837         ResNode = CurDAG->getTargetNode(PPC::VCMPGEFP, MVT::v4f32, Tmp1, Tmp2);
00838         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00839         Result = SDOperand(ResNode, 0);
00840       }
00841       return;
00842     }
00843 
00844     // Pattern: (PPCvcmp:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 710:i32)
00845     // Emits: (VCMPGTFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB)
00846     // Pattern complexity = 5  cost = 1
00847     if (CN0 == 710 &&
00848         N.Val->getValueType(0) == MVT::v4f32) {
00849       Select(Tmp1, N0);
00850       Select(Tmp2, N1);
00851       if (N.Val->hasOneUse()) {
00852         Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPGTFP, MVT::v4f32, Tmp1, Tmp2);
00853       } else {
00854         ResNode = CurDAG->getTargetNode(PPC::VCMPGTFP, MVT::v4f32, Tmp1, Tmp2);
00855         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00856         Result = SDOperand(ResNode, 0);
00857       }
00858       return;
00859     }
00860 
00861     // Pattern: (PPCvcmp:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, 6:i32)
00862     // Emits: (VCMPEQUB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
00863     // Pattern complexity = 5  cost = 1
00864     if (CN0 == 6 &&
00865         N.Val->getValueType(0) == MVT::v16i8) {
00866       Select(Tmp1, N0);
00867       Select(Tmp2, N1);
00868       if (N.Val->hasOneUse()) {
00869         Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPEQUB, MVT::v16i8, Tmp1, Tmp2);
00870       } else {
00871         ResNode = CurDAG->getTargetNode(PPC::VCMPEQUB, MVT::v16i8, Tmp1, Tmp2);
00872         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00873         Result = SDOperand(ResNode, 0);
00874       }
00875       return;
00876     }
00877 
00878     // Pattern: (PPCvcmp:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, 774:i32)
00879     // Emits: (VCMPGTSB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
00880     // Pattern complexity = 5  cost = 1
00881     if (CN0 == 774 &&
00882         N.Val->getValueType(0) == MVT::v16i8) {
00883       Select(Tmp1, N0);
00884       Select(Tmp2, N1);
00885       if (N.Val->hasOneUse()) {
00886         Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPGTSB, MVT::v16i8, Tmp1, Tmp2);
00887       } else {
00888         ResNode = CurDAG->getTargetNode(PPC::VCMPGTSB, MVT::v16i8, Tmp1, Tmp2);
00889         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00890         Result = SDOperand(ResNode, 0);
00891       }
00892       return;
00893     }
00894 
00895     // Pattern: (PPCvcmp:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, 518:i32)
00896     // Emits: (VCMPGTUB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
00897     // Pattern complexity = 5  cost = 1
00898     if (CN0 == 518 &&
00899         N.Val->getValueType(0) == MVT::v16i8) {
00900       Select(Tmp1, N0);
00901       Select(Tmp2, N1);
00902       if (N.Val->hasOneUse()) {
00903         Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPGTUB, MVT::v16i8, Tmp1, Tmp2);
00904       } else {
00905         ResNode = CurDAG->getTargetNode(PPC::VCMPGTUB, MVT::v16i8, Tmp1, Tmp2);
00906         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00907         Result = SDOperand(ResNode, 0);
00908       }
00909       return;
00910     }
00911 
00912     // Pattern: (PPCvcmp:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, 70:i32)
00913     // Emits: (VCMPEQUH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
00914     // Pattern complexity = 5  cost = 1
00915     if (CN0 == 70 &&
00916         N.Val->getValueType(0) == MVT::v8i16) {
00917       Select(Tmp1, N0);
00918       Select(Tmp2, N1);
00919       if (N.Val->hasOneUse()) {
00920         Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPEQUH, MVT::v8i16, Tmp1, Tmp2);
00921       } else {
00922         ResNode = CurDAG->getTargetNode(PPC::VCMPEQUH, MVT::v8i16, Tmp1, Tmp2);
00923         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00924         Result = SDOperand(ResNode, 0);
00925       }
00926       return;
00927     }
00928 
00929     // Pattern: (PPCvcmp:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, 838:i32)
00930     // Emits: (VCMPGTSH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
00931     // Pattern complexity = 5  cost = 1
00932     if (CN0 == 838 &&
00933         N.Val->getValueType(0) == MVT::v8i16) {
00934       Select(Tmp1, N0);
00935       Select(Tmp2, N1);
00936       if (N.Val->hasOneUse()) {
00937         Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPGTSH, MVT::v8i16, Tmp1, Tmp2);
00938       } else {
00939         ResNode = CurDAG->getTargetNode(PPC::VCMPGTSH, MVT::v8i16, Tmp1, Tmp2);
00940         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00941         Result = SDOperand(ResNode, 0);
00942       }
00943       return;
00944     }
00945 
00946     // Pattern: (PPCvcmp:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, 582:i32)
00947     // Emits: (VCMPGTUH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
00948     // Pattern complexity = 5  cost = 1
00949     if (CN0 == 582 &&
00950         N.Val->getValueType(0) == MVT::v8i16) {
00951       Select(Tmp1, N0);
00952       Select(Tmp2, N1);
00953       if (N.Val->hasOneUse()) {
00954         Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPGTUH, MVT::v8i16, Tmp1, Tmp2);
00955       } else {
00956         ResNode = CurDAG->getTargetNode(PPC::VCMPGTUH, MVT::v8i16, Tmp1, Tmp2);
00957         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00958         Result = SDOperand(ResNode, 0);
00959       }
00960       return;
00961     }
00962 
00963     // Pattern: (PPCvcmp:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, 134:i32)
00964     // Emits: (VCMPEQUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
00965     // Pattern complexity = 5  cost = 1
00966     if (CN0 == 134 &&
00967         N.Val->getValueType(0) == MVT::v4i32) {
00968       Select(Tmp1, N0);
00969       Select(Tmp2, N1);
00970       if (N.Val->hasOneUse()) {
00971         Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPEQUW, MVT::v4i32, Tmp1, Tmp2);
00972       } else {
00973         ResNode = CurDAG->getTargetNode(PPC::VCMPEQUW, MVT::v4i32, Tmp1, Tmp2);
00974         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00975         Result = SDOperand(ResNode, 0);
00976       }
00977       return;
00978     }
00979 
00980     // Pattern: (PPCvcmp:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, 902:i32)
00981     // Emits: (VCMPGTSW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
00982     // Pattern complexity = 5  cost = 1
00983     if (CN0 == 902 &&
00984         N.Val->getValueType(0) == MVT::v4i32) {
00985       Select(Tmp1, N0);
00986       Select(Tmp2, N1);
00987       if (N.Val->hasOneUse()) {
00988         Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPGTSW, MVT::v4i32, Tmp1, Tmp2);
00989       } else {
00990         ResNode = CurDAG->getTargetNode(PPC::VCMPGTSW, MVT::v4i32, Tmp1, Tmp2);
00991         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
00992         Result = SDOperand(ResNode, 0);
00993       }
00994       return;
00995     }
00996 
00997     // Pattern: (PPCvcmp:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, 646:i32)
00998     // Emits: (VCMPGTUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
00999     // Pattern complexity = 5  cost = 1
01000     if (CN0 == 646 &&
01001         N.Val->getValueType(0) == MVT::v4i32) {
01002       Select(Tmp1, N0);
01003       Select(Tmp2, N1);
01004       if (N.Val->hasOneUse()) {
01005         Result = CurDAG->SelectNodeTo(N.Val, PPC::VCMPGTUW, MVT::v4i32, Tmp1, Tmp2);
01006       } else {
01007         ResNode = CurDAG->getTargetNode(PPC::VCMPGTUW, MVT::v4i32, Tmp1, Tmp2);
01008         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01009         Result = SDOperand(ResNode, 0);
01010       }
01011       return;
01012     }
01013   }
01014   std::cerr << "Cannot yet select: ";
01015   N.Val->dump(CurDAG);
01016   std::cerr << '\n';
01017   abort();
01018 }
01019 
01020 void Select_PPCvcmp_o(SDOperand &Result, SDOperand N) {
01021   SDOperand InFlag(0, 0);
01022   SDOperand N0(0, 0);
01023   SDOperand N1(0, 0);
01024   SDOperand N2(0, 0);
01025   SDOperand Tmp1(0, 0);
01026   SDOperand Tmp2(0, 0);
01027   SDNode *ResNode;
01028   N0 = N.getOperand(0);
01029   N1 = N.getOperand(1);
01030   N2 = N.getOperand(2);
01031   if (isa<ConstantSDNode>(N2)) {
01032     int64_t CN0 = cast<ConstantSDNode>(N2)->getSignExtended();
01033 
01034     // Pattern: (PPCvcmp_o:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 966:i32)
01035     // Emits: (VCMPBFPo:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB)
01036     // Pattern complexity = 5  cost = 1
01037     if (CN0 == 966 &&
01038         N.Val->getValueType(0) == MVT::v4f32) {
01039       Select(Tmp1, N0);
01040       Select(Tmp2, N1);
01041       ResNode = CurDAG->getTargetNode(PPC::VCMPBFPo, MVT::v4f32, MVT::Flag, Tmp1, Tmp2);
01042       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01043       InFlag = SDOperand(ResNode, 1);
01044       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01045       Result = SDOperand(ResNode, N.ResNo);
01046       return;
01047     }
01048 
01049     // Pattern: (PPCvcmp_o:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 198:i32)
01050     // Emits: (VCMPEQFPo:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB)
01051     // Pattern complexity = 5  cost = 1
01052     if (CN0 == 198 &&
01053         N.Val->getValueType(0) == MVT::v4f32) {
01054       Select(Tmp1, N0);
01055       Select(Tmp2, N1);
01056       ResNode = CurDAG->getTargetNode(PPC::VCMPEQFPo, MVT::v4f32, MVT::Flag, Tmp1, Tmp2);
01057       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01058       InFlag = SDOperand(ResNode, 1);
01059       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01060       Result = SDOperand(ResNode, N.ResNo);
01061       return;
01062     }
01063 
01064     // Pattern: (PPCvcmp_o:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 454:i32)
01065     // Emits: (VCMPGEFPo:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB)
01066     // Pattern complexity = 5  cost = 1
01067     if (CN0 == 454 &&
01068         N.Val->getValueType(0) == MVT::v4f32) {
01069       Select(Tmp1, N0);
01070       Select(Tmp2, N1);
01071       ResNode = CurDAG->getTargetNode(PPC::VCMPGEFPo, MVT::v4f32, MVT::Flag, Tmp1, Tmp2);
01072       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01073       InFlag = SDOperand(ResNode, 1);
01074       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01075       Result = SDOperand(ResNode, N.ResNo);
01076       return;
01077     }
01078 
01079     // Pattern: (PPCvcmp_o:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB, 710:i32)
01080     // Emits: (VCMPGTFPo:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB)
01081     // Pattern complexity = 5  cost = 1
01082     if (CN0 == 710 &&
01083         N.Val->getValueType(0) == MVT::v4f32) {
01084       Select(Tmp1, N0);
01085       Select(Tmp2, N1);
01086       ResNode = CurDAG->getTargetNode(PPC::VCMPGTFPo, MVT::v4f32, MVT::Flag, Tmp1, Tmp2);
01087       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01088       InFlag = SDOperand(ResNode, 1);
01089       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01090       Result = SDOperand(ResNode, N.ResNo);
01091       return;
01092     }
01093 
01094     // Pattern: (PPCvcmp_o:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, 6:i32)
01095     // Emits: (VCMPEQUBo:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
01096     // Pattern complexity = 5  cost = 1
01097     if (CN0 == 6 &&
01098         N.Val->getValueType(0) == MVT::v16i8) {
01099       Select(Tmp1, N0);
01100       Select(Tmp2, N1);
01101       ResNode = CurDAG->getTargetNode(PPC::VCMPEQUBo, MVT::v16i8, MVT::Flag, Tmp1, Tmp2);
01102       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01103       InFlag = SDOperand(ResNode, 1);
01104       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01105       Result = SDOperand(ResNode, N.ResNo);
01106       return;
01107     }
01108 
01109     // Pattern: (PPCvcmp_o:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, 774:i32)
01110     // Emits: (VCMPGTSBo:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
01111     // Pattern complexity = 5  cost = 1
01112     if (CN0 == 774 &&
01113         N.Val->getValueType(0) == MVT::v16i8) {
01114       Select(Tmp1, N0);
01115       Select(Tmp2, N1);
01116       ResNode = CurDAG->getTargetNode(PPC::VCMPGTSBo, MVT::v16i8, MVT::Flag, Tmp1, Tmp2);
01117       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01118       InFlag = SDOperand(ResNode, 1);
01119       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01120       Result = SDOperand(ResNode, N.ResNo);
01121       return;
01122     }
01123 
01124     // Pattern: (PPCvcmp_o:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, 518:i32)
01125     // Emits: (VCMPGTUBo:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
01126     // Pattern complexity = 5  cost = 1
01127     if (CN0 == 518 &&
01128         N.Val->getValueType(0) == MVT::v16i8) {
01129       Select(Tmp1, N0);
01130       Select(Tmp2, N1);
01131       ResNode = CurDAG->getTargetNode(PPC::VCMPGTUBo, MVT::v16i8, MVT::Flag, Tmp1, Tmp2);
01132       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01133       InFlag = SDOperand(ResNode, 1);
01134       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01135       Result = SDOperand(ResNode, N.ResNo);
01136       return;
01137     }
01138 
01139     // Pattern: (PPCvcmp_o:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, 70:i32)
01140     // Emits: (VCMPEQUHo:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
01141     // Pattern complexity = 5  cost = 1
01142     if (CN0 == 70 &&
01143         N.Val->getValueType(0) == MVT::v8i16) {
01144       Select(Tmp1, N0);
01145       Select(Tmp2, N1);
01146       ResNode = CurDAG->getTargetNode(PPC::VCMPEQUHo, MVT::v8i16, MVT::Flag, Tmp1, Tmp2);
01147       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01148       InFlag = SDOperand(ResNode, 1);
01149       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01150       Result = SDOperand(ResNode, N.ResNo);
01151       return;
01152     }
01153 
01154     // Pattern: (PPCvcmp_o:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, 838:i32)
01155     // Emits: (VCMPGTSHo:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
01156     // Pattern complexity = 5  cost = 1
01157     if (CN0 == 838 &&
01158         N.Val->getValueType(0) == MVT::v8i16) {
01159       Select(Tmp1, N0);
01160       Select(Tmp2, N1);
01161       ResNode = CurDAG->getTargetNode(PPC::VCMPGTSHo, MVT::v8i16, MVT::Flag, Tmp1, Tmp2);
01162       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01163       InFlag = SDOperand(ResNode, 1);
01164       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01165       Result = SDOperand(ResNode, N.ResNo);
01166       return;
01167     }
01168 
01169     // Pattern: (PPCvcmp_o:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, 582:i32)
01170     // Emits: (VCMPGTUHo:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
01171     // Pattern complexity = 5  cost = 1
01172     if (CN0 == 582 &&
01173         N.Val->getValueType(0) == MVT::v8i16) {
01174       Select(Tmp1, N0);
01175       Select(Tmp2, N1);
01176       ResNode = CurDAG->getTargetNode(PPC::VCMPGTUHo, MVT::v8i16, MVT::Flag, Tmp1, Tmp2);
01177       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01178       InFlag = SDOperand(ResNode, 1);
01179       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01180       Result = SDOperand(ResNode, N.ResNo);
01181       return;
01182     }
01183 
01184     // Pattern: (PPCvcmp_o:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, 134:i32)
01185     // Emits: (VCMPEQUWo:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
01186     // Pattern complexity = 5  cost = 1
01187     if (CN0 == 134 &&
01188         N.Val->getValueType(0) == MVT::v4i32) {
01189       Select(Tmp1, N0);
01190       Select(Tmp2, N1);
01191       ResNode = CurDAG->getTargetNode(PPC::VCMPEQUWo, MVT::v4i32, MVT::Flag, Tmp1, Tmp2);
01192       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01193       InFlag = SDOperand(ResNode, 1);
01194       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01195       Result = SDOperand(ResNode, N.ResNo);
01196       return;
01197     }
01198 
01199     // Pattern: (PPCvcmp_o:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, 902:i32)
01200     // Emits: (VCMPGTSWo:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
01201     // Pattern complexity = 5  cost = 1
01202     if (CN0 == 902 &&
01203         N.Val->getValueType(0) == MVT::v4i32) {
01204       Select(Tmp1, N0);
01205       Select(Tmp2, N1);
01206       ResNode = CurDAG->getTargetNode(PPC::VCMPGTSWo, MVT::v4i32, MVT::Flag, Tmp1, Tmp2);
01207       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01208       InFlag = SDOperand(ResNode, 1);
01209       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01210       Result = SDOperand(ResNode, N.ResNo);
01211       return;
01212     }
01213 
01214     // Pattern: (PPCvcmp_o:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, 646:i32)
01215     // Emits: (VCMPGTUWo:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
01216     // Pattern complexity = 5  cost = 1
01217     if (CN0 == 646 &&
01218         N.Val->getValueType(0) == MVT::v4i32) {
01219       Select(Tmp1, N0);
01220       Select(Tmp2, N1);
01221       ResNode = CurDAG->getTargetNode(PPC::VCMPGTUWo, MVT::v4i32, MVT::Flag, Tmp1, Tmp2);
01222       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01223       InFlag = SDOperand(ResNode, 1);
01224       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01225       Result = SDOperand(ResNode, N.ResNo);
01226       return;
01227     }
01228   }
01229   std::cerr << "Cannot yet select: ";
01230   N.Val->dump(CurDAG);
01231   std::cerr << '\n';
01232   abort();
01233 }
01234 
01235 void Select_PPCvmaddfp(SDOperand &Result, SDOperand N) {
01236   SDOperand N0(0, 0);
01237   SDOperand N1(0, 0);
01238   SDOperand N2(0, 0);
01239   SDOperand Tmp0(0, 0);
01240   SDOperand Tmp1(0, 0);
01241   SDOperand Tmp2(0, 0);
01242   SDNode *ResNode;
01243   N0 = N.getOperand(0);
01244   N1 = N.getOperand(1);
01245   N2 = N.getOperand(2);
01246   if (N.Val->getValueType(0) == MVT::v4f32) {
01247     Select(Tmp0, N0);
01248     Select(Tmp1, N1);
01249     Select(Tmp2, N2);
01250     if (N.Val->hasOneUse()) {
01251       Result = CurDAG->SelectNodeTo(N.Val, PPC::VMADDFP, MVT::v16i8, Tmp0, Tmp1, Tmp2);
01252     } else {
01253       ResNode = CurDAG->getTargetNode(PPC::VMADDFP, MVT::v16i8, Tmp0, Tmp1, Tmp2);
01254       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01255       Result = SDOperand(ResNode, 0);
01256     }
01257     return;
01258   }
01259   std::cerr << "Cannot yet select: ";
01260   N.Val->dump(CurDAG);
01261   std::cerr << '\n';
01262   abort();
01263 }
01264 
01265 void Select_PPCvnmsubfp(SDOperand &Result, SDOperand N) {
01266   SDOperand N0(0, 0);
01267   SDOperand N1(0, 0);
01268   SDOperand N2(0, 0);
01269   SDOperand Tmp0(0, 0);
01270   SDOperand Tmp1(0, 0);
01271   SDOperand Tmp2(0, 0);
01272   SDNode *ResNode;
01273   N0 = N.getOperand(0);
01274   N1 = N.getOperand(1);
01275   N2 = N.getOperand(2);
01276   if (N.Val->getValueType(0) == MVT::v4f32) {
01277     Select(Tmp0, N0);
01278     Select(Tmp1, N1);
01279     Select(Tmp2, N2);
01280     if (N.Val->hasOneUse()) {
01281       Result = CurDAG->SelectNodeTo(N.Val, PPC::VNMSUBFP, MVT::v16i8, Tmp0, Tmp1, Tmp2);
01282     } else {
01283       ResNode = CurDAG->getTargetNode(PPC::VNMSUBFP, MVT::v16i8, Tmp0, Tmp1, Tmp2);
01284       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01285       Result = SDOperand(ResNode, 0);
01286     }
01287     return;
01288   }
01289   std::cerr << "Cannot yet select: ";
01290   N.Val->dump(CurDAG);
01291   std::cerr << '\n';
01292   abort();
01293 }
01294 
01295 void Select_PPCvperm(SDOperand &Result, SDOperand N) {
01296   SDOperand N0(0, 0);
01297   SDOperand N1(0, 0);
01298   SDOperand N2(0, 0);
01299   SDOperand Tmp0(0, 0);
01300   SDOperand Tmp1(0, 0);
01301   SDOperand Tmp2(0, 0);
01302   SDNode *ResNode;
01303   N0 = N.getOperand(0);
01304   N1 = N.getOperand(1);
01305   N2 = N.getOperand(2);
01306   if (N.Val->getValueType(0) == MVT::v16i8) {
01307     Select(Tmp0, N0);
01308     Select(Tmp1, N1);
01309     Select(Tmp2, N2);
01310     if (N.Val->hasOneUse()) {
01311       Result = CurDAG->SelectNodeTo(N.Val, PPC::VPERM, MVT::v16i8, Tmp0, Tmp1, Tmp2);
01312     } else {
01313       ResNode = CurDAG->getTargetNode(PPC::VPERM, MVT::v16i8, Tmp0, Tmp1, Tmp2);
01314       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01315       Result = SDOperand(ResNode, 0);
01316     }
01317     return;
01318   }
01319   std::cerr << "Cannot yet select: ";
01320   N.Val->dump(CurDAG);
01321   std::cerr << '\n';
01322   abort();
01323 }
01324 
01325 void Select_add(SDOperand &Result, SDOperand N) {
01326   SDOperand N0(0, 0);
01327   SDOperand N00(0, 0);
01328   SDOperand N01(0, 0);
01329   SDOperand N1(0, 0);
01330   SDOperand N10(0, 0);
01331   SDOperand N11(0, 0);
01332   SDOperand Tmp0(0, 0);
01333   SDOperand Tmp1(0, 0);
01334   SDOperand Tmp2(0, 0);
01335   SDOperand Tmp3(0, 0);
01336   SDOperand Tmp4(0, 0);
01337   SDNode *ResNode;
01338   N0 = N.getOperand(0);
01339   {
01340     N1 = N.getOperand(1);
01341 
01342     // Pattern: (add:i32 GPRC:i32:$rA, (PPClo:i32 (tglobaladdr:i32):$sym, 0:i32))
01343     // Emits: (LA:i32 GPRC:i32:$rA, (tglobaladdr:i32):$sym)
01344     // Pattern complexity = 9  cost = 1
01345     if (N1.getOpcode() == PPCISD::Lo) {
01346       N10 = N1.getOperand(0);
01347       if (N10.getOpcode() == ISD::TargetGlobalAddress) {
01348         N11 = N1.getOperand(1);
01349         if (isa<ConstantSDNode>(N11)) {
01350           int64_t CN0 = cast<ConstantSDNode>(N11)->getSignExtended();
01351           if (CN0 == 0) {
01352             Select(Tmp1, N0);
01353             Tmp2 = N10;
01354             if (N.Val->hasOneUse()) {
01355               Result = CurDAG->SelectNodeTo(N.Val, PPC::LA, MVT::i32, Tmp1, Tmp2);
01356             } else {
01357               ResNode = CurDAG->getTargetNode(PPC::LA, MVT::i32, Tmp1, Tmp2);
01358               SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01359               Result = SDOperand(ResNode, 0);
01360             }
01361             return;
01362           }
01363         }
01364       }
01365     }
01366     if (N1.getOpcode() == PPCISD::Hi) {
01367       N10 = N1.getOperand(0);
01368 
01369       // Pattern: (add:i32 GPRC:i32:$in, (PPChi:i32 (tglobaladdr:i32):$g, 0:i32))
01370       // Emits: (ADDIS:i32 GPRC:i32:$in, (tglobaladdr:i32):$g)
01371       // Pattern complexity = 9  cost = 1
01372       if (N10.getOpcode() == ISD::TargetGlobalAddress) {
01373         N11 = N1.getOperand(1);
01374         if (isa<ConstantSDNode>(N11)) {
01375           int64_t CN0 = cast<ConstantSDNode>(N11)->getSignExtended();
01376           if (CN0 == 0) {
01377             Select(Tmp1, N0);
01378             Tmp2 = N10;
01379             if (N.Val->hasOneUse()) {
01380               Result = CurDAG->SelectNodeTo(N.Val, PPC::ADDIS, MVT::i32, Tmp1, Tmp2);
01381             } else {
01382               ResNode = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, Tmp1, Tmp2);
01383               SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01384               Result = SDOperand(ResNode, 0);
01385             }
01386             return;
01387           }
01388         }
01389       }
01390 
01391       // Pattern: (add:i32 GPRC:i32:$in, (PPChi:i32 (tconstpool:i32):$g, 0:i32))
01392       // Emits: (ADDIS:i32 GPRC:i32:$in, (tconstpool:i32):$g)
01393       // Pattern complexity = 9  cost = 1
01394       if (N10.getOpcode() == ISD::TargetConstantPool) {
01395         N11 = N1.getOperand(1);
01396         if (isa<ConstantSDNode>(N11)) {
01397           int64_t CN0 = cast<ConstantSDNode>(N11)->getSignExtended();
01398           if (CN0 == 0) {
01399             Select(Tmp1, N0);
01400             Tmp2 = N10;
01401             if (N.Val->hasOneUse()) {
01402               Result = CurDAG->SelectNodeTo(N.Val, PPC::ADDIS, MVT::i32, Tmp1, Tmp2);
01403             } else {
01404               ResNode = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, Tmp1, Tmp2);
01405               SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01406               Result = SDOperand(ResNode, 0);
01407             }
01408             return;
01409           }
01410         }
01411       }
01412     }
01413   }
01414 
01415   // Pattern: (add:i32 (PPClo:i32 (tglobaladdr:i32):$sym, 0:i32), GPRC:i32:$rA)
01416   // Emits: (LA:i32 GPRC:i32:$rA, (tglobaladdr:i32):$sym)
01417   // Pattern complexity = 9  cost = 1
01418   if (N0.getOpcode() == PPCISD::Lo) {
01419     N00 = N0.getOperand(0);
01420     if (N00.getOpcode() == ISD::TargetGlobalAddress) {
01421       N01 = N0.getOperand(1);
01422       if (isa<ConstantSDNode>(N01)) {
01423         int64_t CN0 = cast<ConstantSDNode>(N01)->getSignExtended();
01424         if (CN0 == 0) {
01425           N1 = N.getOperand(1);
01426           Select(Tmp1, N1);
01427           Tmp2 = N00;
01428           if (N.Val->hasOneUse()) {
01429             Result = CurDAG->SelectNodeTo(N.Val, PPC::LA, MVT::i32, Tmp1, Tmp2);
01430           } else {
01431             ResNode = CurDAG->getTargetNode(PPC::LA, MVT::i32, Tmp1, Tmp2);
01432             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01433             Result = SDOperand(ResNode, 0);
01434           }
01435           return;
01436         }
01437       }
01438     }
01439   }
01440   if (N0.getOpcode() == PPCISD::Hi) {
01441     N00 = N0.getOperand(0);
01442 
01443     // Pattern: (add:i32 (PPChi:i32 (tglobaladdr:i32):$g, 0:i32), GPRC:i32:$in)
01444     // Emits: (ADDIS:i32 GPRC:i32:$in, (tglobaladdr:i32):$g)
01445     // Pattern complexity = 9  cost = 1
01446     if (N00.getOpcode() == ISD::TargetGlobalAddress) {
01447       N01 = N0.getOperand(1);
01448       if (isa<ConstantSDNode>(N01)) {
01449         int64_t CN0 = cast<ConstantSDNode>(N01)->getSignExtended();
01450         if (CN0 == 0) {
01451           N1 = N.getOperand(1);
01452           Select(Tmp1, N1);
01453           Tmp2 = N00;
01454           if (N.Val->hasOneUse()) {
01455             Result = CurDAG->SelectNodeTo(N.Val, PPC::ADDIS, MVT::i32, Tmp1, Tmp2);
01456           } else {
01457             ResNode = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, Tmp1, Tmp2);
01458             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01459             Result = SDOperand(ResNode, 0);
01460           }
01461           return;
01462         }
01463       }
01464     }
01465 
01466     // Pattern: (add:i32 (PPChi:i32 (tconstpool:i32):$g, 0:i32), GPRC:i32:$in)
01467     // Emits: (ADDIS:i32 GPRC:i32:$in, (tconstpool:i32):$g)
01468     // Pattern complexity = 9  cost = 1
01469     if (N00.getOpcode() == ISD::TargetConstantPool) {
01470       N01 = N0.getOperand(1);
01471       if (isa<ConstantSDNode>(N01)) {
01472         int64_t CN0 = cast<ConstantSDNode>(N01)->getSignExtended();
01473         if (CN0 == 0) {
01474           N1 = N.getOperand(1);
01475           Select(Tmp1, N1);
01476           Tmp2 = N00;
01477           if (N.Val->hasOneUse()) {
01478             Result = CurDAG->SelectNodeTo(N.Val, PPC::ADDIS, MVT::i32, Tmp1, Tmp2);
01479           } else {
01480             ResNode = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, Tmp1, Tmp2);
01481             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01482             Result = SDOperand(ResNode, 0);
01483           }
01484           return;
01485         }
01486       }
01487     }
01488   }
01489   N1 = N.getOperand(1);
01490   if (N1.getOpcode() == ISD::Constant) {
01491 
01492     // Pattern: (add:i32 GPRC:i32:$rA, (imm:i32)<<P:Predicate_immSExt16>>:$imm)
01493     // Emits: (ADDI:i32 GPRC:i32:$rA, (imm:i32):$imm)
01494     // Pattern complexity = 5  cost = 1
01495     if (Predicate_immSExt16(N1.Val) &&
01496         N.Val->getValueType(0) == MVT::i32) {
01497       Select(Tmp0, N0);
01498       unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
01499       Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
01500       if (N.Val->hasOneUse()) {
01501         Result = CurDAG->SelectNodeTo(N.Val, PPC::ADDI, MVT::i32, Tmp0, Tmp1);
01502       } else {
01503         ResNode = CurDAG->getTargetNode(PPC::ADDI, MVT::i32, Tmp0, Tmp1);
01504         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01505         Result = SDOperand(ResNode, 0);
01506       }
01507       return;
01508     }
01509 
01510     // Pattern: (add:i32 GPRC:i32:$rA, (imm:i32)<<P:Predicate_imm16Shifted>><<X:HI16>>:$imm)
01511     // Emits: (ADDIS:i32 GPRC:i32:$rA, (HI16:i32 (imm:i32):$imm))
01512     // Pattern complexity = 5  cost = 1
01513     if (Predicate_imm16Shifted(N1.Val) &&
01514         N.Val->getValueType(0) == MVT::i32) {
01515       Select(Tmp0, N0);
01516       unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
01517       Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
01518       Tmp2 = Transform_HI16(Tmp1.Val);
01519       if (N.Val->hasOneUse()) {
01520         Result = CurDAG->SelectNodeTo(N.Val, PPC::ADDIS, MVT::i32, Tmp0, Tmp2);
01521       } else {
01522         ResNode = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, Tmp0, Tmp2);
01523         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01524         Result = SDOperand(ResNode, 0);
01525       }
01526       return;
01527     }
01528 
01529     // Pattern: (add:i32 GPRC:i32:$in, (imm:i32):$imm)
01530     // Emits: (ADDIS:i32 (ADDI:i32 GPRC:i32:$in, (LO16:i32 (imm:i32):$imm)), (HA16:i32 (imm:i32):$imm))
01531     // Pattern complexity = 4  cost = 2
01532     if (N.Val->getValueType(0) == MVT::i32) {
01533       Select(Tmp0, N0);
01534       unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
01535       Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
01536       Tmp2 = Transform_LO16(Tmp1.Val);
01537       Tmp3 = SDOperand(CurDAG->getTargetNode(PPC::ADDI, MVT::i32, Tmp0, Tmp2), 0);
01538       Tmp4 = Transform_HA16(Tmp1.Val);
01539       if (N.Val->hasOneUse()) {
01540         Result = CurDAG->SelectNodeTo(N.Val, PPC::ADDIS, MVT::i32, Tmp3, Tmp4);
01541       } else {
01542         ResNode = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, Tmp3, Tmp4);
01543         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01544         Result = SDOperand(ResNode, 0);
01545       }
01546       return;
01547     }
01548   }
01549 
01550   // Pattern: (add:i32 GPRC:i32:$rA, GPRC:i32:$rB)
01551   // Emits: (ADD4:i32 GPRC:i32:$rA, GPRC:i32:$rB)
01552   // Pattern complexity = 2  cost = 1
01553   if (N.Val->getValueType(0) == MVT::i32) {
01554     Select(Tmp0, N0);
01555     Select(Tmp1, N1);
01556     if (N.Val->hasOneUse()) {
01557       Result = CurDAG->SelectNodeTo(N.Val, PPC::ADD4, MVT::i32, Tmp0, Tmp1);
01558     } else {
01559       ResNode = CurDAG->getTargetNode(PPC::ADD4, MVT::i32, Tmp0, Tmp1);
01560       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01561       Result = SDOperand(ResNode, 0);
01562     }
01563     return;
01564   }
01565 
01566   // Pattern: (add:i64 G8RC:i64:$rA, G8RC:i64:$rB)
01567   // Emits: (ADD8:i64 G8RC:i64:$rA, G8RC:i64:$rB)
01568   // Pattern complexity = 2  cost = 1
01569   if (N.Val->getValueType(0) == MVT::i64) {
01570     Select(Tmp0, N0);
01571     Select(Tmp1, N1);
01572     if (N.Val->hasOneUse()) {
01573       Result = CurDAG->SelectNodeTo(N.Val, PPC::ADD8, MVT::i64, Tmp0, Tmp1);
01574     } else {
01575       ResNode = CurDAG->getTargetNode(PPC::ADD8, MVT::i64, Tmp0, Tmp1);
01576       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01577       Result = SDOperand(ResNode, 0);
01578     }
01579     return;
01580   }
01581 
01582   // Pattern: (add:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
01583   // Emits: (VADDUBM:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
01584   // Pattern complexity = 2  cost = 1
01585   if (N.Val->getValueType(0) == MVT::v16i8) {
01586     Select(Tmp0, N0);
01587     Select(Tmp1, N1);
01588     if (N.Val->hasOneUse()) {
01589       Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDUBM, MVT::v16i8, Tmp0, Tmp1);
01590     } else {
01591       ResNode = CurDAG->getTargetNode(PPC::VADDUBM, MVT::v16i8, Tmp0, Tmp1);
01592       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01593       Result = SDOperand(ResNode, 0);
01594     }
01595     return;
01596   }
01597 
01598   // Pattern: (add:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
01599   // Emits: (VADDUHM:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
01600   // Pattern complexity = 2  cost = 1
01601   if (N.Val->getValueType(0) == MVT::v8i16) {
01602     Select(Tmp0, N0);
01603     Select(Tmp1, N1);
01604     if (N.Val->hasOneUse()) {
01605       Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDUHM, MVT::v8i16, Tmp0, Tmp1);
01606     } else {
01607       ResNode = CurDAG->getTargetNode(PPC::VADDUHM, MVT::v8i16, Tmp0, Tmp1);
01608       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01609       Result = SDOperand(ResNode, 0);
01610     }
01611     return;
01612   }
01613 
01614   // Pattern: (add:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
01615   // Emits: (VADDUWM:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
01616   // Pattern complexity = 2  cost = 1
01617   if (N.Val->getValueType(0) == MVT::v4i32) {
01618     Select(Tmp0, N0);
01619     Select(Tmp1, N1);
01620     if (N.Val->hasOneUse()) {
01621       Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDUWM, MVT::v4i32, Tmp0, Tmp1);
01622     } else {
01623       ResNode = CurDAG->getTargetNode(PPC::VADDUWM, MVT::v4i32, Tmp0, Tmp1);
01624       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01625       Result = SDOperand(ResNode, 0);
01626     }
01627     return;
01628   }
01629   std::cerr << "Cannot yet select: ";
01630   N.Val->dump(CurDAG);
01631   std::cerr << '\n';
01632   abort();
01633 }
01634 
01635 void Select_addc(SDOperand &Result, SDOperand N) {
01636   SDOperand InFlag(0, 0);
01637   SDOperand N0(0, 0);
01638   SDOperand N1(0, 0);
01639   SDOperand Tmp0(0, 0);
01640   SDOperand Tmp1(0, 0);
01641   SDNode *ResNode;
01642   N0 = N.getOperand(0);
01643   N1 = N.getOperand(1);
01644 
01645   // Pattern: (addc:i32 GPRC:i32:$rA, (imm:i32)<<P:Predicate_immSExt16>>:$imm)
01646   // Emits: (ADDIC:i32 GPRC:i32:$rA, (imm:i32):$imm)
01647   // Pattern complexity = 5  cost = 1
01648   if (N1.getOpcode() == ISD::Constant &&
01649       Predicate_immSExt16(N1.Val) &&
01650       N.Val->getValueType(0) == MVT::i32) {
01651     Select(Tmp0, N0);
01652     unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
01653     Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
01654     ResNode = CurDAG->getTargetNode(PPC::ADDIC, MVT::i32, MVT::Flag, Tmp0, Tmp1);
01655     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01656     InFlag = SDOperand(ResNode, 1);
01657     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01658     Result = SDOperand(ResNode, N.ResNo);
01659     return;
01660   }
01661 
01662   // Pattern: (addc:i32 GPRC:i32:$rA, GPRC:i32:$rB)
01663   // Emits: (ADDC:i32 GPRC:i32:$rA, GPRC:i32:$rB)
01664   // Pattern complexity = 2  cost = 1
01665   if (N.Val->getValueType(0) == MVT::i32) {
01666     Select(Tmp0, N0);
01667     Select(Tmp1, N1);
01668     ResNode = CurDAG->getTargetNode(PPC::ADDC, MVT::i32, MVT::Flag, Tmp0, Tmp1);
01669     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01670     InFlag = SDOperand(ResNode, 1);
01671     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01672     Result = SDOperand(ResNode, N.ResNo);
01673     return;
01674   }
01675   std::cerr << "Cannot yet select: ";
01676   N.Val->dump(CurDAG);
01677   std::cerr << '\n';
01678   abort();
01679 }
01680 
01681 void Select_adde(SDOperand &Result, SDOperand N) {
01682   SDOperand InFlag(0, 0);
01683   SDOperand N0(0, 0);
01684   SDOperand N1(0, 0);
01685   SDOperand Tmp0(0, 0);
01686   SDOperand Tmp1(0, 0);
01687   SDNode *ResNode;
01688   N0 = N.getOperand(0);
01689   {
01690     N1 = N.getOperand(1);
01691 
01692     // Pattern: (adde:i32 GPRC:i32:$rA, (imm:i32)<<P:Predicate_immAllOnes>>)
01693     // Emits: (ADDME:i32 GPRC:i32:$rA)
01694     // Pattern complexity = 5  cost = 1
01695     if (N1.getOpcode() == ISD::Constant &&
01696         Predicate_immAllOnes(N1.Val) &&
01697         N.Val->getValueType(0) == MVT::i32) {
01698       Select(Tmp0, N0);
01699       Select(InFlag, N.getOperand(2));
01700       ResNode = CurDAG->getTargetNode(PPC::ADDME, MVT::i32, MVT::Flag, Tmp0, InFlag);
01701       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01702       InFlag = SDOperand(ResNode, 1);
01703       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01704       Result = SDOperand(ResNode, N.ResNo);
01705       return;
01706     }
01707 
01708     // Pattern: (adde:i32 GPRC:i32:$rA, 0:i32)
01709     // Emits: (ADDZE:i32 GPRC:i32:$rA)
01710     // Pattern complexity = 5  cost = 1
01711     if (isa<ConstantSDNode>(N1)) {
01712       int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended();
01713       if (CN0 == 0 &&
01714           N.Val->getValueType(0) == MVT::i32) {
01715         Select(Tmp1, N0);
01716         Select(InFlag, N.getOperand(2));
01717         ResNode = CurDAG->getTargetNode(PPC::ADDZE, MVT::i32, MVT::Flag, Tmp1, InFlag);
01718         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01719         InFlag = SDOperand(ResNode, 1);
01720         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01721         Result = SDOperand(ResNode, N.ResNo);
01722         return;
01723       }
01724     }
01725   }
01726 
01727   // Pattern: (adde:i32 0:i32, GPRC:i32:$rA)
01728   // Emits: (ADDZE:i32 GPRC:i32:$rA)
01729   // Pattern complexity = 5  cost = 1
01730   if (isa<ConstantSDNode>(N0)) {
01731     int64_t CN0 = cast<ConstantSDNode>(N0)->getSignExtended();
01732     if (CN0 == 0) {
01733       N1 = N.getOperand(1);
01734       if (N.Val->getValueType(0) == MVT::i32) {
01735         Select(Tmp1, N1);
01736         Select(InFlag, N.getOperand(2));
01737         ResNode = CurDAG->getTargetNode(PPC::ADDZE, MVT::i32, MVT::Flag, Tmp1, InFlag);
01738         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01739         InFlag = SDOperand(ResNode, 1);
01740         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01741         Result = SDOperand(ResNode, N.ResNo);
01742         return;
01743       }
01744     }
01745   }
01746 
01747   // Pattern: (adde:i32 GPRC:i32:$rA, GPRC:i32:$rB)
01748   // Emits: (ADDE:i32 GPRC:i32:$rA, GPRC:i32:$rB)
01749   // Pattern complexity = 2  cost = 1
01750   N1 = N.getOperand(1);
01751   if (N.Val->getValueType(0) == MVT::i32) {
01752     Select(Tmp0, N0);
01753     Select(Tmp1, N1);
01754     Select(InFlag, N.getOperand(2));
01755     ResNode = CurDAG->getTargetNode(PPC::ADDE, MVT::i32, MVT::Flag, Tmp0, Tmp1, InFlag);
01756     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
01757     InFlag = SDOperand(ResNode, 1);
01758     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
01759     Result = SDOperand(ResNode, N.ResNo);
01760     return;
01761   }
01762   std::cerr << "Cannot yet select: ";
01763   N.Val->dump(CurDAG);
01764   std::cerr << '\n';
01765   abort();
01766 }
01767 
01768 void Select_and(SDOperand &Result, SDOperand N) {
01769   SDOperand N0(0, 0);
01770   SDOperand N00(0, 0);
01771   SDOperand N01(0, 0);
01772   SDOperand N1(0, 0);
01773   SDOperand N10(0, 0);
01774   SDOperand N11(0, 0);
01775   SDOperand Tmp0(0, 0);
01776   SDOperand Tmp1(0, 0);
01777   SDOperand Tmp2(0, 0);
01778   SDNode *ResNode;
01779   N0 = N.getOperand(0);
01780   {
01781     N1 = N.getOperand(1);
01782     if (N1.getOpcode() == ISD::XOR) {
01783       N10 = N1.getOperand(0);
01784       N11 = N1.getOperand(1);
01785 
01786       // Pattern: (and:i32 GPRC:i32:$rS, (xor:i32 GPRC:i32:$rB, (imm:i32)<<P:Predicate_immAllOnes>>))
01787       // Emits: (ANDC:i32 GPRC:i32:$rS, GPRC:i32:$rB)
01788       // Pattern complexity = 7  cost = 1
01789       if (N11.getOpcode() == ISD::Constant &&
01790           Predicate_immAllOnes(N11.Val) &&
01791           N.Val->getValueType(0) == MVT::i32) {
01792         Select(Tmp0, N0);
01793         Select(Tmp1, N10);
01794         if (N.Val->hasOneUse()) {
01795           Result = CurDAG->SelectNodeTo(N.Val, PPC::ANDC, MVT::i32, Tmp0, Tmp1);
01796         } else {
01797           ResNode = CurDAG->getTargetNode(PPC::ANDC, MVT::i32, Tmp0, Tmp1);
01798           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01799           Result = SDOperand(ResNode, 0);
01800         }
01801         return;
01802       }
01803       if (N11.getOpcode() == ISD::BUILD_VECTOR &&
01804           Predicate_immAllOnesV(N11.Val)) {
01805 
01806         // Pattern: (and:v4i32 VRRC:v4i32:$vA, (xor:v4i32 VRRC:v4i32:$vB, (build_vector:v4i32)<<P:Predicate_immAllOnesV>>))
01807         // Emits: (VANDC:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
01808         // Pattern complexity = 7  cost = 1
01809         if (N.Val->getValueType(0) == MVT::v4i32) {
01810           Select(Tmp0, N0);
01811           Select(Tmp1, N10);
01812           if (N.Val->hasOneUse()) {
01813             Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v4i32, Tmp0, Tmp1);
01814           } else {
01815             ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v4i32, Tmp0, Tmp1);
01816             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01817             Result = SDOperand(ResNode, 0);
01818           }
01819           return;
01820         }
01821 
01822         // Pattern: (and:v16i8 VRRC:v16i8:$A, (xor:v16i8 VRRC:v16i8:$B, (build_vector:v16i8)<<P:Predicate_immAllOnesV>>))
01823         // Emits: (VANDC:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B)
01824         // Pattern complexity = 7  cost = 1
01825         if (N.Val->getValueType(0) == MVT::v16i8) {
01826           Select(Tmp0, N0);
01827           Select(Tmp1, N10);
01828           if (N.Val->hasOneUse()) {
01829             Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v16i8, Tmp0, Tmp1);
01830           } else {
01831             ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v16i8, Tmp0, Tmp1);
01832             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01833             Result = SDOperand(ResNode, 0);
01834           }
01835           return;
01836         }
01837 
01838         // Pattern: (and:v8i16 VRRC:v8i16:$A, (xor:v8i16 VRRC:v8i16:$B, (build_vector:v8i16)<<P:Predicate_immAllOnesV>>))
01839         // Emits: (VANDC:v8i16 VRRC:v16i8:$A, VRRC:v16i8:$B)
01840         // Pattern complexity = 7  cost = 1
01841         if (N.Val->getValueType(0) == MVT::v8i16) {
01842           Select(Tmp0, N0);
01843           Select(Tmp1, N10);
01844           if (N.Val->hasOneUse()) {
01845             Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v8i16, Tmp0, Tmp1);
01846           } else {
01847             ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v8i16, Tmp0, Tmp1);
01848             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01849             Result = SDOperand(ResNode, 0);
01850           }
01851           return;
01852         }
01853       }
01854     }
01855   }
01856 
01857   // Pattern: (and:i32 (xor:i32 GPRC:i32:$rB, (imm:i32)<<P:Predicate_immAllOnes>>), GPRC:i32:$rS)
01858   // Emits: (ANDC:i32 GPRC:i32:$rS, GPRC:i32:$rB)
01859   // Pattern complexity = 7  cost = 1
01860   if (N0.getOpcode() == ISD::XOR) {
01861     N00 = N0.getOperand(0);
01862     N01 = N0.getOperand(1);
01863     if (N01.getOpcode() == ISD::Constant &&
01864         Predicate_immAllOnes(N01.Val)) {
01865       N1 = N.getOperand(1);
01866       if (N.Val->getValueType(0) == MVT::i32) {
01867         Select(Tmp0, N1);
01868         Select(Tmp1, N00);
01869         if (N.Val->hasOneUse()) {
01870           Result = CurDAG->SelectNodeTo(N.Val, PPC::ANDC, MVT::i32, Tmp0, Tmp1);
01871         } else {
01872           ResNode = CurDAG->getTargetNode(PPC::ANDC, MVT::i32, Tmp0, Tmp1);
01873           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01874           Result = SDOperand(ResNode, 0);
01875         }
01876         return;
01877       }
01878     }
01879   }
01880 
01881   // Pattern: (and:v4i32 VRRC:v4i32:$vA, (xor:v4i32 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>, VRRC:v4i32:$vB))
01882   // Emits: (VANDC:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
01883   // Pattern complexity = 7  cost = 1
01884   {
01885     N1 = N.getOperand(1);
01886     if (N1.getOpcode() == ISD::XOR) {
01887       N10 = N1.getOperand(0);
01888       if (N10.getOpcode() == ISD::BUILD_VECTOR &&
01889           Predicate_immAllOnesV(N10.Val)) {
01890         N11 = N1.getOperand(1);
01891         if (N.Val->getValueType(0) == MVT::v4i32) {
01892           Select(Tmp0, N0);
01893           Select(Tmp1, N11);
01894           if (N.Val->hasOneUse()) {
01895             Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v4i32, Tmp0, Tmp1);
01896           } else {
01897             ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v4i32, Tmp0, Tmp1);
01898             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01899             Result = SDOperand(ResNode, 0);
01900           }
01901           return;
01902         }
01903       }
01904     }
01905   }
01906   if (N0.getOpcode() == ISD::XOR) {
01907     N00 = N0.getOperand(0);
01908 
01909     // Pattern: (and:v4i32 (xor:v4i32 VRRC:v4i32:$vB, (build_vector:v4i32)<<P:Predicate_immAllOnesV>>), VRRC:v4i32:$vA)
01910     // Emits: (VANDC:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
01911     // Pattern complexity = 7  cost = 1
01912     {
01913       N01 = N0.getOperand(1);
01914       if (N01.getOpcode() == ISD::BUILD_VECTOR &&
01915           Predicate_immAllOnesV(N01.Val)) {
01916         N1 = N.getOperand(1);
01917         if (N.Val->getValueType(0) == MVT::v4i32) {
01918           Select(Tmp0, N1);
01919           Select(Tmp1, N00);
01920           if (N.Val->hasOneUse()) {
01921             Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v4i32, Tmp0, Tmp1);
01922           } else {
01923             ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v4i32, Tmp0, Tmp1);
01924             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01925             Result = SDOperand(ResNode, 0);
01926           }
01927           return;
01928         }
01929       }
01930     }
01931 
01932     // Pattern: (and:v4i32 (xor:v4i32 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>, VRRC:v4i32:$vB), VRRC:v4i32:$vA)
01933     // Emits: (VANDC:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
01934     // Pattern complexity = 7  cost = 1
01935     if (N00.getOpcode() == ISD::BUILD_VECTOR &&
01936         Predicate_immAllOnesV(N00.Val)) {
01937       N01 = N0.getOperand(1);
01938       N1 = N.getOperand(1);
01939       if (N.Val->getValueType(0) == MVT::v4i32) {
01940         Select(Tmp0, N1);
01941         Select(Tmp1, N01);
01942         if (N.Val->hasOneUse()) {
01943           Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v4i32, Tmp0, Tmp1);
01944         } else {
01945           ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v4i32, Tmp0, Tmp1);
01946           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01947           Result = SDOperand(ResNode, 0);
01948         }
01949         return;
01950       }
01951     }
01952   }
01953 
01954   // Pattern: (and:v16i8 VRRC:v16i8:$A, (xor:v16i8 (build_vector:v16i8)<<P:Predicate_immAllOnesV>>, VRRC:v16i8:$B))
01955   // Emits: (VANDC:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B)
01956   // Pattern complexity = 7  cost = 1
01957   {
01958     N1 = N.getOperand(1);
01959     if (N1.getOpcode() == ISD::XOR) {
01960       N10 = N1.getOperand(0);
01961       if (N10.getOpcode() == ISD::BUILD_VECTOR &&
01962           Predicate_immAllOnesV(N10.Val)) {
01963         N11 = N1.getOperand(1);
01964         if (N.Val->getValueType(0) == MVT::v16i8) {
01965           Select(Tmp0, N0);
01966           Select(Tmp1, N11);
01967           if (N.Val->hasOneUse()) {
01968             Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v16i8, Tmp0, Tmp1);
01969           } else {
01970             ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v16i8, Tmp0, Tmp1);
01971             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01972             Result = SDOperand(ResNode, 0);
01973           }
01974           return;
01975         }
01976       }
01977     }
01978   }
01979   if (N0.getOpcode() == ISD::XOR) {
01980     N00 = N0.getOperand(0);
01981 
01982     // Pattern: (and:v16i8 (xor:v16i8 VRRC:v16i8:$B, (build_vector:v16i8)<<P:Predicate_immAllOnesV>>), VRRC:v16i8:$A)
01983     // Emits: (VANDC:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B)
01984     // Pattern complexity = 7  cost = 1
01985     {
01986       N01 = N0.getOperand(1);
01987       if (N01.getOpcode() == ISD::BUILD_VECTOR &&
01988           Predicate_immAllOnesV(N01.Val)) {
01989         N1 = N.getOperand(1);
01990         if (N.Val->getValueType(0) == MVT::v16i8) {
01991           Select(Tmp0, N1);
01992           Select(Tmp1, N00);
01993           if (N.Val->hasOneUse()) {
01994             Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v16i8, Tmp0, Tmp1);
01995           } else {
01996             ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v16i8, Tmp0, Tmp1);
01997             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
01998             Result = SDOperand(ResNode, 0);
01999           }
02000           return;
02001         }
02002       }
02003     }
02004 
02005     // Pattern: (and:v16i8 (xor:v16i8 (build_vector:v16i8)<<P:Predicate_immAllOnesV>>, VRRC:v16i8:$B), VRRC:v16i8:$A)
02006     // Emits: (VANDC:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B)
02007     // Pattern complexity = 7  cost = 1
02008     if (N00.getOpcode() == ISD::BUILD_VECTOR &&
02009         Predicate_immAllOnesV(N00.Val)) {
02010       N01 = N0.getOperand(1);
02011       N1 = N.getOperand(1);
02012       if (N.Val->getValueType(0) == MVT::v16i8) {
02013         Select(Tmp0, N1);
02014         Select(Tmp1, N01);
02015         if (N.Val->hasOneUse()) {
02016           Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v16i8, Tmp0, Tmp1);
02017         } else {
02018           ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v16i8, Tmp0, Tmp1);
02019           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02020           Result = SDOperand(ResNode, 0);
02021         }
02022         return;
02023       }
02024     }
02025   }
02026 
02027   // Pattern: (and:v8i16 VRRC:v8i16:$A, (xor:v8i16 (build_vector:v8i16)<<P:Predicate_immAllOnesV>>, VRRC:v8i16:$B))
02028   // Emits: (VANDC:v8i16 VRRC:v16i8:$A, VRRC:v16i8:$B)
02029   // Pattern complexity = 7  cost = 1
02030   {
02031     N1 = N.getOperand(1);
02032     if (N1.getOpcode() == ISD::XOR) {
02033       N10 = N1.getOperand(0);
02034       if (N10.getOpcode() == ISD::BUILD_VECTOR &&
02035           Predicate_immAllOnesV(N10.Val)) {
02036         N11 = N1.getOperand(1);
02037         if (N.Val->getValueType(0) == MVT::v8i16) {
02038           Select(Tmp0, N0);
02039           Select(Tmp1, N11);
02040           if (N.Val->hasOneUse()) {
02041             Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v8i16, Tmp0, Tmp1);
02042           } else {
02043             ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v8i16, Tmp0, Tmp1);
02044             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02045             Result = SDOperand(ResNode, 0);
02046           }
02047           return;
02048         }
02049       }
02050     }
02051   }
02052   if (N0.getOpcode() == ISD::XOR) {
02053     N00 = N0.getOperand(0);
02054 
02055     // Pattern: (and:v8i16 (xor:v8i16 VRRC:v8i16:$B, (build_vector:v8i16)<<P:Predicate_immAllOnesV>>), VRRC:v8i16:$A)
02056     // Emits: (VANDC:v8i16 VRRC:v16i8:$A, VRRC:v16i8:$B)
02057     // Pattern complexity = 7  cost = 1
02058     {
02059       N01 = N0.getOperand(1);
02060       if (N01.getOpcode() == ISD::BUILD_VECTOR &&
02061           Predicate_immAllOnesV(N01.Val)) {
02062         N1 = N.getOperand(1);
02063         if (N.Val->getValueType(0) == MVT::v8i16) {
02064           Select(Tmp0, N1);
02065           Select(Tmp1, N00);
02066           if (N.Val->hasOneUse()) {
02067             Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v8i16, Tmp0, Tmp1);
02068           } else {
02069             ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v8i16, Tmp0, Tmp1);
02070             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02071             Result = SDOperand(ResNode, 0);
02072           }
02073           return;
02074         }
02075       }
02076     }
02077 
02078     // Pattern: (and:v8i16 (xor:v8i16 (build_vector:v8i16)<<P:Predicate_immAllOnesV>>, VRRC:v8i16:$B), VRRC:v8i16:$A)
02079     // Emits: (VANDC:v8i16 VRRC:v16i8:$A, VRRC:v16i8:$B)
02080     // Pattern complexity = 7  cost = 1
02081     if (N00.getOpcode() == ISD::BUILD_VECTOR &&
02082         Predicate_immAllOnesV(N00.Val)) {
02083       N01 = N0.getOperand(1);
02084       N1 = N.getOperand(1);
02085       if (N.Val->getValueType(0) == MVT::v8i16) {
02086         Select(Tmp0, N1);
02087         Select(Tmp1, N01);
02088         if (N.Val->hasOneUse()) {
02089           Result = CurDAG->SelectNodeTo(N.Val, PPC::VANDC, MVT::v8i16, Tmp0, Tmp1);
02090         } else {
02091           ResNode = CurDAG->getTargetNode(PPC::VANDC, MVT::v8i16, Tmp0, Tmp1);
02092           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02093           Result = SDOperand(ResNode, 0);
02094         }
02095         return;
02096       }
02097     }
02098   }
02099   N1 = N.getOperand(1);
02100   if (N1.getOpcode() == ISD::Constant) {
02101 
02102     // Pattern: (and:i32 GPRC:i32:$src1, (imm:i32)<<P:Predicate_immZExt16>><<X:LO16>>:$src2)
02103     // Emits: (ANDIo:i32 GPRC:i32:$src1, (LO16:i32 (imm:i32):$src2))
02104     // Pattern complexity = 5  cost = 1
02105     if (Predicate_immZExt16(N1.Val) &&
02106         N.Val->getValueType(0) == MVT::i32) {
02107       Select(Tmp0, N0);
02108       unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
02109       Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
02110       Tmp2 = Transform_LO16(Tmp1.Val);
02111       if (N.Val->hasOneUse()) {
02112         Result = CurDAG->SelectNodeTo(N.Val, PPC::ANDIo, MVT::i32, Tmp0, Tmp2);
02113       } else {
02114         ResNode = CurDAG->getTargetNode(PPC::ANDIo, MVT::i32, Tmp0, Tmp2);
02115         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02116         Result = SDOperand(ResNode, 0);
02117       }
02118       return;
02119     }
02120 
02121     // Pattern: (and:i32 GPRC:i32:$src1, (imm:i32)<<P:Predicate_imm16Shifted>><<X:HI16>>:$src2)
02122     // Emits: (ANDISo:i32 GPRC:i32:$src1, (HI16:i32 (imm:i32):$src2))
02123     // Pattern complexity = 5  cost = 1
02124     if (Predicate_imm16Shifted(N1.Val) &&
02125         N.Val->getValueType(0) == MVT::i32) {
02126       Select(Tmp0, N0);
02127       unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
02128       Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
02129       Tmp2 = Transform_HI16(Tmp1.Val);
02130       if (N.Val->hasOneUse()) {
02131         Result = CurDAG->SelectNodeTo(N.Val, PPC::ANDISo, MVT::i32, Tmp0, Tmp2);
02132       } else {
02133         ResNode = CurDAG->getTargetNode(PPC::ANDISo, MVT::i32, Tmp0, Tmp2);
02134         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02135         Result = SDOperand(ResNode, 0);
02136       }
02137       return;
02138     }
02139   }
02140 
02141   // Pattern: (and:i32 GPRC:i32:$rS, GPRC:i32:$rB)
02142   // Emits: (AND:i32 GPRC:i32:$rS, GPRC:i32:$rB)
02143   // Pattern complexity = 2  cost = 1
02144   if (N.Val->getValueType(0) == MVT::i32) {
02145     Select(Tmp0, N0);
02146     Select(Tmp1, N1);
02147     if (N.Val->hasOneUse()) {
02148       Result = CurDAG->SelectNodeTo(N.Val, PPC::AND, MVT::i32, Tmp0, Tmp1);
02149     } else {
02150       ResNode = CurDAG->getTargetNode(PPC::AND, MVT::i32, Tmp0, Tmp1);
02151       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02152       Result = SDOperand(ResNode, 0);
02153     }
02154     return;
02155   }
02156 
02157   // Pattern: (and:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
02158   // Emits: (VAND:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
02159   // Pattern complexity = 2  cost = 1
02160   if (N.Val->getValueType(0) == MVT::v4i32) {
02161     Select(Tmp0, N0);
02162     Select(Tmp1, N1);
02163     if (N.Val->hasOneUse()) {
02164       Result = CurDAG->SelectNodeTo(N.Val, PPC::VAND, MVT::v4i32, Tmp0, Tmp1);
02165     } else {
02166       ResNode = CurDAG->getTargetNode(PPC::VAND, MVT::v4i32, Tmp0, Tmp1);
02167       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02168       Result = SDOperand(ResNode, 0);
02169     }
02170     return;
02171   }
02172 
02173   // Pattern: (and:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B)
02174   // Emits: (VAND:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B)
02175   // Pattern complexity = 2  cost = 1
02176   if (N.Val->getValueType(0) == MVT::v16i8) {
02177     Select(Tmp0, N0);
02178     Select(Tmp1, N1);
02179     if (N.Val->hasOneUse()) {
02180       Result = CurDAG->SelectNodeTo(N.Val, PPC::VAND, MVT::v16i8, Tmp0, Tmp1);
02181     } else {
02182       ResNode = CurDAG->getTargetNode(PPC::VAND, MVT::v16i8, Tmp0, Tmp1);
02183       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02184       Result = SDOperand(ResNode, 0);
02185     }
02186     return;
02187   }
02188 
02189   // Pattern: (and:v8i16 VRRC:v8i16:$A, VRRC:v8i16:$B)
02190   // Emits: (VAND:v8i16 VRRC:v16i8:$A, VRRC:v16i8:$B)
02191   // Pattern complexity = 2  cost = 1
02192   if (N.Val->getValueType(0) == MVT::v8i16) {
02193     Select(Tmp0, N0);
02194     Select(Tmp1, N1);
02195     if (N.Val->hasOneUse()) {
02196       Result = CurDAG->SelectNodeTo(N.Val, PPC::VAND, MVT::v8i16, Tmp0, Tmp1);
02197     } else {
02198       ResNode = CurDAG->getTargetNode(PPC::VAND, MVT::v8i16, Tmp0, Tmp1);
02199       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02200       Result = SDOperand(ResNode, 0);
02201     }
02202     return;
02203   }
02204   std::cerr << "Cannot yet select: ";
02205   N.Val->dump(CurDAG);
02206   std::cerr << '\n';
02207   abort();
02208 }
02209 
02210 void Select_anyext(SDOperand &Result, SDOperand N) {
02211   SDOperand N0(0, 0);
02212   SDOperand Tmp0(0, 0);
02213   SDNode *ResNode;
02214   N0 = N.getOperand(0);
02215   if (N.Val->getValueType(0) == MVT::i64 &&
02216       N0.Val->getValueType(0) == MVT::i32) {
02217     Select(Tmp0, N0);
02218     if (N.Val->hasOneUse()) {
02219       Result = CurDAG->SelectNodeTo(N.Val, PPC::OR4To8, MVT::i64, Tmp0, Tmp0);
02220     } else {
02221       ResNode = CurDAG->getTargetNode(PPC::OR4To8, MVT::i64, Tmp0, Tmp0);
02222       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02223       Result = SDOperand(ResNode, 0);
02224     }
02225     return;
02226   }
02227   std::cerr << "Cannot yet select: ";
02228   N.Val->dump(CurDAG);
02229   std::cerr << '\n';
02230   abort();
02231 }
02232 
02233 void Select_bitconvert(SDOperand &Result, SDOperand N) {
02234   SDOperand N0(0, 0);
02235   SDOperand Tmp0(0, 0);
02236   N0 = N.getOperand(0);
02237   if (N.Val->getValueType(0) == MVT::v16i8) {
02238 
02239     // Pattern: (bitconvert:v16i8 VRRC:v8i16:$src)
02240     // Emits: VRRC:v16i8:$src
02241     // Pattern complexity = 2  cost = 0
02242     if (N0.Val->getValueType(0) == MVT::v8i16) {
02243       Select(Tmp0, N0);
02244       Result = Tmp0;
02245       return;
02246     }
02247 
02248     // Pattern: (bitconvert:v16i8 VRRC:v4i32:$src)
02249     // Emits: VRRC:v16i8:$src
02250     // Pattern complexity = 2  cost = 0
02251     if (N0.Val->getValueType(0) == MVT::v4i32) {
02252       Select(Tmp0, N0);
02253       Result = Tmp0;
02254       return;
02255     }
02256 
02257     // Pattern: (bitconvert:v16i8 VRRC:v4f32:$src)
02258     // Emits: VRRC:v16i8:$src
02259     // Pattern complexity = 2  cost = 0
02260     if (N0.Val->getValueType(0) == MVT::v4f32) {
02261       Select(Tmp0, N0);
02262       Result = Tmp0;
02263       return;
02264     }
02265   }
02266   if (N.Val->getValueType(0) == MVT::v8i16) {
02267 
02268     // Pattern: (bitconvert:v8i16 VRRC:v16i8:$src)
02269     // Emits: VRRC:v8i16:$src
02270     // Pattern complexity = 2  cost = 0
02271     if (N0.Val->getValueType(0) == MVT::v16i8) {
02272       Select(Tmp0, N0);
02273       Result = Tmp0;
02274       return;
02275     }
02276 
02277     // Pattern: (bitconvert:v8i16 VRRC:v4i32:$src)
02278     // Emits: VRRC:v8i16:$src
02279     // Pattern complexity = 2  cost = 0
02280     if (N0.Val->getValueType(0) == MVT::v4i32) {
02281       Select(Tmp0, N0);
02282       Result = Tmp0;
02283       return;
02284     }
02285 
02286     // Pattern: (bitconvert:v8i16 VRRC:v4f32:$src)
02287     // Emits: VRRC:v8i16:$src
02288     // Pattern complexity = 2  cost = 0
02289     if (N0.Val->getValueType(0) == MVT::v4f32) {
02290       Select(Tmp0, N0);
02291       Result = Tmp0;
02292       return;
02293     }
02294   }
02295   if (N.Val->getValueType(0) == MVT::v4i32) {
02296 
02297     // Pattern: (bitconvert:v4i32 VRRC:v16i8:$src)
02298     // Emits: VRRC:v4i32:$src
02299     // Pattern complexity = 2  cost = 0
02300     if (N0.Val->getValueType(0) == MVT::v16i8) {
02301       Select(Tmp0, N0);
02302       Result = Tmp0;
02303       return;
02304     }
02305 
02306     // Pattern: (bitconvert:v4i32 VRRC:v8i16:$src)
02307     // Emits: VRRC:v4i32:$src
02308     // Pattern complexity = 2  cost = 0
02309     if (N0.Val->getValueType(0) == MVT::v8i16) {
02310       Select(Tmp0, N0);
02311       Result = Tmp0;
02312       return;
02313     }
02314 
02315     // Pattern: (bitconvert:v4i32 VRRC:v4f32:$src)
02316     // Emits: VRRC:v4i32:$src
02317     // Pattern complexity = 2  cost = 0
02318     if (N0.Val->getValueType(0) == MVT::v4f32) {
02319       Select(Tmp0, N0);
02320       Result = Tmp0;
02321       return;
02322     }
02323   }
02324   if (N.Val->getValueType(0) == MVT::v4f32) {
02325 
02326     // Pattern: (bitconvert:v4f32 VRRC:v16i8:$src)
02327     // Emits: VRRC:v4f32:$src
02328     // Pattern complexity = 2  cost = 0
02329     if (N0.Val->getValueType(0) == MVT::v16i8) {
02330       Select(Tmp0, N0);
02331       Result = Tmp0;
02332       return;
02333     }
02334 
02335     // Pattern: (bitconvert:v4f32 VRRC:v8i16:$src)
02336     // Emits: VRRC:v4f32:$src
02337     // Pattern complexity = 2  cost = 0
02338     if (N0.Val->getValueType(0) == MVT::v8i16) {
02339       Select(Tmp0, N0);
02340       Result = Tmp0;
02341       return;
02342     }
02343 
02344     // Pattern: (bitconvert:v4f32 VRRC:v4i32:$src)
02345     // Emits: VRRC:v4f32:$src
02346     // Pattern complexity = 2  cost = 0
02347     if (N0.Val->getValueType(0) == MVT::v4i32) {
02348       Select(Tmp0, N0);
02349       Result = Tmp0;
02350       return;
02351     }
02352   }
02353   std::cerr << "Cannot yet select: ";
02354   N.Val->dump(CurDAG);
02355   std::cerr << '\n';
02356   abort();
02357 }
02358 
02359 void Select_br(SDOperand &Result, SDOperand N) {
02360   SDOperand Chain(0, 0);
02361   SDOperand N1(0, 0);
02362   SDOperand Tmp0(0, 0);
02363   SDNode *ResNode;
02364   Chain = N.getOperand(0);
02365   N1 = N.getOperand(1);
02366   if (N1.getOpcode() == ISD::BasicBlock) {
02367     Select(Tmp0, N1);
02368     Select(Chain, Chain);
02369     ResNode = CurDAG->getTargetNode(PPC::B, MVT::Other, Tmp0, Chain);
02370     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
02371     Result = SDOperand(ResNode, N.ResNo);
02372     return;
02373   }
02374   std::cerr << "Cannot yet select: ";
02375   N.Val->dump(CurDAG);
02376   std::cerr << '\n';
02377   abort();
02378 }
02379 
02380 void Select_build_vector(SDOperand &Result, SDOperand N) {
02381   SDOperand Tmp0(0, 0);
02382   SDOperand Tmp1(0, 0);
02383   SDNode *ResNode;
02384 
02385   // Pattern: (build_vector:v16i8)<<P:Predicate_vecspltisb>><<X:VSPLTISB_get_imm>>:$SIMM
02386   // Emits: (VSPLTISB:v16i8 (VSPLTISB_get_imm:i32 (build_vector:v16i8):$SIMM))
02387   // Pattern complexity = 3  cost = 1
02388   if (Predicate_vecspltisb(N.Val) &&
02389       N.Val->getValueType(0) == MVT::v16i8) {
02390     Tmp0 = N;
02391     Tmp1 = Transform_VSPLTISB_get_imm(Tmp0.Val);
02392     if (N.Val->hasOneUse()) {
02393       Result = CurDAG->SelectNodeTo(N.Val, PPC::VSPLTISB, MVT::v16i8, Tmp1);
02394     } else {
02395       ResNode = CurDAG->getTargetNode(PPC::VSPLTISB, MVT::v16i8, Tmp1);
02396       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02397       Result = SDOperand(ResNode, 0);
02398     }
02399     return;
02400   }
02401 
02402   // Pattern: (build_vector:v8i16)<<P:Predicate_vecspltish>><<X:VSPLTISH_get_imm>>:$SIMM
02403   // Emits: (VSPLTISH:v8i16 (VSPLTISH_get_imm:i32 (build_vector:v8i16):$SIMM))
02404   // Pattern complexity = 3  cost = 1
02405   if (Predicate_vecspltish(N.Val) &&
02406       N.Val->getValueType(0) == MVT::v8i16) {
02407     Tmp0 = N;
02408     Tmp1 = Transform_VSPLTISH_get_imm(Tmp0.Val);
02409     if (N.Val->hasOneUse()) {
02410       Result = CurDAG->SelectNodeTo(N.Val, PPC::VSPLTISH, MVT::v8i16, Tmp1);
02411     } else {
02412       ResNode = CurDAG->getTargetNode(PPC::VSPLTISH, MVT::v8i16, Tmp1);
02413       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02414       Result = SDOperand(ResNode, 0);
02415     }
02416     return;
02417   }
02418 
02419   // Pattern: (build_vector:v4i32)<<P:Predicate_vecspltisw>><<X:VSPLTISW_get_imm>>:$SIMM
02420   // Emits: (VSPLTISW:v4i32 (VSPLTISW_get_imm:i32 (build_vector:v4i32):$SIMM))
02421   // Pattern complexity = 3  cost = 1
02422   if (Predicate_vecspltisw(N.Val) &&
02423       N.Val->getValueType(0) == MVT::v4i32) {
02424     Tmp0 = N;
02425     Tmp1 = Transform_VSPLTISW_get_imm(Tmp0.Val);
02426     if (N.Val->hasOneUse()) {
02427       Result = CurDAG->SelectNodeTo(N.Val, PPC::VSPLTISW, MVT::v4i32, Tmp1);
02428     } else {
02429       ResNode = CurDAG->getTargetNode(PPC::VSPLTISW, MVT::v4i32, Tmp1);
02430       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02431       Result = SDOperand(ResNode, 0);
02432     }
02433     return;
02434   }
02435 
02436   // Pattern: (build_vector:v4i32)<<P:Predicate_immAllZerosV>>
02437   // Emits: (V_SET0:v4i32)
02438   // Pattern complexity = 3  cost = 1
02439   if (Predicate_immAllZerosV(N.Val) &&
02440       N.Val->getValueType(0) == MVT::v4i32) {
02441     if (N.Val->hasOneUse()) {
02442       Result = CurDAG->SelectNodeTo(N.Val, PPC::V_SET0, MVT::v4i32);
02443     } else {
02444       ResNode = CurDAG->getTargetNode(PPC::V_SET0, MVT::v4i32);
02445       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02446       Result = SDOperand(ResNode, 0);
02447     }
02448     return;
02449   }
02450   std::cerr << "Cannot yet select: ";
02451   N.Val->dump(CurDAG);
02452   std::cerr << '\n';
02453   abort();
02454 }
02455 
02456 void Select_callseq_end(SDOperand &Result, SDOperand N) {
02457   SDOperand Chain(0, 0);
02458   SDOperand N1(0, 0);
02459   SDOperand Tmp0(0, 0);
02460   SDNode *ResNode;
02461   Chain = N.getOperand(0);
02462   N1 = N.getOperand(1);
02463   if (N1.getOpcode() == ISD::Constant) {
02464     unsigned Tmp0C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
02465     Tmp0 = CurDAG->getTargetConstant(Tmp0C, MVT::i32);
02466     Select(Chain, Chain);
02467     ResNode = CurDAG->getTargetNode(PPC::ADJCALLSTACKUP, MVT::Other, Tmp0, Chain);
02468     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
02469     Result = SDOperand(ResNode, N.ResNo);
02470     return;
02471   }
02472   std::cerr << "Cannot yet select: ";
02473   N.Val->dump(CurDAG);
02474   std::cerr << '\n';
02475   abort();
02476 }
02477 
02478 void Select_callseq_start(SDOperand &Result, SDOperand N) {
02479   SDOperand Chain(0, 0);
02480   SDOperand N1(0, 0);
02481   SDOperand Tmp0(0, 0);
02482   SDNode *ResNode;
02483   Chain = N.getOperand(0);
02484   N1 = N.getOperand(1);
02485   if (N1.getOpcode() == ISD::Constant) {
02486     unsigned Tmp0C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
02487     Tmp0 = CurDAG->getTargetConstant(Tmp0C, MVT::i32);
02488     Select(Chain, Chain);
02489     ResNode = CurDAG->getTargetNode(PPC::ADJCALLSTACKDOWN, MVT::Other, Tmp0, Chain);
02490     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
02491     Result = SDOperand(ResNode, N.ResNo);
02492     return;
02493   }
02494   std::cerr << "Cannot yet select: ";
02495   N.Val->dump(CurDAG);
02496   std::cerr << '\n';
02497   abort();
02498 }
02499 
02500 void Select_ctlz(SDOperand &Result, SDOperand N) {
02501   SDOperand N0(0, 0);
02502   SDOperand Tmp0(0, 0);
02503   SDNode *ResNode;
02504   N0 = N.getOperand(0);
02505   if (N.Val->getValueType(0) == MVT::i32) {
02506     Select(Tmp0, N0);
02507     if (N.Val->hasOneUse()) {
02508       Result = CurDAG->SelectNodeTo(N.Val, PPC::CNTLZW, MVT::i32, Tmp0);
02509     } else {
02510       ResNode = CurDAG->getTargetNode(PPC::CNTLZW, MVT::i32, Tmp0);
02511       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02512       Result = SDOperand(ResNode, 0);
02513     }
02514     return;
02515   }
02516   std::cerr << "Cannot yet select: ";
02517   N.Val->dump(CurDAG);
02518   std::cerr << '\n';
02519   abort();
02520 }
02521 
02522 void Select_dwarf_label(SDOperand &Result, SDOperand N) {
02523   SDOperand Chain(0, 0);
02524   SDOperand N1(0, 0);
02525   SDOperand Tmp0(0, 0);
02526   SDNode *ResNode;
02527   Chain = N.getOperand(0);
02528   N1 = N.getOperand(1);
02529   if (N1.getOpcode() == ISD::Constant &&
02530       N1.Val->getValueType(0) == MVT::i32) {
02531     unsigned Tmp0C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
02532     Tmp0 = CurDAG->getTargetConstant(Tmp0C, MVT::i32);
02533     Select(Chain, Chain);
02534     ResNode = CurDAG->getTargetNode(PPC::DWARF_LABEL, MVT::Other, Tmp0, Chain);
02535     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
02536     Result = SDOperand(ResNode, N.ResNo);
02537     return;
02538   }
02539   std::cerr << "Cannot yet select: ";
02540   N.Val->dump(CurDAG);
02541   std::cerr << '\n';
02542   abort();
02543 }
02544 
02545 void Select_dwarf_loc(SDOperand &Result, SDOperand N) {
02546   SDOperand Chain(0, 0);
02547   SDOperand N1(0, 0);
02548   SDOperand N2(0, 0);
02549   SDOperand N3(0, 0);
02550   SDOperand Tmp0(0, 0);
02551   SDOperand Tmp1(0, 0);
02552   SDOperand Tmp2(0, 0);
02553   SDNode *ResNode;
02554   Chain = N.getOperand(0);
02555   N1 = N.getOperand(1);
02556   if (N1.getOpcode() == ISD::Constant) {
02557     N2 = N.getOperand(2);
02558     if (N2.getOpcode() == ISD::Constant) {
02559       N3 = N.getOperand(3);
02560       if (N3.getOpcode() == ISD::Constant &&
02561           N1.Val->getValueType(0) == MVT::i32 &&
02562           N2.Val->getValueType(0) == MVT::i32 &&
02563           N3.Val->getValueType(0) == MVT::i32) {
02564         unsigned Tmp0C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
02565         Tmp0 = CurDAG->getTargetConstant(Tmp0C, MVT::i32);
02566         unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N2)->getValue();
02567         Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
02568         unsigned Tmp2C = (unsigned)cast<ConstantSDNode>(N3)->getValue();
02569         Tmp2 = CurDAG->getTargetConstant(Tmp2C, MVT::i32);
02570         Select(Chain, Chain);
02571         ResNode = CurDAG->getTargetNode(PPC::DWARF_LOC, MVT::Other, Tmp0, Tmp1, Tmp2, Chain);
02572         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
02573         Result = SDOperand(ResNode, N.ResNo);
02574         return;
02575       }
02576     }
02577   }
02578   std::cerr << "Cannot yet select: ";
02579   N.Val->dump(CurDAG);
02580   std::cerr << '\n';
02581   abort();
02582 }
02583 
02584 void Select_extld(SDOperand &Result, SDOperand N) {
02585   if (N.ResNo == 1 && N.getValue(0).hasOneUse()) {
02586     SDOperand Dummy = CurDAG->getNode(ISD::HANDLENODE, MVT::Other, N);
02587     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Dummy.Val, 0);
02588     SelectionDAG::InsertISelMapEntry(HandleMap, N.Val, 1, Dummy.Val, 0);
02589     Result = Dummy;
02590     return;
02591   }
02592   SDOperand Chain(0, 0);
02593   SDOperand N1(0, 0);
02594   SDOperand N2(0, 0);
02595   SDOperand N3(0, 0);
02596   SDOperand Tmp0(0, 0);
02597   SDOperand Tmp1(0, 0);
02598   SDOperand Tmp2(0, 0);
02599   SDNode *ResNode;
02600   Chain = N.getOperand(0);
02601   N1 = N.getOperand(1);
02602   N2 = N.getOperand(2);
02603   N3 = N.getOperand(3);
02604   if (cast<VTSDNode>(N3)->getVT() == MVT::i1 &&
02605       N.Val->getValueType(0) == MVT::i32) {
02606 
02607     // Pattern: (extld:i32 iaddr:i32:$src, srcvalue:Other:$dummy, i1:Other)
02608     // Emits: (LBZ:i32 iaddr:i32:$src)
02609     // Pattern complexity = 8  cost = 1
02610     if (SelectAddrImm(N1, Tmp0, Tmp1)) {
02611       Select(Tmp0, Tmp0);
02612       Select(Tmp1, Tmp1);
02613       Select(Chain, Chain);
02614       ResNode = CurDAG->getTargetNode(PPC::LBZ, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain);
02615       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
02616       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
02617       if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
02618       Result = SDOperand(ResNode, N.ResNo);
02619       return;
02620     }
02621 
02622     // Pattern: (extld:i32 xaddr:i32:$src, srcvalue:Other:$dummy, i1:Other)
02623     // Emits: (LBZX:i32 xaddr:i32:$src)
02624     // Pattern complexity = 8  cost = 1
02625     if (SelectAddrIdx(N1, Tmp0, Tmp1)) {
02626       Select(Tmp0, Tmp0);
02627       Select(Tmp1, Tmp1);
02628       Select(Chain, Chain);
02629       ResNode = CurDAG->getTargetNode(PPC::LBZX, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain);
02630       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
02631       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
02632       if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
02633       Result = SDOperand(ResNode, N.ResNo);
02634       return;
02635     }
02636   }
02637   if (cast<VTSDNode>(N3)->getVT() == MVT::i8 &&
02638       N.Val->getValueType(0) == MVT::i32) {
02639 
02640     // Pattern: (extld:i32 iaddr:i32:$src, srcvalue:Other:$dummy, i8:Other)
02641     // Emits: (LBZ:i32 iaddr:i32:$src)
02642     // Pattern complexity = 8  cost = 1
02643     if (SelectAddrImm(N1, Tmp0, Tmp1)) {
02644       Select(Tmp0, Tmp0);
02645       Select(Tmp1, Tmp1);
02646       Select(Chain, Chain);
02647       ResNode = CurDAG->getTargetNode(PPC::LBZ, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain);
02648       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
02649       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
02650       if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
02651       Result = SDOperand(ResNode, N.ResNo);
02652       return;
02653     }
02654 
02655     // Pattern: (extld:i32 xaddr:i32:$src, srcvalue:Other:$dummy, i8:Other)
02656     // Emits: (LBZX:i32 xaddr:i32:$src)
02657     // Pattern complexity = 8  cost = 1
02658     if (SelectAddrIdx(N1, Tmp0, Tmp1)) {
02659       Select(Tmp0, Tmp0);
02660       Select(Tmp1, Tmp1);
02661       Select(Chain, Chain);
02662       ResNode = CurDAG->getTargetNode(PPC::LBZX, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain);
02663       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
02664       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
02665       if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
02666       Result = SDOperand(ResNode, N.ResNo);
02667       return;
02668     }
02669   }
02670   if (cast<VTSDNode>(N3)->getVT() == MVT::i16 &&
02671       N.Val->getValueType(0) == MVT::i32) {
02672 
02673     // Pattern: (extld:i32 iaddr:i32:$src, srcvalue:Other:$dummy, i16:Other)
02674     // Emits: (LHZ:i32 iaddr:i32:$src)
02675     // Pattern complexity = 8  cost = 1
02676     if (SelectAddrImm(N1, Tmp0, Tmp1)) {
02677       Select(Tmp0, Tmp0);
02678       Select(Tmp1, Tmp1);
02679       Select(Chain, Chain);
02680       ResNode = CurDAG->getTargetNode(PPC::LHZ, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain);
02681       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
02682       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
02683       if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
02684       Result = SDOperand(ResNode, N.ResNo);
02685       return;
02686     }
02687 
02688     // Pattern: (extld:i32 xaddr:i32:$src, srcvalue:Other:$dummy, i16:Other)
02689     // Emits: (LHZX:i32 xaddr:i32:$src)
02690     // Pattern complexity = 8  cost = 1
02691     if (SelectAddrIdx(N1, Tmp0, Tmp1)) {
02692       Select(Tmp0, Tmp0);
02693       Select(Tmp1, Tmp1);
02694       Select(Chain, Chain);
02695       ResNode = CurDAG->getTargetNode(PPC::LHZX, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain);
02696       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
02697       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
02698       if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
02699       Result = SDOperand(ResNode, N.ResNo);
02700       return;
02701     }
02702   }
02703   if (cast<VTSDNode>(N3)->getVT() == MVT::f32 &&
02704       N.Val->getValueType(0) == MVT::f64) {
02705 
02706     // Pattern: (extld:f64 iaddr:i32:$src, srcvalue:Other:$dummy, f32:Other)
02707     // Emits: (FMRSD:f64 (LFS:f32 iaddr:i32:$src))
02708     // Pattern complexity = 8  cost = 2
02709     if (SelectAddrImm(N1, Tmp0, Tmp1)) {
02710       Select(Tmp0, Tmp0);
02711       Select(Tmp1, Tmp1);
02712       Tmp2 = SDOperand(CurDAG->getTargetNode(PPC::LFS, MVT::f32, Tmp0, Tmp1), 0);
02713       Select(Chain, Chain);
02714       ResNode = CurDAG->getTargetNode(PPC::FMRSD, MVT::f64, MVT::Other, Tmp2, Chain);
02715       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
02716       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
02717       if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
02718       Result = SDOperand(ResNode, N.ResNo);
02719       return;
02720     }
02721 
02722     // Pattern: (extld:f64 xaddr:i32:$src, srcvalue:Other:$dummy, f32:Other)
02723     // Emits: (FMRSD:f64 (LFSX:f32 xaddr:i32:$src))
02724     // Pattern complexity = 8  cost = 2
02725     if (SelectAddrIdx(N1, Tmp0, Tmp1)) {
02726       Select(Tmp0, Tmp0);
02727       Select(Tmp1, Tmp1);
02728       Tmp2 = SDOperand(CurDAG->getTargetNode(PPC::LFSX, MVT::f32, Tmp0, Tmp1), 0);
02729       Select(Chain, Chain);
02730       ResNode = CurDAG->getTargetNode(PPC::FMRSD, MVT::f64, MVT::Other, Tmp2, Chain);
02731       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
02732       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
02733       if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
02734       Result = SDOperand(ResNode, N.ResNo);
02735       return;
02736     }
02737   }
02738   std::cerr << "Cannot yet select: ";
02739   N.Val->dump(CurDAG);
02740   std::cerr << '\n';
02741   abort();
02742 }
02743 
02744 void Select_fabs(SDOperand &Result, SDOperand N) {
02745   SDOperand N0(0, 0);
02746   SDOperand Tmp0(0, 0);
02747   SDNode *ResNode;
02748   N0 = N.getOperand(0);
02749 
02750   // Pattern: (fabs:f32 F4RC:f32:$frB)
02751   // Emits: (FABSS:f32 F4RC:f32:$frB)
02752   // Pattern complexity = 2  cost = 1
02753   if (N.Val->getValueType(0) == MVT::f32) {
02754     Select(Tmp0, N0);
02755     if (N.Val->hasOneUse()) {
02756       Result = CurDAG->SelectNodeTo(N.Val, PPC::FABSS, MVT::f32, Tmp0);
02757     } else {
02758       ResNode = CurDAG->getTargetNode(PPC::FABSS, MVT::f32, Tmp0);
02759       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02760       Result = SDOperand(ResNode, 0);
02761     }
02762     return;
02763   }
02764 
02765   // Pattern: (fabs:f64 F8RC:f64:$frB)
02766   // Emits: (FABSD:f64 F8RC:f64:$frB)
02767   // Pattern complexity = 2  cost = 1
02768   if (N.Val->getValueType(0) == MVT::f64) {
02769     Select(Tmp0, N0);
02770     if (N.Val->hasOneUse()) {
02771       Result = CurDAG->SelectNodeTo(N.Val, PPC::FABSD, MVT::f64, Tmp0);
02772     } else {
02773       ResNode = CurDAG->getTargetNode(PPC::FABSD, MVT::f64, Tmp0);
02774       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02775       Result = SDOperand(ResNode, 0);
02776     }
02777     return;
02778   }
02779   std::cerr << "Cannot yet select: ";
02780   N.Val->dump(CurDAG);
02781   std::cerr << '\n';
02782   abort();
02783 }
02784 
02785 void Select_fadd(SDOperand &Result, SDOperand N) {
02786   SDOperand N0(0, 0);
02787   SDOperand N00(0, 0);
02788   SDOperand N01(0, 0);
02789   SDOperand N1(0, 0);
02790   SDOperand N10(0, 0);
02791   SDOperand N11(0, 0);
02792   SDOperand Tmp0(0, 0);
02793   SDOperand Tmp1(0, 0);
02794   SDOperand Tmp2(0, 0);
02795   SDNode *ResNode;
02796   if ((!NoExcessFPPrecision)) {
02797     N0 = N.getOperand(0);
02798     if (N0.getOpcode() == ISD::FMUL) {
02799       N00 = N0.getOperand(0);
02800       N01 = N0.getOperand(1);
02801       N1 = N.getOperand(1);
02802 
02803       // Pattern: (fadd:f64 (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRC), F8RC:f64:$FRB)
02804       // Emits: (FMADD:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB)
02805       // Pattern complexity = 4  cost = 1
02806       if (N.Val->getValueType(0) == MVT::f64) {
02807         Select(Tmp0, N00);
02808         Select(Tmp1, N01);
02809         Select(Tmp2, N1);
02810         if (N.Val->hasOneUse()) {
02811           Result = CurDAG->SelectNodeTo(N.Val, PPC::FMADD, MVT::f64, Tmp0, Tmp1, Tmp2);
02812         } else {
02813           ResNode = CurDAG->getTargetNode(PPC::FMADD, MVT::f64, Tmp0, Tmp1, Tmp2);
02814           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02815           Result = SDOperand(ResNode, 0);
02816         }
02817         return;
02818       }
02819 
02820       // Pattern: (fadd:f32 (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRC), F4RC:f32:$FRB)
02821       // Emits: (FMADDS:f32 F4RC:f32:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB)
02822       // Pattern complexity = 4  cost = 1
02823       if (N.Val->getValueType(0) == MVT::f32) {
02824         Select(Tmp0, N00);
02825         Select(Tmp1, N01);
02826         Select(Tmp2, N1);
02827         if (N.Val->hasOneUse()) {
02828           Result = CurDAG->SelectNodeTo(N.Val, PPC::FMADDS, MVT::f32, Tmp0, Tmp1, Tmp2);
02829         } else {
02830           ResNode = CurDAG->getTargetNode(PPC::FMADDS, MVT::f32, Tmp0, Tmp1, Tmp2);
02831           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02832           Result = SDOperand(ResNode, 0);
02833         }
02834         return;
02835       }
02836 
02837       // Pattern: (fadd:v4f32 (fmul:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vC), VRRC:v4f32:$vB)
02838       // Emits: (VMADDFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vC, VRRC:v4f32:$vB)
02839       // Pattern complexity = 4  cost = 1
02840       if (N.Val->getValueType(0) == MVT::v4f32) {
02841         Select(Tmp0, N00);
02842         Select(Tmp1, N01);
02843         Select(Tmp2, N1);
02844         if (N.Val->hasOneUse()) {
02845           Result = CurDAG->SelectNodeTo(N.Val, PPC::VMADDFP, MVT::v4f32, Tmp0, Tmp1, Tmp2);
02846         } else {
02847           ResNode = CurDAG->getTargetNode(PPC::VMADDFP, MVT::v4f32, Tmp0, Tmp1, Tmp2);
02848           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02849           Result = SDOperand(ResNode, 0);
02850         }
02851         return;
02852       }
02853     }
02854     N1 = N.getOperand(1);
02855     if (N1.getOpcode() == ISD::FMUL) {
02856       N10 = N1.getOperand(0);
02857       N11 = N1.getOperand(1);
02858 
02859       // Pattern: (fadd:f64 F8RC:f64:$FRB, (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRC))
02860       // Emits: (FMADD:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB)
02861       // Pattern complexity = 4  cost = 1
02862       if (N.Val->getValueType(0) == MVT::f64) {
02863         Select(Tmp0, N10);
02864         Select(Tmp1, N11);
02865         Select(Tmp2, N0);
02866         if (N.Val->hasOneUse()) {
02867           Result = CurDAG->SelectNodeTo(N.Val, PPC::FMADD, MVT::f64, Tmp0, Tmp1, Tmp2);
02868         } else {
02869           ResNode = CurDAG->getTargetNode(PPC::FMADD, MVT::f64, Tmp0, Tmp1, Tmp2);
02870           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02871           Result = SDOperand(ResNode, 0);
02872         }
02873         return;
02874       }
02875 
02876       // Pattern: (fadd:f32 F4RC:f32:$FRB, (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRC))
02877       // Emits: (FMADDS:f32 F4RC:f32:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB)
02878       // Pattern complexity = 4  cost = 1
02879       if (N.Val->getValueType(0) == MVT::f32) {
02880         Select(Tmp0, N10);
02881         Select(Tmp1, N11);
02882         Select(Tmp2, N0);
02883         if (N.Val->hasOneUse()) {
02884           Result = CurDAG->SelectNodeTo(N.Val, PPC::FMADDS, MVT::f32, Tmp0, Tmp1, Tmp2);
02885         } else {
02886           ResNode = CurDAG->getTargetNode(PPC::FMADDS, MVT::f32, Tmp0, Tmp1, Tmp2);
02887           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02888           Result = SDOperand(ResNode, 0);
02889         }
02890         return;
02891       }
02892 
02893       // Pattern: (fadd:v4f32 VRRC:v4f32:$vB, (fmul:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vC))
02894       // Emits: (VMADDFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vC, VRRC:v4f32:$vB)
02895       // Pattern complexity = 4  cost = 1
02896       if (N.Val->getValueType(0) == MVT::v4f32) {
02897         Select(Tmp0, N10);
02898         Select(Tmp1, N11);
02899         Select(Tmp2, N0);
02900         if (N.Val->hasOneUse()) {
02901           Result = CurDAG->SelectNodeTo(N.Val, PPC::VMADDFP, MVT::v4f32, Tmp0, Tmp1, Tmp2);
02902         } else {
02903           ResNode = CurDAG->getTargetNode(PPC::VMADDFP, MVT::v4f32, Tmp0, Tmp1, Tmp2);
02904           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02905           Result = SDOperand(ResNode, 0);
02906         }
02907         return;
02908       }
02909     }
02910   }
02911   N0 = N.getOperand(0);
02912   N1 = N.getOperand(1);
02913 
02914   // Pattern: (fadd:f64 F8RC:f64:$FRA, F8RC:f64:$FRB)
02915   // Emits: (FADD:f64 F8RC:f64:$FRA, F8RC:f64:$FRB)
02916   // Pattern complexity = 2  cost = 1
02917   if (N.Val->getValueType(0) == MVT::f64) {
02918     Select(Tmp0, N0);
02919     Select(Tmp1, N1);
02920     if (N.Val->hasOneUse()) {
02921       Result = CurDAG->SelectNodeTo(N.Val, PPC::FADD, MVT::f64, Tmp0, Tmp1);
02922     } else {
02923       ResNode = CurDAG->getTargetNode(PPC::FADD, MVT::f64, Tmp0, Tmp1);
02924       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02925       Result = SDOperand(ResNode, 0);
02926     }
02927     return;
02928   }
02929 
02930   // Pattern: (fadd:f32 F4RC:f32:$FRA, F4RC:f32:$FRB)
02931   // Emits: (FADDS:f32 F4RC:f32:$FRA, F4RC:f32:$FRB)
02932   // Pattern complexity = 2  cost = 1
02933   if (N.Val->getValueType(0) == MVT::f32) {
02934     Select(Tmp0, N0);
02935     Select(Tmp1, N1);
02936     if (N.Val->hasOneUse()) {
02937       Result = CurDAG->SelectNodeTo(N.Val, PPC::FADDS, MVT::f32, Tmp0, Tmp1);
02938     } else {
02939       ResNode = CurDAG->getTargetNode(PPC::FADDS, MVT::f32, Tmp0, Tmp1);
02940       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02941       Result = SDOperand(ResNode, 0);
02942     }
02943     return;
02944   }
02945 
02946   // Pattern: (fadd:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB)
02947   // Emits: (VADDFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB)
02948   // Pattern complexity = 2  cost = 1
02949   if (N.Val->getValueType(0) == MVT::v4f32) {
02950     Select(Tmp0, N0);
02951     Select(Tmp1, N1);
02952     if (N.Val->hasOneUse()) {
02953       Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDFP, MVT::v4f32, Tmp0, Tmp1);
02954     } else {
02955       ResNode = CurDAG->getTargetNode(PPC::VADDFP, MVT::v4f32, Tmp0, Tmp1);
02956       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02957       Result = SDOperand(ResNode, 0);
02958     }
02959     return;
02960   }
02961   std::cerr << "Cannot yet select: ";
02962   N.Val->dump(CurDAG);
02963   std::cerr << '\n';
02964   abort();
02965 }
02966 
02967 void Select_fdiv(SDOperand &Result, SDOperand N) {
02968   SDOperand N0(0, 0);
02969   SDOperand N1(0, 0);
02970   SDOperand Tmp0(0, 0);
02971   SDOperand Tmp1(0, 0);
02972   SDNode *ResNode;
02973   N0 = N.getOperand(0);
02974   N1 = N.getOperand(1);
02975 
02976   // Pattern: (fdiv:f64 F8RC:f64:$FRA, F8RC:f64:$FRB)
02977   // Emits: (FDIV:f64 F8RC:f64:$FRA, F8RC:f64:$FRB)
02978   // Pattern complexity = 2  cost = 1
02979   if (N.Val->getValueType(0) == MVT::f64) {
02980     Select(Tmp0, N0);
02981     Select(Tmp1, N1);
02982     if (N.Val->hasOneUse()) {
02983       Result = CurDAG->SelectNodeTo(N.Val, PPC::FDIV, MVT::f64, Tmp0, Tmp1);
02984     } else {
02985       ResNode = CurDAG->getTargetNode(PPC::FDIV, MVT::f64, Tmp0, Tmp1);
02986       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
02987       Result = SDOperand(ResNode, 0);
02988     }
02989     return;
02990   }
02991 
02992   // Pattern: (fdiv:f32 F4RC:f32:$FRA, F4RC:f32:$FRB)
02993   // Emits: (FDIVS:f32 F4RC:f32:$FRA, F4RC:f32:$FRB)
02994   // Pattern complexity = 2  cost = 1
02995   if (N.Val->getValueType(0) == MVT::f32) {
02996     Select(Tmp0, N0);
02997     Select(Tmp1, N1);
02998     if (N.Val->hasOneUse()) {
02999       Result = CurDAG->SelectNodeTo(N.Val, PPC::FDIVS, MVT::f32, Tmp0, Tmp1);
03000     } else {
03001       ResNode = CurDAG->getTargetNode(PPC::FDIVS, MVT::f32, Tmp0, Tmp1);
03002       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03003       Result = SDOperand(ResNode, 0);
03004     }
03005     return;
03006   }
03007   std::cerr << "Cannot yet select: ";
03008   N.Val->dump(CurDAG);
03009   std::cerr << '\n';
03010   abort();
03011 }
03012 
03013 void Select_fextend(SDOperand &Result, SDOperand N) {
03014   SDOperand N0(0, 0);
03015   SDOperand Tmp0(0, 0);
03016   SDNode *ResNode;
03017   N0 = N.getOperand(0);
03018   if (N.Val->getValueType(0) == MVT::f64 &&
03019       N0.Val->getValueType(0) == MVT::f32) {
03020     Select(Tmp0, N0);
03021     if (N.Val->hasOneUse()) {
03022       Result = CurDAG->SelectNodeTo(N.Val, PPC::FMRSD, MVT::f64, Tmp0);
03023     } else {
03024       ResNode = CurDAG->getTargetNode(PPC::FMRSD, MVT::f64, Tmp0);
03025       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03026       Result = SDOperand(ResNode, 0);
03027     }
03028     return;
03029   }
03030   std::cerr << "Cannot yet select: ";
03031   N.Val->dump(CurDAG);
03032   std::cerr << '\n';
03033   abort();
03034 }
03035 
03036 void Select_fmul(SDOperand &Result, SDOperand N) {
03037   SDOperand N0(0, 0);
03038   SDOperand N1(0, 0);
03039   SDOperand Tmp0(0, 0);
03040   SDOperand Tmp1(0, 0);
03041   SDOperand Tmp2(0, 0);
03042   SDNode *ResNode;
03043   N0 = N.getOperand(0);
03044   N1 = N.getOperand(1);
03045 
03046   // Pattern: (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRB)
03047   // Emits: (FMUL:f64 F8RC:f64:$FRA, F8RC:f64:$FRB)
03048   // Pattern complexity = 2  cost = 1
03049   if (N.Val->getValueType(0) == MVT::f64) {
03050     Select(Tmp0, N0);
03051     Select(Tmp1, N1);
03052     if (N.Val->hasOneUse()) {
03053       Result = CurDAG->SelectNodeTo(N.Val, PPC::FMUL, MVT::f64, Tmp0, Tmp1);
03054     } else {
03055       ResNode = CurDAG->getTargetNode(PPC::FMUL, MVT::f64, Tmp0, Tmp1);
03056       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03057       Result = SDOperand(ResNode, 0);
03058     }
03059     return;
03060   }
03061 
03062   // Pattern: (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRB)
03063   // Emits: (FMULS:f32 F4RC:f32:$FRA, F4RC:f32:$FRB)
03064   // Pattern complexity = 2  cost = 1
03065   if (N.Val->getValueType(0) == MVT::f32) {
03066     Select(Tmp0, N0);
03067     Select(Tmp1, N1);
03068     if (N.Val->hasOneUse()) {
03069       Result = CurDAG->SelectNodeTo(N.Val, PPC::FMULS, MVT::f32, Tmp0, Tmp1);
03070     } else {
03071       ResNode = CurDAG->getTargetNode(PPC::FMULS, MVT::f32, Tmp0, Tmp1);
03072       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03073       Result = SDOperand(ResNode, 0);
03074     }
03075     return;
03076   }
03077 
03078   // Pattern: (fmul:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB)
03079   // Emits: (VMADDFP:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (V_SET0:v4i32))
03080   // Pattern complexity = 2  cost = 2
03081   if (N.Val->getValueType(0) == MVT::v4f32) {
03082     Select(Tmp0, N0);
03083     Select(Tmp1, N1);
03084     Tmp2 = SDOperand(CurDAG->getTargetNode(PPC::V_SET0, MVT::v4i32), 0);
03085     if (N.Val->hasOneUse()) {
03086       Result = CurDAG->SelectNodeTo(N.Val, PPC::VMADDFP, MVT::v16i8, Tmp0, Tmp1, Tmp2);
03087     } else {
03088       ResNode = CurDAG->getTargetNode(PPC::VMADDFP, MVT::v16i8, Tmp0, Tmp1, Tmp2);
03089       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03090       Result = SDOperand(ResNode, 0);
03091     }
03092     return;
03093   }
03094   std::cerr << "Cannot yet select: ";
03095   N.Val->dump(CurDAG);
03096   std::cerr << '\n';
03097   abort();
03098 }
03099 
03100 void Select_fneg(SDOperand &Result, SDOperand N) {
03101   SDOperand N0(0, 0);
03102   SDOperand N00(0, 0);
03103   SDOperand N000(0, 0);
03104   SDOperand N001(0, 0);
03105   SDOperand N01(0, 0);
03106   SDOperand N010(0, 0);
03107   SDOperand N011(0, 0);
03108   SDOperand Tmp0(0, 0);
03109   SDOperand Tmp1(0, 0);
03110   SDOperand Tmp2(0, 0);
03111   SDNode *ResNode;
03112   if ((!NoExcessFPPrecision)) {
03113     N0 = N.getOperand(0);
03114     if (N0.getOpcode() == ISD::FADD) {
03115       N00 = N0.getOperand(0);
03116       if (N00.getOpcode() == ISD::FMUL) {
03117         N000 = N00.getOperand(0);
03118         N001 = N00.getOperand(1);
03119         N01 = N0.getOperand(1);
03120 
03121         // Pattern: (fneg:f64 (fadd:f64 (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRC), F8RC:f64:$FRB))
03122         // Emits: (FNMADD:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB)
03123         // Pattern complexity = 6  cost = 1
03124         if (N.Val->getValueType(0) == MVT::f64) {
03125           Select(Tmp0, N000);
03126           Select(Tmp1, N001);
03127           Select(Tmp2, N01);
03128           if (N.Val->hasOneUse()) {
03129             Result = CurDAG->SelectNodeTo(N.Val, PPC::FNMADD, MVT::f64, Tmp0, Tmp1, Tmp2);
03130           } else {
03131             ResNode = CurDAG->getTargetNode(PPC::FNMADD, MVT::f64, Tmp0, Tmp1, Tmp2);
03132             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03133             Result = SDOperand(ResNode, 0);
03134           }
03135           return;
03136         }
03137 
03138         // Pattern: (fneg:f32 (fadd:f32 (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRC), F4RC:f32:$FRB))
03139         // Emits: (FNMADDS:f32 F4RC:f32:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB)
03140         // Pattern complexity = 6  cost = 1
03141         if (N.Val->getValueType(0) == MVT::f32) {
03142           Select(Tmp0, N000);
03143           Select(Tmp1, N001);
03144           Select(Tmp2, N01);
03145           if (N.Val->hasOneUse()) {
03146             Result = CurDAG->SelectNodeTo(N.Val, PPC::FNMADDS, MVT::f32, Tmp0, Tmp1, Tmp2);
03147           } else {
03148             ResNode = CurDAG->getTargetNode(PPC::FNMADDS, MVT::f32, Tmp0, Tmp1, Tmp2);
03149             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03150             Result = SDOperand(ResNode, 0);
03151           }
03152           return;
03153         }
03154       }
03155     }
03156     if (N0.getOpcode() == ISD::FSUB) {
03157       N00 = N0.getOperand(0);
03158       if (N00.getOpcode() == ISD::FMUL) {
03159         N000 = N00.getOperand(0);
03160         N001 = N00.getOperand(1);
03161         N01 = N0.getOperand(1);
03162 
03163         // Pattern: (fneg:f64 (fsub:f64 (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRC), F8RC:f64:$FRB))
03164         // Emits: (FNMSUB:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB)
03165         // Pattern complexity = 6  cost = 1
03166         if (N.Val->getValueType(0) == MVT::f64) {
03167           Select(Tmp0, N000);
03168           Select(Tmp1, N001);
03169           Select(Tmp2, N01);
03170           if (N.Val->hasOneUse()) {
03171             Result = CurDAG->SelectNodeTo(N.Val, PPC::FNMSUB, MVT::f64, Tmp0, Tmp1, Tmp2);
03172           } else {
03173             ResNode = CurDAG->getTargetNode(PPC::FNMSUB, MVT::f64, Tmp0, Tmp1, Tmp2);
03174             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03175             Result = SDOperand(ResNode, 0);
03176           }
03177           return;
03178         }
03179 
03180         // Pattern: (fneg:f32 (fsub:f32 (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRC), F4RC:f32:$FRB))
03181         // Emits: (FNMSUBS:f32 F4RC:f32:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB)
03182         // Pattern complexity = 6  cost = 1
03183         if (N.Val->getValueType(0) == MVT::f32) {
03184           Select(Tmp0, N000);
03185           Select(Tmp1, N001);
03186           Select(Tmp2, N01);
03187           if (N.Val->hasOneUse()) {
03188             Result = CurDAG->SelectNodeTo(N.Val, PPC::FNMSUBS, MVT::f32, Tmp0, Tmp1, Tmp2);
03189           } else {
03190             ResNode = CurDAG->getTargetNode(PPC::FNMSUBS, MVT::f32, Tmp0, Tmp1, Tmp2);
03191             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03192             Result = SDOperand(ResNode, 0);
03193           }
03194           return;
03195         }
03196 
03197         // Pattern: (fneg:v4f32 (fsub:v4f32 (fmul:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vC), VRRC:v4f32:$vB))
03198         // Emits: (VNMSUBFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vC, VRRC:v4f32:$vB)
03199         // Pattern complexity = 6  cost = 1
03200         if (N.Val->getValueType(0) == MVT::v4f32) {
03201           Select(Tmp0, N000);
03202           Select(Tmp1, N001);
03203           Select(Tmp2, N01);
03204           if (N.Val->hasOneUse()) {
03205             Result = CurDAG->SelectNodeTo(N.Val, PPC::VNMSUBFP, MVT::v4f32, Tmp0, Tmp1, Tmp2);
03206           } else {
03207             ResNode = CurDAG->getTargetNode(PPC::VNMSUBFP, MVT::v4f32, Tmp0, Tmp1, Tmp2);
03208             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03209             Result = SDOperand(ResNode, 0);
03210           }
03211           return;
03212         }
03213       }
03214     }
03215     if (N0.getOpcode() == ISD::FADD) {
03216       N00 = N0.getOperand(0);
03217       N01 = N0.getOperand(1);
03218       if (N01.getOpcode() == ISD::FMUL) {
03219         N010 = N01.getOperand(0);
03220         N011 = N01.getOperand(1);
03221 
03222         // Pattern: (fneg:f64 (fadd:f64 F8RC:f64:$FRB, (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRC)))
03223         // Emits: (FNMADD:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB)
03224         // Pattern complexity = 6  cost = 1
03225         if (N.Val->getValueType(0) == MVT::f64) {
03226           Select(Tmp0, N010);
03227           Select(Tmp1, N011);
03228           Select(Tmp2, N00);
03229           if (N.Val->hasOneUse()) {
03230             Result = CurDAG->SelectNodeTo(N.Val, PPC::FNMADD, MVT::f64, Tmp0, Tmp1, Tmp2);
03231           } else {
03232             ResNode = CurDAG->getTargetNode(PPC::FNMADD, MVT::f64, Tmp0, Tmp1, Tmp2);
03233             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03234             Result = SDOperand(ResNode, 0);
03235           }
03236           return;
03237         }
03238 
03239         // Pattern: (fneg:f32 (fadd:f32 F4RC:f32:$FRB, (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRC)))
03240         // Emits: (FNMADDS:f32 F4RC:f32:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB)
03241         // Pattern complexity = 6  cost = 1
03242         if (N.Val->getValueType(0) == MVT::f32) {
03243           Select(Tmp0, N010);
03244           Select(Tmp1, N011);
03245           Select(Tmp2, N00);
03246           if (N.Val->hasOneUse()) {
03247             Result = CurDAG->SelectNodeTo(N.Val, PPC::FNMADDS, MVT::f32, Tmp0, Tmp1, Tmp2);
03248           } else {
03249             ResNode = CurDAG->getTargetNode(PPC::FNMADDS, MVT::f32, Tmp0, Tmp1, Tmp2);
03250             SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03251             Result = SDOperand(ResNode, 0);
03252           }
03253           return;
03254         }
03255       }
03256     }
03257   }
03258   N0 = N.getOperand(0);
03259   if (N0.getOpcode() == ISD::FABS) {
03260     N00 = N0.getOperand(0);
03261 
03262     // Pattern: (fneg:f32 (fabs:f32 F4RC:f32:$frB))
03263     // Emits: (FNABSS:f32 F4RC:f32:$frB)
03264     // Pattern complexity = 4  cost = 1
03265     if (N.Val->getValueType(0) == MVT::f32) {
03266       Select(Tmp0, N00);
03267       if (N.Val->hasOneUse()) {
03268         Result = CurDAG->SelectNodeTo(N.Val, PPC::FNABSS, MVT::f32, Tmp0);
03269       } else {
03270         ResNode = CurDAG->getTargetNode(PPC::FNABSS, MVT::f32, Tmp0);
03271         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03272         Result = SDOperand(ResNode, 0);
03273       }
03274       return;
03275     }
03276 
03277     // Pattern: (fneg:f64 (fabs:f64 F8RC:f64:$frB))
03278     // Emits: (FNABSD:f64 F8RC:f64:$frB)
03279     // Pattern complexity = 4  cost = 1
03280     if (N.Val->getValueType(0) == MVT::f64) {
03281       Select(Tmp0, N00);
03282       if (N.Val->hasOneUse()) {
03283         Result = CurDAG->SelectNodeTo(N.Val, PPC::FNABSD, MVT::f64, Tmp0);
03284       } else {
03285         ResNode = CurDAG->getTargetNode(PPC::FNABSD, MVT::f64, Tmp0);
03286         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03287         Result = SDOperand(ResNode, 0);
03288       }
03289       return;
03290     }
03291   }
03292 
03293   // Pattern: (fneg:f32 F4RC:f32:$frB)
03294   // Emits: (FNEGS:f32 F4RC:f32:$frB)
03295   // Pattern complexity = 2  cost = 1
03296   if (N.Val->getValueType(0) == MVT::f32) {
03297     Select(Tmp0, N0);
03298     if (N.Val->hasOneUse()) {
03299       Result = CurDAG->SelectNodeTo(N.Val, PPC::FNEGS, MVT::f32, Tmp0);
03300     } else {
03301       ResNode = CurDAG->getTargetNode(PPC::FNEGS, MVT::f32, Tmp0);
03302       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03303       Result = SDOperand(ResNode, 0);
03304     }
03305     return;
03306   }
03307 
03308   // Pattern: (fneg:f64 F8RC:f64:$frB)
03309   // Emits: (FNEGD:f64 F8RC:f64:$frB)
03310   // Pattern complexity = 2  cost = 1
03311   if (N.Val->getValueType(0) == MVT::f64) {
03312     Select(Tmp0, N0);
03313     if (N.Val->hasOneUse()) {
03314       Result = CurDAG->SelectNodeTo(N.Val, PPC::FNEGD, MVT::f64, Tmp0);
03315     } else {
03316       ResNode = CurDAG->getTargetNode(PPC::FNEGD, MVT::f64, Tmp0);
03317       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03318       Result = SDOperand(ResNode, 0);
03319     }
03320     return;
03321   }
03322   std::cerr << "Cannot yet select: ";
03323   N.Val->dump(CurDAG);
03324   std::cerr << '\n';
03325   abort();
03326 }
03327 
03328 void Select_fround(SDOperand &Result, SDOperand N) {
03329   SDOperand N0(0, 0);
03330   SDOperand Tmp0(0, 0);
03331   SDNode *ResNode;
03332   N0 = N.getOperand(0);
03333   if (N.Val->getValueType(0) == MVT::f32 &&
03334       N0.Val->getValueType(0) == MVT::f64) {
03335     Select(Tmp0, N0);
03336     if (N.Val->hasOneUse()) {
03337       Result = CurDAG->SelectNodeTo(N.Val, PPC::FRSP, MVT::f32, Tmp0);
03338     } else {
03339       ResNode = CurDAG->getTargetNode(PPC::FRSP, MVT::f32, Tmp0);
03340       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03341       Result = SDOperand(ResNode, 0);
03342     }
03343     return;
03344   }
03345   std::cerr << "Cannot yet select: ";
03346   N.Val->dump(CurDAG);
03347   std::cerr << '\n';
03348   abort();
03349 }
03350 
03351 void Select_fsqrt(SDOperand &Result, SDOperand N) {
03352   SDOperand N0(0, 0);
03353   SDOperand Tmp0(0, 0);
03354   SDNode *ResNode;
03355   N0 = N.getOperand(0);
03356 
03357   // Pattern: (fsqrt:f64 F8RC:f64:$frB)
03358   // Emits: (FSQRT:f64 F8RC:f64:$frB)
03359   // Pattern complexity = 2  cost = 1
03360   if (N.Val->getValueType(0) == MVT::f64) {
03361     Select(Tmp0, N0);
03362     if (N.Val->hasOneUse()) {
03363       Result = CurDAG->SelectNodeTo(N.Val, PPC::FSQRT, MVT::f64, Tmp0);
03364     } else {
03365       ResNode = CurDAG->getTargetNode(PPC::FSQRT, MVT::f64, Tmp0);
03366       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03367       Result = SDOperand(ResNode, 0);
03368     }
03369     return;
03370   }
03371 
03372   // Pattern: (fsqrt:f32 F4RC:f32:$frB)
03373   // Emits: (FSQRTS:f32 F4RC:f32:$frB)
03374   // Pattern complexity = 2  cost = 1
03375   if (N.Val->getValueType(0) == MVT::f32) {
03376     Select(Tmp0, N0);
03377     if (N.Val->hasOneUse()) {
03378       Result = CurDAG->SelectNodeTo(N.Val, PPC::FSQRTS, MVT::f32, Tmp0);
03379     } else {
03380       ResNode = CurDAG->getTargetNode(PPC::FSQRTS, MVT::f32, Tmp0);
03381       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03382       Result = SDOperand(ResNode, 0);
03383     }
03384     return;
03385   }
03386   std::cerr << "Cannot yet select: ";
03387   N.Val->dump(CurDAG);
03388   std::cerr << '\n';
03389   abort();
03390 }
03391 
03392 void Select_fsub(SDOperand &Result, SDOperand N) {
03393   SDOperand N0(0, 0);
03394   SDOperand N00(0, 0);
03395   SDOperand N01(0, 0);
03396   SDOperand N1(0, 0);
03397   SDOperand N10(0, 0);
03398   SDOperand N11(0, 0);
03399   SDOperand Tmp0(0, 0);
03400   SDOperand Tmp1(0, 0);
03401   SDOperand Tmp2(0, 0);
03402   SDNode *ResNode;
03403   if ((!NoExcessFPPrecision)) {
03404     N0 = N.getOperand(0);
03405     if (N0.getOpcode() == ISD::FMUL) {
03406       N00 = N0.getOperand(0);
03407       N01 = N0.getOperand(1);
03408       N1 = N.getOperand(1);
03409 
03410       // Pattern: (fsub:f64 (fmul:f64 F8RC:f64:$FRA, F8RC:f64:$FRC), F8RC:f64:$FRB)
03411       // Emits: (FMSUB:f64 F8RC:f64:$FRA, F8RC:f64:$FRC, F8RC:f64:$FRB)
03412       // Pattern complexity = 4  cost = 1
03413       if (N.Val->getValueType(0) == MVT::f64) {
03414         Select(Tmp0, N00);
03415         Select(Tmp1, N01);
03416         Select(Tmp2, N1);
03417         if (N.Val->hasOneUse()) {
03418           Result = CurDAG->SelectNodeTo(N.Val, PPC::FMSUB, MVT::f64, Tmp0, Tmp1, Tmp2);
03419         } else {
03420           ResNode = CurDAG->getTargetNode(PPC::FMSUB, MVT::f64, Tmp0, Tmp1, Tmp2);
03421           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03422           Result = SDOperand(ResNode, 0);
03423         }
03424         return;
03425       }
03426 
03427       // Pattern: (fsub:f32 (fmul:f32 F4RC:f32:$FRA, F4RC:f32:$FRC), F4RC:f32:$FRB)
03428       // Emits: (FMSUBS:f32 F4RC:f32:$FRA, F4RC:f32:$FRC, F4RC:f32:$FRB)
03429       // Pattern complexity = 4  cost = 1
03430       if (N.Val->getValueType(0) == MVT::f32) {
03431         Select(Tmp0, N00);
03432         Select(Tmp1, N01);
03433         Select(Tmp2, N1);
03434         if (N.Val->hasOneUse()) {
03435           Result = CurDAG->SelectNodeTo(N.Val, PPC::FMSUBS, MVT::f32, Tmp0, Tmp1, Tmp2);
03436         } else {
03437           ResNode = CurDAG->getTargetNode(PPC::FMSUBS, MVT::f32, Tmp0, Tmp1, Tmp2);
03438           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03439           Result = SDOperand(ResNode, 0);
03440         }
03441         return;
03442       }
03443     }
03444     N1 = N.getOperand(1);
03445     if (N1.getOpcode() == ISD::FMUL) {
03446       N10 = N1.getOperand(0);
03447       N11 = N1.getOperand(1);
03448 
03449       // Pattern: (fsub:f64 F8RC:f64:$B, (fmul:f64 F8RC:f64:$A, F8RC:f64:$C))
03450       // Emits: (FNMSUB:f64 F8RC:f64:$A, F8RC:f64:$C, F8RC:f64:$B)
03451       // Pattern complexity = 4  cost = 1
03452       if (N.Val->getValueType(0) == MVT::f64) {
03453         Select(Tmp0, N10);
03454         Select(Tmp1, N11);
03455         Select(Tmp2, N0);
03456         if (N.Val->hasOneUse()) {
03457           Result = CurDAG->SelectNodeTo(N.Val, PPC::FNMSUB, MVT::f64, Tmp0, Tmp1, Tmp2);
03458         } else {
03459           ResNode = CurDAG->getTargetNode(PPC::FNMSUB, MVT::f64, Tmp0, Tmp1, Tmp2);
03460           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03461           Result = SDOperand(ResNode, 0);
03462         }
03463         return;
03464       }
03465 
03466       // Pattern: (fsub:f32 F4RC:f32:$B, (fmul:f32 F4RC:f32:$A, F4RC:f32:$C))
03467       // Emits: (FNMSUBS:f32 F4RC:f32:$A, F4RC:f32:$C, F4RC:f32:$B)
03468       // Pattern complexity = 4  cost = 1
03469       if (N.Val->getValueType(0) == MVT::f32) {
03470         Select(Tmp0, N10);
03471         Select(Tmp1, N11);
03472         Select(Tmp2, N0);
03473         if (N.Val->hasOneUse()) {
03474           Result = CurDAG->SelectNodeTo(N.Val, PPC::FNMSUBS, MVT::f32, Tmp0, Tmp1, Tmp2);
03475         } else {
03476           ResNode = CurDAG->getTargetNode(PPC::FNMSUBS, MVT::f32, Tmp0, Tmp1, Tmp2);
03477           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03478           Result = SDOperand(ResNode, 0);
03479         }
03480         return;
03481       }
03482     }
03483   }
03484   N0 = N.getOperand(0);
03485   N1 = N.getOperand(1);
03486 
03487   // Pattern: (fsub:f64 F8RC:f64:$FRA, F8RC:f64:$FRB)
03488   // Emits: (FSUB:f64 F8RC:f64:$FRA, F8RC:f64:$FRB)
03489   // Pattern complexity = 2  cost = 1
03490   if (N.Val->getValueType(0) == MVT::f64) {
03491     Select(Tmp0, N0);
03492     Select(Tmp1, N1);
03493     if (N.Val->hasOneUse()) {
03494       Result = CurDAG->SelectNodeTo(N.Val, PPC::FSUB, MVT::f64, Tmp0, Tmp1);
03495     } else {
03496       ResNode = CurDAG->getTargetNode(PPC::FSUB, MVT::f64, Tmp0, Tmp1);
03497       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03498       Result = SDOperand(ResNode, 0);
03499     }
03500     return;
03501   }
03502 
03503   // Pattern: (fsub:f32 F4RC:f32:$FRA, F4RC:f32:$FRB)
03504   // Emits: (FSUBS:f32 F4RC:f32:$FRA, F4RC:f32:$FRB)
03505   // Pattern complexity = 2  cost = 1
03506   if (N.Val->getValueType(0) == MVT::f32) {
03507     Select(Tmp0, N0);
03508     Select(Tmp1, N1);
03509     if (N.Val->hasOneUse()) {
03510       Result = CurDAG->SelectNodeTo(N.Val, PPC::FSUBS, MVT::f32, Tmp0, Tmp1);
03511     } else {
03512       ResNode = CurDAG->getTargetNode(PPC::FSUBS, MVT::f32, Tmp0, Tmp1);
03513       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03514       Result = SDOperand(ResNode, 0);
03515     }
03516     return;
03517   }
03518 
03519   // Pattern: (fsub:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB)
03520   // Emits: (VSUBFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB)
03521   // Pattern complexity = 2  cost = 1
03522   if (N.Val->getValueType(0) == MVT::v4f32) {
03523     Select(Tmp0, N0);
03524     Select(Tmp1, N1);
03525     if (N.Val->hasOneUse()) {
03526       Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBFP, MVT::v4f32, Tmp0, Tmp1);
03527     } else {
03528       ResNode = CurDAG->getTargetNode(PPC::VSUBFP, MVT::v4f32, Tmp0, Tmp1);
03529       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03530       Result = SDOperand(ResNode, 0);
03531     }
03532     return;
03533   }
03534   std::cerr << "Cannot yet select: ";
03535   N.Val->dump(CurDAG);
03536   std::cerr << '\n';
03537   abort();
03538 }
03539 
03540 void Select_imm(SDOperand &Result, SDOperand N) {
03541   SDOperand Tmp0(0, 0);
03542   SDOperand Tmp1(0, 0);
03543   SDOperand Tmp2(0, 0);
03544   SDOperand Tmp3(0, 0);
03545   SDNode *ResNode;
03546 
03547   // Pattern: (imm:i32)<<P:Predicate_immSExt16>>:$imm
03548   // Emits: (LI:i32 (imm:i32):$imm)
03549   // Pattern complexity = 3  cost = 1
03550   if (Predicate_immSExt16(N.Val) &&
03551       N.Val->getValueType(0) == MVT::i32) {
03552     unsigned Tmp0C = (unsigned)cast<ConstantSDNode>(N)->getValue();
03553     Tmp0 = CurDAG->getTargetConstant(Tmp0C, MVT::i32);
03554     if (N.Val->hasOneUse()) {
03555       Result = CurDAG->SelectNodeTo(N.Val, PPC::LI, MVT::i32, Tmp0);
03556     } else {
03557       ResNode = CurDAG->getTargetNode(PPC::LI, MVT::i32, Tmp0);
03558       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03559       Result = SDOperand(ResNode, 0);
03560     }
03561     return;
03562   }
03563 
03564   // Pattern: (imm:i32)<<P:Predicate_imm16Shifted>><<X:HI16>>:$imm
03565   // Emits: (LIS:i32 (HI16:i32 (imm:i32):$imm))
03566   // Pattern complexity = 3  cost = 1
03567   if (Predicate_imm16Shifted(N.Val) &&
03568       N.Val->getValueType(0) == MVT::i32) {
03569     unsigned Tmp0C = (unsigned)cast<ConstantSDNode>(N)->getValue();
03570     Tmp0 = CurDAG->getTargetConstant(Tmp0C, MVT::i32);
03571     Tmp1 = Transform_HI16(Tmp0.Val);
03572     if (N.Val->hasOneUse()) {
03573       Result = CurDAG->SelectNodeTo(N.Val, PPC::LIS, MVT::i32, Tmp1);
03574     } else {
03575       ResNode = CurDAG->getTargetNode(PPC::LIS, MVT::i32, Tmp1);
03576       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03577       Result = SDOperand(ResNode, 0);
03578     }
03579     return;
03580   }
03581 
03582   // Pattern: (imm:i32):$imm
03583   // Emits: (ORI:i32 (LIS:i32 (HI16:i32 (imm:i32):$imm)), (LO16:i32 (imm:i32):$imm))
03584   // Pattern complexity = 2  cost = 2
03585   if (N.Val->getValueType(0) == MVT::i32) {
03586     unsigned Tmp0C = (unsigned)cast<ConstantSDNode>(N)->getValue();
03587     Tmp0 = CurDAG->getTargetConstant(Tmp0C, MVT::i32);
03588     Tmp1 = Transform_HI16(Tmp0.Val);
03589     Tmp2 = SDOperand(CurDAG->getTargetNode(PPC::LIS, MVT::i32, Tmp1), 0);
03590     Tmp3 = Transform_LO16(Tmp0.Val);
03591     if (N.Val->hasOneUse()) {
03592       Result = CurDAG->SelectNodeTo(N.Val, PPC::ORI, MVT::i32, Tmp2, Tmp3);
03593     } else {
03594       ResNode = CurDAG->getTargetNode(PPC::ORI, MVT::i32, Tmp2, Tmp3);
03595       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
03596       Result = SDOperand(ResNode, 0);
03597     }
03598     return;
03599   }
03600   std::cerr << "Cannot yet select: ";
03601   N.Val->dump(CurDAG);
03602   std::cerr << '\n';
03603   abort();
03604 }
03605 
03606 void Select_intrinsic_void(SDOperand &Result, SDOperand N) {
03607   SDOperand Chain(0, 0);
03608   SDOperand N1(0, 0);
03609   SDOperand N2(0, 0);
03610   SDOperand N3(0, 0);
03611   SDOperand N4(0, 0);
03612   SDOperand Tmp1(0, 0);
03613   SDOperand Tmp2(0, 0);
03614   SDOperand Tmp3(0, 0);
03615   SDOperand Tmp4(0, 0);
03616   SDNode *ResNode;
03617   Chain = N.getOperand(0);
03618   N1 = N.getOperand(1);
03619   if (isa<ConstantSDNode>(N1)) {
03620     int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended();
03621 
03622     // Pattern: (intrinsic_void:void 50:i32, VRRC:v16i8:$rS, xoaddr:i32:$dst)
03623     // Emits: (STVEBX:void VRRC:v16i8:$rS, xoaddr:i32:$dst)
03624     // Pattern complexity = 11  cost = 1
03625     if (CN0 == 50) {
03626       N2 = N.getOperand(2);
03627       N3 = N.getOperand(3);
03628       if (SelectAddrIdxOnly(N3, Tmp1, Tmp2)) {
03629         Select(Tmp1, Tmp1);
03630         Select(Tmp2, Tmp2);
03631         Select(Tmp3, N2);
03632         Select(Chain, Chain);
03633         ResNode = CurDAG->getTargetNode(PPC::STVEBX, MVT::Other, Tmp3, Tmp1, Tmp2, Chain);
03634         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
03635         Result = SDOperand(ResNode, N.ResNo);
03636         return;
03637       }
03638     }
03639 
03640     // Pattern: (intrinsic_void:void 51:i32, VRRC:v8i16:$rS, xoaddr:i32:$dst)
03641     // Emits: (STVEHX:void VRRC:v8i16:$rS, xoaddr:i32:$dst)
03642     // Pattern complexity = 11  cost = 1
03643     if (CN0 == 51) {
03644       N2 = N.getOperand(2);
03645       N3 = N.getOperand(3);
03646       if (SelectAddrIdxOnly(N3, Tmp1, Tmp2)) {
03647         Select(Tmp1, Tmp1);
03648         Select(Tmp2, Tmp2);
03649         Select(Tmp3, N2);
03650         Select(Chain, Chain);
03651         ResNode = CurDAG->getTargetNode(PPC::STVEHX, MVT::Other, Tmp3, Tmp1, Tmp2, Chain);
03652         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
03653         Result = SDOperand(ResNode, N.ResNo);
03654         return;
03655       }
03656     }
03657 
03658     // Pattern: (intrinsic_void:void 52:i32, VRRC:v4i32:$rS, xoaddr:i32:$dst)
03659     // Emits: (STVEWX:void VRRC:v4i32:$rS, xoaddr:i32:$dst)
03660     // Pattern complexity = 11  cost = 1
03661     if (CN0 == 52) {
03662       N2 = N.getOperand(2);
03663       N3 = N.getOperand(3);
03664       if (SelectAddrIdxOnly(N3, Tmp1, Tmp2)) {
03665         Select(Tmp1, Tmp1);
03666         Select(Tmp2, Tmp2);
03667         Select(Tmp3, N2);
03668         Select(Chain, Chain);
03669         ResNode = CurDAG->getTargetNode(PPC::STVEWX, MVT::Other, Tmp3, Tmp1, Tmp2, Chain);
03670         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
03671         Result = SDOperand(ResNode, N.ResNo);
03672         return;
03673       }
03674     }
03675 
03676     // Pattern: (intrinsic_void:void 53:i32, VRRC:v4i32:$rS, xoaddr:i32:$dst)
03677     // Emits: (STVX:void VRRC:v4i32:$rS, xoaddr:i32:$dst)
03678     // Pattern complexity = 11  cost = 1
03679     if (CN0 == 53) {
03680       N2 = N.getOperand(2);
03681       N3 = N.getOperand(3);
03682       if (SelectAddrIdxOnly(N3, Tmp1, Tmp2)) {
03683         Select(Tmp1, Tmp1);
03684         Select(Tmp2, Tmp2);
03685         Select(Tmp3, N2);
03686         Select(Chain, Chain);
03687         ResNode = CurDAG->getTargetNode(PPC::STVX, MVT::Other, Tmp3, Tmp1, Tmp2, Chain);
03688         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
03689         Result = SDOperand(ResNode, N.ResNo);
03690         return;
03691       }
03692     }
03693 
03694     // Pattern: (intrinsic_void:void 54:i32, VRRC:v4i32:$rS, xoaddr:i32:$dst)
03695     // Emits: (STVXL:void VRRC:v4i32:$rS, xoaddr:i32:$dst)
03696     // Pattern complexity = 11  cost = 1
03697     if (CN0 == 54) {
03698       N2 = N.getOperand(2);
03699       N3 = N.getOperand(3);
03700       if (SelectAddrIdxOnly(N3, Tmp1, Tmp2)) {
03701         Select(Tmp1, Tmp1);
03702         Select(Tmp2, Tmp2);
03703         Select(Tmp3, N2);
03704         Select(Chain, Chain);
03705         ResNode = CurDAG->getTargetNode(PPC::STVXL, MVT::Other, Tmp3, Tmp1, Tmp2, Chain);
03706         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
03707         Result = SDOperand(ResNode, N.ResNo);
03708         return;
03709       }
03710     }
03711 
03712     // Pattern: (intrinsic_void:void 35:i32, (imm:i32):$STRM)
03713     // Emits: (DSS:void 0:i32, (imm:i32):$STRM, 0:i32, 0:i32)
03714     // Pattern complexity = 7  cost = 1
03715     if (CN0 == 35) {
03716       N2 = N.getOperand(2);
03717       if (N2.getOpcode() == ISD::Constant) {
03718         Tmp1 = CurDAG->getTargetConstant(0, MVT::i32);
03719         unsigned Tmp2C = (unsigned)cast<ConstantSDNode>(N2)->getValue();
03720         Tmp2 = CurDAG->getTargetConstant(Tmp2C, MVT::i32);
03721         Tmp3 = CurDAG->getTargetConstant(0, MVT::i32);
03722         Tmp4 = CurDAG->getTargetConstant(0, MVT::i32);
03723         Select(Chain, Chain);
03724         ResNode = CurDAG->getTargetNode(PPC::DSS, MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4, Chain);
03725         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
03726         Result = SDOperand(ResNode, N.ResNo);
03727         return;
03728       }
03729     }
03730 
03731     // Pattern: (intrinsic_void:void 37:i32, GPRC:i32:$rA, GPRC:i32:$rB, (imm:i32):$STRM)
03732     // Emits: (DST:void 0:i32, (imm:i32):$STRM, GPRC:i32:$rA, GPRC:i32:$rB)
03733     // Pattern complexity = 7  cost = 1
03734     if (CN0 == 37) {
03735       N2 = N.getOperand(2);
03736       N3 = N.getOperand(3);
03737       N4 = N.getOperand(4);
03738       if (N4.getOpcode() == ISD::Constant) {
03739         Tmp1 = CurDAG->getTargetConstant(0, MVT::i32);
03740         unsigned Tmp2C = (unsigned)cast<ConstantSDNode>(N4)->getValue();
03741         Tmp2 = CurDAG->getTargetConstant(Tmp2C, MVT::i32);
03742         Select(Tmp3, N2);
03743         Select(Tmp4, N3);
03744         Select(Chain, Chain);
03745         ResNode = CurDAG->getTargetNode(PPC::DST, MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4, Chain);
03746         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
03747         Result = SDOperand(ResNode, N.ResNo);
03748         return;
03749       }
03750     }
03751 
03752     // Pattern: (intrinsic_void:void 40:i32, GPRC:i32:$rA, GPRC:i32:$rB, (imm:i32):$STRM)
03753     // Emits: (DST:void 1:i32, (imm:i32):$STRM, GPRC:i32:$rA, GPRC:i32:$rB)
03754     // Pattern complexity = 7  cost = 1
03755     if (CN0 == 40) {
03756       N2 = N.getOperand(2);
03757       N3 = N.getOperand(3);
03758       N4 = N.getOperand(4);
03759       if (N4.getOpcode() == ISD::Constant) {
03760         Tmp1 = CurDAG->getTargetConstant(1, MVT::i32);
03761         unsigned Tmp2C = (unsigned)cast<ConstantSDNode>(N4)->getValue();
03762         Tmp2 = CurDAG->getTargetConstant(Tmp2C, MVT::i32);
03763         Select(Tmp3, N2);
03764         Select(Tmp4, N3);
03765         Select(Chain, Chain);
03766         ResNode = CurDAG->getTargetNode(PPC::DST, MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4, Chain);
03767         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
03768         Result = SDOperand(ResNode, N.ResNo);
03769         return;
03770       }
03771     }
03772 
03773     // Pattern: (intrinsic_void:void 38:i32, GPRC:i32:$rA, GPRC:i32:$rB, (imm:i32):$STRM)
03774     // Emits: (DSTST:void 0:i32, (imm:i32):$STRM, GPRC:i32:$rA, GPRC:i32:$rB)
03775     // Pattern complexity = 7  cost = 1
03776     if (CN0 == 38) {
03777       N2 = N.getOperand(2);
03778       N3 = N.getOperand(3);
03779       N4 = N.getOperand(4);
03780       if (N4.getOpcode() == ISD::Constant) {
03781         Tmp1 = CurDAG->getTargetConstant(0, MVT::i32);
03782         unsigned Tmp2C = (unsigned)cast<ConstantSDNode>(N4)->getValue();
03783         Tmp2 = CurDAG->getTargetConstant(Tmp2C, MVT::i32);
03784         Select(Tmp3, N2);
03785         Select(Tmp4, N3);
03786         Select(Chain, Chain);
03787         ResNode = CurDAG->getTargetNode(PPC::DSTST, MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4, Chain);
03788         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
03789         Result = SDOperand(ResNode, N.ResNo);
03790         return;
03791       }
03792     }
03793 
03794     // Pattern: (intrinsic_void:void 39:i32, GPRC:i32:$rA, GPRC:i32:$rB, (imm:i32):$STRM)
03795     // Emits: (DSTST:void 1:i32, (imm:i32):$STRM, GPRC:i32:$rA, GPRC:i32:$rB)
03796     // Pattern complexity = 7  cost = 1
03797     if (CN0 == 39) {
03798       N2 = N.getOperand(2);
03799       N3 = N.getOperand(3);
03800       N4 = N.getOperand(4);
03801       if (N4.getOpcode() == ISD::Constant) {
03802         Tmp1 = CurDAG->getTargetConstant(1, MVT::i32);
03803         unsigned Tmp2C = (unsigned)cast<ConstantSDNode>(N4)->getValue();
03804         Tmp2 = CurDAG->getTargetConstant(Tmp2C, MVT::i32);
03805         Select(Tmp3, N2);
03806         Select(Tmp4, N3);
03807         Select(Chain, Chain);
03808         ResNode = CurDAG->getTargetNode(PPC::DSTST, MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4, Chain);
03809         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
03810         Result = SDOperand(ResNode, N.ResNo);
03811         return;
03812       }
03813     }
03814 
03815     // Pattern: (intrinsic_void:void 49:i32, VRRC:v4i32:$vB)
03816     // Emits: (MTVSCR:void VRRC:v4i32:$vB)
03817     // Pattern complexity = 5  cost = 1
03818     if (CN0 == 49) {
03819       N2 = N.getOperand(2);
03820       Select(Tmp1, N2);
03821       Select(Chain, Chain);
03822       ResNode = CurDAG->getTargetNode(PPC::MTVSCR, MVT::Other, Tmp1, Chain);
03823       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
03824       Result = SDOperand(ResNode, N.ResNo);
03825       return;
03826     }
03827 
03828     // Pattern: (intrinsic_void:void 36:i32)
03829     // Emits: (DSS:void 1:i32, 0:i32, 0:i32, 0:i32)
03830     // Pattern complexity = 5  cost = 1
03831     if (CN0 == 36) {
03832       Tmp1 = CurDAG->getTargetConstant(1, MVT::i32);
03833       Tmp2 = CurDAG->getTargetConstant(0, MVT::i32);
03834       Tmp3 = CurDAG->getTargetConstant(0, MVT::i32);
03835       Tmp4 = CurDAG->getTargetConstant(0, MVT::i32);
03836       Select(Chain, Chain);
03837       ResNode = CurDAG->getTargetNode(PPC::DSS, MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4, Chain);
03838       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
03839       Result = SDOperand(ResNode, N.ResNo);
03840       return;
03841     }
03842   }
03843   std::cerr << "Cannot yet select: ";
03844   unsigned iid = cast<ConstantSDNode>(N.getOperand(N.getOperand(0).getValueType() == MVT::Other))->getValue();
03845   std::cerr << "intrinsic %"<< Intrinsic::getName((Intrinsic::ID)iid);
03846   std::cerr << '\n';
03847   abort();
03848 }
03849 
03850 void Select_intrinsic_w_chain(SDOperand &Result, SDOperand N) {
03851   if (N.ResNo == 1 && N.getValue(0).hasOneUse()) {
03852     SDOperand Dummy = CurDAG->getNode(ISD::HANDLENODE, MVT::Other, N);
03853     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Dummy.Val, 0);
03854     SelectionDAG::InsertISelMapEntry(HandleMap, N.Val, 1, Dummy.Val, 0);
03855     Result = Dummy;
03856     return;
03857   }
03858   SDOperand Chain(0, 0);
03859   SDOperand N1(0, 0);
03860   SDOperand N2(0, 0);
03861   SDOperand Tmp1(0, 0);
03862   SDOperand Tmp2(0, 0);
03863   SDNode *ResNode;
03864   Chain = N.getOperand(0);
03865   N1 = N.getOperand(1);
03866   if (isa<ConstantSDNode>(N1)) {
03867     int64_t CN0 = cast<ConstantSDNode>(N1)->getSignExtended();
03868 
03869     // Pattern: (intrinsic_w_chain:v16i8 41:i32, xoaddr:i32:$src)
03870     // Emits: (LVEBX:v16i8 xoaddr:i32:$src)
03871     // Pattern complexity = 11  cost = 1
03872     if (CN0 == 41) {
03873       N2 = N.getOperand(2);
03874       if (SelectAddrIdxOnly(N2, Tmp1, Tmp2)) {
03875         Select(Tmp1, Tmp1);
03876         Select(Tmp2, Tmp2);
03877         Select(Chain, Chain);
03878         ResNode = CurDAG->getTargetNode(PPC::LVEBX, MVT::v16i8, MVT::Other, Tmp1, Tmp2, Chain);
03879         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
03880         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
03881         if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
03882         Result = SDOperand(ResNode, N.ResNo);
03883         return;
03884       }
03885     }
03886 
03887     // Pattern: (intrinsic_w_chain:v8i16 42:i32, xoaddr:i32:$src)
03888     // Emits: (LVEHX:v8i16 xoaddr:i32:$src)
03889     // Pattern complexity = 11  cost = 1
03890     if (CN0 == 42) {
03891       N2 = N.getOperand(2);
03892       if (SelectAddrIdxOnly(N2, Tmp1, Tmp2)) {
03893         Select(Tmp1, Tmp1);
03894         Select(Tmp2, Tmp2);
03895         Select(Chain, Chain);
03896         ResNode = CurDAG->getTargetNode(PPC::LVEHX, MVT::v8i16, MVT::Other, Tmp1, Tmp2, Chain);
03897         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
03898         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
03899         if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
03900         Result = SDOperand(ResNode, N.ResNo);
03901         return;
03902       }
03903     }
03904 
03905     // Pattern: (intrinsic_w_chain:v4i32 43:i32, xoaddr:i32:$src)
03906     // Emits: (LVEWX:v4i32 xoaddr:i32:$src)
03907     // Pattern complexity = 11  cost = 1
03908     if (CN0 == 43) {
03909       N2 = N.getOperand(2);
03910       if (SelectAddrIdxOnly(N2, Tmp1, Tmp2)) {
03911         Select(Tmp1, Tmp1);
03912         Select(Tmp2, Tmp2);
03913         Select(Chain, Chain);
03914         ResNode = CurDAG->getTargetNode(PPC::LVEWX, MVT::v4i32, MVT::Other, Tmp1, Tmp2, Chain);
03915         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
03916         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
03917         if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
03918         Result = SDOperand(ResNode, N.ResNo);
03919         return;
03920       }
03921     }
03922 
03923     // Pattern: (intrinsic_w_chain:v4i32 46:i32, xoaddr:i32:$src)
03924     // Emits: (LVX:v4i32 xoaddr:i32:$src)
03925     // Pattern complexity = 11  cost = 1
03926     if (CN0 == 46) {
03927       N2 = N.getOperand(2);
03928       if (SelectAddrIdxOnly(N2, Tmp1, Tmp2)) {
03929         Select(Tmp1, Tmp1);
03930         Select(Tmp2, Tmp2);
03931         Select(Chain, Chain);
03932         ResNode = CurDAG->getTargetNode(PPC::LVX, MVT::v4i32, MVT::Other, Tmp1, Tmp2, Chain);
03933         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
03934         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
03935         if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
03936         Result = SDOperand(ResNode, N.ResNo);
03937         return;
03938       }
03939     }
03940 
03941     // Pattern: (intrinsic_w_chain:v4i32 47:i32, xoaddr:i32:$src)
03942     // Emits: (LVXL:v4i32 xoaddr:i32:$src)
03943     // Pattern complexity = 11  cost = 1
03944     if (CN0 == 47) {
03945       N2 = N.getOperand(2);
03946       if (SelectAddrIdxOnly(N2, Tmp1, Tmp2)) {
03947         Select(Tmp1, Tmp1);
03948         Select(Tmp2, Tmp2);
03949         Select(Chain, Chain);
03950         ResNode = CurDAG->getTargetNode(PPC::LVXL, MVT::v4i32, MVT::Other, Tmp1, Tmp2, Chain);
03951         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
03952         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
03953         if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
03954         Result = SDOperand(ResNode, N.ResNo);
03955         return;
03956       }
03957     }
03958 
03959     // Pattern: (intrinsic_w_chain:v8i16 48:i32)
03960     // Emits: (MFVSCR:v8i16)
03961     // Pattern complexity = 5  cost = 1
03962     if (CN0 == 48) {
03963       Select(Chain, Chain);
03964       ResNode = CurDAG->getTargetNode(PPC::MFVSCR, MVT::v8i16, MVT::Other, Chain);
03965       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
03966       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
03967       if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
03968       Result = SDOperand(ResNode, N.ResNo);
03969       return;
03970     }
03971   }
03972   std::cerr << "Cannot yet select: ";
03973   unsigned iid = cast<ConstantSDNode>(N.getOperand(N.getOperand(0).getValueType() == MVT::Other))->getValue();
03974   std::cerr << "intrinsic %"<< Intrinsic::getName((Intrinsic::ID)iid);
03975   std::cerr << '\n';
03976   abort();
03977 }
03978 
03979 void Select_intrinsic_wo_chain(SDOperand &Result, SDOperand N) {
03980   SDOperand N0(0, 0);
03981   SDOperand N1(0, 0);
03982   SDOperand N2(0, 0);
03983   SDOperand N3(0, 0);
03984   SDOperand Tmp1(0, 0);
03985   SDOperand Tmp2(0, 0);
03986   SDOperand Tmp3(0, 0);
03987   SDNode *ResNode;
03988   N0 = N.getOperand(0);
03989   if (isa<ConstantSDNode>(N0)) {
03990     int64_t CN0 = cast<ConstantSDNode>(N0)->getSignExtended();
03991 
03992     // Pattern: (intrinsic_wo_chain:v16i8 44:i32, xoaddr:i32:$src)
03993     // Emits: (LVSL:v16i8 xoaddr:i32:$src)
03994     // Pattern complexity = 11  cost = 1
03995     if (CN0 == 44) {
03996       N1 = N.getOperand(1);
03997       if (SelectAddrIdxOnly(N1, Tmp1, Tmp2)) {
03998         Select(Tmp1, Tmp1);
03999         Select(Tmp2, Tmp2);
04000         if (N.Val->hasOneUse()) {
04001           Result = CurDAG->SelectNodeTo(N.Val, PPC::LVSL, MVT::v16i8, Tmp1, Tmp2);
04002         } else {
04003           ResNode = CurDAG->getTargetNode(PPC::LVSL, MVT::v16i8, Tmp1, Tmp2);
04004           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04005           Result = SDOperand(ResNode, 0);
04006         }
04007         return;
04008       }
04009     }
04010 
04011     // Pattern: (intrinsic_wo_chain:v16i8 45:i32, xoaddr:i32:$src)
04012     // Emits: (LVSR:v16i8 xoaddr:i32:$src)
04013     // Pattern complexity = 11  cost = 1
04014     if (CN0 == 45) {
04015       N1 = N.getOperand(1);
04016       if (SelectAddrIdxOnly(N1, Tmp1, Tmp2)) {
04017         Select(Tmp1, Tmp1);
04018         Select(Tmp2, Tmp2);
04019         if (N.Val->hasOneUse()) {
04020           Result = CurDAG->SelectNodeTo(N.Val, PPC::LVSR, MVT::v16i8, Tmp1, Tmp2);
04021         } else {
04022           ResNode = CurDAG->getTargetNode(PPC::LVSR, MVT::v16i8, Tmp1, Tmp2);
04023           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04024           Result = SDOperand(ResNode, 0);
04025         }
04026         return;
04027       }
04028     }
04029 
04030     // Pattern: (intrinsic_wo_chain:v4f32 68:i32, VRRC:v4i32:$vB, (imm:i32):$UIMM)
04031     // Emits: (VCFSX:v4f32 (imm:i32):$UIMM, VRRC:v4i32:$vB)
04032     // Pattern complexity = 7  cost = 1
04033     if (CN0 == 68) {
04034       N1 = N.getOperand(1);
04035       N2 = N.getOperand(2);
04036       if (N2.getOpcode() == ISD::Constant) {
04037         unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N2)->getValue();
04038         Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
04039         Select(Tmp2, N1);
04040         if (N.Val->hasOneUse()) {
04041           Result = CurDAG->SelectNodeTo(N.Val, PPC::VCFSX, MVT::v4f32, Tmp1, Tmp2);
04042         } else {
04043           ResNode = CurDAG->getTargetNode(PPC::VCFSX, MVT::v4f32, Tmp1, Tmp2);
04044           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04045           Result = SDOperand(ResNode, 0);
04046         }
04047         return;
04048       }
04049     }
04050 
04051     // Pattern: (intrinsic_wo_chain:v4f32 69:i32, VRRC:v4i32:$vB, (imm:i32):$UIMM)
04052     // Emits: (VCFUX:v4f32 (imm:i32):$UIMM, VRRC:v4i32:$vB)
04053     // Pattern complexity = 7  cost = 1
04054     if (CN0 == 69) {
04055       N1 = N.getOperand(1);
04056       N2 = N.getOperand(2);
04057       if (N2.getOpcode() == ISD::Constant) {
04058         unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N2)->getValue();
04059         Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
04060         Select(Tmp2, N1);
04061         if (N.Val->hasOneUse()) {
04062           Result = CurDAG->SelectNodeTo(N.Val, PPC::VCFUX, MVT::v4f32, Tmp1, Tmp2);
04063         } else {
04064           ResNode = CurDAG->getTargetNode(PPC::VCFUX, MVT::v4f32, Tmp1, Tmp2);
04065           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04066           Result = SDOperand(ResNode, 0);
04067         }
04068         return;
04069       }
04070     }
04071 
04072     // Pattern: (intrinsic_wo_chain:v4i32 96:i32, VRRC:v4f32:$vB, (imm:i32):$UIMM)
04073     // Emits: (VCTSXS:v4i32 (imm:i32):$UIMM, VRRC:v4f32:$vB)
04074     // Pattern complexity = 7  cost = 1
04075     if (CN0 == 96) {
04076       N1 = N.getOperand(1);
04077       N2 = N.getOperand(2);
04078       if (N2.getOpcode() == ISD::Constant) {
04079         unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N2)->getValue();
04080         Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
04081         Select(Tmp2, N1);
04082         if (N.Val->hasOneUse()) {
04083           Result = CurDAG->SelectNodeTo(N.Val, PPC::VCTSXS, MVT::v4i32, Tmp1, Tmp2);
04084         } else {
04085           ResNode = CurDAG->getTargetNode(PPC::VCTSXS, MVT::v4i32, Tmp1, Tmp2);
04086           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04087           Result = SDOperand(ResNode, 0);
04088         }
04089         return;
04090       }
04091     }
04092 
04093     // Pattern: (intrinsic_wo_chain:v4i32 97:i32, VRRC:v4f32:$vB, (imm:i32):$UIMM)
04094     // Emits: (VCTUXS:v4i32 (imm:i32):$UIMM, VRRC:v4f32:$vB)
04095     // Pattern complexity = 7  cost = 1
04096     if (CN0 == 97) {
04097       N1 = N.getOperand(1);
04098       N2 = N.getOperand(2);
04099       if (N2.getOpcode() == ISD::Constant) {
04100         unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N2)->getValue();
04101         Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
04102         Select(Tmp2, N1);
04103         if (N.Val->hasOneUse()) {
04104           Result = CurDAG->SelectNodeTo(N.Val, PPC::VCTUXS, MVT::v4i32, Tmp1, Tmp2);
04105         } else {
04106           ResNode = CurDAG->getTargetNode(PPC::VCTUXS, MVT::v4i32, Tmp1, Tmp2);
04107           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04108           Result = SDOperand(ResNode, 0);
04109         }
04110         return;
04111       }
04112     }
04113 
04114     // Pattern: (intrinsic_wo_chain:v8i16 108:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v8i16:$vC)
04115     // Emits: (VMHADDSHS:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v8i16:$vC)
04116     // Pattern complexity = 5  cost = 1
04117     if (CN0 == 108) {
04118       N1 = N.getOperand(1);
04119       N2 = N.getOperand(2);
04120       N3 = N.getOperand(3);
04121       Select(Tmp1, N1);
04122       Select(Tmp2, N2);
04123       Select(Tmp3, N3);
04124       if (N.Val->hasOneUse()) {
04125         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMHADDSHS, MVT::v8i16, Tmp1, Tmp2, Tmp3);
04126       } else {
04127         ResNode = CurDAG->getTargetNode(PPC::VMHADDSHS, MVT::v8i16, Tmp1, Tmp2, Tmp3);
04128         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04129         Result = SDOperand(ResNode, 0);
04130       }
04131       return;
04132     }
04133 
04134     // Pattern: (intrinsic_wo_chain:v8i16 109:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v8i16:$vC)
04135     // Emits: (VMHRADDSHS:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v8i16:$vC)
04136     // Pattern complexity = 5  cost = 1
04137     if (CN0 == 109) {
04138       N1 = N.getOperand(1);
04139       N2 = N.getOperand(2);
04140       N3 = N.getOperand(3);
04141       Select(Tmp1, N1);
04142       Select(Tmp2, N2);
04143       Select(Tmp3, N3);
04144       if (N.Val->hasOneUse()) {
04145         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMHRADDSHS, MVT::v8i16, Tmp1, Tmp2, Tmp3);
04146       } else {
04147         ResNode = CurDAG->getTargetNode(PPC::VMHRADDSHS, MVT::v8i16, Tmp1, Tmp2, Tmp3);
04148         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04149         Result = SDOperand(ResNode, 0);
04150       }
04151       return;
04152     }
04153 
04154     // Pattern: (intrinsic_wo_chain:v8i16 117:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v8i16:$vC)
04155     // Emits: (VMLADDUHM:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v8i16:$vC)
04156     // Pattern complexity = 5  cost = 1
04157     if (CN0 == 117) {
04158       N1 = N.getOperand(1);
04159       N2 = N.getOperand(2);
04160       N3 = N.getOperand(3);
04161       Select(Tmp1, N1);
04162       Select(Tmp2, N2);
04163       Select(Tmp3, N3);
04164       if (N.Val->hasOneUse()) {
04165         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMLADDUHM, MVT::v8i16, Tmp1, Tmp2, Tmp3);
04166       } else {
04167         ResNode = CurDAG->getTargetNode(PPC::VMLADDUHM, MVT::v8i16, Tmp1, Tmp2, Tmp3);
04168         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04169         Result = SDOperand(ResNode, 0);
04170       }
04171       return;
04172     }
04173 
04174     // Pattern: (intrinsic_wo_chain:v4i32 133:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB, VRRC:v16i8:$vC)
04175     // Emits: (VPERM:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, VRRC:v16i8:$vC)
04176     // Pattern complexity = 5  cost = 1
04177     if (CN0 == 133) {
04178       N1 = N.getOperand(1);
04179       N2 = N.getOperand(2);
04180       N3 = N.getOperand(3);
04181       Select(Tmp1, N1);
04182       Select(Tmp2, N2);
04183       Select(Tmp3, N3);
04184       if (N.Val->hasOneUse()) {
04185         Result = CurDAG->SelectNodeTo(N.Val, PPC::VPERM, MVT::v4i32, Tmp1, Tmp2, Tmp3);
04186       } else {
04187         ResNode = CurDAG->getTargetNode(PPC::VPERM, MVT::v4i32, Tmp1, Tmp2, Tmp3);
04188         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04189         Result = SDOperand(ResNode, 0);
04190       }
04191       return;
04192     }
04193 
04194     // Pattern: (intrinsic_wo_chain:v4i32 150:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB, VRRC:v4i32:$vC)
04195     // Emits: (VSEL:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB, VRRC:v4i32:$vC)
04196     // Pattern complexity = 5  cost = 1
04197     if (CN0 == 150) {
04198       N1 = N.getOperand(1);
04199       N2 = N.getOperand(2);
04200       N3 = N.getOperand(3);
04201       Select(Tmp1, N1);
04202       Select(Tmp2, N2);
04203       Select(Tmp3, N3);
04204       if (N.Val->hasOneUse()) {
04205         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSEL, MVT::v4i32, Tmp1, Tmp2, Tmp3);
04206       } else {
04207         ResNode = CurDAG->getTargetNode(PPC::VSEL, MVT::v4i32, Tmp1, Tmp2, Tmp3);
04208         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04209         Result = SDOperand(ResNode, 0);
04210       }
04211       return;
04212     }
04213 
04214     // Pattern: (intrinsic_wo_chain:v4i32 55:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
04215     // Emits: (VADDCUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
04216     // Pattern complexity = 5  cost = 1
04217     if (CN0 == 55) {
04218       N1 = N.getOperand(1);
04219       N2 = N.getOperand(2);
04220       Select(Tmp1, N1);
04221       Select(Tmp2, N2);
04222       if (N.Val->hasOneUse()) {
04223         Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDCUW, MVT::v4i32, Tmp1, Tmp2);
04224       } else {
04225         ResNode = CurDAG->getTargetNode(PPC::VADDCUW, MVT::v4i32, Tmp1, Tmp2);
04226         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04227         Result = SDOperand(ResNode, 0);
04228       }
04229       return;
04230     }
04231 
04232     // Pattern: (intrinsic_wo_chain:v16i8 56:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04233     // Emits: (VADDSBS:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04234     // Pattern complexity = 5  cost = 1
04235     if (CN0 == 56) {
04236       N1 = N.getOperand(1);
04237       N2 = N.getOperand(2);
04238       Select(Tmp1, N1);
04239       Select(Tmp2, N2);
04240       if (N.Val->hasOneUse()) {
04241         Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDSBS, MVT::v16i8, Tmp1, Tmp2);
04242       } else {
04243         ResNode = CurDAG->getTargetNode(PPC::VADDSBS, MVT::v16i8, Tmp1, Tmp2);
04244         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04245         Result = SDOperand(ResNode, 0);
04246       }
04247       return;
04248     }
04249 
04250     // Pattern: (intrinsic_wo_chain:v8i16 57:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04251     // Emits: (VADDSHS:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04252     // Pattern complexity = 5  cost = 1
04253     if (CN0 == 57) {
04254       N1 = N.getOperand(1);
04255       N2 = N.getOperand(2);
04256       Select(Tmp1, N1);
04257       Select(Tmp2, N2);
04258       if (N.Val->hasOneUse()) {
04259         Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDSHS, MVT::v8i16, Tmp1, Tmp2);
04260       } else {
04261         ResNode = CurDAG->getTargetNode(PPC::VADDSHS, MVT::v8i16, Tmp1, Tmp2);
04262         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04263         Result = SDOperand(ResNode, 0);
04264       }
04265       return;
04266     }
04267 
04268     // Pattern: (intrinsic_wo_chain:v4i32 58:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
04269     // Emits: (VADDSWS:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
04270     // Pattern complexity = 5  cost = 1
04271     if (CN0 == 58) {
04272       N1 = N.getOperand(1);
04273       N2 = N.getOperand(2);
04274       Select(Tmp1, N1);
04275       Select(Tmp2, N2);
04276       if (N.Val->hasOneUse()) {
04277         Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDSWS, MVT::v4i32, Tmp1, Tmp2);
04278       } else {
04279         ResNode = CurDAG->getTargetNode(PPC::VADDSWS, MVT::v4i32, Tmp1, Tmp2);
04280         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04281         Result = SDOperand(ResNode, 0);
04282       }
04283       return;
04284     }
04285 
04286     // Pattern: (intrinsic_wo_chain:v16i8 59:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04287     // Emits: (VADDUBS:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04288     // Pattern complexity = 5  cost = 1
04289     if (CN0 == 59) {
04290       N1 = N.getOperand(1);
04291       N2 = N.getOperand(2);
04292       Select(Tmp1, N1);
04293       Select(Tmp2, N2);
04294       if (N.Val->hasOneUse()) {
04295         Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDUBS, MVT::v16i8, Tmp1, Tmp2);
04296       } else {
04297         ResNode = CurDAG->getTargetNode(PPC::VADDUBS, MVT::v16i8, Tmp1, Tmp2);
04298         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04299         Result = SDOperand(ResNode, 0);
04300       }
04301       return;
04302     }
04303 
04304     // Pattern: (intrinsic_wo_chain:v8i16 60:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04305     // Emits: (VADDUHS:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04306     // Pattern complexity = 5  cost = 1
04307     if (CN0 == 60) {
04308       N1 = N.getOperand(1);
04309       N2 = N.getOperand(2);
04310       Select(Tmp1, N1);
04311       Select(Tmp2, N2);
04312       if (N.Val->hasOneUse()) {
04313         Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDUHS, MVT::v8i16, Tmp1, Tmp2);
04314       } else {
04315         ResNode = CurDAG->getTargetNode(PPC::VADDUHS, MVT::v8i16, Tmp1, Tmp2);
04316         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04317         Result = SDOperand(ResNode, 0);
04318       }
04319       return;
04320     }
04321 
04322     // Pattern: (intrinsic_wo_chain:v4i32 61:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
04323     // Emits: (VADDUWS:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
04324     // Pattern complexity = 5  cost = 1
04325     if (CN0 == 61) {
04326       N1 = N.getOperand(1);
04327       N2 = N.getOperand(2);
04328       Select(Tmp1, N1);
04329       Select(Tmp2, N2);
04330       if (N.Val->hasOneUse()) {
04331         Result = CurDAG->SelectNodeTo(N.Val, PPC::VADDUWS, MVT::v4i32, Tmp1, Tmp2);
04332       } else {
04333         ResNode = CurDAG->getTargetNode(PPC::VADDUWS, MVT::v4i32, Tmp1, Tmp2);
04334         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04335         Result = SDOperand(ResNode, 0);
04336       }
04337       return;
04338     }
04339 
04340     // Pattern: (intrinsic_wo_chain:v4f32 98:i32, VRRC:v4f32:$vB)
04341     // Emits: (VEXPTEFP:v4f32 VRRC:v4f32:$vB)
04342     // Pattern complexity = 5  cost = 1
04343     if (CN0 == 98) {
04344       N1 = N.getOperand(1);
04345       Select(Tmp1, N1);
04346       if (N.Val->hasOneUse()) {
04347         Result = CurDAG->SelectNodeTo(N.Val, PPC::VEXPTEFP, MVT::v4f32, Tmp1);
04348       } else {
04349         ResNode = CurDAG->getTargetNode(PPC::VEXPTEFP, MVT::v4f32, Tmp1);
04350         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04351         Result = SDOperand(ResNode, 0);
04352       }
04353       return;
04354     }
04355 
04356     // Pattern: (intrinsic_wo_chain:v4f32 99:i32, VRRC:v4f32:$vB)
04357     // Emits: (VLOGEFP:v4f32 VRRC:v4f32:$vB)
04358     // Pattern complexity = 5  cost = 1
04359     if (CN0 == 99) {
04360       N1 = N.getOperand(1);
04361       Select(Tmp1, N1);
04362       if (N.Val->hasOneUse()) {
04363         Result = CurDAG->SelectNodeTo(N.Val, PPC::VLOGEFP, MVT::v4f32, Tmp1);
04364       } else {
04365         ResNode = CurDAG->getTargetNode(PPC::VLOGEFP, MVT::v4f32, Tmp1);
04366         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04367         Result = SDOperand(ResNode, 0);
04368       }
04369       return;
04370     }
04371 
04372     // Pattern: (intrinsic_wo_chain:v16i8 62:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04373     // Emits: (VAVGSB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04374     // Pattern complexity = 5  cost = 1
04375     if (CN0 == 62) {
04376       N1 = N.getOperand(1);
04377       N2 = N.getOperand(2);
04378       Select(Tmp1, N1);
04379       Select(Tmp2, N2);
04380       if (N.Val->hasOneUse()) {
04381         Result = CurDAG->SelectNodeTo(N.Val, PPC::VAVGSB, MVT::v16i8, Tmp1, Tmp2);
04382       } else {
04383         ResNode = CurDAG->getTargetNode(PPC::VAVGSB, MVT::v16i8, Tmp1, Tmp2);
04384         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04385         Result = SDOperand(ResNode, 0);
04386       }
04387       return;
04388     }
04389 
04390     // Pattern: (intrinsic_wo_chain:v8i16 63:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04391     // Emits: (VAVGSH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04392     // Pattern complexity = 5  cost = 1
04393     if (CN0 == 63) {
04394       N1 = N.getOperand(1);
04395       N2 = N.getOperand(2);
04396       Select(Tmp1, N1);
04397       Select(Tmp2, N2);
04398       if (N.Val->hasOneUse()) {
04399         Result = CurDAG->SelectNodeTo(N.Val, PPC::VAVGSH, MVT::v8i16, Tmp1, Tmp2);
04400       } else {
04401         ResNode = CurDAG->getTargetNode(PPC::VAVGSH, MVT::v8i16, Tmp1, Tmp2);
04402         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04403         Result = SDOperand(ResNode, 0);
04404       }
04405       return;
04406     }
04407 
04408     // Pattern: (intrinsic_wo_chain:v4i32 64:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
04409     // Emits: (VAVGSW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
04410     // Pattern complexity = 5  cost = 1
04411     if (CN0 == 64) {
04412       N1 = N.getOperand(1);
04413       N2 = N.getOperand(2);
04414       Select(Tmp1, N1);
04415       Select(Tmp2, N2);
04416       if (N.Val->hasOneUse()) {
04417         Result = CurDAG->SelectNodeTo(N.Val, PPC::VAVGSW, MVT::v4i32, Tmp1, Tmp2);
04418       } else {
04419         ResNode = CurDAG->getTargetNode(PPC::VAVGSW, MVT::v4i32, Tmp1, Tmp2);
04420         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04421         Result = SDOperand(ResNode, 0);
04422       }
04423       return;
04424     }
04425 
04426     // Pattern: (intrinsic_wo_chain:v16i8 65:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04427     // Emits: (VAVGUB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04428     // Pattern complexity = 5  cost = 1
04429     if (CN0 == 65) {
04430       N1 = N.getOperand(1);
04431       N2 = N.getOperand(2);
04432       Select(Tmp1, N1);
04433       Select(Tmp2, N2);
04434       if (N.Val->hasOneUse()) {
04435         Result = CurDAG->SelectNodeTo(N.Val, PPC::VAVGUB, MVT::v16i8, Tmp1, Tmp2);
04436       } else {
04437         ResNode = CurDAG->getTargetNode(PPC::VAVGUB, MVT::v16i8, Tmp1, Tmp2);
04438         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04439         Result = SDOperand(ResNode, 0);
04440       }
04441       return;
04442     }
04443 
04444     // Pattern: (intrinsic_wo_chain:v8i16 66:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04445     // Emits: (VAVGUH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04446     // Pattern complexity = 5  cost = 1
04447     if (CN0 == 66) {
04448       N1 = N.getOperand(1);
04449       N2 = N.getOperand(2);
04450       Select(Tmp1, N1);
04451       Select(Tmp2, N2);
04452       if (N.Val->hasOneUse()) {
04453         Result = CurDAG->SelectNodeTo(N.Val, PPC::VAVGUH, MVT::v8i16, Tmp1, Tmp2);
04454       } else {
04455         ResNode = CurDAG->getTargetNode(PPC::VAVGUH, MVT::v8i16, Tmp1, Tmp2);
04456         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04457         Result = SDOperand(ResNode, 0);
04458       }
04459       return;
04460     }
04461 
04462     // Pattern: (intrinsic_wo_chain:v4i32 67:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
04463     // Emits: (VAVGUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
04464     // Pattern complexity = 5  cost = 1
04465     if (CN0 == 67) {
04466       N1 = N.getOperand(1);
04467       N2 = N.getOperand(2);
04468       Select(Tmp1, N1);
04469       Select(Tmp2, N2);
04470       if (N.Val->hasOneUse()) {
04471         Result = CurDAG->SelectNodeTo(N.Val, PPC::VAVGUW, MVT::v4i32, Tmp1, Tmp2);
04472       } else {
04473         ResNode = CurDAG->getTargetNode(PPC::VAVGUW, MVT::v4i32, Tmp1, Tmp2);
04474         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04475         Result = SDOperand(ResNode, 0);
04476       }
04477       return;
04478     }
04479 
04480     // Pattern: (intrinsic_wo_chain:v4f32 101:i32, VRRC:v4f32:$vA, VRRC:v4f32:$vB)
04481     // Emits: (VMAXFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB)
04482     // Pattern complexity = 5  cost = 1
04483     if (CN0 == 101) {
04484       N1 = N.getOperand(1);
04485       N2 = N.getOperand(2);
04486       Select(Tmp1, N1);
04487       Select(Tmp2, N2);
04488       if (N.Val->hasOneUse()) {
04489         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMAXFP, MVT::v4f32, Tmp1, Tmp2);
04490       } else {
04491         ResNode = CurDAG->getTargetNode(PPC::VMAXFP, MVT::v4f32, Tmp1, Tmp2);
04492         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04493         Result = SDOperand(ResNode, 0);
04494       }
04495       return;
04496     }
04497 
04498     // Pattern: (intrinsic_wo_chain:v16i8 102:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04499     // Emits: (VMAXSB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04500     // Pattern complexity = 5  cost = 1
04501     if (CN0 == 102) {
04502       N1 = N.getOperand(1);
04503       N2 = N.getOperand(2);
04504       Select(Tmp1, N1);
04505       Select(Tmp2, N2);
04506       if (N.Val->hasOneUse()) {
04507         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMAXSB, MVT::v16i8, Tmp1, Tmp2);
04508       } else {
04509         ResNode = CurDAG->getTargetNode(PPC::VMAXSB, MVT::v16i8, Tmp1, Tmp2);
04510         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04511         Result = SDOperand(ResNode, 0);
04512       }
04513       return;
04514     }
04515 
04516     // Pattern: (intrinsic_wo_chain:v8i16 103:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04517     // Emits: (VMAXSH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04518     // Pattern complexity = 5  cost = 1
04519     if (CN0 == 103) {
04520       N1 = N.getOperand(1);
04521       N2 = N.getOperand(2);
04522       Select(Tmp1, N1);
04523       Select(Tmp2, N2);
04524       if (N.Val->hasOneUse()) {
04525         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMAXSH, MVT::v8i16, Tmp1, Tmp2);
04526       } else {
04527         ResNode = CurDAG->getTargetNode(PPC::VMAXSH, MVT::v8i16, Tmp1, Tmp2);
04528         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04529         Result = SDOperand(ResNode, 0);
04530       }
04531       return;
04532     }
04533 
04534     // Pattern: (intrinsic_wo_chain:v4i32 104:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
04535     // Emits: (VMAXSW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
04536     // Pattern complexity = 5  cost = 1
04537     if (CN0 == 104) {
04538       N1 = N.getOperand(1);
04539       N2 = N.getOperand(2);
04540       Select(Tmp1, N1);
04541       Select(Tmp2, N2);
04542       if (N.Val->hasOneUse()) {
04543         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMAXSW, MVT::v4i32, Tmp1, Tmp2);
04544       } else {
04545         ResNode = CurDAG->getTargetNode(PPC::VMAXSW, MVT::v4i32, Tmp1, Tmp2);
04546         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04547         Result = SDOperand(ResNode, 0);
04548       }
04549       return;
04550     }
04551 
04552     // Pattern: (intrinsic_wo_chain:v16i8 105:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04553     // Emits: (VMAXUB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04554     // Pattern complexity = 5  cost = 1
04555     if (CN0 == 105) {
04556       N1 = N.getOperand(1);
04557       N2 = N.getOperand(2);
04558       Select(Tmp1, N1);
04559       Select(Tmp2, N2);
04560       if (N.Val->hasOneUse()) {
04561         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMAXUB, MVT::v16i8, Tmp1, Tmp2);
04562       } else {
04563         ResNode = CurDAG->getTargetNode(PPC::VMAXUB, MVT::v16i8, Tmp1, Tmp2);
04564         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04565         Result = SDOperand(ResNode, 0);
04566       }
04567       return;
04568     }
04569 
04570     // Pattern: (intrinsic_wo_chain:v8i16 106:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04571     // Emits: (VMAXUH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04572     // Pattern complexity = 5  cost = 1
04573     if (CN0 == 106) {
04574       N1 = N.getOperand(1);
04575       N2 = N.getOperand(2);
04576       Select(Tmp1, N1);
04577       Select(Tmp2, N2);
04578       if (N.Val->hasOneUse()) {
04579         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMAXUH, MVT::v8i16, Tmp1, Tmp2);
04580       } else {
04581         ResNode = CurDAG->getTargetNode(PPC::VMAXUH, MVT::v8i16, Tmp1, Tmp2);
04582         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04583         Result = SDOperand(ResNode, 0);
04584       }
04585       return;
04586     }
04587 
04588     // Pattern: (intrinsic_wo_chain:v4i32 107:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
04589     // Emits: (VMAXUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
04590     // Pattern complexity = 5  cost = 1
04591     if (CN0 == 107) {
04592       N1 = N.getOperand(1);
04593       N2 = N.getOperand(2);
04594       Select(Tmp1, N1);
04595       Select(Tmp2, N2);
04596       if (N.Val->hasOneUse()) {
04597         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMAXUW, MVT::v4i32, Tmp1, Tmp2);
04598       } else {
04599         ResNode = CurDAG->getTargetNode(PPC::VMAXUW, MVT::v4i32, Tmp1, Tmp2);
04600         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04601         Result = SDOperand(ResNode, 0);
04602       }
04603       return;
04604     }
04605 
04606     // Pattern: (intrinsic_wo_chain:v4f32 110:i32, VRRC:v4f32:$vA, VRRC:v4f32:$vB)
04607     // Emits: (VMINFP:v4f32 VRRC:v4f32:$vA, VRRC:v4f32:$vB)
04608     // Pattern complexity = 5  cost = 1
04609     if (CN0 == 110) {
04610       N1 = N.getOperand(1);
04611       N2 = N.getOperand(2);
04612       Select(Tmp1, N1);
04613       Select(Tmp2, N2);
04614       if (N.Val->hasOneUse()) {
04615         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMINFP, MVT::v4f32, Tmp1, Tmp2);
04616       } else {
04617         ResNode = CurDAG->getTargetNode(PPC::VMINFP, MVT::v4f32, Tmp1, Tmp2);
04618         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04619         Result = SDOperand(ResNode, 0);
04620       }
04621       return;
04622     }
04623 
04624     // Pattern: (intrinsic_wo_chain:v16i8 111:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04625     // Emits: (VMINSB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04626     // Pattern complexity = 5  cost = 1
04627     if (CN0 == 111) {
04628       N1 = N.getOperand(1);
04629       N2 = N.getOperand(2);
04630       Select(Tmp1, N1);
04631       Select(Tmp2, N2);
04632       if (N.Val->hasOneUse()) {
04633         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMINSB, MVT::v16i8, Tmp1, Tmp2);
04634       } else {
04635         ResNode = CurDAG->getTargetNode(PPC::VMINSB, MVT::v16i8, Tmp1, Tmp2);
04636         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04637         Result = SDOperand(ResNode, 0);
04638       }
04639       return;
04640     }
04641 
04642     // Pattern: (intrinsic_wo_chain:v8i16 112:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04643     // Emits: (VMINSH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04644     // Pattern complexity = 5  cost = 1
04645     if (CN0 == 112) {
04646       N1 = N.getOperand(1);
04647       N2 = N.getOperand(2);
04648       Select(Tmp1, N1);
04649       Select(Tmp2, N2);
04650       if (N.Val->hasOneUse()) {
04651         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMINSH, MVT::v8i16, Tmp1, Tmp2);
04652       } else {
04653         ResNode = CurDAG->getTargetNode(PPC::VMINSH, MVT::v8i16, Tmp1, Tmp2);
04654         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04655         Result = SDOperand(ResNode, 0);
04656       }
04657       return;
04658     }
04659 
04660     // Pattern: (intrinsic_wo_chain:v4i32 113:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
04661     // Emits: (VMINSW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
04662     // Pattern complexity = 5  cost = 1
04663     if (CN0 == 113) {
04664       N1 = N.getOperand(1);
04665       N2 = N.getOperand(2);
04666       Select(Tmp1, N1);
04667       Select(Tmp2, N2);
04668       if (N.Val->hasOneUse()) {
04669         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMINSW, MVT::v4i32, Tmp1, Tmp2);
04670       } else {
04671         ResNode = CurDAG->getTargetNode(PPC::VMINSW, MVT::v4i32, Tmp1, Tmp2);
04672         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04673         Result = SDOperand(ResNode, 0);
04674       }
04675       return;
04676     }
04677 
04678     // Pattern: (intrinsic_wo_chain:v16i8 114:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04679     // Emits: (VMINUB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04680     // Pattern complexity = 5  cost = 1
04681     if (CN0 == 114) {
04682       N1 = N.getOperand(1);
04683       N2 = N.getOperand(2);
04684       Select(Tmp1, N1);
04685       Select(Tmp2, N2);
04686       if (N.Val->hasOneUse()) {
04687         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMINUB, MVT::v16i8, Tmp1, Tmp2);
04688       } else {
04689         ResNode = CurDAG->getTargetNode(PPC::VMINUB, MVT::v16i8, Tmp1, Tmp2);
04690         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04691         Result = SDOperand(ResNode, 0);
04692       }
04693       return;
04694     }
04695 
04696     // Pattern: (intrinsic_wo_chain:v8i16 115:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04697     // Emits: (VMINUH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04698     // Pattern complexity = 5  cost = 1
04699     if (CN0 == 115) {
04700       N1 = N.getOperand(1);
04701       N2 = N.getOperand(2);
04702       Select(Tmp1, N1);
04703       Select(Tmp2, N2);
04704       if (N.Val->hasOneUse()) {
04705         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMINUH, MVT::v8i16, Tmp1, Tmp2);
04706       } else {
04707         ResNode = CurDAG->getTargetNode(PPC::VMINUH, MVT::v8i16, Tmp1, Tmp2);
04708         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04709         Result = SDOperand(ResNode, 0);
04710       }
04711       return;
04712     }
04713 
04714     // Pattern: (intrinsic_wo_chain:v4i32 116:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
04715     // Emits: (VMINUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
04716     // Pattern complexity = 5  cost = 1
04717     if (CN0 == 116) {
04718       N1 = N.getOperand(1);
04719       N2 = N.getOperand(2);
04720       Select(Tmp1, N1);
04721       Select(Tmp2, N2);
04722       if (N.Val->hasOneUse()) {
04723         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMINUW, MVT::v4i32, Tmp1, Tmp2);
04724       } else {
04725         ResNode = CurDAG->getTargetNode(PPC::VMINUW, MVT::v4i32, Tmp1, Tmp2);
04726         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04727         Result = SDOperand(ResNode, 0);
04728       }
04729       return;
04730     }
04731 
04732     // Pattern: (intrinsic_wo_chain:v4i32 118:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB, VRRC:v4i32:$vC)
04733     // Emits: (VMSUMMBM:v4i32 VRRC:v16i8:$vA, VRRC:v16i8:$vB, VRRC:v4i32:$vC)
04734     // Pattern complexity = 5  cost = 1
04735     if (CN0 == 118) {
04736       N1 = N.getOperand(1);
04737       N2 = N.getOperand(2);
04738       N3 = N.getOperand(3);
04739       Select(Tmp1, N1);
04740       Select(Tmp2, N2);
04741       Select(Tmp3, N3);
04742       if (N.Val->hasOneUse()) {
04743         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMSUMMBM, MVT::v4i32, Tmp1, Tmp2, Tmp3);
04744       } else {
04745         ResNode = CurDAG->getTargetNode(PPC::VMSUMMBM, MVT::v4i32, Tmp1, Tmp2, Tmp3);
04746         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04747         Result = SDOperand(ResNode, 0);
04748       }
04749       return;
04750     }
04751 
04752     // Pattern: (intrinsic_wo_chain:v4i32 119:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC)
04753     // Emits: (VMSUMSHM:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC)
04754     // Pattern complexity = 5  cost = 1
04755     if (CN0 == 119) {
04756       N1 = N.getOperand(1);
04757       N2 = N.getOperand(2);
04758       N3 = N.getOperand(3);
04759       Select(Tmp1, N1);
04760       Select(Tmp2, N2);
04761       Select(Tmp3, N3);
04762       if (N.Val->hasOneUse()) {
04763         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMSUMSHM, MVT::v4i32, Tmp1, Tmp2, Tmp3);
04764       } else {
04765         ResNode = CurDAG->getTargetNode(PPC::VMSUMSHM, MVT::v4i32, Tmp1, Tmp2, Tmp3);
04766         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04767         Result = SDOperand(ResNode, 0);
04768       }
04769       return;
04770     }
04771 
04772     // Pattern: (intrinsic_wo_chain:v4i32 120:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC)
04773     // Emits: (VMSUMSHS:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC)
04774     // Pattern complexity = 5  cost = 1
04775     if (CN0 == 120) {
04776       N1 = N.getOperand(1);
04777       N2 = N.getOperand(2);
04778       N3 = N.getOperand(3);
04779       Select(Tmp1, N1);
04780       Select(Tmp2, N2);
04781       Select(Tmp3, N3);
04782       if (N.Val->hasOneUse()) {
04783         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMSUMSHS, MVT::v4i32, Tmp1, Tmp2, Tmp3);
04784       } else {
04785         ResNode = CurDAG->getTargetNode(PPC::VMSUMSHS, MVT::v4i32, Tmp1, Tmp2, Tmp3);
04786         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04787         Result = SDOperand(ResNode, 0);
04788       }
04789       return;
04790     }
04791 
04792     // Pattern: (intrinsic_wo_chain:v4i32 121:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB, VRRC:v4i32:$vC)
04793     // Emits: (VMSUMUBM:v4i32 VRRC:v16i8:$vA, VRRC:v16i8:$vB, VRRC:v4i32:$vC)
04794     // Pattern complexity = 5  cost = 1
04795     if (CN0 == 121) {
04796       N1 = N.getOperand(1);
04797       N2 = N.getOperand(2);
04798       N3 = N.getOperand(3);
04799       Select(Tmp1, N1);
04800       Select(Tmp2, N2);
04801       Select(Tmp3, N3);
04802       if (N.Val->hasOneUse()) {
04803         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMSUMUBM, MVT::v4i32, Tmp1, Tmp2, Tmp3);
04804       } else {
04805         ResNode = CurDAG->getTargetNode(PPC::VMSUMUBM, MVT::v4i32, Tmp1, Tmp2, Tmp3);
04806         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04807         Result = SDOperand(ResNode, 0);
04808       }
04809       return;
04810     }
04811 
04812     // Pattern: (intrinsic_wo_chain:v4i32 122:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC)
04813     // Emits: (VMSUMUHM:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC)
04814     // Pattern complexity = 5  cost = 1
04815     if (CN0 == 122) {
04816       N1 = N.getOperand(1);
04817       N2 = N.getOperand(2);
04818       N3 = N.getOperand(3);
04819       Select(Tmp1, N1);
04820       Select(Tmp2, N2);
04821       Select(Tmp3, N3);
04822       if (N.Val->hasOneUse()) {
04823         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMSUMUHM, MVT::v4i32, Tmp1, Tmp2, Tmp3);
04824       } else {
04825         ResNode = CurDAG->getTargetNode(PPC::VMSUMUHM, MVT::v4i32, Tmp1, Tmp2, Tmp3);
04826         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04827         Result = SDOperand(ResNode, 0);
04828       }
04829       return;
04830     }
04831 
04832     // Pattern: (intrinsic_wo_chain:v4i32 123:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC)
04833     // Emits: (VMSUMUHS:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB, VRRC:v4i32:$vC)
04834     // Pattern complexity = 5  cost = 1
04835     if (CN0 == 123) {
04836       N1 = N.getOperand(1);
04837       N2 = N.getOperand(2);
04838       N3 = N.getOperand(3);
04839       Select(Tmp1, N1);
04840       Select(Tmp2, N2);
04841       Select(Tmp3, N3);
04842       if (N.Val->hasOneUse()) {
04843         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMSUMUHS, MVT::v4i32, Tmp1, Tmp2, Tmp3);
04844       } else {
04845         ResNode = CurDAG->getTargetNode(PPC::VMSUMUHS, MVT::v4i32, Tmp1, Tmp2, Tmp3);
04846         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04847         Result = SDOperand(ResNode, 0);
04848       }
04849       return;
04850     }
04851 
04852     // Pattern: (intrinsic_wo_chain:v8i16 124:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04853     // Emits: (VMULESB:v8i16 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04854     // Pattern complexity = 5  cost = 1
04855     if (CN0 == 124) {
04856       N1 = N.getOperand(1);
04857       N2 = N.getOperand(2);
04858       Select(Tmp1, N1);
04859       Select(Tmp2, N2);
04860       if (N.Val->hasOneUse()) {
04861         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMULESB, MVT::v8i16, Tmp1, Tmp2);
04862       } else {
04863         ResNode = CurDAG->getTargetNode(PPC::VMULESB, MVT::v8i16, Tmp1, Tmp2);
04864         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04865         Result = SDOperand(ResNode, 0);
04866       }
04867       return;
04868     }
04869 
04870     // Pattern: (intrinsic_wo_chain:v4i32 125:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04871     // Emits: (VMULESH:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04872     // Pattern complexity = 5  cost = 1
04873     if (CN0 == 125) {
04874       N1 = N.getOperand(1);
04875       N2 = N.getOperand(2);
04876       Select(Tmp1, N1);
04877       Select(Tmp2, N2);
04878       if (N.Val->hasOneUse()) {
04879         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMULESH, MVT::v4i32, Tmp1, Tmp2);
04880       } else {
04881         ResNode = CurDAG->getTargetNode(PPC::VMULESH, MVT::v4i32, Tmp1, Tmp2);
04882         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04883         Result = SDOperand(ResNode, 0);
04884       }
04885       return;
04886     }
04887 
04888     // Pattern: (intrinsic_wo_chain:v8i16 126:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04889     // Emits: (VMULEUB:v8i16 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04890     // Pattern complexity = 5  cost = 1
04891     if (CN0 == 126) {
04892       N1 = N.getOperand(1);
04893       N2 = N.getOperand(2);
04894       Select(Tmp1, N1);
04895       Select(Tmp2, N2);
04896       if (N.Val->hasOneUse()) {
04897         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMULEUB, MVT::v8i16, Tmp1, Tmp2);
04898       } else {
04899         ResNode = CurDAG->getTargetNode(PPC::VMULEUB, MVT::v8i16, Tmp1, Tmp2);
04900         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04901         Result = SDOperand(ResNode, 0);
04902       }
04903       return;
04904     }
04905 
04906     // Pattern: (intrinsic_wo_chain:v4i32 127:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04907     // Emits: (VMULEUH:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04908     // Pattern complexity = 5  cost = 1
04909     if (CN0 == 127) {
04910       N1 = N.getOperand(1);
04911       N2 = N.getOperand(2);
04912       Select(Tmp1, N1);
04913       Select(Tmp2, N2);
04914       if (N.Val->hasOneUse()) {
04915         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMULEUH, MVT::v4i32, Tmp1, Tmp2);
04916       } else {
04917         ResNode = CurDAG->getTargetNode(PPC::VMULEUH, MVT::v4i32, Tmp1, Tmp2);
04918         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04919         Result = SDOperand(ResNode, 0);
04920       }
04921       return;
04922     }
04923 
04924     // Pattern: (intrinsic_wo_chain:v8i16 128:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04925     // Emits: (VMULOSB:v8i16 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04926     // Pattern complexity = 5  cost = 1
04927     if (CN0 == 128) {
04928       N1 = N.getOperand(1);
04929       N2 = N.getOperand(2);
04930       Select(Tmp1, N1);
04931       Select(Tmp2, N2);
04932       if (N.Val->hasOneUse()) {
04933         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMULOSB, MVT::v8i16, Tmp1, Tmp2);
04934       } else {
04935         ResNode = CurDAG->getTargetNode(PPC::VMULOSB, MVT::v8i16, Tmp1, Tmp2);
04936         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04937         Result = SDOperand(ResNode, 0);
04938       }
04939       return;
04940     }
04941 
04942     // Pattern: (intrinsic_wo_chain:v4i32 129:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04943     // Emits: (VMULOSH:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04944     // Pattern complexity = 5  cost = 1
04945     if (CN0 == 129) {
04946       N1 = N.getOperand(1);
04947       N2 = N.getOperand(2);
04948       Select(Tmp1, N1);
04949       Select(Tmp2, N2);
04950       if (N.Val->hasOneUse()) {
04951         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMULOSH, MVT::v4i32, Tmp1, Tmp2);
04952       } else {
04953         ResNode = CurDAG->getTargetNode(PPC::VMULOSH, MVT::v4i32, Tmp1, Tmp2);
04954         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04955         Result = SDOperand(ResNode, 0);
04956       }
04957       return;
04958     }
04959 
04960     // Pattern: (intrinsic_wo_chain:v8i16 130:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04961     // Emits: (VMULOUB:v8i16 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
04962     // Pattern complexity = 5  cost = 1
04963     if (CN0 == 130) {
04964       N1 = N.getOperand(1);
04965       N2 = N.getOperand(2);
04966       Select(Tmp1, N1);
04967       Select(Tmp2, N2);
04968       if (N.Val->hasOneUse()) {
04969         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMULOUB, MVT::v8i16, Tmp1, Tmp2);
04970       } else {
04971         ResNode = CurDAG->getTargetNode(PPC::VMULOUB, MVT::v8i16, Tmp1, Tmp2);
04972         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04973         Result = SDOperand(ResNode, 0);
04974       }
04975       return;
04976     }
04977 
04978     // Pattern: (intrinsic_wo_chain:v4i32 131:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04979     // Emits: (VMULOUH:v4i32 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
04980     // Pattern complexity = 5  cost = 1
04981     if (CN0 == 131) {
04982       N1 = N.getOperand(1);
04983       N2 = N.getOperand(2);
04984       Select(Tmp1, N1);
04985       Select(Tmp2, N2);
04986       if (N.Val->hasOneUse()) {
04987         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMULOUH, MVT::v4i32, Tmp1, Tmp2);
04988       } else {
04989         ResNode = CurDAG->getTargetNode(PPC::VMULOUH, MVT::v4i32, Tmp1, Tmp2);
04990         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
04991         Result = SDOperand(ResNode, 0);
04992       }
04993       return;
04994     }
04995 
04996     // Pattern: (intrinsic_wo_chain:v4f32 141:i32, VRRC:v4f32:$vB)
04997     // Emits: (VREFP:v4f32 VRRC:v4f32:$vB)
04998     // Pattern complexity = 5  cost = 1
04999     if (CN0 == 141) {
05000       N1 = N.getOperand(1);
05001       Select(Tmp1, N1);
05002       if (N.Val->hasOneUse()) {
05003         Result = CurDAG->SelectNodeTo(N.Val, PPC::VREFP, MVT::v4f32, Tmp1);
05004       } else {
05005         ResNode = CurDAG->getTargetNode(PPC::VREFP, MVT::v4f32, Tmp1);
05006         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05007         Result = SDOperand(ResNode, 0);
05008       }
05009       return;
05010     }
05011 
05012     // Pattern: (intrinsic_wo_chain:v4f32 142:i32, VRRC:v4f32:$vB)
05013     // Emits: (VRFIM:v4f32 VRRC:v4f32:$vB)
05014     // Pattern complexity = 5  cost = 1
05015     if (CN0 == 142) {
05016       N1 = N.getOperand(1);
05017       Select(Tmp1, N1);
05018       if (N.Val->hasOneUse()) {
05019         Result = CurDAG->SelectNodeTo(N.Val, PPC::VRFIM, MVT::v4f32, Tmp1);
05020       } else {
05021         ResNode = CurDAG->getTargetNode(PPC::VRFIM, MVT::v4f32, Tmp1);
05022         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05023         Result = SDOperand(ResNode, 0);
05024       }
05025       return;
05026     }
05027 
05028     // Pattern: (intrinsic_wo_chain:v4f32 143:i32, VRRC:v4f32:$vB)
05029     // Emits: (VRFIN:v4f32 VRRC:v4f32:$vB)
05030     // Pattern complexity = 5  cost = 1
05031     if (CN0 == 143) {
05032       N1 = N.getOperand(1);
05033       Select(Tmp1, N1);
05034       if (N.Val->hasOneUse()) {
05035         Result = CurDAG->SelectNodeTo(N.Val, PPC::VRFIN, MVT::v4f32, Tmp1);
05036       } else {
05037         ResNode = CurDAG->getTargetNode(PPC::VRFIN, MVT::v4f32, Tmp1);
05038         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05039         Result = SDOperand(ResNode, 0);
05040       }
05041       return;
05042     }
05043 
05044     // Pattern: (intrinsic_wo_chain:v4f32 144:i32, VRRC:v4f32:$vB)
05045     // Emits: (VRFIP:v4f32 VRRC:v4f32:$vB)
05046     // Pattern complexity = 5  cost = 1
05047     if (CN0 == 144) {
05048       N1 = N.getOperand(1);
05049       Select(Tmp1, N1);
05050       if (N.Val->hasOneUse()) {
05051         Result = CurDAG->SelectNodeTo(N.Val, PPC::VRFIP, MVT::v4f32, Tmp1);
05052       } else {
05053         ResNode = CurDAG->getTargetNode(PPC::VRFIP, MVT::v4f32, Tmp1);
05054         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05055         Result = SDOperand(ResNode, 0);
05056       }
05057       return;
05058     }
05059 
05060     // Pattern: (intrinsic_wo_chain:v4f32 145:i32, VRRC:v4f32:$vB)
05061     // Emits: (VRFIZ:v4f32 VRRC:v4f32:$vB)
05062     // Pattern complexity = 5  cost = 1
05063     if (CN0 == 145) {
05064       N1 = N.getOperand(1);
05065       Select(Tmp1, N1);
05066       if (N.Val->hasOneUse()) {
05067         Result = CurDAG->SelectNodeTo(N.Val, PPC::VRFIZ, MVT::v4f32, Tmp1);
05068       } else {
05069         ResNode = CurDAG->getTargetNode(PPC::VRFIZ, MVT::v4f32, Tmp1);
05070         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05071         Result = SDOperand(ResNode, 0);
05072       }
05073       return;
05074     }
05075 
05076     // Pattern: (intrinsic_wo_chain:v4f32 149:i32, VRRC:v4f32:$vB)
05077     // Emits: (VRSQRTEFP:v4f32 VRRC:v4f32:$vB)
05078     // Pattern complexity = 5  cost = 1
05079     if (CN0 == 149) {
05080       N1 = N.getOperand(1);
05081       Select(Tmp1, N1);
05082       if (N.Val->hasOneUse()) {
05083         Result = CurDAG->SelectNodeTo(N.Val, PPC::VRSQRTEFP, MVT::v4f32, Tmp1);
05084       } else {
05085         ResNode = CurDAG->getTargetNode(PPC::VRSQRTEFP, MVT::v4f32, Tmp1);
05086         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05087         Result = SDOperand(ResNode, 0);
05088       }
05089       return;
05090     }
05091 
05092     // Pattern: (intrinsic_wo_chain:v4i32 164:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05093     // Emits: (VSUBCUW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05094     // Pattern complexity = 5  cost = 1
05095     if (CN0 == 164) {
05096       N1 = N.getOperand(1);
05097       N2 = N.getOperand(2);
05098       Select(Tmp1, N1);
05099       Select(Tmp2, N2);
05100       if (N.Val->hasOneUse()) {
05101         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBCUW, MVT::v4i32, Tmp1, Tmp2);
05102       } else {
05103         ResNode = CurDAG->getTargetNode(PPC::VSUBCUW, MVT::v4i32, Tmp1, Tmp2);
05104         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05105         Result = SDOperand(ResNode, 0);
05106       }
05107       return;
05108     }
05109 
05110     // Pattern: (intrinsic_wo_chain:v16i8 165:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB)
05111     // Emits: (VSUBSBS:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
05112     // Pattern complexity = 5  cost = 1
05113     if (CN0 == 165) {
05114       N1 = N.getOperand(1);
05115       N2 = N.getOperand(2);
05116       Select(Tmp1, N1);
05117       Select(Tmp2, N2);
05118       if (N.Val->hasOneUse()) {
05119         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBSBS, MVT::v16i8, Tmp1, Tmp2);
05120       } else {
05121         ResNode = CurDAG->getTargetNode(PPC::VSUBSBS, MVT::v16i8, Tmp1, Tmp2);
05122         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05123         Result = SDOperand(ResNode, 0);
05124       }
05125       return;
05126     }
05127 
05128     // Pattern: (intrinsic_wo_chain:v8i16 166:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
05129     // Emits: (VSUBSHS:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
05130     // Pattern complexity = 5  cost = 1
05131     if (CN0 == 166) {
05132       N1 = N.getOperand(1);
05133       N2 = N.getOperand(2);
05134       Select(Tmp1, N1);
05135       Select(Tmp2, N2);
05136       if (N.Val->hasOneUse()) {
05137         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBSHS, MVT::v8i16, Tmp1, Tmp2);
05138       } else {
05139         ResNode = CurDAG->getTargetNode(PPC::VSUBSHS, MVT::v8i16, Tmp1, Tmp2);
05140         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05141         Result = SDOperand(ResNode, 0);
05142       }
05143       return;
05144     }
05145 
05146     // Pattern: (intrinsic_wo_chain:v4i32 167:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05147     // Emits: (VSUBSWS:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05148     // Pattern complexity = 5  cost = 1
05149     if (CN0 == 167) {
05150       N1 = N.getOperand(1);
05151       N2 = N.getOperand(2);
05152       Select(Tmp1, N1);
05153       Select(Tmp2, N2);
05154       if (N.Val->hasOneUse()) {
05155         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBSWS, MVT::v4i32, Tmp1, Tmp2);
05156       } else {
05157         ResNode = CurDAG->getTargetNode(PPC::VSUBSWS, MVT::v4i32, Tmp1, Tmp2);
05158         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05159         Result = SDOperand(ResNode, 0);
05160       }
05161       return;
05162     }
05163 
05164     // Pattern: (intrinsic_wo_chain:v16i8 168:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB)
05165     // Emits: (VSUBUBS:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
05166     // Pattern complexity = 5  cost = 1
05167     if (CN0 == 168) {
05168       N1 = N.getOperand(1);
05169       N2 = N.getOperand(2);
05170       Select(Tmp1, N1);
05171       Select(Tmp2, N2);
05172       if (N.Val->hasOneUse()) {
05173         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBUBS, MVT::v16i8, Tmp1, Tmp2);
05174       } else {
05175         ResNode = CurDAG->getTargetNode(PPC::VSUBUBS, MVT::v16i8, Tmp1, Tmp2);
05176         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05177         Result = SDOperand(ResNode, 0);
05178       }
05179       return;
05180     }
05181 
05182     // Pattern: (intrinsic_wo_chain:v8i16 169:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
05183     // Emits: (VSUBUHS:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
05184     // Pattern complexity = 5  cost = 1
05185     if (CN0 == 169) {
05186       N1 = N.getOperand(1);
05187       N2 = N.getOperand(2);
05188       Select(Tmp1, N1);
05189       Select(Tmp2, N2);
05190       if (N.Val->hasOneUse()) {
05191         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBUHS, MVT::v8i16, Tmp1, Tmp2);
05192       } else {
05193         ResNode = CurDAG->getTargetNode(PPC::VSUBUHS, MVT::v8i16, Tmp1, Tmp2);
05194         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05195         Result = SDOperand(ResNode, 0);
05196       }
05197       return;
05198     }
05199 
05200     // Pattern: (intrinsic_wo_chain:v4i32 170:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05201     // Emits: (VSUBUWS:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05202     // Pattern complexity = 5  cost = 1
05203     if (CN0 == 170) {
05204       N1 = N.getOperand(1);
05205       N2 = N.getOperand(2);
05206       Select(Tmp1, N1);
05207       Select(Tmp2, N2);
05208       if (N.Val->hasOneUse()) {
05209         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBUWS, MVT::v4i32, Tmp1, Tmp2);
05210       } else {
05211         ResNode = CurDAG->getTargetNode(PPC::VSUBUWS, MVT::v4i32, Tmp1, Tmp2);
05212         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05213         Result = SDOperand(ResNode, 0);
05214       }
05215       return;
05216     }
05217 
05218     // Pattern: (intrinsic_wo_chain:v4i32 175:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05219     // Emits: (VSUMSWS:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05220     // Pattern complexity = 5  cost = 1
05221     if (CN0 == 175) {
05222       N1 = N.getOperand(1);
05223       N2 = N.getOperand(2);
05224       Select(Tmp1, N1);
05225       Select(Tmp2, N2);
05226       if (N.Val->hasOneUse()) {
05227         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUMSWS, MVT::v4i32, Tmp1, Tmp2);
05228       } else {
05229         ResNode = CurDAG->getTargetNode(PPC::VSUMSWS, MVT::v4i32, Tmp1, Tmp2);
05230         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05231         Result = SDOperand(ResNode, 0);
05232       }
05233       return;
05234     }
05235 
05236     // Pattern: (intrinsic_wo_chain:v4i32 171:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05237     // Emits: (VSUM2SWS:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05238     // Pattern complexity = 5  cost = 1
05239     if (CN0 == 171) {
05240       N1 = N.getOperand(1);
05241       N2 = N.getOperand(2);
05242       Select(Tmp1, N1);
05243       Select(Tmp2, N2);
05244       if (N.Val->hasOneUse()) {
05245         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUM2SWS, MVT::v4i32, Tmp1, Tmp2);
05246       } else {
05247         ResNode = CurDAG->getTargetNode(PPC::VSUM2SWS, MVT::v4i32, Tmp1, Tmp2);
05248         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05249         Result = SDOperand(ResNode, 0);
05250       }
05251       return;
05252     }
05253 
05254     // Pattern: (intrinsic_wo_chain:v4i32 172:i32, VRRC:v16i8:$vA, VRRC:v4i32:$vB)
05255     // Emits: (VSUM4SBS:v4i32 VRRC:v16i8:$vA, VRRC:v4i32:$vB)
05256     // Pattern complexity = 5  cost = 1
05257     if (CN0 == 172) {
05258       N1 = N.getOperand(1);
05259       N2 = N.getOperand(2);
05260       Select(Tmp1, N1);
05261       Select(Tmp2, N2);
05262       if (N.Val->hasOneUse()) {
05263         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUM4SBS, MVT::v4i32, Tmp1, Tmp2);
05264       } else {
05265         ResNode = CurDAG->getTargetNode(PPC::VSUM4SBS, MVT::v4i32, Tmp1, Tmp2);
05266         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05267         Result = SDOperand(ResNode, 0);
05268       }
05269       return;
05270     }
05271 
05272     // Pattern: (intrinsic_wo_chain:v4i32 173:i32, VRRC:v8i16:$vA, VRRC:v4i32:$vB)
05273     // Emits: (VSUM4SHS:v4i32 VRRC:v8i16:$vA, VRRC:v4i32:$vB)
05274     // Pattern complexity = 5  cost = 1
05275     if (CN0 == 173) {
05276       N1 = N.getOperand(1);
05277       N2 = N.getOperand(2);
05278       Select(Tmp1, N1);
05279       Select(Tmp2, N2);
05280       if (N.Val->hasOneUse()) {
05281         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUM4SHS, MVT::v4i32, Tmp1, Tmp2);
05282       } else {
05283         ResNode = CurDAG->getTargetNode(PPC::VSUM4SHS, MVT::v4i32, Tmp1, Tmp2);
05284         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05285         Result = SDOperand(ResNode, 0);
05286       }
05287       return;
05288     }
05289 
05290     // Pattern: (intrinsic_wo_chain:v4i32 174:i32, VRRC:v16i8:$vA, VRRC:v4i32:$vB)
05291     // Emits: (VSUM4UBS:v4i32 VRRC:v16i8:$vA, VRRC:v4i32:$vB)
05292     // Pattern complexity = 5  cost = 1
05293     if (CN0 == 174) {
05294       N1 = N.getOperand(1);
05295       N2 = N.getOperand(2);
05296       Select(Tmp1, N1);
05297       Select(Tmp2, N2);
05298       if (N.Val->hasOneUse()) {
05299         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUM4UBS, MVT::v4i32, Tmp1, Tmp2);
05300       } else {
05301         ResNode = CurDAG->getTargetNode(PPC::VSUM4UBS, MVT::v4i32, Tmp1, Tmp2);
05302         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05303         Result = SDOperand(ResNode, 0);
05304       }
05305       return;
05306     }
05307 
05308     // Pattern: (intrinsic_wo_chain:v16i8 146:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB)
05309     // Emits: (VRLB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
05310     // Pattern complexity = 5  cost = 1
05311     if (CN0 == 146) {
05312       N1 = N.getOperand(1);
05313       N2 = N.getOperand(2);
05314       Select(Tmp1, N1);
05315       Select(Tmp2, N2);
05316       if (N.Val->hasOneUse()) {
05317         Result = CurDAG->SelectNodeTo(N.Val, PPC::VRLB, MVT::v16i8, Tmp1, Tmp2);
05318       } else {
05319         ResNode = CurDAG->getTargetNode(PPC::VRLB, MVT::v16i8, Tmp1, Tmp2);
05320         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05321         Result = SDOperand(ResNode, 0);
05322       }
05323       return;
05324     }
05325 
05326     // Pattern: (intrinsic_wo_chain:v8i16 147:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
05327     // Emits: (VRLH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
05328     // Pattern complexity = 5  cost = 1
05329     if (CN0 == 147) {
05330       N1 = N.getOperand(1);
05331       N2 = N.getOperand(2);
05332       Select(Tmp1, N1);
05333       Select(Tmp2, N2);
05334       if (N.Val->hasOneUse()) {
05335         Result = CurDAG->SelectNodeTo(N.Val, PPC::VRLH, MVT::v8i16, Tmp1, Tmp2);
05336       } else {
05337         ResNode = CurDAG->getTargetNode(PPC::VRLH, MVT::v8i16, Tmp1, Tmp2);
05338         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05339         Result = SDOperand(ResNode, 0);
05340       }
05341       return;
05342     }
05343 
05344     // Pattern: (intrinsic_wo_chain:v4i32 148:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05345     // Emits: (VRLW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05346     // Pattern complexity = 5  cost = 1
05347     if (CN0 == 148) {
05348       N1 = N.getOperand(1);
05349       N2 = N.getOperand(2);
05350       Select(Tmp1, N1);
05351       Select(Tmp2, N2);
05352       if (N.Val->hasOneUse()) {
05353         Result = CurDAG->SelectNodeTo(N.Val, PPC::VRLW, MVT::v4i32, Tmp1, Tmp2);
05354       } else {
05355         ResNode = CurDAG->getTargetNode(PPC::VRLW, MVT::v4i32, Tmp1, Tmp2);
05356         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05357         Result = SDOperand(ResNode, 0);
05358       }
05359       return;
05360     }
05361 
05362     // Pattern: (intrinsic_wo_chain:v4i32 151:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05363     // Emits: (VSL:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05364     // Pattern complexity = 5  cost = 1
05365     if (CN0 == 151) {
05366       N1 = N.getOperand(1);
05367       N2 = N.getOperand(2);
05368       Select(Tmp1, N1);
05369       Select(Tmp2, N2);
05370       if (N.Val->hasOneUse()) {
05371         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSL, MVT::v4i32, Tmp1, Tmp2);
05372       } else {
05373         ResNode = CurDAG->getTargetNode(PPC::VSL, MVT::v4i32, Tmp1, Tmp2);
05374         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05375         Result = SDOperand(ResNode, 0);
05376       }
05377       return;
05378     }
05379 
05380     // Pattern: (intrinsic_wo_chain:v4i32 154:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05381     // Emits: (VSLO:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05382     // Pattern complexity = 5  cost = 1
05383     if (CN0 == 154) {
05384       N1 = N.getOperand(1);
05385       N2 = N.getOperand(2);
05386       Select(Tmp1, N1);
05387       Select(Tmp2, N2);
05388       if (N.Val->hasOneUse()) {
05389         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSLO, MVT::v4i32, Tmp1, Tmp2);
05390       } else {
05391         ResNode = CurDAG->getTargetNode(PPC::VSLO, MVT::v4i32, Tmp1, Tmp2);
05392         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05393         Result = SDOperand(ResNode, 0);
05394       }
05395       return;
05396     }
05397 
05398     // Pattern: (intrinsic_wo_chain:v16i8 152:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB)
05399     // Emits: (VSLB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
05400     // Pattern complexity = 5  cost = 1
05401     if (CN0 == 152) {
05402       N1 = N.getOperand(1);
05403       N2 = N.getOperand(2);
05404       Select(Tmp1, N1);
05405       Select(Tmp2, N2);
05406       if (N.Val->hasOneUse()) {
05407         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSLB, MVT::v16i8, Tmp1, Tmp2);
05408       } else {
05409         ResNode = CurDAG->getTargetNode(PPC::VSLB, MVT::v16i8, Tmp1, Tmp2);
05410         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05411         Result = SDOperand(ResNode, 0);
05412       }
05413       return;
05414     }
05415 
05416     // Pattern: (intrinsic_wo_chain:v8i16 153:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
05417     // Emits: (VSLH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
05418     // Pattern complexity = 5  cost = 1
05419     if (CN0 == 153) {
05420       N1 = N.getOperand(1);
05421       N2 = N.getOperand(2);
05422       Select(Tmp1, N1);
05423       Select(Tmp2, N2);
05424       if (N.Val->hasOneUse()) {
05425         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSLH, MVT::v8i16, Tmp1, Tmp2);
05426       } else {
05427         ResNode = CurDAG->getTargetNode(PPC::VSLH, MVT::v8i16, Tmp1, Tmp2);
05428         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05429         Result = SDOperand(ResNode, 0);
05430       }
05431       return;
05432     }
05433 
05434     // Pattern: (intrinsic_wo_chain:v4i32 155:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05435     // Emits: (VSLW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05436     // Pattern complexity = 5  cost = 1
05437     if (CN0 == 155) {
05438       N1 = N.getOperand(1);
05439       N2 = N.getOperand(2);
05440       Select(Tmp1, N1);
05441       Select(Tmp2, N2);
05442       if (N.Val->hasOneUse()) {
05443         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSLW, MVT::v4i32, Tmp1, Tmp2);
05444       } else {
05445         ResNode = CurDAG->getTargetNode(PPC::VSLW, MVT::v4i32, Tmp1, Tmp2);
05446         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05447         Result = SDOperand(ResNode, 0);
05448       }
05449       return;
05450     }
05451 
05452     // Pattern: (intrinsic_wo_chain:v4i32 156:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05453     // Emits: (VSR:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05454     // Pattern complexity = 5  cost = 1
05455     if (CN0 == 156) {
05456       N1 = N.getOperand(1);
05457       N2 = N.getOperand(2);
05458       Select(Tmp1, N1);
05459       Select(Tmp2, N2);
05460       if (N.Val->hasOneUse()) {
05461         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSR, MVT::v4i32, Tmp1, Tmp2);
05462       } else {
05463         ResNode = CurDAG->getTargetNode(PPC::VSR, MVT::v4i32, Tmp1, Tmp2);
05464         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05465         Result = SDOperand(ResNode, 0);
05466       }
05467       return;
05468     }
05469 
05470     // Pattern: (intrinsic_wo_chain:v4i32 162:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05471     // Emits: (VSRO:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05472     // Pattern complexity = 5  cost = 1
05473     if (CN0 == 162) {
05474       N1 = N.getOperand(1);
05475       N2 = N.getOperand(2);
05476       Select(Tmp1, N1);
05477       Select(Tmp2, N2);
05478       if (N.Val->hasOneUse()) {
05479         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSRO, MVT::v4i32, Tmp1, Tmp2);
05480       } else {
05481         ResNode = CurDAG->getTargetNode(PPC::VSRO, MVT::v4i32, Tmp1, Tmp2);
05482         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05483         Result = SDOperand(ResNode, 0);
05484       }
05485       return;
05486     }
05487 
05488     // Pattern: (intrinsic_wo_chain:v16i8 157:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB)
05489     // Emits: (VSRAB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
05490     // Pattern complexity = 5  cost = 1
05491     if (CN0 == 157) {
05492       N1 = N.getOperand(1);
05493       N2 = N.getOperand(2);
05494       Select(Tmp1, N1);
05495       Select(Tmp2, N2);
05496       if (N.Val->hasOneUse()) {
05497         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSRAB, MVT::v16i8, Tmp1, Tmp2);
05498       } else {
05499         ResNode = CurDAG->getTargetNode(PPC::VSRAB, MVT::v16i8, Tmp1, Tmp2);
05500         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05501         Result = SDOperand(ResNode, 0);
05502       }
05503       return;
05504     }
05505 
05506     // Pattern: (intrinsic_wo_chain:v8i16 158:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
05507     // Emits: (VSRAH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
05508     // Pattern complexity = 5  cost = 1
05509     if (CN0 == 158) {
05510       N1 = N.getOperand(1);
05511       N2 = N.getOperand(2);
05512       Select(Tmp1, N1);
05513       Select(Tmp2, N2);
05514       if (N.Val->hasOneUse()) {
05515         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSRAH, MVT::v8i16, Tmp1, Tmp2);
05516       } else {
05517         ResNode = CurDAG->getTargetNode(PPC::VSRAH, MVT::v8i16, Tmp1, Tmp2);
05518         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05519         Result = SDOperand(ResNode, 0);
05520       }
05521       return;
05522     }
05523 
05524     // Pattern: (intrinsic_wo_chain:v4i32 159:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05525     // Emits: (VSRAW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05526     // Pattern complexity = 5  cost = 1
05527     if (CN0 == 159) {
05528       N1 = N.getOperand(1);
05529       N2 = N.getOperand(2);
05530       Select(Tmp1, N1);
05531       Select(Tmp2, N2);
05532       if (N.Val->hasOneUse()) {
05533         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSRAW, MVT::v4i32, Tmp1, Tmp2);
05534       } else {
05535         ResNode = CurDAG->getTargetNode(PPC::VSRAW, MVT::v4i32, Tmp1, Tmp2);
05536         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05537         Result = SDOperand(ResNode, 0);
05538       }
05539       return;
05540     }
05541 
05542     // Pattern: (intrinsic_wo_chain:v16i8 160:i32, VRRC:v16i8:$vA, VRRC:v16i8:$vB)
05543     // Emits: (VSRB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
05544     // Pattern complexity = 5  cost = 1
05545     if (CN0 == 160) {
05546       N1 = N.getOperand(1);
05547       N2 = N.getOperand(2);
05548       Select(Tmp1, N1);
05549       Select(Tmp2, N2);
05550       if (N.Val->hasOneUse()) {
05551         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSRB, MVT::v16i8, Tmp1, Tmp2);
05552       } else {
05553         ResNode = CurDAG->getTargetNode(PPC::VSRB, MVT::v16i8, Tmp1, Tmp2);
05554         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05555         Result = SDOperand(ResNode, 0);
05556       }
05557       return;
05558     }
05559 
05560     // Pattern: (intrinsic_wo_chain:v8i16 161:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
05561     // Emits: (VSRH:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
05562     // Pattern complexity = 5  cost = 1
05563     if (CN0 == 161) {
05564       N1 = N.getOperand(1);
05565       N2 = N.getOperand(2);
05566       Select(Tmp1, N1);
05567       Select(Tmp2, N2);
05568       if (N.Val->hasOneUse()) {
05569         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSRH, MVT::v8i16, Tmp1, Tmp2);
05570       } else {
05571         ResNode = CurDAG->getTargetNode(PPC::VSRH, MVT::v8i16, Tmp1, Tmp2);
05572         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05573         Result = SDOperand(ResNode, 0);
05574       }
05575       return;
05576     }
05577 
05578     // Pattern: (intrinsic_wo_chain:v4i32 163:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05579     // Emits: (VSRW:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05580     // Pattern complexity = 5  cost = 1
05581     if (CN0 == 163) {
05582       N1 = N.getOperand(1);
05583       N2 = N.getOperand(2);
05584       Select(Tmp1, N1);
05585       Select(Tmp2, N2);
05586       if (N.Val->hasOneUse()) {
05587         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSRW, MVT::v4i32, Tmp1, Tmp2);
05588       } else {
05589         ResNode = CurDAG->getTargetNode(PPC::VSRW, MVT::v4i32, Tmp1, Tmp2);
05590         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05591         Result = SDOperand(ResNode, 0);
05592       }
05593       return;
05594     }
05595 
05596     // Pattern: (intrinsic_wo_chain:v8i16 134:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05597     // Emits: (VPKPX:v8i16 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05598     // Pattern complexity = 5  cost = 1
05599     if (CN0 == 134) {
05600       N1 = N.getOperand(1);
05601       N2 = N.getOperand(2);
05602       Select(Tmp1, N1);
05603       Select(Tmp2, N2);
05604       if (N.Val->hasOneUse()) {
05605         Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKPX, MVT::v8i16, Tmp1, Tmp2);
05606       } else {
05607         ResNode = CurDAG->getTargetNode(PPC::VPKPX, MVT::v8i16, Tmp1, Tmp2);
05608         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05609         Result = SDOperand(ResNode, 0);
05610       }
05611       return;
05612     }
05613 
05614     // Pattern: (intrinsic_wo_chain:v16i8 135:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
05615     // Emits: (VPKSHSS:v16i8 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
05616     // Pattern complexity = 5  cost = 1
05617     if (CN0 == 135) {
05618       N1 = N.getOperand(1);
05619       N2 = N.getOperand(2);
05620       Select(Tmp1, N1);
05621       Select(Tmp2, N2);
05622       if (N.Val->hasOneUse()) {
05623         Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKSHSS, MVT::v16i8, Tmp1, Tmp2);
05624       } else {
05625         ResNode = CurDAG->getTargetNode(PPC::VPKSHSS, MVT::v16i8, Tmp1, Tmp2);
05626         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05627         Result = SDOperand(ResNode, 0);
05628       }
05629       return;
05630     }
05631 
05632     // Pattern: (intrinsic_wo_chain:v16i8 136:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
05633     // Emits: (VPKSHUS:v16i8 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
05634     // Pattern complexity = 5  cost = 1
05635     if (CN0 == 136) {
05636       N1 = N.getOperand(1);
05637       N2 = N.getOperand(2);
05638       Select(Tmp1, N1);
05639       Select(Tmp2, N2);
05640       if (N.Val->hasOneUse()) {
05641         Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKSHUS, MVT::v16i8, Tmp1, Tmp2);
05642       } else {
05643         ResNode = CurDAG->getTargetNode(PPC::VPKSHUS, MVT::v16i8, Tmp1, Tmp2);
05644         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05645         Result = SDOperand(ResNode, 0);
05646       }
05647       return;
05648     }
05649 
05650     // Pattern: (intrinsic_wo_chain:v16i8 137:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05651     // Emits: (VPKSWSS:v16i8 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05652     // Pattern complexity = 5  cost = 1
05653     if (CN0 == 137) {
05654       N1 = N.getOperand(1);
05655       N2 = N.getOperand(2);
05656       Select(Tmp1, N1);
05657       Select(Tmp2, N2);
05658       if (N.Val->hasOneUse()) {
05659         Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKSWSS, MVT::v16i8, Tmp1, Tmp2);
05660       } else {
05661         ResNode = CurDAG->getTargetNode(PPC::VPKSWSS, MVT::v16i8, Tmp1, Tmp2);
05662         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05663         Result = SDOperand(ResNode, 0);
05664       }
05665       return;
05666     }
05667 
05668     // Pattern: (intrinsic_wo_chain:v8i16 138:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05669     // Emits: (VPKSWUS:v8i16 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05670     // Pattern complexity = 5  cost = 1
05671     if (CN0 == 138) {
05672       N1 = N.getOperand(1);
05673       N2 = N.getOperand(2);
05674       Select(Tmp1, N1);
05675       Select(Tmp2, N2);
05676       if (N.Val->hasOneUse()) {
05677         Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKSWUS, MVT::v8i16, Tmp1, Tmp2);
05678       } else {
05679         ResNode = CurDAG->getTargetNode(PPC::VPKSWUS, MVT::v8i16, Tmp1, Tmp2);
05680         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05681         Result = SDOperand(ResNode, 0);
05682       }
05683       return;
05684     }
05685 
05686     // Pattern: (intrinsic_wo_chain:v16i8 139:i32, VRRC:v8i16:$vA, VRRC:v8i16:$vB)
05687     // Emits: (VPKUHUS:v16i8 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
05688     // Pattern complexity = 5  cost = 1
05689     if (CN0 == 139) {
05690       N1 = N.getOperand(1);
05691       N2 = N.getOperand(2);
05692       Select(Tmp1, N1);
05693       Select(Tmp2, N2);
05694       if (N.Val->hasOneUse()) {
05695         Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKUHUS, MVT::v16i8, Tmp1, Tmp2);
05696       } else {
05697         ResNode = CurDAG->getTargetNode(PPC::VPKUHUS, MVT::v16i8, Tmp1, Tmp2);
05698         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05699         Result = SDOperand(ResNode, 0);
05700       }
05701       return;
05702     }
05703 
05704     // Pattern: (intrinsic_wo_chain:v16i8 140:i32, VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05705     // Emits: (VPKUWUS:v16i8 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
05706     // Pattern complexity = 5  cost = 1
05707     if (CN0 == 140) {
05708       N1 = N.getOperand(1);
05709       N2 = N.getOperand(2);
05710       Select(Tmp1, N1);
05711       Select(Tmp2, N2);
05712       if (N.Val->hasOneUse()) {
05713         Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKUWUS, MVT::v16i8, Tmp1, Tmp2);
05714       } else {
05715         ResNode = CurDAG->getTargetNode(PPC::VPKUWUS, MVT::v16i8, Tmp1, Tmp2);
05716         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05717         Result = SDOperand(ResNode, 0);
05718       }
05719       return;
05720     }
05721 
05722     // Pattern: (intrinsic_wo_chain:v4i32 176:i32, VRRC:v8i16:$vB)
05723     // Emits: (VUPKHPX:v4i32 VRRC:v8i16:$vB)
05724     // Pattern complexity = 5  cost = 1
05725     if (CN0 == 176) {
05726       N1 = N.getOperand(1);
05727       Select(Tmp1, N1);
05728       if (N.Val->hasOneUse()) {
05729         Result = CurDAG->SelectNodeTo(N.Val, PPC::VUPKHPX, MVT::v4i32, Tmp1);
05730       } else {
05731         ResNode = CurDAG->getTargetNode(PPC::VUPKHPX, MVT::v4i32, Tmp1);
05732         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05733         Result = SDOperand(ResNode, 0);
05734       }
05735       return;
05736     }
05737 
05738     // Pattern: (intrinsic_wo_chain:v8i16 177:i32, VRRC:v16i8:$vB)
05739     // Emits: (VUPKHSB:v8i16 VRRC:v16i8:$vB)
05740     // Pattern complexity = 5  cost = 1
05741     if (CN0 == 177) {
05742       N1 = N.getOperand(1);
05743       Select(Tmp1, N1);
05744       if (N.Val->hasOneUse()) {
05745         Result = CurDAG->SelectNodeTo(N.Val, PPC::VUPKHSB, MVT::v8i16, Tmp1);
05746       } else {
05747         ResNode = CurDAG->getTargetNode(PPC::VUPKHSB, MVT::v8i16, Tmp1);
05748         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05749         Result = SDOperand(ResNode, 0);
05750       }
05751       return;
05752     }
05753 
05754     // Pattern: (intrinsic_wo_chain:v4i32 178:i32, VRRC:v8i16:$vB)
05755     // Emits: (VUPKHSH:v4i32 VRRC:v8i16:$vB)
05756     // Pattern complexity = 5  cost = 1
05757     if (CN0 == 178) {
05758       N1 = N.getOperand(1);
05759       Select(Tmp1, N1);
05760       if (N.Val->hasOneUse()) {
05761         Result = CurDAG->SelectNodeTo(N.Val, PPC::VUPKHSH, MVT::v4i32, Tmp1);
05762       } else {
05763         ResNode = CurDAG->getTargetNode(PPC::VUPKHSH, MVT::v4i32, Tmp1);
05764         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05765         Result = SDOperand(ResNode, 0);
05766       }
05767       return;
05768     }
05769 
05770     // Pattern: (intrinsic_wo_chain:v4i32 179:i32, VRRC:v8i16:$vB)
05771     // Emits: (VUPKLPX:v4i32 VRRC:v8i16:$vB)
05772     // Pattern complexity = 5  cost = 1
05773     if (CN0 == 179) {
05774       N1 = N.getOperand(1);
05775       Select(Tmp1, N1);
05776       if (N.Val->hasOneUse()) {
05777         Result = CurDAG->SelectNodeTo(N.Val, PPC::VUPKLPX, MVT::v4i32, Tmp1);
05778       } else {
05779         ResNode = CurDAG->getTargetNode(PPC::VUPKLPX, MVT::v4i32, Tmp1);
05780         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05781         Result = SDOperand(ResNode, 0);
05782       }
05783       return;
05784     }
05785 
05786     // Pattern: (intrinsic_wo_chain:v8i16 180:i32, VRRC:v16i8:$vB)
05787     // Emits: (VUPKLSB:v8i16 VRRC:v16i8:$vB)
05788     // Pattern complexity = 5  cost = 1
05789     if (CN0 == 180) {
05790       N1 = N.getOperand(1);
05791       Select(Tmp1, N1);
05792       if (N.Val->hasOneUse()) {
05793         Result = CurDAG->SelectNodeTo(N.Val, PPC::VUPKLSB, MVT::v8i16, Tmp1);
05794       } else {
05795         ResNode = CurDAG->getTargetNode(PPC::VUPKLSB, MVT::v8i16, Tmp1);
05796         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05797         Result = SDOperand(ResNode, 0);
05798       }
05799       return;
05800     }
05801 
05802     // Pattern: (intrinsic_wo_chain:v4i32 181:i32, VRRC:v8i16:$vB)
05803     // Emits: (VUPKLSH:v4i32 VRRC:v8i16:$vB)
05804     // Pattern complexity = 5  cost = 1
05805     if (CN0 == 181) {
05806       N1 = N.getOperand(1);
05807       Select(Tmp1, N1);
05808       if (N.Val->hasOneUse()) {
05809         Result = CurDAG->SelectNodeTo(N.Val, PPC::VUPKLSH, MVT::v4i32, Tmp1);
05810       } else {
05811         ResNode = CurDAG->getTargetNode(PPC::VUPKLSH, MVT::v4i32, Tmp1);
05812         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05813         Result = SDOperand(ResNode, 0);
05814       }
05815       return;
05816     }
05817 
05818     // Pattern: (intrinsic_wo_chain:v4f32 100:i32, VRRC:v4f32:$A, VRRC:v4f32:$B, VRRC:v4f32:$C)
05819     // Emits: (VMADDFP:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B, VRRC:v16i8:$C)
05820     // Pattern complexity = 5  cost = 1
05821     if (CN0 == 100) {
05822       N1 = N.getOperand(1);
05823       N2 = N.getOperand(2);
05824       N3 = N.getOperand(3);
05825       Select(Tmp1, N1);
05826       Select(Tmp2, N2);
05827       Select(Tmp3, N3);
05828       if (N.Val->hasOneUse()) {
05829         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMADDFP, MVT::v16i8, Tmp1, Tmp2, Tmp3);
05830       } else {
05831         ResNode = CurDAG->getTargetNode(PPC::VMADDFP, MVT::v16i8, Tmp1, Tmp2, Tmp3);
05832         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05833         Result = SDOperand(ResNode, 0);
05834       }
05835       return;
05836     }
05837 
05838     // Pattern: (intrinsic_wo_chain:v4f32 132:i32, VRRC:v4f32:$A, VRRC:v4f32:$B, VRRC:v4f32:$C)
05839     // Emits: (VNMSUBFP:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B, VRRC:v16i8:$C)
05840     // Pattern complexity = 5  cost = 1
05841     if (CN0 == 132) {
05842       N1 = N.getOperand(1);
05843       N2 = N.getOperand(2);
05844       N3 = N.getOperand(3);
05845       Select(Tmp1, N1);
05846       Select(Tmp2, N2);
05847       Select(Tmp3, N3);
05848       if (N.Val->hasOneUse()) {
05849         Result = CurDAG->SelectNodeTo(N.Val, PPC::VNMSUBFP, MVT::v16i8, Tmp1, Tmp2, Tmp3);
05850       } else {
05851         ResNode = CurDAG->getTargetNode(PPC::VNMSUBFP, MVT::v16i8, Tmp1, Tmp2, Tmp3);
05852         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
05853         Result = SDOperand(ResNode, 0);
05854       }
05855       return;
05856     }
05857   }
05858   std::cerr << "Cannot yet select: ";
05859   unsigned iid = cast<ConstantSDNode>(N.getOperand(N.getOperand(0).getValueType() == MVT::Other))->getValue();
05860   std::cerr << "intrinsic %"<< Intrinsic::getName((Intrinsic::ID)iid);
05861   std::cerr << '\n';
05862   abort();
05863 }
05864 
05865 void Select_load(SDOperand &Result, SDOperand N) {
05866   if (N.ResNo == 1 && N.getValue(0).hasOneUse()) {
05867     SDOperand Dummy = CurDAG->getNode(ISD::HANDLENODE, MVT::Other, N);
05868     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Dummy.Val, 0);
05869     SelectionDAG::InsertISelMapEntry(HandleMap, N.Val, 1, Dummy.Val, 0);
05870     Result = Dummy;
05871     return;
05872   }
05873   SDOperand Chain(0, 0);
05874   SDOperand N1(0, 0);
05875   SDOperand Tmp0(0, 0);
05876   SDOperand Tmp1(0, 0);
05877   SDNode *ResNode;
05878   Chain = N.getOperand(0);
05879   N1 = N.getOperand(1);
05880 
05881   // Pattern: (load:i32 iaddr:i32:$src)
05882   // Emits: (LWZ:i32 iaddr:i32:$src)
05883   // Pattern complexity = 8  cost = 1
05884   if (N.Val->getValueType(0) == MVT::i32 &&
05885       SelectAddrImm(N1, Tmp0, Tmp1)) {
05886     Select(Tmp0, Tmp0);
05887     Select(Tmp1, Tmp1);
05888     Select(Chain, Chain);
05889     ResNode = CurDAG->getTargetNode(PPC::LWZ, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain);
05890     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
05891     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
05892     if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
05893     Result = SDOperand(ResNode, N.ResNo);
05894     return;
05895   }
05896 
05897   // Pattern: (load:f32 iaddr:i32:$src)
05898   // Emits: (LFS:f32 iaddr:i32:$src)
05899   // Pattern complexity = 8  cost = 1
05900   if (N.Val->getValueType(0) == MVT::f32 &&
05901       SelectAddrImm(N1, Tmp0, Tmp1)) {
05902     Select(Tmp0, Tmp0);
05903     Select(Tmp1, Tmp1);
05904     Select(Chain, Chain);
05905     ResNode = CurDAG->getTargetNode(PPC::LFS, MVT::f32, MVT::Other, Tmp0, Tmp1, Chain);
05906     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
05907     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
05908     if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
05909     Result = SDOperand(ResNode, N.ResNo);
05910     return;
05911   }
05912 
05913   // Pattern: (load:f64 iaddr:i32:$src)
05914   // Emits: (LFD:f64 iaddr:i32:$src)
05915   // Pattern complexity = 8  cost = 1
05916   if (N.Val->getValueType(0) == MVT::f64 &&
05917       SelectAddrImm(N1, Tmp0, Tmp1)) {
05918     Select(Tmp0, Tmp0);
05919     Select(Tmp1, Tmp1);
05920     Select(Chain, Chain);
05921     ResNode = CurDAG->getTargetNode(PPC::LFD, MVT::f64, MVT::Other, Tmp0, Tmp1, Chain);
05922     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
05923     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
05924     if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
05925     Result = SDOperand(ResNode, N.ResNo);
05926     return;
05927   }
05928 
05929   // Pattern: (load:i32 xaddr:i32:$src)
05930   // Emits: (LWZX:i32 xaddr:i32:$src)
05931   // Pattern complexity = 8  cost = 1
05932   if (N.Val->getValueType(0) == MVT::i32 &&
05933       SelectAddrIdx(N1, Tmp0, Tmp1)) {
05934     Select(Tmp0, Tmp0);
05935     Select(Tmp1, Tmp1);
05936     Select(Chain, Chain);
05937     ResNode = CurDAG->getTargetNode(PPC::LWZX, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain);
05938     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
05939     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
05940     if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
05941     Result = SDOperand(ResNode, N.ResNo);
05942     return;
05943   }
05944 
05945   // Pattern: (load:i64 xaddr:i32:$src)
05946   // Emits: (LDX:i64 xaddr:i32:$src)
05947   // Pattern complexity = 8  cost = 1
05948   if (N.Val->getValueType(0) == MVT::i64 &&
05949       SelectAddrIdx(N1, Tmp0, Tmp1)) {
05950     Select(Tmp0, Tmp0);
05951     Select(Tmp1, Tmp1);
05952     Select(Chain, Chain);
05953     ResNode = CurDAG->getTargetNode(PPC::LDX, MVT::i64, MVT::Other, Tmp0, Tmp1, Chain);
05954     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
05955     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
05956     if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
05957     Result = SDOperand(ResNode, N.ResNo);
05958     return;
05959   }
05960 
05961   // Pattern: (load:f32 xaddr:i32:$src)
05962   // Emits: (LFSX:f32 xaddr:i32:$src)
05963   // Pattern complexity = 8  cost = 1
05964   if (N.Val->getValueType(0) == MVT::f32 &&
05965       SelectAddrIdx(N1, Tmp0, Tmp1)) {
05966     Select(Tmp0, Tmp0);
05967     Select(Tmp1, Tmp1);
05968     Select(Chain, Chain);
05969     ResNode = CurDAG->getTargetNode(PPC::LFSX, MVT::f32, MVT::Other, Tmp0, Tmp1, Chain);
05970     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
05971     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
05972     if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
05973     Result = SDOperand(ResNode, N.ResNo);
05974     return;
05975   }
05976 
05977   // Pattern: (load:f64 xaddr:i32:$src)
05978   // Emits: (LFDX:f64 xaddr:i32:$src)
05979   // Pattern complexity = 8  cost = 1
05980   if (N.Val->getValueType(0) == MVT::f64 &&
05981       SelectAddrIdx(N1, Tmp0, Tmp1)) {
05982     Select(Tmp0, Tmp0);
05983     Select(Tmp1, Tmp1);
05984     Select(Chain, Chain);
05985     ResNode = CurDAG->getTargetNode(PPC::LFDX, MVT::f64, MVT::Other, Tmp0, Tmp1, Chain);
05986     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
05987     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
05988     if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
05989     Result = SDOperand(ResNode, N.ResNo);
05990     return;
05991   }
05992 
05993   // Pattern: (load:v16i8 xoaddr:i32:$src)
05994   // Emits: (LVX:v16i8 xoaddr:i32:$src)
05995   // Pattern complexity = 8  cost = 1
05996   if (N.Val->getValueType(0) == MVT::v16i8 &&
05997       SelectAddrIdxOnly(N1, Tmp0, Tmp1)) {
05998     Select(Tmp0, Tmp0);
05999     Select(Tmp1, Tmp1);
06000     Select(Chain, Chain);
06001     ResNode = CurDAG->getTargetNode(PPC::LVX, MVT::v16i8, MVT::Other, Tmp0, Tmp1, Chain);
06002     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
06003     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
06004     if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
06005     Result = SDOperand(ResNode, N.ResNo);
06006     return;
06007   }
06008 
06009   // Pattern: (load:v8i16 xoaddr:i32:$src)
06010   // Emits: (LVX:v8i16 xoaddr:i32:$src)
06011   // Pattern complexity = 8  cost = 1
06012   if (N.Val->getValueType(0) == MVT::v8i16 &&
06013       SelectAddrIdxOnly(N1, Tmp0, Tmp1)) {
06014     Select(Tmp0, Tmp0);
06015     Select(Tmp1, Tmp1);
06016     Select(Chain, Chain);
06017     ResNode = CurDAG->getTargetNode(PPC::LVX, MVT::v8i16, MVT::Other, Tmp0, Tmp1, Chain);
06018     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
06019     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
06020     if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
06021     Result = SDOperand(ResNode, N.ResNo);
06022     return;
06023   }
06024 
06025   // Pattern: (load:v4i32 xoaddr:i32:$src)
06026   // Emits: (LVX:v4i32 xoaddr:i32:$src)
06027   // Pattern complexity = 8  cost = 1
06028   if (N.Val->getValueType(0) == MVT::v4i32 &&
06029       SelectAddrIdxOnly(N1, Tmp0, Tmp1)) {
06030     Select(Tmp0, Tmp0);
06031     Select(Tmp1, Tmp1);
06032     Select(Chain, Chain);
06033     ResNode = CurDAG->getTargetNode(PPC::LVX, MVT::v4i32, MVT::Other, Tmp0, Tmp1, Chain);
06034     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
06035     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
06036     if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
06037     Result = SDOperand(ResNode, N.ResNo);
06038     return;
06039   }
06040 
06041   // Pattern: (load:v4f32 xoaddr:i32:$src)
06042   // Emits: (LVX:v4f32 xoaddr:i32:$src)
06043   // Pattern complexity = 8  cost = 1
06044   if (N.Val->getValueType(0) == MVT::v4f32 &&
06045       SelectAddrIdxOnly(N1, Tmp0, Tmp1)) {
06046     Select(Tmp0, Tmp0);
06047     Select(Tmp1, Tmp1);
06048     Select(Chain, Chain);
06049     ResNode = CurDAG->getTargetNode(PPC::LVX, MVT::v4f32, MVT::Other, Tmp0, Tmp1, Chain);
06050     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
06051     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
06052     if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
06053     Result = SDOperand(ResNode, N.ResNo);
06054     return;
06055   }
06056   std::cerr << "Cannot yet select: ";
06057   N.Val->dump(CurDAG);
06058   std::cerr << '\n';
06059   abort();
06060 }
06061 
06062 void Select_mul(SDOperand &Result, SDOperand N) {
06063   SDOperand N0(0, 0);
06064   SDOperand N1(0, 0);
06065   SDOperand Tmp0(0, 0);
06066   SDOperand Tmp1(0, 0);
06067   SDNode *ResNode;
06068   N0 = N.getOperand(0);
06069   N1 = N.getOperand(1);
06070 
06071   // Pattern: (mul:i32 GPRC:i32:$rA, (imm:i32)<<P:Predicate_immSExt16>>:$imm)
06072   // Emits: (MULLI:i32 GPRC:i32:$rA, (imm:i32):$imm)
06073   // Pattern complexity = 5  cost = 1
06074   if (N1.getOpcode() == ISD::Constant &&
06075       Predicate_immSExt16(N1.Val) &&
06076       N.Val->getValueType(0) == MVT::i32) {
06077     Select(Tmp0, N0);
06078     unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
06079     Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
06080     if (N.Val->hasOneUse()) {
06081       Result = CurDAG->SelectNodeTo(N.Val, PPC::MULLI, MVT::i32, Tmp0, Tmp1);
06082     } else {
06083       ResNode = CurDAG->getTargetNode(PPC::MULLI, MVT::i32, Tmp0, Tmp1);
06084       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06085       Result = SDOperand(ResNode, 0);
06086     }
06087     return;
06088   }
06089 
06090   // Pattern: (mul:i64 G8RC:i64:$rA, G8RC:i64:$rB)
06091   // Emits: (MULLD:i64 G8RC:i64:$rA, G8RC:i64:$rB)
06092   // Pattern complexity = 2  cost = 1
06093   if (N.Val->getValueType(0) == MVT::i64) {
06094     Select(Tmp0, N0);
06095     Select(Tmp1, N1);
06096     if (N.Val->hasOneUse()) {
06097       Result = CurDAG->SelectNodeTo(N.Val, PPC::MULLD, MVT::i64, Tmp0, Tmp1);
06098     } else {
06099       ResNode = CurDAG->getTargetNode(PPC::MULLD, MVT::i64, Tmp0, Tmp1);
06100       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06101       Result = SDOperand(ResNode, 0);
06102     }
06103     return;
06104   }
06105 
06106   // Pattern: (mul:i32 GPRC:i32:$rA, GPRC:i32:$rB)
06107   // Emits: (MULLW:i32 GPRC:i32:$rA, GPRC:i32:$rB)
06108   // Pattern complexity = 2  cost = 1
06109   if (N.Val->getValueType(0) == MVT::i32) {
06110     Select(Tmp0, N0);
06111     Select(Tmp1, N1);
06112     if (N.Val->hasOneUse()) {
06113       Result = CurDAG->SelectNodeTo(N.Val, PPC::MULLW, MVT::i32, Tmp0, Tmp1);
06114     } else {
06115       ResNode = CurDAG->getTargetNode(PPC::MULLW, MVT::i32, Tmp0, Tmp1);
06116       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06117       Result = SDOperand(ResNode, 0);
06118     }
06119     return;
06120   }
06121   std::cerr << "Cannot yet select: ";
06122   N.Val->dump(CurDAG);
06123   std::cerr << '\n';
06124   abort();
06125 }
06126 
06127 void Select_mulhs(SDOperand &Result, SDOperand N) {
06128   SDOperand N0(0, 0);
06129   SDOperand N1(0, 0);
06130   SDOperand Tmp0(0, 0);
06131   SDOperand Tmp1(0, 0);
06132   SDNode *ResNode;
06133   N0 = N.getOperand(0);
06134   N1 = N.getOperand(1);
06135 
06136   // Pattern: (mulhs:i64 G8RC:i64:$rA, G8RC:i64:$rB)
06137   // Emits: (MULHD:i64 G8RC:i64:$rA, G8RC:i64:$rB)
06138   // Pattern complexity = 2  cost = 1
06139   if (N.Val->getValueType(0) == MVT::i64) {
06140     Select(Tmp0, N0);
06141     Select(Tmp1, N1);
06142     if (N.Val->hasOneUse()) {
06143       Result = CurDAG->SelectNodeTo(N.Val, PPC::MULHD, MVT::i64, Tmp0, Tmp1);
06144     } else {
06145       ResNode = CurDAG->getTargetNode(PPC::MULHD, MVT::i64, Tmp0, Tmp1);
06146       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06147       Result = SDOperand(ResNode, 0);
06148     }
06149     return;
06150   }
06151 
06152   // Pattern: (mulhs:i32 GPRC:i32:$rA, GPRC:i32:$rB)
06153   // Emits: (MULHW:i32 GPRC:i32:$rA, GPRC:i32:$rB)
06154   // Pattern complexity = 2  cost = 1
06155   if (N.Val->getValueType(0) == MVT::i32) {
06156     Select(Tmp0, N0);
06157     Select(Tmp1, N1);
06158     if (N.Val->hasOneUse()) {
06159       Result = CurDAG->SelectNodeTo(N.Val, PPC::MULHW, MVT::i32, Tmp0, Tmp1);
06160     } else {
06161       ResNode = CurDAG->getTargetNode(PPC::MULHW, MVT::i32, Tmp0, Tmp1);
06162       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06163       Result = SDOperand(ResNode, 0);
06164     }
06165     return;
06166   }
06167   std::cerr << "Cannot yet select: ";
06168   N.Val->dump(CurDAG);
06169   std::cerr << '\n';
06170   abort();
06171 }
06172 
06173 void Select_mulhu(SDOperand &Result, SDOperand N) {
06174   SDOperand N0(0, 0);
06175   SDOperand N1(0, 0);
06176   SDOperand Tmp0(0, 0);
06177   SDOperand Tmp1(0, 0);
06178   SDNode *ResNode;
06179   N0 = N.getOperand(0);
06180   N1 = N.getOperand(1);
06181 
06182   // Pattern: (mulhu:i64 G8RC:i64:$rA, G8RC:i64:$rB)
06183   // Emits: (MULHDU:i64 G8RC:i64:$rA, G8RC:i64:$rB)
06184   // Pattern complexity = 2  cost = 1
06185   if (N.Val->getValueType(0) == MVT::i64) {
06186     Select(Tmp0, N0);
06187     Select(Tmp1, N1);
06188     if (N.Val->hasOneUse()) {
06189       Result = CurDAG->SelectNodeTo(N.Val, PPC::MULHDU, MVT::i64, Tmp0, Tmp1);
06190     } else {
06191       ResNode = CurDAG->getTargetNode(PPC::MULHDU, MVT::i64, Tmp0, Tmp1);
06192       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06193       Result = SDOperand(ResNode, 0);
06194     }
06195     return;
06196   }
06197 
06198   // Pattern: (mulhu:i32 GPRC:i32:$rA, GPRC:i32:$rB)
06199   // Emits: (MULHWU:i32 GPRC:i32:$rA, GPRC:i32:$rB)
06200   // Pattern complexity = 2  cost = 1
06201   if (N.Val->getValueType(0) == MVT::i32) {
06202     Select(Tmp0, N0);
06203     Select(Tmp1, N1);
06204     if (N.Val->hasOneUse()) {
06205       Result = CurDAG->SelectNodeTo(N.Val, PPC::MULHWU, MVT::i32, Tmp0, Tmp1);
06206     } else {
06207       ResNode = CurDAG->getTargetNode(PPC::MULHWU, MVT::i32, Tmp0, Tmp1);
06208       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06209       Result = SDOperand(ResNode, 0);
06210     }
06211     return;
06212   }
06213   std::cerr << "Cannot yet select: ";
06214   N.Val->dump(CurDAG);
06215   std::cerr << '\n';
06216   abort();
06217 }
06218 
06219 void Select_or(SDOperand &Result, SDOperand N) {
06220   SDOperand N0(0, 0);
06221   SDOperand N00(0, 0);
06222   SDOperand N01(0, 0);
06223   SDOperand N1(0, 0);
06224   SDOperand N10(0, 0);
06225   SDOperand N11(0, 0);
06226   SDOperand Tmp0(0, 0);
06227   SDOperand Tmp1(0, 0);
06228   SDOperand Tmp2(0, 0);
06229   SDOperand Tmp3(0, 0);
06230   SDOperand Tmp4(0, 0);
06231   SDNode *ResNode;
06232   N0 = N.getOperand(0);
06233 
06234   // Pattern: (or:i32 GPRC:i32:$rS, (xor:i32 GPRC:i32:$rB, (imm:i32)<<P:Predicate_immAllOnes>>))
06235   // Emits: (ORC:i32 GPRC:i32:$rS, GPRC:i32:$rB)
06236   // Pattern complexity = 7  cost = 1
06237   {
06238     N1 = N.getOperand(1);
06239     if (N1.getOpcode() == ISD::XOR) {
06240       N10 = N1.getOperand(0);
06241       N11 = N1.getOperand(1);
06242       if (N11.getOpcode() == ISD::Constant &&
06243           Predicate_immAllOnes(N11.Val) &&
06244           N.Val->getValueType(0) == MVT::i32) {
06245         Select(Tmp0, N0);
06246         Select(Tmp1, N10);
06247         if (N.Val->hasOneUse()) {
06248           Result = CurDAG->SelectNodeTo(N.Val, PPC::ORC, MVT::i32, Tmp0, Tmp1);
06249         } else {
06250           ResNode = CurDAG->getTargetNode(PPC::ORC, MVT::i32, Tmp0, Tmp1);
06251           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06252           Result = SDOperand(ResNode, 0);
06253         }
06254         return;
06255       }
06256     }
06257   }
06258 
06259   // Pattern: (or:i32 (xor:i32 GPRC:i32:$rB, (imm:i32)<<P:Predicate_immAllOnes>>), GPRC:i32:$rS)
06260   // Emits: (ORC:i32 GPRC:i32:$rS, GPRC:i32:$rB)
06261   // Pattern complexity = 7  cost = 1
06262   if (N0.getOpcode() == ISD::XOR) {
06263     N00 = N0.getOperand(0);
06264     N01 = N0.getOperand(1);
06265     if (N01.getOpcode() == ISD::Constant &&
06266         Predicate_immAllOnes(N01.Val)) {
06267       N1 = N.getOperand(1);
06268       if (N.Val->getValueType(0) == MVT::i32) {
06269         Select(Tmp0, N1);
06270         Select(Tmp1, N00);
06271         if (N.Val->hasOneUse()) {
06272           Result = CurDAG->SelectNodeTo(N.Val, PPC::ORC, MVT::i32, Tmp0, Tmp1);
06273         } else {
06274           ResNode = CurDAG->getTargetNode(PPC::ORC, MVT::i32, Tmp0, Tmp1);
06275           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06276           Result = SDOperand(ResNode, 0);
06277         }
06278         return;
06279       }
06280     }
06281   }
06282   N1 = N.getOperand(1);
06283   if (N1.getOpcode() == ISD::Constant) {
06284 
06285     // Pattern: (or:i32 GPRC:i32:$src1, (imm:i32)<<P:Predicate_immZExt16>><<X:LO16>>:$src2)
06286     // Emits: (ORI:i32 GPRC:i32:$src1, (LO16:i32 (imm:i32):$src2))
06287     // Pattern complexity = 5  cost = 1
06288     if (Predicate_immZExt16(N1.Val) &&
06289         N.Val->getValueType(0) == MVT::i32) {
06290       Select(Tmp0, N0);
06291       unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
06292       Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
06293       Tmp2 = Transform_LO16(Tmp1.Val);
06294       if (N.Val->hasOneUse()) {
06295         Result = CurDAG->SelectNodeTo(N.Val, PPC::ORI, MVT::i32, Tmp0, Tmp2);
06296       } else {
06297         ResNode = CurDAG->getTargetNode(PPC::ORI, MVT::i32, Tmp0, Tmp2);
06298         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06299         Result = SDOperand(ResNode, 0);
06300       }
06301       return;
06302     }
06303 
06304     // Pattern: (or:i32 GPRC:i32:$src1, (imm:i32)<<P:Predicate_imm16Shifted>><<X:HI16>>:$src2)
06305     // Emits: (ORIS:i32 GPRC:i32:$src1, (HI16:i32 (imm:i32):$src2))
06306     // Pattern complexity = 5  cost = 1
06307     if (Predicate_imm16Shifted(N1.Val) &&
06308         N.Val->getValueType(0) == MVT::i32) {
06309       Select(Tmp0, N0);
06310       unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
06311       Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
06312       Tmp2 = Transform_HI16(Tmp1.Val);
06313       if (N.Val->hasOneUse()) {
06314         Result = CurDAG->SelectNodeTo(N.Val, PPC::ORIS, MVT::i32, Tmp0, Tmp2);
06315       } else {
06316         ResNode = CurDAG->getTargetNode(PPC::ORIS, MVT::i32, Tmp0, Tmp2);
06317         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06318         Result = SDOperand(ResNode, 0);
06319       }
06320       return;
06321     }
06322 
06323     // Pattern: (or:i32 GPRC:i32:$in, (imm:i32):$imm)
06324     // Emits: (ORIS:i32 (ORI:i32 GPRC:i32:$in, (LO16:i32 (imm:i32):$imm)), (HI16:i32 (imm:i32):$imm))
06325     // Pattern complexity = 4  cost = 2
06326     if (N.Val->getValueType(0) == MVT::i32) {
06327       Select(Tmp0, N0);
06328       unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
06329       Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
06330       Tmp2 = Transform_LO16(Tmp1.Val);
06331       Tmp3 = SDOperand(CurDAG->getTargetNode(PPC::ORI, MVT::i32, Tmp0, Tmp2), 0);
06332       Tmp4 = Transform_HI16(Tmp1.Val);
06333       if (N.Val->hasOneUse()) {
06334         Result = CurDAG->SelectNodeTo(N.Val, PPC::ORIS, MVT::i32, Tmp3, Tmp4);
06335       } else {
06336         ResNode = CurDAG->getTargetNode(PPC::ORIS, MVT::i32, Tmp3, Tmp4);
06337         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06338         Result = SDOperand(ResNode, 0);
06339       }
06340       return;
06341     }
06342   }
06343 
06344   // Pattern: (or:i32 GPRC:i32:$rS, GPRC:i32:$rB)
06345   // Emits: (OR4:i32 GPRC:i32:$rS, GPRC:i32:$rB)
06346   // Pattern complexity = 2  cost = 1
06347   if (N.Val->getValueType(0) == MVT::i32) {
06348     Select(Tmp0, N0);
06349     Select(Tmp1, N1);
06350     if (N.Val->hasOneUse()) {
06351       Result = CurDAG->SelectNodeTo(N.Val, PPC::OR4, MVT::i32, Tmp0, Tmp1);
06352     } else {
06353       ResNode = CurDAG->getTargetNode(PPC::OR4, MVT::i32, Tmp0, Tmp1);
06354       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06355       Result = SDOperand(ResNode, 0);
06356     }
06357     return;
06358   }
06359 
06360   // Pattern: (or:i64 G8RC:i64:$rS, G8RC:i64:$rB)
06361   // Emits: (OR8:i64 G8RC:i64:$rS, G8RC:i64:$rB)
06362   // Pattern complexity = 2  cost = 1
06363   if (N.Val->getValueType(0) == MVT::i64) {
06364     Select(Tmp0, N0);
06365     Select(Tmp1, N1);
06366     if (N.Val->hasOneUse()) {
06367       Result = CurDAG->SelectNodeTo(N.Val, PPC::OR8, MVT::i64, Tmp0, Tmp1);
06368     } else {
06369       ResNode = CurDAG->getTargetNode(PPC::OR8, MVT::i64, Tmp0, Tmp1);
06370       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06371       Result = SDOperand(ResNode, 0);
06372     }
06373     return;
06374   }
06375 
06376   // Pattern: (or:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
06377   // Emits: (VOR:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
06378   // Pattern complexity = 2  cost = 1
06379   if (N.Val->getValueType(0) == MVT::v4i32) {
06380     Select(Tmp0, N0);
06381     Select(Tmp1, N1);
06382     if (N.Val->hasOneUse()) {
06383       Result = CurDAG->SelectNodeTo(N.Val, PPC::VOR, MVT::v4i32, Tmp0, Tmp1);
06384     } else {
06385       ResNode = CurDAG->getTargetNode(PPC::VOR, MVT::v4i32, Tmp0, Tmp1);
06386       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06387       Result = SDOperand(ResNode, 0);
06388     }
06389     return;
06390   }
06391 
06392   // Pattern: (or:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B)
06393   // Emits: (VOR:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B)
06394   // Pattern complexity = 2  cost = 1
06395   if (N.Val->getValueType(0) == MVT::v16i8) {
06396     Select(Tmp0, N0);
06397     Select(Tmp1, N1);
06398     if (N.Val->hasOneUse()) {
06399       Result = CurDAG->SelectNodeTo(N.Val, PPC::VOR, MVT::v16i8, Tmp0, Tmp1);
06400     } else {
06401       ResNode = CurDAG->getTargetNode(PPC::VOR, MVT::v16i8, Tmp0, Tmp1);
06402       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06403       Result = SDOperand(ResNode, 0);
06404     }
06405     return;
06406   }
06407 
06408   // Pattern: (or:v8i16 VRRC:v8i16:$A, VRRC:v8i16:$B)
06409   // Emits: (VOR:v8i16 VRRC:v16i8:$A, VRRC:v16i8:$B)
06410   // Pattern complexity = 2  cost = 1
06411   if (N.Val->getValueType(0) == MVT::v8i16) {
06412     Select(Tmp0, N0);
06413     Select(Tmp1, N1);
06414     if (N.Val->hasOneUse()) {
06415       Result = CurDAG->SelectNodeTo(N.Val, PPC::VOR, MVT::v8i16, Tmp0, Tmp1);
06416     } else {
06417       ResNode = CurDAG->getTargetNode(PPC::VOR, MVT::v8i16, Tmp0, Tmp1);
06418       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06419       Result = SDOperand(ResNode, 0);
06420     }
06421     return;
06422   }
06423   std::cerr << "Cannot yet select: ";
06424   N.Val->dump(CurDAG);
06425   std::cerr << '\n';
06426   abort();
06427 }
06428 
06429 void Select_ret(SDOperand &Result, SDOperand N) {
06430   SDOperand Chain(0, 0);
06431   SDNode *ResNode;
06432   Chain = N.getOperand(0);
06433   Select(Chain, Chain);
06434   ResNode = CurDAG->getTargetNode(PPC::BLR, MVT::Other, Chain);
06435   SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
06436   Result = SDOperand(ResNode, N.ResNo);
06437   return;
06438 }
06439 
06440 void Select_retflag(SDOperand &Result, SDOperand N) {
06441   SDOperand Chain(0, 0);
06442   SDOperand InFlag(0, 0);
06443   SDNode *ResNode;
06444   Chain = N.getOperand(0);
06445   bool HasOptInFlag = false;
06446   Select(Chain, Chain);
06447   if (N.getNumOperands() == 2) {
06448     Select(InFlag, N.getOperand(1));
06449     HasOptInFlag = true;
06450   }
06451   if (HasOptInFlag)
06452     ResNode = CurDAG->getTargetNode(PPC::BLR, MVT::Other, Chain, InFlag);
06453   else
06454     ResNode = CurDAG->getTargetNode(PPC::BLR, MVT::Other, Chain);
06455   SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
06456   Result = SDOperand(ResNode, N.ResNo);
06457   return;
06458 }
06459 
06460 void Select_rotl(SDOperand &Result, SDOperand N) {
06461   SDOperand N0(0, 0);
06462   SDOperand N1(0, 0);
06463   SDOperand Tmp0(0, 0);
06464   SDOperand Tmp1(0, 0);
06465   SDOperand Tmp2(0, 0);
06466   SDOperand Tmp3(0, 0);
06467   SDNode *ResNode;
06468   N0 = N.getOperand(0);
06469   N1 = N.getOperand(1);
06470 
06471   // Pattern: (rotl:i32 GPRC:i32:$in, (imm:i32):$imm)
06472   // Emits: (RLWINM:i32 GPRC:i32:$in, (imm:i32):$imm, 0:i32, 31:i32)
06473   // Pattern complexity = 4  cost = 1
06474   if (N1.getOpcode() == ISD::Constant &&
06475       N.Val->getValueType(0) == MVT::i32 &&
06476       N1.Val->getValueType(0) == MVT::i32) {
06477     Select(Tmp0, N0);
06478     unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
06479     Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
06480     Tmp2 = CurDAG->getTargetConstant(0, MVT::i32);
06481     Tmp3 = CurDAG->getTargetConstant(31, MVT::i32);
06482     if (N.Val->hasOneUse()) {
06483       Result = CurDAG->SelectNodeTo(N.Val, PPC::RLWINM, MVT::i32, Tmp0, Tmp1, Tmp2, Tmp3);
06484     } else {
06485       ResNode = CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Tmp0, Tmp1, Tmp2, Tmp3);
06486       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06487       Result = SDOperand(ResNode, 0);
06488     }
06489     return;
06490   }
06491 
06492   // Pattern: (rotl:i32 GPRC:i32:$in, GPRC:i32:$sh)
06493   // Emits: (RLWNM:i32 GPRC:i32:$in, GPRC:i32:$sh, 0:i32, 31:i32)
06494   // Pattern complexity = 2  cost = 1
06495   if (N.Val->getValueType(0) == MVT::i32 &&
06496       N1.Val->getValueType(0) == MVT::i32) {
06497     Select(Tmp0, N0);
06498     Select(Tmp1, N1);
06499     Tmp2 = CurDAG->getTargetConstant(0, MVT::i32);
06500     Tmp3 = CurDAG->getTargetConstant(31, MVT::i32);
06501     if (N.Val->hasOneUse()) {
06502       Result = CurDAG->SelectNodeTo(N.Val, PPC::RLWNM, MVT::i32, Tmp0, Tmp1, Tmp2, Tmp3);
06503     } else {
06504       ResNode = CurDAG->getTargetNode(PPC::RLWNM, MVT::i32, Tmp0, Tmp1, Tmp2, Tmp3);
06505       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06506       Result = SDOperand(ResNode, 0);
06507     }
06508     return;
06509   }
06510   std::cerr << "Cannot yet select: ";
06511   N.Val->dump(CurDAG);
06512   std::cerr << '\n';
06513   abort();
06514 }
06515 
06516 void Select_sdiv(SDOperand &Result, SDOperand N) {
06517   SDOperand N0(0, 0);
06518   SDOperand N1(0, 0);
06519   SDOperand Tmp0(0, 0);
06520   SDOperand Tmp1(0, 0);
06521   SDNode *ResNode;
06522   N0 = N.getOperand(0);
06523   N1 = N.getOperand(1);
06524 
06525   // Pattern: (sdiv:i64 G8RC:i64:$rA, G8RC:i64:$rB)
06526   // Emits: (DIVD:i64 G8RC:i64:$rA, G8RC:i64:$rB)
06527   // Pattern complexity = 2  cost = 1
06528   if (N.Val->getValueType(0) == MVT::i64) {
06529     Select(Tmp0, N0);
06530     Select(Tmp1, N1);
06531     if (N.Val->hasOneUse()) {
06532       Result = CurDAG->SelectNodeTo(N.Val, PPC::DIVD, MVT::i64, Tmp0, Tmp1);
06533     } else {
06534       ResNode = CurDAG->getTargetNode(PPC::DIVD, MVT::i64, Tmp0, Tmp1);
06535       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06536       Result = SDOperand(ResNode, 0);
06537     }
06538     return;
06539   }
06540 
06541   // Pattern: (sdiv:i32 GPRC:i32:$rA, GPRC:i32:$rB)
06542   // Emits: (DIVW:i32 GPRC:i32:$rA, GPRC:i32:$rB)
06543   // Pattern complexity = 2  cost = 1
06544   if (N.Val->getValueType(0) == MVT::i32) {
06545     Select(Tmp0, N0);
06546     Select(Tmp1, N1);
06547     if (N.Val->hasOneUse()) {
06548       Result = CurDAG->SelectNodeTo(N.Val, PPC::DIVW, MVT::i32, Tmp0, Tmp1);
06549     } else {
06550       ResNode = CurDAG->getTargetNode(PPC::DIVW, MVT::i32, Tmp0, Tmp1);
06551       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06552       Result = SDOperand(ResNode, 0);
06553     }
06554     return;
06555   }
06556   std::cerr << "Cannot yet select: ";
06557   N.Val->dump(CurDAG);
06558   std::cerr << '\n';
06559   abort();
06560 }
06561 
06562 void Select_sext_inreg(SDOperand &Result, SDOperand N) {
06563   SDOperand N0(0, 0);
06564   SDOperand N1(0, 0);
06565   SDOperand Tmp0(0, 0);
06566   SDNode *ResNode;
06567   N0 = N.getOperand(0);
06568   N1 = N.getOperand(1);
06569 
06570   // Pattern: (sext_inreg:i32 GPRC:i32:$rS, i8:Other)
06571   // Emits: (EXTSB:i32 GPRC:i32:$rS)
06572   // Pattern complexity = 2  cost = 1
06573   if (cast<VTSDNode>(N1)->getVT() == MVT::i8 &&
06574       N.Val->getValueType(0) == MVT::i32) {
06575     Select(Tmp0, N0);
06576     if (N.Val->hasOneUse()) {
06577       Result = CurDAG->SelectNodeTo(N.Val, PPC::EXTSB, MVT::i32, Tmp0);
06578     } else {
06579       ResNode = CurDAG->getTargetNode(PPC::EXTSB, MVT::i32, Tmp0);
06580       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06581       Result = SDOperand(ResNode, 0);
06582     }
06583     return;
06584   }
06585 
06586   // Pattern: (sext_inreg:i32 GPRC:i32:$rS, i16:Other)
06587   // Emits: (EXTSH:i32 GPRC:i32:$rS)
06588   // Pattern complexity = 2  cost = 1
06589   if (cast<VTSDNode>(N1)->getVT() == MVT::i16 &&
06590       N.Val->getValueType(0) == MVT::i32) {
06591     Select(Tmp0, N0);
06592     if (N.Val->hasOneUse()) {
06593       Result = CurDAG->SelectNodeTo(N.Val, PPC::EXTSH, MVT::i32, Tmp0);
06594     } else {
06595       ResNode = CurDAG->getTargetNode(PPC::EXTSH, MVT::i32, Tmp0);
06596       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06597       Result = SDOperand(ResNode, 0);
06598     }
06599     return;
06600   }
06601 
06602   // Pattern: (sext_inreg:i64 G8RC:i64:$rS, i32:Other)
06603   // Emits: (EXTSW:i64 G8RC:i64:$rS)
06604   // Pattern complexity = 2  cost = 1
06605   if (cast<VTSDNode>(N1)->getVT() == MVT::i32 &&
06606       N.Val->getValueType(0) == MVT::i64) {
06607     Select(Tmp0, N0);
06608     if (N.Val->hasOneUse()) {
06609       Result = CurDAG->SelectNodeTo(N.Val, PPC::EXTSW, MVT::i64, Tmp0);
06610     } else {
06611       ResNode = CurDAG->getTargetNode(PPC::EXTSW, MVT::i64, Tmp0);
06612       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06613       Result = SDOperand(ResNode, 0);
06614     }
06615     return;
06616   }
06617   std::cerr << "Cannot yet select: ";
06618   N.Val->dump(CurDAG);
06619   std::cerr << '\n';
06620   abort();
06621 }
06622 
06623 void Select_sextld(SDOperand &Result, SDOperand N) {
06624   if (N.ResNo == 1 && N.getValue(0).hasOneUse()) {
06625     SDOperand Dummy = CurDAG->getNode(ISD::HANDLENODE, MVT::Other, N);
06626     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Dummy.Val, 0);
06627     SelectionDAG::InsertISelMapEntry(HandleMap, N.Val, 1, Dummy.Val, 0);
06628     Result = Dummy;
06629     return;
06630   }
06631   SDOperand Chain(0, 0);
06632   SDOperand N1(0, 0);
06633   SDOperand N2(0, 0);
06634   SDOperand N3(0, 0);
06635   SDOperand Tmp0(0, 0);
06636   SDOperand Tmp1(0, 0);
06637   SDNode *ResNode;
06638   Chain = N.getOperand(0);
06639   N1 = N.getOperand(1);
06640   N2 = N.getOperand(2);
06641   N3 = N.getOperand(3);
06642   if (cast<VTSDNode>(N3)->getVT() == MVT::i16 &&
06643       N.Val->getValueType(0) == MVT::i32) {
06644 
06645     // Pattern: (sextld:i32 iaddr:i32:$src, srcvalue:Other:$dummy, i16:Other)
06646     // Emits: (LHA:i32 iaddr:i32:$src)
06647     // Pattern complexity = 8  cost = 1
06648     if (SelectAddrImm(N1, Tmp0, Tmp1)) {
06649       Select(Tmp0, Tmp0);
06650       Select(Tmp1, Tmp1);
06651       Select(Chain, Chain);
06652       ResNode = CurDAG->getTargetNode(PPC::LHA, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain);
06653       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
06654       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
06655       if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
06656       Result = SDOperand(ResNode, N.ResNo);
06657       return;
06658     }
06659 
06660     // Pattern: (sextld:i32 xaddr:i32:$src, srcvalue:Other:$dummy, i16:Other)
06661     // Emits: (LHAX:i32 xaddr:i32:$src)
06662     // Pattern complexity = 8  cost = 1
06663     if (SelectAddrIdx(N1, Tmp0, Tmp1)) {
06664       Select(Tmp0, Tmp0);
06665       Select(Tmp1, Tmp1);
06666       Select(Chain, Chain);
06667       ResNode = CurDAG->getTargetNode(PPC::LHAX, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain);
06668       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
06669       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
06670       if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
06671       Result = SDOperand(ResNode, N.ResNo);
06672       return;
06673     }
06674   }
06675 
06676   // Pattern: (sextld:i64 xaddr:i32:$src, srcvalue:Other:$dummy, i32:Other)
06677   // Emits: (LWAX:i64 xaddr:i32:$src)
06678   // Pattern complexity = 8  cost = 1
06679   if (cast<VTSDNode>(N3)->getVT() == MVT::i32 &&
06680       N.Val->getValueType(0) == MVT::i64 &&
06681       SelectAddrIdx(N1, Tmp0, Tmp1)) {
06682     Select(Tmp0, Tmp0);
06683     Select(Tmp1, Tmp1);
06684     Select(Chain, Chain);
06685     ResNode = CurDAG->getTargetNode(PPC::LWAX, MVT::i64, MVT::Other, Tmp0, Tmp1, Chain);
06686     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
06687     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
06688     if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
06689     Result = SDOperand(ResNode, N.ResNo);
06690     return;
06691   }
06692   std::cerr << "Cannot yet select: ";
06693   N.Val->dump(CurDAG);
06694   std::cerr << '\n';
06695   abort();
06696 }
06697 
06698 void Select_shl(SDOperand &Result, SDOperand N) {
06699   SDOperand N0(0, 0);
06700   SDOperand N1(0, 0);
06701   SDOperand Tmp0(0, 0);
06702   SDOperand Tmp1(0, 0);
06703   SDOperand Tmp2(0, 0);
06704   SDOperand Tmp3(0, 0);
06705   SDNode *ResNode;
06706   N0 = N.getOperand(0);
06707   N1 = N.getOperand(1);
06708   if (N1.getOpcode() == ISD::Constant) {
06709 
06710     // Pattern: (shl:i64 G8RC:i64:$in, (imm:i64):$imm)
06711     // Emits: (RLDICR:i64 G8RC:i64:$in, (imm:i32):$imm, (SHL64:i32 (imm:i32):$imm))
06712     // Pattern complexity = 4  cost = 1
06713     if (N.Val->getValueType(0) == MVT::i64 &&
06714         N1.Val->getValueType(0) == MVT::i64) {
06715       Select(Tmp0, N0);
06716       unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
06717       Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
06718       Tmp2 = Transform_SHL64(Tmp1.Val);
06719       if (N.Val->hasOneUse()) {
06720         Result = CurDAG->SelectNodeTo(N.Val, PPC::RLDICR, MVT::i64, Tmp0, Tmp1, Tmp2);
06721       } else {
06722         ResNode = CurDAG->getTargetNode(PPC::RLDICR, MVT::i64, Tmp0, Tmp1, Tmp2);
06723         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06724         Result = SDOperand(ResNode, 0);
06725       }
06726       return;
06727     }
06728 
06729     // Pattern: (shl:i32 GPRC:i32:$in, (imm:i32):$imm)
06730     // Emits: (RLWINM:i32 GPRC:i32:$in, (imm:i32):$imm, 0:i32, (SHL32:i32 (imm:i32):$imm))
06731     // Pattern complexity = 4  cost = 1
06732     if (N.Val->getValueType(0) == MVT::i32 &&
06733         N1.Val->getValueType(0) == MVT::i32) {
06734       Select(Tmp0, N0);
06735       unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
06736       Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
06737       Tmp2 = CurDAG->getTargetConstant(0, MVT::i32);
06738       Tmp3 = Transform_SHL32(Tmp1.Val);
06739       if (N.Val->hasOneUse()) {
06740         Result = CurDAG->SelectNodeTo(N.Val, PPC::RLWINM, MVT::i32, Tmp0, Tmp1, Tmp2, Tmp3);
06741       } else {
06742         ResNode = CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Tmp0, Tmp1, Tmp2, Tmp3);
06743         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06744         Result = SDOperand(ResNode, 0);
06745       }
06746       return;
06747     }
06748   }
06749 
06750   // Pattern: (shl:i64 G8RC:i64:$rS, G8RC:i64:$rB)
06751   // Emits: (SLD:i64 G8RC:i64:$rS, G8RC:i64:$rB)
06752   // Pattern complexity = 2  cost = 1
06753   if (N.Val->getValueType(0) == MVT::i64 &&
06754       N1.Val->getValueType(0) == MVT::i64) {
06755     Select(Tmp0, N0);
06756     Select(Tmp1, N1);
06757     if (N.Val->hasOneUse()) {
06758       Result = CurDAG->SelectNodeTo(N.Val, PPC::SLD, MVT::i64, Tmp0, Tmp1);
06759     } else {
06760       ResNode = CurDAG->getTargetNode(PPC::SLD, MVT::i64, Tmp0, Tmp1);
06761       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06762       Result = SDOperand(ResNode, 0);
06763     }
06764     return;
06765   }
06766 
06767   // Pattern: (shl:i32 GPRC:i32:$rS, GPRC:i32:$rB)
06768   // Emits: (SLW:i32 GPRC:i32:$rS, GPRC:i32:$rB)
06769   // Pattern complexity = 2  cost = 1
06770   if (N.Val->getValueType(0) == MVT::i32 &&
06771       N1.Val->getValueType(0) == MVT::i32) {
06772     Select(Tmp0, N0);
06773     Select(Tmp1, N1);
06774     if (N.Val->hasOneUse()) {
06775       Result = CurDAG->SelectNodeTo(N.Val, PPC::SLW, MVT::i32, Tmp0, Tmp1);
06776     } else {
06777       ResNode = CurDAG->getTargetNode(PPC::SLW, MVT::i32, Tmp0, Tmp1);
06778       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06779       Result = SDOperand(ResNode, 0);
06780     }
06781     return;
06782   }
06783   std::cerr << "Cannot yet select: ";
06784   N.Val->dump(CurDAG);
06785   std::cerr << '\n';
06786   abort();
06787 }
06788 
06789 void Select_sra(SDOperand &Result, SDOperand N) {
06790   SDOperand N0(0, 0);
06791   SDOperand N1(0, 0);
06792   SDOperand Tmp0(0, 0);
06793   SDOperand Tmp1(0, 0);
06794   SDNode *ResNode;
06795   N0 = N.getOperand(0);
06796   N1 = N.getOperand(1);
06797 
06798   // Pattern: (sra:i32 GPRC:i32:$rS, (imm:i32):$SH)
06799   // Emits: (SRAWI:i32 GPRC:i32:$rS, (imm:i32):$SH)
06800   // Pattern complexity = 4  cost = 1
06801   if (N1.getOpcode() == ISD::Constant &&
06802       N.Val->getValueType(0) == MVT::i32 &&
06803       N1.Val->getValueType(0) == MVT::i32) {
06804     Select(Tmp0, N0);
06805     unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
06806     Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
06807     if (N.Val->hasOneUse()) {
06808       Result = CurDAG->SelectNodeTo(N.Val, PPC::SRAWI, MVT::i32, Tmp0, Tmp1);
06809     } else {
06810       ResNode = CurDAG->getTargetNode(PPC::SRAWI, MVT::i32, Tmp0, Tmp1);
06811       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06812       Result = SDOperand(ResNode, 0);
06813     }
06814     return;
06815   }
06816 
06817   // Pattern: (sra:i64 G8RC:i64:$rS, G8RC:i64:$rB)
06818   // Emits: (SRAD:i64 G8RC:i64:$rS, G8RC:i64:$rB)
06819   // Pattern complexity = 2  cost = 1
06820   if (N.Val->getValueType(0) == MVT::i64 &&
06821       N1.Val->getValueType(0) == MVT::i64) {
06822     Select(Tmp0, N0);
06823     Select(Tmp1, N1);
06824     if (N.Val->hasOneUse()) {
06825       Result = CurDAG->SelectNodeTo(N.Val, PPC::SRAD, MVT::i64, Tmp0, Tmp1);
06826     } else {
06827       ResNode = CurDAG->getTargetNode(PPC::SRAD, MVT::i64, Tmp0, Tmp1);
06828       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06829       Result = SDOperand(ResNode, 0);
06830     }
06831     return;
06832   }
06833 
06834   // Pattern: (sra:i32 GPRC:i32:$rS, GPRC:i32:$rB)
06835   // Emits: (SRAW:i32 GPRC:i32:$rS, GPRC:i32:$rB)
06836   // Pattern complexity = 2  cost = 1
06837   if (N.Val->getValueType(0) == MVT::i32 &&
06838       N1.Val->getValueType(0) == MVT::i32) {
06839     Select(Tmp0, N0);
06840     Select(Tmp1, N1);
06841     if (N.Val->hasOneUse()) {
06842       Result = CurDAG->SelectNodeTo(N.Val, PPC::SRAW, MVT::i32, Tmp0, Tmp1);
06843     } else {
06844       ResNode = CurDAG->getTargetNode(PPC::SRAW, MVT::i32, Tmp0, Tmp1);
06845       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06846       Result = SDOperand(ResNode, 0);
06847     }
06848     return;
06849   }
06850   std::cerr << "Cannot yet select: ";
06851   N.Val->dump(CurDAG);
06852   std::cerr << '\n';
06853   abort();
06854 }
06855 
06856 void Select_srl(SDOperand &Result, SDOperand N) {
06857   SDOperand N0(0, 0);
06858   SDOperand N1(0, 0);
06859   SDOperand Tmp0(0, 0);
06860   SDOperand Tmp1(0, 0);
06861   SDOperand Tmp2(0, 0);
06862   SDOperand Tmp3(0, 0);
06863   SDNode *ResNode;
06864   N0 = N.getOperand(0);
06865   N1 = N.getOperand(1);
06866   if (N1.getOpcode() == ISD::Constant) {
06867 
06868     // Pattern: (srl:i32 GPRC:i32:$in, (imm:i32):$imm)
06869     // Emits: (RLWINM:i32 GPRC:i32:$in, (SRL32:i32 (imm:i32):$imm), (imm:i32):$imm, 31:i32)
06870     // Pattern complexity = 4  cost = 1
06871     if (N.Val->getValueType(0) == MVT::i32 &&
06872         N1.Val->getValueType(0) == MVT::i32) {
06873       Select(Tmp0, N0);
06874       unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
06875       Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
06876       Tmp2 = Transform_SRL32(Tmp1.Val);
06877       Tmp3 = CurDAG->getTargetConstant(31, MVT::i32);
06878       if (N.Val->hasOneUse()) {
06879         Result = CurDAG->SelectNodeTo(N.Val, PPC::RLWINM, MVT::i32, Tmp0, Tmp2, Tmp1, Tmp3);
06880       } else {
06881         ResNode = CurDAG->getTargetNode(PPC::RLWINM, MVT::i32, Tmp0, Tmp2, Tmp1, Tmp3);
06882         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06883         Result = SDOperand(ResNode, 0);
06884       }
06885       return;
06886     }
06887 
06888     // Pattern: (srl:i64 G8RC:i64:$in, (imm:i64):$imm)
06889     // Emits: (RLDICL:i64 G8RC:i64:$in, (SRL64:i32 (imm:i32):$imm), (imm:i32):$imm)
06890     // Pattern complexity = 4  cost = 1
06891     if (N.Val->getValueType(0) == MVT::i64 &&
06892         N1.Val->getValueType(0) == MVT::i64) {
06893       Select(Tmp0, N0);
06894       unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
06895       Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
06896       Tmp2 = Transform_SRL64(Tmp1.Val);
06897       if (N.Val->hasOneUse()) {
06898         Result = CurDAG->SelectNodeTo(N.Val, PPC::RLDICL, MVT::i64, Tmp0, Tmp2, Tmp1);
06899       } else {
06900         ResNode = CurDAG->getTargetNode(PPC::RLDICL, MVT::i64, Tmp0, Tmp2, Tmp1);
06901         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06902         Result = SDOperand(ResNode, 0);
06903       }
06904       return;
06905     }
06906   }
06907 
06908   // Pattern: (srl:i64 G8RC:i64:$rS, G8RC:i64:$rB)
06909   // Emits: (SRD:i64 G8RC:i64:$rS, G8RC:i64:$rB)
06910   // Pattern complexity = 2  cost = 1
06911   if (N.Val->getValueType(0) == MVT::i64 &&
06912       N1.Val->getValueType(0) == MVT::i64) {
06913     Select(Tmp0, N0);
06914     Select(Tmp1, N1);
06915     if (N.Val->hasOneUse()) {
06916       Result = CurDAG->SelectNodeTo(N.Val, PPC::SRD, MVT::i64, Tmp0, Tmp1);
06917     } else {
06918       ResNode = CurDAG->getTargetNode(PPC::SRD, MVT::i64, Tmp0, Tmp1);
06919       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06920       Result = SDOperand(ResNode, 0);
06921     }
06922     return;
06923   }
06924 
06925   // Pattern: (srl:i32 GPRC:i32:$rS, GPRC:i32:$rB)
06926   // Emits: (SRW:i32 GPRC:i32:$rS, GPRC:i32:$rB)
06927   // Pattern complexity = 2  cost = 1
06928   if (N.Val->getValueType(0) == MVT::i32 &&
06929       N1.Val->getValueType(0) == MVT::i32) {
06930     Select(Tmp0, N0);
06931     Select(Tmp1, N1);
06932     if (N.Val->hasOneUse()) {
06933       Result = CurDAG->SelectNodeTo(N.Val, PPC::SRW, MVT::i32, Tmp0, Tmp1);
06934     } else {
06935       ResNode = CurDAG->getTargetNode(PPC::SRW, MVT::i32, Tmp0, Tmp1);
06936       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
06937       Result = SDOperand(ResNode, 0);
06938     }
06939     return;
06940   }
06941   std::cerr << "Cannot yet select: ";
06942   N.Val->dump(CurDAG);
06943   std::cerr << '\n';
06944   abort();
06945 }
06946 
06947 void Select_store(SDOperand &Result, SDOperand N) {
06948   SDOperand Chain(0, 0);
06949   SDOperand N1(0, 0);
06950   SDOperand N2(0, 0);
06951   SDOperand Tmp0(0, 0);
06952   SDOperand Tmp1(0, 0);
06953   SDOperand Tmp2(0, 0);
06954   SDNode *ResNode;
06955   Chain = N.getOperand(0);
06956   N1 = N.getOperand(1);
06957   N2 = N.getOperand(2);
06958 
06959   // Pattern: (store:void GPRC:i32:$rS, iaddr:i32:$src)
06960   // Emits: (STW:void GPRC:i32:$rS, iaddr:i32:$src)
06961   // Pattern complexity = 8  cost = 1
06962   if (N1.Val->getValueType(0) == MVT::i32 &&
06963       SelectAddrImm(N2, Tmp0, Tmp1)) {
06964     Select(Tmp0, Tmp0);
06965     Select(Tmp1, Tmp1);
06966     Select(Tmp2, N1);
06967     Select(Chain, Chain);
06968     ResNode = CurDAG->getTargetNode(PPC::STW, MVT::Other, Tmp2, Tmp0, Tmp1, Chain);
06969     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
06970     Result = SDOperand(ResNode, N.ResNo);
06971     return;
06972   }
06973 
06974   // Pattern: (store:void F4RC:f32:$rS, iaddr:i32:$dst)
06975   // Emits: (STFS:void F4RC:f32:$rS, iaddr:i32:$dst)
06976   // Pattern complexity = 8  cost = 1
06977   if (N1.Val->getValueType(0) == MVT::f32 &&
06978       SelectAddrImm(N2, Tmp0, Tmp1)) {
06979     Select(Tmp0, Tmp0);
06980     Select(Tmp1, Tmp1);
06981     Select(Tmp2, N1);
06982     Select(Chain, Chain);
06983     ResNode = CurDAG->getTargetNode(PPC::STFS, MVT::Other, Tmp2, Tmp0, Tmp1, Chain);
06984     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
06985     Result = SDOperand(ResNode, N.ResNo);
06986     return;
06987   }
06988 
06989   // Pattern: (store:void F8RC:f64:$rS, iaddr:i32:$dst)
06990   // Emits: (STFD:void F8RC:f64:$rS, iaddr:i32:$dst)
06991   // Pattern complexity = 8  cost = 1
06992   if (N1.Val->getValueType(0) == MVT::f64 &&
06993       SelectAddrImm(N2, Tmp0, Tmp1)) {
06994     Select(Tmp0, Tmp0);
06995     Select(Tmp1, Tmp1);
06996     Select(Tmp2, N1);
06997     Select(Chain, Chain);
06998     ResNode = CurDAG->getTargetNode(PPC::STFD, MVT::Other, Tmp2, Tmp0, Tmp1, Chain);
06999     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
07000     Result = SDOperand(ResNode, N.ResNo);
07001     return;
07002   }
07003 
07004   // Pattern: (store:void GPRC:i32:$rS, xaddr:i32:$dst)
07005   // Emits: (STWX:void GPRC:i32:$rS, xaddr:i32:$dst)
07006   // Pattern complexity = 8  cost = 1
07007   if (N1.Val->getValueType(0) == MVT::i32 &&
07008       SelectAddrIdx(N2, Tmp0, Tmp1)) {
07009     Select(Tmp0, Tmp0);
07010     Select(Tmp1, Tmp1);
07011     Select(Tmp2, N1);
07012     Select(Chain, Chain);
07013     ResNode = CurDAG->getTargetNode(PPC::STWX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain);
07014     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
07015     Result = SDOperand(ResNode, N.ResNo);
07016     return;
07017   }
07018 
07019   // Pattern: (store:void F4RC:f32:$frS, xaddr:i32:$dst)
07020   // Emits: (STFSX:void F4RC:f32:$frS, xaddr:i32:$dst)
07021   // Pattern complexity = 8  cost = 1
07022   if (N1.Val->getValueType(0) == MVT::f32 &&
07023       SelectAddrIdx(N2, Tmp0, Tmp1)) {
07024     Select(Tmp0, Tmp0);
07025     Select(Tmp1, Tmp1);
07026     Select(Tmp2, N1);
07027     Select(Chain, Chain);
07028     ResNode = CurDAG->getTargetNode(PPC::STFSX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain);
07029     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
07030     Result = SDOperand(ResNode, N.ResNo);
07031     return;
07032   }
07033 
07034   // Pattern: (store:void F8RC:f64:$frS, xaddr:i32:$dst)
07035   // Emits: (STFDX:void F8RC:f64:$frS, xaddr:i32:$dst)
07036   // Pattern complexity = 8  cost = 1
07037   if (N1.Val->getValueType(0) == MVT::f64 &&
07038       SelectAddrIdx(N2, Tmp0, Tmp1)) {
07039     Select(Tmp0, Tmp0);
07040     Select(Tmp1, Tmp1);
07041     Select(Tmp2, N1);
07042     Select(Chain, Chain);
07043     ResNode = CurDAG->getTargetNode(PPC::STFDX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain);
07044     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
07045     Result = SDOperand(ResNode, N.ResNo);
07046     return;
07047   }
07048 
07049   // Pattern: (store:void VRRC:v16i8:$rS, xoaddr:i32:$dst)
07050   // Emits: (STVX:void VRRC:v16i8:$rS, xoaddr:i32:$dst)
07051   // Pattern complexity = 8  cost = 1
07052   if (N1.Val->getValueType(0) == MVT::v16i8 &&
07053       SelectAddrIdxOnly(N2, Tmp0, Tmp1)) {
07054     Select(Tmp0, Tmp0);
07055     Select(Tmp1, Tmp1);
07056     Select(Tmp2, N1);
07057     Select(Chain, Chain);
07058     ResNode = CurDAG->getTargetNode(PPC::STVX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain);
07059     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
07060     Result = SDOperand(ResNode, N.ResNo);
07061     return;
07062   }
07063 
07064   // Pattern: (store:void VRRC:v8i16:$rS, xoaddr:i32:$dst)
07065   // Emits: (STVX:void VRRC:v8i16:$rS, xoaddr:i32:$dst)
07066   // Pattern complexity = 8  cost = 1
07067   if (N1.Val->getValueType(0) == MVT::v8i16 &&
07068       SelectAddrIdxOnly(N2, Tmp0, Tmp1)) {
07069     Select(Tmp0, Tmp0);
07070     Select(Tmp1, Tmp1);
07071     Select(Tmp2, N1);
07072     Select(Chain, Chain);
07073     ResNode = CurDAG->getTargetNode(PPC::STVX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain);
07074     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
07075     Result = SDOperand(ResNode, N.ResNo);
07076     return;
07077   }
07078 
07079   // Pattern: (store:void VRRC:v4i32:$rS, xoaddr:i32:$dst)
07080   // Emits: (STVX:void VRRC:v4i32:$rS, xoaddr:i32:$dst)
07081   // Pattern complexity = 8  cost = 1
07082   if (N1.Val->getValueType(0) == MVT::v4i32 &&
07083       SelectAddrIdxOnly(N2, Tmp0, Tmp1)) {
07084     Select(Tmp0, Tmp0);
07085     Select(Tmp1, Tmp1);
07086     Select(Tmp2, N1);
07087     Select(Chain, Chain);
07088     ResNode = CurDAG->getTargetNode(PPC::STVX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain);
07089     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
07090     Result = SDOperand(ResNode, N.ResNo);
07091     return;
07092   }
07093 
07094   // Pattern: (store:void VRRC:v4f32:$rS, xoaddr:i32:$dst)
07095   // Emits: (STVX:void VRRC:v4f32:$rS, xoaddr:i32:$dst)
07096   // Pattern complexity = 8  cost = 1
07097   if (N1.Val->getValueType(0) == MVT::v4f32 &&
07098       SelectAddrIdxOnly(N2, Tmp0, Tmp1)) {
07099     Select(Tmp0, Tmp0);
07100     Select(Tmp1, Tmp1);
07101     Select(Tmp2, N1);
07102     Select(Chain, Chain);
07103     ResNode = CurDAG->getTargetNode(PPC::STVX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain);
07104     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
07105     Result = SDOperand(ResNode, N.ResNo);
07106     return;
07107   }
07108   std::cerr << "Cannot yet select: ";
07109   N.Val->dump(CurDAG);
07110   std::cerr << '\n';
07111   abort();
07112 }
07113 
07114 void Select_sub(SDOperand &Result, SDOperand N) {
07115   SDOperand N0(0, 0);
07116   SDOperand N1(0, 0);
07117   SDOperand Tmp0(0, 0);
07118   SDOperand Tmp1(0, 0);
07119   SDNode *ResNode;
07120   N0 = N.getOperand(0);
07121 
07122   // Pattern: (sub:i32 0:i32, GPRC:i32:$rA)
07123   // Emits: (NEG:i32 GPRC:i32:$rA)
07124   // Pattern complexity = 5  cost = 1
07125   if (isa<ConstantSDNode>(N0)) {
07126     int64_t CN0 = cast<ConstantSDNode>(N0)->getSignExtended();
07127     if (CN0 == 0) {
07128       N1 = N.getOperand(1);
07129       if (N.Val->getValueType(0) == MVT::i32) {
07130         Select(Tmp1, N1);
07131         if (N.Val->hasOneUse()) {
07132           Result = CurDAG->SelectNodeTo(N.Val, PPC::NEG, MVT::i32, Tmp1);
07133         } else {
07134           ResNode = CurDAG->getTargetNode(PPC::NEG, MVT::i32, Tmp1);
07135           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07136           Result = SDOperand(ResNode, 0);
07137         }
07138         return;
07139       }
07140     }
07141   }
07142 
07143   // Pattern: (sub:i32 (imm:i32)<<P:Predicate_immSExt16>>:$imm, GPRC:i32:$in)
07144   // Emits: (SUBFIC:i32 GPRC:i32:$in, (imm:i32):$imm)
07145   // Pattern complexity = 5  cost = 1
07146   if (N0.getOpcode() == ISD::Constant &&
07147       Predicate_immSExt16(N0.Val)) {
07148     N1 = N.getOperand(1);
07149     if (N.Val->getValueType(0) == MVT::i32) {
07150       Select(Tmp0, N1);
07151       unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N0)->getValue();
07152       Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
07153       if (N.Val->hasOneUse()) {
07154         Result = CurDAG->SelectNodeTo(N.Val, PPC::SUBFIC, MVT::i32, Tmp0, Tmp1);
07155       } else {
07156         ResNode = CurDAG->getTargetNode(PPC::SUBFIC, MVT::i32, Tmp0, Tmp1);
07157         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07158         Result = SDOperand(ResNode, 0);
07159       }
07160       return;
07161     }
07162   }
07163   N1 = N.getOperand(1);
07164 
07165   // Pattern: (sub:i32 GPRC:i32:$rB, GPRC:i32:$rA)
07166   // Emits: (SUBF:i32 GPRC:i32:$rA, GPRC:i32:$rB)
07167   // Pattern complexity = 2  cost = 1
07168   if (N.Val->getValueType(0) == MVT::i32) {
07169     Select(Tmp0, N1);
07170     Select(Tmp1, N0);
07171     if (N.Val->hasOneUse()) {
07172       Result = CurDAG->SelectNodeTo(N.Val, PPC::SUBF, MVT::i32, Tmp0, Tmp1);
07173     } else {
07174       ResNode = CurDAG->getTargetNode(PPC::SUBF, MVT::i32, Tmp0, Tmp1);
07175       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07176       Result = SDOperand(ResNode, 0);
07177     }
07178     return;
07179   }
07180 
07181   // Pattern: (sub:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
07182   // Emits: (VSUBUBM:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
07183   // Pattern complexity = 2  cost = 1
07184   if (N.Val->getValueType(0) == MVT::v16i8) {
07185     Select(Tmp0, N0);
07186     Select(Tmp1, N1);
07187     if (N.Val->hasOneUse()) {
07188       Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBUBM, MVT::v16i8, Tmp0, Tmp1);
07189     } else {
07190       ResNode = CurDAG->getTargetNode(PPC::VSUBUBM, MVT::v16i8, Tmp0, Tmp1);
07191       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07192       Result = SDOperand(ResNode, 0);
07193     }
07194     return;
07195   }
07196 
07197   // Pattern: (sub:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
07198   // Emits: (VSUBUHM:v8i16 VRRC:v8i16:$vA, VRRC:v8i16:$vB)
07199   // Pattern complexity = 2  cost = 1
07200   if (N.Val->getValueType(0) == MVT::v8i16) {
07201     Select(Tmp0, N0);
07202     Select(Tmp1, N1);
07203     if (N.Val->hasOneUse()) {
07204       Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBUHM, MVT::v8i16, Tmp0, Tmp1);
07205     } else {
07206       ResNode = CurDAG->getTargetNode(PPC::VSUBUHM, MVT::v8i16, Tmp0, Tmp1);
07207       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07208       Result = SDOperand(ResNode, 0);
07209     }
07210     return;
07211   }
07212 
07213   // Pattern: (sub:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
07214   // Emits: (VSUBUWM:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
07215   // Pattern complexity = 2  cost = 1
07216   if (N.Val->getValueType(0) == MVT::v4i32) {
07217     Select(Tmp0, N0);
07218     Select(Tmp1, N1);
07219     if (N.Val->hasOneUse()) {
07220       Result = CurDAG->SelectNodeTo(N.Val, PPC::VSUBUWM, MVT::v4i32, Tmp0, Tmp1);
07221     } else {
07222       ResNode = CurDAG->getTargetNode(PPC::VSUBUWM, MVT::v4i32, Tmp0, Tmp1);
07223       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07224       Result = SDOperand(ResNode, 0);
07225     }
07226     return;
07227   }
07228   std::cerr << "Cannot yet select: ";
07229   N.Val->dump(CurDAG);
07230   std::cerr << '\n';
07231   abort();
07232 }
07233 
07234 void Select_subc(SDOperand &Result, SDOperand N) {
07235   SDOperand InFlag(0, 0);
07236   SDOperand N0(0, 0);
07237   SDOperand N1(0, 0);
07238   SDOperand Tmp0(0, 0);
07239   SDOperand Tmp1(0, 0);
07240   SDNode *ResNode;
07241   N0 = N.getOperand(0);
07242 
07243   // Pattern: (subc:i32 (imm:i32)<<P:Predicate_immSExt16>>:$imm, GPRC:i32:$rA)
07244   // Emits: (SUBFIC:i32 GPRC:i32:$rA, (imm:i32):$imm)
07245   // Pattern complexity = 5  cost = 1
07246   if (N0.getOpcode() == ISD::Constant &&
07247       Predicate_immSExt16(N0.Val)) {
07248     N1 = N.getOperand(1);
07249     if (N.Val->getValueType(0) == MVT::i32) {
07250       Select(Tmp0, N1);
07251       unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N0)->getValue();
07252       Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
07253       ResNode = CurDAG->getTargetNode(PPC::SUBFIC, MVT::i32, MVT::Flag, Tmp0, Tmp1);
07254       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
07255       InFlag = SDOperand(ResNode, 1);
07256       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
07257       Result = SDOperand(ResNode, N.ResNo);
07258       return;
07259     }
07260   }
07261 
07262   // Pattern: (subc:i32 GPRC:i32:$rB, GPRC:i32:$rA)
07263   // Emits: (SUBFC:i32 GPRC:i32:$rA, GPRC:i32:$rB)
07264   // Pattern complexity = 2  cost = 1
07265   N1 = N.getOperand(1);
07266   if (N.Val->getValueType(0) == MVT::i32) {
07267     Select(Tmp0, N1);
07268     Select(Tmp1, N0);
07269     ResNode = CurDAG->getTargetNode(PPC::SUBFC, MVT::i32, MVT::Flag, Tmp0, Tmp1);
07270     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
07271     InFlag = SDOperand(ResNode, 1);
07272     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
07273     Result = SDOperand(ResNode, N.ResNo);
07274     return;
07275   }
07276   std::cerr << "Cannot yet select: ";
07277   N.Val->dump(CurDAG);
07278   std::cerr << '\n';
07279   abort();
07280 }
07281 
07282 void Select_sube(SDOperand &Result, SDOperand N) {
07283   SDOperand InFlag(0, 0);
07284   SDOperand N0(0, 0);
07285   SDOperand N1(0, 0);
07286   SDOperand Tmp0(0, 0);
07287   SDOperand Tmp1(0, 0);
07288   SDNode *ResNode;
07289   N0 = N.getOperand(0);
07290 
07291   // Pattern: (sube:i32 (imm:i32)<<P:Predicate_immAllOnes>>, GPRC:i32:$rA)
07292   // Emits: (SUBFME:i32 GPRC:i32:$rA)
07293   // Pattern complexity = 5  cost = 1
07294   if (N0.getOpcode() == ISD::Constant &&
07295       Predicate_immAllOnes(N0.Val)) {
07296     N1 = N.getOperand(1);
07297     if (N.Val->getValueType(0) == MVT::i32) {
07298       Select(Tmp0, N1);
07299       Select(InFlag, N.getOperand(2));
07300       ResNode = CurDAG->getTargetNode(PPC::SUBFME, MVT::i32, MVT::Flag, Tmp0, InFlag);
07301       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
07302       InFlag = SDOperand(ResNode, 1);
07303       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
07304       Result = SDOperand(ResNode, N.ResNo);
07305       return;
07306     }
07307   }
07308 
07309   // Pattern: (sube:i32 0:i32, GPRC:i32:$rA)
07310   // Emits: (SUBFZE:i32 GPRC:i32:$rA)
07311   // Pattern complexity = 5  cost = 1
07312   if (isa<ConstantSDNode>(N0)) {
07313     int64_t CN0 = cast<ConstantSDNode>(N0)->getSignExtended();
07314     if (CN0 == 0) {
07315       N1 = N.getOperand(1);
07316       if (N.Val->getValueType(0) == MVT::i32) {
07317         Select(Tmp1, N1);
07318         Select(InFlag, N.getOperand(2));
07319         ResNode = CurDAG->getTargetNode(PPC::SUBFZE, MVT::i32, MVT::Flag, Tmp1, InFlag);
07320         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
07321         InFlag = SDOperand(ResNode, 1);
07322         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
07323         Result = SDOperand(ResNode, N.ResNo);
07324         return;
07325       }
07326     }
07327   }
07328 
07329   // Pattern: (sube:i32 GPRC:i32:$rB, GPRC:i32:$rA)
07330   // Emits: (SUBFE:i32 GPRC:i32:$rA, GPRC:i32:$rB)
07331   // Pattern complexity = 2  cost = 1
07332   N1 = N.getOperand(1);
07333   if (N.Val->getValueType(0) == MVT::i32) {
07334     Select(Tmp0, N1);
07335     Select(Tmp1, N0);
07336     Select(InFlag, N.getOperand(2));
07337     ResNode = CurDAG->getTargetNode(PPC::SUBFE, MVT::i32, MVT::Flag, Tmp0, Tmp1, InFlag);
07338     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
07339     InFlag = SDOperand(ResNode, 1);
07340     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, InFlag.Val, InFlag.ResNo);
07341     Result = SDOperand(ResNode, N.ResNo);
07342     return;
07343   }
07344   std::cerr << "Cannot yet select: ";
07345   N.Val->dump(CurDAG);
07346   std::cerr << '\n';
07347   abort();
07348 }
07349 
07350 void Select_trunc(SDOperand &Result, SDOperand N) {
07351   SDOperand N0(0, 0);
07352   SDOperand Tmp0(0, 0);
07353   SDNode *ResNode;
07354   N0 = N.getOperand(0);
07355   if (N.Val->getValueType(0) == MVT::i32 &&
07356       N0.Val->getValueType(0) == MVT::i64) {
07357     Select(Tmp0, N0);
07358     if (N.Val->hasOneUse()) {
07359       Result = CurDAG->SelectNodeTo(N.Val, PPC::OR8To4, MVT::i32, Tmp0, Tmp0);
07360     } else {
07361       ResNode = CurDAG->getTargetNode(PPC::OR8To4, MVT::i32, Tmp0, Tmp0);
07362       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07363       Result = SDOperand(ResNode, 0);
07364     }
07365     return;
07366   }
07367   std::cerr << "Cannot yet select: ";
07368   N.Val->dump(CurDAG);
07369   std::cerr << '\n';
07370   abort();
07371 }
07372 
07373 void Select_truncst(SDOperand &Result, SDOperand N) {
07374   SDOperand Chain(0, 0);
07375   SDOperand N1(0, 0);
07376   SDOperand N2(0, 0);
07377   SDOperand N3(0, 0);
07378   SDOperand N4(0, 0);
07379   SDOperand Tmp0(0, 0);
07380   SDOperand Tmp1(0, 0);
07381   SDOperand Tmp2(0, 0);
07382   SDNode *ResNode;
07383   Chain = N.getOperand(0);
07384   N1 = N.getOperand(1);
07385   N2 = N.getOperand(2);
07386   N3 = N.getOperand(3);
07387   N4 = N.getOperand(4);
07388 
07389   // Pattern: (truncst:void GPRC:i32:$rS, iaddr:i32:$src, srcvalue:Other:$dummy, i8:Other)
07390   // Emits: (STB:void GPRC:i32:$rS, iaddr:i32:$src)
07391   // Pattern complexity = 8  cost = 1
07392   if (cast<VTSDNode>(N4)->getVT() == MVT::i8 &&
07393       N1.Val->getValueType(0) == MVT::i32 &&
07394       SelectAddrImm(N2, Tmp0, Tmp1)) {
07395     Select(Tmp0, Tmp0);
07396     Select(Tmp1, Tmp1);
07397     Select(Tmp2, N1);
07398     Select(Chain, Chain);
07399     ResNode = CurDAG->getTargetNode(PPC::STB, MVT::Other, Tmp2, Tmp0, Tmp1, Chain);
07400     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
07401     Result = SDOperand(ResNode, N.ResNo);
07402     return;
07403   }
07404 
07405   // Pattern: (truncst:void GPRC:i32:$rS, iaddr:i32:$src, srcvalue:Other:$dummy, i16:Other)
07406   // Emits: (STH:void GPRC:i32:$rS, iaddr:i32:$src)
07407   // Pattern complexity = 8  cost = 1
07408   if (cast<VTSDNode>(N4)->getVT() == MVT::i16 &&
07409       N1.Val->getValueType(0) == MVT::i32 &&
07410       SelectAddrImm(N2, Tmp0, Tmp1)) {
07411     Select(Tmp0, Tmp0);
07412     Select(Tmp1, Tmp1);
07413     Select(Tmp2, N1);
07414     Select(Chain, Chain);
07415     ResNode = CurDAG->getTargetNode(PPC::STH, MVT::Other, Tmp2, Tmp0, Tmp1, Chain);
07416     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
07417     Result = SDOperand(ResNode, N.ResNo);
07418     return;
07419   }
07420 
07421   // Pattern: (truncst:void GPRC:i32:$rS, xaddr:i32:$dst, srcvalue:Other:$dummy, i8:Other)
07422   // Emits: (STBX:void GPRC:i32:$rS, xaddr:i32:$dst)
07423   // Pattern complexity = 8  cost = 1
07424   if (cast<VTSDNode>(N4)->getVT() == MVT::i8 &&
07425       N1.Val->getValueType(0) == MVT::i32 &&
07426       SelectAddrIdx(N2, Tmp0, Tmp1)) {
07427     Select(Tmp0, Tmp0);
07428     Select(Tmp1, Tmp1);
07429     Select(Tmp2, N1);
07430     Select(Chain, Chain);
07431     ResNode = CurDAG->getTargetNode(PPC::STBX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain);
07432     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
07433     Result = SDOperand(ResNode, N.ResNo);
07434     return;
07435   }
07436 
07437   // Pattern: (truncst:void GPRC:i32:$rS, xaddr:i32:$dst, srcvalue:Other:$dummy, i16:Other)
07438   // Emits: (STHX:void GPRC:i32:$rS, xaddr:i32:$dst)
07439   // Pattern complexity = 8  cost = 1
07440   if (cast<VTSDNode>(N4)->getVT() == MVT::i16 &&
07441       N1.Val->getValueType(0) == MVT::i32 &&
07442       SelectAddrIdx(N2, Tmp0, Tmp1)) {
07443     Select(Tmp0, Tmp0);
07444     Select(Tmp1, Tmp1);
07445     Select(Tmp2, N1);
07446     Select(Chain, Chain);
07447     ResNode = CurDAG->getTargetNode(PPC::STHX, MVT::Other, Tmp2, Tmp0, Tmp1, Chain);
07448     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
07449     Result = SDOperand(ResNode, N.ResNo);
07450     return;
07451   }
07452   std::cerr << "Cannot yet select: ";
07453   N.Val->dump(CurDAG);
07454   std::cerr << '\n';
07455   abort();
07456 }
07457 
07458 void Select_udiv(SDOperand &Result, SDOperand N) {
07459   SDOperand N0(0, 0);
07460   SDOperand N1(0, 0);
07461   SDOperand Tmp0(0, 0);
07462   SDOperand Tmp1(0, 0);
07463   SDNode *ResNode;
07464   N0 = N.getOperand(0);
07465   N1 = N.getOperand(1);
07466 
07467   // Pattern: (udiv:i64 G8RC:i64:$rA, G8RC:i64:$rB)
07468   // Emits: (DIVDU:i64 G8RC:i64:$rA, G8RC:i64:$rB)
07469   // Pattern complexity = 2  cost = 1
07470   if (N.Val->getValueType(0) == MVT::i64) {
07471     Select(Tmp0, N0);
07472     Select(Tmp1, N1);
07473     if (N.Val->hasOneUse()) {
07474       Result = CurDAG->SelectNodeTo(N.Val, PPC::DIVDU, MVT::i64, Tmp0, Tmp1);
07475     } else {
07476       ResNode = CurDAG->getTargetNode(PPC::DIVDU, MVT::i64, Tmp0, Tmp1);
07477       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07478       Result = SDOperand(ResNode, 0);
07479     }
07480     return;
07481   }
07482 
07483   // Pattern: (udiv:i32 GPRC:i32:$rA, GPRC:i32:$rB)
07484   // Emits: (DIVWU:i32 GPRC:i32:$rA, GPRC:i32:$rB)
07485   // Pattern complexity = 2  cost = 1
07486   if (N.Val->getValueType(0) == MVT::i32) {
07487     Select(Tmp0, N0);
07488     Select(Tmp1, N1);
07489     if (N.Val->hasOneUse()) {
07490       Result = CurDAG->SelectNodeTo(N.Val, PPC::DIVWU, MVT::i32, Tmp0, Tmp1);
07491     } else {
07492       ResNode = CurDAG->getTargetNode(PPC::DIVWU, MVT::i32, Tmp0, Tmp1);
07493       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07494       Result = SDOperand(ResNode, 0);
07495     }
07496     return;
07497   }
07498   std::cerr << "Cannot yet select: ";
07499   N.Val->dump(CurDAG);
07500   std::cerr << '\n';
07501   abort();
07502 }
07503 
07504 void Select_undef(SDOperand &Result, SDOperand N) {
07505   SDNode *ResNode;
07506 
07507   // Pattern: (undef:i32)
07508   // Emits: (IMPLICIT_DEF_GPR:i32)
07509   // Pattern complexity = 2  cost = 1
07510   if (N.Val->getValueType(0) == MVT::i32) {
07511     if (N.Val->hasOneUse()) {
07512       Result = CurDAG->SelectNodeTo(N.Val, PPC::IMPLICIT_DEF_GPR, MVT::i32);
07513     } else {
07514       ResNode = CurDAG->getTargetNode(PPC::IMPLICIT_DEF_GPR, MVT::i32);
07515       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07516       Result = SDOperand(ResNode, 0);
07517     }
07518     return;
07519   }
07520 
07521   // Pattern: (undef:f64)
07522   // Emits: (IMPLICIT_DEF_F8:f64)
07523   // Pattern complexity = 2  cost = 1
07524   if (N.Val->getValueType(0) == MVT::f64) {
07525     if (N.Val->hasOneUse()) {
07526       Result = CurDAG->SelectNodeTo(N.Val, PPC::IMPLICIT_DEF_F8, MVT::f64);
07527     } else {
07528       ResNode = CurDAG->getTargetNode(PPC::IMPLICIT_DEF_F8, MVT::f64);
07529       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07530       Result = SDOperand(ResNode, 0);
07531     }
07532     return;
07533   }
07534 
07535   // Pattern: (undef:f32)
07536   // Emits: (IMPLICIT_DEF_F4:f32)
07537   // Pattern complexity = 2  cost = 1
07538   if (N.Val->getValueType(0) == MVT::f32) {
07539     if (N.Val->hasOneUse()) {
07540       Result = CurDAG->SelectNodeTo(N.Val, PPC::IMPLICIT_DEF_F4, MVT::f32);
07541     } else {
07542       ResNode = CurDAG->getTargetNode(PPC::IMPLICIT_DEF_F4, MVT::f32);
07543       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07544       Result = SDOperand(ResNode, 0);
07545     }
07546     return;
07547   }
07548 
07549   // Pattern: (undef:v4f32)
07550   // Emits: (IMPLICIT_DEF_VRRC:v4f32)
07551   // Pattern complexity = 2  cost = 1
07552   if (N.Val->getValueType(0) == MVT::v4f32) {
07553     if (N.Val->hasOneUse()) {
07554       Result = CurDAG->SelectNodeTo(N.Val, PPC::IMPLICIT_DEF_VRRC, MVT::v4f32);
07555     } else {
07556       ResNode = CurDAG->getTargetNode(PPC::IMPLICIT_DEF_VRRC, MVT::v4f32);
07557       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07558       Result = SDOperand(ResNode, 0);
07559     }
07560     return;
07561   }
07562 
07563   // Pattern: (undef:v16i8)
07564   // Emits: (IMPLICIT_DEF_VRRC:v16i8)
07565   // Pattern complexity = 2  cost = 1
07566   if (N.Val->getValueType(0) == MVT::v16i8) {
07567     if (N.Val->hasOneUse()) {
07568       Result = CurDAG->SelectNodeTo(N.Val, PPC::IMPLICIT_DEF_VRRC, MVT::v16i8);
07569     } else {
07570       ResNode = CurDAG->getTargetNode(PPC::IMPLICIT_DEF_VRRC, MVT::v16i8);
07571       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07572       Result = SDOperand(ResNode, 0);
07573     }
07574     return;
07575   }
07576 
07577   // Pattern: (undef:v8i16)
07578   // Emits: (IMPLICIT_DEF_VRRC:v8i16)
07579   // Pattern complexity = 2  cost = 1
07580   if (N.Val->getValueType(0) == MVT::v8i16) {
07581     if (N.Val->hasOneUse()) {
07582       Result = CurDAG->SelectNodeTo(N.Val, PPC::IMPLICIT_DEF_VRRC, MVT::v8i16);
07583     } else {
07584       ResNode = CurDAG->getTargetNode(PPC::IMPLICIT_DEF_VRRC, MVT::v8i16);
07585       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07586       Result = SDOperand(ResNode, 0);
07587     }
07588     return;
07589   }
07590 
07591   // Pattern: (undef:v4i32)
07592   // Emits: (IMPLICIT_DEF_VRRC:v4i32)
07593   // Pattern complexity = 2  cost = 1
07594   if (N.Val->getValueType(0) == MVT::v4i32) {
07595     if (N.Val->hasOneUse()) {
07596       Result = CurDAG->SelectNodeTo(N.Val, PPC::IMPLICIT_DEF_VRRC, MVT::v4i32);
07597     } else {
07598       ResNode = CurDAG->getTargetNode(PPC::IMPLICIT_DEF_VRRC, MVT::v4i32);
07599       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07600       Result = SDOperand(ResNode, 0);
07601     }
07602     return;
07603   }
07604   std::cerr << "Cannot yet select: ";
07605   N.Val->dump(CurDAG);
07606   std::cerr << '\n';
07607   abort();
07608 }
07609 
07610 void Select_vector_shuffle(SDOperand &Result, SDOperand N) {
07611   SDOperand N0(0, 0);
07612   SDOperand N1(0, 0);
07613   SDOperand N2(0, 0);
07614   SDOperand Tmp0(0, 0);
07615   SDOperand Tmp1(0, 0);
07616   SDOperand Tmp2(0, 0);
07617   SDOperand Tmp3(0, 0);
07618   SDNode *ResNode;
07619   N0 = N.getOperand(0);
07620   N1 = N.getOperand(1);
07621   if (N1.getOpcode() == ISD::UNDEF) {
07622     N2 = N.getOperand(2);
07623     if (N2.getOpcode() == ISD::BUILD_VECTOR) {
07624 
07625       // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vB, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VSPLTB_shuffle_mask>><<X:VSPLTB_get_imm>>:$UIMM)
07626       // Emits: (VSPLTB:v16i8 (VSPLTB_get_imm:i32 (build_vector:v16i8):$UIMM), VRRC:v16i8:$vB)
07627       // Pattern complexity = 7  cost = 1
07628       if (Predicate_VSPLTB_shuffle_mask(N2.Val) &&
07629           N.Val->getValueType(0) == MVT::v16i8) {
07630         Tmp0 = N2;
07631         Tmp1 = Transform_VSPLTB_get_imm(Tmp0.Val);
07632         Select(Tmp2, N0);
07633         if (N.Val->hasOneUse()) {
07634           Result = CurDAG->SelectNodeTo(N.Val, PPC::VSPLTB, MVT::v16i8, Tmp1, Tmp2);
07635         } else {
07636           ResNode = CurDAG->getTargetNode(PPC::VSPLTB, MVT::v16i8, Tmp1, Tmp2);
07637           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07638           Result = SDOperand(ResNode, 0);
07639         }
07640         return;
07641       }
07642 
07643       // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vB, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VSPLTH_shuffle_mask>><<X:VSPLTH_get_imm>>:$UIMM)
07644       // Emits: (VSPLTH:v16i8 (VSPLTH_get_imm:i32 (build_vector:v16i8):$UIMM), VRRC:v16i8:$vB)
07645       // Pattern complexity = 7  cost = 1
07646       if (Predicate_VSPLTH_shuffle_mask(N2.Val) &&
07647           N.Val->getValueType(0) == MVT::v16i8) {
07648         Tmp0 = N2;
07649         Tmp1 = Transform_VSPLTH_get_imm(Tmp0.Val);
07650         Select(Tmp2, N0);
07651         if (N.Val->hasOneUse()) {
07652           Result = CurDAG->SelectNodeTo(N.Val, PPC::VSPLTH, MVT::v16i8, Tmp1, Tmp2);
07653         } else {
07654           ResNode = CurDAG->getTargetNode(PPC::VSPLTH, MVT::v16i8, Tmp1, Tmp2);
07655           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07656           Result = SDOperand(ResNode, 0);
07657         }
07658         return;
07659       }
07660 
07661       // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vB, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VSPLTW_shuffle_mask>><<X:VSPLTW_get_imm>>:$UIMM)
07662       // Emits: (VSPLTW:v16i8 (VSPLTW_get_imm:i32 (build_vector:v16i8):$UIMM), VRRC:v16i8:$vB)
07663       // Pattern complexity = 7  cost = 1
07664       if (Predicate_VSPLTW_shuffle_mask(N2.Val) &&
07665           N.Val->getValueType(0) == MVT::v16i8) {
07666         Tmp0 = N2;
07667         Tmp1 = Transform_VSPLTW_get_imm(Tmp0.Val);
07668         Select(Tmp2, N0);
07669         if (N.Val->hasOneUse()) {
07670           Result = CurDAG->SelectNodeTo(N.Val, PPC::VSPLTW, MVT::v16i8, Tmp1, Tmp2);
07671         } else {
07672           ResNode = CurDAG->getTargetNode(PPC::VSPLTW, MVT::v16i8, Tmp1, Tmp2);
07673           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07674           Result = SDOperand(ResNode, 0);
07675         }
07676         return;
07677       }
07678 
07679       // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VSLDOI_unary_shuffle_mask>><<X:VSLDOI_unary_get_imm>>:$in)
07680       // Emits: (VSLDOI:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA, (VSLDOI_unary_get_imm:i32 (build_vector:i32)<<P:Predicate_VSLDOI_unary_shuffle_mask>>:$in))
07681       // Pattern complexity = 7  cost = 1
07682       if (Predicate_VSLDOI_unary_shuffle_mask(N2.Val) &&
07683           N.Val->getValueType(0) == MVT::v16i8) {
07684         Select(Tmp0, N0);
07685         Tmp1 = N2;
07686         Tmp2 = Transform_VSLDOI_unary_get_imm(Tmp1.Val);
07687         if (N.Val->hasOneUse()) {
07688           Result = CurDAG->SelectNodeTo(N.Val, PPC::VSLDOI, MVT::v16i8, Tmp0, Tmp0, Tmp2);
07689         } else {
07690           ResNode = CurDAG->getTargetNode(PPC::VSLDOI, MVT::v16i8, Tmp0, Tmp0, Tmp2);
07691           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07692           Result = SDOperand(ResNode, 0);
07693         }
07694         return;
07695       }
07696 
07697       // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VPKUWUM_unary_shuffle_mask>>:$in)
07698       // Emits: (VPKUWUM:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA)
07699       // Pattern complexity = 7  cost = 1
07700       if (Predicate_VPKUWUM_unary_shuffle_mask(N2.Val) &&
07701           N.Val->getValueType(0) == MVT::v16i8) {
07702         Select(Tmp0, N0);
07703         if (N.Val->hasOneUse()) {
07704           Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKUWUM, MVT::v16i8, Tmp0, Tmp0);
07705         } else {
07706           ResNode = CurDAG->getTargetNode(PPC::VPKUWUM, MVT::v16i8, Tmp0, Tmp0);
07707           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07708           Result = SDOperand(ResNode, 0);
07709         }
07710         return;
07711       }
07712 
07713       // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VPKUHUM_unary_shuffle_mask>>:$in)
07714       // Emits: (VPKUHUM:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA)
07715       // Pattern complexity = 7  cost = 1
07716       if (Predicate_VPKUHUM_unary_shuffle_mask(N2.Val) &&
07717           N.Val->getValueType(0) == MVT::v16i8) {
07718         Select(Tmp0, N0);
07719         if (N.Val->hasOneUse()) {
07720           Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKUHUM, MVT::v16i8, Tmp0, Tmp0);
07721         } else {
07722           ResNode = CurDAG->getTargetNode(PPC::VPKUHUM, MVT::v16i8, Tmp0, Tmp0);
07723           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07724           Result = SDOperand(ResNode, 0);
07725         }
07726         return;
07727       }
07728 
07729       // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VMRGLB_unary_shuffle_mask>>:$in)
07730       // Emits: (VMRGLB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA)
07731       // Pattern complexity = 7  cost = 1
07732       if (Predicate_VMRGLB_unary_shuffle_mask(N2.Val) &&
07733           N.Val->getValueType(0) == MVT::v16i8) {
07734         Select(Tmp0, N0);
07735         if (N.Val->hasOneUse()) {
07736           Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGLB, MVT::v16i8, Tmp0, Tmp0);
07737         } else {
07738           ResNode = CurDAG->getTargetNode(PPC::VMRGLB, MVT::v16i8, Tmp0, Tmp0);
07739           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07740           Result = SDOperand(ResNode, 0);
07741         }
07742         return;
07743       }
07744 
07745       // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VMRGLH_unary_shuffle_mask>>:$in)
07746       // Emits: (VMRGLH:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA)
07747       // Pattern complexity = 7  cost = 1
07748       if (Predicate_VMRGLH_unary_shuffle_mask(N2.Val) &&
07749           N.Val->getValueType(0) == MVT::v16i8) {
07750         Select(Tmp0, N0);
07751         if (N.Val->hasOneUse()) {
07752           Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGLH, MVT::v16i8, Tmp0, Tmp0);
07753         } else {
07754           ResNode = CurDAG->getTargetNode(PPC::VMRGLH, MVT::v16i8, Tmp0, Tmp0);
07755           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07756           Result = SDOperand(ResNode, 0);
07757         }
07758         return;
07759       }
07760 
07761       // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VMRGLW_unary_shuffle_mask>>:$in)
07762       // Emits: (VMRGLW:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA)
07763       // Pattern complexity = 7  cost = 1
07764       if (Predicate_VMRGLW_unary_shuffle_mask(N2.Val) &&
07765           N.Val->getValueType(0) == MVT::v16i8) {
07766         Select(Tmp0, N0);
07767         if (N.Val->hasOneUse()) {
07768           Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGLW, MVT::v16i8, Tmp0, Tmp0);
07769         } else {
07770           ResNode = CurDAG->getTargetNode(PPC::VMRGLW, MVT::v16i8, Tmp0, Tmp0);
07771           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07772           Result = SDOperand(ResNode, 0);
07773         }
07774         return;
07775       }
07776 
07777       // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VMRGHB_unary_shuffle_mask>>:$in)
07778       // Emits: (VMRGHB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA)
07779       // Pattern complexity = 7  cost = 1
07780       if (Predicate_VMRGHB_unary_shuffle_mask(N2.Val) &&
07781           N.Val->getValueType(0) == MVT::v16i8) {
07782         Select(Tmp0, N0);
07783         if (N.Val->hasOneUse()) {
07784           Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGHB, MVT::v16i8, Tmp0, Tmp0);
07785         } else {
07786           ResNode = CurDAG->getTargetNode(PPC::VMRGHB, MVT::v16i8, Tmp0, Tmp0);
07787           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07788           Result = SDOperand(ResNode, 0);
07789         }
07790         return;
07791       }
07792 
07793       // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VMRGHH_unary_shuffle_mask>>:$in)
07794       // Emits: (VMRGHH:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA)
07795       // Pattern complexity = 7  cost = 1
07796       if (Predicate_VMRGHH_unary_shuffle_mask(N2.Val) &&
07797           N.Val->getValueType(0) == MVT::v16i8) {
07798         Select(Tmp0, N0);
07799         if (N.Val->hasOneUse()) {
07800           Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGHH, MVT::v16i8, Tmp0, Tmp0);
07801         } else {
07802           ResNode = CurDAG->getTargetNode(PPC::VMRGHH, MVT::v16i8, Tmp0, Tmp0);
07803           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07804           Result = SDOperand(ResNode, 0);
07805         }
07806         return;
07807       }
07808 
07809       // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, (undef:v16i8), (build_vector:v16i8)<<P:Predicate_VMRGHW_unary_shuffle_mask>>:$in)
07810       // Emits: (VMRGHW:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA)
07811       // Pattern complexity = 7  cost = 1
07812       if (Predicate_VMRGHW_unary_shuffle_mask(N2.Val) &&
07813           N.Val->getValueType(0) == MVT::v16i8) {
07814         Select(Tmp0, N0);
07815         if (N.Val->hasOneUse()) {
07816           Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGHW, MVT::v16i8, Tmp0, Tmp0);
07817         } else {
07818           ResNode = CurDAG->getTargetNode(PPC::VMRGHW, MVT::v16i8, Tmp0, Tmp0);
07819           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07820           Result = SDOperand(ResNode, 0);
07821         }
07822         return;
07823       }
07824     }
07825   }
07826   N2 = N.getOperand(2);
07827   if (N2.getOpcode() == ISD::BUILD_VECTOR) {
07828 
07829     // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VSLDOI_shuffle_mask>><<X:VSLDOI_get_imm>>:$SH)
07830     // Emits: (VSLDOI:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (VSLDOI_get_imm:i32 (build_vector:v16i8):$SH))
07831     // Pattern complexity = 5  cost = 1
07832     if (Predicate_VSLDOI_shuffle_mask(N2.Val) &&
07833         N.Val->getValueType(0) == MVT::v16i8) {
07834       Select(Tmp0, N0);
07835       Select(Tmp1, N1);
07836       Tmp2 = N2;
07837       Tmp3 = Transform_VSLDOI_get_imm(Tmp2.Val);
07838       if (N.Val->hasOneUse()) {
07839         Result = CurDAG->SelectNodeTo(N.Val, PPC::VSLDOI, MVT::v16i8, Tmp0, Tmp1, Tmp3);
07840       } else {
07841         ResNode = CurDAG->getTargetNode(PPC::VSLDOI, MVT::v16i8, Tmp0, Tmp1, Tmp3);
07842         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07843         Result = SDOperand(ResNode, 0);
07844       }
07845       return;
07846     }
07847 
07848     // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VMRGHB_shuffle_mask>>)
07849     // Emits: (VMRGHB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
07850     // Pattern complexity = 5  cost = 1
07851     if (Predicate_VMRGHB_shuffle_mask(N2.Val) &&
07852         N.Val->getValueType(0) == MVT::v16i8) {
07853       Select(Tmp0, N0);
07854       Select(Tmp1, N1);
07855       if (N.Val->hasOneUse()) {
07856         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGHB, MVT::v16i8, Tmp0, Tmp1);
07857       } else {
07858         ResNode = CurDAG->getTargetNode(PPC::VMRGHB, MVT::v16i8, Tmp0, Tmp1);
07859         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07860         Result = SDOperand(ResNode, 0);
07861       }
07862       return;
07863     }
07864 
07865     // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VMRGHH_shuffle_mask>>)
07866     // Emits: (VMRGHH:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
07867     // Pattern complexity = 5  cost = 1
07868     if (Predicate_VMRGHH_shuffle_mask(N2.Val) &&
07869         N.Val->getValueType(0) == MVT::v16i8) {
07870       Select(Tmp0, N0);
07871       Select(Tmp1, N1);
07872       if (N.Val->hasOneUse()) {
07873         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGHH, MVT::v16i8, Tmp0, Tmp1);
07874       } else {
07875         ResNode = CurDAG->getTargetNode(PPC::VMRGHH, MVT::v16i8, Tmp0, Tmp1);
07876         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07877         Result = SDOperand(ResNode, 0);
07878       }
07879       return;
07880     }
07881 
07882     // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VMRGHW_shuffle_mask>>)
07883     // Emits: (VMRGHW:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
07884     // Pattern complexity = 5  cost = 1
07885     if (Predicate_VMRGHW_shuffle_mask(N2.Val) &&
07886         N.Val->getValueType(0) == MVT::v16i8) {
07887       Select(Tmp0, N0);
07888       Select(Tmp1, N1);
07889       if (N.Val->hasOneUse()) {
07890         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGHW, MVT::v16i8, Tmp0, Tmp1);
07891       } else {
07892         ResNode = CurDAG->getTargetNode(PPC::VMRGHW, MVT::v16i8, Tmp0, Tmp1);
07893         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07894         Result = SDOperand(ResNode, 0);
07895       }
07896       return;
07897     }
07898 
07899     // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VMRGLB_shuffle_mask>>)
07900     // Emits: (VMRGLB:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
07901     // Pattern complexity = 5  cost = 1
07902     if (Predicate_VMRGLB_shuffle_mask(N2.Val) &&
07903         N.Val->getValueType(0) == MVT::v16i8) {
07904       Select(Tmp0, N0);
07905       Select(Tmp1, N1);
07906       if (N.Val->hasOneUse()) {
07907         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGLB, MVT::v16i8, Tmp0, Tmp1);
07908       } else {
07909         ResNode = CurDAG->getTargetNode(PPC::VMRGLB, MVT::v16i8, Tmp0, Tmp1);
07910         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07911         Result = SDOperand(ResNode, 0);
07912       }
07913       return;
07914     }
07915 
07916     // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VMRGLH_shuffle_mask>>)
07917     // Emits: (VMRGLH:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
07918     // Pattern complexity = 5  cost = 1
07919     if (Predicate_VMRGLH_shuffle_mask(N2.Val) &&
07920         N.Val->getValueType(0) == MVT::v16i8) {
07921       Select(Tmp0, N0);
07922       Select(Tmp1, N1);
07923       if (N.Val->hasOneUse()) {
07924         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGLH, MVT::v16i8, Tmp0, Tmp1);
07925       } else {
07926         ResNode = CurDAG->getTargetNode(PPC::VMRGLH, MVT::v16i8, Tmp0, Tmp1);
07927         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07928         Result = SDOperand(ResNode, 0);
07929       }
07930       return;
07931     }
07932 
07933     // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VMRGLW_shuffle_mask>>)
07934     // Emits: (VMRGLW:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
07935     // Pattern complexity = 5  cost = 1
07936     if (Predicate_VMRGLW_shuffle_mask(N2.Val) &&
07937         N.Val->getValueType(0) == MVT::v16i8) {
07938       Select(Tmp0, N0);
07939       Select(Tmp1, N1);
07940       if (N.Val->hasOneUse()) {
07941         Result = CurDAG->SelectNodeTo(N.Val, PPC::VMRGLW, MVT::v16i8, Tmp0, Tmp1);
07942       } else {
07943         ResNode = CurDAG->getTargetNode(PPC::VMRGLW, MVT::v16i8, Tmp0, Tmp1);
07944         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07945         Result = SDOperand(ResNode, 0);
07946       }
07947       return;
07948     }
07949 
07950     // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VPKUHUM_shuffle_mask>>)
07951     // Emits: (VPKUHUM:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
07952     // Pattern complexity = 5  cost = 1
07953     if (Predicate_VPKUHUM_shuffle_mask(N2.Val) &&
07954         N.Val->getValueType(0) == MVT::v16i8) {
07955       Select(Tmp0, N0);
07956       Select(Tmp1, N1);
07957       if (N.Val->hasOneUse()) {
07958         Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKUHUM, MVT::v16i8, Tmp0, Tmp1);
07959       } else {
07960         ResNode = CurDAG->getTargetNode(PPC::VPKUHUM, MVT::v16i8, Tmp0, Tmp1);
07961         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07962         Result = SDOperand(ResNode, 0);
07963       }
07964       return;
07965     }
07966 
07967     // Pattern: (vector_shuffle:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB, (build_vector:v16i8)<<P:Predicate_VPKUWUM_shuffle_mask>>)
07968     // Emits: (VPKUWUM:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vB)
07969     // Pattern complexity = 5  cost = 1
07970     if (Predicate_VPKUWUM_shuffle_mask(N2.Val) &&
07971         N.Val->getValueType(0) == MVT::v16i8) {
07972       Select(Tmp0, N0);
07973       Select(Tmp1, N1);
07974       if (N.Val->hasOneUse()) {
07975         Result = CurDAG->SelectNodeTo(N.Val, PPC::VPKUWUM, MVT::v16i8, Tmp0, Tmp1);
07976       } else {
07977         ResNode = CurDAG->getTargetNode(PPC::VPKUWUM, MVT::v16i8, Tmp0, Tmp1);
07978         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
07979         Result = SDOperand(ResNode, 0);
07980       }
07981       return;
07982     }
07983   }
07984   std::cerr << "Cannot yet select: ";
07985   N.Val->dump(CurDAG);
07986   std::cerr << '\n';
07987   abort();
07988 }
07989 
07990 void Select_xor(SDOperand &Result, SDOperand N) {
07991   SDOperand N0(0, 0);
07992   SDOperand N00(0, 0);
07993   SDOperand N01(0, 0);
07994   SDOperand N1(0, 0);
07995   SDOperand N10(0, 0);
07996   SDOperand N11(0, 0);
07997   SDOperand Tmp0(0, 0);
07998   SDOperand Tmp1(0, 0);
07999   SDOperand Tmp2(0, 0);
08000   SDOperand Tmp3(0, 0);
08001   SDOperand Tmp4(0, 0);
08002   SDNode *ResNode;
08003   N0 = N.getOperand(0);
08004 
08005   // Pattern: (xor:i32 (and:i32 GPRC:i32:$rS, GPRC:i32:$rB), (imm:i32)<<P:Predicate_immAllOnes>>)
08006   // Emits: (NAND:i32 GPRC:i32:$rS, GPRC:i32:$rB)
08007   // Pattern complexity = 7  cost = 1
08008   if (N0.getOpcode() == ISD::AND) {
08009     N00 = N0.getOperand(0);
08010     N01 = N0.getOperand(1);
08011     N1 = N.getOperand(1);
08012     if (N1.getOpcode() == ISD::Constant &&
08013         Predicate_immAllOnes(N1.Val) &&
08014         N.Val->getValueType(0) == MVT::i32) {
08015       Select(Tmp0, N00);
08016       Select(Tmp1, N01);
08017       if (N.Val->hasOneUse()) {
08018         Result = CurDAG->SelectNodeTo(N.Val, PPC::NAND, MVT::i32, Tmp0, Tmp1);
08019       } else {
08020         ResNode = CurDAG->getTargetNode(PPC::NAND, MVT::i32, Tmp0, Tmp1);
08021         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08022         Result = SDOperand(ResNode, 0);
08023       }
08024       return;
08025     }
08026   }
08027 
08028   // Pattern: (xor:i32 (or:i32 GPRC:i32:$rS, GPRC:i32:$rB), (imm:i32)<<P:Predicate_immAllOnes>>)
08029   // Emits: (NOR:i32 GPRC:i32:$rS, GPRC:i32:$rB)
08030   // Pattern complexity = 7  cost = 1
08031   if (N0.getOpcode() == ISD::OR) {
08032     N00 = N0.getOperand(0);
08033     N01 = N0.getOperand(1);
08034     N1 = N.getOperand(1);
08035     if (N1.getOpcode() == ISD::Constant &&
08036         Predicate_immAllOnes(N1.Val) &&
08037         N.Val->getValueType(0) == MVT::i32) {
08038       Select(Tmp0, N00);
08039       Select(Tmp1, N01);
08040       if (N.Val->hasOneUse()) {
08041         Result = CurDAG->SelectNodeTo(N.Val, PPC::NOR, MVT::i32, Tmp0, Tmp1);
08042       } else {
08043         ResNode = CurDAG->getTargetNode(PPC::NOR, MVT::i32, Tmp0, Tmp1);
08044         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08045         Result = SDOperand(ResNode, 0);
08046       }
08047       return;
08048     }
08049   }
08050 
08051   // Pattern: (xor:i32 (xor:i32 GPRC:i32:$rS, GPRC:i32:$rB), (imm:i32)<<P:Predicate_immAllOnes>>)
08052   // Emits: (EQV:i32 GPRC:i32:$rS, GPRC:i32:$rB)
08053   // Pattern complexity = 7  cost = 1
08054   if (N0.getOpcode() == ISD::XOR) {
08055     N00 = N0.getOperand(0);
08056     N01 = N0.getOperand(1);
08057     N1 = N.getOperand(1);
08058     if (N1.getOpcode() == ISD::Constant &&
08059         Predicate_immAllOnes(N1.Val) &&
08060         N.Val->getValueType(0) == MVT::i32) {
08061       Select(Tmp0, N00);
08062       Select(Tmp1, N01);
08063       if (N.Val->hasOneUse()) {
08064         Result = CurDAG->SelectNodeTo(N.Val, PPC::EQV, MVT::i32, Tmp0, Tmp1);
08065       } else {
08066         ResNode = CurDAG->getTargetNode(PPC::EQV, MVT::i32, Tmp0, Tmp1);
08067         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08068         Result = SDOperand(ResNode, 0);
08069       }
08070       return;
08071     }
08072   }
08073   if (N0.getOpcode() == ISD::OR) {
08074     N00 = N0.getOperand(0);
08075     N01 = N0.getOperand(1);
08076     N1 = N.getOperand(1);
08077     if (N1.getOpcode() == ISD::BUILD_VECTOR &&
08078         Predicate_immAllOnesV(N1.Val)) {
08079 
08080       // Pattern: (xor:v4i32 (or:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB), (build_vector:v4i32)<<P:Predicate_immAllOnesV>>)
08081       // Emits: (VNOR:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
08082       // Pattern complexity = 7  cost = 1
08083       if (N.Val->getValueType(0) == MVT::v4i32) {
08084         Select(Tmp0, N00);
08085         Select(Tmp1, N01);
08086         if (N.Val->hasOneUse()) {
08087           Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v4i32, Tmp0, Tmp1);
08088         } else {
08089           ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v4i32, Tmp0, Tmp1);
08090           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08091           Result = SDOperand(ResNode, 0);
08092         }
08093         return;
08094       }
08095 
08096       // Pattern: (xor:v16i8 (or:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B), (build_vector:v16i8)<<P:Predicate_immAllOnesV>>)
08097       // Emits: (VNOR:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B)
08098       // Pattern complexity = 7  cost = 1
08099       if (N.Val->getValueType(0) == MVT::v16i8) {
08100         Select(Tmp0, N00);
08101         Select(Tmp1, N01);
08102         if (N.Val->hasOneUse()) {
08103           Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v16i8, Tmp0, Tmp1);
08104         } else {
08105           ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v16i8, Tmp0, Tmp1);
08106           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08107           Result = SDOperand(ResNode, 0);
08108         }
08109         return;
08110       }
08111 
08112       // Pattern: (xor:v8i16 (or:v8i16 VRRC:v8i16:$A, VRRC:v8i16:$B), (build_vector:v8i16)<<P:Predicate_immAllOnesV>>)
08113       // Emits: (VNOR:v8i16 VRRC:v16i8:$A, VRRC:v16i8:$B)
08114       // Pattern complexity = 7  cost = 1
08115       if (N.Val->getValueType(0) == MVT::v8i16) {
08116         Select(Tmp0, N00);
08117         Select(Tmp1, N01);
08118         if (N.Val->hasOneUse()) {
08119           Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v8i16, Tmp0, Tmp1);
08120         } else {
08121           ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v8i16, Tmp0, Tmp1);
08122           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08123           Result = SDOperand(ResNode, 0);
08124         }
08125         return;
08126       }
08127     }
08128   }
08129 
08130   // Pattern: (xor:i32 (xor:i32 GPRC:i32:$rS, (imm:i32)<<P:Predicate_immAllOnes>>), GPRC:i32:$rB)
08131   // Emits: (EQV:i32 GPRC:i32:$rS, GPRC:i32:$rB)
08132   // Pattern complexity = 7  cost = 1
08133   if (N0.getOpcode() == ISD::XOR) {
08134     N00 = N0.getOperand(0);
08135     N01 = N0.getOperand(1);
08136     if (N01.getOpcode() == ISD::Constant &&
08137         Predicate_immAllOnes(N01.Val)) {
08138       N1 = N.getOperand(1);
08139       if (N.Val->getValueType(0) == MVT::i32) {
08140         Select(Tmp0, N00);
08141         Select(Tmp1, N1);
08142         if (N.Val->hasOneUse()) {
08143           Result = CurDAG->SelectNodeTo(N.Val, PPC::EQV, MVT::i32, Tmp0, Tmp1);
08144         } else {
08145           ResNode = CurDAG->getTargetNode(PPC::EQV, MVT::i32, Tmp0, Tmp1);
08146           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08147           Result = SDOperand(ResNode, 0);
08148         }
08149         return;
08150       }
08151     }
08152   }
08153 
08154   // Pattern: (xor:i32 GPRC:i32:$rB, (xor:i32 GPRC:i32:$rS, (imm:i32)<<P:Predicate_immAllOnes>>))
08155   // Emits: (EQV:i32 GPRC:i32:$rS, GPRC:i32:$rB)
08156   // Pattern complexity = 7  cost = 1
08157   {
08158     N1 = N.getOperand(1);
08159     if (N1.getOpcode() == ISD::XOR) {
08160       N10 = N1.getOperand(0);
08161       N11 = N1.getOperand(1);
08162       if (N11.getOpcode() == ISD::Constant &&
08163           Predicate_immAllOnes(N11.Val) &&
08164           N.Val->getValueType(0) == MVT::i32) {
08165         Select(Tmp0, N10);
08166         Select(Tmp1, N0);
08167         if (N.Val->hasOneUse()) {
08168           Result = CurDAG->SelectNodeTo(N.Val, PPC::EQV, MVT::i32, Tmp0, Tmp1);
08169         } else {
08170           ResNode = CurDAG->getTargetNode(PPC::EQV, MVT::i32, Tmp0, Tmp1);
08171           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08172           Result = SDOperand(ResNode, 0);
08173         }
08174         return;
08175       }
08176     }
08177   }
08178   if (N0.getOpcode() == ISD::BUILD_VECTOR &&
08179       Predicate_immAllOnesV(N0.Val)) {
08180     N1 = N.getOperand(1);
08181     if (N1.getOpcode() == ISD::OR) {
08182       N10 = N1.getOperand(0);
08183       N11 = N1.getOperand(1);
08184 
08185       // Pattern: (xor:v4i32 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>, (or:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB))
08186       // Emits: (VNOR:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
08187       // Pattern complexity = 7  cost = 1
08188       if (N.Val->getValueType(0) == MVT::v4i32) {
08189         Select(Tmp0, N10);
08190         Select(Tmp1, N11);
08191         if (N.Val->hasOneUse()) {
08192           Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v4i32, Tmp0, Tmp1);
08193         } else {
08194           ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v4i32, Tmp0, Tmp1);
08195           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08196           Result = SDOperand(ResNode, 0);
08197         }
08198         return;
08199       }
08200 
08201       // Pattern: (xor:v16i8 (build_vector:v16i8)<<P:Predicate_immAllOnesV>>, (or:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B))
08202       // Emits: (VNOR:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B)
08203       // Pattern complexity = 7  cost = 1
08204       if (N.Val->getValueType(0) == MVT::v16i8) {
08205         Select(Tmp0, N10);
08206         Select(Tmp1, N11);
08207         if (N.Val->hasOneUse()) {
08208           Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v16i8, Tmp0, Tmp1);
08209         } else {
08210           ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v16i8, Tmp0, Tmp1);
08211           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08212           Result = SDOperand(ResNode, 0);
08213         }
08214         return;
08215       }
08216 
08217       // Pattern: (xor:v8i16 (build_vector:v8i16)<<P:Predicate_immAllOnesV>>, (or:v8i16 VRRC:v8i16:$A, VRRC:v8i16:$B))
08218       // Emits: (VNOR:v8i16 VRRC:v16i8:$A, VRRC:v16i8:$B)
08219       // Pattern complexity = 7  cost = 1
08220       if (N.Val->getValueType(0) == MVT::v8i16) {
08221         Select(Tmp0, N10);
08222         Select(Tmp1, N11);
08223         if (N.Val->hasOneUse()) {
08224           Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v8i16, Tmp0, Tmp1);
08225         } else {
08226           ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v8i16, Tmp0, Tmp1);
08227           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08228           Result = SDOperand(ResNode, 0);
08229         }
08230         return;
08231       }
08232     }
08233   }
08234   {
08235     N1 = N.getOperand(1);
08236     if (N1.getOpcode() == ISD::Constant) {
08237 
08238       // Pattern: (xor:i32 GPRC:i32:$src1, (imm:i32)<<P:Predicate_immZExt16>><<X:LO16>>:$src2)
08239       // Emits: (XORI:i32 GPRC:i32:$src1, (LO16:i32 (imm:i32):$src2))
08240       // Pattern complexity = 5  cost = 1
08241       if (Predicate_immZExt16(N1.Val) &&
08242           N.Val->getValueType(0) == MVT::i32) {
08243         Select(Tmp0, N0);
08244         unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
08245         Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
08246         Tmp2 = Transform_LO16(Tmp1.Val);
08247         if (N.Val->hasOneUse()) {
08248           Result = CurDAG->SelectNodeTo(N.Val, PPC::XORI, MVT::i32, Tmp0, Tmp2);
08249         } else {
08250           ResNode = CurDAG->getTargetNode(PPC::XORI, MVT::i32, Tmp0, Tmp2);
08251           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08252           Result = SDOperand(ResNode, 0);
08253         }
08254         return;
08255       }
08256 
08257       // Pattern: (xor:i32 GPRC:i32:$src1, (imm:i32)<<P:Predicate_imm16Shifted>><<X:HI16>>:$src2)
08258       // Emits: (XORIS:i32 GPRC:i32:$src1, (HI16:i32 (imm:i32):$src2))
08259       // Pattern complexity = 5  cost = 1
08260       if (Predicate_imm16Shifted(N1.Val) &&
08261           N.Val->getValueType(0) == MVT::i32) {
08262         Select(Tmp0, N0);
08263         unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
08264         Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
08265         Tmp2 = Transform_HI16(Tmp1.Val);
08266         if (N.Val->hasOneUse()) {
08267           Result = CurDAG->SelectNodeTo(N.Val, PPC::XORIS, MVT::i32, Tmp0, Tmp2);
08268         } else {
08269           ResNode = CurDAG->getTargetNode(PPC::XORIS, MVT::i32, Tmp0, Tmp2);
08270           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08271           Result = SDOperand(ResNode, 0);
08272         }
08273         return;
08274       }
08275 
08276       // Pattern: (xor:i32 GPRC:i32:$in, (imm:i32)<<P:Predicate_immAllOnes>>)
08277       // Emits: (NOR:i32 GPRC:i32:$in, GPRC:i32:$in)
08278       // Pattern complexity = 5  cost = 1
08279       if (Predicate_immAllOnes(N1.Val) &&
08280           N.Val->getValueType(0) == MVT::i32) {
08281         Select(Tmp0, N0);
08282         if (N.Val->hasOneUse()) {
08283           Result = CurDAG->SelectNodeTo(N.Val, PPC::NOR, MVT::i32, Tmp0, Tmp0);
08284         } else {
08285           ResNode = CurDAG->getTargetNode(PPC::NOR, MVT::i32, Tmp0, Tmp0);
08286           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08287           Result = SDOperand(ResNode, 0);
08288         }
08289         return;
08290       }
08291     }
08292     if (N1.getOpcode() == ISD::BUILD_VECTOR &&
08293         Predicate_immAllOnesV(N1.Val)) {
08294 
08295       // Pattern: (xor:v16i8 VRRC:v16i8:$vA, (build_vector:v16i8)<<P:Predicate_immAllOnesV>>)
08296       // Emits: (VNOR:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA)
08297       // Pattern complexity = 5  cost = 1
08298       if (N.Val->getValueType(0) == MVT::v16i8) {
08299         Select(Tmp0, N0);
08300         if (N.Val->hasOneUse()) {
08301           Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v16i8, Tmp0, Tmp0);
08302         } else {
08303           ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v16i8, Tmp0, Tmp0);
08304           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08305           Result = SDOperand(ResNode, 0);
08306         }
08307         return;
08308       }
08309 
08310       // Pattern: (xor:v8i16 VRRC:v8i16:$vA, (build_vector:v8i16)<<P:Predicate_immAllOnesV>>)
08311       // Emits: (VNOR:v8i16 VRRC:v16i8:$vA, VRRC:v16i8:$vA)
08312       // Pattern complexity = 5  cost = 1
08313       if (N.Val->getValueType(0) == MVT::v8i16) {
08314         Select(Tmp0, N0);
08315         if (N.Val->hasOneUse()) {
08316           Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v8i16, Tmp0, Tmp0);
08317         } else {
08318           ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v8i16, Tmp0, Tmp0);
08319           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08320           Result = SDOperand(ResNode, 0);
08321         }
08322         return;
08323       }
08324 
08325       // Pattern: (xor:v4i32 VRRC:v4i32:$vA, (build_vector:v4i32)<<P:Predicate_immAllOnesV>>)
08326       // Emits: (VNOR:v4i32 VRRC:v16i8:$vA, VRRC:v16i8:$vA)
08327       // Pattern complexity = 5  cost = 1
08328       if (N.Val->getValueType(0) == MVT::v4i32) {
08329         Select(Tmp0, N0);
08330         if (N.Val->hasOneUse()) {
08331           Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v4i32, Tmp0, Tmp0);
08332         } else {
08333           ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v4i32, Tmp0, Tmp0);
08334           SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08335           Result = SDOperand(ResNode, 0);
08336         }
08337         return;
08338       }
08339     }
08340   }
08341   if (N0.getOpcode() == ISD::BUILD_VECTOR &&
08342       Predicate_immAllOnesV(N0.Val)) {
08343     N1 = N.getOperand(1);
08344 
08345     // Pattern: (xor:v16i8 (build_vector:v16i8)<<P:Predicate_immAllOnesV>>, VRRC:v16i8:$vA)
08346     // Emits: (VNOR:v16i8 VRRC:v16i8:$vA, VRRC:v16i8:$vA)
08347     // Pattern complexity = 5  cost = 1
08348     if (N.Val->getValueType(0) == MVT::v16i8) {
08349       Select(Tmp0, N1);
08350       if (N.Val->hasOneUse()) {
08351         Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v16i8, Tmp0, Tmp0);
08352       } else {
08353         ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v16i8, Tmp0, Tmp0);
08354         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08355         Result = SDOperand(ResNode, 0);
08356       }
08357       return;
08358     }
08359 
08360     // Pattern: (xor:v8i16 (build_vector:v8i16)<<P:Predicate_immAllOnesV>>, VRRC:v8i16:$vA)
08361     // Emits: (VNOR:v8i16 VRRC:v16i8:$vA, VRRC:v16i8:$vA)
08362     // Pattern complexity = 5  cost = 1
08363     if (N.Val->getValueType(0) == MVT::v8i16) {
08364       Select(Tmp0, N1);
08365       if (N.Val->hasOneUse()) {
08366         Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v8i16, Tmp0, Tmp0);
08367       } else {
08368         ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v8i16, Tmp0, Tmp0);
08369         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08370         Result = SDOperand(ResNode, 0);
08371       }
08372       return;
08373     }
08374 
08375     // Pattern: (xor:v4i32 (build_vector:v4i32)<<P:Predicate_immAllOnesV>>, VRRC:v4i32:$vA)
08376     // Emits: (VNOR:v4i32 VRRC:v16i8:$vA, VRRC:v16i8:$vA)
08377     // Pattern complexity = 5  cost = 1
08378     if (N.Val->getValueType(0) == MVT::v4i32) {
08379       Select(Tmp0, N1);
08380       if (N.Val->hasOneUse()) {
08381         Result = CurDAG->SelectNodeTo(N.Val, PPC::VNOR, MVT::v4i32, Tmp0, Tmp0);
08382       } else {
08383         ResNode = CurDAG->getTargetNode(PPC::VNOR, MVT::v4i32, Tmp0, Tmp0);
08384         SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08385         Result = SDOperand(ResNode, 0);
08386       }
08387       return;
08388     }
08389   }
08390   N1 = N.getOperand(1);
08391 
08392   // Pattern: (xor:i32 GPRC:i32:$in, (imm:i32):$imm)
08393   // Emits: (XORIS:i32 (XORI:i32 GPRC:i32:$in, (LO16:i32 (imm:i32):$imm)), (HI16:i32 (imm:i32):$imm))
08394   // Pattern complexity = 4  cost = 2
08395   if (N1.getOpcode() == ISD::Constant &&
08396       N.Val->getValueType(0) == MVT::i32) {
08397     Select(Tmp0, N0);
08398     unsigned Tmp1C = (unsigned)cast<ConstantSDNode>(N1)->getValue();
08399     Tmp1 = CurDAG->getTargetConstant(Tmp1C, MVT::i32);
08400     Tmp2 = Transform_LO16(Tmp1.Val);
08401     Tmp3 = SDOperand(CurDAG->getTargetNode(PPC::XORI, MVT::i32, Tmp0, Tmp2), 0);
08402     Tmp4 = Transform_HI16(Tmp1.Val);
08403     if (N.Val->hasOneUse()) {
08404       Result = CurDAG->SelectNodeTo(N.Val, PPC::XORIS, MVT::i32, Tmp3, Tmp4);
08405     } else {
08406       ResNode = CurDAG->getTargetNode(PPC::XORIS, MVT::i32, Tmp3, Tmp4);
08407       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08408       Result = SDOperand(ResNode, 0);
08409     }
08410     return;
08411   }
08412 
08413   // Pattern: (xor:i32 GPRC:i32:$rS, GPRC:i32:$rB)
08414   // Emits: (XOR:i32 GPRC:i32:$rS, GPRC:i32:$rB)
08415   // Pattern complexity = 2  cost = 1
08416   if (N.Val->getValueType(0) == MVT::i32) {
08417     Select(Tmp0, N0);
08418     Select(Tmp1, N1);
08419     if (N.Val->hasOneUse()) {
08420       Result = CurDAG->SelectNodeTo(N.Val, PPC::XOR, MVT::i32, Tmp0, Tmp1);
08421     } else {
08422       ResNode = CurDAG->getTargetNode(PPC::XOR, MVT::i32, Tmp0, Tmp1);
08423       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08424       Result = SDOperand(ResNode, 0);
08425     }
08426     return;
08427   }
08428 
08429   // Pattern: (xor:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
08430   // Emits: (VXOR:v4i32 VRRC:v4i32:$vA, VRRC:v4i32:$vB)
08431   // Pattern complexity = 2  cost = 1
08432   if (N.Val->getValueType(0) == MVT::v4i32) {
08433     Select(Tmp0, N0);
08434     Select(Tmp1, N1);
08435     if (N.Val->hasOneUse()) {
08436       Result = CurDAG->SelectNodeTo(N.Val, PPC::VXOR, MVT::v4i32, Tmp0, Tmp1);
08437     } else {
08438       ResNode = CurDAG->getTargetNode(PPC::VXOR, MVT::v4i32, Tmp0, Tmp1);
08439       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08440       Result = SDOperand(ResNode, 0);
08441     }
08442     return;
08443   }
08444 
08445   // Pattern: (xor:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B)
08446   // Emits: (VXOR:v16i8 VRRC:v16i8:$A, VRRC:v16i8:$B)
08447   // Pattern complexity = 2  cost = 1
08448   if (N.Val->getValueType(0) == MVT::v16i8) {
08449     Select(Tmp0, N0);
08450     Select(Tmp1, N1);
08451     if (N.Val->hasOneUse()) {
08452       Result = CurDAG->SelectNodeTo(N.Val, PPC::VXOR, MVT::v16i8, Tmp0, Tmp1);
08453     } else {
08454       ResNode = CurDAG->getTargetNode(PPC::VXOR, MVT::v16i8, Tmp0, Tmp1);
08455       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08456       Result = SDOperand(ResNode, 0);
08457     }
08458     return;
08459   }
08460 
08461   // Pattern: (xor:v8i16 VRRC:v8i16:$A, VRRC:v8i16:$B)
08462   // Emits: (VXOR:v8i16 VRRC:v16i8:$A, VRRC:v16i8:$B)
08463   // Pattern complexity = 2  cost = 1
08464   if (N.Val->getValueType(0) == MVT::v8i16) {
08465     Select(Tmp0, N0);
08466     Select(Tmp1, N1);
08467     if (N.Val->hasOneUse()) {
08468       Result = CurDAG->SelectNodeTo(N.Val, PPC::VXOR, MVT::v8i16, Tmp0, Tmp1);
08469     } else {
08470       ResNode = CurDAG->getTargetNode(PPC::VXOR, MVT::v8i16, Tmp0, Tmp1);
08471       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08472       Result = SDOperand(ResNode, 0);
08473     }
08474     return;
08475   }
08476   std::cerr << "Cannot yet select: ";
08477   N.Val->dump(CurDAG);
08478   std::cerr << '\n';
08479   abort();
08480 }
08481 
08482 void Select_zext(SDOperand &Result, SDOperand N) {
08483   SDOperand N0(0, 0);
08484   SDOperand Tmp0(0, 0);
08485   SDOperand Tmp1(0, 0);
08486   SDOperand Tmp2(0, 0);
08487   SDOperand Tmp3(0, 0);
08488   SDNode *ResNode;
08489   N0 = N.getOperand(0);
08490   if (N.Val->getValueType(0) == MVT::i64 &&
08491       N0.Val->getValueType(0) == MVT::i32) {
08492     Select(Tmp0, N0);
08493     Tmp1 = SDOperand(CurDAG->getTargetNode(PPC::OR4To8, MVT::i64, Tmp0, Tmp0), 0);
08494     Tmp2 = CurDAG->getTargetConstant(0, MVT::i32);
08495     Tmp3 = CurDAG->getTargetConstant(32, MVT::i32);
08496     if (N.Val->hasOneUse()) {
08497       Result = CurDAG->SelectNodeTo(N.Val, PPC::RLDICL, MVT::i64, Tmp1, Tmp2, Tmp3);
08498     } else {
08499       ResNode = CurDAG->getTargetNode(PPC::RLDICL, MVT::i64, Tmp1, Tmp2, Tmp3);
08500       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, ResNode, 0);
08501       Result = SDOperand(ResNode, 0);
08502     }
08503     return;
08504   }
08505   std::cerr << "Cannot yet select: ";
08506   N.Val->dump(CurDAG);
08507   std::cerr << '\n';
08508   abort();
08509 }
08510 
08511 void Select_zextld(SDOperand &Result, SDOperand N) {
08512   if (N.ResNo == 1 && N.getValue(0).hasOneUse()) {
08513     SDOperand Dummy = CurDAG->getNode(ISD::HANDLENODE, MVT::Other, N);
08514     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Dummy.Val, 0);
08515     SelectionDAG::InsertISelMapEntry(HandleMap, N.Val, 1, Dummy.Val, 0);
08516     Result = Dummy;
08517     return;
08518   }
08519   SDOperand Chain(0, 0);
08520   SDOperand N1(0, 0);
08521   SDOperand N2(0, 0);
08522   SDOperand N3(0, 0);
08523   SDOperand Tmp0(0, 0);
08524   SDOperand Tmp1(0, 0);
08525   SDNode *ResNode;
08526   Chain = N.getOperand(0);
08527   N1 = N.getOperand(1);
08528   N2 = N.getOperand(2);
08529   N3 = N.getOperand(3);
08530 
08531   // Pattern: (zextld:i32 iaddr:i32:$src, srcvalue:Other:$dummy, i8:Other)
08532   // Emits: (LBZ:i32 iaddr:i32:$src)
08533   // Pattern complexity = 8  cost = 1
08534   if (cast<VTSDNode>(N3)->getVT() == MVT::i8 &&
08535       N.Val->getValueType(0) == MVT::i32 &&
08536       SelectAddrImm(N1, Tmp0, Tmp1)) {
08537     Select(Tmp0, Tmp0);
08538     Select(Tmp1, Tmp1);
08539     Select(Chain, Chain);
08540     ResNode = CurDAG->getTargetNode(PPC::LBZ, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain);
08541     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
08542     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
08543     if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
08544     Result = SDOperand(ResNode, N.ResNo);
08545     return;
08546   }
08547 
08548   // Pattern: (zextld:i32 iaddr:i32:$src, srcvalue:Other:$dummy, i16:Other)
08549   // Emits: (LHZ:i32 iaddr:i32:$src)
08550   // Pattern complexity = 8  cost = 1
08551   if (cast<VTSDNode>(N3)->getVT() == MVT::i16 &&
08552       N.Val->getValueType(0) == MVT::i32 &&
08553       SelectAddrImm(N1, Tmp0, Tmp1)) {
08554     Select(Tmp0, Tmp0);
08555     Select(Tmp1, Tmp1);
08556     Select(Chain, Chain);
08557     ResNode = CurDAG->getTargetNode(PPC::LHZ, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain);
08558     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
08559     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
08560     if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
08561     Result = SDOperand(ResNode, N.ResNo);
08562     return;
08563   }
08564 
08565   // Pattern: (zextld:i32 xaddr:i32:$src, srcvalue:Other:$dummy, i8:Other)
08566   // Emits: (LBZX:i32 xaddr:i32:$src)
08567   // Pattern complexity = 8  cost = 1
08568   if (cast<VTSDNode>(N3)->getVT() == MVT::i8 &&
08569       N.Val->getValueType(0) == MVT::i32 &&
08570       SelectAddrIdx(N1, Tmp0, Tmp1)) {
08571     Select(Tmp0, Tmp0);
08572     Select(Tmp1, Tmp1);
08573     Select(Chain, Chain);
08574     ResNode = CurDAG->getTargetNode(PPC::LBZX, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain);
08575     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
08576     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
08577     if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
08578     Result = SDOperand(ResNode, N.ResNo);
08579     return;
08580   }
08581 
08582   // Pattern: (zextld:i32 xaddr:i32:$src, srcvalue:Other:$dummy, i16:Other)
08583   // Emits: (LHZX:i32 xaddr:i32:$src)
08584   // Pattern complexity = 8  cost = 1
08585   if (cast<VTSDNode>(N3)->getVT() == MVT::i16 &&
08586       N.Val->getValueType(0) == MVT::i32 &&
08587       SelectAddrIdx(N1, Tmp0, Tmp1)) {
08588     Select(Tmp0, Tmp0);
08589     Select(Tmp1, Tmp1);
08590     Select(Chain, Chain);
08591     ResNode = CurDAG->getTargetNode(PPC::LHZX, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain);
08592     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
08593     SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
08594     if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
08595     Result = SDOperand(ResNode, N.ResNo);
08596     return;
08597   }
08598   if (cast<VTSDNode>(N3)->getVT() == MVT::i1 &&
08599       N.Val->getValueType(0) == MVT::i32) {
08600 
08601     // Pattern: (zextld:i32 iaddr:i32:$src, srcvalue:Other:$dummy, i1:Other)
08602     // Emits: (LBZ:i32 iaddr:i32:$src)
08603     // Pattern complexity = 8  cost = 1
08604     if (SelectAddrImm(N1, Tmp0, Tmp1)) {
08605       Select(Tmp0, Tmp0);
08606       Select(Tmp1, Tmp1);
08607       Select(Chain, Chain);
08608       ResNode = CurDAG->getTargetNode(PPC::LBZ, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain);
08609       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
08610       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
08611       if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
08612       Result = SDOperand(ResNode, N.ResNo);
08613       return;
08614     }
08615 
08616     // Pattern: (zextld:i32 xaddr:i32:$src, srcvalue:Other:$dummy, i1:Other)
08617     // Emits: (LBZX:i32 xaddr:i32:$src)
08618     // Pattern complexity = 8  cost = 1
08619     if (SelectAddrIdx(N1, Tmp0, Tmp1)) {
08620       Select(Tmp0, Tmp0);
08621       Select(Tmp1, Tmp1);
08622       Select(Chain, Chain);
08623       ResNode = CurDAG->getTargetNode(PPC::LBZX, MVT::i32, MVT::Other, Tmp0, Tmp1, Chain);
08624       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, ResNode, 0);
08625       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, ResNode, 1);
08626       if (N.ResNo == 0) AddHandleReplacement(N.Val, 1, ResNode, 1);
08627       Result = SDOperand(ResNode, N.ResNo);
08628       return;
08629     }
08630   }
08631   std::cerr << "Cannot yet select: ";
08632   N.Val->dump(CurDAG);
08633   std::cerr << '\n';
08634   abort();
08635 }
08636 
08637 void Select_INLINEASM(SDOperand& Result, SDOperand N) {
08638   std::vector<SDOperand> Ops(N.Val->op_begin(), N.Val->op_end());
08639   Select(Ops[0], N.getOperand(0)); // Select the chain.
08640 
08641   // Select the flag operand.
08642   if (Ops.back().getValueType() == MVT::Flag)
08643     Select(Ops.back(), Ops.back());
08644   SelectInlineAsmMemoryOperands(Ops, *CurDAG);
08645   std::vector<MVT::ValueType> VTs;
08646   VTs.push_back(MVT::Other);
08647   VTs.push_back(MVT::Flag);
08648   SDOperand New = CurDAG->getNode(ISD::INLINEASM, VTs, Ops);
08649   SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, New.Val, 0);
08650   SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, New.Val, 1);
08651   Result = New.getValue(N.ResNo);
08652   return;
08653 }
08654 
08655 // The main instruction selector code.
08656 void SelectCode(SDOperand &Result, SDOperand N) {
08657   if (N.getOpcode() >= ISD::BUILTIN_OP_END &&
08658       N.getOpcode() < (ISD::BUILTIN_OP_END+PPC::INSTRUCTION_LIST_END)) {
08659     Result = N;
08660     return;   // Already selected.
08661   }
08662 
08663   std::map<SDOperand, SDOperand>::iterator CGMI = CodeGenMap.find(N);
08664   if (CGMI != CodeGenMap.end()) {
08665     Result = CGMI->second;
08666     return;
08667   }
08668 
08669   switch (N.getOpcode()) {
08670   default: break;
08671   case ISD::EntryToken:       // These leaves remain the same.
08672   case ISD::BasicBlock:
08673   case ISD::Register:
08674   case ISD::HANDLENODE:
08675   case ISD::TargetConstant:
08676   case ISD::TargetConstantPool:
08677   case ISD::TargetFrameIndex:
08678   case ISD::TargetGlobalAddress: {
08679     Result = N;
08680     return;
08681   }
08682   case ISD::AssertSext:
08683   case ISD::AssertZext: {
08684     SDOperand Tmp0;
08685     Select(Tmp0, N.getOperand(0));
08686     if (!N.Val->hasOneUse())
08687       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, Tmp0.Val, Tmp0.ResNo);
08688     Result = Tmp0;
08689     return;
08690   }
08691   case ISD::TokenFactor:
08692     if (N.getNumOperands() == 2) {
08693       SDOperand Op0, Op1;
08694       Select(Op0, N.getOperand(0));
08695       Select(Op1, N.getOperand(1));
08696       Result = 
08697           CurDAG->getNode(ISD::TokenFactor, MVT::Other, Op0, Op1);
08698       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, Result.Val, Result.ResNo);
08699     } else {
08700       std::vector<SDOperand> Ops;
08701       for (unsigned i = 0, e = N.getNumOperands(); i != e; ++i) {
08702         SDOperand Val;
08703         Select(Val, N.getOperand(i));
08704         Ops.push_back(Val);
08705       }
08706       Result = 
08707           CurDAG->getNode(ISD::TokenFactor, MVT::Other, Ops);
08708       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, Result.Val, Result.ResNo);
08709     }
08710     return;
08711   case ISD::CopyFromReg: {
08712     SDOperand Chain;
08713     Select(Chain, N.getOperand(0));
08714     unsigned Reg = cast<RegisterSDNode>(N.getOperand(1))->getReg();
08715     MVT::ValueType VT = N.Val->getValueType(0);
08716     if (N.Val->getNumValues() == 2) {
08717       if (Chain == N.getOperand(0)) {
08718         Result = N; // No change
08719         return;
08720       }
08721       SDOperand New = CurDAG->getCopyFromReg(Chain, Reg, VT);
08722       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, New.Val, 0);
08723       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, New.Val, 1);
08724       Result = New.getValue(N.ResNo);
08725       return;
08726     } else {
08727       SDOperand Flag;
08728       if (N.getNumOperands() == 3) Select(Flag, N.getOperand(2));
08729       if (Chain == N.getOperand(0) &&
08730           (N.getNumOperands() == 2 || Flag == N.getOperand(2))) {
08731         Result = N; // No change
08732         return;
08733       }
08734       SDOperand New = CurDAG->getCopyFromReg(Chain, Reg, VT, Flag);
08735       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, New.Val, 0);
08736       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, New.Val, 1);
08737       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 2, New.Val, 2);
08738       Result = New.getValue(N.ResNo);
08739       return;
08740     }
08741   }
08742   case ISD::CopyToReg: {
08743     SDOperand Chain;
08744     Select(Chain, N.getOperand(0));
08745     unsigned Reg = cast<RegisterSDNode>(N.getOperand(1))->getReg();
08746     SDOperand Val;
08747     Select(Val, N.getOperand(2));
08748     Result = N;
08749     if (N.Val->getNumValues() == 1) {
08750       if (Chain != N.getOperand(0) || Val != N.getOperand(2))
08751         Result = CurDAG->getCopyToReg(Chain, Reg, Val);
08752       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Result.Val, 0);
08753     } else {
08754       SDOperand Flag(0, 0);
08755       if (N.getNumOperands() == 4) Select(Flag, N.getOperand(3));
08756       if (Chain != N.getOperand(0) || Val != N.getOperand(2) ||
08757           (N.getNumOperands() == 4 && Flag != N.getOperand(3)))
08758         Result = CurDAG->getCopyToReg(Chain, Reg, Val, Flag);
08759       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, Result.Val, 0);
08760       SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, Result.Val, 1);
08761       Result = Result.getValue(N.ResNo);
08762     }
08763     return;
08764   }
08765   case ISD::INLINEASM:  Select_INLINEASM(Result, N); return;
08766   case PPCISD::EXTSW_32:         Select_PPCextsw_32(Result, N); return;
08767   case PPCISD::FCFID:            Select_PPCfcfid(Result, N); return;
08768   case PPCISD::FCTIDZ:           Select_PPCfctidz(Result, N); return;
08769   case PPCISD::FCTIWZ:           Select_PPCfctiwz(Result, N); return;
08770   case PPCISD::FSEL:             Select_PPCfsel(Result, N); return;
08771   case PPCISD::Hi:               Select_PPChi(Result, N); return;
08772   case PPCISD::Lo:               Select_PPClo(Result, N); return;
08773   case PPCISD::SHL:              Select_PPCshl(Result, N); return;
08774   case PPCISD::SRA:              Select_PPCsra(Result, N); return;
08775   case PPCISD::SRL:              Select_PPCsrl(Result, N); return;
08776   case PPCISD::STD_32:           Select_PPCstd_32(Result, N); return;
08777   case PPCISD::STFIWX:           Select_PPCstfiwx(Result, N); return;
08778   case PPCISD::VCMP:             Select_PPCvcmp(Result, N); return;
08779   case PPCISD::VCMPo:            Select_PPCvcmp_o(Result, N); return;
08780   case PPCISD::VMADDFP:          Select_PPCvmaddfp(Result, N); return;
08781   case PPCISD::VNMSUBFP:         Select_PPCvnmsubfp(Result, N); return;
08782   case PPCISD::VPERM:            Select_PPCvperm(Result, N); return;
08783   case ISD::ADD:                 Select_add(Result, N); return;
08784   case ISD::ADDC:                Select_addc(Result, N); return;
08785   case ISD::ADDE:                Select_adde(Result, N); return;
08786   case ISD::AND:                 Select_and(Result, N); return;
08787   case ISD::ANY_EXTEND:          Select_anyext(Result, N); return;
08788   case ISD::BIT_CONVERT:         Select_bitconvert(Result, N); return;
08789   case ISD::BR:                  Select_br(Result, N); return;
08790   case ISD::BUILD_VECTOR:        Select_build_vector(Result, N); return;
08791   case ISD::CALLSEQ_END:         Select_callseq_end(Result, N); return;
08792   case ISD::CALLSEQ_START:       Select_callseq_start(Result, N); return;
08793   case ISD::CTLZ:                Select_ctlz(Result, N); return;
08794   case ISD::DEBUG_LABEL:         Select_dwarf_label(Result, N); return;
08795   case ISD::DEBUG_LOC:           Select_dwarf_loc(Result, N); return;
08796   case ISD::EXTLOAD:             Select_extld(Result, N); return;
08797   case ISD::FABS:                Select_fabs(Result, N); return;
08798   case ISD::FADD:                Select_fadd(Result, N); return;
08799   case ISD::FDIV:                Select_fdiv(Result, N); return;
08800   case ISD::FP_EXTEND:           Select_fextend(Result, N); return;
08801   case ISD::FMUL:                Select_fmul(Result, N); return;
08802   case ISD::FNEG:                Select_fneg(Result, N); return;
08803   case ISD::FP_ROUND:            Select_fround(Result, N); return;
08804   case ISD::FSQRT:               Select_fsqrt(Result, N); return;
08805   case ISD::FSUB:                Select_fsub(Result, N); return;
08806   case ISD::Constant:            Select_imm(Result, N); return;
08807   case ISD::INTRINSIC_VOID:      Select_intrinsic_void(Result, N); return;
08808   case ISD::INTRINSIC_W_CHAIN:   Select_intrinsic_w_chain(Result, N); return;
08809   case ISD::INTRINSIC_WO_CHAIN:  Select_intrinsic_wo_chain(Result, N); return;
08810   case ISD::LOAD:                Select_load(Result, N); return;
08811   case ISD::MUL:                 Select_mul(Result, N); return;
08812   case ISD::MULHS:               Select_mulhs(Result, N); return;
08813   case ISD::MULHU:               Select_mulhu(Result, N); return;
08814   case ISD::OR:                  Select_or(Result, N); return;
08815   case ISD::RET:                 Select_ret(Result, N); return;
08816   case PPCISD::RET_FLAG:         Select_retflag(Result, N); return;
08817   case ISD::ROTL:                Select_rotl(Result, N); return;
08818   case ISD::SDIV:                Select_sdiv(Result, N); return;
08819   case ISD::SIGN_EXTEND_INREG:   Select_sext_inreg(Result, N); return;
08820   case ISD::SEXTLOAD:            Select_sextld(Result, N); return;
08821   case ISD::SHL:                 Select_shl(Result, N); return;
08822   case ISD::SRA:                 Select_sra(Result, N); return;
08823   case ISD::SRL:                 Select_srl(Result, N); return;
08824   case ISD::STORE:               Select_store(Result, N); return;
08825   case ISD::SUB:                 Select_sub(Result, N); return;
08826   case ISD::SUBC:                Select_subc(Result, N); return;
08827   case ISD::SUBE:                Select_sube(Result, N); return;
08828   case ISD::TRUNCATE:            Select_trunc(Result, N); return;
08829   case ISD::TRUNCSTORE:          Select_truncst(Result, N); return;
08830   case ISD::UDIV:                Select_udiv(Result, N); return;
08831   case ISD::UNDEF:               Select_undef(Result, N); return;
08832   case ISD::VECTOR_SHUFFLE:      Select_vector_shuffle(Result, N); return;
08833   case ISD::XOR:                 Select_xor(Result, N); return;
08834   case ISD::ZERO_EXTEND:         Select_zext(Result, N); return;
08835   case ISD::ZEXTLOAD:            Select_zextld(Result, N); return;
08836   } // end of big switch.
08837 
08838   std::cerr << "Cannot yet select: ";
08839   if (N.getOpcode() != ISD::INTRINSIC_W_CHAIN &&
08840       N.getOpcode() != ISD::INTRINSIC_WO_CHAIN &&
08841       N.getOpcode() != ISD::INTRINSIC_VOID) {
08842     N.Val->dump(CurDAG);
08843   } else {
08844     unsigned iid = cast<ConstantSDNode>(N.getOperand(N.getOperand(0).getValueType() == MVT::Other))->getValue();
08845     std::cerr << "intrinsic %"<< Intrinsic::getName((Intrinsic::ID)iid);
08846   }
08847   std::cerr << '\n';
08848   abort();
08849 }