13e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===-- LegalizeDAG.cpp - Implement SelectionDAG::Legalize ----------------===// 2edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 33e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// The LLVM Compiler Infrastructure 43e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 83e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 93e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// This file implements the SelectionDAG::Legalize method. 113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 133e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 143d2125c9dbac695c93f42c0f59fd040e413fd711Evan Cheng#include "llvm/Analysis/DebugInfo.h" 153d2125c9dbac695c93f42c0f59fd040e413fd711Evan Cheng#include "llvm/CodeGen/Analysis.h" 163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/CodeGen/MachineFunction.h" 17acd80ac7bb19f8bdfa55336d567c9ecbe695c8b8Jim Laskey#include "llvm/CodeGen/MachineJumpTableInfo.h" 183d2125c9dbac695c93f42c0f59fd040e413fd711Evan Cheng#include "llvm/CodeGen/SelectionDAG.h" 1916c29b5f285f375be53dabaa73e3e91107485fe4Anton Korobeynikov#include "llvm/Target/TargetFrameLowering.h" 203e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/Target/TargetLowering.h" 21e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner#include "llvm/Target/TargetData.h" 223d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng#include "llvm/Target/TargetMachine.h" 23adf6a965a321372c640845407195594835921eb4Chris Lattner#include "llvm/CallingConv.h" 243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/Constants.h" 25c10305743c313558405079452138f03124e87581Reid Spencer#include "llvm/DerivedTypes.h" 269adc0abad3c3ed40a268ccbcee0c74cb9e1359feOwen Anderson#include "llvm/LLVMContext.h" 27993aacedfdc3f156f667b4efa280ee79eab3b898David Greene#include "llvm/Support/Debug.h" 28e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach#include "llvm/Support/ErrorHandling.h" 29dc84650679b6330e0fcdd4cf8bc2a351387db7caDuncan Sands#include "llvm/Support/MathExtras.h" 3045cfe545ec8177262dabc70580ce05feaa1c3880Chris Lattner#include "llvm/Support/raw_ostream.h" 317971514755a08ec156a1b9c0f7f05d67919c56b7Chris Lattner#include "llvm/ADT/DenseMap.h" 32f06f35e30b4c4d7db304f717a3d4dc6595fbd078Chris Lattner#include "llvm/ADT/SmallVector.h" 3300755df36c1448ac4728a74d907aa09e3d8b2d49Chris Lattner#include "llvm/ADT/SmallPtrSet.h" 343e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerusing namespace llvm; 353e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// SelectionDAGLegalize - This takes an arbitrary SelectionDAG as input and 383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// hacks on it until the target machine can handle it. This involves 393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// eliminating value sizes the machine cannot handle (promoting small sizes to 403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// large sizes or splitting up large values into small values) as well as 413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// eliminating operations the machine cannot handle. 423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// This code also does a small amount of optimization and recognition of idioms 443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// as part of its processing. For example, if a target does not support a 453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 'setcc' instruction efficiently, but does support 'brcc' instruction, this 463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// will attempt merge setcc and brc instructions into brcc's. 473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnernamespace { 4965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohmanclass SelectionDAGLegalize : public SelectionDAG::DAGUpdateListener { 5055e59c186303ff02c0be7429da3b1b36c347f164Dan Gohman const TargetMachine &TM; 51d858e90f039f5fcdc2fa93035e911a5a9505cc50Dan Gohman const TargetLowering &TLI; 523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SelectionDAG &DAG; 533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 5465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman /// LegalizePosition - The iterator for walking through the node list. 5565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SelectionDAG::allnodes_iterator LegalizePosition; 566f3ddef7c51f03945644ad0e69068dfb24d4b092Dan Gohman 5765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman /// LegalizedNodes - The set of nodes which have already been legalized. 5865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SmallPtrSet<SDNode *, 16> LegalizedNodes; 596f3ddef7c51f03945644ad0e69068dfb24d4b092Dan Gohman 6065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman // Libcall insertion helpers. 618afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner 623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerpublic: 63975716af1b9a09274df6c2d92683449015bd8564Dan Gohman explicit SelectionDAGLegalize(SelectionDAG &DAG); 643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 653e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void LegalizeDAG(); 663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 67456a93afcec7740c45cafa8354317f7b17987a6dChris Lattnerprivate: 6865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman /// LegalizeOp - Legalizes the given operation. 6965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman void LegalizeOp(SDNode *Node); 70fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 717ef3d178660b82d1571757e49f44b004d772a116Eli Friedman SDValue OptimizeFloatStore(StoreSDNode *ST); 727ef3d178660b82d1571757e49f44b004d772a116Eli Friedman 736867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman /// PerformInsertVectorEltInMemory - Some target cannot handle a variable 746867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman /// insertion index for the INSERT_VECTOR_ELT instruction. In this case, it 756867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman /// is necessary to spill the vector being inserted into to memory, perform 766867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman /// the insert there, and then read the result back. 77475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue PerformInsertVectorEltInMemory(SDValue Vec, SDValue Val, 783f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman SDValue Idx, DebugLoc dl); 793f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman SDValue ExpandINSERT_VECTOR_ELT(SDValue Vec, SDValue Val, 803f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman SDValue Idx, DebugLoc dl); 81826695281344e3a4c4d44d73dd155107aafd689bDan Gohman 825a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman /// ShuffleWithNarrowerEltType - Return a vector shuffle operation which 835a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman /// performs the same shuffe in terms of order or result bytes, but on a type 845a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman /// whose vector element type is narrower than the original shuffle type. 855a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman /// e.g. <v4i32> <0, 1, 0, 1> -> v8i16 <0, 1, 2, 3, 0, 1, 2, 3> 86e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue ShuffleWithNarrowerEltType(EVT NVT, EVT VT, DebugLoc dl, 876e9926108a69efbc11f1cadf947e98500e4d4228Jim Grosbach SDValue N1, SDValue N2, 88ed4c8c633c52a40ad1a3e8687f290be4aeb1f0e8Benjamin Kramer ArrayRef<int> Mask) const; 89fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 90e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson void LegalizeSetCCCondCode(EVT VT, SDValue &LHS, SDValue &RHS, SDValue &CC, 91775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling DebugLoc dl); 92fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 9347b41f7e20b6af7aaaf0e050200102d55d038b9dEli Friedman SDValue ExpandLibCall(RTLIB::Libcall LC, SDNode *Node, bool isSigned); 94abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher SDValue ExpandLibCall(RTLIB::Libcall LC, EVT RetVT, const SDValue *Ops, 95abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher unsigned NumOps, bool isSigned, DebugLoc dl); 96abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher 97e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach std::pair<SDValue, SDValue> ExpandChainLibCall(RTLIB::Libcall LC, 98e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach SDNode *Node, bool isSigned); 99f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman SDValue ExpandFPLibCall(SDNode *Node, RTLIB::Libcall Call_F32, 100f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_F64, RTLIB::Libcall Call_F80, 101f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_PPCF128); 1028983da729aa1ca99a11a3b98ae6280dfcdbadb39Anton Korobeynikov SDValue ExpandIntLibCall(SDNode *Node, bool isSigned, 1038983da729aa1ca99a11a3b98ae6280dfcdbadb39Anton Korobeynikov RTLIB::Libcall Call_I8, 1048983da729aa1ca99a11a3b98ae6280dfcdbadb39Anton Korobeynikov RTLIB::Libcall Call_I16, 1058983da729aa1ca99a11a3b98ae6280dfcdbadb39Anton Korobeynikov RTLIB::Libcall Call_I32, 1068983da729aa1ca99a11a3b98ae6280dfcdbadb39Anton Korobeynikov RTLIB::Libcall Call_I64, 107f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_I128); 10865279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng void ExpandDivRemLibCall(SDNode *Node, SmallVectorImpl<SDValue> &Results); 109475871a144eb604ddaf37503397ba0941442e5fbDan Gohman 110e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue EmitStackConvert(SDValue SrcOp, EVT SlotVT, EVT DestVT, DebugLoc dl); 111475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue ExpandBUILD_VECTOR(SDNode *Node); 112475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue ExpandSCALAR_TO_VECTOR(SDNode *Node); 1134bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman void ExpandDYNAMIC_STACKALLOC(SDNode *Node, 1144bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SmallVectorImpl<SDValue> &Results); 1154bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue ExpandFCOPYSIGN(SDNode *Node); 116e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue ExpandLegalINT_TO_FP(bool isSigned, SDValue LegalOp, EVT DestVT, 117af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl); 118e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue PromoteLegalINT_TO_FP(SDValue LegalOp, EVT DestVT, bool isSigned, 119af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl); 120e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue PromoteLegalFP_TO_INT(SDValue LegalOp, EVT DestVT, bool isSigned, 121af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl); 122475871a144eb604ddaf37503397ba0941442e5fbDan Gohman 1238a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen SDValue ExpandBSWAP(SDValue Op, DebugLoc dl); 1248a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen SDValue ExpandBitCount(unsigned Opc, SDValue Op, DebugLoc dl); 125475871a144eb604ddaf37503397ba0941442e5fbDan Gohman 1263d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman SDValue ExpandExtractFromVectorThroughStack(SDValue Op); 127cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene SDValue ExpandInsertToVectorThroughStack(SDValue Op); 1287ef3d178660b82d1571757e49f44b004d772a116Eli Friedman SDValue ExpandVectorBuildThroughStack(SDNode* Node); 1298c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman 13065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue ExpandConstantFP(ConstantFPSDNode *CFP, bool UseCP); 13165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman 132e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach std::pair<SDValue, SDValue> ExpandAtomic(SDNode *Node); 133e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach 13465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman void ExpandNode(SDNode *Node); 13565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman void PromoteNode(SDNode *Node); 13665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman 1370e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman void ForgetNode(SDNode *N) { 13865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman LegalizedNodes.erase(N); 13965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman if (LegalizePosition == SelectionDAG::allnodes_iterator(N)) 14065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman ++LegalizePosition; 14165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman } 14265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman 1430e3642a58746a26f50709179a2bcb25f335e2dacEli Friedmanpublic: 1440e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman // DAGUpdateListener implementation. 1450e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman virtual void NodeDeleted(SDNode *N, SDNode *E) { 1460e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ForgetNode(N); 1470e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman } 14865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman virtual void NodeUpdated(SDNode *N) {} 1490e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman 1500e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman // Node replacement helpers 1510e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman void ReplacedNode(SDNode *N) { 1520e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman if (N->use_empty()) { 1530e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman DAG.RemoveDeadNode(N, this); 1540e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman } else { 1550e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ForgetNode(N); 1560e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman } 1570e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman } 1580e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman void ReplaceNode(SDNode *Old, SDNode *New) { 1590e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman DAG.ReplaceAllUsesWith(Old, New, this); 1600e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ReplacedNode(Old); 1610e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman } 1620e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman void ReplaceNode(SDValue Old, SDValue New) { 1630e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman DAG.ReplaceAllUsesWith(Old, New, this); 1640e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ReplacedNode(Old.getNode()); 1650e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman } 1660e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman void ReplaceNode(SDNode *Old, const SDValue *New) { 1670e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman DAG.ReplaceAllUsesWith(Old, New, this); 1680e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ReplacedNode(Old); 1690e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman } 1703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner}; 1713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 1723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1735a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman/// ShuffleWithNarrowerEltType - Return a vector shuffle operation which 1745a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman/// performs the same shuffe in terms of order or result bytes, but on a type 1755a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman/// whose vector element type is narrower than the original shuffle type. 1769008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman/// e.g. <v4i32> <0, 1, 0, 1> -> v8i16 <0, 1, 2, 3, 0, 1, 2, 3> 1776e9926108a69efbc11f1cadf947e98500e4d4228Jim GrosbachSDValue 1786e9926108a69efbc11f1cadf947e98500e4d4228Jim GrosbachSelectionDAGLegalize::ShuffleWithNarrowerEltType(EVT NVT, EVT VT, DebugLoc dl, 1795a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman SDValue N1, SDValue N2, 180ed4c8c633c52a40ad1a3e8687f290be4aeb1f0e8Benjamin Kramer ArrayRef<int> Mask) const { 1815a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman unsigned NumMaskElts = VT.getVectorNumElements(); 1825a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman unsigned NumDestElts = NVT.getVectorNumElements(); 1839008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman unsigned NumEltsGrowth = NumDestElts / NumMaskElts; 1849008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman 1859008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman assert(NumEltsGrowth && "Cannot promote to vector type with fewer elts!"); 1869008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman 1879008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman if (NumEltsGrowth == 1) 1889008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman return DAG.getVectorShuffle(NVT, dl, N1, N2, &Mask[0]); 1896e9926108a69efbc11f1cadf947e98500e4d4228Jim Grosbach 1909008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman SmallVector<int, 8> NewMask; 1915a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman for (unsigned i = 0; i != NumMaskElts; ++i) { 1929008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman int Idx = Mask[i]; 1939008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman for (unsigned j = 0; j != NumEltsGrowth; ++j) { 1946e9926108a69efbc11f1cadf947e98500e4d4228Jim Grosbach if (Idx < 0) 1959008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman NewMask.push_back(-1); 1969008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman else 1979008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman NewMask.push_back(Idx * NumEltsGrowth + j); 1984352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner } 19915684b29552393553524171bff1913e750f390f8Rafael Espindola } 2005a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman assert(NewMask.size() == NumDestElts && "Non-integer NumEltsGrowth?"); 2019008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman assert(TLI.isShuffleMaskLegal(NewMask, NVT) && "Shuffle not legal?"); 2029008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman return DAG.getVectorShuffle(NVT, dl, N1, N2, &NewMask[0]); 2034352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner} 2044352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner 205975716af1b9a09274df6c2d92683449015bd8564Dan GohmanSelectionDAGLegalize::SelectionDAGLegalize(SelectionDAG &dag) 20655e59c186303ff02c0be7429da3b1b36c347f164Dan Gohman : TM(dag.getTarget()), TLI(dag.getTargetLoweringInfo()), 207ea0270298de4d2a4186454fc39a6836e99271f1dDan Gohman DAG(dag) { 2083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 2093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::LegalizeDAG() { 211f06c835f769aa1cf67801ed1f6bd366a447c18b1Dan Gohman DAG.AssignTopologicalOrder(); 2126f3ddef7c51f03945644ad0e69068dfb24d4b092Dan Gohman 21365fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman // Visit all the nodes. We start in topological order, so that we see 21465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman // nodes with their original operands intact. Legalization can produce 21565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman // new nodes which may themselves need to be legalized. Iterate until all 21665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman // nodes have been legalized. 21765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman for (;;) { 21865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman bool AnyLegalized = false; 21965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman for (LegalizePosition = DAG.allnodes_end(); 22065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman LegalizePosition != DAG.allnodes_begin(); ) { 22165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman --LegalizePosition; 22265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman 22365fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDNode *N = LegalizePosition; 22465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman if (LegalizedNodes.insert(N)) { 22565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman AnyLegalized = true; 22665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman LegalizeOp(N); 22765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman } 228a304d02791b3e0297a9d545e0c602c9f916691f9Stuart Hastings } 22965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman if (!AnyLegalized) 2302ba60e593012ba9b2a9d20b86733eadca288bcb2Dan Gohman break; 2316831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 232c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner } 2336831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 23465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman // Remove dead nodes now. 23565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG.RemoveDeadNodes(); 2366831a815999dde4cf801e2076e66b4943964daf2Chris Lattner} 2376831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 2389f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng/// ExpandConstantFP - Expands the ConstantFP node to an integer constant or 2399f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng/// a load from the constant pool. 24065fd6564b8aedd053845c81ede1ac594acb470e4Dan GohmanSDValue 24165fd6564b8aedd053845c81ede1ac594acb470e4Dan GohmanSelectionDAGLegalize::ExpandConstantFP(ConstantFPSDNode *CFP, bool UseCP) { 242004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng bool Extend = false; 24333c960f523f2308482d5b2816af46a7ec90a6d3dDale Johannesen DebugLoc dl = CFP->getDebugLoc(); 244004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng 245004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng // If a FP immediate is precise when represented as a float and if the 246004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng // target can do an extending load from float to double, we put it into 247004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng // the constant pool as a float, even if it's is statically typed as a 248aa2acbbbf06348f20274f4eeb77f9761c654a589Chris Lattner // double. This shrinks FP constants and canonicalizes them for targets where 249aa2acbbbf06348f20274f4eeb77f9761c654a589Chris Lattner // an FP extending load is the same cost as a normal load (such as on the x87 250aa2acbbbf06348f20274f4eeb77f9761c654a589Chris Lattner // fp stack or PPC FP unit). 251e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = CFP->getValueType(0); 2524fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman ConstantFP *LLVMC = const_cast<ConstantFP*>(CFP->getConstantFPValue()); 2539f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng if (!UseCP) { 254825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson assert((VT == MVT::f64 || VT == MVT::f32) && "Invalid type expansion"); 2557111b02c734c992b8c97d9918118768026dad79eDale Johannesen return DAG.getConstant(LLVMC->getValueAPF().bitcastToAPInt(), 256825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson (VT == MVT::f64) ? MVT::i64 : MVT::i32); 257279101eb1ac61e2d5b83d5bdcc5be56e710d2cd7Evan Cheng } 258279101eb1ac61e2d5b83d5bdcc5be56e710d2cd7Evan Cheng 259e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT OrigVT = VT; 260e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SVT = VT; 261825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson while (SVT != MVT::f32) { 262825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson SVT = (MVT::SimpleValueType)(SVT.getSimpleVT().SimpleTy - 1); 2637720cb3823d5b5868f9b88b0127277820edcb562Dan Gohman if (ConstantFPSDNode::isValueValidForType(SVT, CFP->getValueAPF()) && 264ef12057737229452c17983faa20857dba441ef05Evan Cheng // Only do this if the target has a native EXTLOAD instruction from 265ef12057737229452c17983faa20857dba441ef05Evan Cheng // smaller type. 2660329466b6b4927f4e6f5d144891fef06a027fec5Evan Cheng TLI.isLoadExtLegal(ISD::EXTLOAD, SVT) && 267aa2acbbbf06348f20274f4eeb77f9761c654a589Chris Lattner TLI.ShouldShrinkFPConstant(OrigVT)) { 268db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SType = SVT.getTypeForEVT(*DAG.getContext()); 269baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson LLVMC = cast<ConstantFP>(ConstantExpr::getFPTrunc(LLVMC, SType)); 270ef12057737229452c17983faa20857dba441ef05Evan Cheng VT = SVT; 271ef12057737229452c17983faa20857dba441ef05Evan Cheng Extend = true; 272ef12057737229452c17983faa20857dba441ef05Evan Cheng } 273004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng } 274004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng 275475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue CPIdx = DAG.getConstantPool(LLVMC, TLI.getPointerTy()); 2761606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned Alignment = cast<ConstantPoolSDNode>(CPIdx)->getAlignment(); 27765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman if (Extend) { 27865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue Result = 27965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG.getExtLoad(ISD::EXTLOAD, dl, OrigVT, 28065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG.getEntryNode(), 28165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman CPIdx, MachinePointerInfo::getConstantPool(), 28265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman VT, false, false, Alignment); 28365fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman return Result; 28465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman } 28565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue Result = 28665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG.getLoad(OrigVT, dl, DAG.getEntryNode(), CPIdx, 287d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper MachinePointerInfo::getConstantPool(), false, false, false, 28865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Alignment); 28965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman return Result; 290004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng} 291004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng 292f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio/// ExpandUnalignedStore - Expands an unaligned store to 2 half-size stores. 29365fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohmanstatic void ExpandUnalignedStore(StoreSDNode *ST, SelectionDAG &DAG, 29465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman const TargetLowering &TLI, 2950e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman SelectionDAGLegalize *DAGLegalize) { 296b91b6001a63ea22cdad1a5392cb2b8a604d8219cEli Friedman assert(ST->getAddressingMode() == ISD::UNINDEXED && 297b91b6001a63ea22cdad1a5392cb2b8a604d8219cEli Friedman "unaligned indexed stores not implemented!"); 298475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Chain = ST->getChain(); 299475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ptr = ST->getBasePtr(); 300475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Val = ST->getValue(); 301e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Val.getValueType(); 302907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen int Alignment = ST->getAlignment(); 303bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl = ST->getDebugLoc(); 30483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (ST->getMemoryVT().isFloatingPoint() || 30583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands ST->getMemoryVT().isVector()) { 30623b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT intVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits()); 30705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands if (TLI.isTypeLegal(intVT)) { 30805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Expand to a bitconvert of the value to the integer type of the 30905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // same size, then a (misaligned) int store. 31005e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // FIXME: Does not handle truncating floating point stores! 311bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck SDValue Result = DAG.getNode(ISD::BITCAST, dl, intVT, Val); 31265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Result = DAG.getStore(Chain, dl, Result, Ptr, ST->getPointerInfo(), 31365fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman ST->isVolatile(), ST->isNonTemporal(), Alignment); 3140e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman DAGLegalize->ReplaceNode(SDValue(ST, 0), Result); 31565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman return; 31605e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands } 3171b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman // Do a (aligned) store to a stack slot, then copy from the stack slot 3181b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman // to the final destination using (unaligned) integer loads and stores. 3191b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman EVT StoredVT = ST->getMemoryVT(); 3201b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman EVT RegVT = 3211b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman TLI.getRegisterType(*DAG.getContext(), 3221b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman EVT::getIntegerVT(*DAG.getContext(), 3231b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman StoredVT.getSizeInBits())); 3241b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman unsigned StoredBytes = StoredVT.getSizeInBits() / 8; 3251b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman unsigned RegBytes = RegVT.getSizeInBits() / 8; 3261b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman unsigned NumRegs = (StoredBytes + RegBytes - 1) / RegBytes; 3271b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman 3281b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman // Make sure the stack slot is also aligned for the register type. 3291b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman SDValue StackPtr = DAG.CreateStackTemporary(StoredVT, RegVT); 3301b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman 3311b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman // Perform the original store, only redirected to the stack slot. 3321b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman SDValue Store = DAG.getTruncStore(Chain, dl, 3331b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman Val, StackPtr, MachinePointerInfo(), 3341b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman StoredVT, false, false, 0); 3351b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman SDValue Increment = DAG.getConstant(RegBytes, TLI.getPointerTy()); 3361b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman SmallVector<SDValue, 8> Stores; 3371b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman unsigned Offset = 0; 3381b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman 3391b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman // Do all but one copies using the full register width. 3401b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman for (unsigned i = 1; i < NumRegs; i++) { 3411b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman // Load one integer register's worth from the stack slot. 3421b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman SDValue Load = DAG.getLoad(RegVT, dl, Store, StackPtr, 3431b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman MachinePointerInfo(), 344d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper false, false, false, 0); 3451b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman // Store it to the final location. Remember the store. 3461b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman Stores.push_back(DAG.getStore(Load.getValue(1), dl, Load, Ptr, 3471b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman ST->getPointerInfo().getWithOffset(Offset), 3481b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman ST->isVolatile(), ST->isNonTemporal(), 3491b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman MinAlign(ST->getAlignment(), Offset))); 3501b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman // Increment the pointers. 3511b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman Offset += RegBytes; 3521b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr, 3531b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman Increment); 3541b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment); 3551b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman } 3561b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman 3571b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman // The last store may be partial. Do a truncating store. On big-endian 3581b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman // machines this requires an extending load from the stack slot to ensure 3591b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman // that the bits are in the right place. 3601b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman EVT MemVT = EVT::getIntegerVT(*DAG.getContext(), 3611b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman 8 * (StoredBytes - Offset)); 3621b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman 3631b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman // Load from the stack slot. 3641b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, RegVT, Store, StackPtr, 3651b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman MachinePointerInfo(), 3661b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman MemVT, false, false, 0); 3671b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman 3681b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman Stores.push_back(DAG.getTruncStore(Load.getValue(1), dl, Load, Ptr, 3691b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman ST->getPointerInfo() 3701b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman .getWithOffset(Offset), 3711b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman MemVT, ST->isVolatile(), 3721b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman ST->isNonTemporal(), 3731b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman MinAlign(ST->getAlignment(), Offset))); 3741b32896bd2a6e001c8513fcf182d5a92ab7d487aDan Gohman // The order of the stores doesn't matter - say it with a TokenFactor. 37565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue Result = 37665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &Stores[0], 37765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Stores.size()); 3780e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman DAGLegalize->ReplaceNode(SDValue(ST, 0), Result); 37965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman return; 380907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen } 38183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(ST->getMemoryVT().isInteger() && 38283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands !ST->getMemoryVT().isVector() && 383907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen "Unaligned store of unknown type."); 384f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // Get the half-size VT 385bceddbdc919fc2ca7bc8c3911586ba93367686f0Ken Dyck EVT NewStoredVT = ST->getMemoryVT().getHalfSizedIntegerVT(*DAG.getContext()); 38683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands int NumBits = NewStoredVT.getSizeInBits(); 387f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio int IncrementSize = NumBits / 8; 388f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 389f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // Divide the stored value in two parts. 39095771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson SDValue ShiftAmount = DAG.getConstant(NumBits, 39195771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson TLI.getShiftAmountTy(Val.getValueType())); 392475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Lo = Val; 393bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Hi = DAG.getNode(ISD::SRL, dl, VT, Val, ShiftAmount); 394f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 395f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // Store the two parts 396475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Store1, Store2; 397bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Store1 = DAG.getTruncStore(Chain, dl, TLI.isLittleEndian()?Lo:Hi, Ptr, 398da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner ST->getPointerInfo(), NewStoredVT, 3991e559443a17d1b335f697551c6263ba60d5dd827David Greene ST->isVolatile(), ST->isNonTemporal(), Alignment); 400bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, 401f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio DAG.getConstant(IncrementSize, TLI.getPointerTy())); 402dc84650679b6330e0fcdd4cf8bc2a351387db7caDuncan Sands Alignment = MinAlign(Alignment, IncrementSize); 403bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Store2 = DAG.getTruncStore(Chain, dl, TLI.isLittleEndian()?Hi:Lo, Ptr, 404da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner ST->getPointerInfo().getWithOffset(IncrementSize), 4051e559443a17d1b335f697551c6263ba60d5dd827David Greene NewStoredVT, ST->isVolatile(), ST->isNonTemporal(), 4061e559443a17d1b335f697551c6263ba60d5dd827David Greene Alignment); 407f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 40865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue Result = 40965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Store1, Store2); 4100e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman DAGLegalize->ReplaceNode(SDValue(ST, 0), Result); 411f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio} 412f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 413f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio/// ExpandUnalignedLoad - Expands an unaligned load to 2 half-size loads. 41465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohmanstatic void 41565fd6564b8aedd053845c81ede1ac594acb470e4Dan GohmanExpandUnalignedLoad(LoadSDNode *LD, SelectionDAG &DAG, 41665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman const TargetLowering &TLI, 41765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue &ValResult, SDValue &ChainResult) { 418b91b6001a63ea22cdad1a5392cb2b8a604d8219cEli Friedman assert(LD->getAddressingMode() == ISD::UNINDEXED && 419b91b6001a63ea22cdad1a5392cb2b8a604d8219cEli Friedman "unaligned indexed loads not implemented!"); 420475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Chain = LD->getChain(); 421475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ptr = LD->getBasePtr(); 422e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = LD->getValueType(0); 423e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT LoadedVT = LD->getMemoryVT(); 424bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl = LD->getDebugLoc(); 42583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (VT.isFloatingPoint() || VT.isVector()) { 42623b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT intVT = EVT::getIntegerVT(*DAG.getContext(), LoadedVT.getSizeInBits()); 42705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands if (TLI.isTypeLegal(intVT)) { 42805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Expand to a (misaligned) integer load of the same size, 42905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // then bitconvert to floating point or vector. 430ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner SDValue newLoad = DAG.getLoad(intVT, dl, Chain, Ptr, LD->getPointerInfo(), 431ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner LD->isVolatile(), 432d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper LD->isNonTemporal(), 433d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper LD->isInvariant(), LD->getAlignment()); 434bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck SDValue Result = DAG.getNode(ISD::BITCAST, dl, LoadedVT, newLoad); 43505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands if (VT.isFloatingPoint() && LoadedVT != VT) 436bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Result = DAG.getNode(ISD::FP_EXTEND, dl, VT, Result); 437907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen 43865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman ValResult = Result; 43965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman ChainResult = Chain; 44065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman return; 441ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner } 442bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 443ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner // Copy the value to a (aligned) stack slot using (unaligned) integer 444ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner // loads and stores, then do a (aligned) load from the stack slot. 445ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner EVT RegVT = TLI.getRegisterType(*DAG.getContext(), intVT); 446ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner unsigned LoadedBytes = LoadedVT.getSizeInBits() / 8; 447ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner unsigned RegBytes = RegVT.getSizeInBits() / 8; 448ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner unsigned NumRegs = (LoadedBytes + RegBytes - 1) / RegBytes; 449ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner 450ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner // Make sure the stack slot is also aligned for the register type. 451ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner SDValue StackBase = DAG.CreateStackTemporary(LoadedVT, RegVT); 452ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner 453ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner SDValue Increment = DAG.getConstant(RegBytes, TLI.getPointerTy()); 454ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner SmallVector<SDValue, 8> Stores; 455ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner SDValue StackPtr = StackBase; 456ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner unsigned Offset = 0; 457ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner 458ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner // Do all but one copies using the full register width. 459ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner for (unsigned i = 1; i < NumRegs; i++) { 460ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner // Load one integer register's worth from the original location. 461ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner SDValue Load = DAG.getLoad(RegVT, dl, Chain, Ptr, 462ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner LD->getPointerInfo().getWithOffset(Offset), 463ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner LD->isVolatile(), LD->isNonTemporal(), 464d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper LD->isInvariant(), 465ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner MinAlign(LD->getAlignment(), Offset)); 46605e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Follow the load with a store to the stack slot. Remember the store. 467ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner Stores.push_back(DAG.getStore(Load.getValue(1), dl, Load, StackPtr, 4686229d0acb8f395552131a7015a5d1e7b2bae2111Chris Lattner MachinePointerInfo(), false, false, 0)); 469ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner // Increment the pointers. 470ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner Offset += RegBytes; 471ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment); 472ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr, 473ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner Increment); 47405e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands } 475ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner 476ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner // The last copy may be partial. Do an extending load. 477ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner EVT MemVT = EVT::getIntegerVT(*DAG.getContext(), 478ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner 8 * (LoadedBytes - Offset)); 479a901129169194881a78b7fd8953e09f55b846d10Stuart Hastings SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, RegVT, Chain, Ptr, 480ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner LD->getPointerInfo().getWithOffset(Offset), 481ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner MemVT, LD->isVolatile(), 482ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner LD->isNonTemporal(), 483ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner MinAlign(LD->getAlignment(), Offset)); 484ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner // Follow the load with a store to the stack slot. Remember the store. 485ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner // On big-endian machines this requires a truncating store to ensure 486ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner // that the bits end up in the right place. 487ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner Stores.push_back(DAG.getTruncStore(Load.getValue(1), dl, Load, StackPtr, 488ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner MachinePointerInfo(), MemVT, 489ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner false, false, 0)); 490ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner 491ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner // The order of the stores doesn't matter - say it with a TokenFactor. 492ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &Stores[0], 493ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner Stores.size()); 494ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner 495ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner // Finally, perform the original load only redirected to the stack slot. 496a901129169194881a78b7fd8953e09f55b846d10Stuart Hastings Load = DAG.getExtLoad(LD->getExtensionType(), dl, VT, TF, StackBase, 497ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner MachinePointerInfo(), LoadedVT, false, false, 0); 498ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner 499ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner // Callers expect a MERGE_VALUES node. 50065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman ValResult = Load; 50165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman ChainResult = TF; 50265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman return; 503907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen } 50483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(LoadedVT.isInteger() && !LoadedVT.isVector() && 505e400af83b3f8b69407a8963f1d2e2c82fa766f33Chris Lattner "Unaligned load of unsupported type."); 506e400af83b3f8b69407a8963f1d2e2c82fa766f33Chris Lattner 5078155d64c2ffab8b17e0fd8e3b7a66fcef6a8ec9dDale Johannesen // Compute the new VT that is half the size of the old one. This is an 5088155d64c2ffab8b17e0fd8e3b7a66fcef6a8ec9dDale Johannesen // integer MVT. 50983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned NumBits = LoadedVT.getSizeInBits(); 510e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT NewLoadedVT; 51123b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson NewLoadedVT = EVT::getIntegerVT(*DAG.getContext(), NumBits/2); 512e400af83b3f8b69407a8963f1d2e2c82fa766f33Chris Lattner NumBits >>= 1; 513fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 514e400af83b3f8b69407a8963f1d2e2c82fa766f33Chris Lattner unsigned Alignment = LD->getAlignment(); 515e400af83b3f8b69407a8963f1d2e2c82fa766f33Chris Lattner unsigned IncrementSize = NumBits / 8; 516f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio ISD::LoadExtType HiExtType = LD->getExtensionType(); 517f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 518f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // If the original load is NON_EXTLOAD, the hi part load must be ZEXTLOAD. 519f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio if (HiExtType == ISD::NON_EXTLOAD) 520f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio HiExtType = ISD::ZEXTLOAD; 521f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 522f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // Load the value in two parts 523475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Lo, Hi; 524f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio if (TLI.isLittleEndian()) { 525a901129169194881a78b7fd8953e09f55b846d10Stuart Hastings Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, VT, Chain, Ptr, LD->getPointerInfo(), 526ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner NewLoadedVT, LD->isVolatile(), 5271e559443a17d1b335f697551c6263ba60d5dd827David Greene LD->isNonTemporal(), Alignment); 528bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, 529f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio DAG.getConstant(IncrementSize, TLI.getPointerTy())); 530a901129169194881a78b7fd8953e09f55b846d10Stuart Hastings Hi = DAG.getExtLoad(HiExtType, dl, VT, Chain, Ptr, 531ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner LD->getPointerInfo().getWithOffset(IncrementSize), 532ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner NewLoadedVT, LD->isVolatile(), 5336e9926108a69efbc11f1cadf947e98500e4d4228Jim Grosbach LD->isNonTemporal(), MinAlign(Alignment,IncrementSize)); 534f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } else { 535a901129169194881a78b7fd8953e09f55b846d10Stuart Hastings Hi = DAG.getExtLoad(HiExtType, dl, VT, Chain, Ptr, LD->getPointerInfo(), 536ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner NewLoadedVT, LD->isVolatile(), 5371e559443a17d1b335f697551c6263ba60d5dd827David Greene LD->isNonTemporal(), Alignment); 538bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, 539f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio DAG.getConstant(IncrementSize, TLI.getPointerTy())); 540a901129169194881a78b7fd8953e09f55b846d10Stuart Hastings Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, VT, Chain, Ptr, 541ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner LD->getPointerInfo().getWithOffset(IncrementSize), 542ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner NewLoadedVT, LD->isVolatile(), 5436e9926108a69efbc11f1cadf947e98500e4d4228Jim Grosbach LD->isNonTemporal(), MinAlign(Alignment,IncrementSize)); 544f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 545f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 546f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // aggregate the two parts 54795771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson SDValue ShiftAmount = DAG.getConstant(NumBits, 54895771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson TLI.getShiftAmountTy(Hi.getValueType())); 549bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Result = DAG.getNode(ISD::SHL, dl, VT, Hi, ShiftAmount); 550bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Result = DAG.getNode(ISD::OR, dl, VT, Result, Lo); 551f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 552825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1), 553f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio Hi.getValue(1)); 554f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 55565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman ValResult = Result; 55665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman ChainResult = TF; 557f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio} 558912095becac923ff614d7b07728eb345ada67765Evan Cheng 5596867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman/// PerformInsertVectorEltInMemory - Some target cannot handle a variable 5606867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman/// insertion index for the INSERT_VECTOR_ELT instruction. In this case, it 5616867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman/// is necessary to spill the vector being inserted into to memory, perform 5626867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman/// the insert there, and then read the result back. 563475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize:: 564bb5da918545efb54857a09c983a5a7f22a7e04d4Dale JohannesenPerformInsertVectorEltInMemory(SDValue Vec, SDValue Val, SDValue Idx, 565bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl) { 566475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp1 = Vec; 567475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp2 = Val; 568475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp3 = Idx; 569fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 5706867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // If the target doesn't support this, we have to spill the input vector 5716867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // to a temporary stack slot, update the element, then reload it. This is 5726867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // badness. We could also load the value into a vector register (either 5736867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // with a "move to register" or "extload into register" instruction, then 5746867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // permute it into place, if the idx is a constant and if the idx is 5756867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // supported by the target. 576e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Tmp1.getValueType(); 577e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT EltVT = VT.getVectorElementType(); 578e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT IdxVT = Tmp3.getValueType(); 579e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT PtrVT = TLI.getPointerTy(); 580475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue StackPtr = DAG.CreateStackTemporary(VT); 5816867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman 582ff89dcb06fbd103373436e2d0ae85f252fae2254Evan Cheng int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex(); 583ff89dcb06fbd103373436e2d0ae85f252fae2254Evan Cheng 5846867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // Store the vector. 585bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, Tmp1, StackPtr, 58685ca1066328639119f94c47a83b698c48b84ebb0Chris Lattner MachinePointerInfo::getFixedStack(SPFI), 5871e559443a17d1b335f697551c6263ba60d5dd827David Greene false, false, 0); 5886867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman 5896867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // Truncate or zero extend offset to target pointer type. 5908e4eb09b1e3571965f49edcdfb56b1375b1b7551Duncan Sands unsigned CastOpc = IdxVT.bitsGT(PtrVT) ? ISD::TRUNCATE : ISD::ZERO_EXTEND; 591bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Tmp3 = DAG.getNode(CastOpc, dl, PtrVT, Tmp3); 5926867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // Add the offset to the index. 593aa9d854b334cab2f29ca6d95413a0946b8a38429Dan Gohman unsigned EltSize = EltVT.getSizeInBits()/8; 594bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Tmp3 = DAG.getNode(ISD::MUL, dl, IdxVT, Tmp3,DAG.getConstant(EltSize, IdxVT)); 595bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue StackPtr2 = DAG.getNode(ISD::ADD, dl, IdxVT, Tmp3, StackPtr); 5966867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // Store the scalar value. 59785ca1066328639119f94c47a83b698c48b84ebb0Chris Lattner Ch = DAG.getTruncStore(Ch, dl, Tmp2, StackPtr2, MachinePointerInfo(), EltVT, 5981e559443a17d1b335f697551c6263ba60d5dd827David Greene false, false, 0); 5996867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // Load the updated vector. 600bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen return DAG.getLoad(VT, dl, Ch, StackPtr, 601d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper MachinePointerInfo::getFixedStack(SPFI), false, false, 602d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper false, 0); 6036867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman} 6046867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman 605e9f1015d1f184a51aaadfd03be0846bd5e7d08a2Mon P Wang 6063f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli FriedmanSDValue SelectionDAGLegalize:: 6073f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli FriedmanExpandINSERT_VECTOR_ELT(SDValue Vec, SDValue Val, SDValue Idx, DebugLoc dl) { 6083f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman if (ConstantSDNode *InsertPos = dyn_cast<ConstantSDNode>(Idx)) { 6093f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // SCALAR_TO_VECTOR requires that the type of the value being inserted 6103f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // match the element type of the vector being created, except for 6113f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // integers in which case the inserted value can be over width. 612e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT EltVT = Vec.getValueType().getVectorElementType(); 6133f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman if (Val.getValueType() == EltVT || 6143f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman (EltVT.isInteger() && Val.getValueType().bitsGE(EltVT))) { 6153f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman SDValue ScVec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, 6163f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman Vec.getValueType(), Val); 6173f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman 6183f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman unsigned NumElts = Vec.getValueType().getVectorNumElements(); 6193f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // We generate a shuffle of InVec and ScVec, so the shuffle mask 6203f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // should be 0,1,2,3,4,5... with the appropriate element replaced with 6213f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // elt 0 of the RHS. 6223f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman SmallVector<int, 8> ShufOps; 6233f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman for (unsigned i = 0; i != NumElts; ++i) 6243f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman ShufOps.push_back(i != InsertPos->getZExtValue() ? i : NumElts); 6253f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman 6263f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman return DAG.getVectorShuffle(Vec.getValueType(), dl, Vec, ScVec, 6273f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman &ShufOps[0]); 6283f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman } 6293f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman } 6303f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman return PerformInsertVectorEltInMemory(Vec, Val, Idx, dl); 6313f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman} 6323f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman 6337ef3d178660b82d1571757e49f44b004d772a116Eli FriedmanSDValue SelectionDAGLegalize::OptimizeFloatStore(StoreSDNode* ST) { 6347ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // Turn 'store float 1.0, Ptr' -> 'store int 0x12345678, Ptr' 6357ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // FIXME: We shouldn't do this for TargetConstantFP's. 6367ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // FIXME: move this to the DAG Combiner! Note that we can't regress due 6377ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // to phase ordering between legalized code and the dag combiner. This 6387ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // probably means that we need to integrate dag combiner and legalizer 6397ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // together. 6407ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // We generally can't do this one for long doubles. 6417ef3d178660b82d1571757e49f44b004d772a116Eli Friedman SDValue Tmp1 = ST->getChain(); 6427ef3d178660b82d1571757e49f44b004d772a116Eli Friedman SDValue Tmp2 = ST->getBasePtr(); 6437ef3d178660b82d1571757e49f44b004d772a116Eli Friedman SDValue Tmp3; 6447ef3d178660b82d1571757e49f44b004d772a116Eli Friedman unsigned Alignment = ST->getAlignment(); 6457ef3d178660b82d1571757e49f44b004d772a116Eli Friedman bool isVolatile = ST->isVolatile(); 6461e559443a17d1b335f697551c6263ba60d5dd827David Greene bool isNonTemporal = ST->isNonTemporal(); 6477ef3d178660b82d1571757e49f44b004d772a116Eli Friedman DebugLoc dl = ST->getDebugLoc(); 6487ef3d178660b82d1571757e49f44b004d772a116Eli Friedman if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(ST->getValue())) { 649825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (CFP->getValueType(0) == MVT::f32 && 65075b10047fc57c30c86bb7c9ea0ee923ff3c33a7eDan Gohman TLI.isTypeLegal(MVT::i32)) { 6517ef3d178660b82d1571757e49f44b004d772a116Eli Friedman Tmp3 = DAG.getConstant(CFP->getValueAPF(). 6527ef3d178660b82d1571757e49f44b004d772a116Eli Friedman bitcastToAPInt().zextOrTrunc(32), 653825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT::i32); 654da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner return DAG.getStore(Tmp1, dl, Tmp3, Tmp2, ST->getPointerInfo(), 655da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner isVolatile, isNonTemporal, Alignment); 656da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner } 657bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 658da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner if (CFP->getValueType(0) == MVT::f64) { 6597ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // If this target supports 64-bit registers, do a single 64-bit store. 66075b10047fc57c30c86bb7c9ea0ee923ff3c33a7eDan Gohman if (TLI.isTypeLegal(MVT::i64)) { 6617ef3d178660b82d1571757e49f44b004d772a116Eli Friedman Tmp3 = DAG.getConstant(CFP->getValueAPF().bitcastToAPInt(). 662825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson zextOrTrunc(64), MVT::i64); 663da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner return DAG.getStore(Tmp1, dl, Tmp3, Tmp2, ST->getPointerInfo(), 664da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner isVolatile, isNonTemporal, Alignment); 665da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner } 666bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 66775b10047fc57c30c86bb7c9ea0ee923ff3c33a7eDan Gohman if (TLI.isTypeLegal(MVT::i32) && !ST->isVolatile()) { 6687ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // Otherwise, if the target supports 32-bit registers, use 2 32-bit 6697ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // stores. If the target supports neither 32- nor 64-bits, this 6707ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // xform is certainly not worth it. 6717ef3d178660b82d1571757e49f44b004d772a116Eli Friedman const APInt &IntVal =CFP->getValueAPF().bitcastToAPInt(); 67240f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad SDValue Lo = DAG.getConstant(IntVal.trunc(32), MVT::i32); 673825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson SDValue Hi = DAG.getConstant(IntVal.lshr(32).trunc(32), MVT::i32); 6747ef3d178660b82d1571757e49f44b004d772a116Eli Friedman if (TLI.isBigEndian()) std::swap(Lo, Hi); 6757ef3d178660b82d1571757e49f44b004d772a116Eli Friedman 676da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner Lo = DAG.getStore(Tmp1, dl, Lo, Tmp2, ST->getPointerInfo(), isVolatile, 677da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner isNonTemporal, Alignment); 6787ef3d178660b82d1571757e49f44b004d772a116Eli Friedman Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2, 6797ef3d178660b82d1571757e49f44b004d772a116Eli Friedman DAG.getIntPtrConstant(4)); 680da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner Hi = DAG.getStore(Tmp1, dl, Hi, Tmp2, 681da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner ST->getPointerInfo().getWithOffset(4), 6821e559443a17d1b335f697551c6263ba60d5dd827David Greene isVolatile, isNonTemporal, MinAlign(Alignment, 4U)); 6837ef3d178660b82d1571757e49f44b004d772a116Eli Friedman 684825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi); 6857ef3d178660b82d1571757e49f44b004d772a116Eli Friedman } 6867ef3d178660b82d1571757e49f44b004d772a116Eli Friedman } 6877ef3d178660b82d1571757e49f44b004d772a116Eli Friedman } 6888e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng return SDValue(0, 0); 6897ef3d178660b82d1571757e49f44b004d772a116Eli Friedman} 6907ef3d178660b82d1571757e49f44b004d772a116Eli Friedman 6916a109f9d70bf7f75541400145a7a89880cc48166Dan Gohman/// LegalizeOp - Return a legal replacement for the given operation, with 6926a109f9d70bf7f75541400145a7a89880cc48166Dan Gohman/// all legal operands. 69365fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohmanvoid SelectionDAGLegalize::LegalizeOp(SDNode *Node) { 69465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman if (Node->getOpcode() == ISD::TargetConstant) // Allow illegal target nodes. 69565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman return; 696fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 6977d2ad624fa749a6d3edac0d94e9c107989c16304Dale Johannesen DebugLoc dl = Node->getDebugLoc(); 698e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner 6991fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 70075b10047fc57c30c86bb7c9ea0ee923ff3c33a7eDan Gohman assert(TLI.getTypeAction(*DAG.getContext(), Node->getValueType(i)) == 70175b10047fc57c30c86bb7c9ea0ee923ff3c33a7eDan Gohman TargetLowering::TypeLegal && 7021fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman "Unexpected illegal type!"); 7031fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman 7041fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) 70575b10047fc57c30c86bb7c9ea0ee923ff3c33a7eDan Gohman assert((TLI.getTypeAction(*DAG.getContext(), 70675b10047fc57c30c86bb7c9ea0ee923ff3c33a7eDan Gohman Node->getOperand(i).getValueType()) == 70775b10047fc57c30c86bb7c9ea0ee923ff3c33a7eDan Gohman TargetLowering::TypeLegal || 7081fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman Node->getOperand(i).getOpcode() == ISD::TargetConstant) && 7091fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman "Unexpected illegal type!"); 7103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 711475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp1, Tmp2, Tmp3, Tmp4; 712456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner bool isCustom = false; 713fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 7148c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // Figure out the correct action; the way to query this varies by opcode 7156b9a293a0c7d86c07d704da5facb34cc03ce1d02Bill Wendling TargetLowering::LegalizeAction Action = TargetLowering::Legal; 7168c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman bool SimpleFinishLegalizing = true; 7173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 7188c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::INTRINSIC_W_CHAIN: 7198c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::INTRINSIC_WO_CHAIN: 7208c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::INTRINSIC_VOID: 7218c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::STACKSAVE: 722825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson Action = TLI.getOperationAction(Node->getOpcode(), MVT::Other); 7238c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 7245194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel case ISD::VAARG: 7255194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel Action = TLI.getOperationAction(Node->getOpcode(), 7265194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel Node->getValueType(0)); 7275194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel if (Action != TargetLowering::Promote) 7285194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel Action = TLI.getOperationAction(Node->getOpcode(), MVT::Other); 7295194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel break; 7308c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SINT_TO_FP: 7318c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::UINT_TO_FP: 7328c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::EXTRACT_VECTOR_ELT: 7338c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Action = TLI.getOperationAction(Node->getOpcode(), 7348c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOperand(0).getValueType()); 7358c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 7368c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FP_ROUND_INREG: 7378c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SIGN_EXTEND_INREG: { 738e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT InnerType = cast<VTSDNode>(Node->getOperand(1))->getVT(); 7398c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Action = TLI.getOperationAction(Node->getOpcode(), InnerType); 7408c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 7418c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 742327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman case ISD::ATOMIC_STORE: { 743327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman Action = TLI.getOperationAction(Node->getOpcode(), 744327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman Node->getOperand(2).getValueType()); 745327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman break; 746327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman } 7473be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman case ISD::SELECT_CC: 7483be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman case ISD::SETCC: 7493be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman case ISD::BR_CC: { 7503be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman unsigned CCOperand = Node->getOpcode() == ISD::SELECT_CC ? 4 : 7513be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman Node->getOpcode() == ISD::SETCC ? 2 : 1; 7523be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman unsigned CompareOperand = Node->getOpcode() == ISD::BR_CC ? 2 : 0; 753e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT OpVT = Node->getOperand(CompareOperand).getValueType(); 7543be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman ISD::CondCode CCCode = 7553be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman cast<CondCodeSDNode>(Node->getOperand(CCOperand))->get(); 7563be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman Action = TLI.getCondCodeAction(CCCode, OpVT); 7573be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman if (Action == TargetLowering::Legal) { 7583be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman if (Node->getOpcode() == ISD::SELECT_CC) 7593be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman Action = TLI.getOperationAction(Node->getOpcode(), 7603be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman Node->getValueType(0)); 7613be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman else 7623be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman Action = TLI.getOperationAction(Node->getOpcode(), OpVT); 7633be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman } 7643be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman break; 7653be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman } 7668c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::LOAD: 7678c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::STORE: 768ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman // FIXME: Model these properly. LOAD and STORE are complicated, and 769ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman // STORE expects the unlegalized operand in some cases. 770ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman SimpleFinishLegalizing = false; 771ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman break; 7728c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::CALLSEQ_START: 7738c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::CALLSEQ_END: 774ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman // FIXME: This shouldn't be necessary. These nodes have special properties 775ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman // dealing with the recursive nature of legalization. Removing this 776ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman // special case should be done as part of making LegalizeDAG non-recursive. 777ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman SimpleFinishLegalizing = false; 778ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman break; 7798c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::EXTRACT_ELEMENT: 7808c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FLT_ROUNDS_: 7818c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SADDO: 7828c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SSUBO: 7838c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::UADDO: 7848c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::USUBO: 7858c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SMULO: 7868c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::UMULO: 7878c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FPOWI: 7888c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::MERGE_VALUES: 7898c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::EH_RETURN: 7908c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FRAME_TO_ARGS_OFFSET: 791c66e150b2cb1f2f8e2f4eb124b9177ffc6ef3a74Jim Grosbach case ISD::EH_SJLJ_SETJMP: 792c66e150b2cb1f2f8e2f4eb124b9177ffc6ef3a74Jim Grosbach case ISD::EH_SJLJ_LONGJMP: 793f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman // These operations lie about being legal: when they claim to be legal, 794f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman // they should actually be expanded. 7958c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Action = TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0)); 7968c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (Action == TargetLowering::Legal) 7978c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Action = TargetLowering::Expand; 7988c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 7994a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands case ISD::INIT_TRAMPOLINE: 8004a544a79bd735967f1d33fe675ae4566dbd17813Duncan Sands case ISD::ADJUST_TRAMPOLINE: 8018c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FRAMEADDR: 8028c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::RETURNADDR: 8034bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman // These operations lie about being legal: when they claim to be legal, 8044bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman // they should actually be custom-lowered. 8054bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman Action = TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0)); 8064bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman if (Action == TargetLowering::Legal) 8074bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman Action = TargetLowering::Custom; 8088c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 8093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 810d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Node->getOpcode() >= ISD::BUILTIN_OP_END) { 8118c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Action = TargetLowering::Legal; 8128c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } else { 8138c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Action = TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0)); 8148c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 8158c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 8168c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 817d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner 8188c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (SimpleFinishLegalizing) { 81965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SmallVector<SDValue, 8> Ops; 8208c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) 82165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Ops.push_back(Node->getOperand(i)); 8228c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman switch (Node->getOpcode()) { 8238c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman default: break; 8248c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SHL: 8258c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SRL: 8268c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SRA: 8278c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::ROTL: 8288c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::ROTR: 8298c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // Legalizing shifts/rotates requires adjusting the shift amount 8308c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // to the appropriate width. 83165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman if (!Ops[1].getValueType().isVector()) { 83265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue SAO = DAG.getShiftAmountOperand(Ops[0].getValueType(), Ops[1]); 83365fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman HandleSDNode Handle(SAO); 83465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman LegalizeOp(SAO.getNode()); 83565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Ops[1] = Handle.getValue(); 83665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman } 8378c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 838db8dc2b9faf346fbfa04c07f501981250948f5e2Dan Gohman case ISD::SRL_PARTS: 839db8dc2b9faf346fbfa04c07f501981250948f5e2Dan Gohman case ISD::SRA_PARTS: 840db8dc2b9faf346fbfa04c07f501981250948f5e2Dan Gohman case ISD::SHL_PARTS: 841db8dc2b9faf346fbfa04c07f501981250948f5e2Dan Gohman // Legalizing shifts/rotates requires adjusting the shift amount 842db8dc2b9faf346fbfa04c07f501981250948f5e2Dan Gohman // to the appropriate width. 84365fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman if (!Ops[2].getValueType().isVector()) { 84465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue SAO = DAG.getShiftAmountOperand(Ops[0].getValueType(), Ops[2]); 84565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman HandleSDNode Handle(SAO); 84665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman LegalizeOp(SAO.getNode()); 84765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Ops[2] = Handle.getValue(); 84865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman } 8492c9489d6e96d99f77b6c31919805b5e61954deb2Dan Gohman break; 8508c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 8518c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman 85265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDNode *NewNode = DAG.UpdateNodeOperands(Node, Ops.data(), Ops.size()); 85365fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman if (NewNode != Node) { 85465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG.ReplaceAllUsesWith(Node, NewNode, this); 85565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 85665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG.TransferDbgValues(SDValue(Node, i), SDValue(NewNode, i)); 8570e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ReplacedNode(Node); 85865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Node = NewNode; 85965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman } 8608c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman switch (Action) { 8618c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case TargetLowering::Legal: 86265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman return; 8638c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case TargetLowering::Custom: 8648c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // FIXME: The handling for custom lowering with multiple results is 8658c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // a complete mess. 86665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp1 = TLI.LowerOperation(SDValue(Node, 0), DAG); 8678c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (Tmp1.getNode()) { 86865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SmallVector<SDValue, 8> ResultVals; 8698c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) { 8708c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (e == 1) 8718c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman ResultVals.push_back(Tmp1); 8728c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman else 8738c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman ResultVals.push_back(Tmp1.getValue(i)); 8748c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 87565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman if (Tmp1.getNode() != Node || Tmp1.getResNo() != 0) { 87665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG.ReplaceAllUsesWith(Node, ResultVals.data(), this); 87765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 87865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG.TransferDbgValues(SDValue(Node, i), ResultVals[i]); 8790e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ReplacedNode(Node); 88065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman } 88165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman return; 8828c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 8838c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman 8848c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // FALL THROUGH 8858c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case TargetLowering::Expand: 88665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman ExpandNode(Node); 88765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman return; 8888c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case TargetLowering::Promote: 88965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman PromoteNode(Node); 89065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman return; 891d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 8928c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 8938c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman 8948c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman switch (Node->getOpcode()) { 8958c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman default: 896e37fe9b3a1cadceb42ac27fa0718f5a10ea2f0e6Jim Laskey#ifndef NDEBUG 897993aacedfdc3f156f667b4efa280ee79eab3b898David Greene dbgs() << "NODE: "; 898993aacedfdc3f156f667b4efa280ee79eab3b898David Greene Node->dump( &DAG); 899993aacedfdc3f156f667b4efa280ee79eab3b898David Greene dbgs() << "\n"; 900e37fe9b3a1cadceb42ac27fa0718f5a10ea2f0e6Jim Laskey#endif 9015e25ee8a1fcf8288d00d731b0f7ab7976f33b123Craig Topper llvm_unreachable("Do not know how to legalize this operator!"); 90298ca4f2a325f72374a477f9deba7d09e8999c29bDan Gohman 90365fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman case ISD::CALLSEQ_START: 9046f3ddef7c51f03945644ad0e69068dfb24d4b092Dan Gohman case ISD::CALLSEQ_END: 90565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman break; 906f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case ISD::LOAD: { 907466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng LoadSDNode *LD = cast<LoadSDNode>(Node); 90865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp1 = LD->getChain(); // Legalize the chain. 90965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp2 = LD->getBasePtr(); // Legalize the base pointer. 9102d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 911466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng ISD::LoadExtType ExtType = LD->getExtensionType(); 912466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng if (ExtType == ISD::NON_EXTLOAD) { 913e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Node->getValueType(0); 91465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp3 = SDValue(Node, 0); 91565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp4 = SDValue(Node, 1); 916fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 917466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng switch (TLI.getOperationAction(Node->getOpcode(), VT)) { 9185e25ee8a1fcf8288d00d731b0f7ab7976f33b123Craig Topper default: llvm_unreachable("This action is not supported yet!"); 919f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio case TargetLowering::Legal: 920f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // If this is an unaligned load and the target doesn't support it, 921f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // expand it. 922bc037cfcdef8e88274d7dd167fb9d8ba545f2229Benjamin Kramer if (!TLI.allowsUnalignedMemoryAccesses(LD->getMemoryVT())) { 923db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = LD->getMemoryVT().getTypeForEVT(*DAG.getContext()); 924e96507c73111d88743a15db6d6329f4fbdde7decEvan Cheng unsigned ABIAlignment = TLI.getTargetData()->getABITypeAlignment(Ty); 925f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio if (LD->getAlignment() < ABIAlignment){ 92665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman ExpandUnalignedLoad(cast<LoadSDNode>(Node), 92765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG, TLI, Tmp3, Tmp4); 928f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 929f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 930f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio break; 931466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng case TargetLowering::Custom: 932466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng Tmp1 = TLI.LowerOperation(Tmp3, DAG); 933ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) { 93465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp3 = Tmp1; 93565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp4 = Tmp1.getValue(1); 936466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng } 937466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng break; 938466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng case TargetLowering::Promote: { 939466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng // Only promote a load of vector type to another. 94083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(VT.isVector() && "Cannot promote this load!"); 941466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng // Change base type to a different vector type. 942e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), VT); 943466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng 944ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner Tmp1 = DAG.getLoad(NVT, dl, Tmp1, Tmp2, LD->getPointerInfo(), 9451e559443a17d1b335f697551c6263ba60d5dd827David Greene LD->isVolatile(), LD->isNonTemporal(), 946d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper LD->isInvariant(), LD->getAlignment()); 94765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp3 = DAG.getNode(ISD::BITCAST, dl, VT, Tmp1); 94865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp4 = Tmp1.getValue(1); 949466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng break; 950f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 951466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng } 9520e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman if (Tmp4.getNode() != Node) { 9530e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman assert(Tmp3.getNode() != Node && "Load must be completely replaced"); 9540e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 0), Tmp3); 9550e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 1), Tmp4); 9560e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ReplacedNode(Node); 9570e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman } 95865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman return; 9593d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner } 960bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 9613d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner EVT SrcVT = LD->getMemoryVT(); 9623d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner unsigned SrcWidth = SrcVT.getSizeInBits(); 9633d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner unsigned Alignment = LD->getAlignment(); 9643d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner bool isVolatile = LD->isVolatile(); 9653d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner bool isNonTemporal = LD->isNonTemporal(); 9663d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner 9673d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner if (SrcWidth != SrcVT.getStoreSizeInBits() && 9683d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // Some targets pretend to have an i1 loading operation, and actually 9693d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // load an i8. This trick is correct for ZEXTLOAD because the top 7 9703d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // bits are guaranteed to be zero; it helps the optimizers understand 9713d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // that these bits are zero. It is also useful for EXTLOAD, since it 9723d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // tells the optimizers that those bits are undefined. It would be 9733d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // nice to have an effective generic way of getting these benefits... 9743d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // Until such a way is found, don't insist on promoting i1 here. 9753d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner (SrcVT != MVT::i1 || 9763d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner TLI.getLoadExtAction(ExtType, MVT::i1) == TargetLowering::Promote)) { 9773d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // Promote to a byte-sized load if not loading an integral number of 9783d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // bytes. For example, promote EXTLOAD:i20 -> EXTLOAD:i24. 9793d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner unsigned NewWidth = SrcVT.getStoreSizeInBits(); 9803d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner EVT NVT = EVT::getIntegerVT(*DAG.getContext(), NewWidth); 9813d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner SDValue Ch; 9823d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner 9833d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // The extra bits are guaranteed to be zero, since we stored them that 9843d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // way. A zext load from NVT thus automatically gives zext from SrcVT. 9853d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner 9863d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner ISD::LoadExtType NewExtType = 9873d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner ExtType == ISD::ZEXTLOAD ? ISD::ZEXTLOAD : ISD::EXTLOAD; 9883d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner 98965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue Result = 99065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG.getExtLoad(NewExtType, dl, Node->getValueType(0), 99165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp1, Tmp2, LD->getPointerInfo(), 99265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman NVT, isVolatile, isNonTemporal, Alignment); 9933d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner 9943d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Ch = Result.getValue(1); // The chain. 9953d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner 9963d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner if (ExtType == ISD::SEXTLOAD) 9973d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // Having the top bits zero doesn't help when sign extending. 9983d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, 9993d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Result.getValueType(), 10003d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Result, DAG.getValueType(SrcVT)); 10013d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner else if (ExtType == ISD::ZEXTLOAD || NVT == Result.getValueType()) 10023d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // All the top bits are guaranteed to be zero - inform the optimizers. 10033d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Result = DAG.getNode(ISD::AssertZext, dl, 10043d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Result.getValueType(), Result, 10053d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner DAG.getValueType(SrcVT)); 10063d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner 100765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp1 = Result; 100865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp2 = Ch; 10093d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner } else if (SrcWidth & (SrcWidth - 1)) { 10103d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // If not loading a power-of-2 number of bits, expand as two loads. 10113d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner assert(!SrcVT.isVector() && "Unsupported extload!"); 10123d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner unsigned RoundWidth = 1 << Log2_32(SrcWidth); 10133d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner assert(RoundWidth < SrcWidth); 10143d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner unsigned ExtraWidth = SrcWidth - RoundWidth; 10153d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner assert(ExtraWidth < RoundWidth); 10163d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner assert(!(RoundWidth % 8) && !(ExtraWidth % 8) && 10173d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner "Load size not an integral number of bytes!"); 10183d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner EVT RoundVT = EVT::getIntegerVT(*DAG.getContext(), RoundWidth); 10193d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner EVT ExtraVT = EVT::getIntegerVT(*DAG.getContext(), ExtraWidth); 10203d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner SDValue Lo, Hi, Ch; 10213d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner unsigned IncrementSize; 10223d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner 10233d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner if (TLI.isLittleEndian()) { 10243d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // EXTLOAD:i24 -> ZEXTLOAD:i16 | (shl EXTLOAD@+2:i8, 16) 10253d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // Load the bottom RoundWidth bits. 1026a901129169194881a78b7fd8953e09f55b846d10Stuart Hastings Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, Node->getValueType(0), 10273d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Tmp1, Tmp2, 10283d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner LD->getPointerInfo(), RoundVT, isVolatile, 10293d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner isNonTemporal, Alignment); 10303d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner 10313d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // Load the remaining ExtraWidth bits. 10323d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner IncrementSize = RoundWidth / 8; 10333d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2, 10343d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner DAG.getIntPtrConstant(IncrementSize)); 1035a901129169194881a78b7fd8953e09f55b846d10Stuart Hastings Hi = DAG.getExtLoad(ExtType, dl, Node->getValueType(0), Tmp1, Tmp2, 10363d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner LD->getPointerInfo().getWithOffset(IncrementSize), 10373d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner ExtraVT, isVolatile, isNonTemporal, 10383d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner MinAlign(Alignment, IncrementSize)); 10393d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner 10403d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // Build a factor node to remember that this load is independent of 10413d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // the other one. 10423d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1), 10433d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Hi.getValue(1)); 10443d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner 10453d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // Move the top bits to the right place. 10463d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Hi = DAG.getNode(ISD::SHL, dl, Hi.getValueType(), Hi, 104795771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson DAG.getConstant(RoundWidth, 104895771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson TLI.getShiftAmountTy(Hi.getValueType()))); 10493d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner 10503d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // Join the hi and lo parts. 105165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp1 = DAG.getNode(ISD::OR, dl, Node->getValueType(0), Lo, Hi); 10523d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner } else { 10533d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // Big endian - avoid unaligned loads. 10543d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // EXTLOAD:i24 -> (shl EXTLOAD:i16, 8) | ZEXTLOAD@+2:i8 10553d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // Load the top RoundWidth bits. 1056a901129169194881a78b7fd8953e09f55b846d10Stuart Hastings Hi = DAG.getExtLoad(ExtType, dl, Node->getValueType(0), Tmp1, Tmp2, 10573d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner LD->getPointerInfo(), RoundVT, isVolatile, 10583d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner isNonTemporal, Alignment); 10593d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner 10603d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // Load the remaining ExtraWidth bits. 10613d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner IncrementSize = RoundWidth / 8; 10623d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2, 10633d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner DAG.getIntPtrConstant(IncrementSize)); 10643d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Lo = DAG.getExtLoad(ISD::ZEXTLOAD, 1065a901129169194881a78b7fd8953e09f55b846d10Stuart Hastings dl, Node->getValueType(0), Tmp1, Tmp2, 10663d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner LD->getPointerInfo().getWithOffset(IncrementSize), 10673d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner ExtraVT, isVolatile, isNonTemporal, 10683d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner MinAlign(Alignment, IncrementSize)); 10693d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner 10703d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // Build a factor node to remember that this load is independent of 10713d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // the other one. 10723d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1), 10733d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Hi.getValue(1)); 10743d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner 10753d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // Move the top bits to the right place. 10763d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Hi = DAG.getNode(ISD::SHL, dl, Hi.getValueType(), Hi, 107795771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson DAG.getConstant(ExtraWidth, 107895771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson TLI.getShiftAmountTy(Hi.getValueType()))); 10793d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner 10803d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // Join the hi and lo parts. 108165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp1 = DAG.getNode(ISD::OR, dl, Node->getValueType(0), Lo, Hi); 10823d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner } 1083f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 108465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp2 = Ch; 10853d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner } else { 10863d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner switch (TLI.getLoadExtAction(ExtType, SrcVT)) { 10875e25ee8a1fcf8288d00d731b0f7ab7976f33b123Craig Topper default: llvm_unreachable("This action is not supported yet!"); 10883d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner case TargetLowering::Custom: 10893d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner isCustom = true; 10903d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // FALLTHROUGH 10913d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner case TargetLowering::Legal: 109265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp1 = SDValue(Node, 0); 109365fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp2 = SDValue(Node, 1); 10943d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner 10953d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner if (isCustom) { 109665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp3 = TLI.LowerOperation(SDValue(Node, 0), DAG); 10973d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner if (Tmp3.getNode()) { 109865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp1 = Tmp3; 109965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp2 = Tmp3.getValue(1); 11003d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner } 1101f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } else { 11023d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // If this is an unaligned load and the target doesn't support it, 11033d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // expand it. 11043d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner if (!TLI.allowsUnalignedMemoryAccesses(LD->getMemoryVT())) { 1105db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = 11063d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner LD->getMemoryVT().getTypeForEVT(*DAG.getContext()); 11073d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner unsigned ABIAlignment = 11083d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner TLI.getTargetData()->getABITypeAlignment(Ty); 11093d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner if (LD->getAlignment() < ABIAlignment){ 111065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman ExpandUnalignedLoad(cast<LoadSDNode>(Node), 111165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG, TLI, Tmp1, Tmp2); 1112f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 1113f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 11143d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner } 11153d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner break; 11163d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner case TargetLowering::Expand: 111775b10047fc57c30c86bb7c9ea0ee923ff3c33a7eDan Gohman if (!TLI.isLoadExtLegal(ISD::EXTLOAD, SrcVT) && TLI.isTypeLegal(SrcVT)) { 11183d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner SDValue Load = DAG.getLoad(SrcVT, dl, Tmp1, Tmp2, 11193d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner LD->getPointerInfo(), 11203d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner LD->isVolatile(), LD->isNonTemporal(), 1121d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper LD->isInvariant(), LD->getAlignment()); 11223d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner unsigned ExtendOp; 11233d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner switch (ExtType) { 11243d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner case ISD::EXTLOAD: 11253d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner ExtendOp = (SrcVT.isFloatingPoint() ? 11263d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner ISD::FP_EXTEND : ISD::ANY_EXTEND); 1127f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands break; 11283d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner case ISD::SEXTLOAD: ExtendOp = ISD::SIGN_EXTEND; break; 11293d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner case ISD::ZEXTLOAD: ExtendOp = ISD::ZERO_EXTEND; break; 11303d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner default: llvm_unreachable("Unexpected extend load type!"); 1131f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands } 113265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp1 = DAG.getNode(ExtendOp, dl, Node->getValueType(0), Load); 113365fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp2 = Load.getValue(1); 1134466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng break; 1135466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng } 1136c2492c28ef04dbc77c5d47ec81ffc64c5407771fNadav Rotem 1137e9b58d0aac4e89b53a4be0e6f289b66649e1512bNadav Rotem assert(!SrcVT.isVector() && 1138e9b58d0aac4e89b53a4be0e6f289b66649e1512bNadav Rotem "Vector Loads are handled in LegalizeVectorOps"); 1139c2492c28ef04dbc77c5d47ec81ffc64c5407771fNadav Rotem 11403d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // FIXME: This does not work for vectors on most targets. Sign- and 11413d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // zero-extend operations are currently folded into extending loads, 11423d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // whether they are legal or not, and then we end up here without any 11433d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // support for legalizing them. 11443d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner assert(ExtType != ISD::EXTLOAD && 11453d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner "EXTLOAD should always be supported!"); 11463d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // Turn the unsupported load into an EXTLOAD followed by an explicit 11473d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // zero/sign extend inreg. 114865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue Result = DAG.getExtLoad(ISD::EXTLOAD, dl, Node->getValueType(0), 114965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp1, Tmp2, LD->getPointerInfo(), SrcVT, 115065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman LD->isVolatile(), LD->isNonTemporal(), 115165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman LD->getAlignment()); 11523d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner SDValue ValRes; 11533d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner if (ExtType == ISD::SEXTLOAD) 11543d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner ValRes = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, 11553d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Result.getValueType(), 11563d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Result, DAG.getValueType(SrcVT)); 11573d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner else 1158dd11ea4a372b992775f67b64fb703edf2de0d27bDan Gohman ValRes = DAG.getZeroExtendInReg(Result, dl, SrcVT.getScalarType()); 115965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp1 = ValRes; 116065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp2 = Result.getValue(1); 11613d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner break; 11629d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth } 116301ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 11643d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner 11653d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // Since loads produce two values, make sure to remember that we legalized 11663d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner // both of them. 11670e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman if (Tmp2.getNode() != Node) { 11680e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman assert(Tmp1.getNode() != Node && "Load must be completely replaced"); 11690e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 0), Tmp1); 11700e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 1), Tmp2); 11710e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ReplacedNode(Node); 11720e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman } 117365fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman break; 117401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 1175f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case ISD::STORE: { 11768b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng StoreSDNode *ST = cast<StoreSDNode>(Node); 117765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp1 = ST->getChain(); 117865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp2 = ST->getBasePtr(); 1179d6fd1bc122ba791c698255d8be158b8ec424e248Dan Gohman unsigned Alignment = ST->getAlignment(); 1180d6fd1bc122ba791c698255d8be158b8ec424e248Dan Gohman bool isVolatile = ST->isVolatile(); 11811e559443a17d1b335f697551c6263ba60d5dd827David Greene bool isNonTemporal = ST->isNonTemporal(); 11828b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng 11838b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng if (!ST->isTruncatingStore()) { 11847ef3d178660b82d1571757e49f44b004d772a116Eli Friedman if (SDNode *OptStore = OptimizeFloatStore(ST).getNode()) { 11850e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ReplaceNode(ST, OptStore); 11867ef3d178660b82d1571757e49f44b004d772a116Eli Friedman break; 1187d93d46ee7e0a0e539d42139b85c71b2b8c3968feChris Lattner } 1188fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1189957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman { 119065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp3 = ST->getValue(); 1191e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Tmp3.getValueType(); 11928b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng switch (TLI.getOperationAction(ISD::STORE, VT)) { 11935e25ee8a1fcf8288d00d731b0f7ab7976f33b123Craig Topper default: llvm_unreachable("This action is not supported yet!"); 1194f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio case TargetLowering::Legal: 1195f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // If this is an unaligned store and the target doesn't support it, 1196f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // expand it. 1197bc037cfcdef8e88274d7dd167fb9d8ba545f2229Benjamin Kramer if (!TLI.allowsUnalignedMemoryAccesses(ST->getMemoryVT())) { 1198db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = ST->getMemoryVT().getTypeForEVT(*DAG.getContext()); 11996e9926108a69efbc11f1cadf947e98500e4d4228Jim Grosbach unsigned ABIAlignment= TLI.getTargetData()->getABITypeAlignment(Ty); 1200f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio if (ST->getAlignment() < ABIAlignment) 120165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman ExpandUnalignedStore(cast<StoreSDNode>(Node), 120265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG, TLI, this); 1203f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 1204f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio break; 12058b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng case TargetLowering::Custom: 120665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp1 = TLI.LowerOperation(SDValue(Node, 0), DAG); 12070e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman if (Tmp1.getNode()) 12080e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ReplaceNode(SDValue(Node, 0), Tmp1); 12098b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng break; 121065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman case TargetLowering::Promote: { 121183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(VT.isVector() && "Unknown legal promote case!"); 1212bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck Tmp3 = DAG.getNode(ISD::BITCAST, dl, 12138b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng TLI.getTypeToPromoteTo(ISD::STORE, VT), Tmp3); 121465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue Result = 121565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG.getStore(Tmp1, dl, Tmp3, Tmp2, 121665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman ST->getPointerInfo(), isVolatile, 121765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman isNonTemporal, Alignment); 12180e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ReplaceNode(SDValue(Node, 0), Result); 12198b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng break; 12208b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng } 122165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman } 12222efce0a589e2a688a1a06b5dc2ed0db32ae79924Chris Lattner break; 1223f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 12248b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng } else { 122565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Tmp3 = ST->getValue(); 12267e857201f387d004571e6058e2ea709163500f38Duncan Sands 1227e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT StVT = ST->getMemoryVT(); 122883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned StWidth = StVT.getSizeInBits(); 12297e857201f387d004571e6058e2ea709163500f38Duncan Sands 123083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (StWidth != StVT.getStoreSizeInBits()) { 12317e857201f387d004571e6058e2ea709163500f38Duncan Sands // Promote to a byte-sized store with upper bits zero if not 12327e857201f387d004571e6058e2ea709163500f38Duncan Sands // storing an integral number of bytes. For example, promote 12337e857201f387d004571e6058e2ea709163500f38Duncan Sands // TRUNCSTORE:i1 X -> TRUNCSTORE:i8 (and X, 1) 1234adf979900c84d00e1fe0872a68d2819c654b6f29Evan Cheng EVT NVT = EVT::getIntegerVT(*DAG.getContext(), 1235adf979900c84d00e1fe0872a68d2819c654b6f29Evan Cheng StVT.getStoreSizeInBits()); 1236a1c415cfc2dba4446021f322e4b7a43534a96f1aNadav Rotem Tmp3 = DAG.getZeroExtendInReg(Tmp3, dl, StVT); 123765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue Result = 123865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG.getTruncStore(Tmp1, dl, Tmp3, Tmp2, ST->getPointerInfo(), 123965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman NVT, isVolatile, isNonTemporal, Alignment); 12400e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ReplaceNode(SDValue(Node, 0), Result); 12417e857201f387d004571e6058e2ea709163500f38Duncan Sands } else if (StWidth & (StWidth - 1)) { 12427e857201f387d004571e6058e2ea709163500f38Duncan Sands // If not storing a power-of-2 number of bits, expand as two stores. 1243bceddbdc919fc2ca7bc8c3911586ba93367686f0Ken Dyck assert(!StVT.isVector() && "Unsupported truncstore!"); 12447e857201f387d004571e6058e2ea709163500f38Duncan Sands unsigned RoundWidth = 1 << Log2_32(StWidth); 12457e857201f387d004571e6058e2ea709163500f38Duncan Sands assert(RoundWidth < StWidth); 12467e857201f387d004571e6058e2ea709163500f38Duncan Sands unsigned ExtraWidth = StWidth - RoundWidth; 12477e857201f387d004571e6058e2ea709163500f38Duncan Sands assert(ExtraWidth < RoundWidth); 12487e857201f387d004571e6058e2ea709163500f38Duncan Sands assert(!(RoundWidth % 8) && !(ExtraWidth % 8) && 12497e857201f387d004571e6058e2ea709163500f38Duncan Sands "Store size not an integral number of bytes!"); 125023b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT RoundVT = EVT::getIntegerVT(*DAG.getContext(), RoundWidth); 125123b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT ExtraVT = EVT::getIntegerVT(*DAG.getContext(), ExtraWidth); 1252475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Lo, Hi; 12537e857201f387d004571e6058e2ea709163500f38Duncan Sands unsigned IncrementSize; 12547e857201f387d004571e6058e2ea709163500f38Duncan Sands 12557e857201f387d004571e6058e2ea709163500f38Duncan Sands if (TLI.isLittleEndian()) { 12567e857201f387d004571e6058e2ea709163500f38Duncan Sands // TRUNCSTORE:i24 X -> TRUNCSTORE:i16 X, TRUNCSTORE@+2:i8 (srl X, 16) 12577e857201f387d004571e6058e2ea709163500f38Duncan Sands // Store the bottom RoundWidth bits. 1258da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner Lo = DAG.getTruncStore(Tmp1, dl, Tmp3, Tmp2, ST->getPointerInfo(), 1259da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner RoundVT, 12601e559443a17d1b335f697551c6263ba60d5dd827David Greene isVolatile, isNonTemporal, Alignment); 12617e857201f387d004571e6058e2ea709163500f38Duncan Sands 12627e857201f387d004571e6058e2ea709163500f38Duncan Sands // Store the remaining ExtraWidth bits. 12637e857201f387d004571e6058e2ea709163500f38Duncan Sands IncrementSize = RoundWidth / 8; 1264ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2, 12657e857201f387d004571e6058e2ea709163500f38Duncan Sands DAG.getIntPtrConstant(IncrementSize)); 1266ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getNode(ISD::SRL, dl, Tmp3.getValueType(), Tmp3, 126795771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson DAG.getConstant(RoundWidth, 126895771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson TLI.getShiftAmountTy(Tmp3.getValueType()))); 1269da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner Hi = DAG.getTruncStore(Tmp1, dl, Hi, Tmp2, 1270da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner ST->getPointerInfo().getWithOffset(IncrementSize), 1271da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner ExtraVT, isVolatile, isNonTemporal, 12727e857201f387d004571e6058e2ea709163500f38Duncan Sands MinAlign(Alignment, IncrementSize)); 12737e857201f387d004571e6058e2ea709163500f38Duncan Sands } else { 12747e857201f387d004571e6058e2ea709163500f38Duncan Sands // Big endian - avoid unaligned stores. 12757e857201f387d004571e6058e2ea709163500f38Duncan Sands // TRUNCSTORE:i24 X -> TRUNCSTORE:i16 (srl X, 8), TRUNCSTORE@+2:i8 X 12767e857201f387d004571e6058e2ea709163500f38Duncan Sands // Store the top RoundWidth bits. 1277ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getNode(ISD::SRL, dl, Tmp3.getValueType(), Tmp3, 127895771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson DAG.getConstant(ExtraWidth, 127995771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson TLI.getShiftAmountTy(Tmp3.getValueType()))); 1280da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner Hi = DAG.getTruncStore(Tmp1, dl, Hi, Tmp2, ST->getPointerInfo(), 1281da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner RoundVT, isVolatile, isNonTemporal, Alignment); 12827e857201f387d004571e6058e2ea709163500f38Duncan Sands 12837e857201f387d004571e6058e2ea709163500f38Duncan Sands // Store the remaining ExtraWidth bits. 12847e857201f387d004571e6058e2ea709163500f38Duncan Sands IncrementSize = RoundWidth / 8; 1285ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2, 12867e857201f387d004571e6058e2ea709163500f38Duncan Sands DAG.getIntPtrConstant(IncrementSize)); 1287da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner Lo = DAG.getTruncStore(Tmp1, dl, Tmp3, Tmp2, 1288da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner ST->getPointerInfo().getWithOffset(IncrementSize), 1289da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner ExtraVT, isVolatile, isNonTemporal, 12907e857201f387d004571e6058e2ea709163500f38Duncan Sands MinAlign(Alignment, IncrementSize)); 12917e857201f387d004571e6058e2ea709163500f38Duncan Sands } 1292c7029805ef35ce9805931067b841e6af11db382eChris Lattner 12937e857201f387d004571e6058e2ea709163500f38Duncan Sands // The order of the stores doesn't matter. 129465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue Result = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi); 12950e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ReplaceNode(SDValue(Node, 0), Result); 12967e857201f387d004571e6058e2ea709163500f38Duncan Sands } else { 12977e857201f387d004571e6058e2ea709163500f38Duncan Sands switch (TLI.getTruncStoreAction(ST->getValue().getValueType(), StVT)) { 12985e25ee8a1fcf8288d00d731b0f7ab7976f33b123Craig Topper default: llvm_unreachable("This action is not supported yet!"); 12997e857201f387d004571e6058e2ea709163500f38Duncan Sands case TargetLowering::Legal: 13007e857201f387d004571e6058e2ea709163500f38Duncan Sands // If this is an unaligned store and the target doesn't support it, 13017e857201f387d004571e6058e2ea709163500f38Duncan Sands // expand it. 1302bc037cfcdef8e88274d7dd167fb9d8ba545f2229Benjamin Kramer if (!TLI.allowsUnalignedMemoryAccesses(ST->getMemoryVT())) { 1303db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = ST->getMemoryVT().getTypeForEVT(*DAG.getContext()); 13046e9926108a69efbc11f1cadf947e98500e4d4228Jim Grosbach unsigned ABIAlignment= TLI.getTargetData()->getABITypeAlignment(Ty); 13057e857201f387d004571e6058e2ea709163500f38Duncan Sands if (ST->getAlignment() < ABIAlignment) 130665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman ExpandUnalignedStore(cast<StoreSDNode>(Node), DAG, TLI, this); 13077e857201f387d004571e6058e2ea709163500f38Duncan Sands } 13087e857201f387d004571e6058e2ea709163500f38Duncan Sands break; 13097e857201f387d004571e6058e2ea709163500f38Duncan Sands case TargetLowering::Custom: 13100e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ReplaceNode(SDValue(Node, 0), 13110e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman TLI.LowerOperation(SDValue(Node, 0), DAG)); 13127e857201f387d004571e6058e2ea709163500f38Duncan Sands break; 1313e63e5ab50ab37fd59cc6e815fffcb90e75537ca3Dan Gohman case TargetLowering::Expand: 1314e9b58d0aac4e89b53a4be0e6f289b66649e1512bNadav Rotem assert(!StVT.isVector() && 1315e9b58d0aac4e89b53a4be0e6f289b66649e1512bNadav Rotem "Vector Stores are handled in LegalizeVectorOps"); 1316c2492c28ef04dbc77c5d47ec81ffc64c5407771fNadav Rotem 13177e857201f387d004571e6058e2ea709163500f38Duncan Sands // TRUNCSTORE:i16 i32 -> STORE i16 131875b10047fc57c30c86bb7c9ea0ee923ff3c33a7eDan Gohman assert(TLI.isTypeLegal(StVT) && "Do not know how to expand this store!"); 1319ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp3 = DAG.getNode(ISD::TRUNCATE, dl, StVT, Tmp3); 132065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue Result = 132165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG.getStore(Tmp1, dl, Tmp3, Tmp2, ST->getPointerInfo(), 132265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman isVolatile, isNonTemporal, Alignment); 13230e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ReplaceNode(SDValue(Node, 0), Result); 13247e857201f387d004571e6058e2ea709163500f38Duncan Sands break; 1325f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 13268b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng } 13273e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 13283e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1329f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 133045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 13313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 13323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 13333d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli FriedmanSDValue SelectionDAGLegalize::ExpandExtractFromVectorThroughStack(SDValue Op) { 13343d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman SDValue Vec = Op.getOperand(0); 13353d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman SDValue Idx = Op.getOperand(1); 13363d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman DebugLoc dl = Op.getDebugLoc(); 13373d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman // Store the value to a temporary stack slot, then LOAD the returned part. 13383d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman SDValue StackPtr = DAG.CreateStackTemporary(Vec.getValueType()); 13396229d0acb8f395552131a7015a5d1e7b2bae2111Chris Lattner SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr, 13406229d0acb8f395552131a7015a5d1e7b2bae2111Chris Lattner MachinePointerInfo(), false, false, 0); 13413d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman 13423d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman // Add the offset to the index. 1343aa9d854b334cab2f29ca6d95413a0946b8a38429Dan Gohman unsigned EltSize = 1344aa9d854b334cab2f29ca6d95413a0946b8a38429Dan Gohman Vec.getValueType().getVectorElementType().getSizeInBits()/8; 13453d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman Idx = DAG.getNode(ISD::MUL, dl, Idx.getValueType(), Idx, 13463d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman DAG.getConstant(EltSize, Idx.getValueType())); 13473d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman 13483d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman if (Idx.getValueType().bitsGT(TLI.getPointerTy())) 13493d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman Idx = DAG.getNode(ISD::TRUNCATE, dl, TLI.getPointerTy(), Idx); 13503d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman else 13513d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman Idx = DAG.getNode(ISD::ZERO_EXTEND, dl, TLI.getPointerTy(), Idx); 13523d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman 13533d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman StackPtr = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, StackPtr); 13543d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman 1355c680ac90032bf455b2bba77de538fccea08eb267Eli Friedman if (Op.getValueType().isVector()) 1356ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner return DAG.getLoad(Op.getValueType(), dl, Ch, StackPtr,MachinePointerInfo(), 1357d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper false, false, false, 0); 1358a901129169194881a78b7fd8953e09f55b846d10Stuart Hastings return DAG.getExtLoad(ISD::EXTLOAD, dl, Op.getValueType(), Ch, StackPtr, 13593d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner MachinePointerInfo(), 13603d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner Vec.getValueType().getVectorElementType(), 13613d6ccfba314ed38e4506dae2781a060e9a3e07acChris Lattner false, false, 0); 13623d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman} 13633d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman 1364cfe33c46aa50f04adb0431243e7d25f79b719ac6David GreeneSDValue SelectionDAGLegalize::ExpandInsertToVectorThroughStack(SDValue Op) { 1365cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene assert(Op.getValueType().isVector() && "Non-vector insert subvector!"); 1366cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene 1367cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene SDValue Vec = Op.getOperand(0); 1368cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene SDValue Part = Op.getOperand(1); 1369cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene SDValue Idx = Op.getOperand(2); 1370cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene DebugLoc dl = Op.getDebugLoc(); 1371cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene 1372cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene // Store the value to a temporary stack slot, then LOAD the returned part. 1373cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene 1374cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene SDValue StackPtr = DAG.CreateStackTemporary(Vec.getValueType()); 1375cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene int FI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex(); 1376cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(FI); 1377cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene 1378cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene // First store the whole vector. 1379cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr, PtrInfo, 1380cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene false, false, 0); 1381cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene 1382cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene // Then store the inserted part. 1383cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene 1384cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene // Add the offset to the index. 1385cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene unsigned EltSize = 1386cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene Vec.getValueType().getVectorElementType().getSizeInBits()/8; 1387cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene 1388cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene Idx = DAG.getNode(ISD::MUL, dl, Idx.getValueType(), Idx, 1389cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene DAG.getConstant(EltSize, Idx.getValueType())); 1390cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene 1391cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene if (Idx.getValueType().bitsGT(TLI.getPointerTy())) 1392cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene Idx = DAG.getNode(ISD::TRUNCATE, dl, TLI.getPointerTy(), Idx); 1393cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene else 1394cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene Idx = DAG.getNode(ISD::ZERO_EXTEND, dl, TLI.getPointerTy(), Idx); 1395cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene 1396cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene SDValue SubStackPtr = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, 1397cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene StackPtr); 1398cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene 1399cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene // Store the subvector. 1400cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene Ch = DAG.getStore(DAG.getEntryNode(), dl, Part, SubStackPtr, 1401cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene MachinePointerInfo(), false, false, 0); 1402cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene 1403cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene // Finally, load the updated vector. 1404cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene return DAG.getLoad(Op.getValueType(), dl, Ch, StackPtr, PtrInfo, 1405d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper false, false, false, 0); 1406cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene} 1407cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene 14087ef3d178660b82d1571757e49f44b004d772a116Eli FriedmanSDValue SelectionDAGLegalize::ExpandVectorBuildThroughStack(SDNode* Node) { 14097ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // We can't handle this case efficiently. Allocate a sufficiently 14107ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // aligned object on the stack, store each element into it, then load 14117ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // the result as a vector. 14127ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // Create the stack frame object. 1413e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Node->getValueType(0); 14145b8bce11d60694a651965cf019b9cb5d84ed3b90Dale Johannesen EVT EltVT = VT.getVectorElementType(); 14157ef3d178660b82d1571757e49f44b004d772a116Eli Friedman DebugLoc dl = Node->getDebugLoc(); 14167ef3d178660b82d1571757e49f44b004d772a116Eli Friedman SDValue FIPtr = DAG.CreateStackTemporary(VT); 1417ff89dcb06fbd103373436e2d0ae85f252fae2254Evan Cheng int FI = cast<FrameIndexSDNode>(FIPtr.getNode())->getIndex(); 1418ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(FI); 14197ef3d178660b82d1571757e49f44b004d772a116Eli Friedman 14207ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // Emit a store of each element to the stack slot. 14217ef3d178660b82d1571757e49f44b004d772a116Eli Friedman SmallVector<SDValue, 8> Stores; 1422aa9d854b334cab2f29ca6d95413a0946b8a38429Dan Gohman unsigned TypeByteSize = EltVT.getSizeInBits() / 8; 14237ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // Store (in the right endianness) the elements to memory. 14247ef3d178660b82d1571757e49f44b004d772a116Eli Friedman for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 14257ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // Ignore undef elements. 14267ef3d178660b82d1571757e49f44b004d772a116Eli Friedman if (Node->getOperand(i).getOpcode() == ISD::UNDEF) continue; 14277ef3d178660b82d1571757e49f44b004d772a116Eli Friedman 14287ef3d178660b82d1571757e49f44b004d772a116Eli Friedman unsigned Offset = TypeByteSize*i; 14297ef3d178660b82d1571757e49f44b004d772a116Eli Friedman 14307ef3d178660b82d1571757e49f44b004d772a116Eli Friedman SDValue Idx = DAG.getConstant(Offset, FIPtr.getValueType()); 14317ef3d178660b82d1571757e49f44b004d772a116Eli Friedman Idx = DAG.getNode(ISD::ADD, dl, FIPtr.getValueType(), FIPtr, Idx); 14327ef3d178660b82d1571757e49f44b004d772a116Eli Friedman 14339949dd612c8100f7ea7e6daaa56e465f106dd0bdDan Gohman // If the destination vector element type is narrower than the source 14349949dd612c8100f7ea7e6daaa56e465f106dd0bdDan Gohman // element type, only store the bits necessary. 14359949dd612c8100f7ea7e6daaa56e465f106dd0bdDan Gohman if (EltVT.bitsLT(Node->getOperand(i).getValueType().getScalarType())) { 14365b8bce11d60694a651965cf019b9cb5d84ed3b90Dale Johannesen Stores.push_back(DAG.getTruncStore(DAG.getEntryNode(), dl, 1437ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner Node->getOperand(i), Idx, 1438ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner PtrInfo.getWithOffset(Offset), 14391e559443a17d1b335f697551c6263ba60d5dd827David Greene EltVT, false, false, 0)); 1440eb38ebf15c326a5bb45ca9da6329cdf19ad6df95Mon P Wang } else 14416e9926108a69efbc11f1cadf947e98500e4d4228Jim Grosbach Stores.push_back(DAG.getStore(DAG.getEntryNode(), dl, 1442ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner Node->getOperand(i), Idx, 1443ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner PtrInfo.getWithOffset(Offset), 14441e559443a17d1b335f697551c6263ba60d5dd827David Greene false, false, 0)); 14457ef3d178660b82d1571757e49f44b004d772a116Eli Friedman } 14467ef3d178660b82d1571757e49f44b004d772a116Eli Friedman 14477ef3d178660b82d1571757e49f44b004d772a116Eli Friedman SDValue StoreChain; 14487ef3d178660b82d1571757e49f44b004d772a116Eli Friedman if (!Stores.empty()) // Not all undef elements? 1449825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson StoreChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, 14507ef3d178660b82d1571757e49f44b004d772a116Eli Friedman &Stores[0], Stores.size()); 14517ef3d178660b82d1571757e49f44b004d772a116Eli Friedman else 14527ef3d178660b82d1571757e49f44b004d772a116Eli Friedman StoreChain = DAG.getEntryNode(); 14537ef3d178660b82d1571757e49f44b004d772a116Eli Friedman 14547ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // Result is a load from the stack slot. 1455d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper return DAG.getLoad(VT, dl, StoreChain, FIPtr, PtrInfo, 1456d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper false, false, false, 0); 14577ef3d178660b82d1571757e49f44b004d772a116Eli Friedman} 14587ef3d178660b82d1571757e49f44b004d772a116Eli Friedman 14594bc8c718218159fe410462f6e3670e7cb76c0c04Eli FriedmanSDValue SelectionDAGLegalize::ExpandFCOPYSIGN(SDNode* Node) { 14604bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman DebugLoc dl = Node->getDebugLoc(); 14614bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue Tmp1 = Node->getOperand(0); 14624bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue Tmp2 = Node->getOperand(1); 14635d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands 14645d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands // Get the sign bit of the RHS. First obtain a value that has the same 14655d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands // sign as the sign bit, i.e. negative if and only if the sign bit is 1. 14664bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue SignBit; 14675d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands EVT FloatVT = Tmp2.getValueType(); 14685d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands EVT IVT = EVT::getIntegerVT(*DAG.getContext(), FloatVT.getSizeInBits()); 146975b10047fc57c30c86bb7c9ea0ee923ff3c33a7eDan Gohman if (TLI.isTypeLegal(IVT)) { 14705d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands // Convert to an integer with the same sign bit. 1471bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck SignBit = DAG.getNode(ISD::BITCAST, dl, IVT, Tmp2); 14724bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman } else { 14735d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands // Store the float to memory, then load the sign part out as an integer. 14745d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands MVT LoadTy = TLI.getPointerTy(); 14755d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands // First create a temporary that is aligned for both the load and store. 14765d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands SDValue StackPtr = DAG.CreateStackTemporary(FloatVT, LoadTy); 14775d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands // Then store the float to it. 14784bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue Ch = 14796229d0acb8f395552131a7015a5d1e7b2bae2111Chris Lattner DAG.getStore(DAG.getEntryNode(), dl, Tmp2, StackPtr, MachinePointerInfo(), 14801e559443a17d1b335f697551c6263ba60d5dd827David Greene false, false, 0); 14815d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands if (TLI.isBigEndian()) { 14825d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands assert(FloatVT.isByteSized() && "Unsupported floating point type!"); 14835d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands // Load out a legal integer with the same sign bit as the float. 1484ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner SignBit = DAG.getLoad(LoadTy, dl, Ch, StackPtr, MachinePointerInfo(), 1485d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper false, false, false, 0); 14865d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands } else { // Little endian 14875d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands SDValue LoadPtr = StackPtr; 14885d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands // The float may be wider than the integer we are going to load. Advance 14895d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands // the pointer so that the loaded integer will contain the sign bit. 14905d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands unsigned Strides = (FloatVT.getSizeInBits()-1)/LoadTy.getSizeInBits(); 14915d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands unsigned ByteOffset = (Strides * LoadTy.getSizeInBits()) / 8; 14925d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands LoadPtr = DAG.getNode(ISD::ADD, dl, LoadPtr.getValueType(), 14935d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands LoadPtr, DAG.getIntPtrConstant(ByteOffset)); 14945d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands // Load a legal integer containing the sign bit. 1495ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner SignBit = DAG.getLoad(LoadTy, dl, Ch, LoadPtr, MachinePointerInfo(), 1496d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper false, false, false, 0); 14975d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands // Move the sign bit to the top bit of the loaded integer. 14985d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands unsigned BitShift = LoadTy.getSizeInBits() - 14995d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands (FloatVT.getSizeInBits() - 8 * ByteOffset); 15005d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands assert(BitShift < LoadTy.getSizeInBits() && "Pointer advanced wrong?"); 15015d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands if (BitShift) 15025d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands SignBit = DAG.getNode(ISD::SHL, dl, LoadTy, SignBit, 150395771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson DAG.getConstant(BitShift, 150495771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson TLI.getShiftAmountTy(SignBit.getValueType()))); 15055d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands } 15064bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman } 15075d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands // Now get the sign bit proper, by seeing whether the value is negative. 15085d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands SignBit = DAG.getSetCC(dl, TLI.getSetCCResultType(SignBit.getValueType()), 15095d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands SignBit, DAG.getConstant(0, SignBit.getValueType()), 15105d54b4112d7b8bcd49a07e398ebff263fac1eb9cDuncan Sands ISD::SETLT); 15114bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman // Get the absolute value of the result. 15124bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue AbsVal = DAG.getNode(ISD::FABS, dl, Tmp1.getValueType(), Tmp1); 15134bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman // Select between the nabs and abs value based on the sign bit of 15144bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman // the input. 15154bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman return DAG.getNode(ISD::SELECT, dl, AbsVal.getValueType(), SignBit, 15164bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman DAG.getNode(ISD::FNEG, dl, AbsVal.getValueType(), AbsVal), 15174bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman AbsVal); 15184bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman} 15194bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman 15204bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedmanvoid SelectionDAGLegalize::ExpandDYNAMIC_STACKALLOC(SDNode* Node, 15214bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SmallVectorImpl<SDValue> &Results) { 15224bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman unsigned SPReg = TLI.getStackPointerRegisterToSaveRestore(); 15234bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman assert(SPReg && "Target cannot require DYNAMIC_STACKALLOC expansion and" 15244bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman " not tell us which reg is the stack pointer!"); 15254bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman DebugLoc dl = Node->getDebugLoc(); 1526e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Node->getValueType(0); 15274bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue Tmp1 = SDValue(Node, 0); 15284bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue Tmp2 = SDValue(Node, 1); 15294bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue Tmp3 = Node->getOperand(2); 15304bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue Chain = Tmp1.getOperand(0); 15314bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman 15324bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman // Chain the dynamic stack allocation so that it doesn't modify the stack 15334bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman // pointer when other instructions are using the stack. 15344bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(0, true)); 15354bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman 15364bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue Size = Tmp2.getOperand(1); 15374bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, VT); 15384bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman Chain = SP.getValue(1); 15394bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman unsigned Align = cast<ConstantSDNode>(Tmp3)->getZExtValue(); 154016c29b5f285f375be53dabaa73e3e91107485fe4Anton Korobeynikov unsigned StackAlign = TM.getFrameLowering()->getStackAlignment(); 15414bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman if (Align > StackAlign) 15424bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SP = DAG.getNode(ISD::AND, dl, VT, SP, 15434bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman DAG.getConstant(-(uint64_t)Align, VT)); 15444bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman Tmp1 = DAG.getNode(ISD::SUB, dl, VT, SP, Size); // Value 15454bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman Chain = DAG.getCopyToReg(Chain, dl, SPReg, Tmp1); // Output chain 15464bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman 15474bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman Tmp2 = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(0, true), 15484bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman DAG.getIntPtrConstant(0, true), SDValue()); 15494bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman 15504bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman Results.push_back(Tmp1); 15514bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman Results.push_back(Tmp2); 15524bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman} 15534bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman 15547f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng/// LegalizeSetCCCondCode - Legalize a SETCC with given LHS and RHS and 1555f77fc92b03efe455008474894d217282e2a03cadDan Gohman/// condition code CC on the current target. This routine expands SETCC with 15567f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng/// illegal condition code into AND / OR of multiple SETCC values. 1557e50ed30282bb5b4a9ed952580523f2dda16215acOwen Andersonvoid SelectionDAGLegalize::LegalizeSetCCCondCode(EVT VT, 15587f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng SDValue &LHS, SDValue &RHS, 1559bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue &CC, 1560775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling DebugLoc dl) { 1561e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT OpVT = LHS.getValueType(); 15627f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng ISD::CondCode CCCode = cast<CondCodeSDNode>(CC)->get(); 15637f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng switch (TLI.getCondCodeAction(CCCode, OpVT)) { 15645e25ee8a1fcf8288d00d731b0f7ab7976f33b123Craig Topper default: llvm_unreachable("Unknown condition code action!"); 15657f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng case TargetLowering::Legal: 15667f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng // Nothing to do. 15677f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng break; 15687f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng case TargetLowering::Expand: { 15697f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng ISD::CondCode CC1 = ISD::SETCC_INVALID, CC2 = ISD::SETCC_INVALID; 15707f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng unsigned Opc = 0; 15717f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng switch (CCCode) { 15725e25ee8a1fcf8288d00d731b0f7ab7976f33b123Craig Topper default: llvm_unreachable("Don't know how to expand this condition!"); 1573e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETOEQ: CC1 = ISD::SETEQ; CC2 = ISD::SETO; Opc = ISD::AND; break; 1574e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETOGT: CC1 = ISD::SETGT; CC2 = ISD::SETO; Opc = ISD::AND; break; 1575e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETOGE: CC1 = ISD::SETGE; CC2 = ISD::SETO; Opc = ISD::AND; break; 1576e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETOLT: CC1 = ISD::SETLT; CC2 = ISD::SETO; Opc = ISD::AND; break; 1577e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETOLE: CC1 = ISD::SETLE; CC2 = ISD::SETO; Opc = ISD::AND; break; 1578e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETONE: CC1 = ISD::SETNE; CC2 = ISD::SETO; Opc = ISD::AND; break; 1579e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETUEQ: CC1 = ISD::SETEQ; CC2 = ISD::SETUO; Opc = ISD::OR; break; 1580e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETUGT: CC1 = ISD::SETGT; CC2 = ISD::SETUO; Opc = ISD::OR; break; 1581e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETUGE: CC1 = ISD::SETGE; CC2 = ISD::SETUO; Opc = ISD::OR; break; 1582e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETULT: CC1 = ISD::SETLT; CC2 = ISD::SETUO; Opc = ISD::OR; break; 1583e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETULE: CC1 = ISD::SETLE; CC2 = ISD::SETUO; Opc = ISD::OR; break; 1584e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETUNE: CC1 = ISD::SETNE; CC2 = ISD::SETUO; Opc = ISD::OR; break; 15857f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng // FIXME: Implement more expansions. 15867f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng } 15877f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng 1588bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue SetCC1 = DAG.getSetCC(dl, VT, LHS, RHS, CC1); 1589bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue SetCC2 = DAG.getSetCC(dl, VT, LHS, RHS, CC2); 1590bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen LHS = DAG.getNode(Opc, dl, VT, SetCC1, SetCC2); 15917f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng RHS = SDValue(); 15927f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng CC = SDValue(); 15937f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng break; 15947f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng } 15957f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng } 15967f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng} 15977f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng 15981401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner/// EmitStackConvert - Emit a store/load combination to the stack. This stores 15991401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner/// SrcOp to a stack slot of type SlotVT, truncating it if needed. It then does 16001401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner/// a load from the stack slot to DestVT, extending it if needed. 16011401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner/// The resultant code need not be legal. 1602475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::EmitStackConvert(SDValue SrcOp, 1603e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SlotVT, 1604e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DestVT, 16058a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DebugLoc dl) { 160635481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner // Create the stack frame object. 1607ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson unsigned SrcAlign = 1608ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson TLI.getTargetData()->getPrefTypeAlignment(SrcOp.getValueType(). 160923b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson getTypeForEVT(*DAG.getContext())); 1610475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue FIPtr = DAG.CreateStackTemporary(SlotVT, SrcAlign); 1611fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1612ff89dcb06fbd103373436e2d0ae85f252fae2254Evan Cheng FrameIndexSDNode *StackPtrFI = cast<FrameIndexSDNode>(FIPtr); 1613ff89dcb06fbd103373436e2d0ae85f252fae2254Evan Cheng int SPFI = StackPtrFI->getIndex(); 1614da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(SPFI); 1615ff89dcb06fbd103373436e2d0ae85f252fae2254Evan Cheng 161683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned SrcSize = SrcOp.getValueType().getSizeInBits(); 161783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned SlotSize = SlotVT.getSizeInBits(); 161883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned DestSize = DestVT.getSizeInBits(); 1619db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *DestType = DestVT.getTypeForEVT(*DAG.getContext()); 1620adf979900c84d00e1fe0872a68d2819c654b6f29Evan Cheng unsigned DestAlign = TLI.getTargetData()->getPrefTypeAlignment(DestType); 1621fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 16221401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner // Emit a store to the stack slot. Use a truncstore if the input value is 16231401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner // later than DestVT. 1624475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Store; 1625ff89dcb06fbd103373436e2d0ae85f252fae2254Evan Cheng 16261401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner if (SrcSize > SlotSize) 16278a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Store = DAG.getTruncStore(DAG.getEntryNode(), dl, SrcOp, FIPtr, 1628da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner PtrInfo, SlotVT, false, false, SrcAlign); 16291401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner else { 16301401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner assert(SrcSize == SlotSize && "Invalid store"); 16318a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Store = DAG.getStore(DAG.getEntryNode(), dl, SrcOp, FIPtr, 1632da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner PtrInfo, false, false, SrcAlign); 16331401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner } 1634fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 163535481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner // Result is a load from the stack slot. 16361401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner if (SlotSize == DestSize) 1637da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner return DAG.getLoad(DestVT, dl, Store, FIPtr, PtrInfo, 1638d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper false, false, false, DestAlign); 1639fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 16401401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner assert(SlotSize < DestSize && "Unknown extension!"); 1641a901129169194881a78b7fd8953e09f55b846d10Stuart Hastings return DAG.getExtLoad(ISD::EXTLOAD, dl, DestVT, Store, FIPtr, 1642da2d8e1032eb4c2fefb1f647d7877910b9483835Chris Lattner PtrInfo, SlotVT, false, false, DestAlign); 164335481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner} 164435481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner 1645475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::ExpandSCALAR_TO_VECTOR(SDNode *Node) { 16468a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DebugLoc dl = Node->getDebugLoc(); 16474352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner // Create a vector sized/aligned stack slot, store the value to element #0, 16484352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner // then load the whole vector back out. 1649475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue StackPtr = DAG.CreateStackTemporary(Node->getValueType(0)); 165069de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman 1651ff89dcb06fbd103373436e2d0ae85f252fae2254Evan Cheng FrameIndexSDNode *StackPtrFI = cast<FrameIndexSDNode>(StackPtr); 1652ff89dcb06fbd103373436e2d0ae85f252fae2254Evan Cheng int SPFI = StackPtrFI->getIndex(); 1653ff89dcb06fbd103373436e2d0ae85f252fae2254Evan Cheng 1654b10b5ac8d9da43ca2db61401a20af6b676c98438Duncan Sands SDValue Ch = DAG.getTruncStore(DAG.getEntryNode(), dl, Node->getOperand(0), 1655b10b5ac8d9da43ca2db61401a20af6b676c98438Duncan Sands StackPtr, 165685ca1066328639119f94c47a83b698c48b84ebb0Chris Lattner MachinePointerInfo::getFixedStack(SPFI), 16571e559443a17d1b335f697551c6263ba60d5dd827David Greene Node->getValueType(0).getVectorElementType(), 16581e559443a17d1b335f697551c6263ba60d5dd827David Greene false, false, 0); 16598a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getLoad(Node->getValueType(0), dl, Ch, StackPtr, 166085ca1066328639119f94c47a83b698c48b84ebb0Chris Lattner MachinePointerInfo::getFixedStack(SPFI), 1661d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper false, false, false, 0); 16624352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner} 16634352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner 16644352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner 1665ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner/// ExpandBUILD_VECTOR - Expand a BUILD_VECTOR node on targets that don't 166607a96765daedf180a7102d39fe56c499878312b7Dan Gohman/// support the operation, but do support the resultant vector type. 1667475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::ExpandBUILD_VECTOR(SDNode *Node) { 166826cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson unsigned NumElems = Node->getNumOperands(); 16697a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman SDValue Value1, Value2; 167026cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson DebugLoc dl = Node->getDebugLoc(); 1671e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Node->getValueType(0); 1672e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT OpVT = Node->getOperand(0).getValueType(); 1673e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT EltVT = VT.getVectorElementType(); 1674fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1675fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // If the only non-undef value is the low element, turn this into a 167687100e0b83b808757bf44dabecd1d1048255d1adChris Lattner // SCALAR_TO_VECTOR node. If this is { X, X, X, X }, determine X. 1677ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner bool isOnlyLowElement = true; 16787a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman bool MoreThanTwoValues = false; 16792eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner bool isConstant = true; 16807a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman for (unsigned i = 0; i < NumElems; ++i) { 1681475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue V = Node->getOperand(i); 16827a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman if (V.getOpcode() == ISD::UNDEF) 16837a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman continue; 16847a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman if (i > 0) 1685ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner isOnlyLowElement = false; 16867a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman if (!isa<ConstantFPSDNode>(V) && !isa<ConstantSDNode>(V)) 16872eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner isConstant = false; 16887a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman 16897a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman if (!Value1.getNode()) { 16907a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman Value1 = V; 16917a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman } else if (!Value2.getNode()) { 16927a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman if (V != Value1) 16937a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman Value2 = V; 16947a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman } else if (V != Value1 && V != Value2) { 16957a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman MoreThanTwoValues = true; 16967a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman } 1697ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } 1698fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 16997a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman if (!Value1.getNode()) 17007a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman return DAG.getUNDEF(VT); 17017a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman 17027a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman if (isOnlyLowElement) 170326cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Node->getOperand(0)); 1704fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 17052eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner // If all elements are constants, create a load from the constant pool. 1706ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner if (isConstant) { 17074ca829e89567f002fc74eb0e3e532a7c7662e031Chris Lattner SmallVector<Constant*, 16> CV; 1708033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng for (unsigned i = 0, e = NumElems; i != e; ++i) { 1709fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel if (ConstantFPSDNode *V = 1710ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner dyn_cast<ConstantFPSDNode>(Node->getOperand(i))) { 17114fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman CV.push_back(const_cast<ConstantFP *>(V->getConstantFPValue())); 1712fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel } else if (ConstantSDNode *V = 1713ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson dyn_cast<ConstantSDNode>(Node->getOperand(i))) { 17149a645cd9d4c0e7d25e4b8836ed31deb5881c8101Dale Johannesen if (OpVT==EltVT) 17159a645cd9d4c0e7d25e4b8836ed31deb5881c8101Dale Johannesen CV.push_back(const_cast<ConstantInt *>(V->getConstantIntValue())); 17169a645cd9d4c0e7d25e4b8836ed31deb5881c8101Dale Johannesen else { 17179a645cd9d4c0e7d25e4b8836ed31deb5881c8101Dale Johannesen // If OpVT and EltVT don't match, EltVT is not legal and the 17189a645cd9d4c0e7d25e4b8836ed31deb5881c8101Dale Johannesen // element values have been promoted/truncated earlier. Undo this; 17199a645cd9d4c0e7d25e4b8836ed31deb5881c8101Dale Johannesen // we don't want a v16i8 to become a v16i32 for example. 17209a645cd9d4c0e7d25e4b8836ed31deb5881c8101Dale Johannesen const ConstantInt *CI = V->getConstantIntValue(); 17219a645cd9d4c0e7d25e4b8836ed31deb5881c8101Dale Johannesen CV.push_back(ConstantInt::get(EltVT.getTypeForEVT(*DAG.getContext()), 17229a645cd9d4c0e7d25e4b8836ed31deb5881c8101Dale Johannesen CI->getZExtValue())); 17239a645cd9d4c0e7d25e4b8836ed31deb5881c8101Dale Johannesen } 1724ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } else { 1725ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner assert(Node->getOperand(i).getOpcode() == ISD::UNDEF); 1726db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *OpNTy = EltVT.getTypeForEVT(*DAG.getContext()); 17279e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson CV.push_back(UndefValue::get(OpNTy)); 1728ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } 1729ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } 1730af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson Constant *CP = ConstantVector::get(CV); 1731475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue CPIdx = DAG.getConstantPool(CP, TLI.getPointerTy()); 17321606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned Alignment = cast<ConstantPoolSDNode>(CPIdx)->getAlignment(); 17338a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx, 173485ca1066328639119f94c47a83b698c48b84ebb0Chris Lattner MachinePointerInfo::getConstantPool(), 1735d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper false, false, false, Alignment); 1736ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } 1737fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 17387a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman if (!MoreThanTwoValues) { 17397a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman SmallVector<int, 8> ShuffleVec(NumElems, -1); 17407a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman for (unsigned i = 0; i < NumElems; ++i) { 17417a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman SDValue V = Node->getOperand(i); 17427a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman if (V.getOpcode() == ISD::UNDEF) 17437a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman continue; 17447a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman ShuffleVec[i] = V == Value1 ? 0 : NumElems; 17457a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman } 17467a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman if (TLI.isShuffleMaskLegal(ShuffleVec, Node->getValueType(0))) { 17472eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner // Get the splatted value into the low element of a vector register. 17487a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman SDValue Vec1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Value1); 17497a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman SDValue Vec2; 17507a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman if (Value2.getNode()) 17517a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman Vec2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Value2); 17527a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman else 17537a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman Vec2 = DAG.getUNDEF(VT); 1754fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 17552eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner // Return shuffle(LowValVec, undef, <0,0,0,0>) 17567a5e55509b99d579d56d126a7b503ec6fe153a8fEli Friedman return DAG.getVectorShuffle(VT, dl, Vec1, Vec2, ShuffleVec.data()); 1757033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng } 1758033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng } 1759fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 17607ef3d178660b82d1571757e49f44b004d772a116Eli Friedman // Otherwise, we can't handle this case efficiently. 17617ef3d178660b82d1571757e49f44b004d772a116Eli Friedman return ExpandVectorBuildThroughStack(Node); 1762ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner} 1763ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner 176477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// ExpandLibCall - Expand a node into a call to a libcall. If the result value 176577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// does not fit into a register, return the lo part and set the hi part to the 176677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// by-reg argument. If it does fit into a single register, return the result 176777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// and leave the Hi part unset. 1768475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::ExpandLibCall(RTLIB::Libcall LC, SDNode *Node, 176947b41f7e20b6af7aaaf0e050200102d55d038b9dEli Friedman bool isSigned) { 177077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 177147857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TargetLowering::ArgListEntry Entry; 177277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 1773e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT ArgVT = Node->getOperand(i).getValueType(); 1774db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext()); 1775fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Entry.Node = Node->getOperand(i); Entry.Ty = ArgTy; 1776d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Entry.isSExt = isSigned; 177700fee65fd21f9615d1a604b8b7d42cd16a3f6b47Duncan Sands Entry.isZExt = !isSigned; 177847857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Args.push_back(Entry); 177977e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 1780056292fd738924f3f7703725d8f630983794b5a5Bill Wendling SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC), 17810c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang TLI.getPointerTy()); 1782edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1783db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *RetTy = Node->getValueType(0).getTypeForEVT(*DAG.getContext()); 17843d2125c9dbac695c93f42c0f59fd040e413fd711Evan Cheng 1785bf010eb9110009d745382bf15131fbe556562ffeEvan Cheng // By default, the input chain to this libcall is the entry node of the 1786bf010eb9110009d745382bf15131fbe556562ffeEvan Cheng // function. If the libcall is going to be emitted as a tail call then 1787bf010eb9110009d745382bf15131fbe556562ffeEvan Cheng // TLI.isUsedByReturnOnly will change it to the right chain if the return 1788bf010eb9110009d745382bf15131fbe556562ffeEvan Cheng // node which is being folded has a non-entry input chain. 1789bf010eb9110009d745382bf15131fbe556562ffeEvan Cheng SDValue InChain = DAG.getEntryNode(); 1790bf010eb9110009d745382bf15131fbe556562ffeEvan Cheng 17913d2125c9dbac695c93f42c0f59fd040e413fd711Evan Cheng // isTailCall may be true since the callee does not reference caller stack 17923d2125c9dbac695c93f42c0f59fd040e413fd711Evan Cheng // frame. Check if it's in the right position. 1793b52ba49fdbf6cdf055e8b264c18b6e594fd30dc4Evan Cheng SDValue TCChain = InChain; 1794b52ba49fdbf6cdf055e8b264c18b6e594fd30dc4Evan Cheng bool isTailCall = isInTailCallPosition(DAG, Node, TCChain, TLI); 1795b52ba49fdbf6cdf055e8b264c18b6e594fd30dc4Evan Cheng if (isTailCall) 1796b52ba49fdbf6cdf055e8b264c18b6e594fd30dc4Evan Cheng InChain = TCChain; 1797b52ba49fdbf6cdf055e8b264c18b6e594fd30dc4Evan Cheng 1798ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson std::pair<SDValue, SDValue> CallInfo = 179986098bd6a63d2cdf0c9be9ef3151bd2728281fd7Dale Johannesen TLI.LowerCallTo(InChain, RetTy, isSigned, !isSigned, false, false, 18003d2125c9dbac695c93f42c0f59fd040e413fd711Evan Cheng 0, TLI.getLibcallCallingConv(LC), isTailCall, 18014bfcd4acbc7d12aa55f8de9af84a38422f0f6d83Evan Cheng /*doesNotReturn=*/false, /*isReturnValueUsed=*/true, 180246ada19645c981a0b7932487d163f7582074a4d9Bill Wendling Callee, Args, DAG, Node->getDebugLoc()); 18030d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 18043d2125c9dbac695c93f42c0f59fd040e413fd711Evan Cheng if (!CallInfo.second.getNode()) 18053d2125c9dbac695c93f42c0f59fd040e413fd711Evan Cheng // It's a tailcall, return the chain (which is the DAG root). 18063d2125c9dbac695c93f42c0f59fd040e413fd711Evan Cheng return DAG.getRoot(); 18073d2125c9dbac695c93f42c0f59fd040e413fd711Evan Cheng 180874807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman return CallInfo.first; 180922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner} 181022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 1811f316eb70743e88227b8919370fe38587ffe93512Dan Gohman/// ExpandLibCall - Generate a libcall taking the given operands as arguments 1812abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher/// and returning a result of type RetVT. 1813abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric ChristopherSDValue SelectionDAGLegalize::ExpandLibCall(RTLIB::Libcall LC, EVT RetVT, 1814abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher const SDValue *Ops, unsigned NumOps, 1815abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher bool isSigned, DebugLoc dl) { 1816abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher TargetLowering::ArgListTy Args; 1817abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher Args.reserve(NumOps); 1818f316eb70743e88227b8919370fe38587ffe93512Dan Gohman 1819abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher TargetLowering::ArgListEntry Entry; 1820abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher for (unsigned i = 0; i != NumOps; ++i) { 1821abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher Entry.Node = Ops[i]; 1822abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher Entry.Ty = Entry.Node.getValueType().getTypeForEVT(*DAG.getContext()); 1823abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher Entry.isSExt = isSigned; 1824abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher Entry.isZExt = !isSigned; 1825abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher Args.push_back(Entry); 1826abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher } 1827abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC), 1828abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher TLI.getPointerTy()); 1829f316eb70743e88227b8919370fe38587ffe93512Dan Gohman 1830db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext()); 1831abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher std::pair<SDValue,SDValue> CallInfo = 1832abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher TLI.LowerCallTo(DAG.getEntryNode(), RetTy, isSigned, !isSigned, false, 1833bf010eb9110009d745382bf15131fbe556562ffeEvan Cheng false, 0, TLI.getLibcallCallingConv(LC), /*isTailCall=*/false, 18344bfcd4acbc7d12aa55f8de9af84a38422f0f6d83Evan Cheng /*doesNotReturn=*/false, /*isReturnValueUsed=*/true, 1835abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher Callee, Args, DAG, dl); 1836f316eb70743e88227b8919370fe38587ffe93512Dan Gohman 1837abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher return CallInfo.first; 1838abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher} 1839abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher 1840e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach// ExpandChainLibCall - Expand a node into a call to a libcall. Similar to 1841e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach// ExpandLibCall except that the first operand is the in-chain. 1842e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbachstd::pair<SDValue, SDValue> 1843e03262fcfc09356a0e3ec589041bc2e0248944e9Jim GrosbachSelectionDAGLegalize::ExpandChainLibCall(RTLIB::Libcall LC, 1844e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach SDNode *Node, 1845e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach bool isSigned) { 1846e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach SDValue InChain = Node->getOperand(0); 1847e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach 1848e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach TargetLowering::ArgListTy Args; 1849e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach TargetLowering::ArgListEntry Entry; 1850e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach for (unsigned i = 1, e = Node->getNumOperands(); i != e; ++i) { 1851e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach EVT ArgVT = Node->getOperand(i).getValueType(); 1852db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext()); 1853e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Entry.Node = Node->getOperand(i); 1854e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Entry.Ty = ArgTy; 1855e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Entry.isSExt = isSigned; 1856e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Entry.isZExt = !isSigned; 1857e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Args.push_back(Entry); 1858e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach } 1859e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC), 1860e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach TLI.getPointerTy()); 1861e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach 1862db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *RetTy = Node->getValueType(0).getTypeForEVT(*DAG.getContext()); 1863e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach std::pair<SDValue, SDValue> CallInfo = 1864e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach TLI.LowerCallTo(InChain, RetTy, isSigned, !isSigned, false, false, 18653d2125c9dbac695c93f42c0f59fd040e413fd711Evan Cheng 0, TLI.getLibcallCallingConv(LC), /*isTailCall=*/false, 18664bfcd4acbc7d12aa55f8de9af84a38422f0f6d83Evan Cheng /*doesNotReturn=*/false, /*isReturnValueUsed=*/true, 1867e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Callee, Args, DAG, Node->getDebugLoc()); 1868e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach 1869e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach return CallInfo; 1870e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach} 1871e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach 1872f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli FriedmanSDValue SelectionDAGLegalize::ExpandFPLibCall(SDNode* Node, 1873f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_F32, 1874f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_F64, 1875f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_F80, 1876f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_PPCF128) { 1877f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall LC; 1878825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson switch (Node->getValueType(0).getSimpleVT().SimpleTy) { 18795e25ee8a1fcf8288d00d731b0f7ab7976f33b123Craig Topper default: llvm_unreachable("Unexpected request for libcall!"); 1880825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::f32: LC = Call_F32; break; 1881825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::f64: LC = Call_F64; break; 1882825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::f80: LC = Call_F80; break; 1883825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::ppcf128: LC = Call_PPCF128; break; 1884f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman } 1885f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman return ExpandLibCall(LC, Node, false); 1886f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman} 1887f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman 1888f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli FriedmanSDValue SelectionDAGLegalize::ExpandIntLibCall(SDNode* Node, bool isSigned, 18898983da729aa1ca99a11a3b98ae6280dfcdbadb39Anton Korobeynikov RTLIB::Libcall Call_I8, 1890f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_I16, 1891f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_I32, 1892f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_I64, 1893f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_I128) { 1894f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall LC; 1895825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson switch (Node->getValueType(0).getSimpleVT().SimpleTy) { 18965e25ee8a1fcf8288d00d731b0f7ab7976f33b123Craig Topper default: llvm_unreachable("Unexpected request for libcall!"); 18978983da729aa1ca99a11a3b98ae6280dfcdbadb39Anton Korobeynikov case MVT::i8: LC = Call_I8; break; 18988983da729aa1ca99a11a3b98ae6280dfcdbadb39Anton Korobeynikov case MVT::i16: LC = Call_I16; break; 18998983da729aa1ca99a11a3b98ae6280dfcdbadb39Anton Korobeynikov case MVT::i32: LC = Call_I32; break; 19008983da729aa1ca99a11a3b98ae6280dfcdbadb39Anton Korobeynikov case MVT::i64: LC = Call_I64; break; 1901825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::i128: LC = Call_I128; break; 1902f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman } 1903f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman return ExpandLibCall(LC, Node, isSigned); 1904f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman} 1905f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman 190665279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng/// isDivRemLibcallAvailable - Return true if divmod libcall is available. 190765279cb9bd985721ac6ad090fed02298396ba06dEvan Chengstatic bool isDivRemLibcallAvailable(SDNode *Node, bool isSigned, 190865279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng const TargetLowering &TLI) { 19098e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng RTLIB::Libcall LC; 19108e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng switch (Node->getValueType(0).getSimpleVT().SimpleTy) { 19115e25ee8a1fcf8288d00d731b0f7ab7976f33b123Craig Topper default: llvm_unreachable("Unexpected request for libcall!"); 19128e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng case MVT::i8: LC= isSigned ? RTLIB::SDIVREM_I8 : RTLIB::UDIVREM_I8; break; 19138e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng case MVT::i16: LC= isSigned ? RTLIB::SDIVREM_I16 : RTLIB::UDIVREM_I16; break; 19148e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng case MVT::i32: LC= isSigned ? RTLIB::SDIVREM_I32 : RTLIB::UDIVREM_I32; break; 19158e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng case MVT::i64: LC= isSigned ? RTLIB::SDIVREM_I64 : RTLIB::UDIVREM_I64; break; 19168e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng case MVT::i128: LC= isSigned ? RTLIB::SDIVREM_I128:RTLIB::UDIVREM_I128; break; 19178e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng } 19188e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng 191965279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng return TLI.getLibcallName(LC) != 0; 192065279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng} 19218e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng 192265279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng/// UseDivRem - Only issue divrem libcall if both quotient and remainder are 192365279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng/// needed. 192465279cb9bd985721ac6ad090fed02298396ba06dEvan Chengstatic bool UseDivRem(SDNode *Node, bool isSigned, bool isDIV) { 19258e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng unsigned OtherOpcode = 0; 192665279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng if (isSigned) 19278e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng OtherOpcode = isDIV ? ISD::SREM : ISD::SDIV; 192865279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng else 19298e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng OtherOpcode = isDIV ? ISD::UREM : ISD::UDIV; 193065279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng 19318e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng SDValue Op0 = Node->getOperand(0); 19328e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng SDValue Op1 = Node->getOperand(1); 19338e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng for (SDNode::use_iterator UI = Op0.getNode()->use_begin(), 19348e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng UE = Op0.getNode()->use_end(); UI != UE; ++UI) { 19358e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng SDNode *User = *UI; 19368e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng if (User == Node) 19378e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng continue; 19388e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng if (User->getOpcode() == OtherOpcode && 19398e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng User->getOperand(0) == Op0 && 194065279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng User->getOperand(1) == Op1) 194165279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng return true; 19428e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng } 194365279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng return false; 194465279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng} 194565279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng 194665279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng/// ExpandDivRemLibCall - Issue libcalls to __{u}divmod to compute div / rem 194765279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng/// pairs. 194865279cb9bd985721ac6ad090fed02298396ba06dEvan Chengvoid 194965279cb9bd985721ac6ad090fed02298396ba06dEvan ChengSelectionDAGLegalize::ExpandDivRemLibCall(SDNode *Node, 195065279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng SmallVectorImpl<SDValue> &Results) { 195165279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng unsigned Opcode = Node->getOpcode(); 195265279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng bool isSigned = Opcode == ISD::SDIVREM; 195365279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng 195465279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng RTLIB::Libcall LC; 195565279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng switch (Node->getValueType(0).getSimpleVT().SimpleTy) { 19565e25ee8a1fcf8288d00d731b0f7ab7976f33b123Craig Topper default: llvm_unreachable("Unexpected request for libcall!"); 195765279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng case MVT::i8: LC= isSigned ? RTLIB::SDIVREM_I8 : RTLIB::UDIVREM_I8; break; 195865279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng case MVT::i16: LC= isSigned ? RTLIB::SDIVREM_I16 : RTLIB::UDIVREM_I16; break; 195965279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng case MVT::i32: LC= isSigned ? RTLIB::SDIVREM_I32 : RTLIB::UDIVREM_I32; break; 196065279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng case MVT::i64: LC= isSigned ? RTLIB::SDIVREM_I64 : RTLIB::UDIVREM_I64; break; 196165279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng case MVT::i128: LC= isSigned ? RTLIB::SDIVREM_I128:RTLIB::UDIVREM_I128; break; 19628e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng } 19638e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng 19648e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng // The input chain to this libcall is the entry node of the function. 19658e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng // Legalizing the call will automatically add the previous call to the 19668e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng // dependence. 19678e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng SDValue InChain = DAG.getEntryNode(); 19688e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng 19698e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng EVT RetVT = Node->getValueType(0); 1970db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext()); 19718e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng 19728e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng TargetLowering::ArgListTy Args; 19738e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng TargetLowering::ArgListEntry Entry; 19748e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 19758e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng EVT ArgVT = Node->getOperand(i).getValueType(); 1976db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext()); 19778e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Entry.Node = Node->getOperand(i); Entry.Ty = ArgTy; 19788e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Entry.isSExt = isSigned; 19798e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Entry.isZExt = !isSigned; 19808e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Args.push_back(Entry); 19818e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng } 19828e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng 19838e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng // Also pass the return address of the remainder. 19848e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng SDValue FIPtr = DAG.CreateStackTemporary(RetVT); 19858e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Entry.Node = FIPtr; 19868e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Entry.Ty = RetTy->getPointerTo(); 19878e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Entry.isSExt = isSigned; 19888e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Entry.isZExt = !isSigned; 19898e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng Args.push_back(Entry); 19908e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng 19918e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC), 19928e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng TLI.getPointerTy()); 19938e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng 19948e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng DebugLoc dl = Node->getDebugLoc(); 19958e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng std::pair<SDValue, SDValue> CallInfo = 19968e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng TLI.LowerCallTo(InChain, RetTy, isSigned, !isSigned, false, false, 19978e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng 0, TLI.getLibcallCallingConv(LC), /*isTailCall=*/false, 19984bfcd4acbc7d12aa55f8de9af84a38422f0f6d83Evan Cheng /*doesNotReturn=*/false, /*isReturnValueUsed=*/true, 19994bfcd4acbc7d12aa55f8de9af84a38422f0f6d83Evan Cheng Callee, Args, DAG, dl); 20008e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng 20018e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng // Remainder is loaded back from the stack frame. 200265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue Rem = DAG.getLoad(RetVT, dl, CallInfo.second, FIPtr, 2003d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper MachinePointerInfo(), false, false, false, 0); 200465279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng Results.push_back(CallInfo.first); 200565279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng Results.push_back(Rem); 20068e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng} 20078e23e815ad1136721acdfcce76975a37c8a2c036Evan Cheng 200822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// ExpandLegalINT_TO_FP - This function is responsible for legalizing a 200922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// INT_TO_FP operation of the specified operand when the target requests that 201022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// we expand it. At this point, we know that the result and operand types are 201122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// legal for the target. 2012475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::ExpandLegalINT_TO_FP(bool isSigned, 2013475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op0, 2014e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DestVT, 2015af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl) { 2016825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (Op0.getValueType() == MVT::i32) { 201722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // simple 32-bit [signed|unsigned] integer to float/double expansion 2018fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 201923594d4537fb88a963c6d6993af5027eac9bfbacChris Lattner // Get the stack frame index of a 8 byte buffer. 2020825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson SDValue StackSlot = DAG.CreateStackTemporary(MVT::f64); 2021fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 202222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // word offset constant for Hi/Lo address computation 2023475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue WordOff = DAG.getConstant(sizeof(int), TLI.getPointerTy()); 202422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // set up Hi and Lo (into buffer) address based on endian 2025475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Hi = StackSlot; 2026fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel SDValue Lo = DAG.getNode(ISD::ADD, dl, 2027ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson TLI.getPointerTy(), StackSlot, WordOff); 2028408c428096df3a3970a8387f9dd258ae948663a6Chris Lattner if (TLI.isLittleEndian()) 2029408c428096df3a3970a8387f9dd258ae948663a6Chris Lattner std::swap(Hi, Lo); 2030fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 203122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // if signed map to unsigned space 2032475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op0Mapped; 203322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (isSigned) { 203422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // constant used to invert sign bit (signed to unsigned mapping) 2035825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson SDValue SignBit = DAG.getConstant(0x80000000u, MVT::i32); 2036825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson Op0Mapped = DAG.getNode(ISD::XOR, dl, MVT::i32, Op0, SignBit); 203722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } else { 203822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner Op0Mapped = Op0; 203922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 204022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // store the lo of the constructed double - based on integer input 2041af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue Store1 = DAG.getStore(DAG.getEntryNode(), dl, 20426229d0acb8f395552131a7015a5d1e7b2bae2111Chris Lattner Op0Mapped, Lo, MachinePointerInfo(), 20431e559443a17d1b335f697551c6263ba60d5dd827David Greene false, false, 0); 204422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // initial hi portion of constructed double 2045825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson SDValue InitialHi = DAG.getConstant(0x43300000u, MVT::i32); 204622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // store the hi of the constructed double - biased exponent 20476229d0acb8f395552131a7015a5d1e7b2bae2111Chris Lattner SDValue Store2 = DAG.getStore(Store1, dl, InitialHi, Hi, 20486229d0acb8f395552131a7015a5d1e7b2bae2111Chris Lattner MachinePointerInfo(), 20496229d0acb8f395552131a7015a5d1e7b2bae2111Chris Lattner false, false, 0); 205022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // load the constructed double 2051ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner SDValue Load = DAG.getLoad(MVT::f64, dl, Store2, StackSlot, 2052d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper MachinePointerInfo(), false, false, false, 0); 205322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // FP constant to bias correct the final result 2054475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Bias = DAG.getConstantFP(isSigned ? 2055ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson BitsToDouble(0x4330000080000000ULL) : 2056ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson BitsToDouble(0x4330000000000000ULL), 2057825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT::f64); 205822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // subtract the bias 2059825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::f64, Load, Bias); 206022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // final result 2061475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Result; 206222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // handle final rounding 2063825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (DestVT == MVT::f64) { 206422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // do nothing 206522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner Result = Sub; 2066825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson } else if (DestVT.bitsLT(MVT::f64)) { 2067af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen Result = DAG.getNode(ISD::FP_ROUND, dl, DestVT, Sub, 20680bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(0)); 2069825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson } else if (DestVT.bitsGT(MVT::f64)) { 2070af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen Result = DAG.getNode(ISD::FP_EXTEND, dl, DestVT, Sub); 207122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 207222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner return Result; 207322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 207422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner assert(!isSigned && "Legalize cannot Expand SINT_TO_FP for i64 yet"); 2075a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen // Code below here assumes !isSigned without checking again. 20760fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman 20770fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman // Implementation of unsigned i64 to f64 following the algorithm in 20780fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman // __floatundidf in compiler_rt. This implementation has the advantage 20790fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman // of performing rounding correctly, both in the default rounding mode 20800fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman // and in all alternate rounding modes. 20810fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman // TODO: Generalize this for use with other types. 20820fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman if (Op0.getValueType() == MVT::i64 && DestVT == MVT::f64) { 20830fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman SDValue TwoP52 = 20840fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman DAG.getConstant(UINT64_C(0x4330000000000000), MVT::i64); 20850fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman SDValue TwoP84PlusTwoP52 = 20860fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman DAG.getConstantFP(BitsToDouble(UINT64_C(0x4530000000100000)), MVT::f64); 20870fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman SDValue TwoP84 = 20880fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman DAG.getConstant(UINT64_C(0x4530000000000000), MVT::i64); 20890fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman 20900fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman SDValue Lo = DAG.getZeroExtendInReg(Op0, dl, MVT::i32); 20910fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman SDValue Hi = DAG.getNode(ISD::SRL, dl, MVT::i64, Op0, 20920fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman DAG.getConstant(32, MVT::i64)); 20930fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman SDValue LoOr = DAG.getNode(ISD::OR, dl, MVT::i64, Lo, TwoP52); 20940fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman SDValue HiOr = DAG.getNode(ISD::OR, dl, MVT::i64, Hi, TwoP84); 2095bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck SDValue LoFlt = DAG.getNode(ISD::BITCAST, dl, MVT::f64, LoOr); 2096bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck SDValue HiFlt = DAG.getNode(ISD::BITCAST, dl, MVT::f64, HiOr); 20976e9926108a69efbc11f1cadf947e98500e4d4228Jim Grosbach SDValue HiSub = DAG.getNode(ISD::FSUB, dl, MVT::f64, HiFlt, 20986e9926108a69efbc11f1cadf947e98500e4d4228Jim Grosbach TwoP84PlusTwoP52); 20990fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman return DAG.getNode(ISD::FADD, dl, MVT::f64, LoFlt, HiSub); 21000fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman } 21010fa9d1d9011a98212b66daf27f6a8a3d734ae818Dan Gohman 21023a9e7690ba99c27d9b09fa8e61fb9f7ba01364c9Owen Anderson // Implementation of unsigned i64 to f32. 2103a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen // TODO: Generalize this for use with other types. 2104a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen if (Op0.getValueType() == MVT::i64 && DestVT == MVT::f32) { 21053a9e7690ba99c27d9b09fa8e61fb9f7ba01364c9Owen Anderson // For unsigned conversions, convert them to signed conversions using the 21063a9e7690ba99c27d9b09fa8e61fb9f7ba01364c9Owen Anderson // algorithm from the x86_64 __floatundidf in compiler_rt. 21073a9e7690ba99c27d9b09fa8e61fb9f7ba01364c9Owen Anderson if (!isSigned) { 21083a9e7690ba99c27d9b09fa8e61fb9f7ba01364c9Owen Anderson SDValue Fast = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::f32, Op0); 2109bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 211095771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson SDValue ShiftConst = 211195771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson DAG.getConstant(1, TLI.getShiftAmountTy(Op0.getValueType())); 21123a9e7690ba99c27d9b09fa8e61fb9f7ba01364c9Owen Anderson SDValue Shr = DAG.getNode(ISD::SRL, dl, MVT::i64, Op0, ShiftConst); 21133a9e7690ba99c27d9b09fa8e61fb9f7ba01364c9Owen Anderson SDValue AndConst = DAG.getConstant(1, MVT::i64); 21143a9e7690ba99c27d9b09fa8e61fb9f7ba01364c9Owen Anderson SDValue And = DAG.getNode(ISD::AND, dl, MVT::i64, Op0, AndConst); 21153a9e7690ba99c27d9b09fa8e61fb9f7ba01364c9Owen Anderson SDValue Or = DAG.getNode(ISD::OR, dl, MVT::i64, And, Shr); 2116bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 21173a9e7690ba99c27d9b09fa8e61fb9f7ba01364c9Owen Anderson SDValue SignCvt = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::f32, Or); 21183a9e7690ba99c27d9b09fa8e61fb9f7ba01364c9Owen Anderson SDValue Slow = DAG.getNode(ISD::FADD, dl, MVT::f32, SignCvt, SignCvt); 2119bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 21203a9e7690ba99c27d9b09fa8e61fb9f7ba01364c9Owen Anderson // TODO: This really should be implemented using a branch rather than a 2121bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // select. We happen to get lucky and machinesink does the right 2122bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // thing most of the time. This would be a good candidate for a 21233a9e7690ba99c27d9b09fa8e61fb9f7ba01364c9Owen Anderson //pseudo-op, or, even better, for whole-function isel. 2124bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck SDValue SignBitTest = DAG.getSetCC(dl, TLI.getSetCCResultType(MVT::i64), 21253a9e7690ba99c27d9b09fa8e61fb9f7ba01364c9Owen Anderson Op0, DAG.getConstant(0, MVT::i64), ISD::SETLT); 21263a9e7690ba99c27d9b09fa8e61fb9f7ba01364c9Owen Anderson return DAG.getNode(ISD::SELECT, dl, MVT::f32, SignBitTest, Slow, Fast); 21273a9e7690ba99c27d9b09fa8e61fb9f7ba01364c9Owen Anderson } 2128bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 21293a9e7690ba99c27d9b09fa8e61fb9f7ba01364c9Owen Anderson // Otherwise, implement the fully general conversion. 2130bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 21316e9926108a69efbc11f1cadf947e98500e4d4228Jim Grosbach SDValue And = DAG.getNode(ISD::AND, dl, MVT::i64, Op0, 2132a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen DAG.getConstant(UINT64_C(0xfffffffffffff800), MVT::i64)); 2133a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen SDValue Or = DAG.getNode(ISD::OR, dl, MVT::i64, And, 2134a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen DAG.getConstant(UINT64_C(0x800), MVT::i64)); 21356e9926108a69efbc11f1cadf947e98500e4d4228Jim Grosbach SDValue And2 = DAG.getNode(ISD::AND, dl, MVT::i64, Op0, 2136a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen DAG.getConstant(UINT64_C(0x7ff), MVT::i64)); 2137a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen SDValue Ne = DAG.getSetCC(dl, TLI.getSetCCResultType(MVT::i64), 2138a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen And2, DAG.getConstant(UINT64_C(0), MVT::i64), ISD::SETNE); 2139a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen SDValue Sel = DAG.getNode(ISD::SELECT, dl, MVT::i64, Ne, Or, Op0); 2140a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen SDValue Ge = DAG.getSetCC(dl, TLI.getSetCCResultType(MVT::i64), 2141a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen Op0, DAG.getConstant(UINT64_C(0x0020000000000000), MVT::i64), 21423a9e7690ba99c27d9b09fa8e61fb9f7ba01364c9Owen Anderson ISD::SETUGE); 2143a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen SDValue Sel2 = DAG.getNode(ISD::SELECT, dl, MVT::i64, Ge, Sel, Op0); 214495771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson EVT SHVT = TLI.getShiftAmountTy(Sel2.getValueType()); 2145bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 2146a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen SDValue Sh = DAG.getNode(ISD::SRL, dl, MVT::i64, Sel2, 2147a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen DAG.getConstant(32, SHVT)); 2148a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen SDValue Trunc = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Sh); 2149a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen SDValue Fcvt = DAG.getNode(ISD::UINT_TO_FP, dl, MVT::f64, Trunc); 2150a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen SDValue TwoP32 = 2151a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen DAG.getConstantFP(BitsToDouble(UINT64_C(0x41f0000000000000)), MVT::f64); 2152a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen SDValue Fmul = DAG.getNode(ISD::FMUL, dl, MVT::f64, TwoP32, Fcvt); 2153a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen SDValue Lo = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Sel2); 2154a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen SDValue Fcvt2 = DAG.getNode(ISD::UINT_TO_FP, dl, MVT::f64, Lo); 2155a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen SDValue Fadd = DAG.getNode(ISD::FADD, dl, MVT::f64, Fmul, Fcvt2); 2156a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen return DAG.getNode(ISD::FP_ROUND, dl, MVT::f32, Fadd, 2157a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen DAG.getIntPtrConstant(0)); 2158a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen } 2159a5afa1cb214146fd270c86f606b634c8ed6682f2Dale Johannesen 2160b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman SDValue Tmp1 = DAG.getNode(ISD::SINT_TO_FP, dl, DestVT, Op0); 2161b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman 2162b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman SDValue SignSet = DAG.getSetCC(dl, TLI.getSetCCResultType(Op0.getValueType()), 2163b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman Op0, DAG.getConstant(0, Op0.getValueType()), 2164b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman ISD::SETLT); 2165b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman SDValue Zero = DAG.getIntPtrConstant(0), Four = DAG.getIntPtrConstant(4); 2166b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman SDValue CstOffset = DAG.getNode(ISD::SELECT, dl, Zero.getValueType(), 2167b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman SignSet, Four, Zero); 2168b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman 2169b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman // If the sign bit of the integer is set, the large number will be treated 2170b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman // as a negative number. To counteract this, the dynamic code adds an 2171b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman // offset depending on the data type. 2172b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman uint64_t FF; 2173b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman switch (Op0.getValueType().getSimpleVT().SimpleTy) { 21745e25ee8a1fcf8288d00d731b0f7ab7976f33b123Craig Topper default: llvm_unreachable("Unsupported integer type!"); 2175b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman case MVT::i8 : FF = 0x43800000ULL; break; // 2^8 (as a float) 2176b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman case MVT::i16: FF = 0x47800000ULL; break; // 2^16 (as a float) 2177b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman case MVT::i32: FF = 0x4F800000ULL; break; // 2^32 (as a float) 2178b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman case MVT::i64: FF = 0x5F800000ULL; break; // 2^64 (as a float) 2179b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman } 2180b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman if (TLI.isLittleEndian()) FF <<= 32; 2181b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman Constant *FudgeFactor = ConstantInt::get( 2182b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman Type::getInt64Ty(*DAG.getContext()), FF); 2183b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman 2184b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman SDValue CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy()); 2185b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman unsigned Alignment = cast<ConstantPoolSDNode>(CPIdx)->getAlignment(); 2186b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman CPIdx = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(), CPIdx, CstOffset); 2187b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman Alignment = std::min(Alignment, 4u); 2188b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman SDValue FudgeInReg; 2189b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman if (DestVT == MVT::f32) 2190b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman FudgeInReg = DAG.getLoad(MVT::f32, dl, DAG.getEntryNode(), CPIdx, 219185ca1066328639119f94c47a83b698c48b84ebb0Chris Lattner MachinePointerInfo::getConstantPool(), 2192d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper false, false, false, Alignment); 2193b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman else { 219465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, DestVT, 219565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG.getEntryNode(), CPIdx, 219665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman MachinePointerInfo::getConstantPool(), 219765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman MVT::f32, false, false, Alignment); 219865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman HandleSDNode Handle(Load); 219965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman LegalizeOp(Load.getNode()); 220065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman FudgeInReg = Handle.getValue(); 2201b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman } 220222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 2203b6b343d77acb5c290f7093e741fbce484d11cedcDan Gohman return DAG.getNode(ISD::FADD, dl, DestVT, Tmp1, FudgeInReg); 220422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner} 220522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 220622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// PromoteLegalINT_TO_FP - This function is responsible for legalizing a 220722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// *INT_TO_FP operation of the specified operand when the target requests that 220822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// we promote it. At this point, we know that the result and operand types are 220922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// legal for the target, and that there is a legal UINT_TO_FP or SINT_TO_FP 221022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// operation that takes a larger input. 2211475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::PromoteLegalINT_TO_FP(SDValue LegalOp, 2212e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DestVT, 2213af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen bool isSigned, 2214af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl) { 221522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // First step, figure out the appropriate *INT_TO_FP operation to use. 2216e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT NewInTy = LegalOp.getValueType(); 221722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 221822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner unsigned OpToUse = 0; 221922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 222022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // Scan for the appropriate larger type to use. 222122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner while (1) { 2222825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson NewInTy = (MVT::SimpleValueType)(NewInTy.getSimpleVT().SimpleTy+1); 222383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(NewInTy.isInteger() && "Ran out of possibilities!"); 222422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 222522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // If the target supports SINT_TO_FP of this type, use it. 22263be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman if (TLI.isOperationLegalOrCustom(ISD::SINT_TO_FP, NewInTy)) { 22273be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman OpToUse = ISD::SINT_TO_FP; 22283be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman break; 222922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 223022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (isSigned) continue; 223122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 223222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // If the target supports UINT_TO_FP of this type, use it. 22333be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman if (TLI.isOperationLegalOrCustom(ISD::UINT_TO_FP, NewInTy)) { 22343be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman OpToUse = ISD::UINT_TO_FP; 22353be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman break; 223622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 223722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 223822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // Otherwise, try a larger type. 223922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 224022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 224122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // Okay, we found the operation and type to use. Zero extend our input to the 224222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // desired type then run the operation on it. 2243af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen return DAG.getNode(OpToUse, dl, DestVT, 224422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, 2245af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen dl, NewInTy, LegalOp)); 224677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 224777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 224822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// PromoteLegalFP_TO_INT - This function is responsible for legalizing a 224922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// FP_TO_*INT operation of the specified operand when the target requests that 225022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// we promote it. At this point, we know that the result and operand types are 225122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// legal for the target, and that there is a legal FP_TO_UINT or FP_TO_SINT 225222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// operation that returns a larger result. 2253475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::PromoteLegalFP_TO_INT(SDValue LegalOp, 2254e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DestVT, 2255af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen bool isSigned, 2256af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl) { 225722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // First step, figure out the appropriate FP_TO*INT operation to use. 2258e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT NewOutTy = DestVT; 22599c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 226022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner unsigned OpToUse = 0; 2261e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 226222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // Scan for the appropriate larger type to use. 226322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner while (1) { 2264825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson NewOutTy = (MVT::SimpleValueType)(NewOutTy.getSimpleVT().SimpleTy+1); 226583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(NewOutTy.isInteger() && "Ran out of possibilities!"); 226666de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner 22673be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman if (TLI.isOperationLegalOrCustom(ISD::FP_TO_SINT, NewOutTy)) { 226822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner OpToUse = ISD::FP_TO_SINT; 226922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner break; 227022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 2271e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 22723be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman if (TLI.isOperationLegalOrCustom(ISD::FP_TO_UINT, NewOutTy)) { 227322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner OpToUse = ISD::FP_TO_UINT; 227422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner break; 2275e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner } 22760d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 227722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // Otherwise, try a larger type. 2278a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner } 2279a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner 2280fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 228127a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner // Okay, we found the operation and type to use. 2282af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue Operation = DAG.getNode(OpToUse, dl, NewOutTy, LegalOp); 2283126d90770bdb17e6925b2fe26de99aa079b7b9b3Duncan Sands 228427a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner // Truncate the result of the extended FP_TO_*INT operation to the desired 228527a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner // size. 2286af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen return DAG.getNode(ISD::TRUNCATE, dl, DestVT, Operation); 228722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner} 228813689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner 228922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// ExpandBSWAP - Open code the operations for BSWAP of the specified operation. 229022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// 22918a782a2a8c2f0c82f292d03a3f707232b0bae27bDale JohannesenSDValue SelectionDAGLegalize::ExpandBSWAP(SDValue Op, DebugLoc dl) { 2292e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Op.getValueType(); 229395771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson EVT SHVT = TLI.getShiftAmountTy(VT); 2294475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp1, Tmp2, Tmp3, Tmp4, Tmp5, Tmp6, Tmp7, Tmp8; 2295825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson switch (VT.getSimpleVT().SimpleTy) { 22965e25ee8a1fcf8288d00d731b0f7ab7976f33b123Craig Topper default: llvm_unreachable("Unhandled Expand type in BSWAP!"); 2297825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::i16: 22988a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, SHVT)); 22998a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, SHVT)); 23008a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getNode(ISD::OR, dl, VT, Tmp1, Tmp2); 2301825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::i32: 23028a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp4 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(24, SHVT)); 23038a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp3 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, SHVT)); 23048a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, SHVT)); 23058a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(24, SHVT)); 23068a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp3 = DAG.getNode(ISD::AND, dl, VT, Tmp3, DAG.getConstant(0xFF0000, VT)); 23078a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp2, DAG.getConstant(0xFF00, VT)); 23088a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp3); 23098a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp1); 23108a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp2); 2311825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson case MVT::i64: 23128a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp8 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(56, SHVT)); 23138a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp7 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(40, SHVT)); 23148a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp6 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(24, SHVT)); 23158a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp5 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, SHVT)); 23168a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp4 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, SHVT)); 23178a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp3 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(24, SHVT)); 23188a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(40, SHVT)); 23198a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(56, SHVT)); 23208a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp7 = DAG.getNode(ISD::AND, dl, VT, Tmp7, DAG.getConstant(255ULL<<48, VT)); 23218a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp6 = DAG.getNode(ISD::AND, dl, VT, Tmp6, DAG.getConstant(255ULL<<40, VT)); 23228a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp5 = DAG.getNode(ISD::AND, dl, VT, Tmp5, DAG.getConstant(255ULL<<32, VT)); 23238a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp4 = DAG.getNode(ISD::AND, dl, VT, Tmp4, DAG.getConstant(255ULL<<24, VT)); 23248a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp3 = DAG.getNode(ISD::AND, dl, VT, Tmp3, DAG.getConstant(255ULL<<16, VT)); 23258a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp2, DAG.getConstant(255ULL<<8 , VT)); 23268a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp8 = DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp7); 23278a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp6 = DAG.getNode(ISD::OR, dl, VT, Tmp6, Tmp5); 23288a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp3); 23298a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp1); 23308a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp8 = DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp6); 23318a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp2); 23328a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp4); 23330d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner } 233477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 2335edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2336b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer/// SplatByte - Distribute ByteVal over NumBits bits. 23375df5a22d1a098961edebac59fbddcab045fddd29Benjamin Kramer// FIXME: Move this helper to a common place. 2338b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramerstatic APInt SplatByte(unsigned NumBits, uint8_t ByteVal) { 2339b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer APInt Val = APInt(NumBits, ByteVal); 2340b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer unsigned Shift = 8; 2341b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer for (unsigned i = NumBits; i > 8; i >>= 1) { 2342b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer Val = (Val << Shift) | Val; 2343b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer Shift <<= 1; 2344b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer } 2345b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer return Val; 2346b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer} 2347b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer 234822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// ExpandBitCount - Expand the specified bitcount instruction into operations. 234922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// 2350fdc40a0a696c658d550d894ea03772e5f8af2c94Scott MichelSDValue SelectionDAGLegalize::ExpandBitCount(unsigned Opc, SDValue Op, 23518a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DebugLoc dl) { 235222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner switch (Opc) { 23535e25ee8a1fcf8288d00d731b0f7ab7976f33b123Craig Topper default: llvm_unreachable("Cannot expand this yet!"); 235422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case ISD::CTPOP: { 2355e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Op.getValueType(); 235695771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson EVT ShVT = TLI.getShiftAmountTy(VT); 2357b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer unsigned Len = VT.getSizeInBits(); 2358b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer 23595df5a22d1a098961edebac59fbddcab045fddd29Benjamin Kramer assert(VT.isInteger() && Len <= 128 && Len % 8 == 0 && 23605df5a22d1a098961edebac59fbddcab045fddd29Benjamin Kramer "CTPOP not implemented for this type."); 23615df5a22d1a098961edebac59fbddcab045fddd29Benjamin Kramer 2362b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer // This is the "best" algorithm from 2363b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer // http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel 2364b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer 2365b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer SDValue Mask55 = DAG.getConstant(SplatByte(Len, 0x55), VT); 2366b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer SDValue Mask33 = DAG.getConstant(SplatByte(Len, 0x33), VT); 2367b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer SDValue Mask0F = DAG.getConstant(SplatByte(Len, 0x0F), VT); 2368b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer SDValue Mask01 = DAG.getConstant(SplatByte(Len, 0x01), VT); 2369b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer 2370b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer // v = v - ((v >> 1) & 0x55555555...) 2371b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer Op = DAG.getNode(ISD::SUB, dl, VT, Op, 2372b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer DAG.getNode(ISD::AND, dl, VT, 2373b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer DAG.getNode(ISD::SRL, dl, VT, Op, 2374b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer DAG.getConstant(1, ShVT)), 2375b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer Mask55)); 2376b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer // v = (v & 0x33333333...) + ((v >> 2) & 0x33333333...) 2377b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer Op = DAG.getNode(ISD::ADD, dl, VT, 2378b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer DAG.getNode(ISD::AND, dl, VT, Op, Mask33), 2379b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer DAG.getNode(ISD::AND, dl, VT, 2380b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer DAG.getNode(ISD::SRL, dl, VT, Op, 2381b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer DAG.getConstant(2, ShVT)), 2382b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer Mask33)); 2383b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer // v = (v + (v >> 4)) & 0x0F0F0F0F... 2384b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer Op = DAG.getNode(ISD::AND, dl, VT, 2385b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer DAG.getNode(ISD::ADD, dl, VT, Op, 2386b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer DAG.getNode(ISD::SRL, dl, VT, Op, 2387b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer DAG.getConstant(4, ShVT))), 2388b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer Mask0F); 2389b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer // v = (v * 0x01010101...) >> (Len - 8) 2390b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer Op = DAG.getNode(ISD::SRL, dl, VT, 2391b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer DAG.getNode(ISD::MUL, dl, VT, Op, Mask01), 2392b6516aeef12a05aa47515f76e18fc426d85babbdBenjamin Kramer DAG.getConstant(Len - 8, ShVT)); 239395771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson 239422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner return Op; 239522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 239663974b2144c87c962effdc0508c27643c8ad98b6Chandler Carruth case ISD::CTLZ_ZERO_UNDEF: 239763974b2144c87c962effdc0508c27643c8ad98b6Chandler Carruth // This trivially expands to CTLZ. 239863974b2144c87c962effdc0508c27643c8ad98b6Chandler Carruth return DAG.getNode(ISD::CTLZ, dl, Op.getValueType(), Op); 239922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case ISD::CTLZ: { 240022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // for now, we do this: 240122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // x = x | (x >> 1); 240222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // x = x | (x >> 2); 240322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // ... 240422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // x = x | (x >>16); 240522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // x = x | (x >>32); // for 64-bit input 240622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // return popcount(~x); 240722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // 240822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // but see also: http://www.hackersdelight.org/HDcode/nlz.cc 2409e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Op.getValueType(); 241095771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson EVT ShVT = TLI.getShiftAmountTy(VT); 241183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned len = VT.getSizeInBits(); 241222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 2413475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp3 = DAG.getConstant(1ULL << i, ShVT); 2414fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Op = DAG.getNode(ISD::OR, dl, VT, Op, 2415e72c5964d5263f2489bf2c7e9d32f71271d205fcDale Johannesen DAG.getNode(ISD::SRL, dl, VT, Op, Tmp3)); 241622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 24178a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Op = DAG.getNOT(dl, Op, VT); 24188a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getNode(ISD::CTPOP, dl, VT, Op); 241922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 242063974b2144c87c962effdc0508c27643c8ad98b6Chandler Carruth case ISD::CTTZ_ZERO_UNDEF: 242163974b2144c87c962effdc0508c27643c8ad98b6Chandler Carruth // This trivially expands to CTTZ. 242263974b2144c87c962effdc0508c27643c8ad98b6Chandler Carruth return DAG.getNode(ISD::CTTZ, dl, Op.getValueType(), Op); 242322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case ISD::CTTZ: { 242422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // for now, we use: { return popcount(~x & (x - 1)); } 242522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // unless the target has ctlz but not ctpop, in which case we use: 242622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // { return 32 - nlz(~x & (x-1)); } 242722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // see also http://www.hackersdelight.org/HDcode/ntz.cc 2428e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Op.getValueType(); 24298a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen SDValue Tmp3 = DAG.getNode(ISD::AND, dl, VT, 24308a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DAG.getNOT(dl, Op, VT), 24318a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DAG.getNode(ISD::SUB, dl, VT, Op, 24327581bfa2757a3149c6d17c0fe592e5c3808aa843Bill Wendling DAG.getConstant(1, VT))); 243322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // If ISD::CTLZ is legal and CTPOP isn't, then do that instead. 2434f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman if (!TLI.isOperationLegalOrCustom(ISD::CTPOP, VT) && 2435f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman TLI.isOperationLegalOrCustom(ISD::CTLZ, VT)) 24368a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getNode(ISD::SUB, dl, VT, 243783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(VT.getSizeInBits(), VT), 24388a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DAG.getNode(ISD::CTLZ, dl, VT, Tmp3)); 24398a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getNode(ISD::CTPOP, dl, VT, Tmp3); 244022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 244122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 244222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner} 2443e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 2444e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbachstd::pair <SDValue, SDValue> SelectionDAGLegalize::ExpandAtomic(SDNode *Node) { 2445e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach unsigned Opc = Node->getOpcode(); 2446e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach MVT VT = cast<AtomicSDNode>(Node)->getMemoryVT().getSimpleVT(); 2447e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach RTLIB::Libcall LC; 2448e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach 2449e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach switch (Opc) { 2450e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach default: 2451e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach llvm_unreachable("Unhandled atomic intrinsic Expand!"); 2452ef6eb9c7ab7967790566c5e2d47977d89fc060eeJim Grosbach case ISD::ATOMIC_SWAP: 2453ef6eb9c7ab7967790566c5e2d47977d89fc060eeJim Grosbach switch (VT.SimpleTy) { 2454ef6eb9c7ab7967790566c5e2d47977d89fc060eeJim Grosbach default: llvm_unreachable("Unexpected value type for atomic!"); 2455ef6eb9c7ab7967790566c5e2d47977d89fc060eeJim Grosbach case MVT::i8: LC = RTLIB::SYNC_LOCK_TEST_AND_SET_1; break; 2456ef6eb9c7ab7967790566c5e2d47977d89fc060eeJim Grosbach case MVT::i16: LC = RTLIB::SYNC_LOCK_TEST_AND_SET_2; break; 2457ef6eb9c7ab7967790566c5e2d47977d89fc060eeJim Grosbach case MVT::i32: LC = RTLIB::SYNC_LOCK_TEST_AND_SET_4; break; 2458ef6eb9c7ab7967790566c5e2d47977d89fc060eeJim Grosbach case MVT::i64: LC = RTLIB::SYNC_LOCK_TEST_AND_SET_8; break; 2459ef6eb9c7ab7967790566c5e2d47977d89fc060eeJim Grosbach } 2460ef6eb9c7ab7967790566c5e2d47977d89fc060eeJim Grosbach break; 2461e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case ISD::ATOMIC_CMP_SWAP: 2462e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach switch (VT.SimpleTy) { 2463e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach default: llvm_unreachable("Unexpected value type for atomic!"); 2464e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i8: LC = RTLIB::SYNC_VAL_COMPARE_AND_SWAP_1; break; 2465e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i16: LC = RTLIB::SYNC_VAL_COMPARE_AND_SWAP_2; break; 2466e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i32: LC = RTLIB::SYNC_VAL_COMPARE_AND_SWAP_4; break; 2467e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i64: LC = RTLIB::SYNC_VAL_COMPARE_AND_SWAP_8; break; 2468e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach } 2469e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach break; 2470e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case ISD::ATOMIC_LOAD_ADD: 2471e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach switch (VT.SimpleTy) { 2472e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach default: llvm_unreachable("Unexpected value type for atomic!"); 2473e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i8: LC = RTLIB::SYNC_FETCH_AND_ADD_1; break; 2474e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i16: LC = RTLIB::SYNC_FETCH_AND_ADD_2; break; 2475e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i32: LC = RTLIB::SYNC_FETCH_AND_ADD_4; break; 2476e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i64: LC = RTLIB::SYNC_FETCH_AND_ADD_8; break; 2477e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach } 2478e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach break; 2479e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case ISD::ATOMIC_LOAD_SUB: 2480e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach switch (VT.SimpleTy) { 2481e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach default: llvm_unreachable("Unexpected value type for atomic!"); 2482e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i8: LC = RTLIB::SYNC_FETCH_AND_SUB_1; break; 2483e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i16: LC = RTLIB::SYNC_FETCH_AND_SUB_2; break; 2484e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i32: LC = RTLIB::SYNC_FETCH_AND_SUB_4; break; 2485e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i64: LC = RTLIB::SYNC_FETCH_AND_SUB_8; break; 2486e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach } 2487e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach break; 2488e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case ISD::ATOMIC_LOAD_AND: 2489e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach switch (VT.SimpleTy) { 2490e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach default: llvm_unreachable("Unexpected value type for atomic!"); 2491e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i8: LC = RTLIB::SYNC_FETCH_AND_AND_1; break; 2492e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i16: LC = RTLIB::SYNC_FETCH_AND_AND_2; break; 2493e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i32: LC = RTLIB::SYNC_FETCH_AND_AND_4; break; 2494e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i64: LC = RTLIB::SYNC_FETCH_AND_AND_8; break; 2495e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach } 2496e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach break; 2497e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case ISD::ATOMIC_LOAD_OR: 2498e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach switch (VT.SimpleTy) { 2499e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach default: llvm_unreachable("Unexpected value type for atomic!"); 2500e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i8: LC = RTLIB::SYNC_FETCH_AND_OR_1; break; 2501e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i16: LC = RTLIB::SYNC_FETCH_AND_OR_2; break; 2502e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i32: LC = RTLIB::SYNC_FETCH_AND_OR_4; break; 2503e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i64: LC = RTLIB::SYNC_FETCH_AND_OR_8; break; 2504e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach } 2505e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach break; 2506e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case ISD::ATOMIC_LOAD_XOR: 2507e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach switch (VT.SimpleTy) { 2508e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach default: llvm_unreachable("Unexpected value type for atomic!"); 2509e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i8: LC = RTLIB::SYNC_FETCH_AND_XOR_1; break; 2510e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i16: LC = RTLIB::SYNC_FETCH_AND_XOR_2; break; 2511e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i32: LC = RTLIB::SYNC_FETCH_AND_XOR_4; break; 2512e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i64: LC = RTLIB::SYNC_FETCH_AND_XOR_8; break; 2513e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach } 2514e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach break; 2515e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case ISD::ATOMIC_LOAD_NAND: 2516e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach switch (VT.SimpleTy) { 2517e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach default: llvm_unreachable("Unexpected value type for atomic!"); 2518e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i8: LC = RTLIB::SYNC_FETCH_AND_NAND_1; break; 2519e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i16: LC = RTLIB::SYNC_FETCH_AND_NAND_2; break; 2520e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i32: LC = RTLIB::SYNC_FETCH_AND_NAND_4; break; 2521e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach case MVT::i64: LC = RTLIB::SYNC_FETCH_AND_NAND_8; break; 2522e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach } 2523e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach break; 2524e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach } 2525e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach 2526e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach return ExpandChainLibCall(LC, Node, false); 2527e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach} 2528e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach 252965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohmanvoid SelectionDAGLegalize::ExpandNode(SDNode *Node) { 253065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SmallVector<SDValue, 8> Results; 25318c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman DebugLoc dl = Node->getDebugLoc(); 2532bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman SDValue Tmp1, Tmp2, Tmp3, Tmp4; 25338c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman switch (Node->getOpcode()) { 25348c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::CTPOP: 25358c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::CTLZ: 253663974b2144c87c962effdc0508c27643c8ad98b6Chandler Carruth case ISD::CTLZ_ZERO_UNDEF: 25378c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::CTTZ: 253863974b2144c87c962effdc0508c27643c8ad98b6Chandler Carruth case ISD::CTTZ_ZERO_UNDEF: 25398c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = ExpandBitCount(Node->getOpcode(), Node->getOperand(0), dl); 25408c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 25418c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 25428c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::BSWAP: 2543775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandBSWAP(Node->getOperand(0), dl)); 25448c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 25458c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FRAMEADDR: 25468c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::RETURNADDR: 25478c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FRAME_TO_ARGS_OFFSET: 25488c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(DAG.getConstant(0, Node->getValueType(0))); 25498c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 25508c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FLT_ROUNDS_: 25518c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(DAG.getConstant(1, Node->getValueType(0))); 25528c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 25538c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::EH_RETURN: 25548c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::EH_LABEL: 25558c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::PREFETCH: 25568c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::VAEND: 2557c66e150b2cb1f2f8e2f4eb124b9177ffc6ef3a74Jim Grosbach case ISD::EH_SJLJ_LONGJMP: 2558e4ad387a5a88dae20f0f7578e55170bbc8eee2a9Jim Grosbach // If the target didn't expand these, there's nothing to do, so just 2559e4ad387a5a88dae20f0f7578e55170bbc8eee2a9Jim Grosbach // preserve the chain and be done. 2560c66e150b2cb1f2f8e2f4eb124b9177ffc6ef3a74Jim Grosbach Results.push_back(Node->getOperand(0)); 2561c66e150b2cb1f2f8e2f4eb124b9177ffc6ef3a74Jim Grosbach break; 2562c66e150b2cb1f2f8e2f4eb124b9177ffc6ef3a74Jim Grosbach case ISD::EH_SJLJ_SETJMP: 2563e4ad387a5a88dae20f0f7578e55170bbc8eee2a9Jim Grosbach // If the target didn't expand this, just return 'zero' and preserve the 2564e4ad387a5a88dae20f0f7578e55170bbc8eee2a9Jim Grosbach // chain. 2565c66e150b2cb1f2f8e2f4eb124b9177ffc6ef3a74Jim Grosbach Results.push_back(DAG.getConstant(0, MVT::i32)); 25668c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Node->getOperand(0)); 25678c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 256814648468011c92a4210f8118721d58c25043daf8Eli Friedman case ISD::ATOMIC_FENCE: 2569bbfc0d22a9a8e197a5ea428f14d37366a1fadd5fJim Grosbach case ISD::MEMBARRIER: { 2570bbfc0d22a9a8e197a5ea428f14d37366a1fadd5fJim Grosbach // If the target didn't lower this, lower it to '__sync_synchronize()' call 257114648468011c92a4210f8118721d58c25043daf8Eli Friedman // FIXME: handle "fence singlethread" more efficiently. 2572bbfc0d22a9a8e197a5ea428f14d37366a1fadd5fJim Grosbach TargetLowering::ArgListTy Args; 2573bbfc0d22a9a8e197a5ea428f14d37366a1fadd5fJim Grosbach std::pair<SDValue, SDValue> CallResult = 2574bbfc0d22a9a8e197a5ea428f14d37366a1fadd5fJim Grosbach TLI.LowerCallTo(Node->getOperand(0), Type::getVoidTy(*DAG.getContext()), 25753d2125c9dbac695c93f42c0f59fd040e413fd711Evan Cheng false, false, false, false, 0, CallingConv::C, 25763d2125c9dbac695c93f42c0f59fd040e413fd711Evan Cheng /*isTailCall=*/false, 25774bfcd4acbc7d12aa55f8de9af84a38422f0f6d83Evan Cheng /*doesNotReturn=*/false, /*isReturnValueUsed=*/true, 2578bbfc0d22a9a8e197a5ea428f14d37366a1fadd5fJim Grosbach DAG.getExternalSymbol("__sync_synchronize", 2579bbfc0d22a9a8e197a5ea428f14d37366a1fadd5fJim Grosbach TLI.getPointerTy()), 2580bbfc0d22a9a8e197a5ea428f14d37366a1fadd5fJim Grosbach Args, DAG, dl); 2581bbfc0d22a9a8e197a5ea428f14d37366a1fadd5fJim Grosbach Results.push_back(CallResult.second); 2582bbfc0d22a9a8e197a5ea428f14d37366a1fadd5fJim Grosbach break; 2583bbfc0d22a9a8e197a5ea428f14d37366a1fadd5fJim Grosbach } 2584069e2ed794a90cb5108a35627ee148866795f140Eli Friedman case ISD::ATOMIC_LOAD: { 2585069e2ed794a90cb5108a35627ee148866795f140Eli Friedman // There is no libcall for atomic load; fake it with ATOMIC_CMP_SWAP. 2586331120b1a482b782e8dffce63033bb8514ba2a96Eli Friedman SDValue Zero = DAG.getConstant(0, Node->getValueType(0)); 2587069e2ed794a90cb5108a35627ee148866795f140Eli Friedman SDValue Swap = DAG.getAtomic(ISD::ATOMIC_CMP_SWAP, dl, 2588069e2ed794a90cb5108a35627ee148866795f140Eli Friedman cast<AtomicSDNode>(Node)->getMemoryVT(), 2589069e2ed794a90cb5108a35627ee148866795f140Eli Friedman Node->getOperand(0), 2590069e2ed794a90cb5108a35627ee148866795f140Eli Friedman Node->getOperand(1), Zero, Zero, 2591069e2ed794a90cb5108a35627ee148866795f140Eli Friedman cast<AtomicSDNode>(Node)->getMemOperand(), 2592069e2ed794a90cb5108a35627ee148866795f140Eli Friedman cast<AtomicSDNode>(Node)->getOrdering(), 2593069e2ed794a90cb5108a35627ee148866795f140Eli Friedman cast<AtomicSDNode>(Node)->getSynchScope()); 2594069e2ed794a90cb5108a35627ee148866795f140Eli Friedman Results.push_back(Swap.getValue(0)); 2595069e2ed794a90cb5108a35627ee148866795f140Eli Friedman Results.push_back(Swap.getValue(1)); 2596069e2ed794a90cb5108a35627ee148866795f140Eli Friedman break; 2597069e2ed794a90cb5108a35627ee148866795f140Eli Friedman } 2598069e2ed794a90cb5108a35627ee148866795f140Eli Friedman case ISD::ATOMIC_STORE: { 2599069e2ed794a90cb5108a35627ee148866795f140Eli Friedman // There is no libcall for atomic store; fake it with ATOMIC_SWAP. 2600069e2ed794a90cb5108a35627ee148866795f140Eli Friedman SDValue Swap = DAG.getAtomic(ISD::ATOMIC_SWAP, dl, 2601069e2ed794a90cb5108a35627ee148866795f140Eli Friedman cast<AtomicSDNode>(Node)->getMemoryVT(), 2602069e2ed794a90cb5108a35627ee148866795f140Eli Friedman Node->getOperand(0), 2603069e2ed794a90cb5108a35627ee148866795f140Eli Friedman Node->getOperand(1), Node->getOperand(2), 2604069e2ed794a90cb5108a35627ee148866795f140Eli Friedman cast<AtomicSDNode>(Node)->getMemOperand(), 2605069e2ed794a90cb5108a35627ee148866795f140Eli Friedman cast<AtomicSDNode>(Node)->getOrdering(), 2606069e2ed794a90cb5108a35627ee148866795f140Eli Friedman cast<AtomicSDNode>(Node)->getSynchScope()); 2607069e2ed794a90cb5108a35627ee148866795f140Eli Friedman Results.push_back(Swap.getValue(1)); 2608069e2ed794a90cb5108a35627ee148866795f140Eli Friedman break; 2609069e2ed794a90cb5108a35627ee148866795f140Eli Friedman } 2610b56ce8171ec52f44015d95127faaa7dd4ed92763Jim Grosbach // By default, atomic intrinsics are marked Legal and lowered. Targets 2611b56ce8171ec52f44015d95127faaa7dd4ed92763Jim Grosbach // which don't support them directly, however, may want libcalls, in which 2612b56ce8171ec52f44015d95127faaa7dd4ed92763Jim Grosbach // case they mark them Expand, and we get here. 2613b56ce8171ec52f44015d95127faaa7dd4ed92763Jim Grosbach case ISD::ATOMIC_SWAP: 2614b56ce8171ec52f44015d95127faaa7dd4ed92763Jim Grosbach case ISD::ATOMIC_LOAD_ADD: 2615b56ce8171ec52f44015d95127faaa7dd4ed92763Jim Grosbach case ISD::ATOMIC_LOAD_SUB: 2616b56ce8171ec52f44015d95127faaa7dd4ed92763Jim Grosbach case ISD::ATOMIC_LOAD_AND: 2617b56ce8171ec52f44015d95127faaa7dd4ed92763Jim Grosbach case ISD::ATOMIC_LOAD_OR: 2618b56ce8171ec52f44015d95127faaa7dd4ed92763Jim Grosbach case ISD::ATOMIC_LOAD_XOR: 2619b56ce8171ec52f44015d95127faaa7dd4ed92763Jim Grosbach case ISD::ATOMIC_LOAD_NAND: 2620b56ce8171ec52f44015d95127faaa7dd4ed92763Jim Grosbach case ISD::ATOMIC_LOAD_MIN: 2621b56ce8171ec52f44015d95127faaa7dd4ed92763Jim Grosbach case ISD::ATOMIC_LOAD_MAX: 2622b56ce8171ec52f44015d95127faaa7dd4ed92763Jim Grosbach case ISD::ATOMIC_LOAD_UMIN: 2623b56ce8171ec52f44015d95127faaa7dd4ed92763Jim Grosbach case ISD::ATOMIC_LOAD_UMAX: 2624a845706dc1cebfe75913832e07ef114519a879d6Evan Cheng case ISD::ATOMIC_CMP_SWAP: { 2625e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach std::pair<SDValue, SDValue> Tmp = ExpandAtomic(Node); 2626e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Results.push_back(Tmp.first); 2627e03262fcfc09356a0e3ec589041bc2e0248944e9Jim Grosbach Results.push_back(Tmp.second); 262859c38f31acf87901208bbf790508196b1c0ad1fdJim Grosbach break; 2629a845706dc1cebfe75913832e07ef114519a879d6Evan Cheng } 26304bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman case ISD::DYNAMIC_STACKALLOC: 26314bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman ExpandDYNAMIC_STACKALLOC(Node, Results); 26324bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman break; 26338c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::MERGE_VALUES: 26348c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman for (unsigned i = 0; i < Node->getNumValues(); i++) 26358c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Node->getOperand(i)); 26368c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 26378c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::UNDEF: { 2638e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Node->getValueType(0); 26398c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (VT.isInteger()) 26408c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(DAG.getConstant(0, VT)); 264135a389344d21178ee280c2410401b2060b5b879cChris Lattner else { 264235a389344d21178ee280c2410401b2060b5b879cChris Lattner assert(VT.isFloatingPoint() && "Unknown value type!"); 26438c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(DAG.getConstantFP(0, VT)); 264435a389344d21178ee280c2410401b2060b5b879cChris Lattner } 26458c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 26468c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 26478c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::TRAP: { 26488c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // If this operation is not supported, lower it to 'abort()' call 26498c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman TargetLowering::ArgListTy Args; 26508c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman std::pair<SDValue, SDValue> CallResult = 26511d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson TLI.LowerCallTo(Node->getOperand(0), Type::getVoidTy(*DAG.getContext()), 26523d2125c9dbac695c93f42c0f59fd040e413fd711Evan Cheng false, false, false, false, 0, CallingConv::C, 26533d2125c9dbac695c93f42c0f59fd040e413fd711Evan Cheng /*isTailCall=*/false, 26544bfcd4acbc7d12aa55f8de9af84a38422f0f6d83Evan Cheng /*doesNotReturn=*/false, /*isReturnValueUsed=*/true, 26558c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman DAG.getExternalSymbol("abort", TLI.getPointerTy()), 265646ada19645c981a0b7932487d163f7582074a4d9Bill Wendling Args, DAG, dl); 26578c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(CallResult.second); 26588c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 26598c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 26608c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FP_ROUND: 2661bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck case ISD::BITCAST: 26628c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = EmitStackConvert(Node->getOperand(0), Node->getValueType(0), 26638c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getValueType(0), dl); 26648c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 26658c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 26668c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FP_EXTEND: 26678c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = EmitStackConvert(Node->getOperand(0), 26688c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOperand(0).getValueType(), 26698c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getValueType(0), dl); 26708c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 26718c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 26728c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SIGN_EXTEND_INREG: { 26738c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // NOTE: we could fall back on load/store here too for targets without 26748c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // SAR. However, it is doubtful that any exist. 2675e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT ExtraVT = cast<VTSDNode>(Node->getOperand(1))->getVT(); 267687862e77bbf90cf1b68c9eea1f3641ad81435e38Dan Gohman EVT VT = Node->getValueType(0); 267795771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson EVT ShiftAmountTy = TLI.getShiftAmountTy(VT); 2678d1996360399ad6dbe75ee185b661b16c83146373Dan Gohman if (VT.isVector()) 267987862e77bbf90cf1b68c9eea1f3641ad81435e38Dan Gohman ShiftAmountTy = VT; 2680d1996360399ad6dbe75ee185b661b16c83146373Dan Gohman unsigned BitsDiff = VT.getScalarType().getSizeInBits() - 2681d1996360399ad6dbe75ee185b661b16c83146373Dan Gohman ExtraVT.getScalarType().getSizeInBits(); 268287862e77bbf90cf1b68c9eea1f3641ad81435e38Dan Gohman SDValue ShiftCst = DAG.getConstant(BitsDiff, ShiftAmountTy); 26838c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::SHL, dl, Node->getValueType(0), 26848c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOperand(0), ShiftCst); 2685775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Tmp1 = DAG.getNode(ISD::SRA, dl, Node->getValueType(0), Tmp1, ShiftCst); 2686775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(Tmp1); 26878c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 26888c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 26898c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FP_ROUND_INREG: { 26908c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // The only way we can lower this is to turn it into a TRUNCSTORE, 26917a2bdde0a0eebcd2125055e0eacaca040f0b766cChris Lattner // EXTLOAD pair, targeting a temporary location (a stack slot). 26928c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman 26938c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // NOTE: there is a choice here between constantly creating new stack 26948c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // slots and always reusing the same one. We currently always create 26958c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // new ones, as reuse may inhibit scheduling. 2696e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT ExtraVT = cast<VTSDNode>(Node->getOperand(1))->getVT(); 26978c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = EmitStackConvert(Node->getOperand(0), ExtraVT, 26988c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getValueType(0), dl); 26998c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 27008c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 27018c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 27028c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SINT_TO_FP: 27038c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::UINT_TO_FP: 27048c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = ExpandLegalINT_TO_FP(Node->getOpcode() == ISD::SINT_TO_FP, 27058c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOperand(0), Node->getValueType(0), dl); 27068c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 27078c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 27088c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FP_TO_UINT: { 27098c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman SDValue True, False; 2710e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Node->getOperand(0).getValueType(); 2711e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT NVT = Node->getValueType(0); 27123069cbf7b3ef9a31bbb8e434686b7259052c364aBenjamin Kramer APFloat apf(APInt::getNullValue(VT.getSizeInBits())); 27138c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman APInt x = APInt::getSignBit(NVT.getSizeInBits()); 27148c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman (void)apf.convertFromAPInt(x, false, APFloat::rmNearestTiesToEven); 27158c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getConstantFP(apf, VT); 27168c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(VT), 27178c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOperand(0), 27188c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1, ISD::SETLT); 27198c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman True = DAG.getNode(ISD::FP_TO_SINT, dl, NVT, Node->getOperand(0)); 2720775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling False = DAG.getNode(ISD::FP_TO_SINT, dl, NVT, 2721775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling DAG.getNode(ISD::FSUB, dl, VT, 2722775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Node->getOperand(0), Tmp1)); 27238c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman False = DAG.getNode(ISD::XOR, dl, NVT, False, 27248c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman DAG.getConstant(x, NVT)); 27258c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::SELECT, dl, NVT, Tmp2, True, False); 27268c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 27278c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 27288c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 2729509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman case ISD::VAARG: { 2730509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman const Value *V = cast<SrcValueSDNode>(Node->getOperand(2))->getValue(); 2731e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Node->getValueType(0); 2732509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Tmp1 = Node->getOperand(0); 2733509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Tmp2 = Node->getOperand(1); 273472d13ff755fe8484c89468252f945ba23fe98f71Rafael Espindola unsigned Align = Node->getConstantOperandVal(3); 273572d13ff755fe8484c89468252f945ba23fe98f71Rafael Espindola 2736ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner SDValue VAListLoad = DAG.getLoad(TLI.getPointerTy(), dl, Tmp1, Tmp2, 2737d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper MachinePointerInfo(V), 2738d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper false, false, false, 0); 273972d13ff755fe8484c89468252f945ba23fe98f71Rafael Espindola SDValue VAList = VAListLoad; 274072d13ff755fe8484c89468252f945ba23fe98f71Rafael Espindola 2741cbeeae23c31d32b833c9c7c3e8984e4cbcf22f45Rafael Espindola if (Align > TLI.getMinStackArgumentAlignment()) { 2742cbeeae23c31d32b833c9c7c3e8984e4cbcf22f45Rafael Espindola assert(((Align & (Align-1)) == 0) && "Expected Align to be a power of 2"); 2743cbeeae23c31d32b833c9c7c3e8984e4cbcf22f45Rafael Espindola 274472d13ff755fe8484c89468252f945ba23fe98f71Rafael Espindola VAList = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(), VAList, 274572d13ff755fe8484c89468252f945ba23fe98f71Rafael Espindola DAG.getConstant(Align - 1, 274672d13ff755fe8484c89468252f945ba23fe98f71Rafael Espindola TLI.getPointerTy())); 274772d13ff755fe8484c89468252f945ba23fe98f71Rafael Espindola 274872d13ff755fe8484c89468252f945ba23fe98f71Rafael Espindola VAList = DAG.getNode(ISD::AND, dl, TLI.getPointerTy(), VAList, 274907e3a38c78d2788e05d716e7fa552b9449c87c33Chris Lattner DAG.getConstant(-(int64_t)Align, 275072d13ff755fe8484c89468252f945ba23fe98f71Rafael Espindola TLI.getPointerTy())); 275172d13ff755fe8484c89468252f945ba23fe98f71Rafael Espindola } 275272d13ff755fe8484c89468252f945ba23fe98f71Rafael Espindola 2753509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman // Increment the pointer, VAList, to the next vaarg 2754509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Tmp3 = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(), VAList, 2755509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman DAG.getConstant(TLI.getTargetData()-> 2756adf979900c84d00e1fe0872a68d2819c654b6f29Evan Cheng getTypeAllocSize(VT.getTypeForEVT(*DAG.getContext())), 2757509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman TLI.getPointerTy())); 2758509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman // Store the incremented VAList to the legalized pointer 27596229d0acb8f395552131a7015a5d1e7b2bae2111Chris Lattner Tmp3 = DAG.getStore(VAListLoad.getValue(1), dl, Tmp3, Tmp2, 27606229d0acb8f395552131a7015a5d1e7b2bae2111Chris Lattner MachinePointerInfo(V), false, false, 0); 2761509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman // Load the actual argument out of the pointer VAList 2762ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner Results.push_back(DAG.getLoad(VT, dl, Tmp3, VAList, MachinePointerInfo(), 2763d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper false, false, false, 0)); 2764509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Results.push_back(Results[0].getValue(1)); 2765509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman break; 2766509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman } 27678c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::VACOPY: { 27688c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // This defaults to loading a pointer from the input and storing it to the 27698c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // output, returning the chain. 27708c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman const Value *VD = cast<SrcValueSDNode>(Node->getOperand(3))->getValue(); 27718c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman const Value *VS = cast<SrcValueSDNode>(Node->getOperand(4))->getValue(); 27728c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getLoad(TLI.getPointerTy(), dl, Node->getOperand(0), 2773ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner Node->getOperand(2), MachinePointerInfo(VS), 2774d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper false, false, false, 0); 2775ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner Tmp1 = DAG.getStore(Tmp1.getValue(1), dl, Tmp1, Node->getOperand(1), 2776ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner MachinePointerInfo(VD), false, false, 0); 2777775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(Tmp1); 27788c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 27798c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 27808c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::EXTRACT_VECTOR_ELT: 27818c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (Node->getOperand(0).getValueType().getVectorNumElements() == 1) 27828c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // This must be an access of the only element. Return it. 2783bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck Tmp1 = DAG.getNode(ISD::BITCAST, dl, Node->getValueType(0), 27848c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOperand(0)); 27858c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman else 27868c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = ExpandExtractFromVectorThroughStack(SDValue(Node, 0)); 27878c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 27888c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 27898c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::EXTRACT_SUBVECTOR: 2790775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandExtractFromVectorThroughStack(SDValue(Node, 0))); 27918c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 2792cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene case ISD::INSERT_SUBVECTOR: 2793cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene Results.push_back(ExpandInsertToVectorThroughStack(SDValue(Node, 0))); 2794cfe33c46aa50f04adb0431243e7d25f79b719ac6David Greene break; 2795509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman case ISD::CONCAT_VECTORS: { 2796775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandVectorBuildThroughStack(Node)); 2797509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman break; 2798509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman } 27998c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SCALAR_TO_VECTOR: 2800775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandSCALAR_TO_VECTOR(Node)); 28018c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 28023f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::INSERT_VECTOR_ELT: 2803775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandINSERT_VECTOR_ELT(Node->getOperand(0), 2804775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Node->getOperand(1), 2805775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Node->getOperand(2), dl)); 28063f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman break; 2807509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman case ISD::VECTOR_SHUFFLE: { 2808ed4c8c633c52a40ad1a3e8687f290be4aeb1f0e8Benjamin Kramer SmallVector<int, 32> NewMask; 2809ed4c8c633c52a40ad1a3e8687f290be4aeb1f0e8Benjamin Kramer ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(Node)->getMask(); 2810509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman 2811e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Node->getValueType(0); 2812e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT EltVT = VT.getVectorElementType(); 2813ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky SDValue Op0 = Node->getOperand(0); 2814ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky SDValue Op1 = Node->getOperand(1); 2815ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky if (!TLI.isTypeLegal(EltVT)) { 2816ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky 2817ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky EVT NewEltVT = TLI.getTypeToTransformTo(*DAG.getContext(), EltVT); 2818ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky 2819ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky // BUILD_VECTOR operands are allowed to be wider than the element type. 2820ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky // But if NewEltVT is smaller that EltVT the BUILD_VECTOR does not accept it 2821ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky if (NewEltVT.bitsLT(EltVT)) { 2822ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky 2823ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky // Convert shuffle node. 2824ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky // If original node was v4i64 and the new EltVT is i32, 2825ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky // cast operands to v8i32 and re-build the mask. 2826ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky 2827ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky // Calculate new VT, the size of the new VT should be equal to original. 2828ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky EVT NewVT = EVT::getVectorVT(*DAG.getContext(), NewEltVT, 2829ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky VT.getSizeInBits()/NewEltVT.getSizeInBits()); 2830ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky assert(NewVT.bitsEq(VT)); 2831ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky 2832ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky // cast operands to new VT 2833ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky Op0 = DAG.getNode(ISD::BITCAST, dl, NewVT, Op0); 2834ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky Op1 = DAG.getNode(ISD::BITCAST, dl, NewVT, Op1); 2835ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky 2836ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky // Convert the shuffle mask 2837ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky unsigned int factor = NewVT.getVectorNumElements()/VT.getVectorNumElements(); 2838ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky 2839ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky // EltVT gets smaller 2840ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky assert(factor > 0); 2841ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky 2842ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky for (unsigned i = 0; i < VT.getVectorNumElements(); ++i) { 2843ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky if (Mask[i] < 0) { 2844ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky for (unsigned fi = 0; fi < factor; ++fi) 2845ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky NewMask.push_back(Mask[i]); 2846ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky } 2847ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky else { 2848ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky for (unsigned fi = 0; fi < factor; ++fi) 2849ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky NewMask.push_back(Mask[i]*factor+fi); 2850ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky } 2851ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky } 2852ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky Mask = NewMask; 2853ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky VT = NewVT; 2854ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky } 2855ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky EltVT = NewEltVT; 2856ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky } 2857509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman unsigned NumElems = VT.getVectorNumElements(); 2858ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky SmallVector<SDValue, 16> Ops; 2859509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman for (unsigned i = 0; i != NumElems; ++i) { 2860509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman if (Mask[i] < 0) { 2861509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Ops.push_back(DAG.getUNDEF(EltVT)); 2862509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman continue; 2863509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman } 2864509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman unsigned Idx = Mask[i]; 2865509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman if (Idx < NumElems) 2866775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, 2867ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky Op0, 2868775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling DAG.getIntPtrConstant(Idx))); 2869509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman else 2870775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, 2871ce58a03587ca46d9c9fe48e2bf433bcd57bb2b3aElena Demikhovsky Op1, 2872775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling DAG.getIntPtrConstant(Idx - NumElems))); 2873509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman } 28746c0366cb2588ae49ef6e2f892db2099d41d85391Nadav Rotem 2875509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Tmp1 = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &Ops[0], Ops.size()); 28766c0366cb2588ae49ef6e2f892db2099d41d85391Nadav Rotem // We may have changed the BUILD_VECTOR type. Cast it back to the Node type. 28776c0366cb2588ae49ef6e2f892db2099d41d85391Nadav Rotem Tmp1 = DAG.getNode(ISD::BITCAST, dl, Node->getValueType(0), Tmp1); 2878509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Results.push_back(Tmp1); 2879509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman break; 2880509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman } 28818c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::EXTRACT_ELEMENT: { 2882e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT OpTy = Node->getOperand(0).getValueType(); 28838c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (cast<ConstantSDNode>(Node->getOperand(1))->getZExtValue()) { 28848c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // 1 -> Hi 28858c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::SRL, dl, OpTy, Node->getOperand(0), 28868c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman DAG.getConstant(OpTy.getSizeInBits()/2, 288795771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson TLI.getShiftAmountTy(Node->getOperand(0).getValueType()))); 28888c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::TRUNCATE, dl, Node->getValueType(0), Tmp1); 28898c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } else { 28908c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // 0 -> Lo 28918c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::TRUNCATE, dl, Node->getValueType(0), 28928c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOperand(0)); 28938c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 28948c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 28958c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 28968c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 28973f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::STACKSAVE: 28983f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // Expand to CopyFromReg if the target set 28993f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // StackPointerRegisterToSaveRestore. 29003f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman if (unsigned SP = TLI.getStackPointerRegisterToSaveRestore()) { 2901775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(DAG.getCopyFromReg(Node->getOperand(0), dl, SP, 2902775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Node->getValueType(0))); 29033f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman Results.push_back(Results[0].getValue(1)); 29043f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman } else { 2905775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(DAG.getUNDEF(Node->getValueType(0))); 29063f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman Results.push_back(Node->getOperand(0)); 29073f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman } 29083f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman break; 29093f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::STACKRESTORE: 2910775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling // Expand to CopyToReg if the target set 2911775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling // StackPointerRegisterToSaveRestore. 2912775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling if (unsigned SP = TLI.getStackPointerRegisterToSaveRestore()) { 2913775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(DAG.getCopyToReg(Node->getOperand(0), dl, SP, 2914775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Node->getOperand(1))); 2915775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling } else { 2916775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(Node->getOperand(0)); 2917775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling } 29183f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman break; 29194bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman case ISD::FCOPYSIGN: 2920775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandFCOPYSIGN(Node)); 29214bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman break; 2922f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FNEG: 2923f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman // Expand Y = FNEG(X) -> Y = SUB -0.0, X 2924f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Tmp1 = DAG.getConstantFP(-0.0, Node->getValueType(0)); 2925f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Tmp1 = DAG.getNode(ISD::FSUB, dl, Node->getValueType(0), Tmp1, 2926f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Node->getOperand(0)); 2927f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(Tmp1); 2928f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 2929f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FABS: { 2930f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman // Expand Y = FABS(X) -> Y = (X >u 0.0) ? X : fneg(X). 2931e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Node->getValueType(0); 2932f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Tmp1 = Node->getOperand(0); 2933f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Tmp2 = DAG.getConstantFP(0.0, VT); 2934775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Tmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(Tmp1.getValueType()), 2935f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Tmp1, Tmp2, ISD::SETUGT); 2936775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Tmp3 = DAG.getNode(ISD::FNEG, dl, VT, Tmp1); 2937775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Tmp1 = DAG.getNode(ISD::SELECT, dl, VT, Tmp2, Tmp1, Tmp3); 2938f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(Tmp1); 2939f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 2940f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman } 2941f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FSQRT: 2942775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandFPLibCall(Node, RTLIB::SQRT_F32, RTLIB::SQRT_F64, 2943775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::SQRT_F80, RTLIB::SQRT_PPCF128)); 2944f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 2945f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FSIN: 2946775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandFPLibCall(Node, RTLIB::SIN_F32, RTLIB::SIN_F64, 2947775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::SIN_F80, RTLIB::SIN_PPCF128)); 2948f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 2949f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FCOS: 2950775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandFPLibCall(Node, RTLIB::COS_F32, RTLIB::COS_F64, 2951775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::COS_F80, RTLIB::COS_PPCF128)); 2952f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 2953f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FLOG: 2954775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandFPLibCall(Node, RTLIB::LOG_F32, RTLIB::LOG_F64, 2955775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::LOG_F80, RTLIB::LOG_PPCF128)); 2956f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 2957f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FLOG2: 2958775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandFPLibCall(Node, RTLIB::LOG2_F32, RTLIB::LOG2_F64, 2959775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::LOG2_F80, RTLIB::LOG2_PPCF128)); 2960f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 2961f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FLOG10: 2962775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandFPLibCall(Node, RTLIB::LOG10_F32, RTLIB::LOG10_F64, 2963775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::LOG10_F80, RTLIB::LOG10_PPCF128)); 2964f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 2965f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FEXP: 2966775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandFPLibCall(Node, RTLIB::EXP_F32, RTLIB::EXP_F64, 2967775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::EXP_F80, RTLIB::EXP_PPCF128)); 2968f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 2969f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FEXP2: 2970775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandFPLibCall(Node, RTLIB::EXP2_F32, RTLIB::EXP2_F64, 2971775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::EXP2_F80, RTLIB::EXP2_PPCF128)); 2972f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 2973f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FTRUNC: 2974775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandFPLibCall(Node, RTLIB::TRUNC_F32, RTLIB::TRUNC_F64, 2975775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::TRUNC_F80, RTLIB::TRUNC_PPCF128)); 2976f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 2977f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FFLOOR: 2978775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandFPLibCall(Node, RTLIB::FLOOR_F32, RTLIB::FLOOR_F64, 2979775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::FLOOR_F80, RTLIB::FLOOR_PPCF128)); 2980f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 2981f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FCEIL: 2982775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandFPLibCall(Node, RTLIB::CEIL_F32, RTLIB::CEIL_F64, 2983775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::CEIL_F80, RTLIB::CEIL_PPCF128)); 2984f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 2985f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FRINT: 2986775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandFPLibCall(Node, RTLIB::RINT_F32, RTLIB::RINT_F64, 2987775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::RINT_F80, RTLIB::RINT_PPCF128)); 2988f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 2989f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FNEARBYINT: 2990775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandFPLibCall(Node, RTLIB::NEARBYINT_F32, 2991775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::NEARBYINT_F64, 2992775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::NEARBYINT_F80, 2993775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::NEARBYINT_PPCF128)); 2994f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 2995f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FPOWI: 2996775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandFPLibCall(Node, RTLIB::POWI_F32, RTLIB::POWI_F64, 2997775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::POWI_F80, RTLIB::POWI_PPCF128)); 2998f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 2999f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FPOW: 3000775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandFPLibCall(Node, RTLIB::POW_F32, RTLIB::POW_F64, 3001775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::POW_F80, RTLIB::POW_PPCF128)); 3002f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3003f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FDIV: 3004775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandFPLibCall(Node, RTLIB::DIV_F32, RTLIB::DIV_F64, 3005775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::DIV_F80, RTLIB::DIV_PPCF128)); 3006f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3007f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FREM: 3008775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(ExpandFPLibCall(Node, RTLIB::REM_F32, RTLIB::REM_F64, 3009775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling RTLIB::REM_F80, RTLIB::REM_PPCF128)); 3010f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 301133390848a7eca75301d04a59b89b516d83e19ee0Cameron Zwarich case ISD::FMA: 301233390848a7eca75301d04a59b89b516d83e19ee0Cameron Zwarich Results.push_back(ExpandFPLibCall(Node, RTLIB::FMA_F32, RTLIB::FMA_F64, 301333390848a7eca75301d04a59b89b516d83e19ee0Cameron Zwarich RTLIB::FMA_F80, RTLIB::FMA_PPCF128)); 301433390848a7eca75301d04a59b89b516d83e19ee0Cameron Zwarich break; 3015927411b7ce0b7852fe4f392d8cd4faaa3881f852Anton Korobeynikov case ISD::FP16_TO_FP32: 3016927411b7ce0b7852fe4f392d8cd4faaa3881f852Anton Korobeynikov Results.push_back(ExpandLibCall(RTLIB::FPEXT_F16_F32, Node, false)); 3017927411b7ce0b7852fe4f392d8cd4faaa3881f852Anton Korobeynikov break; 3018927411b7ce0b7852fe4f392d8cd4faaa3881f852Anton Korobeynikov case ISD::FP32_TO_FP16: 3019927411b7ce0b7852fe4f392d8cd4faaa3881f852Anton Korobeynikov Results.push_back(ExpandLibCall(RTLIB::FPROUND_F32_F16, Node, false)); 3020927411b7ce0b7852fe4f392d8cd4faaa3881f852Anton Korobeynikov break; 3021f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman case ISD::ConstantFP: { 3022f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman ConstantFPSDNode *CFP = cast<ConstantFPSDNode>(Node); 3023775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling // Check to see if this FP immediate is already legal. 3024775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling // If this is a legal constant, turn it into a TargetConstantFP node. 302565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman if (!TLI.isFPImmLegal(CFP->getValueAPF(), Node->getValueType(0))) 302665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Results.push_back(ExpandConstantFP(CFP, true)); 3027f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman break; 3028f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman } 302926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman case ISD::EHSELECTION: { 303026ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman unsigned Reg = TLI.getExceptionSelectorRegister(); 303126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman assert(Reg && "Can't expand to unknown register!"); 3032775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(DAG.getCopyFromReg(Node->getOperand(1), dl, Reg, 3033775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Node->getValueType(0))); 303426ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Results.push_back(Results[0].getValue(1)); 303526ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman break; 303626ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } 303726ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman case ISD::EXCEPTIONADDR: { 30380796134bde31f6d58d077f556fd08ca3734a9e6eLang Hames unsigned Reg = TLI.getExceptionPointerRegister(); 303926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman assert(Reg && "Can't expand to unknown register!"); 3040775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(DAG.getCopyFromReg(Node->getOperand(0), dl, Reg, 3041775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Node->getValueType(0))); 304226ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Results.push_back(Results[0].getValue(1)); 304326ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman break; 304426ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } 3045afd3d56b9dc791d37120922318293a021bd35598Owen Anderson case ISD::FSUB: { 3046afd3d56b9dc791d37120922318293a021bd35598Owen Anderson EVT VT = Node->getValueType(0); 3047afd3d56b9dc791d37120922318293a021bd35598Owen Anderson assert(TLI.isOperationLegalOrCustom(ISD::FADD, VT) && 3048afd3d56b9dc791d37120922318293a021bd35598Owen Anderson TLI.isOperationLegalOrCustom(ISD::FNEG, VT) && 3049afd3d56b9dc791d37120922318293a021bd35598Owen Anderson "Don't know how to expand this FP subtraction!"); 3050afd3d56b9dc791d37120922318293a021bd35598Owen Anderson Tmp1 = DAG.getNode(ISD::FNEG, dl, VT, Node->getOperand(1)); 3051afd3d56b9dc791d37120922318293a021bd35598Owen Anderson Tmp1 = DAG.getNode(ISD::FADD, dl, VT, Node->getOperand(0), Tmp1); 3052afd3d56b9dc791d37120922318293a021bd35598Owen Anderson Results.push_back(Tmp1); 3053afd3d56b9dc791d37120922318293a021bd35598Owen Anderson break; 3054afd3d56b9dc791d37120922318293a021bd35598Owen Anderson } 305526ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman case ISD::SUB: { 3056e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Node->getValueType(0); 305726ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman assert(TLI.isOperationLegalOrCustom(ISD::ADD, VT) && 305826ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman TLI.isOperationLegalOrCustom(ISD::XOR, VT) && 305926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman "Don't know how to expand this subtraction!"); 306026ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Tmp1 = DAG.getNode(ISD::XOR, dl, VT, Node->getOperand(1), 306126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman DAG.getConstant(APInt::getAllOnesValue(VT.getSizeInBits()), VT)); 3062775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Tmp1 = DAG.getNode(ISD::ADD, dl, VT, Tmp2, DAG.getConstant(1, VT)); 3063775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(DAG.getNode(ISD::ADD, dl, VT, Node->getOperand(0), Tmp1)); 306426ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman break; 306526ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } 3066f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman case ISD::UREM: 3067f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman case ISD::SREM: { 3068e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Node->getValueType(0); 306926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman SDVTList VTs = DAG.getVTList(VT, VT); 3070f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman bool isSigned = Node->getOpcode() == ISD::SREM; 3071f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman unsigned DivOpc = isSigned ? ISD::SDIV : ISD::UDIV; 3072f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman unsigned DivRemOpc = isSigned ? ISD::SDIVREM : ISD::UDIVREM; 3073f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman Tmp2 = Node->getOperand(0); 3074f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman Tmp3 = Node->getOperand(1); 307565279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng if (TLI.isOperationLegalOrCustom(DivRemOpc, VT) || 307665279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng (isDivRemLibcallAvailable(Node, isSigned, TLI) && 307765279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng UseDivRem(Node, isSigned, false))) { 30783be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman Tmp1 = DAG.getNode(DivRemOpc, dl, VTs, Tmp2, Tmp3).getValue(1); 30793be2e514c9e7b20135be5b9df3e9aa1cb08cb374Eli Friedman } else if (TLI.isOperationLegalOrCustom(DivOpc, VT)) { 3080f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman // X % Y -> X-X/Y*Y 3081f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman Tmp1 = DAG.getNode(DivOpc, dl, VT, Tmp2, Tmp3); 3082f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman Tmp1 = DAG.getNode(ISD::MUL, dl, VT, Tmp1, Tmp3); 3083f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman Tmp1 = DAG.getNode(ISD::SUB, dl, VT, Tmp2, Tmp1); 308465279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng } else if (isSigned) 308565279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng Tmp1 = ExpandIntLibCall(Node, true, 308665279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng RTLIB::SREM_I8, 308765279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng RTLIB::SREM_I16, RTLIB::SREM_I32, 308865279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng RTLIB::SREM_I64, RTLIB::SREM_I128); 308965279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng else 309065279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng Tmp1 = ExpandIntLibCall(Node, false, 309165279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng RTLIB::UREM_I8, 309265279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng RTLIB::UREM_I16, RTLIB::UREM_I32, 309365279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng RTLIB::UREM_I64, RTLIB::UREM_I128); 309426ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Results.push_back(Tmp1); 309526ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman break; 309626ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } 3097f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman case ISD::UDIV: 3098f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman case ISD::SDIV: { 3099f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman bool isSigned = Node->getOpcode() == ISD::SDIV; 3100f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman unsigned DivRemOpc = isSigned ? ISD::SDIVREM : ISD::UDIVREM; 3101e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Node->getValueType(0); 310226ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman SDVTList VTs = DAG.getVTList(VT, VT); 310365279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng if (TLI.isOperationLegalOrCustom(DivRemOpc, VT) || 310465279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng (isDivRemLibcallAvailable(Node, isSigned, TLI) && 310565279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng UseDivRem(Node, isSigned, true))) 3106f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman Tmp1 = DAG.getNode(DivRemOpc, dl, VTs, Node->getOperand(0), 3107f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman Node->getOperand(1)); 310865279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng else if (isSigned) 310965279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng Tmp1 = ExpandIntLibCall(Node, true, 311065279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng RTLIB::SDIV_I8, 311165279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng RTLIB::SDIV_I16, RTLIB::SDIV_I32, 311265279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng RTLIB::SDIV_I64, RTLIB::SDIV_I128); 311365279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng else 311465279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng Tmp1 = ExpandIntLibCall(Node, false, 311565279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng RTLIB::UDIV_I8, 311665279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng RTLIB::UDIV_I16, RTLIB::UDIV_I32, 311765279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng RTLIB::UDIV_I64, RTLIB::UDIV_I128); 311826ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Results.push_back(Tmp1); 311926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman break; 312026ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } 312126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman case ISD::MULHU: 312226ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman case ISD::MULHS: { 312326ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman unsigned ExpandOpcode = Node->getOpcode() == ISD::MULHU ? ISD::UMUL_LOHI : 312426ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman ISD::SMUL_LOHI; 3125e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Node->getValueType(0); 312626ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman SDVTList VTs = DAG.getVTList(VT, VT); 312726ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman assert(TLI.isOperationLegalOrCustom(ExpandOpcode, VT) && 312826ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman "If this wasn't legal, it shouldn't have been created!"); 312926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Tmp1 = DAG.getNode(ExpandOpcode, dl, VTs, Node->getOperand(0), 313026ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Node->getOperand(1)); 313126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Results.push_back(Tmp1.getValue(1)); 313226ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman break; 313326ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } 313465279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng case ISD::SDIVREM: 313565279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng case ISD::UDIVREM: 313665279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng // Expand into divrem libcall 313765279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng ExpandDivRemLibCall(Node, Results); 313865279cb9bd985721ac6ad090fed02298396ba06dEvan Cheng break; 313926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman case ISD::MUL: { 3140e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Node->getValueType(0); 314126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman SDVTList VTs = DAG.getVTList(VT, VT); 314226ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman // See if multiply or divide can be lowered using two-result operations. 314326ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman // We just need the low half of the multiply; try both the signed 314426ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman // and unsigned forms. If the target supports both SMUL_LOHI and 314526ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman // UMUL_LOHI, form a preference by checking which forms of plain 314626ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman // MULH it supports. 314726ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman bool HasSMUL_LOHI = TLI.isOperationLegalOrCustom(ISD::SMUL_LOHI, VT); 314826ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman bool HasUMUL_LOHI = TLI.isOperationLegalOrCustom(ISD::UMUL_LOHI, VT); 314926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman bool HasMULHS = TLI.isOperationLegalOrCustom(ISD::MULHS, VT); 315026ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman bool HasMULHU = TLI.isOperationLegalOrCustom(ISD::MULHU, VT); 315126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman unsigned OpToUse = 0; 315226ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman if (HasSMUL_LOHI && !HasMULHS) { 315326ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman OpToUse = ISD::SMUL_LOHI; 315426ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } else if (HasUMUL_LOHI && !HasMULHU) { 315526ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman OpToUse = ISD::UMUL_LOHI; 315626ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } else if (HasSMUL_LOHI) { 315726ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman OpToUse = ISD::SMUL_LOHI; 315826ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } else if (HasUMUL_LOHI) { 315926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman OpToUse = ISD::UMUL_LOHI; 316026ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } 316126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman if (OpToUse) { 3162775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(DAG.getNode(OpToUse, dl, VTs, Node->getOperand(0), 3163775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Node->getOperand(1))); 316426ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman break; 316526ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } 31668983da729aa1ca99a11a3b98ae6280dfcdbadb39Anton Korobeynikov Tmp1 = ExpandIntLibCall(Node, false, 31678983da729aa1ca99a11a3b98ae6280dfcdbadb39Anton Korobeynikov RTLIB::MUL_I8, 31688983da729aa1ca99a11a3b98ae6280dfcdbadb39Anton Korobeynikov RTLIB::MUL_I16, RTLIB::MUL_I32, 316926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman RTLIB::MUL_I64, RTLIB::MUL_I128); 317026ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Results.push_back(Tmp1); 317126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman break; 317226ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } 31734bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman case ISD::SADDO: 31744bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman case ISD::SSUBO: { 31754bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue LHS = Node->getOperand(0); 31764bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue RHS = Node->getOperand(1); 31774bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue Sum = DAG.getNode(Node->getOpcode() == ISD::SADDO ? 31784bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman ISD::ADD : ISD::SUB, dl, LHS.getValueType(), 31794bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman LHS, RHS); 31804bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman Results.push_back(Sum); 3181122d06de7482dcb39e7dbcbfe302e39cc55627e5Bill Wendling EVT OType = Node->getValueType(1); 3182775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling 31834bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue Zero = DAG.getConstant(0, LHS.getValueType()); 31844bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman 31854bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman // LHSSign -> LHS >= 0 31864bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman // RHSSign -> RHS >= 0 31874bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman // SumSign -> Sum >= 0 31884bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman // 31894bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman // Add: 31904bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman // Overflow -> (LHSSign == RHSSign) && (LHSSign != SumSign) 31914bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman // Sub: 31924bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman // Overflow -> (LHSSign != RHSSign) && (LHSSign != SumSign) 31934bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman // 31944bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue LHSSign = DAG.getSetCC(dl, OType, LHS, Zero, ISD::SETGE); 31954bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue RHSSign = DAG.getSetCC(dl, OType, RHS, Zero, ISD::SETGE); 31964bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue SignsMatch = DAG.getSetCC(dl, OType, LHSSign, RHSSign, 31974bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman Node->getOpcode() == ISD::SADDO ? 31984bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman ISD::SETEQ : ISD::SETNE); 31994bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman 32004bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue SumSign = DAG.getSetCC(dl, OType, Sum, Zero, ISD::SETGE); 32014bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue SumSignNE = DAG.getSetCC(dl, OType, LHSSign, SumSign, ISD::SETNE); 32024bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman 32034bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue Cmp = DAG.getNode(ISD::AND, dl, OType, SignsMatch, SumSignNE); 32044bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman Results.push_back(Cmp); 32054bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman break; 32064bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman } 32074bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman case ISD::UADDO: 32084bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman case ISD::USUBO: { 32094bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue LHS = Node->getOperand(0); 32104bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue RHS = Node->getOperand(1); 32114bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue Sum = DAG.getNode(Node->getOpcode() == ISD::UADDO ? 32124bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman ISD::ADD : ISD::SUB, dl, LHS.getValueType(), 32134bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman LHS, RHS); 32144bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman Results.push_back(Sum); 3215775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(DAG.getSetCC(dl, Node->getValueType(1), Sum, LHS, 3216775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Node->getOpcode () == ISD::UADDO ? 3217775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling ISD::SETULT : ISD::SETUGT)); 32184bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman break; 32194bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman } 3220db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman case ISD::UMULO: 3221db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman case ISD::SMULO: { 3222e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Node->getValueType(0); 3223abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher EVT WideVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits() * 2); 3224db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman SDValue LHS = Node->getOperand(0); 3225db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman SDValue RHS = Node->getOperand(1); 3226db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman SDValue BottomHalf; 3227db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman SDValue TopHalf; 3228ec9d8b00470b2ddabef4e1b58b4f60d69995d8ceNuno Lopes static const unsigned Ops[2][3] = 3229db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman { { ISD::MULHU, ISD::UMUL_LOHI, ISD::ZERO_EXTEND }, 3230db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman { ISD::MULHS, ISD::SMUL_LOHI, ISD::SIGN_EXTEND }}; 3231db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman bool isSigned = Node->getOpcode() == ISD::SMULO; 3232db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman if (TLI.isOperationLegalOrCustom(Ops[isSigned][0], VT)) { 3233db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman BottomHalf = DAG.getNode(ISD::MUL, dl, VT, LHS, RHS); 3234db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman TopHalf = DAG.getNode(Ops[isSigned][0], dl, VT, LHS, RHS); 3235db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman } else if (TLI.isOperationLegalOrCustom(Ops[isSigned][1], VT)) { 3236db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman BottomHalf = DAG.getNode(Ops[isSigned][1], dl, DAG.getVTList(VT, VT), LHS, 3237db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman RHS); 3238db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman TopHalf = BottomHalf.getValue(1); 323938a18261b97a0b7e0ed75b1c8edd81ec9bd01085Eric Christopher } else if (TLI.isTypeLegal(EVT::getIntegerVT(*DAG.getContext(), 324038a18261b97a0b7e0ed75b1c8edd81ec9bd01085Eric Christopher VT.getSizeInBits() * 2))) { 3241db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman LHS = DAG.getNode(Ops[isSigned][2], dl, WideVT, LHS); 3242db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman RHS = DAG.getNode(Ops[isSigned][2], dl, WideVT, RHS); 3243db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman Tmp1 = DAG.getNode(ISD::MUL, dl, WideVT, LHS, RHS); 3244db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman BottomHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT, Tmp1, 3245db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman DAG.getIntPtrConstant(0)); 3246db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman TopHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT, Tmp1, 3247db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman DAG.getIntPtrConstant(1)); 324838a18261b97a0b7e0ed75b1c8edd81ec9bd01085Eric Christopher } else { 324938a18261b97a0b7e0ed75b1c8edd81ec9bd01085Eric Christopher // We can fall back to a libcall with an illegal type for the MUL if we 325038a18261b97a0b7e0ed75b1c8edd81ec9bd01085Eric Christopher // have a libcall big enough. 325138a18261b97a0b7e0ed75b1c8edd81ec9bd01085Eric Christopher // Also, we can fall back to a division in some cases, but that's a big 325238a18261b97a0b7e0ed75b1c8edd81ec9bd01085Eric Christopher // performance hit in the general case. 325338a18261b97a0b7e0ed75b1c8edd81ec9bd01085Eric Christopher RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL; 325438a18261b97a0b7e0ed75b1c8edd81ec9bd01085Eric Christopher if (WideVT == MVT::i16) 325538a18261b97a0b7e0ed75b1c8edd81ec9bd01085Eric Christopher LC = RTLIB::MUL_I16; 325638a18261b97a0b7e0ed75b1c8edd81ec9bd01085Eric Christopher else if (WideVT == MVT::i32) 325738a18261b97a0b7e0ed75b1c8edd81ec9bd01085Eric Christopher LC = RTLIB::MUL_I32; 325838a18261b97a0b7e0ed75b1c8edd81ec9bd01085Eric Christopher else if (WideVT == MVT::i64) 325938a18261b97a0b7e0ed75b1c8edd81ec9bd01085Eric Christopher LC = RTLIB::MUL_I64; 326038a18261b97a0b7e0ed75b1c8edd81ec9bd01085Eric Christopher else if (WideVT == MVT::i128) 326138a18261b97a0b7e0ed75b1c8edd81ec9bd01085Eric Christopher LC = RTLIB::MUL_I128; 326238a18261b97a0b7e0ed75b1c8edd81ec9bd01085Eric Christopher assert(LC != RTLIB::UNKNOWN_LIBCALL && "Cannot expand this operation!"); 3263f316eb70743e88227b8919370fe38587ffe93512Dan Gohman 3264f316eb70743e88227b8919370fe38587ffe93512Dan Gohman // The high part is obtained by SRA'ing all but one of the bits of low 3265abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher // part. 3266abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher unsigned LoSize = VT.getSizeInBits(); 3267abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher SDValue HiLHS = DAG.getNode(ISD::SRA, dl, VT, RHS, 3268abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher DAG.getConstant(LoSize-1, TLI.getPointerTy())); 3269abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher SDValue HiRHS = DAG.getNode(ISD::SRA, dl, VT, LHS, 3270abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher DAG.getConstant(LoSize-1, TLI.getPointerTy())); 3271abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher 3272abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher // Here we're passing the 2 arguments explicitly as 4 arguments that are 3273abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher // pre-lowered to the correct types. This all depends upon WideVT not 3274abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher // being a legal type for the architecture and thus has to be split to 3275abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher // two arguments. 3276abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher SDValue Args[] = { LHS, HiLHS, RHS, HiRHS }; 3277abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher SDValue Ret = ExpandLibCall(LC, WideVT, Args, 4, isSigned, dl); 3278abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher BottomHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT, Ret, 3279abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher DAG.getIntPtrConstant(0)); 3280abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher TopHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT, Ret, 3281abbbfbd6726c7af8b27479b4311fe6bb6c40b52bEric Christopher DAG.getIntPtrConstant(1)); 328265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman // Ret is a node with an illegal type. Because such things are not 328365fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman // generally permitted during this phase of legalization, delete the 328465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman // node. The above EXTRACT_ELEMENT nodes should have been folded. 328565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG.DeleteNode(Ret.getNode()); 3286db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman } 3287f316eb70743e88227b8919370fe38587ffe93512Dan Gohman 3288db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman if (isSigned) { 328995771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson Tmp1 = DAG.getConstant(VT.getSizeInBits() - 1, 329095771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson TLI.getShiftAmountTy(BottomHalf.getValueType())); 3291db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman Tmp1 = DAG.getNode(ISD::SRA, dl, VT, BottomHalf, Tmp1); 3292db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman TopHalf = DAG.getSetCC(dl, TLI.getSetCCResultType(VT), TopHalf, Tmp1, 3293db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman ISD::SETNE); 3294db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman } else { 3295db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman TopHalf = DAG.getSetCC(dl, TLI.getSetCCResultType(VT), TopHalf, 3296db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman DAG.getConstant(0, VT), ISD::SETNE); 3297db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman } 3298db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman Results.push_back(BottomHalf); 3299db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman Results.push_back(TopHalf); 3300db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman break; 3301db3c169f3a3102d40352ba63fd14a75c819c7adcEli Friedman } 3302f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman case ISD::BUILD_PAIR: { 3303e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT PairTy = Node->getValueType(0); 3304f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, PairTy, Node->getOperand(0)); 3305f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman Tmp2 = DAG.getNode(ISD::ANY_EXTEND, dl, PairTy, Node->getOperand(1)); 3306775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Tmp2 = DAG.getNode(ISD::SHL, dl, PairTy, Tmp2, 3307f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman DAG.getConstant(PairTy.getSizeInBits()/2, 330895771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson TLI.getShiftAmountTy(PairTy))); 3309775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(DAG.getNode(ISD::OR, dl, PairTy, Tmp1, Tmp2)); 3310f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman break; 3311f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman } 3312509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman case ISD::SELECT: 3313509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Tmp1 = Node->getOperand(0); 3314509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Tmp2 = Node->getOperand(1); 3315509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Tmp3 = Node->getOperand(2); 3316775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling if (Tmp1.getOpcode() == ISD::SETCC) { 3317509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Tmp1 = DAG.getSelectCC(dl, Tmp1.getOperand(0), Tmp1.getOperand(1), 3318509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Tmp2, Tmp3, 3319509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman cast<CondCodeSDNode>(Tmp1.getOperand(2))->get()); 3320775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling } else { 3321509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Tmp1 = DAG.getSelectCC(dl, Tmp1, 3322509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman DAG.getConstant(0, Tmp1.getValueType()), 3323509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Tmp2, Tmp3, ISD::SETNE); 3324775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling } 3325509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Results.push_back(Tmp1); 3326509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman break; 33274bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman case ISD::BR_JT: { 33284bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue Chain = Node->getOperand(0); 33294bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue Table = Node->getOperand(1); 33304bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue Index = Node->getOperand(2); 33314bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman 3332e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT PTy = TLI.getPointerTy(); 3333071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner 3334071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner const TargetData &TD = *TLI.getTargetData(); 3335071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner unsigned EntrySize = 3336071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner DAG.getMachineFunction().getJumpTableInfo()->getEntrySize(TD); 33376e9926108a69efbc11f1cadf947e98500e4d4228Jim Grosbach 3338071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner Index = DAG.getNode(ISD::MUL, dl, PTy, 33394bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman Index, DAG.getConstant(EntrySize, PTy)); 33404bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman SDValue Addr = DAG.getNode(ISD::ADD, dl, PTy, Index, Table); 33414bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman 334223b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT MemVT = EVT::getIntegerVT(*DAG.getContext(), EntrySize * 8); 3343a901129169194881a78b7fd8953e09f55b846d10Stuart Hastings SDValue LD = DAG.getExtLoad(ISD::SEXTLOAD, dl, PTy, Chain, Addr, 334485ca1066328639119f94c47a83b698c48b84ebb0Chris Lattner MachinePointerInfo::getJumpTable(), MemVT, 33451e559443a17d1b335f697551c6263ba60d5dd827David Greene false, false, 0); 33464bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman Addr = LD; 334755e59c186303ff02c0be7429da3b1b36c347f164Dan Gohman if (TM.getRelocationModel() == Reloc::PIC_) { 33484bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman // For PIC, the sequence is: 3349775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling // BRIND(load(Jumptable + index) + RelocBase) 33504bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman // RelocBase can be JumpTable, GOT or some sort of global base. 33514bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman Addr = DAG.getNode(ISD::ADD, dl, PTy, Addr, 33524bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman TLI.getPICJumpTableRelocBase(Table, DAG)); 33534bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman } 3354825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson Tmp1 = DAG.getNode(ISD::BRIND, dl, MVT::Other, LD.getValue(1), Addr); 33554bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman Results.push_back(Tmp1); 33564bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman break; 33574bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman } 3358f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman case ISD::BRCOND: 3359f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman // Expand brcond's setcc into its constituent parts and create a BR_CC 3360f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman // Node. 3361f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman Tmp1 = Node->getOperand(0); 3362f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman Tmp2 = Node->getOperand(1); 3363775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling if (Tmp2.getOpcode() == ISD::SETCC) { 3364825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson Tmp1 = DAG.getNode(ISD::BR_CC, dl, MVT::Other, 3365f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman Tmp1, Tmp2.getOperand(2), 3366f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman Tmp2.getOperand(0), Tmp2.getOperand(1), 3367f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman Node->getOperand(2)); 3368775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling } else { 336988882247d2e1bb70103062faf5bd15dd8a30b2d1Stuart Hastings // We test only the i1 bit. Skip the AND if UNDEF. 337088882247d2e1bb70103062faf5bd15dd8a30b2d1Stuart Hastings Tmp3 = (Tmp2.getOpcode() == ISD::UNDEF) ? Tmp2 : 337188882247d2e1bb70103062faf5bd15dd8a30b2d1Stuart Hastings DAG.getNode(ISD::AND, dl, Tmp2.getValueType(), Tmp2, 337288882247d2e1bb70103062faf5bd15dd8a30b2d1Stuart Hastings DAG.getConstant(1, Tmp2.getValueType())); 3373825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson Tmp1 = DAG.getNode(ISD::BR_CC, dl, MVT::Other, Tmp1, 337488882247d2e1bb70103062faf5bd15dd8a30b2d1Stuart Hastings DAG.getCondCode(ISD::SETNE), Tmp3, 337588882247d2e1bb70103062faf5bd15dd8a30b2d1Stuart Hastings DAG.getConstant(0, Tmp3.getValueType()), 3376f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman Node->getOperand(2)); 3377775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling } 3378f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman Results.push_back(Tmp1); 3379f6f20a7779c5308ccb3e4306552d749091a77a60Eli Friedman break; 3380ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman case ISD::SETCC: { 3381ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman Tmp1 = Node->getOperand(0); 3382ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman Tmp2 = Node->getOperand(1); 3383ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman Tmp3 = Node->getOperand(2); 3384775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling LegalizeSetCCCondCode(Node->getValueType(0), Tmp1, Tmp2, Tmp3, dl); 3385ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman 3386ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman // If we expanded the SETCC into an AND/OR, return the new node 3387ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman if (Tmp2.getNode() == 0) { 3388ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman Results.push_back(Tmp1); 3389ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman break; 3390ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman } 3391ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman 3392ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman // Otherwise, SETCC for the given comparison type must be completely 3393ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman // illegal; expand it into a SELECT_CC. 3394e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = Node->getValueType(0); 3395ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman Tmp1 = DAG.getNode(ISD::SELECT_CC, dl, VT, Tmp1, Tmp2, 3396ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman DAG.getConstant(1, VT), DAG.getConstant(0, VT), Tmp3); 3397ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman Results.push_back(Tmp1); 3398ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman break; 3399ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman } 3400bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman case ISD::SELECT_CC: { 3401bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman Tmp1 = Node->getOperand(0); // LHS 3402bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman Tmp2 = Node->getOperand(1); // RHS 3403bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman Tmp3 = Node->getOperand(2); // True 3404bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman Tmp4 = Node->getOperand(3); // False 3405bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman SDValue CC = Node->getOperand(4); 3406bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman 3407bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman LegalizeSetCCCondCode(TLI.getSetCCResultType(Tmp1.getValueType()), 3408775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Tmp1, Tmp2, CC, dl); 3409bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman 3410bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman assert(!Tmp2.getNode() && "Can't legalize SELECT_CC with legal condition!"); 3411bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman Tmp2 = DAG.getConstant(0, Tmp1.getValueType()); 3412bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman CC = DAG.getCondCode(ISD::SETNE); 3413bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman Tmp1 = DAG.getNode(ISD::SELECT_CC, dl, Node->getValueType(0), Tmp1, Tmp2, 3414bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman Tmp3, Tmp4, CC); 3415bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman Results.push_back(Tmp1); 3416bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman break; 3417bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman } 3418bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman case ISD::BR_CC: { 3419bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman Tmp1 = Node->getOperand(0); // Chain 3420bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman Tmp2 = Node->getOperand(2); // LHS 3421bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman Tmp3 = Node->getOperand(3); // RHS 3422bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman Tmp4 = Node->getOperand(1); // CC 3423bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman 3424bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman LegalizeSetCCCondCode(TLI.getSetCCResultType(Tmp2.getValueType()), 3425775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Tmp2, Tmp3, Tmp4, dl); 3426bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman 3427bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman assert(!Tmp3.getNode() && "Can't legalize BR_CC with legal condition!"); 3428bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman Tmp3 = DAG.getConstant(0, Tmp2.getValueType()); 3429bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman Tmp4 = DAG.getCondCode(ISD::SETNE); 3430bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman Tmp1 = DAG.getNode(ISD::BR_CC, dl, Node->getValueType(0), Tmp1, Tmp4, Tmp2, 3431bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman Tmp3, Node->getOperand(4)); 3432bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman Results.push_back(Tmp1); 3433bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman break; 3434bbdd903c52897df78750aa0caf2fc34d55b5ead0Eli Friedman } 343565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman case ISD::BUILD_VECTOR: 343665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Results.push_back(ExpandBUILD_VECTOR(Node)); 343765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman break; 343865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman case ISD::SRA: 343965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman case ISD::SRL: 344065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman case ISD::SHL: { 344165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman // Scalarize vector SRA/SRL/SHL. 344265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman EVT VT = Node->getValueType(0); 344365fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman assert(VT.isVector() && "Unable to legalize non-vector shift"); 344465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman assert(TLI.isTypeLegal(VT.getScalarType())&& "Element type must be legal"); 344565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman unsigned NumElem = VT.getVectorNumElements(); 344665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman 344765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SmallVector<SDValue, 8> Scalars; 344865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman for (unsigned Idx = 0; Idx < NumElem; Idx++) { 344965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue Ex = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, 345065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman VT.getScalarType(), 345165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Node->getOperand(0), DAG.getIntPtrConstant(Idx)); 345265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue Sh = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, 345365fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman VT.getScalarType(), 345465fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Node->getOperand(1), DAG.getIntPtrConstant(Idx)); 345565fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman Scalars.push_back(DAG.getNode(Node->getOpcode(), dl, 345665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman VT.getScalarType(), Ex, Sh)); 345765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman } 345865fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SDValue Result = 345965fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman DAG.getNode(ISD::BUILD_VECTOR, dl, Node->getValueType(0), 346065fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman &Scalars[0], Scalars.size()); 34610e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ReplaceNode(SDValue(Node, 0), Result); 346265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman break; 346365fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman } 34643f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::GLOBAL_OFFSET_TABLE: 34653f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::GlobalAddress: 34663f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::GlobalTLSAddress: 34673f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::ExternalSymbol: 34683f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::ConstantPool: 34693f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::JumpTable: 34703f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::INTRINSIC_W_CHAIN: 34713f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::INTRINSIC_WO_CHAIN: 34723f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::INTRINSIC_VOID: 34733f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // FIXME: Custom lowering for these operations shouldn't return null! 34743f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman break; 34758c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 347665fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman 347765fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman // Replace the original node with the legalized result. 34780e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman if (!Results.empty()) 34790e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ReplaceNode(Node, Results.data()); 34808c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman} 348165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman 348265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohmanvoid SelectionDAGLegalize::PromoteNode(SDNode *Node) { 348365fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman SmallVector<SDValue, 8> Results; 3484e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT OVT = Node->getValueType(0); 34858c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (Node->getOpcode() == ISD::UINT_TO_FP || 3486a64eb92fe305424ebde2e3de2b12160b8bf76047Eli Friedman Node->getOpcode() == ISD::SINT_TO_FP || 3487775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Node->getOpcode() == ISD::SETCC) { 34888c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman OVT = Node->getOperand(0).getValueType(); 3489775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling } 3490e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); 34918c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman DebugLoc dl = Node->getDebugLoc(); 3492509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman SDValue Tmp1, Tmp2, Tmp3; 34938c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman switch (Node->getOpcode()) { 34948c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::CTTZ: 349563974b2144c87c962effdc0508c27643c8ad98b6Chandler Carruth case ISD::CTTZ_ZERO_UNDEF: 34968c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::CTLZ: 349763974b2144c87c962effdc0508c27643c8ad98b6Chandler Carruth case ISD::CTLZ_ZERO_UNDEF: 34988c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::CTPOP: 34998c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // Zero extend the argument. 35008c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Node->getOperand(0)); 350163974b2144c87c962effdc0508c27643c8ad98b6Chandler Carruth // Perform the larger operation. For CTPOP and CTTZ_ZERO_UNDEF, this is 350263974b2144c87c962effdc0508c27643c8ad98b6Chandler Carruth // already the correct result. 35039a4ba45f4cd0496c422f81e104adf6c03ebdd3baJakob Stoklund Olesen Tmp1 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1); 35048c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (Node->getOpcode() == ISD::CTTZ) { 350563974b2144c87c962effdc0508c27643c8ad98b6Chandler Carruth // FIXME: This should set a bit in the zero extended value instead. 35069a4ba45f4cd0496c422f81e104adf6c03ebdd3baJakob Stoklund Olesen Tmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(NVT), 35078c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1, DAG.getConstant(NVT.getSizeInBits(), NVT), 35088c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman ISD::SETEQ); 35098c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::SELECT, dl, NVT, Tmp2, 35108c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman DAG.getConstant(OVT.getSizeInBits(), NVT), Tmp1); 351163974b2144c87c962effdc0508c27643c8ad98b6Chandler Carruth } else if (Node->getOpcode() == ISD::CTLZ || 351263974b2144c87c962effdc0508c27643c8ad98b6Chandler Carruth Node->getOpcode() == ISD::CTLZ_ZERO_UNDEF) { 35138c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 35148c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::SUB, dl, NVT, Tmp1, 35158c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman DAG.getConstant(NVT.getSizeInBits() - 35168c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman OVT.getSizeInBits(), NVT)); 35178c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 3518775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(DAG.getNode(ISD::TRUNCATE, dl, OVT, Tmp1)); 35198c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 35208c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::BSWAP: { 35218c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman unsigned DiffBits = NVT.getSizeInBits() - OVT.getSizeInBits(); 3522167bea71a4bd19329a218f5e1bd8facfd90a0cf9Bill Wendling Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Node->getOperand(0)); 3523775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Tmp1 = DAG.getNode(ISD::BSWAP, dl, NVT, Tmp1); 3524775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Tmp1 = DAG.getNode(ISD::SRL, dl, NVT, Tmp1, 352595771afbfd604ad003fa3723cac66c9370fed55dOwen Anderson DAG.getConstant(DiffBits, TLI.getShiftAmountTy(NVT))); 3526775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(Tmp1); 35278c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 35288c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 35298c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FP_TO_UINT: 35308c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FP_TO_SINT: 35318c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = PromoteLegalFP_TO_INT(Node->getOperand(0), Node->getValueType(0), 35328c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOpcode() == ISD::FP_TO_SINT, dl); 35338c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 35348c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 35358c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::UINT_TO_FP: 35368c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SINT_TO_FP: 35378c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = PromoteLegalINT_TO_FP(Node->getOperand(0), Node->getValueType(0), 35388c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOpcode() == ISD::SINT_TO_FP, dl); 35398c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 35408c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 35415194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel case ISD::VAARG: { 35425194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel SDValue Chain = Node->getOperand(0); // Get the chain. 35435194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel SDValue Ptr = Node->getOperand(1); // Get the pointer. 35445194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel 35455194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel unsigned TruncOp; 35465194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel if (OVT.isVector()) { 35475194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel TruncOp = ISD::BITCAST; 35485194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel } else { 35495194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel assert(OVT.isInteger() 35505194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel && "VAARG promotion is supported only for vectors or integer types"); 35515194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel TruncOp = ISD::TRUNCATE; 35525194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel } 35535194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel 35545194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel // Perform the larger operation, then convert back 35555194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel Tmp1 = DAG.getVAArg(NVT, dl, Chain, Ptr, Node->getOperand(2), 35565194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel Node->getConstantOperandVal(3)); 35575194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel Chain = Tmp1.getValue(1); 35585194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel 35595194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel Tmp2 = DAG.getNode(TruncOp, dl, OVT, Tmp1); 35605194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel 35615194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel // Modified the chain result - switch anything that used the old chain to 35625194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel // use the new one. 35635194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 0), Tmp2); 35645194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 1), Chain); 35655194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel ReplacedNode(Node); 35665194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel break; 35675194d6dd9575845cf1cbb2f10a0c769634d116a9Hal Finkel } 3568f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::AND: 3569f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::OR: 3570c8ca3ae27b64fa785f944799a9bc133fac8f90d9Jakob Stoklund Olesen case ISD::XOR: { 3571c8ca3ae27b64fa785f944799a9bc133fac8f90d9Jakob Stoklund Olesen unsigned ExtOp, TruncOp; 3572c8ca3ae27b64fa785f944799a9bc133fac8f90d9Jakob Stoklund Olesen if (OVT.isVector()) { 3573bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck ExtOp = ISD::BITCAST; 3574bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck TruncOp = ISD::BITCAST; 357535a389344d21178ee280c2410401b2060b5b879cChris Lattner } else { 357635a389344d21178ee280c2410401b2060b5b879cChris Lattner assert(OVT.isInteger() && "Cannot promote logic operation"); 3577c8ca3ae27b64fa785f944799a9bc133fac8f90d9Jakob Stoklund Olesen ExtOp = ISD::ANY_EXTEND; 3578c8ca3ae27b64fa785f944799a9bc133fac8f90d9Jakob Stoklund Olesen TruncOp = ISD::TRUNCATE; 3579c8ca3ae27b64fa785f944799a9bc133fac8f90d9Jakob Stoklund Olesen } 3580c8ca3ae27b64fa785f944799a9bc133fac8f90d9Jakob Stoklund Olesen // Promote each of the values to the new type. 3581c8ca3ae27b64fa785f944799a9bc133fac8f90d9Jakob Stoklund Olesen Tmp1 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(0)); 3582c8ca3ae27b64fa785f944799a9bc133fac8f90d9Jakob Stoklund Olesen Tmp2 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(1)); 3583c8ca3ae27b64fa785f944799a9bc133fac8f90d9Jakob Stoklund Olesen // Perform the larger operation, then convert back 3584775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Tmp1 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1, Tmp2); 3585775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(DAG.getNode(TruncOp, dl, OVT, Tmp1)); 3586f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3587c8ca3ae27b64fa785f944799a9bc133fac8f90d9Jakob Stoklund Olesen } 3588c8ca3ae27b64fa785f944799a9bc133fac8f90d9Jakob Stoklund Olesen case ISD::SELECT: { 3589509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman unsigned ExtOp, TruncOp; 35904bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman if (Node->getValueType(0).isVector()) { 3591bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck ExtOp = ISD::BITCAST; 3592bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck TruncOp = ISD::BITCAST; 35934bc8c718218159fe410462f6e3670e7cb76c0c04Eli Friedman } else if (Node->getValueType(0).isInteger()) { 3594509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman ExtOp = ISD::ANY_EXTEND; 3595509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman TruncOp = ISD::TRUNCATE; 3596509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman } else { 3597509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman ExtOp = ISD::FP_EXTEND; 3598509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman TruncOp = ISD::FP_ROUND; 3599509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman } 3600509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Tmp1 = Node->getOperand(0); 3601509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman // Promote each of the values to the new type. 3602509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Tmp2 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(1)); 3603509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Tmp3 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(2)); 3604509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman // Perform the larger operation, then round down. 3605509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Tmp1 = DAG.getNode(ISD::SELECT, dl, NVT, Tmp1, Tmp2, Tmp3); 3606509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman if (TruncOp != ISD::FP_ROUND) 3607775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Tmp1 = DAG.getNode(TruncOp, dl, Node->getValueType(0), Tmp1); 3608509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman else 3609775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Tmp1 = DAG.getNode(TruncOp, dl, Node->getValueType(0), Tmp1, 3610509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman DAG.getIntPtrConstant(0)); 3611775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Results.push_back(Tmp1); 3612509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman break; 3613c8ca3ae27b64fa785f944799a9bc133fac8f90d9Jakob Stoklund Olesen } 3614509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman case ISD::VECTOR_SHUFFLE: { 3615ed4c8c633c52a40ad1a3e8687f290be4aeb1f0e8Benjamin Kramer ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(Node)->getMask(); 3616509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman 3617509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman // Cast the two input vectors. 3618bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck Tmp1 = DAG.getNode(ISD::BITCAST, dl, NVT, Node->getOperand(0)); 3619bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck Tmp2 = DAG.getNode(ISD::BITCAST, dl, NVT, Node->getOperand(1)); 3620509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman 3621509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman // Convert the shuffle mask to the right # elements. 3622775db97a50fb56fece6fbd68e1a6f86418e8063aBill Wendling Tmp1 = ShuffleWithNarrowerEltType(NVT, OVT, dl, Tmp1, Tmp2, Mask); 3623bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck Tmp1 = DAG.getNode(ISD::BITCAST, dl, OVT, Tmp1); 3624509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman Results.push_back(Tmp1); 3625509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman break; 3626509150f973ae650a57b79010a3ec36e60e40f41dEli Friedman } 3627ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman case ISD::SETCC: { 362878d12644b905dc54cf6cf984af02a49d30d29744Jakob Stoklund Olesen unsigned ExtOp = ISD::FP_EXTEND; 362978d12644b905dc54cf6cf984af02a49d30d29744Jakob Stoklund Olesen if (NVT.isInteger()) { 363078d12644b905dc54cf6cf984af02a49d30d29744Jakob Stoklund Olesen ISD::CondCode CCCode = 363178d12644b905dc54cf6cf984af02a49d30d29744Jakob Stoklund Olesen cast<CondCodeSDNode>(Node->getOperand(2))->get(); 363278d12644b905dc54cf6cf984af02a49d30d29744Jakob Stoklund Olesen ExtOp = isSignedIntSetCC(CCCode) ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND; 3633ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman } 363478d12644b905dc54cf6cf984af02a49d30d29744Jakob Stoklund Olesen Tmp1 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(0)); 363578d12644b905dc54cf6cf984af02a49d30d29744Jakob Stoklund Olesen Tmp2 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(1)); 3636ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman Results.push_back(DAG.getNode(ISD::SETCC, dl, Node->getValueType(0), 3637ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman Tmp1, Tmp2, Node->getOperand(2))); 3638ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman break; 3639ad75460e30aab135057355fa0712141bf2cb08fcEli Friedman } 3640cfe2998c3e1a9ea66c9bab3bcf3f93960be304fdPete Cooper case ISD::FDIV: 36419751b81fc97dcb6ecc4be4304ef8e6e8cf79f6e4Pete Cooper case ISD::FREM: 3642d578b905de8f9dece45aab2496a88ac548c67348Pete Cooper case ISD::FPOW: { 3643d578b905de8f9dece45aab2496a88ac548c67348Pete Cooper Tmp1 = DAG.getNode(ISD::FP_EXTEND, dl, NVT, Node->getOperand(0)); 3644d578b905de8f9dece45aab2496a88ac548c67348Pete Cooper Tmp2 = DAG.getNode(ISD::FP_EXTEND, dl, NVT, Node->getOperand(1)); 3645cfe2998c3e1a9ea66c9bab3bcf3f93960be304fdPete Cooper Tmp3 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1, Tmp2); 3646d578b905de8f9dece45aab2496a88ac548c67348Pete Cooper Results.push_back(DAG.getNode(ISD::FP_ROUND, dl, OVT, 3647d578b905de8f9dece45aab2496a88ac548c67348Pete Cooper Tmp3, DAG.getIntPtrConstant(0))); 3648d578b905de8f9dece45aab2496a88ac548c67348Pete Cooper break; 3649d578b905de8f9dece45aab2496a88ac548c67348Pete Cooper } 3650d578b905de8f9dece45aab2496a88ac548c67348Pete Cooper case ISD::FLOG2: 3651d578b905de8f9dece45aab2496a88ac548c67348Pete Cooper case ISD::FEXP2: 3652d578b905de8f9dece45aab2496a88ac548c67348Pete Cooper case ISD::FLOG: 3653d578b905de8f9dece45aab2496a88ac548c67348Pete Cooper case ISD::FEXP: { 3654d578b905de8f9dece45aab2496a88ac548c67348Pete Cooper Tmp1 = DAG.getNode(ISD::FP_EXTEND, dl, NVT, Node->getOperand(0)); 3655d578b905de8f9dece45aab2496a88ac548c67348Pete Cooper Tmp2 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1); 3656d578b905de8f9dece45aab2496a88ac548c67348Pete Cooper Results.push_back(DAG.getNode(ISD::FP_ROUND, dl, OVT, 3657d578b905de8f9dece45aab2496a88ac548c67348Pete Cooper Tmp2, DAG.getIntPtrConstant(0))); 3658d578b905de8f9dece45aab2496a88ac548c67348Pete Cooper break; 3659d578b905de8f9dece45aab2496a88ac548c67348Pete Cooper } 36608c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 366165fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman 366265fd6564b8aedd053845c81ede1ac594acb470e4Dan Gohman // Replace the original node with the legalized result. 36630e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman if (!Results.empty()) 36640e3642a58746a26f50709179a2bcb25f335e2dacEli Friedman ReplaceNode(Node, Results.data()); 36658c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman} 36668c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman 36673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// SelectionDAG::Legalize - This is the entry point for the file. 36683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 3669975716af1b9a09274df6c2d92683449015bd8564Dan Gohmanvoid SelectionDAG::Legalize() { 36703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// run - This is the main entry point to this class. 36713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 3672975716af1b9a09274df6c2d92683449015bd8564Dan Gohman SelectionDAGLegalize(*this).LegalizeDAG(); 36733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 3674