LegalizeDAG.cpp revision 74807f2520715056be399a2bc59dfc8b6f8f3eb2
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 143e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/CodeGen/SelectionDAG.h" 153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/CodeGen/MachineFunction.h" 1645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 17acd80ac7bb19f8bdfa55336d567c9ecbe695c8b8Jim Laskey#include "llvm/CodeGen/MachineJumpTableInfo.h" 1884bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineModuleInfo.h" 1983489bb7700c69b7a4a8da59365c42d3f5c8129bDevang Patel#include "llvm/CodeGen/DwarfWriter.h" 2083489bb7700c69b7a4a8da59365c42d3f5c8129bDevang Patel#include "llvm/Analysis/DebugInfo.h" 2169de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman#include "llvm/CodeGen/PseudoSourceValue.h" 2261bbbabe3da27479cc9a3a36e49091a1141ba7a3Evan Cheng#include "llvm/Target/TargetFrameInfo.h" 233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/Target/TargetLowering.h" 24e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner#include "llvm/Target/TargetData.h" 253d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng#include "llvm/Target/TargetMachine.h" 260f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner#include "llvm/Target/TargetOptions.h" 27707e0184233f27e0e9f9aee0309f2daab8cfe7f8Dan Gohman#include "llvm/Target/TargetSubtarget.h" 28adf6a965a321372c640845407195594835921eb4Chris Lattner#include "llvm/CallingConv.h" 293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner#include "llvm/Constants.h" 30c10305743c313558405079452138f03124e87581Reid Spencer#include "llvm/DerivedTypes.h" 3186e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling#include "llvm/Function.h" 3283489bb7700c69b7a4a8da59365c42d3f5c8129bDevang Patel#include "llvm/GlobalVariable.h" 335e46a19ec848cd4fc9649bd5170c43d9e657668cChris Lattner#include "llvm/Support/CommandLine.h" 34a4f0b3a084d120cfc5b5bb06f64b222f5cb72740Chris Lattner#include "llvm/Support/Compiler.h" 35dc84650679b6330e0fcdd4cf8bc2a351387db7caDuncan Sands#include "llvm/Support/MathExtras.h" 367971514755a08ec156a1b9c0f7f05d67919c56b7Chris Lattner#include "llvm/ADT/DenseMap.h" 37f06f35e30b4c4d7db304f717a3d4dc6595fbd078Chris Lattner#include "llvm/ADT/SmallVector.h" 3800755df36c1448ac4728a74d907aa09e3d8b2d49Chris Lattner#include "llvm/ADT/SmallPtrSet.h" 39033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng#include <map> 403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerusing namespace llvm; 413e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner//===----------------------------------------------------------------------===// 433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// SelectionDAGLegalize - This takes an arbitrary SelectionDAG as input and 443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// hacks on it until the target machine can handle it. This involves 453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// eliminating value sizes the machine cannot handle (promoting small sizes to 463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// large sizes or splitting up large values into small values) as well as 473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// eliminating operations the machine cannot handle. 483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// This code also does a small amount of optimization and recognition of idioms 503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// as part of its processing. For example, if a target does not support a 513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 'setcc' instruction efficiently, but does support 'brcc' instruction, this 523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// will attempt merge setcc and brc instructions into brcc's. 533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner/// 543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnernamespace { 55360e8200ec544a3c877ff74b48f445140ac9bbd6Chris Lattnerclass VISIBILITY_HIDDEN SelectionDAGLegalize { 563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner TargetLowering &TLI; 573e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner SelectionDAG &DAG; 5898a366d547772010e94609e4584489b3e5ce0043Bill Wendling CodeGenOpt::Level OptLevel; 593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 606831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Libcall insertion helpers. 61fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 626831a815999dde4cf801e2076e66b4943964daf2Chris Lattner /// LastCALLSEQ_END - This keeps track of the CALLSEQ_END node that has been 636831a815999dde4cf801e2076e66b4943964daf2Chris Lattner /// legalized. We use this to ensure that calls are properly serialized 646831a815999dde4cf801e2076e66b4943964daf2Chris Lattner /// against each other, including inserted libcalls. 65475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue LastCALLSEQ_END; 66fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 676831a815999dde4cf801e2076e66b4943964daf2Chris Lattner /// IsLegalizingCall - This member is used *only* for purposes of providing 68fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel /// helpful assertions that a libcall isn't created while another call is 696831a815999dde4cf801e2076e66b4943964daf2Chris Lattner /// being legalized (which could lead to non-serialized call sequences). 706831a815999dde4cf801e2076e66b4943964daf2Chris Lattner bool IsLegalizingCall; 71fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner enum LegalizeAction { 7368a17febc70d9beb5353454e0c6d136ca1e87605Chris Lattner Legal, // The target natively supports this operation. 7468a17febc70d9beb5353454e0c6d136ca1e87605Chris Lattner Promote, // This operation should be executed in a larger type. 75d74ea2bbd8bb630331f35ead42d385249bd42af8Chris Lattner Expand // Try to expand this to other ops, otherwise use a libcall. 763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner }; 77fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// ValueTypeActions - This is a bitvector that contains two bits for each 793e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// value type, where the two bits correspond to the LegalizeAction enum. 803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// This can be queried with "getTypeAction(VT)". 8168a17febc70d9beb5353454e0c6d136ca1e87605Chris Lattner TargetLowering::ValueTypeActionImpl ValueTypeActions; 823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// LegalizedNodes - For nodes that are of legal width, and that have more 843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// than one use, this map indicates what regularized operand to use. This 853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// allows us to avoid legalizing the same thing more than once. 86475871a144eb604ddaf37503397ba0941442e5fbDan Gohman DenseMap<SDValue, SDValue> LegalizedNodes; 873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 88475871a144eb604ddaf37503397ba0941442e5fbDan Gohman void AddLegalizedOperand(SDValue From, SDValue To) { 8969a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner LegalizedNodes.insert(std::make_pair(From, To)); 9069a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner // If someone requests legalization of the new node, return itself. 9169a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner if (From != To) 9269a889eb35d59a10e78a07cc26d41cbab31eddceChris Lattner LegalizedNodes.insert(std::make_pair(To, To)); 938afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner } 948afc48e44ad8868c1d41511db645e2ba1a4b894eChris Lattner 953e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnerpublic: 961fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman SelectionDAGLegalize(SelectionDAG &DAG, CodeGenOpt::Level ol); 973e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 983e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// getTypeAction - Return how we should legalize values of this type, either 993e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// it is already legal or we need to expand it into multiple registers of 1003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// smaller integer type, or we need to promote it to a larger type. 10183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands LegalizeAction getTypeAction(MVT VT) const { 10268a17febc70d9beb5353454e0c6d136ca1e87605Chris Lattner return (LegalizeAction)ValueTypeActions.getTypeAction(VT); 1033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// isTypeLegal - Return true if this type is legal on this target. 1063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 10783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands bool isTypeLegal(MVT VT) const { 1083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return getTypeAction(VT) == Legal; 1093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner void LegalizeDAG(); 1123e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 113456a93afcec7740c45cafa8354317f7b17987a6dChris Lattnerprivate: 1147f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman /// HandleOp - Legalize, Promote, or Expand the specified operand as 115c7029805ef35ce9805931067b841e6af11db382eChris Lattner /// appropriate for its type. 116475871a144eb604ddaf37503397ba0941442e5fbDan Gohman void HandleOp(SDValue Op); 117fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 118c7029805ef35ce9805931067b841e6af11db382eChris Lattner /// LegalizeOp - We know that the specified value has a legal type. 119c7029805ef35ce9805931067b841e6af11db382eChris Lattner /// Recursively ensure that the operands have legal types, then return the 120c7029805ef35ce9805931067b841e6af11db382eChris Lattner /// result. 121475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue LegalizeOp(SDValue O); 122fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1236867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman /// PerformInsertVectorEltInMemory - Some target cannot handle a variable 1246867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman /// insertion index for the INSERT_VECTOR_ELT instruction. In this case, it 1256867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman /// is necessary to spill the vector being inserted into to memory, perform 1266867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman /// the insert there, and then read the result back. 127475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue PerformInsertVectorEltInMemory(SDValue Vec, SDValue Val, 128bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Idx, DebugLoc dl); 129826695281344e3a4c4d44d73dd155107aafd689bDan Gohman 130f007a8b931e229eb325319c97363be8507311e2eMon P Wang /// Useful 16 element vector type that is used to pass operands for widening. 131fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel typedef SmallVector<SDValue, 16> SDValueVector; 132fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1335a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman /// ShuffleWithNarrowerEltType - Return a vector shuffle operation which 1345a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman /// performs the same shuffe in terms of order or result bytes, but on a type 1355a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman /// whose vector element type is narrower than the original shuffle type. 1365a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman /// e.g. <v4i32> <0, 1, 0, 1> -> v8i16 <0, 1, 2, 3, 0, 1, 2, 3> 1375a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman SDValue ShuffleWithNarrowerEltType(MVT NVT, MVT VT, DebugLoc dl, 1385a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman SDValue N1, SDValue N2, 1395a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman SmallVectorImpl<int> &Mask) const; 140fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 141c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner bool LegalizeAllNodesNotLeadingTo(SDNode *N, SDNode *Dest, 14200755df36c1448ac4728a74d907aa09e3d8b2d49Chris Lattner SmallPtrSet<SDNode*, 32> &NodesLeadingTo); 1436831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 144bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen void LegalizeSetCCOperands(SDValue &LHS, SDValue &RHS, SDValue &CC, 145bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl); 146bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen void LegalizeSetCCCondCode(MVT VT, SDValue &LHS, SDValue &RHS, SDValue &CC, 147bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl); 148bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen void LegalizeSetCC(MVT VT, SDValue &LHS, SDValue &RHS, SDValue &CC, 149bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl) { 150bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen LegalizeSetCCOperands(LHS, RHS, CC, dl); 151bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen LegalizeSetCCCondCode(VT, LHS, RHS, CC, dl); 1527f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng } 153fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 154475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue ExpandLibCall(RTLIB::Libcall LC, SDNode *Node, bool isSigned, 155475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Hi); 156475871a144eb604ddaf37503397ba0941442e5fbDan Gohman 1578a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen SDValue EmitStackConvert(SDValue SrcOp, MVT SlotVT, MVT DestVT, DebugLoc dl); 158475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue ExpandBUILD_VECTOR(SDNode *Node); 159475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue ExpandSCALAR_TO_VECTOR(SDNode *Node); 160fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel SDValue LegalizeINT_TO_FP(SDValue Result, bool isSigned, MVT DestTy, 161af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue Op, DebugLoc dl); 162af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue ExpandLegalINT_TO_FP(bool isSigned, SDValue LegalOp, MVT DestVT, 163af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl); 164af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue PromoteLegalINT_TO_FP(SDValue LegalOp, MVT DestVT, bool isSigned, 165af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl); 166af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue PromoteLegalFP_TO_INT(SDValue LegalOp, MVT DestVT, bool isSigned, 167af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl); 168475871a144eb604ddaf37503397ba0941442e5fbDan Gohman 1698a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen SDValue ExpandBSWAP(SDValue Op, DebugLoc dl); 1708a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen SDValue ExpandBitCount(unsigned Opc, SDValue Op, DebugLoc dl); 171475871a144eb604ddaf37503397ba0941442e5fbDan Gohman 172475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue ExpandEXTRACT_VECTOR_ELT(SDValue Op); 1733d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman SDValue ExpandExtractFromVectorThroughStack(SDValue Op); 1743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner}; 1753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 1763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1775a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman/// ShuffleWithNarrowerEltType - Return a vector shuffle operation which 1785a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman/// performs the same shuffe in terms of order or result bytes, but on a type 1795a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman/// whose vector element type is narrower than the original shuffle type. 1809008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman/// e.g. <v4i32> <0, 1, 0, 1> -> v8i16 <0, 1, 2, 3, 0, 1, 2, 3> 1815a5ca1519e04310f585197c20e7ae584b7f2d11fNate BegemanSDValue 1825a5ca1519e04310f585197c20e7ae584b7f2d11fNate BegemanSelectionDAGLegalize::ShuffleWithNarrowerEltType(MVT NVT, MVT VT, DebugLoc dl, 1835a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman SDValue N1, SDValue N2, 1849008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman SmallVectorImpl<int> &Mask) const { 1859008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman MVT EltVT = NVT.getVectorElementType(); 1865a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman unsigned NumMaskElts = VT.getVectorNumElements(); 1875a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman unsigned NumDestElts = NVT.getVectorNumElements(); 1889008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman unsigned NumEltsGrowth = NumDestElts / NumMaskElts; 1899008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman 1909008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman assert(NumEltsGrowth && "Cannot promote to vector type with fewer elts!"); 1919008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman 1929008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman if (NumEltsGrowth == 1) 1939008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman return DAG.getVectorShuffle(NVT, dl, N1, N2, &Mask[0]); 1949008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman 1959008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman SmallVector<int, 8> NewMask; 1965a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman for (unsigned i = 0; i != NumMaskElts; ++i) { 1979008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman int Idx = Mask[i]; 1989008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman for (unsigned j = 0; j != NumEltsGrowth; ++j) { 1999008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman if (Idx < 0) 2009008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman NewMask.push_back(-1); 2019008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman else 2029008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman NewMask.push_back(Idx * NumEltsGrowth + j); 2034352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner } 20415684b29552393553524171bff1913e750f390f8Rafael Espindola } 2055a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman assert(NewMask.size() == NumDestElts && "Non-integer NumEltsGrowth?"); 2069008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman assert(TLI.isShuffleMaskLegal(NewMask, NVT) && "Shuffle not legal?"); 2079008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman return DAG.getVectorShuffle(NVT, dl, N1, N2, &NewMask[0]); 2084352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner} 2094352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner 2105aa4977fba97e816b5735f0bc53f16a46b24de63Bill WendlingSelectionDAGLegalize::SelectionDAGLegalize(SelectionDAG &dag, 2111fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman CodeGenOpt::Level ol) 212be8cc2a3dedeb7685f07e68cdc4b9502eb97eb2bBill Wendling : TLI(dag.getTargetLoweringInfo()), DAG(dag), OptLevel(ol), 2131fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman ValueTypeActions(TLI.getValueTypeActions()) { 2146a648614e88586e85a36ceb5c1d3b84e4f55b458Nate Begeman assert(MVT::LAST_VALUETYPE <= 32 && 2153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Too many value types for ValueTypeActions to hold!"); 2163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 2173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::LegalizeDAG() { 2196831a815999dde4cf801e2076e66b4943964daf2Chris Lattner LastCALLSEQ_END = DAG.getEntryNode(); 2206831a815999dde4cf801e2076e66b4943964daf2Chris Lattner IsLegalizingCall = false; 221e5ab34e05d701da042619bf540046efc3c7bc41fMon P Wang 222ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // The legalize process is inherently a bottom-up recursive process (users 223ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // legalize their uses before themselves). Given infinite stack space, we 224ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // could just start legalizing on the root and traverse the whole graph. In 225ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // practice however, this causes us to run out of stack space on large basic 22632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // blocks. To avoid this problem, compute an ordering of the nodes where each 22732fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // node is only legalized after all of its operands are legalized. 228f06c835f769aa1cf67801ed1f6bd366a447c18b1Dan Gohman DAG.AssignTopologicalOrder(); 229f06c835f769aa1cf67801ed1f6bd366a447c18b1Dan Gohman for (SelectionDAG::allnodes_iterator I = DAG.allnodes_begin(), 230f06c835f769aa1cf67801ed1f6bd366a447c18b1Dan Gohman E = prior(DAG.allnodes_end()); I != next(E); ++I) 231f06c835f769aa1cf67801ed1f6bd366a447c18b1Dan Gohman HandleOp(SDValue(I, 0)); 23232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 23332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // Finally, it's possible the root changed. Get the new root. 234475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue OldRoot = DAG.getRoot(); 23532fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner assert(LegalizedNodes.count(OldRoot) && "Root didn't get legalized?"); 23632fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner DAG.setRoot(LegalizedNodes[OldRoot]); 2373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizedNodes.clear(); 2393e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2403e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remove dead nodes now. 241190a418bf6b49a4ef1c1980229a2f0d516e8a2cdChris Lattner DAG.RemoveDeadNodes(); 2423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 2433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2446831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 2456831a815999dde4cf801e2076e66b4943964daf2Chris Lattner/// FindCallEndFromCallStart - Given a chained node that is part of a call 2466831a815999dde4cf801e2076e66b4943964daf2Chris Lattner/// sequence, find the CALLSEQ_END node that terminates the call sequence. 2476831a815999dde4cf801e2076e66b4943964daf2Chris Lattnerstatic SDNode *FindCallEndFromCallStart(SDNode *Node) { 2486831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) 2496831a815999dde4cf801e2076e66b4943964daf2Chris Lattner return Node; 2506831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (Node->use_empty()) 2516831a815999dde4cf801e2076e66b4943964daf2Chris Lattner return 0; // No CallSeqEnd 252fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2536831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // The chain is usually at the end. 254475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue TheChain(Node, Node->getNumValues()-1); 2556831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (TheChain.getValueType() != MVT::Other) { 2566831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Sometimes it's at the beginning. 257475871a144eb604ddaf37503397ba0941442e5fbDan Gohman TheChain = SDValue(Node, 0); 2586831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (TheChain.getValueType() != MVT::Other) { 2596831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Otherwise, hunt for it. 2606831a815999dde4cf801e2076e66b4943964daf2Chris Lattner for (unsigned i = 1, e = Node->getNumValues(); i != e; ++i) 2616831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (Node->getValueType(i) == MVT::Other) { 262475871a144eb604ddaf37503397ba0941442e5fbDan Gohman TheChain = SDValue(Node, i); 2636831a815999dde4cf801e2076e66b4943964daf2Chris Lattner break; 2646831a815999dde4cf801e2076e66b4943964daf2Chris Lattner } 265fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 266fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // Otherwise, we walked into a node without a chain. 2676831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (TheChain.getValueType() != MVT::Other) 2686831a815999dde4cf801e2076e66b4943964daf2Chris Lattner return 0; 2696831a815999dde4cf801e2076e66b4943964daf2Chris Lattner } 2706831a815999dde4cf801e2076e66b4943964daf2Chris Lattner } 271fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2726831a815999dde4cf801e2076e66b4943964daf2Chris Lattner for (SDNode::use_iterator UI = Node->use_begin(), 2736831a815999dde4cf801e2076e66b4943964daf2Chris Lattner E = Node->use_end(); UI != E; ++UI) { 274fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2756831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Make sure to only follow users of our token chain. 2768968450305c28444edc3c272d8752a8db0c2f34aDan Gohman SDNode *User = *UI; 2776831a815999dde4cf801e2076e66b4943964daf2Chris Lattner for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i) 2786831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (User->getOperand(i) == TheChain) 2796831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (SDNode *Result = FindCallEndFromCallStart(User)) 2806831a815999dde4cf801e2076e66b4943964daf2Chris Lattner return Result; 2816831a815999dde4cf801e2076e66b4943964daf2Chris Lattner } 2826831a815999dde4cf801e2076e66b4943964daf2Chris Lattner return 0; 2836831a815999dde4cf801e2076e66b4943964daf2Chris Lattner} 2846831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 285fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel/// FindCallStartFromCallEnd - Given a chained node that is part of a call 2866831a815999dde4cf801e2076e66b4943964daf2Chris Lattner/// sequence, find the CALLSEQ_START node that initiates the call sequence. 2876831a815999dde4cf801e2076e66b4943964daf2Chris Lattnerstatic SDNode *FindCallStartFromCallEnd(SDNode *Node) { 2886831a815999dde4cf801e2076e66b4943964daf2Chris Lattner assert(Node && "Didn't find callseq_start for a call??"); 2896831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) return Node; 290fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2916831a815999dde4cf801e2076e66b4943964daf2Chris Lattner assert(Node->getOperand(0).getValueType() == MVT::Other && 2926831a815999dde4cf801e2076e66b4943964daf2Chris Lattner "Node doesn't have a token chain argument!"); 293ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return FindCallStartFromCallEnd(Node->getOperand(0).getNode()); 2946831a815999dde4cf801e2076e66b4943964daf2Chris Lattner} 2956831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 2966831a815999dde4cf801e2076e66b4943964daf2Chris Lattner/// LegalizeAllNodesNotLeadingTo - Recursively walk the uses of N, looking to 297fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel/// see if any uses can reach Dest. If no dest operands can get to dest, 2986831a815999dde4cf801e2076e66b4943964daf2Chris Lattner/// legalize them, legalize ourself, and return false, otherwise, return true. 299c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner/// 300c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner/// Keep track of the nodes we fine that actually do lead to Dest in 301c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner/// NodesLeadingTo. This avoids retraversing them exponential number of times. 302c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner/// 303c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattnerbool SelectionDAGLegalize::LegalizeAllNodesNotLeadingTo(SDNode *N, SDNode *Dest, 30400755df36c1448ac4728a74d907aa09e3d8b2d49Chris Lattner SmallPtrSet<SDNode*, 32> &NodesLeadingTo) { 3056831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (N == Dest) return true; // N certainly leads to Dest :) 306fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 307c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner // If we've already processed this node and it does lead to Dest, there is no 308c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner // need to reprocess it. 309c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner if (NodesLeadingTo.count(N)) return true; 310fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 3116831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // If the first result of this node has been already legalized, then it cannot 3126831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // reach N. 31374807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman if (LegalizedNodes.count(SDValue(N, 0))) return false; 314fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 3156831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Okay, this node has not already been legalized. Check and legalize all 3166831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // operands. If none lead to Dest, then we can legalize this node. 3176831a815999dde4cf801e2076e66b4943964daf2Chris Lattner bool OperandsLeadToDest = false; 3186831a815999dde4cf801e2076e66b4943964daf2Chris Lattner for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) 3196831a815999dde4cf801e2076e66b4943964daf2Chris Lattner OperandsLeadToDest |= // If an operand leads to Dest, so do we. 320ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif LegalizeAllNodesNotLeadingTo(N->getOperand(i).getNode(), Dest, NodesLeadingTo); 3216831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 322c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner if (OperandsLeadToDest) { 323c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner NodesLeadingTo.insert(N); 324c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner return true; 325c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner } 3266831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 3276831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Okay, this node looks safe, legalize it and return false. 328475871a144eb604ddaf37503397ba0941442e5fbDan Gohman HandleOp(SDValue(N, 0)); 3296831a815999dde4cf801e2076e66b4943964daf2Chris Lattner return false; 3306831a815999dde4cf801e2076e66b4943964daf2Chris Lattner} 3316831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 3320c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang/// HandleOp - Legalize, Promote, Widen, or Expand the specified operand as 333c7029805ef35ce9805931067b841e6af11db382eChris Lattner/// appropriate for its type. 334475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid SelectionDAGLegalize::HandleOp(SDValue Op) { 3351fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman // Don't touch TargetConstants 3361fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman if (Op.getOpcode() == ISD::TargetConstant) 3371fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman return; 33883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Op.getValueType(); 3391fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman // We should never see any illegal result types here. 3401fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman assert(isTypeLegal(VT) && "Illegal type introduced after type legalization?"); 34174807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman (void)LegalizeOp(Op); 342c7029805ef35ce9805931067b841e6af11db382eChris Lattner} 3436831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 3449f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng/// ExpandConstantFP - Expands the ConstantFP node to an integer constant or 3459f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng/// a load from the constant pool. 346475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanstatic SDValue ExpandConstantFP(ConstantFPSDNode *CFP, bool UseCP, 3470d137d7f35fba98f668098b3badf644efacf0e08Dan Gohman SelectionDAG &DAG, const TargetLowering &TLI) { 348004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng bool Extend = false; 34933c960f523f2308482d5b2816af46a7ec90a6d3dDale Johannesen DebugLoc dl = CFP->getDebugLoc(); 350004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng 351004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng // If a FP immediate is precise when represented as a float and if the 352004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng // target can do an extending load from float to double, we put it into 353004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng // the constant pool as a float, even if it's is statically typed as a 354aa2acbbbf06348f20274f4eeb77f9761c654a589Chris Lattner // double. This shrinks FP constants and canonicalizes them for targets where 355aa2acbbbf06348f20274f4eeb77f9761c654a589Chris Lattner // an FP extending load is the same cost as a normal load (such as on the x87 356aa2acbbbf06348f20274f4eeb77f9761c654a589Chris Lattner // fp stack or PPC FP unit). 35783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = CFP->getValueType(0); 3584fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman ConstantFP *LLVMC = const_cast<ConstantFP*>(CFP->getConstantFPValue()); 3599f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng if (!UseCP) { 360d2e936a513b01b2c5df91a9c0d80070e8c752aceChris Lattner assert((VT == MVT::f64 || VT == MVT::f32) && "Invalid type expansion"); 3617111b02c734c992b8c97d9918118768026dad79eDale Johannesen return DAG.getConstant(LLVMC->getValueAPF().bitcastToAPInt(), 362ef12057737229452c17983faa20857dba441ef05Evan Cheng (VT == MVT::f64) ? MVT::i64 : MVT::i32); 363279101eb1ac61e2d5b83d5bdcc5be56e710d2cd7Evan Cheng } 364279101eb1ac61e2d5b83d5bdcc5be56e710d2cd7Evan Cheng 36583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT OrigVT = VT; 36683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT SVT = VT; 367ef12057737229452c17983faa20857dba441ef05Evan Cheng while (SVT != MVT::f32) { 36883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands SVT = (MVT::SimpleValueType)(SVT.getSimpleVT() - 1); 369ef12057737229452c17983faa20857dba441ef05Evan Cheng if (CFP->isValueValidForType(SVT, CFP->getValueAPF()) && 370ef12057737229452c17983faa20857dba441ef05Evan Cheng // Only do this if the target has a native EXTLOAD instruction from 371ef12057737229452c17983faa20857dba441ef05Evan Cheng // smaller type. 3720329466b6b4927f4e6f5d144891fef06a027fec5Evan Cheng TLI.isLoadExtLegal(ISD::EXTLOAD, SVT) && 373aa2acbbbf06348f20274f4eeb77f9761c654a589Chris Lattner TLI.ShouldShrinkFPConstant(OrigVT)) { 37483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands const Type *SType = SVT.getTypeForMVT(); 375ef12057737229452c17983faa20857dba441ef05Evan Cheng LLVMC = cast<ConstantFP>(ConstantExpr::getFPTrunc(LLVMC, SType)); 376ef12057737229452c17983faa20857dba441ef05Evan Cheng VT = SVT; 377ef12057737229452c17983faa20857dba441ef05Evan Cheng Extend = true; 378ef12057737229452c17983faa20857dba441ef05Evan Cheng } 379004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng } 380004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng 381475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue CPIdx = DAG.getConstantPool(LLVMC, TLI.getPointerTy()); 3821606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned Alignment = cast<ConstantPoolSDNode>(CPIdx)->getAlignment(); 383ef12057737229452c17983faa20857dba441ef05Evan Cheng if (Extend) 38433c960f523f2308482d5b2816af46a7ec90a6d3dDale Johannesen return DAG.getExtLoad(ISD::EXTLOAD, dl, 38539355f9fea790c5a1b12ef0fdcfeac3f533232eaDale Johannesen OrigVT, DAG.getEntryNode(), 3863069b8743769527ce7af6cfb6591a2f0fc2faee4Dan Gohman CPIdx, PseudoSourceValue::getConstantPool(), 38750284d81f863a6576582e1a171a22eb0f012ddf3Dan Gohman 0, VT, false, Alignment); 38833c960f523f2308482d5b2816af46a7ec90a6d3dDale Johannesen return DAG.getLoad(OrigVT, dl, DAG.getEntryNode(), CPIdx, 38950284d81f863a6576582e1a171a22eb0f012ddf3Dan Gohman PseudoSourceValue::getConstantPool(), 0, false, Alignment); 390004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng} 391004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng 392f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio/// ExpandUnalignedStore - Expands an unaligned store to 2 half-size stores. 393f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venanciostatic 394475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue ExpandUnalignedStore(StoreSDNode *ST, SelectionDAG &DAG, 3950d137d7f35fba98f668098b3badf644efacf0e08Dan Gohman const TargetLowering &TLI) { 396475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Chain = ST->getChain(); 397475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ptr = ST->getBasePtr(); 398475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Val = ST->getValue(); 39983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Val.getValueType(); 400907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen int Alignment = ST->getAlignment(); 401907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen int SVOffset = ST->getSrcValueOffset(); 402bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl = ST->getDebugLoc(); 40383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (ST->getMemoryVT().isFloatingPoint() || 40483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands ST->getMemoryVT().isVector()) { 40505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands MVT intVT = MVT::getIntegerVT(VT.getSizeInBits()); 40605e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands if (TLI.isTypeLegal(intVT)) { 40705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Expand to a bitconvert of the value to the integer type of the 40805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // same size, then a (misaligned) int store. 40905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // FIXME: Does not handle truncating floating point stores! 410bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Result = DAG.getNode(ISD::BIT_CONVERT, dl, intVT, Val); 411bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen return DAG.getStore(Chain, dl, Result, Ptr, ST->getSrcValue(), 41205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SVOffset, ST->isVolatile(), Alignment); 41305e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands } else { 41405e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Do a (aligned) store to a stack slot, then copy from the stack slot 41505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // to the final destination using (unaligned) integer loads and stores. 41605e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands MVT StoredVT = ST->getMemoryVT(); 41705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands MVT RegVT = 41805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands TLI.getRegisterType(MVT::getIntegerVT(StoredVT.getSizeInBits())); 41905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands unsigned StoredBytes = StoredVT.getSizeInBits() / 8; 42005e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands unsigned RegBytes = RegVT.getSizeInBits() / 8; 42105e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands unsigned NumRegs = (StoredBytes + RegBytes - 1) / RegBytes; 42205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 423fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands // Make sure the stack slot is also aligned for the register type. 424fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands SDValue StackPtr = DAG.CreateStackTemporary(StoredVT, RegVT); 425fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands 426fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands // Perform the original store, only redirected to the stack slot. 427fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel SDValue Store = DAG.getTruncStore(Chain, dl, 428ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson Val, StackPtr, NULL, 0, StoredVT); 42905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SDValue Increment = DAG.getConstant(RegBytes, TLI.getPointerTy()); 43005e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SmallVector<SDValue, 8> Stores; 43105e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands unsigned Offset = 0; 43205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 43305e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Do all but one copies using the full register width. 43405e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands for (unsigned i = 1; i < NumRegs; i++) { 43505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Load one integer register's worth from the stack slot. 436bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Load = DAG.getLoad(RegVT, dl, Store, StackPtr, NULL, 0); 43705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Store it to the final location. Remember the store. 438bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Stores.push_back(DAG.getStore(Load.getValue(1), dl, Load, Ptr, 43905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands ST->getSrcValue(), SVOffset + Offset, 44005e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands ST->isVolatile(), 44105e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands MinAlign(ST->getAlignment(), Offset))); 44205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Increment the pointers. 44305e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands Offset += RegBytes; 444bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr, 44505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands Increment); 446bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment); 44705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands } 44805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 449fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands // The last store may be partial. Do a truncating store. On big-endian 450fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands // machines this requires an extending load from the stack slot to ensure 451fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands // that the bits are in the right place. 452fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands MVT MemVT = MVT::getIntegerVT(8 * (StoredBytes - Offset)); 453fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands 454fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands // Load from the stack slot. 455bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, RegVT, Store, StackPtr, 456fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands NULL, 0, MemVT); 45705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 458bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Stores.push_back(DAG.getTruncStore(Load.getValue(1), dl, Load, Ptr, 45905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands ST->getSrcValue(), SVOffset + Offset, 460fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands MemVT, ST->isVolatile(), 46105e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands MinAlign(ST->getAlignment(), Offset))); 46205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // The order of the stores doesn't matter - say it with a TokenFactor. 463bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &Stores[0], 46405e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands Stores.size()); 46505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands } 466907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen } 46783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(ST->getMemoryVT().isInteger() && 46883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands !ST->getMemoryVT().isVector() && 469907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen "Unaligned store of unknown type."); 470f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // Get the half-size VT 47183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NewStoredVT = 47283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands (MVT::SimpleValueType)(ST->getMemoryVT().getSimpleVT() - 1); 47383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands int NumBits = NewStoredVT.getSizeInBits(); 474f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio int IncrementSize = NumBits / 8; 475f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 476f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // Divide the stored value in two parts. 477475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue ShiftAmount = DAG.getConstant(NumBits, TLI.getShiftAmountTy()); 478475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Lo = Val; 479bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Hi = DAG.getNode(ISD::SRL, dl, VT, Val, ShiftAmount); 480f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 481f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // Store the two parts 482475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Store1, Store2; 483bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Store1 = DAG.getTruncStore(Chain, dl, TLI.isLittleEndian()?Lo:Hi, Ptr, 484f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio ST->getSrcValue(), SVOffset, NewStoredVT, 485f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio ST->isVolatile(), Alignment); 486bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, 487f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio DAG.getConstant(IncrementSize, TLI.getPointerTy())); 488dc84650679b6330e0fcdd4cf8bc2a351387db7caDuncan Sands Alignment = MinAlign(Alignment, IncrementSize); 489bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Store2 = DAG.getTruncStore(Chain, dl, TLI.isLittleEndian()?Hi:Lo, Ptr, 490f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio ST->getSrcValue(), SVOffset + IncrementSize, 491f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio NewStoredVT, ST->isVolatile(), Alignment); 492f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 493bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Store1, Store2); 494f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio} 495f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 496f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio/// ExpandUnalignedLoad - Expands an unaligned load to 2 half-size loads. 497f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venanciostatic 498475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue ExpandUnalignedLoad(LoadSDNode *LD, SelectionDAG &DAG, 499e9530ecae4897fe8157bd4d7616043bd8c0484e2Dan Gohman const TargetLowering &TLI) { 500f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio int SVOffset = LD->getSrcValueOffset(); 501475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Chain = LD->getChain(); 502475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ptr = LD->getBasePtr(); 50383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = LD->getValueType(0); 50483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT LoadedVT = LD->getMemoryVT(); 505bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl = LD->getDebugLoc(); 50683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (VT.isFloatingPoint() || VT.isVector()) { 50705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands MVT intVT = MVT::getIntegerVT(LoadedVT.getSizeInBits()); 50805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands if (TLI.isTypeLegal(intVT)) { 50905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Expand to a (misaligned) integer load of the same size, 51005e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // then bitconvert to floating point or vector. 511bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue newLoad = DAG.getLoad(intVT, dl, Chain, Ptr, LD->getSrcValue(), 51205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SVOffset, LD->isVolatile(), 513907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen LD->getAlignment()); 514bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Result = DAG.getNode(ISD::BIT_CONVERT, dl, LoadedVT, newLoad); 51505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands if (VT.isFloatingPoint() && LoadedVT != VT) 516bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Result = DAG.getNode(ISD::FP_EXTEND, dl, VT, Result); 517907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen 51805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SDValue Ops[] = { Result, Chain }; 519bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen return DAG.getMergeValues(Ops, 2, dl); 52005e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands } else { 52105e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Copy the value to a (aligned) stack slot using (unaligned) integer 52205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // loads and stores, then do a (aligned) load from the stack slot. 52305e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands MVT RegVT = TLI.getRegisterType(intVT); 52405e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands unsigned LoadedBytes = LoadedVT.getSizeInBits() / 8; 52505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands unsigned RegBytes = RegVT.getSizeInBits() / 8; 52605e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands unsigned NumRegs = (LoadedBytes + RegBytes - 1) / RegBytes; 52705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 528fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands // Make sure the stack slot is also aligned for the register type. 529fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands SDValue StackBase = DAG.CreateStackTemporary(LoadedVT, RegVT); 530fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands 53105e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SDValue Increment = DAG.getConstant(RegBytes, TLI.getPointerTy()); 53205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SmallVector<SDValue, 8> Stores; 53305e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SDValue StackPtr = StackBase; 53405e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands unsigned Offset = 0; 53505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 53605e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Do all but one copies using the full register width. 53705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands for (unsigned i = 1; i < NumRegs; i++) { 53805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Load one integer register's worth from the original location. 539bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Load = DAG.getLoad(RegVT, dl, Chain, Ptr, LD->getSrcValue(), 54005e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SVOffset + Offset, LD->isVolatile(), 54105e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands MinAlign(LD->getAlignment(), Offset)); 54205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Follow the load with a store to the stack slot. Remember the store. 543bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Stores.push_back(DAG.getStore(Load.getValue(1), dl, Load, StackPtr, 54405e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands NULL, 0)); 54505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Increment the pointers. 54605e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands Offset += RegBytes; 547bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment); 548bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr, 54905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands Increment); 55005e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands } 55105e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 55205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // The last copy may be partial. Do an extending load. 553fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands MVT MemVT = MVT::getIntegerVT(8 * (LoadedBytes - Offset)); 554bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, RegVT, Chain, Ptr, 55505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands LD->getSrcValue(), SVOffset + Offset, 556fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands MemVT, LD->isVolatile(), 55705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands MinAlign(LD->getAlignment(), Offset)); 55805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Follow the load with a store to the stack slot. Remember the store. 559fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands // On big-endian machines this requires a truncating store to ensure 560fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands // that the bits end up in the right place. 561bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Stores.push_back(DAG.getTruncStore(Load.getValue(1), dl, Load, StackPtr, 562fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands NULL, 0, MemVT)); 56305e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 56405e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // The order of the stores doesn't matter - say it with a TokenFactor. 565bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &Stores[0], 56605e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands Stores.size()); 56705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 56805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Finally, perform the original load only redirected to the stack slot. 569bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Load = DAG.getExtLoad(LD->getExtensionType(), dl, VT, TF, StackBase, 57005e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands NULL, 0, LoadedVT); 57105e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 57205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Callers expect a MERGE_VALUES node. 57305e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SDValue Ops[] = { Load, TF }; 574bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen return DAG.getMergeValues(Ops, 2, dl); 57505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands } 576907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen } 57783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(LoadedVT.isInteger() && !LoadedVT.isVector() && 578e400af83b3f8b69407a8963f1d2e2c82fa766f33Chris Lattner "Unaligned load of unsupported type."); 579e400af83b3f8b69407a8963f1d2e2c82fa766f33Chris Lattner 5808155d64c2ffab8b17e0fd8e3b7a66fcef6a8ec9dDale Johannesen // Compute the new VT that is half the size of the old one. This is an 5818155d64c2ffab8b17e0fd8e3b7a66fcef6a8ec9dDale Johannesen // integer MVT. 58283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned NumBits = LoadedVT.getSizeInBits(); 58383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NewLoadedVT; 58483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands NewLoadedVT = MVT::getIntegerVT(NumBits/2); 585e400af83b3f8b69407a8963f1d2e2c82fa766f33Chris Lattner NumBits >>= 1; 586fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 587e400af83b3f8b69407a8963f1d2e2c82fa766f33Chris Lattner unsigned Alignment = LD->getAlignment(); 588e400af83b3f8b69407a8963f1d2e2c82fa766f33Chris Lattner unsigned IncrementSize = NumBits / 8; 589f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio ISD::LoadExtType HiExtType = LD->getExtensionType(); 590f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 591f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // If the original load is NON_EXTLOAD, the hi part load must be ZEXTLOAD. 592f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio if (HiExtType == ISD::NON_EXTLOAD) 593f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio HiExtType = ISD::ZEXTLOAD; 594f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 595f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // Load the value in two parts 596475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Lo, Hi; 597f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio if (TLI.isLittleEndian()) { 598bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, VT, Chain, Ptr, LD->getSrcValue(), 599f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio SVOffset, NewLoadedVT, LD->isVolatile(), Alignment); 600bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, 601f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio DAG.getConstant(IncrementSize, TLI.getPointerTy())); 602bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Hi = DAG.getExtLoad(HiExtType, dl, VT, Chain, Ptr, LD->getSrcValue(), 603f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio SVOffset + IncrementSize, NewLoadedVT, LD->isVolatile(), 604dc84650679b6330e0fcdd4cf8bc2a351387db7caDuncan Sands MinAlign(Alignment, IncrementSize)); 605f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } else { 606bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Hi = DAG.getExtLoad(HiExtType, dl, VT, Chain, Ptr, LD->getSrcValue(), 607ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson SVOffset, NewLoadedVT, LD->isVolatile(), Alignment); 608bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, 609f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio DAG.getConstant(IncrementSize, TLI.getPointerTy())); 610bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, VT, Chain, Ptr, LD->getSrcValue(), 611f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio SVOffset + IncrementSize, NewLoadedVT, LD->isVolatile(), 612dc84650679b6330e0fcdd4cf8bc2a351387db7caDuncan Sands MinAlign(Alignment, IncrementSize)); 613f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 614f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 615f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // aggregate the two parts 616475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue ShiftAmount = DAG.getConstant(NumBits, TLI.getShiftAmountTy()); 617bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Result = DAG.getNode(ISD::SHL, dl, VT, Hi, ShiftAmount); 618bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Result = DAG.getNode(ISD::OR, dl, VT, Result, Lo); 619f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 620bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1), 621f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio Hi.getValue(1)); 622f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 623475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Result, TF }; 624bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen return DAG.getMergeValues(Ops, 2, dl); 625f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio} 626912095becac923ff614d7b07728eb345ada67765Evan Cheng 627007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands/// GetFPLibCall - Return the right libcall for the given floating point type. 62883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sandsstatic RTLIB::Libcall GetFPLibCall(MVT VT, 629007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands RTLIB::Libcall Call_F32, 630007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands RTLIB::Libcall Call_F64, 631007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands RTLIB::Libcall Call_F80, 632007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands RTLIB::Libcall Call_PPCF128) { 633007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands return 634007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands VT == MVT::f32 ? Call_F32 : 635007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands VT == MVT::f64 ? Call_F64 : 636007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands VT == MVT::f80 ? Call_F80 : 637007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands VT == MVT::ppcf128 ? Call_PPCF128 : 638007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands RTLIB::UNKNOWN_LIBCALL; 639007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands} 640007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands 6416867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman/// PerformInsertVectorEltInMemory - Some target cannot handle a variable 6426867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman/// insertion index for the INSERT_VECTOR_ELT instruction. In this case, it 6436867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman/// is necessary to spill the vector being inserted into to memory, perform 6446867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman/// the insert there, and then read the result back. 645475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize:: 646bb5da918545efb54857a09c983a5a7f22a7e04d4Dale JohannesenPerformInsertVectorEltInMemory(SDValue Vec, SDValue Val, SDValue Idx, 647bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl) { 648475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp1 = Vec; 649475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp2 = Val; 650475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp3 = Idx; 651fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 6526867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // If the target doesn't support this, we have to spill the input vector 6536867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // to a temporary stack slot, update the element, then reload it. This is 6546867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // badness. We could also load the value into a vector register (either 6556867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // with a "move to register" or "extload into register" instruction, then 6566867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // permute it into place, if the idx is a constant and if the idx is 6576867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // supported by the target. 65883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Tmp1.getValueType(); 65983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT EltVT = VT.getVectorElementType(); 66083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT IdxVT = Tmp3.getValueType(); 66183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT PtrVT = TLI.getPointerTy(); 662475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue StackPtr = DAG.CreateStackTemporary(VT); 6636867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman 664ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex(); 6656867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman 6666867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // Store the vector. 667bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, Tmp1, StackPtr, 6680c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang PseudoSourceValue::getFixedStack(SPFI), 0); 6696867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman 6706867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // Truncate or zero extend offset to target pointer type. 6718e4eb09b1e3571965f49edcdfb56b1375b1b7551Duncan Sands unsigned CastOpc = IdxVT.bitsGT(PtrVT) ? ISD::TRUNCATE : ISD::ZERO_EXTEND; 672bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Tmp3 = DAG.getNode(CastOpc, dl, PtrVT, Tmp3); 6736867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // Add the offset to the index. 67483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned EltSize = EltVT.getSizeInBits()/8; 675bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Tmp3 = DAG.getNode(ISD::MUL, dl, IdxVT, Tmp3,DAG.getConstant(EltSize, IdxVT)); 676bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue StackPtr2 = DAG.getNode(ISD::ADD, dl, IdxVT, Tmp3, StackPtr); 6776867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // Store the scalar value. 678bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Ch = DAG.getTruncStore(Ch, dl, Tmp2, StackPtr2, 679a54cf176613f9ae8301519a61b8935652c0fb8aeDan Gohman PseudoSourceValue::getFixedStack(SPFI), 0, EltVT); 6806867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // Load the updated vector. 681bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen return DAG.getLoad(VT, dl, Ch, StackPtr, 682a54cf176613f9ae8301519a61b8935652c0fb8aeDan Gohman PseudoSourceValue::getFixedStack(SPFI), 0); 6836867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman} 6846867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman 685e9f1015d1f184a51aaadfd03be0846bd5e7d08a2Mon P Wang 686a346615d11f0a560c6e7280c1e614301d9f93051Dan Gohman/// LegalizeOp - We know that the specified value has a legal type, and 687a346615d11f0a560c6e7280c1e614301d9f93051Dan Gohman/// that its operands are legal. Now ensure that the operation itself 688a346615d11f0a560c6e7280c1e614301d9f93051Dan Gohman/// is legal, recursively ensuring that the operands' operations remain 689a346615d11f0a560c6e7280c1e614301d9f93051Dan Gohman/// legal. 690475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::LegalizeOp(SDValue Op) { 69109ec1b058331aadb29a348091611d23892b5c492Chris Lattner if (Op.getOpcode() == ISD::TargetConstant) // Allow illegal target nodes. 69209ec1b058331aadb29a348091611d23892b5c492Chris Lattner return Op; 693fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 694ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif SDNode *Node = Op.getNode(); 6957d2ad624fa749a6d3edac0d94e9c107989c16304Dale Johannesen DebugLoc dl = Node->getDebugLoc(); 696e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner 6971fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 6981fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman assert(getTypeAction(Node->getValueType(i)) == Legal && 6991fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman "Unexpected illegal type!"); 7001fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman 7011fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) 7021fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman assert((isTypeLegal(Node->getOperand(i).getValueType()) || 7031fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman Node->getOperand(i).getOpcode() == ISD::TargetConstant) && 7041fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman "Unexpected illegal type!"); 7053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 70645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 70745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 708475871a144eb604ddaf37503397ba0941442e5fbDan Gohman DenseMap<SDValue, SDValue>::iterator I = LegalizedNodes.find(Op); 709e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (I != LegalizedNodes.end()) return I->second; 7103e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 711475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp1, Tmp2, Tmp3, Tmp4; 712475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Result = Op; 713456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner bool isCustom = false; 714fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 7153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 716948c1b1cda280c6428dbeaa03a6c2c559dbb93f4Chris Lattner case ISD::FrameIndex: 717948c1b1cda280c6428dbeaa03a6c2c559dbb93f4Chris Lattner case ISD::EntryToken: 718948c1b1cda280c6428dbeaa03a6c2c559dbb93f4Chris Lattner case ISD::Register: 719948c1b1cda280c6428dbeaa03a6c2c559dbb93f4Chris Lattner case ISD::BasicBlock: 720948c1b1cda280c6428dbeaa03a6c2c559dbb93f4Chris Lattner case ISD::TargetFrameIndex: 72137efe6764568a3829fee26aba532283131d1a104Nate Begeman case ISD::TargetJumpTable: 722948c1b1cda280c6428dbeaa03a6c2c559dbb93f4Chris Lattner case ISD::TargetConstant: 7233181a771ff5b2090b7ed55f9b18a684ea8fe625aChris Lattner case ISD::TargetConstantFP: 724948c1b1cda280c6428dbeaa03a6c2c559dbb93f4Chris Lattner case ISD::TargetConstantPool: 725948c1b1cda280c6428dbeaa03a6c2c559dbb93f4Chris Lattner case ISD::TargetGlobalAddress: 726b3a0417cad8b625acc3033bd5e24afb9ffd0b084Lauro Ramos Venancio case ISD::TargetGlobalTLSAddress: 727056292fd738924f3f7703725d8f630983794b5a5Bill Wendling case ISD::TargetExternalSymbol: 728948c1b1cda280c6428dbeaa03a6c2c559dbb93f4Chris Lattner case ISD::VALUETYPE: 729948c1b1cda280c6428dbeaa03a6c2c559dbb93f4Chris Lattner case ISD::SRCVALUE: 73069de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman case ISD::MEMOPERAND: 731948c1b1cda280c6428dbeaa03a6c2c559dbb93f4Chris Lattner case ISD::CONDCODE: 732276dcbdc8db6614cfd5004dc7dc35e437ddf9c58Duncan Sands case ISD::ARG_FLAGS: 733948c1b1cda280c6428dbeaa03a6c2c559dbb93f4Chris Lattner // Primitives must all be legal. 734a7c97a7f5b82778ca5abfc3791c6b7f96b82a5faDuncan Sands assert(TLI.isOperationLegal(Node->getOpcode(), Node->getValueType(0)) && 735948c1b1cda280c6428dbeaa03a6c2c559dbb93f4Chris Lattner "This must be legal!"); 736948c1b1cda280c6428dbeaa03a6c2c559dbb93f4Chris Lattner break; 7373e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 738d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Node->getOpcode() >= ISD::BUILTIN_OP_END) { 739d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // If this is a target node, legalize it by legalizing the operands then 740d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // passing it through. 741475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 8> Ops; 742c5d7d7c715f7b7a4eeea1ceaafefc3d1d6df2addChris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) 743d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 744c5d7d7c715f7b7a4eeea1ceaafefc3d1d6df2addChris Lattner 745e3e51c0038bd6ba2add82e2246e97edec0ab2204Jay Foad Result = DAG.UpdateNodeOperands(Result.getValue(0), Ops.data(), Ops.size()); 746d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner 747d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 748d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner AddLegalizedOperand(Op.getValue(i), Result.getValue(i)); 74999a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Result.getValue(Op.getResNo()); 750d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 751d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner // Otherwise this is an unhandled builtin node. splat. 752e37fe9b3a1cadceb42ac27fa0718f5a10ea2f0e6Jim Laskey#ifndef NDEBUG 75339833585556a69de12053ca1e104fe7edfd86cbdDan Gohman cerr << "NODE: "; Node->dump(&DAG); cerr << "\n"; 754e37fe9b3a1cadceb42ac27fa0718f5a10ea2f0e6Jim Laskey#endif 7553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to legalize this operator!"); 7563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 7570d3b67809ccab229a03db8c1bede852fb89eb081Lauro Ramos Venancio case ISD::GLOBAL_OFFSET_TABLE: 7583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::GlobalAddress: 759b3a0417cad8b625acc3033bd5e24afb9ffd0b084Lauro Ramos Venancio case ISD::GlobalTLSAddress: 760056292fd738924f3f7703725d8f630983794b5a5Bill Wendling case ISD::ExternalSymbol: 76137efe6764568a3829fee26aba532283131d1a104Nate Begeman case ISD::ConstantPool: 76237efe6764568a3829fee26aba532283131d1a104Nate Begeman case ISD::JumpTable: // Nothing to do. 7630c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 7640c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner default: assert(0 && "This action is not supported yet!"); 765948c1b1cda280c6428dbeaa03a6c2c559dbb93f4Chris Lattner case TargetLowering::Custom: 766948c1b1cda280c6428dbeaa03a6c2c559dbb93f4Chris Lattner Tmp1 = TLI.LowerOperation(Op, DAG); 767ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 768948c1b1cda280c6428dbeaa03a6c2c559dbb93f4Chris Lattner // FALLTHROUGH if the target doesn't want to lower this op after all. 7690c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner case TargetLowering::Legal: 7700c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner break; 7710c8fbe33a4bdf7c60e0cfd5a9c86499c817d9f1aChris Lattner } 7723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 773bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman case ISD::FRAMEADDR: 774bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman case ISD::RETURNADDR: 775bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman // The only option for these nodes is to custom lower them. If the target 776bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman // does not custom lower them, then return zero. 777bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman Tmp1 = TLI.LowerOperation(Op, DAG); 778fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel if (Tmp1.getNode()) 779bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman Result = Tmp1; 780bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman else 781bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman Result = DAG.getConstant(0, TLI.getPointerTy()); 782bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman break; 783055c5449a4046a5e1a5210d2f91aee4e3901cccfAnton Korobeynikov case ISD::FRAME_TO_ARGS_OFFSET: { 78483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 785066f7b40f8c442dfd52cdbc371a5f6c623d5ba90Anton Korobeynikov switch (TLI.getOperationAction(Node->getOpcode(), VT)) { 786066f7b40f8c442dfd52cdbc371a5f6c623d5ba90Anton Korobeynikov default: assert(0 && "This action is not supported yet!"); 787066f7b40f8c442dfd52cdbc371a5f6c623d5ba90Anton Korobeynikov case TargetLowering::Custom: 788066f7b40f8c442dfd52cdbc371a5f6c623d5ba90Anton Korobeynikov Result = TLI.LowerOperation(Op, DAG); 789ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Result.getNode()) break; 790066f7b40f8c442dfd52cdbc371a5f6c623d5ba90Anton Korobeynikov // Fall Thru 791066f7b40f8c442dfd52cdbc371a5f6c623d5ba90Anton Korobeynikov case TargetLowering::Legal: 792066f7b40f8c442dfd52cdbc371a5f6c623d5ba90Anton Korobeynikov Result = DAG.getConstant(0, VT); 793066f7b40f8c442dfd52cdbc371a5f6c623d5ba90Anton Korobeynikov break; 794066f7b40f8c442dfd52cdbc371a5f6c623d5ba90Anton Korobeynikov } 795055c5449a4046a5e1a5210d2f91aee4e3901cccfAnton Korobeynikov } 796066f7b40f8c442dfd52cdbc371a5f6c623d5ba90Anton Korobeynikov break; 7972bc210d99f5a7322a1ae84775eba351d9ab6ea85Jim Laskey case ISD::EXCEPTIONADDR: { 7982bc210d99f5a7322a1ae84775eba351d9ab6ea85Jim Laskey Tmp1 = LegalizeOp(Node->getOperand(0)); 79983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 8002bc210d99f5a7322a1ae84775eba351d9ab6ea85Jim Laskey switch (TLI.getOperationAction(Node->getOpcode(), VT)) { 8012bc210d99f5a7322a1ae84775eba351d9ab6ea85Jim Laskey default: assert(0 && "This action is not supported yet!"); 8022bc210d99f5a7322a1ae84775eba351d9ab6ea85Jim Laskey case TargetLowering::Expand: { 8038782d481a3c720304540254a7b71d25bbe7cbf49Jim Laskey unsigned Reg = TLI.getExceptionAddressRegister(); 804c460ae90019ddb19d4c07b2cd2fbaecfa7adf67dDale Johannesen Result = DAG.getCopyFromReg(Tmp1, dl, Reg, VT); 8052bc210d99f5a7322a1ae84775eba351d9ab6ea85Jim Laskey } 8062bc210d99f5a7322a1ae84775eba351d9ab6ea85Jim Laskey break; 8072bc210d99f5a7322a1ae84775eba351d9ab6ea85Jim Laskey case TargetLowering::Custom: 8082bc210d99f5a7322a1ae84775eba351d9ab6ea85Jim Laskey Result = TLI.LowerOperation(Op, DAG); 809ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Result.getNode()) break; 8102bc210d99f5a7322a1ae84775eba351d9ab6ea85Jim Laskey // Fall Thru 811eb7f34f2cb1584f155b9cefdb246b300fb2fc9c4Chris Lattner case TargetLowering::Legal: { 812475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { DAG.getConstant(0, VT), Tmp1 }; 813ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getMergeValues(Ops, 2, dl); 8148782d481a3c720304540254a7b71d25bbe7cbf49Jim Laskey break; 8158782d481a3c720304540254a7b71d25bbe7cbf49Jim Laskey } 8168782d481a3c720304540254a7b71d25bbe7cbf49Jim Laskey } 817eb7f34f2cb1584f155b9cefdb246b300fb2fc9c4Chris Lattner } 818ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Result.getNode()->getNumValues() == 1) break; 819b027fa001f16660a231a54ecea6a79f5c7855d7cDuncan Sands 820ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif assert(Result.getNode()->getNumValues() == 2 && 821b027fa001f16660a231a54ecea6a79f5c7855d7cDuncan Sands "Cannot return more than two values!"); 822b027fa001f16660a231a54ecea6a79f5c7855d7cDuncan Sands 823b027fa001f16660a231a54ecea6a79f5c7855d7cDuncan Sands // Since we produced two values, make sure to remember that we 824b027fa001f16660a231a54ecea6a79f5c7855d7cDuncan Sands // legalized both of them. 825b027fa001f16660a231a54ecea6a79f5c7855d7cDuncan Sands Tmp1 = LegalizeOp(Result); 826b027fa001f16660a231a54ecea6a79f5c7855d7cDuncan Sands Tmp2 = LegalizeOp(Result.getValue(1)); 827b027fa001f16660a231a54ecea6a79f5c7855d7cDuncan Sands AddLegalizedOperand(Op.getValue(0), Tmp1); 828b027fa001f16660a231a54ecea6a79f5c7855d7cDuncan Sands AddLegalizedOperand(Op.getValue(1), Tmp2); 82999a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Op.getResNo() ? Tmp2 : Tmp1; 8308782d481a3c720304540254a7b71d25bbe7cbf49Jim Laskey case ISD::EHSELECTION: { 8318782d481a3c720304540254a7b71d25bbe7cbf49Jim Laskey Tmp1 = LegalizeOp(Node->getOperand(0)); 8328782d481a3c720304540254a7b71d25bbe7cbf49Jim Laskey Tmp2 = LegalizeOp(Node->getOperand(1)); 83383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 8348782d481a3c720304540254a7b71d25bbe7cbf49Jim Laskey switch (TLI.getOperationAction(Node->getOpcode(), VT)) { 8358782d481a3c720304540254a7b71d25bbe7cbf49Jim Laskey default: assert(0 && "This action is not supported yet!"); 8368782d481a3c720304540254a7b71d25bbe7cbf49Jim Laskey case TargetLowering::Expand: { 8378782d481a3c720304540254a7b71d25bbe7cbf49Jim Laskey unsigned Reg = TLI.getExceptionSelectorRegister(); 838c460ae90019ddb19d4c07b2cd2fbaecfa7adf67dDale Johannesen Result = DAG.getCopyFromReg(Tmp2, dl, Reg, VT); 8398782d481a3c720304540254a7b71d25bbe7cbf49Jim Laskey } 8408782d481a3c720304540254a7b71d25bbe7cbf49Jim Laskey break; 8418782d481a3c720304540254a7b71d25bbe7cbf49Jim Laskey case TargetLowering::Custom: 8428782d481a3c720304540254a7b71d25bbe7cbf49Jim Laskey Result = TLI.LowerOperation(Op, DAG); 843ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Result.getNode()) break; 8448782d481a3c720304540254a7b71d25bbe7cbf49Jim Laskey // Fall Thru 845eb7f34f2cb1584f155b9cefdb246b300fb2fc9c4Chris Lattner case TargetLowering::Legal: { 846475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { DAG.getConstant(0, VT), Tmp2 }; 847ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getMergeValues(Ops, 2, dl); 8482bc210d99f5a7322a1ae84775eba351d9ab6ea85Jim Laskey break; 8492bc210d99f5a7322a1ae84775eba351d9ab6ea85Jim Laskey } 8502bc210d99f5a7322a1ae84775eba351d9ab6ea85Jim Laskey } 851eb7f34f2cb1584f155b9cefdb246b300fb2fc9c4Chris Lattner } 852ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Result.getNode()->getNumValues() == 1) break; 853b027fa001f16660a231a54ecea6a79f5c7855d7cDuncan Sands 854ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif assert(Result.getNode()->getNumValues() == 2 && 855b027fa001f16660a231a54ecea6a79f5c7855d7cDuncan Sands "Cannot return more than two values!"); 856b027fa001f16660a231a54ecea6a79f5c7855d7cDuncan Sands 857b027fa001f16660a231a54ecea6a79f5c7855d7cDuncan Sands // Since we produced two values, make sure to remember that we 858b027fa001f16660a231a54ecea6a79f5c7855d7cDuncan Sands // legalized both of them. 859b027fa001f16660a231a54ecea6a79f5c7855d7cDuncan Sands Tmp1 = LegalizeOp(Result); 860b027fa001f16660a231a54ecea6a79f5c7855d7cDuncan Sands Tmp2 = LegalizeOp(Result.getValue(1)); 861b027fa001f16660a231a54ecea6a79f5c7855d7cDuncan Sands AddLegalizedOperand(Op.getValue(0), Tmp1); 862b027fa001f16660a231a54ecea6a79f5c7855d7cDuncan Sands AddLegalizedOperand(Op.getValue(1), Tmp2); 86399a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Op.getResNo() ? Tmp2 : Tmp1; 8646d4b711e7f2e27d94d3c49dc9e7575dbe0f242e0Nick Lewycky case ISD::EH_RETURN: { 86583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 8662365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov // The only "good" option for this node is to custom lower it. 8672365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov switch (TLI.getOperationAction(Node->getOpcode(), VT)) { 8682365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov default: assert(0 && "This action is not supported at all!"); 8692365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov case TargetLowering::Custom: 8702365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov Result = TLI.LowerOperation(Op, DAG); 871ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Result.getNode()) break; 8722365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov // Fall Thru 8732365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov case TargetLowering::Legal: 8742365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov // Target does not know, how to lower this, lower to noop 8752365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov Result = LegalizeOp(Node->getOperand(0)); 8762365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov break; 8772365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov } 8786d4b711e7f2e27d94d3c49dc9e7575dbe0f242e0Nick Lewycky } 8792365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov break; 88008951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner case ISD::AssertSext: 88108951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner case ISD::AssertZext: 88208951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 883c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1)); 88408951a32fbc1de3ec3746e14109a74ca506ca251Chris Lattner break; 885308575be66ec3870d27b19df044fda18448feb41Chris Lattner case ISD::MERGE_VALUES: 886c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner // Legalize eliminates MERGE_VALUES nodes. 88799a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif Result = Node->getOperand(Op.getResNo()); 888456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner break; 88969a52155d2eff066b49dbac385113002fd9dba14Chris Lattner case ISD::CopyFromReg: 89069a52155d2eff066b49dbac385113002fd9dba14Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 8917310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner Result = Op.getValue(0); 892f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner if (Node->getNumValues() == 2) { 893c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1)); 8947310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner } else { 895f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner assert(Node->getNumValues() == 3 && "Invalid copyfromreg!"); 896c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner if (Node->getNumOperands() == 3) { 897f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); 898c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1),Tmp2); 899c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner } else { 900c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1)); 901c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner } 9027310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner AddLegalizedOperand(Op.getValue(2), Result.getValue(2)); 9037310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner } 90413c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // Since CopyFromReg produces two values, make sure to remember that we 90513c184de29c09294ed63b01ac43e1b46c049278eChris Lattner // legalized both of them. 90613c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(0), Result); 90713c184de29c09294ed63b01ac43e1b46c049278eChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 90899a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Result.getValue(Op.getResNo()); 909fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman case ISD::UNDEF: { 91083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Op.getValueType(); 911fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman switch (TLI.getOperationAction(ISD::UNDEF, VT)) { 912ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman default: assert(0 && "This action is not supported yet!"); 913ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Expand: 91483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (VT.isInteger()) 915fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman Result = DAG.getConstant(0, VT); 91683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands else if (VT.isFloatingPoint()) 91783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands Result = DAG.getConstantFP(APFloat(APInt(VT.getSizeInBits(), 0)), 918f41db2136fe50e1a92aabfcb3ba1ec1f70f5f0d5Dale Johannesen VT); 919fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman else 920fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman assert(0 && "Unknown value type!"); 921fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 922ea19cd51aaf87c5cc19e7cdc2c32ddbefcac7b8fNate Begeman case TargetLowering::Legal: 923fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 924fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 925fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman break; 926fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman } 927fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 92848b61a729df6576c8833a83893d4086bddff69a5Chris Lattner case ISD::INTRINSIC_W_CHAIN: 92948b61a729df6576c8833a83893d4086bddff69a5Chris Lattner case ISD::INTRINSIC_WO_CHAIN: 93048b61a729df6576c8833a83893d4086bddff69a5Chris Lattner case ISD::INTRINSIC_VOID: { 931475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 8> Ops; 932d1f04d40a078d6ca7c876b16a178992a109af774Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) 933d1f04d40a078d6ca7c876b16a178992a109af774Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 934f06f35e30b4c4d7db304f717a3d4dc6595fbd078Chris Lattner Result = DAG.UpdateNodeOperands(Result, &Ops[0], Ops.size()); 935fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 93610d7fa62fffbceed580c34a00bd30f16643f6607Chris Lattner // Allow the target to custom lower its intrinsics if it wants to. 937fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel if (TLI.getOperationAction(Node->getOpcode(), MVT::Other) == 93810d7fa62fffbceed580c34a00bd30f16643f6607Chris Lattner TargetLowering::Custom) { 93910d7fa62fffbceed580c34a00bd30f16643f6607Chris Lattner Tmp3 = TLI.LowerOperation(Result, DAG); 940ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp3.getNode()) Result = Tmp3; 94113fc2f1d270cdedffb72b33621369cee9a2cdaaaChris Lattner } 94213fc2f1d270cdedffb72b33621369cee9a2cdaaaChris Lattner 943ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Result.getNode()->getNumValues() == 1) break; 94413fc2f1d270cdedffb72b33621369cee9a2cdaaaChris Lattner 94513fc2f1d270cdedffb72b33621369cee9a2cdaaaChris Lattner // Must have return value and chain result. 946ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif assert(Result.getNode()->getNumValues() == 2 && 94713fc2f1d270cdedffb72b33621369cee9a2cdaaaChris Lattner "Cannot return more than two values!"); 94813fc2f1d270cdedffb72b33621369cee9a2cdaaaChris Lattner 949fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // Since loads produce two values, make sure to remember that we 95013fc2f1d270cdedffb72b33621369cee9a2cdaaaChris Lattner // legalized both of them. 951475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 0), Result.getValue(0)); 952475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 1), Result.getValue(1)); 95399a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Result.getValue(Op.getResNo()); 954fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel } 95536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 9567f460203b0c5350e9b2c592f438e40f7a7de6e45Dan Gohman case ISD::DBG_STOPPOINT: 9577f460203b0c5350e9b2c592f438e40f7a7de6e45Dan Gohman assert(Node->getNumOperands() == 1 && "Invalid DBG_STOPPOINT node!"); 95836ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the input chain. 959fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 9607f460203b0c5350e9b2c592f438e40f7a7de6e45Dan Gohman switch (TLI.getOperationAction(ISD::DBG_STOPPOINT, MVT::Other)) { 96136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case TargetLowering::Promote: 96236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner default: assert(0 && "This action is not supported yet!"); 96392c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling case TargetLowering::Expand: { 96492c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling DwarfWriter *DW = DAG.getDwarfWriter(); 96592c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling bool useDEBUG_LOC = TLI.isOperationLegalOrCustom(ISD::DEBUG_LOC, 96692c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling MVT::Other); 96792c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling bool useLABEL = TLI.isOperationLegalOrCustom(ISD::DBG_LABEL, MVT::Other); 968fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 96992c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling const DbgStopPointSDNode *DSP = cast<DbgStopPointSDNode>(Node); 97092c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling GlobalVariable *CU_GV = cast<GlobalVariable>(DSP->getCompileUnit()); 97192c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling if (DW && (useDEBUG_LOC || useLABEL) && !CU_GV->isDeclaration()) { 97292c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling DICompileUnit CU(cast<GlobalVariable>(DSP->getCompileUnit())); 973fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 97492c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling unsigned Line = DSP->getLine(); 97592c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling unsigned Col = DSP->getColumn(); 97686e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling 97798a366d547772010e94609e4584489b3e5ce0043Bill Wendling if (OptLevel == CodeGenOpt::None) { 97886e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling // A bit self-referential to have DebugLoc on Debug_Loc nodes, but it 97986e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling // won't hurt anything. 98086e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling if (useDEBUG_LOC) { 98186e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling SDValue Ops[] = { Tmp1, DAG.getConstant(Line, MVT::i32), 98292c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling DAG.getConstant(Col, MVT::i32), 983a26eae64ddf607549f9e47046d46ea5b9ec648b4Argyrios Kyrtzidis DAG.getSrcValue(CU.getGV()) }; 98486e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling Result = DAG.getNode(ISD::DEBUG_LOC, dl, MVT::Other, Ops, 4); 98586e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling } else { 986a26eae64ddf607549f9e47046d46ea5b9ec648b4Argyrios Kyrtzidis unsigned ID = DW->RecordSourceLine(Line, Col, CU); 98786e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling Result = DAG.getLabel(ISD::DBG_LABEL, dl, Tmp1, ID); 98886e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling } 98992c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } else { 99086e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling Result = Tmp1; // chain 99192c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 99292c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } else { 99392c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling Result = Tmp1; // chain 99492c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 99536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner break; 99692c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 9975274a4afb720858bf1ab927fc90068f1a8f12eb2Sanjiv Gupta case TargetLowering::Custom: 9985274a4afb720858bf1ab927fc90068f1a8f12eb2Sanjiv Gupta Result = TLI.LowerOperation(Op, DAG); 999ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson if (Result.getNode()) 10005274a4afb720858bf1ab927fc90068f1a8f12eb2Sanjiv Gupta break; 100171e8685633e7938ee752004cceedccbd0d850527Evan Cheng case TargetLowering::Legal: { 100274807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman if (Tmp1 == Node->getOperand(0)) 100371e8685633e7938ee752004cceedccbd0d850527Evan Cheng break; 100471e8685633e7938ee752004cceedccbd0d850527Evan Cheng 1005475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 8> Ops; 100671e8685633e7938ee752004cceedccbd0d850527Evan Cheng Ops.push_back(Tmp1); 100774807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman Ops.push_back(Node->getOperand(1)); // line # must be legal. 100874807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman Ops.push_back(Node->getOperand(2)); // col # must be legal. 100971e8685633e7938ee752004cceedccbd0d850527Evan Cheng Ops.push_back(Node->getOperand(3)); // filename must be legal. 101071e8685633e7938ee752004cceedccbd0d850527Evan Cheng Ops.push_back(Node->getOperand(4)); // working dir # must be legal. 101171e8685633e7938ee752004cceedccbd0d850527Evan Cheng Result = DAG.UpdateNodeOperands(Result, &Ops[0], Ops.size()); 101236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner break; 101336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 101471e8685633e7938ee752004cceedccbd0d850527Evan Cheng } 101536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner break; 1016a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng 1017a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng case ISD::DECLARE: 1018a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng assert(Node->getNumOperands() == 3 && "Invalid DECLARE node!"); 1019a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng switch (TLI.getOperationAction(ISD::DECLARE, MVT::Other)) { 1020a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng default: assert(0 && "This action is not supported yet!"); 1021a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng case TargetLowering::Legal: 1022a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 1023a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the address. 1024a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the variable. 1025a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3); 1026a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng break; 1027e07415d4006b923ed1d2057ffa5a493353e28f9eChris Lattner case TargetLowering::Expand: 1028e07415d4006b923ed1d2057ffa5a493353e28f9eChris Lattner Result = LegalizeOp(Node->getOperand(0)); 1029e07415d4006b923ed1d2057ffa5a493353e28f9eChris Lattner break; 1030a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng } 1031fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel break; 1032fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1033f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey case ISD::DEBUG_LOC: 1034abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey assert(Node->getNumOperands() == 4 && "Invalid DEBUG_LOC node!"); 1035f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey switch (TLI.getOperationAction(ISD::DEBUG_LOC, MVT::Other)) { 1036f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey default: assert(0 && "This action is not supported yet!"); 103771e8685633e7938ee752004cceedccbd0d850527Evan Cheng case TargetLowering::Legal: { 1038abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 1039957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman if (Tmp1 == Node->getOperand(0)) 104071e8685633e7938ee752004cceedccbd0d850527Evan Cheng break; 1041957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp2 = Node->getOperand(1); 1042957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp3 = Node->getOperand(2); 1043957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp4 = Node->getOperand(3); 1044c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3, Tmp4); 1045abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey break; 1046abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey } 104771e8685633e7938ee752004cceedccbd0d850527Evan Cheng } 1048fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel break; 1049abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey 10504406604047423576e36657c7ede266ca42e79642Dan Gohman case ISD::DBG_LABEL: 10514406604047423576e36657c7ede266ca42e79642Dan Gohman case ISD::EH_LABEL: 10524406604047423576e36657c7ede266ca42e79642Dan Gohman assert(Node->getNumOperands() == 1 && "Invalid LABEL node!"); 10534406604047423576e36657c7ede266ca42e79642Dan Gohman switch (TLI.getOperationAction(Node->getOpcode(), MVT::Other)) { 1054abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey default: assert(0 && "This action is not supported yet!"); 1055abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey case TargetLowering::Legal: 1056abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 10574406604047423576e36657c7ede266ca42e79642Dan Gohman Result = DAG.UpdateNodeOperands(Result, Tmp1); 1058f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey break; 1059a9569f10de686119ff34b89e102b5a3cbafdf195Chris Lattner case TargetLowering::Expand: 1060a9569f10de686119ff34b89e102b5a3cbafdf195Chris Lattner Result = LegalizeOp(Node->getOperand(0)); 1061a9569f10de686119ff34b89e102b5a3cbafdf195Chris Lattner break; 1062f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey } 1063551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman break; 106436ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 106527b7db549e4c5bff4579d209304de5628513edebEvan Cheng case ISD::PREFETCH: 106627b7db549e4c5bff4579d209304de5628513edebEvan Cheng assert(Node->getNumOperands() == 4 && "Invalid Prefetch node!"); 106727b7db549e4c5bff4579d209304de5628513edebEvan Cheng switch (TLI.getOperationAction(ISD::PREFETCH, MVT::Other)) { 106827b7db549e4c5bff4579d209304de5628513edebEvan Cheng default: assert(0 && "This action is not supported yet!"); 106927b7db549e4c5bff4579d209304de5628513edebEvan Cheng case TargetLowering::Legal: 107027b7db549e4c5bff4579d209304de5628513edebEvan Cheng Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 107127b7db549e4c5bff4579d209304de5628513edebEvan Cheng Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the address. 107227b7db549e4c5bff4579d209304de5628513edebEvan Cheng Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the rw specifier. 107327b7db549e4c5bff4579d209304de5628513edebEvan Cheng Tmp4 = LegalizeOp(Node->getOperand(3)); // Legalize locality specifier. 107427b7db549e4c5bff4579d209304de5628513edebEvan Cheng Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3, Tmp4); 107527b7db549e4c5bff4579d209304de5628513edebEvan Cheng break; 107627b7db549e4c5bff4579d209304de5628513edebEvan Cheng case TargetLowering::Expand: 107727b7db549e4c5bff4579d209304de5628513edebEvan Cheng // It's a noop. 107827b7db549e4c5bff4579d209304de5628513edebEvan Cheng Result = LegalizeOp(Node->getOperand(0)); 107927b7db549e4c5bff4579d209304de5628513edebEvan Cheng break; 108027b7db549e4c5bff4579d209304de5628513edebEvan Cheng } 108127b7db549e4c5bff4579d209304de5628513edebEvan Cheng break; 108227b7db549e4c5bff4579d209304de5628513edebEvan Cheng 108322c5c1b2dfcb1da6a7ebfebea903401fc77d56e6Andrew Lenharth case ISD::MEMBARRIER: { 108422c5c1b2dfcb1da6a7ebfebea903401fc77d56e6Andrew Lenharth assert(Node->getNumOperands() == 6 && "Invalid MemBarrier node!"); 1085d497d9fab6e90499c703f3e672ec001dbfa074f9Andrew Lenharth switch (TLI.getOperationAction(ISD::MEMBARRIER, MVT::Other)) { 1086d497d9fab6e90499c703f3e672ec001dbfa074f9Andrew Lenharth default: assert(0 && "This action is not supported yet!"); 1087d497d9fab6e90499c703f3e672ec001dbfa074f9Andrew Lenharth case TargetLowering::Legal: { 1088475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[6]; 1089d497d9fab6e90499c703f3e672ec001dbfa074f9Andrew Lenharth Ops[0] = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 1090e90a615f37aaee2ad9259c0ef21586d5e4142147Duncan Sands for (int x = 1; x < 6; ++x) { 1091e90a615f37aaee2ad9259c0ef21586d5e4142147Duncan Sands Ops[x] = Node->getOperand(x); 1092e90a615f37aaee2ad9259c0ef21586d5e4142147Duncan Sands } 1093d497d9fab6e90499c703f3e672ec001dbfa074f9Andrew Lenharth Result = DAG.UpdateNodeOperands(Result, &Ops[0], 6); 1094d497d9fab6e90499c703f3e672ec001dbfa074f9Andrew Lenharth break; 1095d497d9fab6e90499c703f3e672ec001dbfa074f9Andrew Lenharth } 1096d497d9fab6e90499c703f3e672ec001dbfa074f9Andrew Lenharth case TargetLowering::Expand: 1097d497d9fab6e90499c703f3e672ec001dbfa074f9Andrew Lenharth //There is no libgcc call for this op 1098d497d9fab6e90499c703f3e672ec001dbfa074f9Andrew Lenharth Result = Node->getOperand(0); // Noop 1099d497d9fab6e90499c703f3e672ec001dbfa074f9Andrew Lenharth break; 1100d497d9fab6e90499c703f3e672ec001dbfa074f9Andrew Lenharth } 110122c5c1b2dfcb1da6a7ebfebea903401fc77d56e6Andrew Lenharth break; 110222c5c1b2dfcb1da6a7ebfebea903401fc77d56e6Andrew Lenharth } 110322c5c1b2dfcb1da6a7ebfebea903401fc77d56e6Andrew Lenharth 11040b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman case ISD::ATOMIC_CMP_SWAP: { 110563307c335aa08b0d6a75f81d64d79af7e90eb78bMon P Wang unsigned int num_operands = 4; 110663307c335aa08b0d6a75f81d64d79af7e90eb78bMon P Wang assert(Node->getNumOperands() == num_operands && "Invalid Atomic node!"); 1107475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[4]; 110863307c335aa08b0d6a75f81d64d79af7e90eb78bMon P Wang for (unsigned int x = 0; x < num_operands; ++x) 110963307c335aa08b0d6a75f81d64d79af7e90eb78bMon P Wang Ops[x] = LegalizeOp(Node->getOperand(x)); 111063307c335aa08b0d6a75f81d64d79af7e90eb78bMon P Wang Result = DAG.UpdateNodeOperands(Result, &Ops[0], num_operands); 1111fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 111263307c335aa08b0d6a75f81d64d79af7e90eb78bMon P Wang switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 111363307c335aa08b0d6a75f81d64d79af7e90eb78bMon P Wang default: assert(0 && "This action is not supported yet!"); 111463307c335aa08b0d6a75f81d64d79af7e90eb78bMon P Wang case TargetLowering::Custom: 111563307c335aa08b0d6a75f81d64d79af7e90eb78bMon P Wang Result = TLI.LowerOperation(Result, DAG); 111663307c335aa08b0d6a75f81d64d79af7e90eb78bMon P Wang break; 111763307c335aa08b0d6a75f81d64d79af7e90eb78bMon P Wang case TargetLowering::Legal: 111863307c335aa08b0d6a75f81d64d79af7e90eb78bMon P Wang break; 111963307c335aa08b0d6a75f81d64d79af7e90eb78bMon P Wang } 1120475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 0), Result.getValue(0)); 1121475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 1), Result.getValue(1)); 112299a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Result.getValue(Op.getResNo()); 1123126d90770bdb17e6925b2fe26de99aa079b7b9b3Duncan Sands } 11240b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman case ISD::ATOMIC_LOAD_ADD: 11250b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman case ISD::ATOMIC_LOAD_SUB: 11260b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman case ISD::ATOMIC_LOAD_AND: 11270b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman case ISD::ATOMIC_LOAD_OR: 11280b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman case ISD::ATOMIC_LOAD_XOR: 11290b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman case ISD::ATOMIC_LOAD_NAND: 11300b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman case ISD::ATOMIC_LOAD_MIN: 11310b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman case ISD::ATOMIC_LOAD_MAX: 11320b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman case ISD::ATOMIC_LOAD_UMIN: 11330b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman case ISD::ATOMIC_LOAD_UMAX: 11340b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman case ISD::ATOMIC_SWAP: { 113563307c335aa08b0d6a75f81d64d79af7e90eb78bMon P Wang unsigned int num_operands = 3; 113663307c335aa08b0d6a75f81d64d79af7e90eb78bMon P Wang assert(Node->getNumOperands() == num_operands && "Invalid Atomic node!"); 1137475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[3]; 113863307c335aa08b0d6a75f81d64d79af7e90eb78bMon P Wang for (unsigned int x = 0; x < num_operands; ++x) 113926ed8697d4733f4ad588ef117ec4387560770ad0Andrew Lenharth Ops[x] = LegalizeOp(Node->getOperand(x)); 114063307c335aa08b0d6a75f81d64d79af7e90eb78bMon P Wang Result = DAG.UpdateNodeOperands(Result, &Ops[0], num_operands); 1141126d90770bdb17e6925b2fe26de99aa079b7b9b3Duncan Sands 114226ed8697d4733f4ad588ef117ec4387560770ad0Andrew Lenharth switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 1143ab0b949e0e9de452f3b052b11634ab761e008b23Andrew Lenharth default: assert(0 && "This action is not supported yet!"); 114426ed8697d4733f4ad588ef117ec4387560770ad0Andrew Lenharth case TargetLowering::Custom: 114526ed8697d4733f4ad588ef117ec4387560770ad0Andrew Lenharth Result = TLI.LowerOperation(Result, DAG); 114626ed8697d4733f4ad588ef117ec4387560770ad0Andrew Lenharth break; 114726ed8697d4733f4ad588ef117ec4387560770ad0Andrew Lenharth case TargetLowering::Legal: 1148ab0b949e0e9de452f3b052b11634ab761e008b23Andrew Lenharth break; 1149ab0b949e0e9de452f3b052b11634ab761e008b23Andrew Lenharth } 1150475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 0), Result.getValue(0)); 1151475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 1), Result.getValue(1)); 115299a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Result.getValue(Op.getResNo()); 1153126d90770bdb17e6925b2fe26de99aa079b7b9b3Duncan Sands } 1154c1513d24eab4b193c951f3cad450ef344e88e0a6Scott Michel case ISD::Constant: { 1155c1513d24eab4b193c951f3cad450ef344e88e0a6Scott Michel ConstantSDNode *CN = cast<ConstantSDNode>(Node); 1156c1513d24eab4b193c951f3cad450ef344e88e0a6Scott Michel unsigned opAction = 1157c1513d24eab4b193c951f3cad450ef344e88e0a6Scott Michel TLI.getOperationAction(ISD::Constant, CN->getValueType(0)); 1158c1513d24eab4b193c951f3cad450ef344e88e0a6Scott Michel 11593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // We know we don't need to expand constants here, constants only have one 11603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // value and we check that it is fine above. 11613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1162c1513d24eab4b193c951f3cad450ef344e88e0a6Scott Michel if (opAction == TargetLowering::Custom) { 1163c1513d24eab4b193c951f3cad450ef344e88e0a6Scott Michel Tmp1 = TLI.LowerOperation(Result, DAG); 1164ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) 1165c1513d24eab4b193c951f3cad450ef344e88e0a6Scott Michel Result = Tmp1; 1166c1513d24eab4b193c951f3cad450ef344e88e0a6Scott Michel } 11673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1168c1513d24eab4b193c951f3cad450ef344e88e0a6Scott Michel } 11693e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ConstantFP: { 11703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Spill FP immediates to the constant pool if the target cannot directly 11713e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // codegen them. Targets often have some immediate values that can be 11723e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // efficiently generated into an FP register without a load. We explicitly 11733e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // leave these constants as ConstantFP nodes for the target to deal with. 11743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFPSDNode *CFP = cast<ConstantFPSDNode>(Node); 11753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 11763181a771ff5b2090b7ed55f9b18a684ea8fe625aChris Lattner switch (TLI.getOperationAction(ISD::ConstantFP, CFP->getValueType(0))) { 11773181a771ff5b2090b7ed55f9b18a684ea8fe625aChris Lattner default: assert(0 && "This action is not supported yet!"); 1178e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman case TargetLowering::Legal: 1179e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman break; 11803181a771ff5b2090b7ed55f9b18a684ea8fe625aChris Lattner case TargetLowering::Custom: 11813181a771ff5b2090b7ed55f9b18a684ea8fe625aChris Lattner Tmp3 = TLI.LowerOperation(Result, DAG); 1182ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp3.getNode()) { 11833181a771ff5b2090b7ed55f9b18a684ea8fe625aChris Lattner Result = Tmp3; 11843181a771ff5b2090b7ed55f9b18a684ea8fe625aChris Lattner break; 11853181a771ff5b2090b7ed55f9b18a684ea8fe625aChris Lattner } 11863181a771ff5b2090b7ed55f9b18a684ea8fe625aChris Lattner // FALLTHROUGH 1187e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman case TargetLowering::Expand: { 1188e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman // Check to see if this FP immediate is already legal. 1189e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman bool isLegal = false; 1190e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman for (TargetLowering::legal_fpimm_iterator I = TLI.legal_fpimm_begin(), 1191e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman E = TLI.legal_fpimm_end(); I != E; ++I) { 1192e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman if (CFP->isExactlyValue(*I)) { 1193e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman isLegal = true; 1194e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman break; 1195e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman } 1196e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman } 1197e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman // If this is a legal constant, turn it into a TargetConstantFP node. 1198e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman if (isLegal) 1199e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman break; 1200279101eb1ac61e2d5b83d5bdcc5be56e710d2cd7Evan Cheng Result = ExpandConstantFP(CFP, true, DAG, TLI); 12013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1202e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman } 12033e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 12043e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1205040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner case ISD::TokenFactor: 1206040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner if (Node->getNumOperands() == 2) { 1207c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 1208c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 1209c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); 1210c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner } else if (Node->getNumOperands() == 3) { 1211c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 1212c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 1213c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); 1214c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3); 1215040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner } else { 1216475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 8> Ops; 1217040c11c24e9f6c172eaf680e135d9bb466c284b2Chris Lattner // Legalize the operands. 1218c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) 1219c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 1220f06f35e30b4c4d7db304f717a3d4dc6595fbd078Chris Lattner Result = DAG.UpdateNodeOperands(Result, &Ops[0], Ops.size()); 1221a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner } 1222a385e9b20fa7d37d3842ce15afd412f617d83a27Chris Lattner break; 1223fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1224fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case ISD::FORMAL_ARGUMENTS: 1225f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case ISD::CALL: 1226fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // The only option for this is to custom lower it. 1227b248e16afd105fd8c01e08d8bf997b08ff08d127Chris Lattner Tmp3 = TLI.LowerOperation(Result.getValue(0), DAG); 1228ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif assert(Tmp3.getNode() && "Target didn't custom lower this node!"); 12290ea0356dff38dfd0420b8c0a2fdf2fae7898c024Dale Johannesen // A call within a calling sequence must be legalized to something 12300ea0356dff38dfd0420b8c0a2fdf2fae7898c024Dale Johannesen // other than the normal CALLSEQ_END. Violating this gets Legalize 12310ea0356dff38dfd0420b8c0a2fdf2fae7898c024Dale Johannesen // into an infinite loop. 12320ea0356dff38dfd0420b8c0a2fdf2fae7898c024Dale Johannesen assert ((!IsLegalizingCall || 12330ea0356dff38dfd0420b8c0a2fdf2fae7898c024Dale Johannesen Node->getOpcode() != ISD::CALL || 1234ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Tmp3.getNode()->getOpcode() != ISD::CALLSEQ_END) && 12350ea0356dff38dfd0420b8c0a2fdf2fae7898c024Dale Johannesen "Nested CALLSEQ_START..CALLSEQ_END not supported."); 12360f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling 12370f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling // The number of incoming and outgoing values should match; unless the final 12380f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling // outgoing value is a flag. 1239ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif assert((Tmp3.getNode()->getNumValues() == Result.getNode()->getNumValues() || 1240ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif (Tmp3.getNode()->getNumValues() == Result.getNode()->getNumValues() + 1 && 1241ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Tmp3.getNode()->getValueType(Tmp3.getNode()->getNumValues() - 1) == 12420f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling MVT::Flag)) && 1243b248e16afd105fd8c01e08d8bf997b08ff08d127Chris Lattner "Lowering call/formal_arguments produced unexpected # results!"); 1244fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1245f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // Since CALL/FORMAL_ARGUMENTS nodes produce multiple values, make sure to 1246e2e41730ccfa9bebfabbd17ab3454aa2bb620b2aChris Lattner // remember that we legalized all of them, so it doesn't get relegalized. 1247ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif for (unsigned i = 0, e = Tmp3.getNode()->getNumValues(); i != e; ++i) { 1248ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp3.getNode()->getValueType(i) == MVT::Flag) 12490f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling continue; 1250b248e16afd105fd8c01e08d8bf997b08ff08d127Chris Lattner Tmp1 = LegalizeOp(Tmp3.getValue(i)); 125199a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif if (Op.getResNo() == i) 1252e2e41730ccfa9bebfabbd17ab3454aa2bb620b2aChris Lattner Tmp2 = Tmp1; 1253475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, i), Tmp1); 1254e2e41730ccfa9bebfabbd17ab3454aa2bb620b2aChris Lattner } 1255e2e41730ccfa9bebfabbd17ab3454aa2bb620b2aChris Lattner return Tmp2; 1256b2827b0901162169bb2692b77a839c9767849134Chris Lattner case ISD::BUILD_VECTOR: 1257b2827b0901162169bb2692b77a839c9767849134Chris Lattner switch (TLI.getOperationAction(ISD::BUILD_VECTOR, Node->getValueType(0))) { 12582332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner default: assert(0 && "This action is not supported yet!"); 12592332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner case TargetLowering::Custom: 12602332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner Tmp3 = TLI.LowerOperation(Result, DAG); 1261ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp3.getNode()) { 12622332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner Result = Tmp3; 12632332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner break; 12642332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner } 12652332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner // FALLTHROUGH 1266ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner case TargetLowering::Expand: 1267ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Result = ExpandBUILD_VECTOR(Result.getNode()); 1268b2827b0901162169bb2692b77a839c9767849134Chris Lattner break; 12692332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner } 12702332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner break; 12712332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner case ISD::INSERT_VECTOR_ELT: 12722332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // InVec 12732332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // InEltNo 12740325d90348f33e8aa719cd70e4663e7b108297fdNate Begeman 12750325d90348f33e8aa719cd70e4663e7b108297fdNate Begeman // The type of the value to insert may not be legal, even though the vector 12760325d90348f33e8aa719cd70e4663e7b108297fdNate Begeman // type is legal. Legalize/Promote accordingly. We do not handle Expand 12770325d90348f33e8aa719cd70e4663e7b108297fdNate Begeman // here. 1278957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp2 = LegalizeOp(Node->getOperand(1)); 12792332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3); 1280fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 12812332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner switch (TLI.getOperationAction(ISD::INSERT_VECTOR_ELT, 12822332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner Node->getValueType(0))) { 12832332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner default: assert(0 && "This action is not supported yet!"); 12842332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner case TargetLowering::Legal: 12852332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner break; 12862332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner case TargetLowering::Custom: 12872281a991414f681c482157265461b29a923ef620Nate Begeman Tmp4 = TLI.LowerOperation(Result, DAG); 1288ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp4.getNode()) { 12892281a991414f681c482157265461b29a923ef620Nate Begeman Result = Tmp4; 12902332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner break; 12912332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner } 12922332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner // FALLTHROUGH 12930c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang case TargetLowering::Promote: 12940c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang // Fall thru for vector case 12952332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner case TargetLowering::Expand: { 12968d5a894501b7546dee94df03118b90126c420820Chris Lattner // If the insert index is a constant, codegen this as a scalar_to_vector, 12978d5a894501b7546dee94df03118b90126c420820Chris Lattner // then a shuffle that inserts it into the right position in the vector. 12988d5a894501b7546dee94df03118b90126c420820Chris Lattner if (ConstantSDNode *InsertPos = dyn_cast<ConstantSDNode>(Tmp3)) { 12990325d90348f33e8aa719cd70e4663e7b108297fdNate Begeman // SCALAR_TO_VECTOR requires that the type of the value being inserted 1300b10b5ac8d9da43ca2db61401a20af6b676c98438Duncan Sands // match the element type of the vector being created, except for 1301b10b5ac8d9da43ca2db61401a20af6b676c98438Duncan Sands // integers in which case the inserted value can be over width. 1302b10b5ac8d9da43ca2db61401a20af6b676c98438Duncan Sands MVT EltVT = Op.getValueType().getVectorElementType(); 1303b10b5ac8d9da43ca2db61401a20af6b676c98438Duncan Sands if (Tmp2.getValueType() == EltVT || 1304b10b5ac8d9da43ca2db61401a20af6b676c98438Duncan Sands (EltVT.isInteger() && Tmp2.getValueType().bitsGE(EltVT))) { 1305ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue ScVec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, 1306ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson Tmp1.getValueType(), Tmp2); 1307fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 130883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned NumElts = Tmp1.getValueType().getVectorNumElements(); 13090325d90348f33e8aa719cd70e4663e7b108297fdNate Begeman // We generate a shuffle of InVec and ScVec, so the shuffle mask 13100325d90348f33e8aa719cd70e4663e7b108297fdNate Begeman // should be 0,1,2,3,4,5... with the appropriate element replaced with 13110325d90348f33e8aa719cd70e4663e7b108297fdNate Begeman // elt 0 of the RHS. 13129008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman SmallVector<int, 8> ShufOps; 13139008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman for (unsigned i = 0; i != NumElts; ++i) 13149008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman ShufOps.push_back(i != InsertPos->getZExtValue() ? i : NumElts); 13159008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman 13169008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman Result = DAG.getVectorShuffle(Tmp1.getValueType(), dl, Tmp1, ScVec, 13179008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman &ShufOps[0]); 13180325d90348f33e8aa719cd70e4663e7b108297fdNate Begeman Result = LegalizeOp(Result); 13190325d90348f33e8aa719cd70e4663e7b108297fdNate Begeman break; 13208d5a894501b7546dee94df03118b90126c420820Chris Lattner } 13218d5a894501b7546dee94df03118b90126c420820Chris Lattner } 1322bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Result = PerformInsertVectorEltInMemory(Tmp1, Tmp2, Tmp3, dl); 13232332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner break; 13242332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner } 13252332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner } 13262332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner break; 1327ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner case ISD::SCALAR_TO_VECTOR: 1328ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // InVal 1329ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1); 1330ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner switch (TLI.getOperationAction(ISD::SCALAR_TO_VECTOR, 1331ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner Node->getValueType(0))) { 1332ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner default: assert(0 && "This action is not supported yet!"); 1333ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner case TargetLowering::Legal: 1334ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner break; 13354d3abee6183f110c9db56b94b0a4b5f8c985002aChris Lattner case TargetLowering::Custom: 13364d3abee6183f110c9db56b94b0a4b5f8c985002aChris Lattner Tmp3 = TLI.LowerOperation(Result, DAG); 1337ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp3.getNode()) { 13384d3abee6183f110c9db56b94b0a4b5f8c985002aChris Lattner Result = Tmp3; 13394d3abee6183f110c9db56b94b0a4b5f8c985002aChris Lattner break; 13404d3abee6183f110c9db56b94b0a4b5f8c985002aChris Lattner } 13414d3abee6183f110c9db56b94b0a4b5f8c985002aChris Lattner // FALLTHROUGH 13424352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner case TargetLowering::Expand: 13434352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner Result = LegalizeOp(ExpandSCALAR_TO_VECTOR(Node)); 1344ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner break; 1345ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } 1346ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner break; 13479008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman case ISD::VECTOR_SHUFFLE: { 134887100e0b83b808757bf44dabecd1d1048255d1adChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the input vectors, 134987100e0b83b808757bf44dabecd1d1048255d1adChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // but not the shuffle mask. 13509008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); 13519008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman MVT VT = Result.getValueType(); 13529008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman 13535a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman // Copy the Mask to a local SmallVector for use with isShuffleMaskLegal. 13549008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman SmallVector<int, 8> Mask; 13559008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman cast<ShuffleVectorSDNode>(Result)->getMask(Mask); 135687100e0b83b808757bf44dabecd1d1048255d1adChris Lattner 135787100e0b83b808757bf44dabecd1d1048255d1adChris Lattner // Allow targets to custom lower the SHUFFLEs they support. 13589008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman switch (TLI.getOperationAction(ISD::VECTOR_SHUFFLE, VT)) { 13594352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner default: assert(0 && "Unknown operation action!"); 13604352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner case TargetLowering::Legal: 13619008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman assert(TLI.isShuffleMaskLegal(Mask, VT) && 13624352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner "vector shuffle should not be created if not legal!"); 13634352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner break; 13644352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner case TargetLowering::Custom: 136518dd6d0a2aeb3b827391f46996a7b40c9b1f907aEvan Cheng Tmp3 = TLI.LowerOperation(Result, DAG); 1366ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp3.getNode()) { 136718dd6d0a2aeb3b827391f46996a7b40c9b1f907aEvan Cheng Result = Tmp3; 136818dd6d0a2aeb3b827391f46996a7b40c9b1f907aEvan Cheng break; 136918dd6d0a2aeb3b827391f46996a7b40c9b1f907aEvan Cheng } 137018dd6d0a2aeb3b827391f46996a7b40c9b1f907aEvan Cheng // FALLTHROUGH 137118dd6d0a2aeb3b827391f46996a7b40c9b1f907aEvan Cheng case TargetLowering::Expand: { 137283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT EltVT = VT.getVectorElementType(); 13735a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman unsigned NumElems = VT.getVectorNumElements(); 1374ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson SmallVector<SDValue, 8> Ops; 13755a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman for (unsigned i = 0; i != NumElems; ++i) { 13769008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman if (Mask[i] < 0) { 1377e8d7230f480654cdb8ff1c3d0a38e1e9ab0bd55fDale Johannesen Ops.push_back(DAG.getUNDEF(EltVT)); 13789008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman continue; 137918dd6d0a2aeb3b827391f46996a7b40c9b1f907aEvan Cheng } 13805a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman unsigned Idx = Mask[i]; 13819008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman if (Idx < NumElems) 13829008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, Tmp1, 13839008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman DAG.getIntPtrConstant(Idx))); 13849008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman else 13859008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, Tmp2, 13869008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman DAG.getIntPtrConstant(Idx - NumElems))); 138718dd6d0a2aeb3b827391f46996a7b40c9b1f907aEvan Cheng } 1388a87008d90b7d894cfca53d407642acfd7be2af3cEvan Cheng Result = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &Ops[0], Ops.size()); 13894352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner break; 139018dd6d0a2aeb3b827391f46996a7b40c9b1f907aEvan Cheng } 13914352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner case TargetLowering::Promote: { 13924352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner // Change base type to a different vector type. 139383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT OVT = Node->getValueType(0); 139483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); 13954352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner 13964352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner // Cast the two input vectors. 1397ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::BIT_CONVERT, dl, NVT, Tmp1); 1398ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::BIT_CONVERT, dl, NVT, Tmp2); 1399fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 14004352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner // Convert the shuffle mask to the right # elements. 14015a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman Result = ShuffleWithNarrowerEltType(NVT, OVT, dl, Tmp1, Tmp2, Mask); 1402ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::BIT_CONVERT, dl, OVT, Result); 14034352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner break; 14044352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner } 140587100e0b83b808757bf44dabecd1d1048255d1adChris Lattner } 140687100e0b83b808757bf44dabecd1d1048255d1adChris Lattner break; 14079008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman } 1408384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner case ISD::EXTRACT_VECTOR_ELT: 14097f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman Tmp1 = Node->getOperand(0); 1410384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); 1411384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); 14127f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman Result = ExpandEXTRACT_VECTOR_ELT(Result); 1413384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner break; 1414384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner 1415fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel case ISD::EXTRACT_SUBVECTOR: 14161fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman Tmp1 = LegalizeOp(Node->getOperand(0)); 14177f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman Tmp2 = LegalizeOp(Node->getOperand(1)); 14187f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); 14191fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman 14203d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman switch (TLI.getOperationAction(ISD::EXTRACT_SUBVECTOR, 14213d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman Node->getValueType(0))) { 14223d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman default: assert(0 && "Unknown operation action!"); 14233d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman case TargetLowering::Legal: 14243d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman break; 14253d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman case TargetLowering::Custom: 14263d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman Tmp3 = TLI.LowerOperation(Result, DAG); 14273d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman if (Tmp3.getNode()) { 14283d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman Result = Tmp3; 14293d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman break; 14303d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman } 14313d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman // FALLTHROUGH 14323d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman case TargetLowering::Expand: { 14333d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman Result = ExpandExtractFromVectorThroughStack(Result); 14343d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman break; 14353d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman } 14363d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman } 14376595635175764f402e7a5e53216c8d46bdce8c28Dan Gohman break; 1438fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 14390c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang case ISD::CONCAT_VECTORS: { 14405ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson // Legalize the operands. 14410c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang SmallVector<SDValue, 8> Ops; 14425ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) 14435ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson Ops.push_back(LegalizeOp(Node->getOperand(i))); 14445ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson Result = DAG.UpdateNodeOperands(Result, &Ops[0], Ops.size()); 14455ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson 14465ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson switch (TLI.getOperationAction(ISD::CONCAT_VECTORS, 14475ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson Node->getValueType(0))) { 14485ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson default: assert(0 && "Unknown operation action!"); 14495ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson case TargetLowering::Legal: 14505ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson break; 14515ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson case TargetLowering::Custom: 14525ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson Tmp3 = TLI.LowerOperation(Result, DAG); 14535ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson if (Tmp3.getNode()) { 14545ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson Result = Tmp3; 14555ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson break; 14565ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson } 14575ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson // FALLTHROUGH 14585ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson case TargetLowering::Expand: { 14595ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson // Use extract/insert/build vector for now. We might try to be 14605ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson // more clever later. 14615ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson MVT PtrVT = TLI.getPointerTy(); 14625ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson SmallVector<SDValue, 8> Ops; 14635ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson unsigned NumOperands = Node->getNumOperands(); 14645ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson for (unsigned i=0; i < NumOperands; ++i) { 14655ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson SDValue SubOp = Node->getOperand(i); 14665ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson MVT VVT = SubOp.getNode()->getValueType(0); 14675ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson MVT EltVT = VVT.getVectorElementType(); 14685ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson unsigned NumSubElem = VVT.getVectorNumElements(); 14695ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson for (unsigned j=0; j < NumSubElem; ++j) { 14705ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, SubOp, 14715ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson DAG.getConstant(j, PtrVT))); 14725ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson } 14730c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang } 14745ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson return LegalizeOp(DAG.getNode(ISD::BUILD_VECTOR, dl, 14755ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson Node->getValueType(0), 14765ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson &Ops[0], Ops.size())); 14770c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang } 14785ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson } 14795ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson break; 14800c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang } 14810c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang 14826831a815999dde4cf801e2076e66b4943964daf2Chris Lattner case ISD::CALLSEQ_START: { 14836831a815999dde4cf801e2076e66b4943964daf2Chris Lattner SDNode *CallEnd = FindCallEndFromCallStart(Node); 1484fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 14856831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Recursively Legalize all of the inputs of the call end that do not lead 14866831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // to this call start. This ensures that any libcalls that need be inserted 14876831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // are inserted *before* the CALLSEQ_START. 148800755df36c1448ac4728a74d907aa09e3d8b2d49Chris Lattner {SmallPtrSet<SDNode*, 32> NodesLeadingTo; 14896831a815999dde4cf801e2076e66b4943964daf2Chris Lattner for (unsigned i = 0, e = CallEnd->getNumOperands(); i != e; ++i) 1490ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif LegalizeAllNodesNotLeadingTo(CallEnd->getOperand(i).getNode(), Node, 1491c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner NodesLeadingTo); 1492c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner } 14936831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 14946831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Now that we legalized all of the inputs (which may have inserted 14956831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // libcalls) create the new CALLSEQ_START node. 14966831a815999dde4cf801e2076e66b4943964daf2Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 14976831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 14986831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Merge in the last call, to ensure that this call start after the last 14996831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // call ended. 1500c5d7d7c715f7b7a4eeea1ceaafefc3d1d6df2addChris Lattner if (LastCALLSEQ_END.getOpcode() != ISD::EntryToken) { 1501fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Tmp1 = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, 1502ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1, LastCALLSEQ_END); 1503b248e16afd105fd8c01e08d8bf997b08ff08d127Chris Lattner Tmp1 = LegalizeOp(Tmp1); 1504b248e16afd105fd8c01e08d8bf997b08ff08d127Chris Lattner } 1505fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 15066831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Do not try to legalize the target-specific arguments (#1+). 15076831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (Tmp1 != Node->getOperand(0)) { 1508475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 8> Ops(Node->op_begin(), Node->op_end()); 15096831a815999dde4cf801e2076e66b4943964daf2Chris Lattner Ops[0] = Tmp1; 1510f06f35e30b4c4d7db304f717a3d4dc6595fbd078Chris Lattner Result = DAG.UpdateNodeOperands(Result, &Ops[0], Ops.size()); 15116831a815999dde4cf801e2076e66b4943964daf2Chris Lattner } 1512fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 15136831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Remember that the CALLSEQ_START is legalized. 15144b653a0405bb16b555334d134c1eb8a97366ec3dChris Lattner AddLegalizedOperand(Op.getValue(0), Result); 15154b653a0405bb16b555334d134c1eb8a97366ec3dChris Lattner if (Node->getNumValues() == 2) // If this has a flag result, remember it. 15164b653a0405bb16b555334d134c1eb8a97366ec3dChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 1517fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 15186831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Now that the callseq_start and all of the non-call nodes above this call 1519fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // sequence have been legalized, legalize the call itself. During this 15206831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // process, no libcalls can/will be inserted, guaranteeing that no calls 15216831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // can overlap. 15226831a815999dde4cf801e2076e66b4943964daf2Chris Lattner assert(!IsLegalizingCall && "Inconsistent sequentialization of calls!"); 15236831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Note that we are selecting this call! 1524475871a144eb604ddaf37503397ba0941442e5fbDan Gohman LastCALLSEQ_END = SDValue(CallEnd, 0); 15256831a815999dde4cf801e2076e66b4943964daf2Chris Lattner IsLegalizingCall = true; 1526fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 15276831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Legalize the call, starting from the CALLSEQ_END. 15286831a815999dde4cf801e2076e66b4943964daf2Chris Lattner LegalizeOp(LastCALLSEQ_END); 15296831a815999dde4cf801e2076e66b4943964daf2Chris Lattner assert(!IsLegalizingCall && "CALLSEQ_END should have cleared this!"); 15306831a815999dde4cf801e2076e66b4943964daf2Chris Lattner return Result; 15316831a815999dde4cf801e2076e66b4943964daf2Chris Lattner } 153216cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_END: 15336831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // If the CALLSEQ_START node hasn't been legalized first, legalize it. This 15346831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // will cause this node to be legalized as well as handling libcalls right. 1535ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (LastCALLSEQ_END.getNode() != Node) { 1536475871a144eb604ddaf37503397ba0941442e5fbDan Gohman LegalizeOp(SDValue(FindCallStartFromCallEnd(Node), 0)); 1537475871a144eb604ddaf37503397ba0941442e5fbDan Gohman DenseMap<SDValue, SDValue>::iterator I = LegalizedNodes.find(Op); 15386831a815999dde4cf801e2076e66b4943964daf2Chris Lattner assert(I != LegalizedNodes.end() && 15396831a815999dde4cf801e2076e66b4943964daf2Chris Lattner "Legalizing the call start should have legalized this node!"); 15406831a815999dde4cf801e2076e66b4943964daf2Chris Lattner return I->second; 15416831a815999dde4cf801e2076e66b4943964daf2Chris Lattner } 1542fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1543fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // Otherwise, the call start has been legalized and everything is going 15446831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // according to plan. Just legalize ourselves normally here. 15453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 154670814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner // Do not try to legalize the target-specific arguments (#1+), except for 154770814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner // an optional flag input. 154870814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner if (Node->getOperand(Node->getNumOperands()-1).getValueType() != MVT::Flag){ 154970814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner if (Tmp1 != Node->getOperand(0)) { 1550475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 8> Ops(Node->op_begin(), Node->op_end()); 155170814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner Ops[0] = Tmp1; 1552f06f35e30b4c4d7db304f717a3d4dc6595fbd078Chris Lattner Result = DAG.UpdateNodeOperands(Result, &Ops[0], Ops.size()); 155370814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner } 155470814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner } else { 155570814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(Node->getNumOperands()-1)); 155670814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner if (Tmp1 != Node->getOperand(0) || 155770814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner Tmp2 != Node->getOperand(Node->getNumOperands()-1)) { 1558475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 8> Ops(Node->op_begin(), Node->op_end()); 155970814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner Ops[0] = Tmp1; 156070814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner Ops.back() = Tmp2; 1561f06f35e30b4c4d7db304f717a3d4dc6595fbd078Chris Lattner Result = DAG.UpdateNodeOperands(Result, &Ops[0], Ops.size()); 156270814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner } 15636a5428934ba6159c1acc541944332e51a6cfa59aChris Lattner } 15644b653a0405bb16b555334d134c1eb8a97366ec3dChris Lattner assert(IsLegalizingCall && "Call sequence imbalance between start/end?"); 15656831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // This finishes up call legalization. 15666831a815999dde4cf801e2076e66b4943964daf2Chris Lattner IsLegalizingCall = false; 1567fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 15684b653a0405bb16b555334d134c1eb8a97366ec3dChris Lattner // If the CALLSEQ_END node has a flag, remember that we legalized it. 1569475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 0), Result.getValue(0)); 15704b653a0405bb16b555334d134c1eb8a97366ec3dChris Lattner if (Node->getNumValues() == 2) 1571475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 1), Result.getValue(1)); 157299a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Result.getValue(Op.getResNo()); 1573a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng case ISD::DYNAMIC_STACKALLOC: { 157483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 1575fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 1576fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the size. 1577fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the alignment. 1578c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3); 1579fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 1580c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp1 = Result.getValue(0); 15815f652295c27826f26547cf5eb4096a59d86b56b8Chris Lattner Tmp2 = Result.getValue(1); 158261bbbabe3da27479cc9a3a36e49091a1141ba7a3Evan Cheng switch (TLI.getOperationAction(Node->getOpcode(), VT)) { 1583a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng default: assert(0 && "This action is not supported yet!"); 1584903d278a9b7398d8905c90832e587e0556c52789Chris Lattner case TargetLowering::Expand: { 1585903d278a9b7398d8905c90832e587e0556c52789Chris Lattner unsigned SPReg = TLI.getStackPointerRegisterToSaveRestore(); 1586903d278a9b7398d8905c90832e587e0556c52789Chris Lattner assert(SPReg && "Target cannot require DYNAMIC_STACKALLOC expansion and" 1587903d278a9b7398d8905c90832e587e0556c52789Chris Lattner " not tell us which reg is the stack pointer!"); 1588475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Chain = Tmp1.getOperand(0); 15890f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling 15900f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling // Chain the dynamic stack allocation so that it doesn't modify the stack 15910f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling // pointer when other instructions are using the stack. 1592e563bbc312f8b11ecfe12b8187176f667df1dff3Chris Lattner Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(0, true)); 15930f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling 1594475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Size = Tmp2.getOperand(1); 1595c460ae90019ddb19d4c07b2cd2fbaecfa7adf67dDale Johannesen SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, VT); 159661bbbabe3da27479cc9a3a36e49091a1141ba7a3Evan Cheng Chain = SP.getValue(1); 1597f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman unsigned Align = cast<ConstantSDNode>(Tmp3)->getZExtValue(); 159861bbbabe3da27479cc9a3a36e49091a1141ba7a3Evan Cheng unsigned StackAlign = 159961bbbabe3da27479cc9a3a36e49091a1141ba7a3Evan Cheng TLI.getTargetMachine().getFrameInfo()->getStackAlignment(); 160061bbbabe3da27479cc9a3a36e49091a1141ba7a3Evan Cheng if (Align > StackAlign) 1601ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SP = DAG.getNode(ISD::AND, dl, VT, SP, 16023e20bba5eb5df2fdd3e6655c8470084cf05032d4Evan Cheng DAG.getConstant(-(uint64_t)Align, VT)); 1603ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::SUB, dl, VT, SP, Size); // Value 1604c460ae90019ddb19d4c07b2cd2fbaecfa7adf67dDale Johannesen Chain = DAG.getCopyToReg(Chain, dl, SPReg, Tmp1); // Output chain 16050f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling 1606ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(0, true), 1607e563bbc312f8b11ecfe12b8187176f667df1dff3Chris Lattner DAG.getIntPtrConstant(0, true), SDValue()); 16080f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling 1609c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp1 = LegalizeOp(Tmp1); 1610c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp2 = LegalizeOp(Tmp2); 1611903d278a9b7398d8905c90832e587e0556c52789Chris Lattner break; 1612903d278a9b7398d8905c90832e587e0556c52789Chris Lattner } 1613903d278a9b7398d8905c90832e587e0556c52789Chris Lattner case TargetLowering::Custom: 16145f652295c27826f26547cf5eb4096a59d86b56b8Chris Lattner Tmp3 = TLI.LowerOperation(Tmp1, DAG); 1615ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp3.getNode()) { 1616c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp1 = LegalizeOp(Tmp3); 1617c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp2 = LegalizeOp(Tmp3.getValue(1)); 1618a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng } 1619903d278a9b7398d8905c90832e587e0556c52789Chris Lattner break; 1620a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng case TargetLowering::Legal: 1621903d278a9b7398d8905c90832e587e0556c52789Chris Lattner break; 1622a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng } 1623903d278a9b7398d8905c90832e587e0556c52789Chris Lattner // Since this op produce two values, make sure to remember that we 1624903d278a9b7398d8905c90832e587e0556c52789Chris Lattner // legalized both of them. 1625475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 0), Tmp1); 1626475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 1), Tmp2); 162799a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Op.getResNo() ? Tmp2 : Tmp1; 1628a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng } 162925a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner case ISD::INLINEASM: { 1630475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 8> Ops(Node->op_begin(), Node->op_end()); 163125a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner bool Changed = false; 163225a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner // Legalize all of the operands of the inline asm, in case they are nodes 163325a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner // that need to be expanded or something. Note we skip the asm string and 163425a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner // all of the TargetConstant flags. 1635475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op = LegalizeOp(Ops[0]); 163625a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner Changed = Op != Ops[0]; 163725a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner Ops[0] = Op; 163825a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner 163925a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner bool HasInFlag = Ops.back().getValueType() == MVT::Flag; 164025a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner for (unsigned i = 2, e = Ops.size()-HasInFlag; i < e; ) { 1641697cbbfb00c318f98d6eb51945f077e2bfe8781eEvan Cheng unsigned NumVals = InlineAsm:: 1642697cbbfb00c318f98d6eb51945f077e2bfe8781eEvan Cheng getNumOperandRegisters(cast<ConstantSDNode>(Ops[i])->getZExtValue()); 164325a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner for (++i; NumVals; ++i, --NumVals) { 1644475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op = LegalizeOp(Ops[i]); 164525a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner if (Op != Ops[i]) { 164625a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner Changed = true; 164725a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner Ops[i] = Op; 164825a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner } 164925a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner } 165025a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner } 165125a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner 165225a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner if (HasInFlag) { 165325a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner Op = LegalizeOp(Ops.back()); 165425a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner Changed |= Op != Ops.back(); 165525a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner Ops.back() = Op; 165625a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner } 1657fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 165825a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner if (Changed) 1659f06f35e30b4c4d7db304f717a3d4dc6595fbd078Chris Lattner Result = DAG.UpdateNodeOperands(Result, &Ops[0], Ops.size()); 1660fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1661ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // INLINE asm returns a chain and flag, make sure to add both to the map. 1662475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 0), Result.getValue(0)); 1663475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 1), Result.getValue(1)); 166499a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Result.getValue(Op.getResNo()); 166525a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner } 1666c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner case ISD::BR: 1667c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 16686831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Ensure that libcalls are emitted before a branch. 1669ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Tmp1, LastCALLSEQ_END); 16706831a815999dde4cf801e2076e66b4943964daf2Chris Lattner Tmp1 = LegalizeOp(Tmp1); 16716831a815999dde4cf801e2076e66b4943964daf2Chris Lattner LastCALLSEQ_END = DAG.getEntryNode(); 1672fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1673c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1)); 1674c7af17923e3bb6053f529679ef0be5399d3519edChris Lattner break; 167537efe6764568a3829fee26aba532283131d1a104Nate Begeman case ISD::BRIND: 167637efe6764568a3829fee26aba532283131d1a104Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 167737efe6764568a3829fee26aba532283131d1a104Nate Begeman // Ensure that libcalls are emitted before a branch. 1678ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Tmp1, LastCALLSEQ_END); 167937efe6764568a3829fee26aba532283131d1a104Nate Begeman Tmp1 = LegalizeOp(Tmp1); 168037efe6764568a3829fee26aba532283131d1a104Nate Begeman LastCALLSEQ_END = DAG.getEntryNode(); 1681fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1682957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 168337efe6764568a3829fee26aba532283131d1a104Nate Begeman Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); 168437efe6764568a3829fee26aba532283131d1a104Nate Begeman break; 16853d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng case ISD::BR_JT: 16863d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 16873d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng // Ensure that libcalls are emitted before a branch. 1688ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Tmp1, LastCALLSEQ_END); 16893d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng Tmp1 = LegalizeOp(Tmp1); 16903d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng LastCALLSEQ_END = DAG.getEntryNode(); 16913d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng 16923d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the jumptable node. 16933d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Node->getOperand(2)); 16943d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng 1695fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel switch (TLI.getOperationAction(ISD::BR_JT, MVT::Other)) { 16963d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng default: assert(0 && "This action is not supported yet!"); 16973d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng case TargetLowering::Legal: break; 16983d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng case TargetLowering::Custom: 16993d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng Tmp1 = TLI.LowerOperation(Result, DAG); 1700ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 17013d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng break; 17023d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng case TargetLowering::Expand: { 1703475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Chain = Result.getOperand(0); 1704475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Table = Result.getOperand(1); 1705475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Index = Result.getOperand(2); 17063d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng 170783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT PTy = TLI.getPointerTy(); 1708acd80ac7bb19f8bdfa55336d567c9ecbe695c8b8Jim Laskey MachineFunction &MF = DAG.getMachineFunction(); 1709acd80ac7bb19f8bdfa55336d567c9ecbe695c8b8Jim Laskey unsigned EntrySize = MF.getJumpTableInfo()->getEntrySize(); 1710fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Index= DAG.getNode(ISD::MUL, dl, PTy, 1711ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Index, DAG.getConstant(EntrySize, PTy)); 1712ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue Addr = DAG.getNode(ISD::ADD, dl, PTy, Index, Table); 1713acd80ac7bb19f8bdfa55336d567c9ecbe695c8b8Jim Laskey 1714712f7b3f549644190e90210a07988753f53daa0aDuncan Sands MVT MemVT = MVT::getIntegerVT(EntrySize * 8); 1715ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue LD = DAG.getExtLoad(ISD::SEXTLOAD, dl, PTy, Chain, Addr, 1716712f7b3f549644190e90210a07988753f53daa0aDuncan Sands PseudoSourceValue::getJumpTable(), 0, MemVT); 1717cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Cheng Addr = LD; 1718acd80ac7bb19f8bdfa55336d567c9ecbe695c8b8Jim Laskey if (TLI.getTargetMachine().getRelocationModel() == Reloc::PIC_) { 17193d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng // For PIC, the sequence is: 17203d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng // BRIND(load(Jumptable + index) + RelocBase) 1721cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Cheng // RelocBase can be JumpTable, GOT or some sort of global base. 1722ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Addr = DAG.getNode(ISD::ADD, dl, PTy, Addr, 1723cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Cheng TLI.getPICJumpTableRelocBase(Table, DAG)); 17243d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng } 1725ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::BRIND, dl, MVT::Other, LD.getValue(1), Addr); 17263d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng } 17273d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng } 17283d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng break; 1729c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner case ISD::BRCOND: 1730c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 17316831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Ensure that libcalls are emitted before a return. 1732ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Tmp1, LastCALLSEQ_END); 17336831a815999dde4cf801e2076e66b4943964daf2Chris Lattner Tmp1 = LegalizeOp(Tmp1); 17346831a815999dde4cf801e2076e66b4943964daf2Chris Lattner LastCALLSEQ_END = DAG.getEntryNode(); 17356831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 1736957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 1737456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner 1738456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner // Basic block destination (Op#2) is always legal. 1739c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Node->getOperand(2)); 1740fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1741fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel switch (TLI.getOperationAction(ISD::BRCOND, MVT::Other)) { 17427cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 1743456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Legal: break; 1744456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 1745456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp1 = TLI.LowerOperation(Result, DAG); 1746ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 1747456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner break; 17487cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 17497cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Expand brcond's setcc into its constituent parts and create a BR_CC 17507cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Node. 17517cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 1752fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getNode(ISD::BR_CC, dl, MVT::Other, 1753ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1, Tmp2.getOperand(2), 17547cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 17557cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 17567cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 1757fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getNode(ISD::BR_CC, dl, MVT::Other, Tmp1, 17587cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), Tmp2, 17597cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 17607cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 17617cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 17627cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 17637cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 17647cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 17657cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BR_CC: 17667cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 17676831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Ensure that libcalls are emitted before a branch. 1768ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Tmp1, LastCALLSEQ_END); 17696831a815999dde4cf801e2076e66b4943964daf2Chris Lattner Tmp1 = LegalizeOp(Tmp1); 1770fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Tmp2 = Node->getOperand(2); // LHS 1771750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp3 = Node->getOperand(3); // RHS 1772750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp4 = Node->getOperand(1); // CC 1773181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner 1774fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel LegalizeSetCC(TLI.getSetCCResultType(Tmp2.getValueType()), 1775bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Tmp2, Tmp3, Tmp4, dl); 1776722cb360690e5d7742b01a9f497fdb65bf8079d5Evan Cheng LastCALLSEQ_END = DAG.getEntryNode(); 1777722cb360690e5d7742b01a9f497fdb65bf8079d5Evan Cheng 17787f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng // If we didn't get both a LHS and RHS back from LegalizeSetCC, 1779750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman // the LHS is a legal SETCC itself. In this case, we need to compare 1780750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman // the result against zero to select between true and false values. 1781ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp3.getNode() == 0) { 1782750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp3 = DAG.getConstant(0, Tmp2.getValueType()); 1783750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp4 = DAG.getCondCode(ISD::SETNE); 1784750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman } 1785fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1786fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp4, Tmp2, Tmp3, 1787750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Node->getOperand(4)); 1788fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1789181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner switch (TLI.getOperationAction(ISD::BR_CC, Tmp3.getValueType())) { 1790181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner default: assert(0 && "Unexpected action for BR_CC!"); 1791456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Legal: break; 1792456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 1793456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp4 = TLI.LowerOperation(Result, DAG); 1794ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp4.getNode()) Result = Tmp4; 1795181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner break; 17967cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 1797c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner break; 1798f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case ISD::LOAD: { 1799466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng LoadSDNode *LD = cast<LoadSDNode>(Node); 1800466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng Tmp1 = LegalizeOp(LD->getChain()); // Legalize the chain. 1801466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng Tmp2 = LegalizeOp(LD->getBasePtr()); // Legalize the base pointer. 18022d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 1803466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng ISD::LoadExtType ExtType = LD->getExtensionType(); 1804466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng if (ExtType == ISD::NON_EXTLOAD) { 180583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 1806466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, LD->getOffset()); 1807466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng Tmp3 = Result.getValue(0); 1808466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng Tmp4 = Result.getValue(1); 1809fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1810466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng switch (TLI.getOperationAction(Node->getOpcode(), VT)) { 1811466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng default: assert(0 && "This action is not supported yet!"); 1812f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio case TargetLowering::Legal: 1813f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // If this is an unaligned load and the target doesn't support it, 1814f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // expand it. 1815f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio if (!TLI.allowsUnalignedMemoryAccesses()) { 1816f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio unsigned ABIAlignment = TLI.getTargetData()-> 181783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands getABITypeAlignment(LD->getMemoryVT().getTypeForMVT()); 1818f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio if (LD->getAlignment() < ABIAlignment){ 1819ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Result = ExpandUnalignedLoad(cast<LoadSDNode>(Result.getNode()), DAG, 1820f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio TLI); 1821f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio Tmp3 = Result.getOperand(0); 1822f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio Tmp4 = Result.getOperand(1); 1823907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen Tmp3 = LegalizeOp(Tmp3); 1824907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen Tmp4 = LegalizeOp(Tmp4); 1825f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 1826f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 1827f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio break; 1828466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng case TargetLowering::Custom: 1829466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng Tmp1 = TLI.LowerOperation(Tmp3, DAG); 1830ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) { 1831466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng Tmp3 = LegalizeOp(Tmp1); 1832466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng Tmp4 = LegalizeOp(Tmp1.getValue(1)); 1833466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng } 1834466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng break; 1835466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng case TargetLowering::Promote: { 1836466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng // Only promote a load of vector type to another. 183783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(VT.isVector() && "Cannot promote this load!"); 1838466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng // Change base type to a different vector type. 183983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), VT); 1840466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng 1841ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getLoad(NVT, dl, Tmp1, Tmp2, LD->getSrcValue(), 1842d6fd1bc122ba791c698255d8be158b8ec424e248Dan Gohman LD->getSrcValueOffset(), 1843d6fd1bc122ba791c698255d8be158b8ec424e248Dan Gohman LD->isVolatile(), LD->getAlignment()); 1844b300d2aa3ef08b5074449e2c05804717f488f4e4Dale Johannesen Tmp3 = LegalizeOp(DAG.getNode(ISD::BIT_CONVERT, dl, VT, Tmp1)); 184541f6cbbeb21d7d4376b8c0302b9766c3e43be5f2Evan Cheng Tmp4 = LegalizeOp(Tmp1.getValue(1)); 1846466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng break; 1847f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 1848466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng } 1849fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // Since loads produce two values, make sure to remember that we 1850466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng // legalized both of them. 1851475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 0), Tmp3); 1852475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 1), Tmp4); 185399a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Op.getResNo() ? Tmp4 : Tmp3; 1854466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng } else { 185583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT SrcVT = LD->getMemoryVT(); 185683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned SrcWidth = SrcVT.getSizeInBits(); 1857f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands int SVOffset = LD->getSrcValueOffset(); 1858f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands unsigned Alignment = LD->getAlignment(); 1859f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands bool isVolatile = LD->isVolatile(); 1860f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 186183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (SrcWidth != SrcVT.getStoreSizeInBits() && 1862f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Some targets pretend to have an i1 loading operation, and actually 1863f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // load an i8. This trick is correct for ZEXTLOAD because the top 7 1864f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // bits are guaranteed to be zero; it helps the optimizers understand 1865f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // that these bits are zero. It is also useful for EXTLOAD, since it 1866f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // tells the optimizers that those bits are undefined. It would be 1867f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // nice to have an effective generic way of getting these benefits... 1868f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Until such a way is found, don't insist on promoting i1 here. 1869f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands (SrcVT != MVT::i1 || 18700329466b6b4927f4e6f5d144891fef06a027fec5Evan Cheng TLI.getLoadExtAction(ExtType, MVT::i1) == TargetLowering::Promote)) { 1871f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Promote to a byte-sized load if not loading an integral number of 1872f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // bytes. For example, promote EXTLOAD:i20 -> EXTLOAD:i24. 187383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned NewWidth = SrcVT.getStoreSizeInBits(); 187483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = MVT::getIntegerVT(NewWidth); 1875475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ch; 1876f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1877f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // The extra bits are guaranteed to be zero, since we stored them that 1878f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // way. A zext load from NVT thus automatically gives zext from SrcVT. 1879f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1880f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands ISD::LoadExtType NewExtType = 1881f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands ExtType == ISD::ZEXTLOAD ? ISD::ZEXTLOAD : ISD::EXTLOAD; 1882f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1883ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getExtLoad(NewExtType, dl, Node->getValueType(0), 1884f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1, Tmp2, LD->getSrcValue(), SVOffset, 1885f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands NVT, isVolatile, Alignment); 1886f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1887f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Ch = Result.getValue(1); // The chain. 1888f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1889f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands if (ExtType == ISD::SEXTLOAD) 1890f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Having the top bits zero doesn't help when sign extending. 1891fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, 1892ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result.getValueType(), 1893f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Result, DAG.getValueType(SrcVT)); 1894f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands else if (ExtType == ISD::ZEXTLOAD || NVT == Result.getValueType()) 1895f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // All the top bits are guaranteed to be zero - inform the optimizers. 1896fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getNode(ISD::AssertZext, dl, 1897ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result.getValueType(), Result, 1898f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands DAG.getValueType(SrcVT)); 1899f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1900f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1 = LegalizeOp(Result); 1901f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp2 = LegalizeOp(Ch); 1902f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands } else if (SrcWidth & (SrcWidth - 1)) { 1903f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // If not loading a power-of-2 number of bits, expand as two loads. 190483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(SrcVT.isExtended() && !SrcVT.isVector() && 1905f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands "Unsupported extload!"); 1906f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands unsigned RoundWidth = 1 << Log2_32(SrcWidth); 1907f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands assert(RoundWidth < SrcWidth); 1908f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands unsigned ExtraWidth = SrcWidth - RoundWidth; 1909f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands assert(ExtraWidth < RoundWidth); 1910f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands assert(!(RoundWidth % 8) && !(ExtraWidth % 8) && 1911f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands "Load size not an integral number of bytes!"); 191283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT RoundVT = MVT::getIntegerVT(RoundWidth); 191383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT ExtraVT = MVT::getIntegerVT(ExtraWidth); 1914475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Lo, Hi, Ch; 1915f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands unsigned IncrementSize; 1916f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1917f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands if (TLI.isLittleEndian()) { 1918f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // EXTLOAD:i24 -> ZEXTLOAD:i16 | (shl EXTLOAD@+2:i8, 16) 1919f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Load the bottom RoundWidth bits. 1920ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, 1921ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Node->getValueType(0), Tmp1, Tmp2, 1922f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands LD->getSrcValue(), SVOffset, RoundVT, isVolatile, 1923f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Alignment); 1924f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1925f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Load the remaining ExtraWidth bits. 1926f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands IncrementSize = RoundWidth / 8; 1927ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2, 1928f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands DAG.getIntPtrConstant(IncrementSize)); 1929ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getExtLoad(ExtType, dl, Node->getValueType(0), Tmp1, Tmp2, 1930f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands LD->getSrcValue(), SVOffset + IncrementSize, 1931f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands ExtraVT, isVolatile, 1932f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands MinAlign(Alignment, IncrementSize)); 1933f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1934f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Build a factor node to remember that this load is independent of the 1935f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // other one. 1936ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1), 1937f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Hi.getValue(1)); 1938f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1939f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Move the top bits to the right place. 1940ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getNode(ISD::SHL, dl, Hi.getValueType(), Hi, 1941f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands DAG.getConstant(RoundWidth, TLI.getShiftAmountTy())); 1942f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1943f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Join the hi and lo parts. 1944ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::OR, dl, Node->getValueType(0), Lo, Hi); 1945f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } else { 1946f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Big endian - avoid unaligned loads. 1947f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // EXTLOAD:i24 -> (shl EXTLOAD:i16, 8) | ZEXTLOAD@+2:i8 1948f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Load the top RoundWidth bits. 1949ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getExtLoad(ExtType, dl, Node->getValueType(0), Tmp1, Tmp2, 1950f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands LD->getSrcValue(), SVOffset, RoundVT, isVolatile, 1951f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Alignment); 1952f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1953f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Load the remaining ExtraWidth bits. 1954f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands IncrementSize = RoundWidth / 8; 1955ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2, 1956f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands DAG.getIntPtrConstant(IncrementSize)); 1957fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, 1958ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Node->getValueType(0), Tmp1, Tmp2, 1959f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands LD->getSrcValue(), SVOffset + IncrementSize, 1960f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands ExtraVT, isVolatile, 1961f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands MinAlign(Alignment, IncrementSize)); 1962f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1963f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Build a factor node to remember that this load is independent of the 1964f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // other one. 1965ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1), 1966f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Hi.getValue(1)); 1967f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1968f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Move the top bits to the right place. 1969ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getNode(ISD::SHL, dl, Hi.getValueType(), Hi, 1970f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands DAG.getConstant(ExtraWidth, TLI.getShiftAmountTy())); 1971f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1972f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Join the hi and lo parts. 1973ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::OR, dl, Node->getValueType(0), Lo, Hi); 1974f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands } 1975f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1976f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1 = LegalizeOp(Result); 1977f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp2 = LegalizeOp(Ch); 1978f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands } else { 19790329466b6b4927f4e6f5d144891fef06a027fec5Evan Cheng switch (TLI.getLoadExtAction(ExtType, SrcVT)) { 1980f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands default: assert(0 && "This action is not supported yet!"); 1981f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands case TargetLowering::Custom: 1982f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands isCustom = true; 1983f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // FALLTHROUGH 1984f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands case TargetLowering::Legal: 1985f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, LD->getOffset()); 1986f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1 = Result.getValue(0); 1987f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp2 = Result.getValue(1); 1988f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1989f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands if (isCustom) { 1990f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp3 = TLI.LowerOperation(Result, DAG); 1991ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp3.getNode()) { 1992f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1 = LegalizeOp(Tmp3); 1993f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp2 = LegalizeOp(Tmp3.getValue(1)); 1994f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands } 1995f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands } else { 1996f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // If this is an unaligned load and the target doesn't support it, 1997f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // expand it. 1998f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands if (!TLI.allowsUnalignedMemoryAccesses()) { 1999f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands unsigned ABIAlignment = TLI.getTargetData()-> 200083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands getABITypeAlignment(LD->getMemoryVT().getTypeForMVT()); 2001f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands if (LD->getAlignment() < ABIAlignment){ 2002ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Result = ExpandUnalignedLoad(cast<LoadSDNode>(Result.getNode()), DAG, 2003f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands TLI); 2004f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1 = Result.getOperand(0); 2005f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp2 = Result.getOperand(1); 2006f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1 = LegalizeOp(Tmp1); 2007f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp2 = LegalizeOp(Tmp2); 2008f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands } 2009f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 2010f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 2011f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands break; 2012f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands case TargetLowering::Expand: 2013f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // f64 = EXTLOAD f32 should expand to LOAD, FP_EXTEND 2014f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands if (SrcVT == MVT::f32 && Node->getValueType(0) == MVT::f64) { 2015ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue Load = DAG.getLoad(SrcVT, dl, Tmp1, Tmp2, LD->getSrcValue(), 2016f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands LD->getSrcValueOffset(), 2017f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands LD->isVolatile(), LD->getAlignment()); 2018fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getNode(ISD::FP_EXTEND, dl, 2019ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Node->getValueType(0), Load); 2020f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1 = LegalizeOp(Result); // Relegalize new nodes. 2021f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp2 = LegalizeOp(Load.getValue(1)); 2022f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands break; 2023f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands } 2024f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands assert(ExtType != ISD::EXTLOAD &&"EXTLOAD should always be supported!"); 2025f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Turn the unsupported load into an EXTLOAD followed by an explicit 2026f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // zero/sign extend inreg. 2027ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getExtLoad(ISD::EXTLOAD, dl, Node->getValueType(0), 2028f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1, Tmp2, LD->getSrcValue(), 2029f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands LD->getSrcValueOffset(), SrcVT, 2030f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands LD->isVolatile(), LD->getAlignment()); 2031475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue ValRes; 2032f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands if (ExtType == ISD::SEXTLOAD) 2033ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen ValRes = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, 2034ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result.getValueType(), 2035f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Result, DAG.getValueType(SrcVT)); 2036f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands else 2037ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen ValRes = DAG.getZeroExtendInReg(Result, dl, SrcVT); 2038f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1 = LegalizeOp(ValRes); // Relegalize new nodes. 2039f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp2 = LegalizeOp(Result.getValue(1)); // Relegalize new nodes. 2040466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng break; 2041466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng } 20429d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth } 2043f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 2044466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng // Since loads produce two values, make sure to remember that we legalized 2045466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng // both of them. 2046475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 0), Tmp1); 2047475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 1), Tmp2); 204899a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Op.getResNo() ? Tmp2 : Tmp1; 204901ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 205001ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 20515dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman case ISD::EXTRACT_ELEMENT: { 205283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT OpTy = Node->getOperand(0).getValueType(); 2053957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman if (cast<ConstantSDNode>(Node->getOperand(1))->getZExtValue()) { 2054957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman // 1 -> Hi 2055957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Result = DAG.getNode(ISD::SRL, dl, OpTy, Node->getOperand(0), 2056957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman DAG.getConstant(OpTy.getSizeInBits()/2, 2057957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman TLI.getShiftAmountTy())); 2058957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Result = DAG.getNode(ISD::TRUNCATE, dl, Node->getValueType(0), Result); 2059957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman } else { 2060957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman // 0 -> Lo 2061957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Result = DAG.getNode(ISD::TRUNCATE, dl, Node->getValueType(0), 2062957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Node->getOperand(0)); 20635dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 20643e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 20655dc897b0e4e5eb4513adc2f161412ce23f6bf2e0Nate Begeman } 20663e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 20673e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::CopyToReg: 20683e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 2069edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 20707310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner // Legalize the incoming value (must be a legal type). 2071d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Tmp2 = LegalizeOp(Node->getOperand(2)); 2072f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner if (Node->getNumValues() == 1) { 2073c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1), Tmp2); 20747310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner } else { 2075f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner assert(Node->getNumValues() == 2 && "Unknown CopyToReg"); 2076c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner if (Node->getNumOperands() == 4) { 2077f1a47c3371ecd5bb449f39736a36ebbebd4e9e14Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(3)); 2078c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1), Tmp2, 2079c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp3); 2080c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner } else { 2081c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1),Tmp2); 20827310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner } 2083fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 20847310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner // Since this produces two values, make sure to remember that we legalized 20857310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner // both of them. 2086475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 0), Result.getValue(0)); 2087475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 1), Result.getValue(1)); 2088c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner return Result; 20897310fb11f2a074069bf9ec3fc169c742ac48d32bChris Lattner } 20903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 20913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 20923e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::RET: 20933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 20946831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 20956831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Ensure that libcalls are emitted before a return. 2096ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Tmp1, LastCALLSEQ_END); 20976831a815999dde4cf801e2076e66b4943964daf2Chris Lattner Tmp1 = LegalizeOp(Tmp1); 20986831a815999dde4cf801e2076e66b4943964daf2Chris Lattner LastCALLSEQ_END = DAG.getEntryNode(); 2099fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 21003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getNumOperands()) { 21018e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng case 3: // ret val 210298f8aeb45fc1e54437cbb8f2a7445c609deab832Evan Cheng Tmp2 = Node->getOperand(1); 21038e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng Tmp3 = Node->getOperand(2); // Signness 2104957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Result = DAG.UpdateNodeOperands(Result, Tmp1, LegalizeOp(Tmp2), Tmp3); 21053e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 21063e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case 1: // ret void 2107c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1); 21083e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 21093e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: { // ret <values> 2110475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 8> NewValues; 21113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner NewValues.push_back(Tmp1); 2112957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman for (unsigned i = 1, e = Node->getNumOperands(); i < e; i += 2) { 2113957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman NewValues.push_back(LegalizeOp(Node->getOperand(i))); 2114957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman NewValues.push_back(Node->getOperand(i+1)); 2115957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman } 2116957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Result = DAG.UpdateNodeOperands(Result, &NewValues[0],NewValues.size()); 21173e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 21183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 21193e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 212017c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng 2121957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman switch (TLI.getOperationAction(Result.getOpcode(), MVT::Other)) { 2122957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman default: assert(0 && "This action is not supported yet!"); 2123957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman case TargetLowering::Legal: break; 2124957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman case TargetLowering::Custom: 2125957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp1 = TLI.LowerOperation(Result, DAG); 2126957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman if (Tmp1.getNode()) Result = Tmp1; 2127957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman break; 212817c428e23dbeac1f985d725905ce6be1c725491fEvan Cheng } 21293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 2130f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case ISD::STORE: { 21318b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng StoreSDNode *ST = cast<StoreSDNode>(Node); 21328b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng Tmp1 = LegalizeOp(ST->getChain()); // Legalize the chain. 21338b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng Tmp2 = LegalizeOp(ST->getBasePtr()); // Legalize the pointer. 2134d6fd1bc122ba791c698255d8be158b8ec424e248Dan Gohman int SVOffset = ST->getSrcValueOffset(); 2135d6fd1bc122ba791c698255d8be158b8ec424e248Dan Gohman unsigned Alignment = ST->getAlignment(); 2136d6fd1bc122ba791c698255d8be158b8ec424e248Dan Gohman bool isVolatile = ST->isVolatile(); 21378b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng 21388b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng if (!ST->isTruncatingStore()) { 2139d93d46ee7e0a0e539d42139b85c71b2b8c3968feChris Lattner // Turn 'store float 1.0, Ptr' -> 'store int 0x12345678, Ptr' 2140d93d46ee7e0a0e539d42139b85c71b2b8c3968feChris Lattner // FIXME: We shouldn't do this for TargetConstantFP's. 2141d93d46ee7e0a0e539d42139b85c71b2b8c3968feChris Lattner // FIXME: move this to the DAG Combiner! Note that we can't regress due 2142d93d46ee7e0a0e539d42139b85c71b2b8c3968feChris Lattner // to phase ordering between legalized code and the dag combiner. This 2143d93d46ee7e0a0e539d42139b85c71b2b8c3968feChris Lattner // probably means that we need to integrate dag combiner and legalizer 2144d93d46ee7e0a0e539d42139b85c71b2b8c3968feChris Lattner // together. 21459e3d3abd937c9bb79d56d25ec0e0724c7cbba67cDale Johannesen // We generally can't do this one for long doubles. 21462b4c279a8e203fa8b13adf7ba3a5d4c8bef70df3Chris Lattner if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(ST->getValue())) { 2147fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel if (CFP->getValueType(0) == MVT::f32 && 21483cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner getTypeAction(MVT::i32) == Legal) { 21496cf9b8adf43b0a460fb4ba8ddbff2787f5aa9d5eDan Gohman Tmp3 = DAG.getConstant(CFP->getValueAPF(). 21507111b02c734c992b8c97d9918118768026dad79eDale Johannesen bitcastToAPInt().zextOrTrunc(32), 21513f6eb7419de437436265831fce92f62498556e08Dale Johannesen MVT::i32); 2152ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getStore(Tmp1, dl, Tmp3, Tmp2, ST->getSrcValue(), 21539e3d3abd937c9bb79d56d25ec0e0724c7cbba67cDale Johannesen SVOffset, isVolatile, Alignment); 21549e3d3abd937c9bb79d56d25ec0e0724c7cbba67cDale Johannesen break; 21559e3d3abd937c9bb79d56d25ec0e0724c7cbba67cDale Johannesen } else if (CFP->getValueType(0) == MVT::f64) { 21563cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner // If this target supports 64-bit registers, do a single 64-bit store. 21573cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner if (getTypeAction(MVT::i64) == Legal) { 21587111b02c734c992b8c97d9918118768026dad79eDale Johannesen Tmp3 = DAG.getConstant(CFP->getValueAPF().bitcastToAPInt(). 21596cf9b8adf43b0a460fb4ba8ddbff2787f5aa9d5eDan Gohman zextOrTrunc(64), MVT::i64); 2160ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getStore(Tmp1, dl, Tmp3, Tmp2, ST->getSrcValue(), 21613cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner SVOffset, isVolatile, Alignment); 21623cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner break; 2163d4b9c17fb705c2f58ceef4f37d789ddb56783584Duncan Sands } else if (getTypeAction(MVT::i32) == Legal && !ST->isVolatile()) { 21643cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner // Otherwise, if the target supports 32-bit registers, use 2 32-bit 21653cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner // stores. If the target supports neither 32- nor 64-bits, this 21663cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner // xform is certainly not worth it. 21677111b02c734c992b8c97d9918118768026dad79eDale Johannesen const APInt &IntVal =CFP->getValueAPF().bitcastToAPInt(); 2168475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Lo = DAG.getConstant(APInt(IntVal).trunc(32), MVT::i32); 2169475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Hi = DAG.getConstant(IntVal.lshr(32).trunc(32), MVT::i32); 21700753fc1850a1ca4d17acca854d830d67737fd623Duncan Sands if (TLI.isBigEndian()) std::swap(Lo, Hi); 21713cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner 2172ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Lo = DAG.getStore(Tmp1, dl, Lo, Tmp2, ST->getSrcValue(), 21733cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner SVOffset, isVolatile, Alignment); 2174ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2, 21750bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(4)); 2176ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getStore(Tmp1, dl, Hi, Tmp2, ST->getSrcValue(), SVOffset+4, 2177dc84650679b6330e0fcdd4cf8bc2a351387db7caDuncan Sands isVolatile, MinAlign(Alignment, 4U)); 21783cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner 2179ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi); 21803cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner break; 21813cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner } 2182d93d46ee7e0a0e539d42139b85c71b2b8c3968feChris Lattner } 2183d93d46ee7e0a0e539d42139b85c71b2b8c3968feChris Lattner } 2184fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2185957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman { 21868b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng Tmp3 = LegalizeOp(ST->getValue()); 2187fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp3, Tmp2, 21888b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng ST->getOffset()); 21898b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng 219083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Tmp3.getValueType(); 21918b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng switch (TLI.getOperationAction(ISD::STORE, VT)) { 21928b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng default: assert(0 && "This action is not supported yet!"); 2193f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio case TargetLowering::Legal: 2194f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // If this is an unaligned store and the target doesn't support it, 2195f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // expand it. 2196f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio if (!TLI.allowsUnalignedMemoryAccesses()) { 2197f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio unsigned ABIAlignment = TLI.getTargetData()-> 219883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands getABITypeAlignment(ST->getMemoryVT().getTypeForMVT()); 2199f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio if (ST->getAlignment() < ABIAlignment) 2200ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Result = ExpandUnalignedStore(cast<StoreSDNode>(Result.getNode()), DAG, 2201f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio TLI); 2202f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 2203f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio break; 22048b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng case TargetLowering::Custom: 22058b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng Tmp1 = TLI.LowerOperation(Result, DAG); 2206ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 22078b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng break; 22088b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng case TargetLowering::Promote: 220983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(VT.isVector() && "Unknown legal promote case!"); 2210fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Tmp3 = DAG.getNode(ISD::BIT_CONVERT, dl, 22118b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng TLI.getTypeToPromoteTo(ISD::STORE, VT), Tmp3); 2212ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getStore(Tmp1, dl, Tmp3, Tmp2, 2213d6fd1bc122ba791c698255d8be158b8ec424e248Dan Gohman ST->getSrcValue(), SVOffset, isVolatile, 2214d6fd1bc122ba791c698255d8be158b8ec424e248Dan Gohman Alignment); 22158b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng break; 22168b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng } 22172efce0a589e2a688a1a06b5dc2ed0db32ae79924Chris Lattner break; 2218f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 22198b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng } else { 2220957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp3 = LegalizeOp(ST->getValue()); 22217e857201f387d004571e6058e2ea709163500f38Duncan Sands 222283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT StVT = ST->getMemoryVT(); 222383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned StWidth = StVT.getSizeInBits(); 22247e857201f387d004571e6058e2ea709163500f38Duncan Sands 222583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (StWidth != StVT.getStoreSizeInBits()) { 22267e857201f387d004571e6058e2ea709163500f38Duncan Sands // Promote to a byte-sized store with upper bits zero if not 22277e857201f387d004571e6058e2ea709163500f38Duncan Sands // storing an integral number of bytes. For example, promote 22287e857201f387d004571e6058e2ea709163500f38Duncan Sands // TRUNCSTORE:i1 X -> TRUNCSTORE:i8 (and X, 1) 222983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = MVT::getIntegerVT(StVT.getStoreSizeInBits()); 2230ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp3 = DAG.getZeroExtendInReg(Tmp3, dl, StVT); 2231ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getTruncStore(Tmp1, dl, Tmp3, Tmp2, ST->getSrcValue(), 22327e857201f387d004571e6058e2ea709163500f38Duncan Sands SVOffset, NVT, isVolatile, Alignment); 22337e857201f387d004571e6058e2ea709163500f38Duncan Sands } else if (StWidth & (StWidth - 1)) { 22347e857201f387d004571e6058e2ea709163500f38Duncan Sands // If not storing a power-of-2 number of bits, expand as two stores. 223583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(StVT.isExtended() && !StVT.isVector() && 22367e857201f387d004571e6058e2ea709163500f38Duncan Sands "Unsupported truncstore!"); 22377e857201f387d004571e6058e2ea709163500f38Duncan Sands unsigned RoundWidth = 1 << Log2_32(StWidth); 22387e857201f387d004571e6058e2ea709163500f38Duncan Sands assert(RoundWidth < StWidth); 22397e857201f387d004571e6058e2ea709163500f38Duncan Sands unsigned ExtraWidth = StWidth - RoundWidth; 22407e857201f387d004571e6058e2ea709163500f38Duncan Sands assert(ExtraWidth < RoundWidth); 22417e857201f387d004571e6058e2ea709163500f38Duncan Sands assert(!(RoundWidth % 8) && !(ExtraWidth % 8) && 22427e857201f387d004571e6058e2ea709163500f38Duncan Sands "Store size not an integral number of bytes!"); 224383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT RoundVT = MVT::getIntegerVT(RoundWidth); 224483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT ExtraVT = MVT::getIntegerVT(ExtraWidth); 2245475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Lo, Hi; 22467e857201f387d004571e6058e2ea709163500f38Duncan Sands unsigned IncrementSize; 22477e857201f387d004571e6058e2ea709163500f38Duncan Sands 22487e857201f387d004571e6058e2ea709163500f38Duncan Sands if (TLI.isLittleEndian()) { 22497e857201f387d004571e6058e2ea709163500f38Duncan Sands // TRUNCSTORE:i24 X -> TRUNCSTORE:i16 X, TRUNCSTORE@+2:i8 (srl X, 16) 22507e857201f387d004571e6058e2ea709163500f38Duncan Sands // Store the bottom RoundWidth bits. 2251ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Lo = DAG.getTruncStore(Tmp1, dl, Tmp3, Tmp2, ST->getSrcValue(), 22527e857201f387d004571e6058e2ea709163500f38Duncan Sands SVOffset, RoundVT, 22537e857201f387d004571e6058e2ea709163500f38Duncan Sands isVolatile, Alignment); 22547e857201f387d004571e6058e2ea709163500f38Duncan Sands 22557e857201f387d004571e6058e2ea709163500f38Duncan Sands // Store the remaining ExtraWidth bits. 22567e857201f387d004571e6058e2ea709163500f38Duncan Sands IncrementSize = RoundWidth / 8; 2257ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2, 22587e857201f387d004571e6058e2ea709163500f38Duncan Sands DAG.getIntPtrConstant(IncrementSize)); 2259ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getNode(ISD::SRL, dl, Tmp3.getValueType(), Tmp3, 22607e857201f387d004571e6058e2ea709163500f38Duncan Sands DAG.getConstant(RoundWidth, TLI.getShiftAmountTy())); 2261ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getTruncStore(Tmp1, dl, Hi, Tmp2, ST->getSrcValue(), 22627e857201f387d004571e6058e2ea709163500f38Duncan Sands SVOffset + IncrementSize, ExtraVT, isVolatile, 22637e857201f387d004571e6058e2ea709163500f38Duncan Sands MinAlign(Alignment, IncrementSize)); 22647e857201f387d004571e6058e2ea709163500f38Duncan Sands } else { 22657e857201f387d004571e6058e2ea709163500f38Duncan Sands // Big endian - avoid unaligned stores. 22667e857201f387d004571e6058e2ea709163500f38Duncan Sands // TRUNCSTORE:i24 X -> TRUNCSTORE:i16 (srl X, 8), TRUNCSTORE@+2:i8 X 22677e857201f387d004571e6058e2ea709163500f38Duncan Sands // Store the top RoundWidth bits. 2268ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getNode(ISD::SRL, dl, Tmp3.getValueType(), Tmp3, 22697e857201f387d004571e6058e2ea709163500f38Duncan Sands DAG.getConstant(ExtraWidth, TLI.getShiftAmountTy())); 2270ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getTruncStore(Tmp1, dl, Hi, Tmp2, ST->getSrcValue(), 2271ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SVOffset, RoundVT, isVolatile, Alignment); 22727e857201f387d004571e6058e2ea709163500f38Duncan Sands 22737e857201f387d004571e6058e2ea709163500f38Duncan Sands // Store the remaining ExtraWidth bits. 22747e857201f387d004571e6058e2ea709163500f38Duncan Sands IncrementSize = RoundWidth / 8; 2275ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2, 22767e857201f387d004571e6058e2ea709163500f38Duncan Sands DAG.getIntPtrConstant(IncrementSize)); 2277ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Lo = DAG.getTruncStore(Tmp1, dl, Tmp3, Tmp2, ST->getSrcValue(), 22787e857201f387d004571e6058e2ea709163500f38Duncan Sands SVOffset + IncrementSize, ExtraVT, isVolatile, 22797e857201f387d004571e6058e2ea709163500f38Duncan Sands MinAlign(Alignment, IncrementSize)); 22807e857201f387d004571e6058e2ea709163500f38Duncan Sands } 2281c7029805ef35ce9805931067b841e6af11db382eChris Lattner 22827e857201f387d004571e6058e2ea709163500f38Duncan Sands // The order of the stores doesn't matter. 2283ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi); 22847e857201f387d004571e6058e2ea709163500f38Duncan Sands } else { 22857e857201f387d004571e6058e2ea709163500f38Duncan Sands if (Tmp1 != ST->getChain() || Tmp3 != ST->getValue() || 22867e857201f387d004571e6058e2ea709163500f38Duncan Sands Tmp2 != ST->getBasePtr()) 22877e857201f387d004571e6058e2ea709163500f38Duncan Sands Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp3, Tmp2, 22887e857201f387d004571e6058e2ea709163500f38Duncan Sands ST->getOffset()); 22897e857201f387d004571e6058e2ea709163500f38Duncan Sands 22907e857201f387d004571e6058e2ea709163500f38Duncan Sands switch (TLI.getTruncStoreAction(ST->getValue().getValueType(), StVT)) { 22917e857201f387d004571e6058e2ea709163500f38Duncan Sands default: assert(0 && "This action is not supported yet!"); 22927e857201f387d004571e6058e2ea709163500f38Duncan Sands case TargetLowering::Legal: 22937e857201f387d004571e6058e2ea709163500f38Duncan Sands // If this is an unaligned store and the target doesn't support it, 22947e857201f387d004571e6058e2ea709163500f38Duncan Sands // expand it. 22957e857201f387d004571e6058e2ea709163500f38Duncan Sands if (!TLI.allowsUnalignedMemoryAccesses()) { 22967e857201f387d004571e6058e2ea709163500f38Duncan Sands unsigned ABIAlignment = TLI.getTargetData()-> 229783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands getABITypeAlignment(ST->getMemoryVT().getTypeForMVT()); 22987e857201f387d004571e6058e2ea709163500f38Duncan Sands if (ST->getAlignment() < ABIAlignment) 2299ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Result = ExpandUnalignedStore(cast<StoreSDNode>(Result.getNode()), DAG, 23007e857201f387d004571e6058e2ea709163500f38Duncan Sands TLI); 23017e857201f387d004571e6058e2ea709163500f38Duncan Sands } 23027e857201f387d004571e6058e2ea709163500f38Duncan Sands break; 23037e857201f387d004571e6058e2ea709163500f38Duncan Sands case TargetLowering::Custom: 23047e857201f387d004571e6058e2ea709163500f38Duncan Sands Result = TLI.LowerOperation(Result, DAG); 23057e857201f387d004571e6058e2ea709163500f38Duncan Sands break; 23067e857201f387d004571e6058e2ea709163500f38Duncan Sands case Expand: 23077e857201f387d004571e6058e2ea709163500f38Duncan Sands // TRUNCSTORE:i16 i32 -> STORE i16 23087e857201f387d004571e6058e2ea709163500f38Duncan Sands assert(isTypeLegal(StVT) && "Do not know how to expand this store!"); 2309ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp3 = DAG.getNode(ISD::TRUNCATE, dl, StVT, Tmp3); 2310ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getStore(Tmp1, dl, Tmp3, Tmp2, ST->getSrcValue(), 2311ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SVOffset, isVolatile, Alignment); 23127e857201f387d004571e6058e2ea709163500f38Duncan Sands break; 2313f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 23148b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng } 23153e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 23163e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 2317f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 231895762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth case ISD::PCMARKER: 231995762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 2320c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1)); 232195762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth break; 2322140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case ISD::STACKSAVE: 2323140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 2324c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1); 2325c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp1 = Result.getValue(0); 2326c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp2 = Result.getValue(1); 2327fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2328140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner switch (TLI.getOperationAction(ISD::STACKSAVE, MVT::Other)) { 2329140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner default: assert(0 && "This action is not supported yet!"); 2330456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Legal: break; 2331456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 2332c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp3 = TLI.LowerOperation(Result, DAG); 2333ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp3.getNode()) { 2334c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp1 = LegalizeOp(Tmp3); 2335c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp2 = LegalizeOp(Tmp3.getValue(1)); 2336140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner } 2337456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner break; 2338140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case TargetLowering::Expand: 2339fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // Expand to CopyFromReg if the target set 23404f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner // StackPointerRegisterToSaveRestore. 23414f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner if (unsigned SP = TLI.getStackPointerRegisterToSaveRestore()) { 2342c460ae90019ddb19d4c07b2cd2fbaecfa7adf67dDale Johannesen Tmp1 = DAG.getCopyFromReg(Result.getOperand(0), dl, SP, 23434f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner Node->getValueType(0)); 2344c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp2 = Tmp1.getValue(1); 23454f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner } else { 2346e8d7230f480654cdb8ff1c3d0a38e1e9ab0bd55fDale Johannesen Tmp1 = DAG.getUNDEF(Node->getValueType(0)); 2347c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp2 = Node->getOperand(0); 23484f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner } 2349456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner break; 2350140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner } 2351456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner 2352456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner // Since stacksave produce two values, make sure to remember that we 2353456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner // legalized both of them. 2354475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 0), Tmp1); 2355475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 1), Tmp2); 235699a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Op.getResNo() ? Tmp2 : Tmp1; 2357456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner 2358140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case ISD::STACKRESTORE: 2359140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 2360140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 2361c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); 2362fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2363140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner switch (TLI.getOperationAction(ISD::STACKRESTORE, MVT::Other)) { 2364140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner default: assert(0 && "This action is not supported yet!"); 2365456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Legal: break; 2366456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 2367456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp1 = TLI.LowerOperation(Result, DAG); 2368ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 2369140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner break; 2370140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case TargetLowering::Expand: 2371fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // Expand to CopyToReg if the target set 23724f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner // StackPointerRegisterToSaveRestore. 23734f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner if (unsigned SP = TLI.getStackPointerRegisterToSaveRestore()) { 2374c460ae90019ddb19d4c07b2cd2fbaecfa7adf67dDale Johannesen Result = DAG.getCopyToReg(Tmp1, dl, SP, Tmp2); 23754f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner } else { 23764f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner Result = Tmp1; 23774f0d8e4018d50c5796660a4fa167763f46259646Chris Lattner } 2378140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner break; 2379140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner } 2380140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner break; 2381140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner 238251b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth case ISD::READCYCLECOUNTER: 238351b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain 2384c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1); 2385f0b3ba6752a49a8868d423ddc2704a52b7101571Evan Cheng switch (TLI.getOperationAction(ISD::READCYCLECOUNTER, 2386f0b3ba6752a49a8868d423ddc2704a52b7101571Evan Cheng Node->getValueType(0))) { 2387f0b3ba6752a49a8868d423ddc2704a52b7101571Evan Cheng default: assert(0 && "This action is not supported yet!"); 23886a16c5ab2d7786583d3c9a79646dc85fbda6cd41Evan Cheng case TargetLowering::Legal: 23896a16c5ab2d7786583d3c9a79646dc85fbda6cd41Evan Cheng Tmp1 = Result.getValue(0); 23906a16c5ab2d7786583d3c9a79646dc85fbda6cd41Evan Cheng Tmp2 = Result.getValue(1); 23916a16c5ab2d7786583d3c9a79646dc85fbda6cd41Evan Cheng break; 2392f0b3ba6752a49a8868d423ddc2704a52b7101571Evan Cheng case TargetLowering::Custom: 2393f0b3ba6752a49a8868d423ddc2704a52b7101571Evan Cheng Result = TLI.LowerOperation(Result, DAG); 23946a16c5ab2d7786583d3c9a79646dc85fbda6cd41Evan Cheng Tmp1 = LegalizeOp(Result.getValue(0)); 23956a16c5ab2d7786583d3c9a79646dc85fbda6cd41Evan Cheng Tmp2 = LegalizeOp(Result.getValue(1)); 2396f0b3ba6752a49a8868d423ddc2704a52b7101571Evan Cheng break; 2397f0b3ba6752a49a8868d423ddc2704a52b7101571Evan Cheng } 239849c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth 239949c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth // Since rdcc produce two values, make sure to remember that we legalized 240049c709f891a3e49db58b56ca94eafa98cbb12c4dAndrew Lenharth // both of them. 2401475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 0), Tmp1); 2402475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 1), Tmp2); 2403c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner return Result; 2404f70e30b41dc6a92733681dcea2c06d8b3dd488dbAndrew Lenharth 24052ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner case ISD::SELECT: 2406957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 24073e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // TrueVal 24082ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // FalseVal 240955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 2410c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3); 2411fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2412b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman switch (TLI.getOperationAction(ISD::SELECT, Tmp2.getValueType())) { 241355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action is not supported yet!"); 2414456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Legal: break; 2415456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: { 2416456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp1 = TLI.LowerOperation(Result, DAG); 2417ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 2418456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner break; 2419456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner } 24209373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case TargetLowering::Expand: 24219373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 2422fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getSelectCC(dl, Tmp1.getOperand(0), Tmp1.getOperand(1), 24239373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, 24249373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman cast<CondCodeSDNode>(Tmp1.getOperand(2))->get()); 24259373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 2426fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getSelectCC(dl, Tmp1, 24279373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 24289373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, ISD::SETNE); 24299373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 243055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 243155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Promote: { 243283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = 243355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TLI.getTypeToPromoteTo(ISD::SELECT, Tmp2.getValueType()); 243455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner unsigned ExtOp, TruncOp; 243583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (Tmp2.getValueType().isVector()) { 243641f6cbbeb21d7d4376b8c0302b9766c3e43be5f2Evan Cheng ExtOp = ISD::BIT_CONVERT; 243741f6cbbeb21d7d4376b8c0302b9766c3e43be5f2Evan Cheng TruncOp = ISD::BIT_CONVERT; 243883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands } else if (Tmp2.getValueType().isInteger()) { 2439456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner ExtOp = ISD::ANY_EXTEND; 2440456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner TruncOp = ISD::TRUNCATE; 244155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } else { 2442456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner ExtOp = ISD::FP_EXTEND; 2443456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner TruncOp = ISD::FP_ROUND; 244455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 244555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Promote each of the values to the new type. 2446ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ExtOp, dl, NVT, Tmp2); 2447ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp3 = DAG.getNode(ExtOp, dl, NVT, Tmp3); 244855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Perform the larger operation, then round down. 2449ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson Result = DAG.getNode(ISD::SELECT, dl, NVT, Tmp1, Tmp2, Tmp3); 24500bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner if (TruncOp != ISD::FP_ROUND) 2451ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(TruncOp, dl, Node->getValueType(0), Result); 24520bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner else 2453ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(TruncOp, dl, Node->getValueType(0), Result, 24540bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(0)); 245555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 245655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 245755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 24583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 2459750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman case ISD::SELECT_CC: { 2460750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp1 = Node->getOperand(0); // LHS 2461750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp2 = Node->getOperand(1); // RHS 24629373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(2)); // True 24639373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp4 = LegalizeOp(Node->getOperand(3)); // False 2464475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue CC = Node->getOperand(4); 2465fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2466fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel LegalizeSetCC(TLI.getSetCCResultType(Tmp1.getValueType()), 2467bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Tmp1, Tmp2, CC, dl); 2468fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 24697f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng // If we didn't get both a LHS and RHS back from LegalizeSetCC, 2470750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman // the LHS is a legal SETCC itself. In this case, we need to compare 2471750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman // the result against zero to select between true and false values. 2472ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp2.getNode() == 0) { 2473750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp2 = DAG.getConstant(0, Tmp1.getValueType()); 2474750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman CC = DAG.getCondCode(ISD::SETNE); 2475750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman } 2476750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3, Tmp4, CC); 2477750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman 2478750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman // Everything is legal, see if we should expand this op or something. 2479750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman switch (TLI.getOperationAction(ISD::SELECT_CC, Tmp3.getValueType())) { 2480750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman default: assert(0 && "This action is not supported yet!"); 2481750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman case TargetLowering::Legal: break; 2482750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman case TargetLowering::Custom: 2483750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp1 = TLI.LowerOperation(Result, DAG); 2484ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 24859373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 24869373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 24879373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 2488750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman } 24893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETCC: 2490750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp1 = Node->getOperand(0); 2491750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp2 = Node->getOperand(1); 2492750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp3 = Node->getOperand(2); 2493bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen LegalizeSetCC(Node->getValueType(0), Tmp1, Tmp2, Tmp3, dl); 2494fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2495fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // If we had to Expand the SetCC operands into a SELECT node, then it may 2496fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // not always be possible to return a true LHS & RHS. In this case, just 2497750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman // return the value we legalized, returned in the LHS 2498ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp2.getNode() == 0) { 2499750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Result = Tmp1; 25003e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 25013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 2502b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman 250373e142f2b6a3b5223de2d557d646f319ca8168cfChris Lattner switch (TLI.getOperationAction(ISD::SETCC, Tmp1.getValueType())) { 2504456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner default: assert(0 && "Cannot handle this action for SETCC yet!"); 2505456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 2506456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner isCustom = true; 2507456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner // FALLTHROUGH. 2508456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Legal: 25092b49c500838666dd0186d021389d4dd70ffda240Evan Cheng Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3); 2510456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner if (isCustom) { 25112b49c500838666dd0186d021389d4dd70ffda240Evan Cheng Tmp4 = TLI.LowerOperation(Result, DAG); 2512ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp4.getNode()) Result = Tmp4; 2513456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner } 2514b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 2515ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth case TargetLowering::Promote: { 2516ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // First step, figure out the appropriate operation to use. 2517ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Allow SETCC to not be supported for all legal data types 2518ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Mostly this targets FP 251983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NewInTy = Node->getOperand(0).getValueType(); 252083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT OldVT = NewInTy; OldVT = OldVT; 2521ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 2522ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Scan for the appropriate larger type to use. 2523ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth while (1) { 252483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands NewInTy = (MVT::SimpleValueType)(NewInTy.getSimpleVT()+1); 2525ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 252683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(NewInTy.isInteger() == OldVT.isInteger() && 2527ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth "Fell off of the edge of the integer world"); 252883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(NewInTy.isFloatingPoint() == OldVT.isFloatingPoint() && 2529ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth "Fell off of the edge of the floating point world"); 2530fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2531ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // If the target supports SETCC of this type, use it. 2532f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman if (TLI.isOperationLegalOrCustom(ISD::SETCC, NewInTy)) 2533ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth break; 2534ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 253583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (NewInTy.isInteger()) 2536ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth assert(0 && "Cannot promote Legal Integer SETCC yet"); 2537ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth else { 2538ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::FP_EXTEND, dl, NewInTy, Tmp1); 2539ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::FP_EXTEND, dl, NewInTy, Tmp2); 2540ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 2541c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp1 = LegalizeOp(Tmp1); 2542c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp2 = LegalizeOp(Tmp2); 25432b49c500838666dd0186d021389d4dd70ffda240Evan Cheng Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3); 2544433f8acefb78f1c8a2cf79c12b101ce7c4b20202Evan Cheng Result = LegalizeOp(Result); 25455e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth break; 2546ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 2547b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman case TargetLowering::Expand: 2548b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // Expand a setcc node into a select_cc of the same condition, lhs, and 2549b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // rhs that selects between const 1 (true) and const 0 (false). 255083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 2551fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getNode(ISD::SELECT_CC, dl, VT, Tmp1, Tmp2, 2552b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman DAG.getConstant(1, VT), DAG.getConstant(0, VT), 25532b49c500838666dd0186d021389d4dd70ffda240Evan Cheng Tmp3); 2554b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 2555b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman } 25563e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 2557b43e9c196542acc80c9e4643809661065710848fNate Begeman case ISD::VSETCC: { 2558b43e9c196542acc80c9e4643809661065710848fNate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 2559b43e9c196542acc80c9e4643809661065710848fNate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 2560475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue CC = Node->getOperand(2); 2561fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2562b43e9c196542acc80c9e4643809661065710848fNate Begeman Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, CC); 2563b43e9c196542acc80c9e4643809661065710848fNate Begeman 2564b43e9c196542acc80c9e4643809661065710848fNate Begeman // Everything is legal, see if we should expand this op or something. 2565b43e9c196542acc80c9e4643809661065710848fNate Begeman switch (TLI.getOperationAction(ISD::VSETCC, Tmp1.getValueType())) { 2566b43e9c196542acc80c9e4643809661065710848fNate Begeman default: assert(0 && "This action is not supported yet!"); 2567b43e9c196542acc80c9e4643809661065710848fNate Begeman case TargetLowering::Legal: break; 2568b43e9c196542acc80c9e4643809661065710848fNate Begeman case TargetLowering::Custom: 2569b43e9c196542acc80c9e4643809661065710848fNate Begeman Tmp1 = TLI.LowerOperation(Result, DAG); 2570ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 2571b43e9c196542acc80c9e4643809661065710848fNate Begeman break; 2572e1a0b2e0bbf2bd905afc628c96d8892edb304a3eMon P Wang case TargetLowering::Expand: { 2573e1a0b2e0bbf2bd905afc628c96d8892edb304a3eMon P Wang // Unroll into a nasty set of scalar code for now. 2574e1a0b2e0bbf2bd905afc628c96d8892edb304a3eMon P Wang MVT VT = Node->getValueType(0); 2575e1a0b2e0bbf2bd905afc628c96d8892edb304a3eMon P Wang unsigned NumElems = VT.getVectorNumElements(); 2576e1a0b2e0bbf2bd905afc628c96d8892edb304a3eMon P Wang MVT EltVT = VT.getVectorElementType(); 2577e1a0b2e0bbf2bd905afc628c96d8892edb304a3eMon P Wang MVT TmpEltVT = Tmp1.getValueType().getVectorElementType(); 2578e1a0b2e0bbf2bd905afc628c96d8892edb304a3eMon P Wang SmallVector<SDValue, 8> Ops(NumElems); 2579e1a0b2e0bbf2bd905afc628c96d8892edb304a3eMon P Wang for (unsigned i = 0; i < NumElems; ++i) { 2580ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue In1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, TmpEltVT, 2581e1a0b2e0bbf2bd905afc628c96d8892edb304a3eMon P Wang Tmp1, DAG.getIntPtrConstant(i)); 2582ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Ops[i] = DAG.getNode(ISD::SETCC, dl, TLI.getSetCCResultType(TmpEltVT), 2583ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen In1, DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, 2584ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen TmpEltVT, Tmp2, 2585ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen DAG.getIntPtrConstant(i)), 258684aff84cfab7fe9822a60ca378c66079bad6be85Mon P Wang CC); 2587ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson Ops[i] = DAG.getNode(ISD::SELECT, dl, EltVT, Ops[i], 2588ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson DAG.getConstant(APInt::getAllOnesValue 2589ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson (EltVT.getSizeInBits()), EltVT), 2590ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson DAG.getConstant(0, EltVT)); 2591e1a0b2e0bbf2bd905afc628c96d8892edb304a3eMon P Wang } 2592a87008d90b7d894cfca53d407642acfd7be2af3cEvan Cheng Result = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &Ops[0], NumElems); 2593e1a0b2e0bbf2bd905afc628c96d8892edb304a3eMon P Wang break; 2594e1a0b2e0bbf2bd905afc628c96d8892edb304a3eMon P Wang } 2595b43e9c196542acc80c9e4643809661065710848fNate Begeman } 2596b43e9c196542acc80c9e4643809661065710848fNate Begeman break; 2597b43e9c196542acc80c9e4643809661065710848fNate Begeman } 259852d08bd9d8a8dcc06148525c7fad6f2ebcad0a42Chris Lattner 25995b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SHL_PARTS: 26005b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRA_PARTS: 26015b359c6c4f052e41579ad7da9af37db4f54207d9Chris Lattner case ISD::SRL_PARTS: { 2602475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 8> Ops; 260384f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner bool Changed = false; 260492abc62399881ba9c525be80362c134ad836e2d9Duncan Sands unsigned N = Node->getNumOperands(); 260592abc62399881ba9c525be80362c134ad836e2d9Duncan Sands for (unsigned i = 0; i + 1 < N; ++i) { 260684f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Ops.push_back(LegalizeOp(Node->getOperand(i))); 260784f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner Changed |= Ops.back() != Node->getOperand(i); 260884f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 260992abc62399881ba9c525be80362c134ad836e2d9Duncan Sands Ops.push_back(LegalizeOp(DAG.getShiftAmountOperand(Node->getOperand(N-1)))); 261092abc62399881ba9c525be80362c134ad836e2d9Duncan Sands Changed |= Ops.back() != Node->getOperand(N-1); 2611c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner if (Changed) 2612f06f35e30b4c4d7db304f717a3d4dc6595fbd078Chris Lattner Result = DAG.UpdateNodeOperands(Result, &Ops[0], Ops.size()); 26132c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 261405a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng switch (TLI.getOperationAction(Node->getOpcode(), 261505a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng Node->getValueType(0))) { 261605a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng default: assert(0 && "This action is not supported yet!"); 2617456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Legal: break; 2618456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 2619456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp1 = TLI.LowerOperation(Result, DAG); 2620ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) { 2621475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp2, RetVal(0, 0); 262205a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) { 2623456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp2 = LegalizeOp(Tmp1.getValue(i)); 2624475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, i), Tmp2); 262599a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif if (i == Op.getResNo()) 262612f2274ba8c6af21e8b6c71ef872afe43a64b6d7Evan Cheng RetVal = Tmp2; 262705a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng } 2628ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif assert(RetVal.getNode() && "Illegal result number"); 262905a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng return RetVal; 263005a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng } 263105a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng break; 263205a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng } 263305a2d568c60b8d547a5ac78f99107c476e6612b5Evan Cheng 26342c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Since these produce multiple values, make sure to remember that we 26352c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // legalized all of them. 26362c8086f4b9916b2d02842be5e375276023225fbaChris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 2637475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, i), Result.getValue(i)); 263899a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Result.getValue(Op.getResNo()); 263984f6788044f9b1b47945e98ce23a6cf4d7d32579Chris Lattner } 26402c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 26412c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Binary operators 26423e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ADD: 26433e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SUB: 26443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::MUL: 2645c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHS: 2646c7c16575fea9aeffe8a63ddabe7c3c25f81ed799Nate Begeman case ISD::MULHU: 26473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::UDIV: 26483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SDIV: 26493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::AND: 26503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::OR: 26513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::XOR: 265203c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SHL: 265303c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRL: 265403c0cf822e9a57109d1b4e6a2705d68852c93e1dChris Lattner case ISD::SRA: 265501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FADD: 265601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FSUB: 265701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FMUL: 265801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FDIV: 2659826695281344e3a4c4d44d73dd155107aafd689bDan Gohman case ISD::FPOW: 26603e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 266192abc62399881ba9c525be80362c134ad836e2d9Duncan Sands Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 266292abc62399881ba9c525be80362c134ad836e2d9Duncan Sands 266392abc62399881ba9c525be80362c134ad836e2d9Duncan Sands if ((Node->getOpcode() == ISD::SHL || 266492abc62399881ba9c525be80362c134ad836e2d9Duncan Sands Node->getOpcode() == ISD::SRL || 266592abc62399881ba9c525be80362c134ad836e2d9Duncan Sands Node->getOpcode() == ISD::SRA) && 266692abc62399881ba9c525be80362c134ad836e2d9Duncan Sands !Node->getValueType(0).isVector()) 266792abc62399881ba9c525be80362c134ad836e2d9Duncan Sands Tmp2 = DAG.getShiftAmountOperand(Tmp2); 266892abc62399881ba9c525be80362c134ad836e2d9Duncan Sands 2669957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp2 = LegalizeOp(Tmp2); // Legalize the RHS. 26705bc1ea0736a5785ed596d58beeff2ab23909e33dNate Begeman 2671c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); 2672aeb06d246254e4829a49164a11eacced9a43d9d4Mon P Wang 2673e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 2674bc70cf8be95f33f9aa30c8c3d0fd79e3fa636360Chris Lattner default: assert(0 && "BinOp legalize operation not supported"); 2675456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Legal: break; 2676456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 2677456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp1 = TLI.LowerOperation(Result, DAG); 2678ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) { 26795bc1ea0736a5785ed596d58beeff2ab23909e33dNate Begeman Result = Tmp1; 26805bc1ea0736a5785ed596d58beeff2ab23909e33dNate Begeman break; 268124dc346a16397bf740d8d961cd1ebec8d2f46957Nate Begeman } 26825bc1ea0736a5785ed596d58beeff2ab23909e33dNate Begeman // Fall through if the custom lower can't deal with the operation 2683bc70cf8be95f33f9aa30c8c3d0fd79e3fa636360Chris Lattner case TargetLowering::Expand: { 268483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Op.getValueType(); 2685fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2686525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman // See if multiply or divide can be lowered using two-result operations. 2687525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman SDVTList VTs = DAG.getVTList(VT, VT); 2688525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman if (Node->getOpcode() == ISD::MUL) { 2689525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman // We just need the low half of the multiply; try both the signed 2690525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman // and unsigned forms. If the target supports both SMUL_LOHI and 2691525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman // UMUL_LOHI, form a preference by checking which forms of plain 2692525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman // MULH it supports. 2693f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman bool HasSMUL_LOHI = TLI.isOperationLegalOrCustom(ISD::SMUL_LOHI, VT); 2694f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman bool HasUMUL_LOHI = TLI.isOperationLegalOrCustom(ISD::UMUL_LOHI, VT); 2695f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman bool HasMULHS = TLI.isOperationLegalOrCustom(ISD::MULHS, VT); 2696f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman bool HasMULHU = TLI.isOperationLegalOrCustom(ISD::MULHU, VT); 2697525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman unsigned OpToUse = 0; 2698525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman if (HasSMUL_LOHI && !HasMULHS) { 2699525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman OpToUse = ISD::SMUL_LOHI; 2700525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman } else if (HasUMUL_LOHI && !HasMULHU) { 2701525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman OpToUse = ISD::UMUL_LOHI; 2702525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman } else if (HasSMUL_LOHI) { 2703525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman OpToUse = ISD::SMUL_LOHI; 2704525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman } else if (HasUMUL_LOHI) { 2705525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman OpToUse = ISD::UMUL_LOHI; 2706525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman } 2707525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman if (OpToUse) { 2708a9cad0e7e09e6d34de2fccb4f1294b7f0b8f3b68Duncan Sands Result = DAG.getNode(OpToUse, dl, VTs, Tmp1, Tmp2); 2709525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman break; 2710525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman } 2711525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman } 2712525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman if (Node->getOpcode() == ISD::MULHS && 2713f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman TLI.isOperationLegalOrCustom(ISD::SMUL_LOHI, VT)) { 2714fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = SDValue(DAG.getNode(ISD::SMUL_LOHI, dl, 2715ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen VTs, Tmp1, Tmp2).getNode(), 271631d7161206d7502e97a01a51a76445a8d9ac6ea5Chris Lattner 1); 2717525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman break; 2718525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman } 2719fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel if (Node->getOpcode() == ISD::MULHU && 2720f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman TLI.isOperationLegalOrCustom(ISD::UMUL_LOHI, VT)) { 2721ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = SDValue(DAG.getNode(ISD::UMUL_LOHI, dl, 2722ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen VTs, Tmp1, Tmp2).getNode(), 272331d7161206d7502e97a01a51a76445a8d9ac6ea5Chris Lattner 1); 2724525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman break; 2725525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman } 2726525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman if (Node->getOpcode() == ISD::SDIV && 2727f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman TLI.isOperationLegalOrCustom(ISD::SDIVREM, VT)) { 2728a9cad0e7e09e6d34de2fccb4f1294b7f0b8f3b68Duncan Sands Result = DAG.getNode(ISD::SDIVREM, dl, VTs, Tmp1, Tmp2); 2729525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman break; 2730525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman } 2731525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman if (Node->getOpcode() == ISD::UDIV && 2732f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman TLI.isOperationLegalOrCustom(ISD::UDIVREM, VT)) { 2733a9cad0e7e09e6d34de2fccb4f1294b7f0b8f3b68Duncan Sands Result = DAG.getNode(ISD::UDIVREM, dl, VTs, Tmp1, Tmp2); 2734a9cad0e7e09e6d34de2fccb4f1294b7f0b8f3b68Duncan Sands break; 2735a9cad0e7e09e6d34de2fccb4f1294b7f0b8f3b68Duncan Sands } 2736a9cad0e7e09e6d34de2fccb4f1294b7f0b8f3b68Duncan Sands if (Node->getOpcode() == ISD::SUB && 2737a9cad0e7e09e6d34de2fccb4f1294b7f0b8f3b68Duncan Sands TLI.isOperationLegalOrCustom(ISD::ADD, VT) && 2738a9cad0e7e09e6d34de2fccb4f1294b7f0b8f3b68Duncan Sands TLI.isOperationLegalOrCustom(ISD::XOR, VT)) { 2739a9cad0e7e09e6d34de2fccb4f1294b7f0b8f3b68Duncan Sands Tmp2 = DAG.getNode(ISD::XOR, dl, VT, Tmp2, 2740a9cad0e7e09e6d34de2fccb4f1294b7f0b8f3b68Duncan Sands DAG.getConstant(APInt::getAllOnesValue(VT.getSizeInBits()), VT)); 2741a9cad0e7e09e6d34de2fccb4f1294b7f0b8f3b68Duncan Sands Tmp2 = DAG.getNode(ISD::ADD, dl, VT, Tmp2, DAG.getConstant(1, VT)); 2742a9cad0e7e09e6d34de2fccb4f1294b7f0b8f3b68Duncan Sands Result = DAG.getNode(ISD::ADD, dl, VT, Tmp1, Tmp2); 2743525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman break; 2744525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman } 274587c8a8f304d1ee72829086ce2c41a8fa3813ba6aMon P Wang 2746826695281344e3a4c4d44d73dd155107aafd689bDan Gohman // Check to see if we have a libcall for this operator. 2747826695281344e3a4c4d44d73dd155107aafd689bDan Gohman RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL; 2748826695281344e3a4c4d44d73dd155107aafd689bDan Gohman bool isSigned = false; 2749826695281344e3a4c4d44d73dd155107aafd689bDan Gohman switch (Node->getOpcode()) { 2750826695281344e3a4c4d44d73dd155107aafd689bDan Gohman case ISD::UDIV: 2751826695281344e3a4c4d44d73dd155107aafd689bDan Gohman case ISD::SDIV: 2752813090cf891325c715b9f6fb1546e6ce67fa8c8bAnton Korobeynikov isSigned = Node->getOpcode() == ISD::SDIV; 2753813090cf891325c715b9f6fb1546e6ce67fa8c8bAnton Korobeynikov if (VT == MVT::i16) 2754813090cf891325c715b9f6fb1546e6ce67fa8c8bAnton Korobeynikov LC = (isSigned ? RTLIB::SDIV_I16 : RTLIB::UDIV_I16); 2755813090cf891325c715b9f6fb1546e6ce67fa8c8bAnton Korobeynikov else if (VT == MVT::i32) 2756813090cf891325c715b9f6fb1546e6ce67fa8c8bAnton Korobeynikov LC = (isSigned ? RTLIB::SDIV_I32 : RTLIB::UDIV_I32); 2757813090cf891325c715b9f6fb1546e6ce67fa8c8bAnton Korobeynikov else if (VT == MVT::i64) 2758813090cf891325c715b9f6fb1546e6ce67fa8c8bAnton Korobeynikov LC = (isSigned ? RTLIB::SDIV_I64 : RTLIB::UDIV_I64); 2759813090cf891325c715b9f6fb1546e6ce67fa8c8bAnton Korobeynikov else if (VT == MVT::i128) 2760813090cf891325c715b9f6fb1546e6ce67fa8c8bAnton Korobeynikov LC = (isSigned ? RTLIB::SDIV_I128 : RTLIB::UDIV_I128); 2761813090cf891325c715b9f6fb1546e6ce67fa8c8bAnton Korobeynikov break; 276231d7161206d7502e97a01a51a76445a8d9ac6ea5Chris Lattner case ISD::MUL: 27632f25c2c63fdc46c3b5b093b5cbdc6729f12a413aAnton Korobeynikov if (VT == MVT::i16) 27642f25c2c63fdc46c3b5b093b5cbdc6729f12a413aAnton Korobeynikov LC = RTLIB::MUL_I16; 2765813090cf891325c715b9f6fb1546e6ce67fa8c8bAnton Korobeynikov else if (VT == MVT::i32) 276631d7161206d7502e97a01a51a76445a8d9ac6ea5Chris Lattner LC = RTLIB::MUL_I32; 27679b9948507474acd3c5941ad7d33a37cb066803adNate Begeman else if (VT == MVT::i64) 2768845145f8b5f7feb8617bcfcfd3803ef80b17765dScott Michel LC = RTLIB::MUL_I64; 27692f25c2c63fdc46c3b5b093b5cbdc6729f12a413aAnton Korobeynikov else if (VT == MVT::i128) 27702f25c2c63fdc46c3b5b093b5cbdc6729f12a413aAnton Korobeynikov LC = RTLIB::MUL_I128; 277131d7161206d7502e97a01a51a76445a8d9ac6ea5Chris Lattner break; 2772826695281344e3a4c4d44d73dd155107aafd689bDan Gohman case ISD::FPOW: 2773007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands LC = GetFPLibCall(VT, RTLIB::POW_F32, RTLIB::POW_F64, RTLIB::POW_F80, 2774007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands RTLIB::POW_PPCF128); 2775826695281344e3a4c4d44d73dd155107aafd689bDan Gohman break; 2776d1e8d9c0a5dc821b6b52f7872181edeeec5df7baScott Michel case ISD::FDIV: 2777d1e8d9c0a5dc821b6b52f7872181edeeec5df7baScott Michel LC = GetFPLibCall(VT, RTLIB::DIV_F32, RTLIB::DIV_F64, RTLIB::DIV_F80, 2778d1e8d9c0a5dc821b6b52f7872181edeeec5df7baScott Michel RTLIB::DIV_PPCF128); 2779d1e8d9c0a5dc821b6b52f7872181edeeec5df7baScott Michel break; 2780826695281344e3a4c4d44d73dd155107aafd689bDan Gohman default: break; 2781826695281344e3a4c4d44d73dd155107aafd689bDan Gohman } 2782826695281344e3a4c4d44d73dd155107aafd689bDan Gohman if (LC != RTLIB::UNKNOWN_LIBCALL) { 2783475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Dummy; 2784460a14e09c2af630fc1e840dcb3e0f725663067bDuncan Sands Result = ExpandLibCall(LC, Node, isSigned, Dummy); 278552cc1ea2a1a374b58801398460a6289723089d91Evan Cheng break; 278652cc1ea2a1a374b58801398460a6289723089d91Evan Cheng } 2787fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 278874807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman assert(0 && "Cannot expand this binary operator!"); 2789bc70cf8be95f33f9aa30c8c3d0fd79e3fa636360Chris Lattner break; 2790bc70cf8be95f33f9aa30c8c3d0fd79e3fa636360Chris Lattner } 2791cc9876124e7096d050e6750dd075758320f2cdceEvan Cheng case TargetLowering::Promote: { 2792cc9876124e7096d050e6750dd075758320f2cdceEvan Cheng switch (Node->getOpcode()) { 2793cc9876124e7096d050e6750dd075758320f2cdceEvan Cheng default: assert(0 && "Do not know how to promote this BinOp!"); 2794cc9876124e7096d050e6750dd075758320f2cdceEvan Cheng case ISD::AND: 2795cc9876124e7096d050e6750dd075758320f2cdceEvan Cheng case ISD::OR: 2796cc9876124e7096d050e6750dd075758320f2cdceEvan Cheng case ISD::XOR: { 279783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT OVT = Node->getValueType(0); 279883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); 279983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(OVT.isVector() && "Cannot promote this BinOp!"); 2800cc9876124e7096d050e6750dd075758320f2cdceEvan Cheng // Bit convert each of the values to the new type. 2801ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::BIT_CONVERT, dl, NVT, Tmp1); 2802ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::BIT_CONVERT, dl, NVT, Tmp2); 2803ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1, Tmp2); 2804cc9876124e7096d050e6750dd075758320f2cdceEvan Cheng // Bit convert the result back the original type. 2805ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::BIT_CONVERT, dl, OVT, Result); 2806cc9876124e7096d050e6750dd075758320f2cdceEvan Cheng break; 2807cc9876124e7096d050e6750dd075758320f2cdceEvan Cheng } 2808cc9876124e7096d050e6750dd075758320f2cdceEvan Cheng } 2809cc9876124e7096d050e6750dd075758320f2cdceEvan Cheng } 2810e8f65f1e62ea1d4f2ca9fd0137ae2e0ce20e26e1Andrew Lenharth } 28113e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 2812fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2813e14ea867449cffa9a5835bc62c9c557ab0bc6618Dan Gohman case ISD::SMUL_LOHI: 2814e14ea867449cffa9a5835bc62c9c557ab0bc6618Dan Gohman case ISD::UMUL_LOHI: 2815e14ea867449cffa9a5835bc62c9c557ab0bc6618Dan Gohman case ISD::SDIVREM: 2816e14ea867449cffa9a5835bc62c9c557ab0bc6618Dan Gohman case ISD::UDIVREM: 2817e14ea867449cffa9a5835bc62c9c557ab0bc6618Dan Gohman // These nodes will only be produced by target-specific lowering, so 2818e14ea867449cffa9a5835bc62c9c557ab0bc6618Dan Gohman // they shouldn't be here if they aren't legal. 2819a7c97a7f5b82778ca5abfc3791c6b7f96b82a5faDuncan Sands assert(TLI.isOperationLegal(Node->getOpcode(), Node->getValueType(0)) && 2820e14ea867449cffa9a5835bc62c9c557ab0bc6618Dan Gohman "This must be legal!"); 2821525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman 2822525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 2823525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 2824525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); 2825e14ea867449cffa9a5835bc62c9c557ab0bc6618Dan Gohman break; 2826e14ea867449cffa9a5835bc62c9c557ab0bc6618Dan Gohman 2827a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner case ISD::FCOPYSIGN: // FCOPYSIGN does not require LHS/RHS to match type! 2828a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 2829957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the RHS. 2830fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2831a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); 2832fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2833a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 2834a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner default: assert(0 && "Operation not supported"); 2835a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner case TargetLowering::Custom: 2836a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner Tmp1 = TLI.LowerOperation(Result, DAG); 2837ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 28388f4191d61978529e9e9d7ddc24dbcd528ef7dd4cChris Lattner break; 2839a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner case TargetLowering::Legal: break; 2840912095becac923ff614d7b07728eb345ada67765Evan Cheng case TargetLowering::Expand: { 2841ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman assert((Tmp2.getValueType() == MVT::f32 || 284257f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman Tmp2.getValueType() == MVT::f64) && 2843ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman "Ugly special-cased code!"); 2844ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman // Get the sign bit of the RHS. 284557f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman SDValue SignBit; 284657f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman MVT IVT = Tmp2.getValueType() == MVT::f64 ? MVT::i64 : MVT::i32; 284757f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman if (isTypeLegal(IVT)) { 284857f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman SignBit = DAG.getNode(ISD::BIT_CONVERT, dl, IVT, Tmp2); 284957f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman } else { 285057f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman assert(isTypeLegal(TLI.getPointerTy()) && 285157f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman (TLI.getPointerTy() == MVT::i32 || 285257f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman TLI.getPointerTy() == MVT::i64) && 285357f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman "Legal type for load?!"); 285457f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman SDValue StackPtr = DAG.CreateStackTemporary(Tmp2.getValueType()); 285557f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman SDValue StorePtr = StackPtr, LoadPtr = StackPtr; 285657f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman SDValue Ch = 285757f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman DAG.getStore(DAG.getEntryNode(), dl, Tmp2, StorePtr, NULL, 0); 285857f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman if (Tmp2.getValueType() == MVT::f64 && TLI.isLittleEndian()) 285957f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman LoadPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), 286057f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman LoadPtr, DAG.getIntPtrConstant(4)); 286157f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman SignBit = DAG.getExtLoad(ISD::SEXTLOAD, dl, TLI.getPointerTy(), 286257f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman Ch, LoadPtr, NULL, 0, MVT::i32); 286357f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman } 286457f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman SignBit = 286557f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman DAG.getSetCC(dl, TLI.getSetCCResultType(SignBit.getValueType()), 286657f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman SignBit, DAG.getConstant(0, SignBit.getValueType()), 286757f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman ISD::SETLT); 2868ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman // Get the absolute value of the result. 2869ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman SDValue AbsVal = DAG.getNode(ISD::FABS, dl, Tmp1.getValueType(), Tmp1); 2870ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman // Select between the nabs and abs value based on the sign bit of 2871ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman // the input. 2872ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman Result = DAG.getNode(ISD::SELECT, dl, AbsVal.getValueType(), SignBit, 2873ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman DAG.getNode(ISD::FNEG, dl, AbsVal.getValueType(), 2874ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman AbsVal), 2875ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman AbsVal); 2876912095becac923ff614d7b07728eb345ada67765Evan Cheng Result = LegalizeOp(Result); 2877a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner break; 2878a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner } 2879912095becac923ff614d7b07728eb345ada67765Evan Cheng } 2880a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner break; 2881fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2882551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman case ISD::ADDC: 2883551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman case ISD::SUBC: 2884551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); 2885551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); 2886551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); 2887d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta Tmp3 = Result.getValue(0); 2888d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta Tmp4 = Result.getValue(1); 2889d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta 2890d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 2891d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta default: assert(0 && "This action is not supported yet!"); 2892d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta case TargetLowering::Legal: 2893d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta break; 2894d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta case TargetLowering::Custom: 2895d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta Tmp1 = TLI.LowerOperation(Tmp3, DAG); 2896d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta if (Tmp1.getNode() != NULL) { 28979b0f0b5e1505dcd4ec0da87ea9e29c59d98a8d27Sanjiv Gupta Tmp3 = LegalizeOp(Tmp1); 2898d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta Tmp4 = LegalizeOp(Tmp1.getValue(1)); 2899d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta } 2900d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta break; 2901d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta } 2902551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman // Since this produces two values, make sure to remember that we legalized 2903551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman // both of them. 2904d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta AddLegalizedOperand(SDValue(Node, 0), Tmp3); 2905d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta AddLegalizedOperand(SDValue(Node, 1), Tmp4); 2906d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta return Op.getResNo() ? Tmp4 : Tmp3; 2907edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2908551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman case ISD::ADDE: 2909551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman case ISD::SUBE: 2910551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); 2911551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); 2912551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(2)); 2913551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3); 2914d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta Tmp3 = Result.getValue(0); 2915d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta Tmp4 = Result.getValue(1); 2916d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta 2917d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 2918d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta default: assert(0 && "This action is not supported yet!"); 2919d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta case TargetLowering::Legal: 2920d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta break; 2921d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta case TargetLowering::Custom: 2922d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta Tmp1 = TLI.LowerOperation(Tmp3, DAG); 2923d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta if (Tmp1.getNode() != NULL) { 29249b0f0b5e1505dcd4ec0da87ea9e29c59d98a8d27Sanjiv Gupta Tmp3 = LegalizeOp(Tmp1); 2925d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta Tmp4 = LegalizeOp(Tmp1.getValue(1)); 2926d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta } 2927d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta break; 2928d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta } 2929551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman // Since this produces two values, make sure to remember that we legalized 2930551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman // both of them. 2931d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta AddLegalizedOperand(SDValue(Node, 0), Tmp3); 2932d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta AddLegalizedOperand(SDValue(Node, 1), Tmp4); 2933d3f01aa5a1c0242ea0a6294f13e1d078ce2b0938Sanjiv Gupta return Op.getResNo() ? Tmp4 : Tmp3; 2934fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2935419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case ISD::BUILD_PAIR: { 293683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT PairTy = Node->getValueType(0); 2937419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman // TODO: handle the case where the Lo and Hi operands are not of legal type 2938419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Lo 2939419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // Hi 2940419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman switch (TLI.getOperationAction(ISD::BUILD_PAIR, PairTy)) { 2941456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Promote: 2942456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 2943456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner assert(0 && "Cannot promote/custom this yet!"); 2944419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Legal: 2945419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 2946ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::BUILD_PAIR, dl, PairTy, Tmp1, Tmp2); 2947419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 2948419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Expand: 2949ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, PairTy, Tmp1); 2950ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::ANY_EXTEND, dl, PairTy, Tmp2); 2951ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::SHL, dl, PairTy, Tmp2, 295283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(PairTy.getSizeInBits()/2, 2953419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman TLI.getShiftAmountTy())); 2954ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::OR, dl, PairTy, Tmp1, Tmp2); 2955419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 2956419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman } 2957419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 2958419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman } 2959419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman 2960c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::UREM: 2961c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::SREM: 296201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner case ISD::FREM: 2963c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 2964c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 2965456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner 2966c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 2967456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Promote: assert(0 && "Cannot promote this yet!"); 2968456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 2969456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner isCustom = true; 2970456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner // FALLTHROUGH 297157030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth case TargetLowering::Legal: 2972c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); 2973456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner if (isCustom) { 2974456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp1 = TLI.LowerOperation(Result, DAG); 2975ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 2976456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner } 297757030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth break; 2978525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman case TargetLowering::Expand: { 29796b5578f052c2405c0d622192ccacfd47563c99a8Evan Cheng unsigned DivOpc= (Node->getOpcode() == ISD::UREM) ? ISD::UDIV : ISD::SDIV; 298047857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer bool isSigned = DivOpc == ISD::SDIV; 298183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 2982fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2983525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman // See if remainder can be lowered using two-result operations. 2984525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman SDVTList VTs = DAG.getVTList(VT, VT); 2985525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman if (Node->getOpcode() == ISD::SREM && 2986f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman TLI.isOperationLegalOrCustom(ISD::SDIVREM, VT)) { 2987fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = SDValue(DAG.getNode(ISD::SDIVREM, dl, 2988ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen VTs, Tmp1, Tmp2).getNode(), 1); 2989525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman break; 2990525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman } 2991525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman if (Node->getOpcode() == ISD::UREM && 2992f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman TLI.isOperationLegalOrCustom(ISD::UDIVREM, VT)) { 2993ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = SDValue(DAG.getNode(ISD::UDIVREM, dl, 2994ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen VTs, Tmp1, Tmp2).getNode(), 1); 2995525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman break; 2996525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman } 2997525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman 299858c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov if (VT.isInteger() && 299958c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov TLI.getOperationAction(DivOpc, VT) == TargetLowering::Legal) { 300058c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov // X % Y -> X-X/Y*Y 300158c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov Result = DAG.getNode(DivOpc, dl, VT, Tmp1, Tmp2); 300258c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov Result = DAG.getNode(ISD::MUL, dl, VT, Result, Tmp2); 300358c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov Result = DAG.getNode(ISD::SUB, dl, VT, Tmp1, Result); 300458c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov break; 300558c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov } 300658c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov 300758c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov // Check to see if we have a libcall for this operator. 300858c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL; 300958c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov switch (Node->getOpcode()) { 301058c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov default: break; 301158c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov case ISD::UREM: 301258c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov case ISD::SREM: 301358c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov if (VT == MVT::i16) 301458c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov LC = (isSigned ? RTLIB::SREM_I16 : RTLIB::UREM_I16); 301558c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov else if (VT == MVT::i32) 301658c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov LC = (isSigned ? RTLIB::SREM_I32 : RTLIB::UREM_I32); 301758c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov else if (VT == MVT::i64) 301858c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov LC = (isSigned ? RTLIB::SREM_I64 : RTLIB::UREM_I64); 301958c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov else if (VT == MVT::i128) 302058c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov LC = (isSigned ? RTLIB::SREM_I128 : RTLIB::UREM_I128); 302158c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov break; 302258c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov case ISD::FREM: 302358c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov // Floating point mod -> fmod libcall. 302458c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov LC = GetFPLibCall(VT, RTLIB::REM_F32, RTLIB::REM_F64, 302558c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov RTLIB::REM_F80, RTLIB::REM_PPCF128); 302658c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov break; 302758c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov } 302858c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov 302958c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov if (LC != RTLIB::UNKNOWN_LIBCALL) { 303058c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov SDValue Dummy; 303158c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov Result = ExpandLibCall(LC, Node, isSigned, Dummy); 303258c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov break; 3033c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 303458c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov 303574807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman assert(0 && "Cannot expand this binary operator!"); 3036c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 3037c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 3038525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman } 3039c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 3040acc398c195a697795bff3245943d104eb19192b9Nate Begeman case ISD::VAARG: { 3041acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 3042acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 3043acc398c195a697795bff3245943d104eb19192b9Nate Begeman 304483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 3045acc398c195a697795bff3245943d104eb19192b9Nate Begeman switch (TLI.getOperationAction(Node->getOpcode(), MVT::Other)) { 3046acc398c195a697795bff3245943d104eb19192b9Nate Begeman default: assert(0 && "This action is not supported yet!"); 3047456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 3048456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner isCustom = true; 3049456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner // FALLTHROUGH 3050acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Legal: 3051c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Node->getOperand(2)); 3052c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = Result.getValue(0); 3053456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp1 = Result.getValue(1); 3054456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner 3055456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner if (isCustom) { 3056456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp2 = TLI.LowerOperation(Result, DAG); 3057ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp2.getNode()) { 3058456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Result = LegalizeOp(Tmp2); 3059456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp1 = LegalizeOp(Tmp2.getValue(1)); 3060456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner } 3061456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner } 3062acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 3063acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Expand: { 306469de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman const Value *V = cast<SrcValueSDNode>(Node->getOperand(2))->getValue(); 3065ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue VAList = DAG.getLoad(TLI.getPointerTy(), dl, Tmp1, Tmp2, V, 0); 3066acc398c195a697795bff3245943d104eb19192b9Nate Begeman // Increment the pointer, VAList, to the next vaarg 3067ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp3 = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(), VAList, 3068ceb4d1aecb9deffe59b3dcdc9a783ffde8477be9Duncan Sands DAG.getConstant(TLI.getTargetData()-> 3069777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands getTypeAllocSize(VT.getTypeForMVT()), 3070ceb4d1aecb9deffe59b3dcdc9a783ffde8477be9Duncan Sands TLI.getPointerTy())); 3071acc398c195a697795bff3245943d104eb19192b9Nate Begeman // Store the incremented VAList to the legalized pointer 3072ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp3 = DAG.getStore(VAList.getValue(1), dl, Tmp3, Tmp2, V, 0); 3073acc398c195a697795bff3245943d104eb19192b9Nate Begeman // Load the actual argument out of the pointer VAList 3074ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getLoad(VT, dl, Tmp3, VAList, NULL, 0); 3075456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp1 = LegalizeOp(Result.getValue(1)); 3076acc398c195a697795bff3245943d104eb19192b9Nate Begeman Result = LegalizeOp(Result); 3077acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 3078acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 3079acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 3080fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // Since VAARG produces two values, make sure to remember that we 3081acc398c195a697795bff3245943d104eb19192b9Nate Begeman // legalized both of them. 3082475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 0), Result); 3083475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 1), Tmp1); 308499a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Op.getResNo() ? Tmp1 : Result; 3085acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 3086fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 3087fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel case ISD::VACOPY: 3088acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 3089acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the dest pointer. 3090acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the source pointer. 3091acc398c195a697795bff3245943d104eb19192b9Nate Begeman 3092acc398c195a697795bff3245943d104eb19192b9Nate Begeman switch (TLI.getOperationAction(ISD::VACOPY, MVT::Other)) { 3093acc398c195a697795bff3245943d104eb19192b9Nate Begeman default: assert(0 && "This action is not supported yet!"); 3094456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 3095456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner isCustom = true; 3096456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner // FALLTHROUGH 3097acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Legal: 3098c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3, 3099c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Node->getOperand(3), Node->getOperand(4)); 3100456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner if (isCustom) { 3101456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp1 = TLI.LowerOperation(Result, DAG); 3102ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 3103456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner } 3104acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 3105acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Expand: 3106acc398c195a697795bff3245943d104eb19192b9Nate Begeman // This defaults to loading a pointer from the input and storing it to the 3107acc398c195a697795bff3245943d104eb19192b9Nate Begeman // output, returning the chain. 310869de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman const Value *VD = cast<SrcValueSDNode>(Node->getOperand(3))->getValue(); 310969de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman const Value *VS = cast<SrcValueSDNode>(Node->getOperand(4))->getValue(); 3110ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp4 = DAG.getLoad(TLI.getPointerTy(), dl, Tmp1, Tmp3, VS, 0); 3111ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getStore(Tmp4.getValue(1), dl, Tmp4, Tmp2, VD, 0); 3112acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 3113acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 3114acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 3115acc398c195a697795bff3245943d104eb19192b9Nate Begeman 3116fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel case ISD::VAEND: 3117acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 3118acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 3119acc398c195a697795bff3245943d104eb19192b9Nate Begeman 3120acc398c195a697795bff3245943d104eb19192b9Nate Begeman switch (TLI.getOperationAction(ISD::VAEND, MVT::Other)) { 3121acc398c195a697795bff3245943d104eb19192b9Nate Begeman default: assert(0 && "This action is not supported yet!"); 3122456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 3123456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner isCustom = true; 3124456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner // FALLTHROUGH 3125acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Legal: 3126c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Node->getOperand(2)); 3127456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner if (isCustom) { 3128456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp1 = TLI.LowerOperation(Tmp1, DAG); 3129ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 3130456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner } 3131acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 3132acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Expand: 3133acc398c195a697795bff3245943d104eb19192b9Nate Begeman Result = Tmp1; // Default to a no-op, return the chain 3134acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 3135acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 3136acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 3137fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 3138fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel case ISD::VASTART: 3139acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 3140acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 3141acc398c195a697795bff3245943d104eb19192b9Nate Begeman 3142c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Node->getOperand(2)); 3143fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 3144acc398c195a697795bff3245943d104eb19192b9Nate Begeman switch (TLI.getOperationAction(ISD::VASTART, MVT::Other)) { 3145acc398c195a697795bff3245943d104eb19192b9Nate Begeman default: assert(0 && "This action is not supported yet!"); 3146456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Legal: break; 3147456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 3148456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp1 = TLI.LowerOperation(Result, DAG); 3149ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 3150acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 3151acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 3152acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 3153fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 315435ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman case ISD::ROTL: 315535ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman case ISD::ROTR: 315635ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 315792abc62399881ba9c525be80362c134ad836e2d9Duncan Sands Tmp2 = LegalizeOp(DAG.getShiftAmountOperand(Node->getOperand(1))); // RHS 3158c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); 3159c9dc11457809b6641de853af2261721a97ad1f26Scott Michel switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 3160c9dc11457809b6641de853af2261721a97ad1f26Scott Michel default: 3161c9dc11457809b6641de853af2261721a97ad1f26Scott Michel assert(0 && "ROTL/ROTR legalize operation not supported"); 3162c9dc11457809b6641de853af2261721a97ad1f26Scott Michel break; 3163c9dc11457809b6641de853af2261721a97ad1f26Scott Michel case TargetLowering::Legal: 3164c9dc11457809b6641de853af2261721a97ad1f26Scott Michel break; 3165c9dc11457809b6641de853af2261721a97ad1f26Scott Michel case TargetLowering::Custom: 3166c9dc11457809b6641de853af2261721a97ad1f26Scott Michel Tmp1 = TLI.LowerOperation(Result, DAG); 3167ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 3168c9dc11457809b6641de853af2261721a97ad1f26Scott Michel break; 3169c9dc11457809b6641de853af2261721a97ad1f26Scott Michel case TargetLowering::Promote: 3170c9dc11457809b6641de853af2261721a97ad1f26Scott Michel assert(0 && "Do not know how to promote ROTL/ROTR"); 3171c9dc11457809b6641de853af2261721a97ad1f26Scott Michel break; 3172c9dc11457809b6641de853af2261721a97ad1f26Scott Michel case TargetLowering::Expand: 3173c9dc11457809b6641de853af2261721a97ad1f26Scott Michel assert(0 && "Do not know how to expand ROTL/ROTR"); 3174c9dc11457809b6641de853af2261721a97ad1f26Scott Michel break; 3175c9dc11457809b6641de853af2261721a97ad1f26Scott Michel } 317635ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman break; 3177fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 3178d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case ISD::BSWAP: 3179d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Op 3180d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 3181456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 3182456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner assert(0 && "Cannot custom legalize this yet!"); 3183456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Legal: 3184c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1); 3185456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner break; 3186456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Promote: { 318783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT OVT = Tmp1.getValueType(); 318883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); 318983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned DiffBits = NVT.getSizeInBits() - OVT.getSizeInBits(); 3190456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner 3191ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Tmp1); 3192ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::BSWAP, dl, NVT, Tmp1); 3193ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::SRL, dl, NVT, Tmp1, 3194456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner DAG.getConstant(DiffBits, TLI.getShiftAmountTy())); 3195456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner break; 3196456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner } 3197456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Expand: 31988a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Result = ExpandBSWAP(Tmp1, dl); 3199456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner break; 3200d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman } 3201d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman break; 3202fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 3203691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 3204691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 3205691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 3206691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Tmp1 = LegalizeOp(Node->getOperand(0)); // Op 3207691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 3208910b66d8d6fd8a27dcdea74431e3ea20c69b7db5Scott Michel case TargetLowering::Custom: 3209691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Legal: 3210c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1); 3211910b66d8d6fd8a27dcdea74431e3ea20c69b7db5Scott Michel if (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0)) == 3212335f4f77882ace48bcdfb7a6019367bf9f4857cdScott Michel TargetLowering::Custom) { 3213335f4f77882ace48bcdfb7a6019367bf9f4857cdScott Michel Tmp1 = TLI.LowerOperation(Result, DAG); 3214ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) { 3215335f4f77882ace48bcdfb7a6019367bf9f4857cdScott Michel Result = Tmp1; 3216335f4f77882ace48bcdfb7a6019367bf9f4857cdScott Michel } 3217910b66d8d6fd8a27dcdea74431e3ea20c69b7db5Scott Michel } 3218691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 3219691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Promote: { 322083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT OVT = Tmp1.getValueType(); 322183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); 3222edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner 3223edb1add9a093efa266c94b6d0a34c26f5b2d5d7bChris Lattner // Zero extend the argument. 3224ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Tmp1); 3225691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth // Perform the larger operation, then subtract if needed. 3226ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(Node->getOpcode(), dl, Node->getValueType(0), Tmp1); 3227456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner switch (Node->getOpcode()) { 3228691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTPOP: 3229691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth Result = Tmp1; 3230691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 3231691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTTZ: 3232691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 3233ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(Tmp1.getValueType()), 3234ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1, DAG.getConstant(NVT.getSizeInBits(), NVT), 32357cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::SETEQ); 3236ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::SELECT, dl, NVT, Tmp2, 323783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(OVT.getSizeInBits(), NVT), Tmp1); 3238691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 3239691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case ISD::CTLZ: 3240456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner // Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 3241ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::SUB, dl, NVT, Tmp1, 324283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(NVT.getSizeInBits() - 324383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands OVT.getSizeInBits(), NVT)); 3244691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 3245691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 3246691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 3247691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 3248691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case TargetLowering::Expand: 32498a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Result = ExpandBitCount(Node->getOpcode(), Tmp1, dl); 3250691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 3251691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth } 3252691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth break; 325300b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 32542c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Unary operators 32552c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FABS: 32562c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case ISD::FNEG: 3257da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSQRT: 3258da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FSIN: 3259da6ba87d234a934409e8d8d5b131b7341ab4bf97Chris Lattner case ISD::FCOS: 32607794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen case ISD::FLOG: 32617794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen case ISD::FLOG2: 32627794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen case ISD::FLOG10: 32637794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen case ISD::FEXP: 32647794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen case ISD::FEXP2: 3265509e84fa7146175c86dec5ef2167290f294dc89eDan Gohman case ISD::FTRUNC: 3266509e84fa7146175c86dec5ef2167290f294dc89eDan Gohman case ISD::FFLOOR: 3267509e84fa7146175c86dec5ef2167290f294dc89eDan Gohman case ISD::FCEIL: 3268509e84fa7146175c86dec5ef2167290f294dc89eDan Gohman case ISD::FRINT: 3269509e84fa7146175c86dec5ef2167290f294dc89eDan Gohman case ISD::FNEARBYINT: 32702c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 32712c8086f4b9916b2d02842be5e375276023225fbaChris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 3272456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Promote: 3273456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 327459ad781e0118021d1ca7dfbc9f8db2ed828745e0Evan Cheng isCustom = true; 327559ad781e0118021d1ca7dfbc9f8db2ed828745e0Evan Cheng // FALLTHROUGH 32762c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Legal: 3277c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1); 327859ad781e0118021d1ca7dfbc9f8db2ed828745e0Evan Cheng if (isCustom) { 327959ad781e0118021d1ca7dfbc9f8db2ed828745e0Evan Cheng Tmp1 = TLI.LowerOperation(Result, DAG); 3280ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 328159ad781e0118021d1ca7dfbc9f8db2ed828745e0Evan Cheng } 32822c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 32832c8086f4b9916b2d02842be5e375276023225fbaChris Lattner case TargetLowering::Expand: 3284456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner switch (Node->getOpcode()) { 3285456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner default: assert(0 && "Unreachable!"); 3286456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case ISD::FNEG: 32872c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Expand Y = FNEG(X) -> Y = SUB -0.0, X 32882c8086f4b9916b2d02842be5e375276023225fbaChris Lattner Tmp2 = DAG.getConstantFP(-0.0, Node->getValueType(0)); 3289ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::FSUB, dl, Node->getValueType(0), Tmp2, Tmp1); 3290f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 3291f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case ISD::FABS: { 32924af6e0d7836126630f579b0a34f054321187f00bChris Lattner // Expand Y = FABS(X) -> Y = (X >u 0.0) ? X : fneg(X). 329383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 32944af6e0d7836126630f579b0a34f054321187f00bChris Lattner Tmp2 = DAG.getConstantFP(0.0, VT); 3295ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(Tmp1.getValueType()), 32965480c0469e5c0323ffb12f1ead2abd169d6cc0e7Duncan Sands Tmp1, Tmp2, ISD::SETUGT); 3297ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp3 = DAG.getNode(ISD::FNEG, dl, VT, Tmp1); 3298ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::SELECT, dl, VT, Tmp2, Tmp1, Tmp3); 3299f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 3300f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 33019d24ac56e1f9f1025a473d6b013557431fd05b7cEvan Cheng case ISD::FSQRT: 33029d24ac56e1f9f1025a473d6b013557431fd05b7cEvan Cheng case ISD::FSIN: 3303fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel case ISD::FCOS: 33047794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen case ISD::FLOG: 33057794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen case ISD::FLOG2: 33067794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen case ISD::FLOG10: 33077794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen case ISD::FEXP: 33087794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen case ISD::FEXP2: 33092bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman case ISD::FTRUNC: 33102bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman case ISD::FFLOOR: 33112bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman case ISD::FCEIL: 33122bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman case ISD::FRINT: 33139d24ac56e1f9f1025a473d6b013557431fd05b7cEvan Cheng case ISD::FNEARBYINT: { 331483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 3315826695281344e3a4c4d44d73dd155107aafd689bDan Gohman 331674807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman assert(!VT.isVector() && "Vector shouldn't get here!"); 3317826695281344e3a4c4d44d73dd155107aafd689bDan Gohman 331856966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL; 3319f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner switch(Node->getOpcode()) { 332056966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng case ISD::FSQRT: 3321007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands LC = GetFPLibCall(VT, RTLIB::SQRT_F32, RTLIB::SQRT_F64, 3322007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands RTLIB::SQRT_F80, RTLIB::SQRT_PPCF128); 332356966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng break; 332456966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng case ISD::FSIN: 3325007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands LC = GetFPLibCall(VT, RTLIB::SIN_F32, RTLIB::SIN_F64, 3326007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands RTLIB::SIN_F80, RTLIB::SIN_PPCF128); 332756966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng break; 332856966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng case ISD::FCOS: 3329007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands LC = GetFPLibCall(VT, RTLIB::COS_F32, RTLIB::COS_F64, 3330007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands RTLIB::COS_F80, RTLIB::COS_PPCF128); 333156966225d1eed9f9a6951d2167bfbbec9628c8d6Evan Cheng break; 33327794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen case ISD::FLOG: 33337794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen LC = GetFPLibCall(VT, RTLIB::LOG_F32, RTLIB::LOG_F64, 33347794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen RTLIB::LOG_F80, RTLIB::LOG_PPCF128); 33357794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen break; 33367794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen case ISD::FLOG2: 33377794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen LC = GetFPLibCall(VT, RTLIB::LOG2_F32, RTLIB::LOG2_F64, 33387794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen RTLIB::LOG2_F80, RTLIB::LOG2_PPCF128); 33397794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen break; 33407794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen case ISD::FLOG10: 33417794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen LC = GetFPLibCall(VT, RTLIB::LOG10_F32, RTLIB::LOG10_F64, 33427794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen RTLIB::LOG10_F80, RTLIB::LOG10_PPCF128); 33437794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen break; 33447794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen case ISD::FEXP: 33457794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen LC = GetFPLibCall(VT, RTLIB::EXP_F32, RTLIB::EXP_F64, 33467794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen RTLIB::EXP_F80, RTLIB::EXP_PPCF128); 33477794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen break; 33487794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen case ISD::FEXP2: 33497794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen LC = GetFPLibCall(VT, RTLIB::EXP2_F32, RTLIB::EXP2_F64, 33507794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen RTLIB::EXP2_F80, RTLIB::EXP2_PPCF128); 33517794f2a3a7778bdbc9bdd861db1fe914450e0470Dale Johannesen break; 33522bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman case ISD::FTRUNC: 33532bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman LC = GetFPLibCall(VT, RTLIB::TRUNC_F32, RTLIB::TRUNC_F64, 33542bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman RTLIB::TRUNC_F80, RTLIB::TRUNC_PPCF128); 33552bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman break; 33562bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman case ISD::FFLOOR: 33572bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman LC = GetFPLibCall(VT, RTLIB::FLOOR_F32, RTLIB::FLOOR_F64, 33582bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman RTLIB::FLOOR_F80, RTLIB::FLOOR_PPCF128); 33592bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman break; 33602bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman case ISD::FCEIL: 33612bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman LC = GetFPLibCall(VT, RTLIB::CEIL_F32, RTLIB::CEIL_F64, 33622bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman RTLIB::CEIL_F80, RTLIB::CEIL_PPCF128); 33632bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman break; 33642bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman case ISD::FRINT: 33652bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman LC = GetFPLibCall(VT, RTLIB::RINT_F32, RTLIB::RINT_F64, 33662bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman RTLIB::RINT_F80, RTLIB::RINT_PPCF128); 33672bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman break; 33682bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman case ISD::FNEARBYINT: 33692bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman LC = GetFPLibCall(VT, RTLIB::NEARBYINT_F32, RTLIB::NEARBYINT_F64, 33702bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman RTLIB::NEARBYINT_F80, RTLIB::NEARBYINT_PPCF128); 33712bb1e3eede14dd8a965506465e2876fb1ae765c2Dan Gohman break; 33729d24ac56e1f9f1025a473d6b013557431fd05b7cEvan Cheng break; 3373f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner default: assert(0 && "Unreachable!"); 3374f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 3375475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Dummy; 3376460a14e09c2af630fc1e840dcb3e0f725663067bDuncan Sands Result = ExpandLibCall(LC, Node, false/*sign irrelevant*/, Dummy); 3377f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner break; 3378f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 33792c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 33802c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 33812c8086f4b9916b2d02842be5e375276023225fbaChris Lattner } 33822c8086f4b9916b2d02842be5e375276023225fbaChris Lattner break; 33836ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner case ISD::FPOWI: { 338483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 3385826695281344e3a4c4d44d73dd155107aafd689bDan Gohman 3386826695281344e3a4c4d44d73dd155107aafd689bDan Gohman // Expand unsupported unary vector operators by unrolling them. 338774807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman assert(!VT.isVector() && "Vector shouldn't get here!"); 3388826695281344e3a4c4d44d73dd155107aafd689bDan Gohman 3389826695281344e3a4c4d44d73dd155107aafd689bDan Gohman // We always lower FPOWI into a libcall. No target support for it yet. 3390007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands RTLIB::Libcall LC = GetFPLibCall(VT, RTLIB::POWI_F32, RTLIB::POWI_F64, 3391007f9847c44ddbe7fd04cba362b4ec0f0f40964bDuncan Sands RTLIB::POWI_F80, RTLIB::POWI_PPCF128); 3392475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Dummy; 3393460a14e09c2af630fc1e840dcb3e0f725663067bDuncan Sands Result = ExpandLibCall(LC, Node, false/*sign irrelevant*/, Dummy); 33946ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner break; 33956ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner } 339635481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner case ISD::BIT_CONVERT: 33971fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman switch (TLI.getOperationAction(ISD::BIT_CONVERT, 33981fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman Node->getOperand(0).getValueType())) { 33991fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman default: assert(0 && "Unknown operation action!"); 34001fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman case TargetLowering::Expand: 34011401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner Result = EmitStackConvert(Node->getOperand(0), Node->getValueType(0), 34028a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Node->getValueType(0), dl); 34031fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman break; 34041fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman case TargetLowering::Legal: 34051fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman Tmp1 = LegalizeOp(Node->getOperand(0)); 34061fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman Result = DAG.UpdateNodeOperands(Result, Tmp1); 34071fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman break; 340835481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner } 340935481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner break; 341077cdf30742284a173fe818417eb482224cdee8d4Mon P Wang case ISD::CONVERT_RNDSAT: { 341177cdf30742284a173fe818417eb482224cdee8d4Mon P Wang ISD::CvtCode CvtCode = cast<CvtRndSatSDNode>(Node)->getCvtCode(); 341277cdf30742284a173fe818417eb482224cdee8d4Mon P Wang switch (CvtCode) { 341377cdf30742284a173fe818417eb482224cdee8d4Mon P Wang default: assert(0 && "Unknown cvt code!"); 341477cdf30742284a173fe818417eb482224cdee8d4Mon P Wang case ISD::CVT_SF: 341577cdf30742284a173fe818417eb482224cdee8d4Mon P Wang case ISD::CVT_UF: 341677cdf30742284a173fe818417eb482224cdee8d4Mon P Wang case ISD::CVT_FF: 34171cd46bbb1c6b1c3cb33bbbd3beb97f0c0373df80Mon P Wang break; 341877cdf30742284a173fe818417eb482224cdee8d4Mon P Wang case ISD::CVT_FS: 341977cdf30742284a173fe818417eb482224cdee8d4Mon P Wang case ISD::CVT_FU: 342077cdf30742284a173fe818417eb482224cdee8d4Mon P Wang case ISD::CVT_SS: 342177cdf30742284a173fe818417eb482224cdee8d4Mon P Wang case ISD::CVT_SU: 342277cdf30742284a173fe818417eb482224cdee8d4Mon P Wang case ISD::CVT_US: 342377cdf30742284a173fe818417eb482224cdee8d4Mon P Wang case ISD::CVT_UU: { 342477cdf30742284a173fe818417eb482224cdee8d4Mon P Wang SDValue DTyOp = Node->getOperand(1); 342577cdf30742284a173fe818417eb482224cdee8d4Mon P Wang SDValue STyOp = Node->getOperand(2); 342677cdf30742284a173fe818417eb482224cdee8d4Mon P Wang SDValue RndOp = Node->getOperand(3); 342777cdf30742284a173fe818417eb482224cdee8d4Mon P Wang SDValue SatOp = Node->getOperand(4); 3428957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp1 = LegalizeOp(Node->getOperand(0)); 3429957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Result = DAG.UpdateNodeOperands(Result, Tmp1, DTyOp, STyOp, 3430957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman RndOp, SatOp); 3431957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman if (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0)) == 3432957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman TargetLowering::Custom) { 3433957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp1 = TLI.LowerOperation(Result, DAG); 3434957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman if (Tmp1.getNode()) Result = Tmp1; 343577cdf30742284a173fe818417eb482224cdee8d4Mon P Wang } 343677cdf30742284a173fe818417eb482224cdee8d4Mon P Wang break; 343777cdf30742284a173fe818417eb482224cdee8d4Mon P Wang } 343877cdf30742284a173fe818417eb482224cdee8d4Mon P Wang } // end switch CvtCode 343977cdf30742284a173fe818417eb482224cdee8d4Mon P Wang break; 344077cdf30742284a173fe818417eb482224cdee8d4Mon P Wang } 34412c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Conversion operators. The source and destination have different types. 3442fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::SINT_TO_FP: 3443fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::UINT_TO_FP: { 3444fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner bool isSigned = Node->getOpcode() == ISD::SINT_TO_FP; 34457f8613e5b8398b688080e3c944ab8c11593e1ed0Dan Gohman Result = LegalizeINT_TO_FP(Result, isSigned, 3446af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen Node->getValueType(0), Node->getOperand(0), dl); 3447fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 3448fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 3449fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::TRUNCATE: 3450957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp1 = LegalizeOp(Node->getOperand(0)); 3451957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 3452957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman default: assert(0 && "Unknown TRUNCATE legalization operation action!"); 3453957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman case TargetLowering::Custom: 3454957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman isCustom = true; 3455957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman // FALLTHROUGH 3456957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman case TargetLowering::Legal: 3457957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Result = DAG.UpdateNodeOperands(Result, Tmp1); 3458957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman if (isCustom) { 3459957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp1 = TLI.LowerOperation(Result, DAG); 3460957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman if (Tmp1.getNode()) Result = Tmp1; 3461b0a5cdd4511d02afacd0cd39223cf6c52a6ef361Tilmann Scheller } 3462fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 3463fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 3464fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 3465d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3466fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_SINT: 3467fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner case ISD::FP_TO_UINT: 3468957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp1 = LegalizeOp(Node->getOperand(0)); 3469f1fa74ee0d30dfdb854f7d3f5ee67437cc82e250Chris Lattner 3470957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))){ 3471957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman default: assert(0 && "Unknown operation action!"); 3472957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman case TargetLowering::Custom: 3473957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman isCustom = true; 3474957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman // FALLTHROUGH 3475957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman case TargetLowering::Legal: 3476957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Result = DAG.UpdateNodeOperands(Result, Tmp1); 3477957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman if (isCustom) { 3478957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp1 = TLI.LowerOperation(Result, DAG); 3479957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman if (Tmp1.getNode()) Result = Tmp1; 34801618bebcf6f9cd19c4e05de3bfffda28c246bb12Chris Lattner } 3481fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 3482957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman case TargetLowering::Promote: 3483957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Result = PromoteLegalFP_TO_INT(Tmp1, Node->getValueType(0), 3484957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Node->getOpcode() == ISD::FP_TO_SINT, 3485957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman dl); 34866af00d588c1b353d9d7a3dd8f58927056eccd6c1Evan Cheng break; 3487957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman case TargetLowering::Expand: 3488957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman if (Node->getOpcode() == ISD::FP_TO_UINT) { 3489957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman SDValue True, False; 3490957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman MVT VT = Node->getOperand(0).getValueType(); 3491957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman MVT NVT = Node->getValueType(0); 3492957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman const uint64_t zero[] = {0, 0}; 3493957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman APFloat apf = APFloat(APInt(VT.getSizeInBits(), 2, zero)); 3494957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman APInt x = APInt::getSignBit(NVT.getSizeInBits()); 3495957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman (void)apf.convertFromAPInt(x, false, APFloat::rmNearestTiesToEven); 3496957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp2 = DAG.getConstantFP(apf, VT); 3497957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp3 = DAG.getSetCC(dl, TLI.getSetCCResultType(VT), 3498957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Node->getOperand(0), 3499957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp2, ISD::SETLT); 3500957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman True = DAG.getNode(ISD::FP_TO_SINT, dl, NVT, Node->getOperand(0)); 3501957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman False = DAG.getNode(ISD::FP_TO_SINT, dl, NVT, 3502957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman DAG.getNode(ISD::FSUB, dl, VT, 3503957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Node->getOperand(0), Tmp2)); 3504957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman False = DAG.getNode(ISD::XOR, dl, NVT, False, 3505957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman DAG.getConstant(x, NVT)); 3506957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Result = DAG.getNode(ISD::SELECT, dl, NVT, Tmp3, True, False); 3507957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman } else { 3508957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman assert(0 && "Do not know how to expand FP_TO_SINT yet!"); 3509957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman } 3510fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 3511fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner } 3512fa9c801a6b42609dc2a934afb6535e3d51d61a3eChris Lattner break; 3513d29b6aa608d69f19b57ebd2ae630b040b1c4951dJeff Cohen 3514f2670a89a7c5e29e7f71ab63e06e75dbf482c55bChris Lattner case ISD::FP_EXTEND: { 351583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT DstVT = Op.getValueType(); 351683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT SrcVT = Op.getOperand(0).getValueType(); 35170bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner if (TLI.getConvertAction(SrcVT, DstVT) == TargetLowering::Expand) { 35180bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner // The only other way we can lower this is to turn it into a STORE, 35190bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner // LOAD pair, targetting a temporary location (a stack slot). 35208a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Result = EmitStackConvert(Node->getOperand(0), SrcVT, DstVT, dl); 35210bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner break; 3522f2670a89a7c5e29e7f71ab63e06e75dbf482c55bChris Lattner } 3523957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp1 = LegalizeOp(Node->getOperand(0)); 3524957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Result = DAG.UpdateNodeOperands(Result, Tmp1); 3525f2670a89a7c5e29e7f71ab63e06e75dbf482c55bChris Lattner break; 35260bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner } 35275411a3937f4303f9c3fc50be92f985a4532d95e6Dale Johannesen case ISD::FP_ROUND: { 352883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT DstVT = Op.getValueType(); 352983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT SrcVT = Op.getOperand(0).getValueType(); 35300bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner if (TLI.getConvertAction(SrcVT, DstVT) == TargetLowering::Expand) { 35310bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner if (SrcVT == MVT::ppcf128) { 35321fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman // FIXME: Figure out how to extract the double without 35331fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman // help from type legalization 35345411a3937f4303f9c3fc50be92f985a4532d95e6Dale Johannesen } 35350bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner // The only other way we can lower this is to turn it into a STORE, 35360bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner // LOAD pair, targetting a temporary location (a stack slot). 35378a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Result = EmitStackConvert(Node->getOperand(0), DstVT, DstVT, dl); 35380bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner break; 3539849f214a4e3676e41168b0c5398165c4d4fb99f8Dale Johannesen } 3540957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp1 = LegalizeOp(Node->getOperand(0)); 3541957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1)); 3542f2670a89a7c5e29e7f71ab63e06e75dbf482c55bChris Lattner break; 35430bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner } 354413c78e2e5f158e9008b279b43b685ff02bb3cbeaChris Lattner case ISD::ANY_EXTEND: 35453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ZERO_EXTEND: 35463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SIGN_EXTEND: 3547957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp1 = LegalizeOp(Node->getOperand(0)); 3548957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Result = DAG.UpdateNodeOperands(Result, Tmp1); 3549957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman if (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0)) == 3550957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman TargetLowering::Custom) { 3551957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp1 = TLI.LowerOperation(Result, DAG); 3552957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman if (Tmp1.getNode()) Result = Tmp1; 35533e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 35543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 35550f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner case ISD::FP_ROUND_INREG: 355623993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner case ISD::SIGN_EXTEND_INREG: { 35570f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 355883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT ExtraVT = cast<VTSDNode>(Node->getOperand(1))->getVT(); 355945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 356045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this operation is not supported, convert it to a shl/shr or load/store 356145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // pair. 356255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), ExtraVT)) { 356355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action not supported for this op yet!"); 356455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Legal: 3565c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1)); 356655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 356755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Expand: 356845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // If this is an integer extend and shifts are supported, do that. 356923993561e24b2a6eaf0e036062522ab825c30d3fChris Lattner if (Node->getOpcode() == ISD::SIGN_EXTEND_INREG) { 357045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: we could fall back on load/store here too for targets without 357145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // SAR. However, it is doubtful that any exist. 357283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned BitsDiff = Node->getValueType(0).getSizeInBits() - 357383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands ExtraVT.getSizeInBits(); 3574475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue ShiftCst = DAG.getConstant(BitsDiff, TLI.getShiftAmountTy()); 3575ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::SHL, dl, Node->getValueType(0), 357645b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Node->getOperand(0), ShiftCst); 3577ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::SRA, dl, Node->getValueType(0), 357845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner Result, ShiftCst); 357945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else if (Node->getOpcode() == ISD::FP_ROUND_INREG) { 35802d84c4c7b314242346dea1a7f48563333476a4d5Jim Laskey // The only way we can lower this is to turn it into a TRUNCSTORE, 358145b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // EXTLOAD pair, targetting a temporary location (a stack slot). 358245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner 358345b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // NOTE: there is a choice here between constantly creating new stack 358445b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // slots and always reusing the same one. We currently always create 358545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner // new ones, as reuse may inhibit scheduling. 3586fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = EmitStackConvert(Node->getOperand(0), ExtraVT, 35878a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Node->getValueType(0), dl); 358845b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } else { 358945b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner assert(0 && "Unknown op"); 359045b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 359155ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 359245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 35930f69b2910810b7c0971a739f18b37fae2a20eca5Chris Lattner break; 35943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 359536397f50343639ce9a25996f2d790c656791ab92Duncan Sands case ISD::TRAMPOLINE: { 3596475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[6]; 359736397f50343639ce9a25996f2d790c656791ab92Duncan Sands for (unsigned i = 0; i != 6; ++i) 359836397f50343639ce9a25996f2d790c656791ab92Duncan Sands Ops[i] = LegalizeOp(Node->getOperand(i)); 359936397f50343639ce9a25996f2d790c656791ab92Duncan Sands Result = DAG.UpdateNodeOperands(Result, Ops, 6); 360036397f50343639ce9a25996f2d790c656791ab92Duncan Sands // The only option for this node is to custom lower it. 360136397f50343639ce9a25996f2d790c656791ab92Duncan Sands Result = TLI.LowerOperation(Result, DAG); 3602ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif assert(Result.getNode() && "Should always custom lower!"); 3603f7331b3dd72409e644833ecaf62a0f6db03c97eeDuncan Sands 3604f7331b3dd72409e644833ecaf62a0f6db03c97eeDuncan Sands // Since trampoline produces two values, make sure to remember that we 3605f7331b3dd72409e644833ecaf62a0f6db03c97eeDuncan Sands // legalized both of them. 3606f7331b3dd72409e644833ecaf62a0f6db03c97eeDuncan Sands Tmp1 = LegalizeOp(Result.getValue(1)); 3607f7331b3dd72409e644833ecaf62a0f6db03c97eeDuncan Sands Result = LegalizeOp(Result); 3608475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 0), Result); 3609475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 1), Tmp1); 361099a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Op.getResNo() ? Tmp1 : Result; 361136397f50343639ce9a25996f2d790c656791ab92Duncan Sands } 36129c78a399076f8356a53ee67dca9c78e594e34967Dan Gohman case ISD::FLT_ROUNDS_: { 361383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 3614917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov switch (TLI.getOperationAction(Node->getOpcode(), VT)) { 3615917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov default: assert(0 && "This action not supported for this op yet!"); 3616917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov case TargetLowering::Custom: 3617917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov Result = TLI.LowerOperation(Op, DAG); 3618ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Result.getNode()) break; 3619917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov // Fall Thru 3620917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov case TargetLowering::Legal: 3621917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov // If this operation is not supported, lower it to constant 1 3622917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov Result = DAG.getConstant(1, VT); 3623917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov break; 3624917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov } 36259ab9ee8209c313713a54db2d9451751d8cfb9e2aDan Gohman break; 3626917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov } 362741bab0beac2600701af99f63e23a6b65f71468acChris Lattner case ISD::TRAP: { 362883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 362966fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov switch (TLI.getOperationAction(Node->getOpcode(), VT)) { 363066fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov default: assert(0 && "This action not supported for this op yet!"); 363141bab0beac2600701af99f63e23a6b65f71468acChris Lattner case TargetLowering::Legal: 363241bab0beac2600701af99f63e23a6b65f71468acChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 363341bab0beac2600701af99f63e23a6b65f71468acChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1); 363441bab0beac2600701af99f63e23a6b65f71468acChris Lattner break; 363566fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov case TargetLowering::Custom: 363666fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov Result = TLI.LowerOperation(Op, DAG); 3637ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Result.getNode()) break; 363866fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov // Fall Thru 363941bab0beac2600701af99f63e23a6b65f71468acChris Lattner case TargetLowering::Expand: 364066fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov // If this operation is not supported, lower it to 'abort()' call 364141bab0beac2600701af99f63e23a6b65f71468acChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); 364266fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov TargetLowering::ArgListTy Args; 3643ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson std::pair<SDValue, SDValue> CallResult = 364400fee65fd21f9615d1a604b8b7d42cd16a3f6b47Duncan Sands TLI.LowerCallTo(Tmp1, Type::VoidTy, 364586098bd6a63d2cdf0c9be9ef3151bd2728281fd7Dale Johannesen false, false, false, false, CallingConv::C, false, 3646056292fd738924f3f7703725d8f630983794b5a5Bill Wendling DAG.getExternalSymbol("abort", TLI.getPointerTy()), 36477d2ad624fa749a6d3edac0d94e9c107989c16304Dale Johannesen Args, DAG, dl); 364866fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov Result = CallResult.second; 364966fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov break; 365066fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov } 365141bab0beac2600701af99f63e23a6b65f71468acChris Lattner break; 365266fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov } 36538ac0d4b4fb10406278cd600214cd3ee6d76620cdBill Wendling 365474c376529101acbe141a256d0bf23a44eb454c84Bill Wendling case ISD::SADDO: 365574c376529101acbe141a256d0bf23a44eb454c84Bill Wendling case ISD::SSUBO: { 3656c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling MVT VT = Node->getValueType(0); 3657c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling switch (TLI.getOperationAction(Node->getOpcode(), VT)) { 3658c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling default: assert(0 && "This action not supported for this op yet!"); 3659c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling case TargetLowering::Custom: 3660c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling Result = TLI.LowerOperation(Op, DAG); 3661c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling if (Result.getNode()) break; 3662c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling // FALLTHROUGH 3663c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling case TargetLowering::Legal: { 3664c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling SDValue LHS = LegalizeOp(Node->getOperand(0)); 3665c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling SDValue RHS = LegalizeOp(Node->getOperand(1)); 3666c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling 3667fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel SDValue Sum = DAG.getNode(Node->getOpcode() == ISD::SADDO ? 3668ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen ISD::ADD : ISD::SUB, dl, LHS.getValueType(), 366974c376529101acbe141a256d0bf23a44eb454c84Bill Wendling LHS, RHS); 3670c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling MVT OType = Node->getValueType(1); 3671c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling 3672a6af91ae124d0713cfabcea8c5f508091dd7a556Bill Wendling SDValue Zero = DAG.getConstant(0, LHS.getValueType()); 3673c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling 3674740464e6164e503f3c01d2b13a52c0261042abe0Bill Wendling // LHSSign -> LHS >= 0 3675740464e6164e503f3c01d2b13a52c0261042abe0Bill Wendling // RHSSign -> RHS >= 0 3676740464e6164e503f3c01d2b13a52c0261042abe0Bill Wendling // SumSign -> Sum >= 0 3677740464e6164e503f3c01d2b13a52c0261042abe0Bill Wendling // 367874c376529101acbe141a256d0bf23a44eb454c84Bill Wendling // Add: 3679740464e6164e503f3c01d2b13a52c0261042abe0Bill Wendling // Overflow -> (LHSSign == RHSSign) && (LHSSign != SumSign) 368074c376529101acbe141a256d0bf23a44eb454c84Bill Wendling // Sub: 368174c376529101acbe141a256d0bf23a44eb454c84Bill Wendling // Overflow -> (LHSSign != RHSSign) && (LHSSign != SumSign) 3682740464e6164e503f3c01d2b13a52c0261042abe0Bill Wendling // 3683ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue LHSSign = DAG.getSetCC(dl, OType, LHS, Zero, ISD::SETGE); 3684ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue RHSSign = DAG.getSetCC(dl, OType, RHS, Zero, ISD::SETGE); 3685fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel SDValue SignsMatch = DAG.getSetCC(dl, OType, LHSSign, RHSSign, 3686fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Node->getOpcode() == ISD::SADDO ? 368774c376529101acbe141a256d0bf23a44eb454c84Bill Wendling ISD::SETEQ : ISD::SETNE); 3688740464e6164e503f3c01d2b13a52c0261042abe0Bill Wendling 3689ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue SumSign = DAG.getSetCC(dl, OType, Sum, Zero, ISD::SETGE); 3690ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue SumSignNE = DAG.getSetCC(dl, OType, LHSSign, SumSign, ISD::SETNE); 3691740464e6164e503f3c01d2b13a52c0261042abe0Bill Wendling 3692ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue Cmp = DAG.getNode(ISD::AND, dl, OType, SignsMatch, SumSignNE); 3693c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling 3694c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling MVT ValueVTs[] = { LHS.getValueType(), OType }; 3695c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling SDValue Ops[] = { Sum, Cmp }; 3696c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling 3697fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getNode(ISD::MERGE_VALUES, dl, 3698ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen DAG.getVTList(&ValueVTs[0], 2), 3699aaffa05d0a652dd3eae76a941d02d6b0469fa821Duncan Sands &Ops[0], 2); 3700c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling SDNode *RNode = Result.getNode(); 3701c23e4968790395053f3f52aeb3342637fcaafdbfDan Gohman DAG.ReplaceAllUsesWith(Node, RNode); 3702c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling break; 3703c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling } 3704c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling } 3705c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling 3706c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling break; 3707c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling } 370874c376529101acbe141a256d0bf23a44eb454c84Bill Wendling case ISD::UADDO: 370974c376529101acbe141a256d0bf23a44eb454c84Bill Wendling case ISD::USUBO: { 371041ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling MVT VT = Node->getValueType(0); 371141ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling switch (TLI.getOperationAction(Node->getOpcode(), VT)) { 371241ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling default: assert(0 && "This action not supported for this op yet!"); 371341ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling case TargetLowering::Custom: 371441ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling Result = TLI.LowerOperation(Op, DAG); 371541ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling if (Result.getNode()) break; 371641ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling // FALLTHROUGH 371741ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling case TargetLowering::Legal: { 371841ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling SDValue LHS = LegalizeOp(Node->getOperand(0)); 371941ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling SDValue RHS = LegalizeOp(Node->getOperand(1)); 372041ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling 372174c376529101acbe141a256d0bf23a44eb454c84Bill Wendling SDValue Sum = DAG.getNode(Node->getOpcode() == ISD::UADDO ? 3722ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen ISD::ADD : ISD::SUB, dl, LHS.getValueType(), 372374c376529101acbe141a256d0bf23a44eb454c84Bill Wendling LHS, RHS); 372441ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling MVT OType = Node->getValueType(1); 3725ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue Cmp = DAG.getSetCC(dl, OType, Sum, LHS, 3726fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Node->getOpcode () == ISD::UADDO ? 372774c376529101acbe141a256d0bf23a44eb454c84Bill Wendling ISD::SETULT : ISD::SETUGT); 372841ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling 372941ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling MVT ValueVTs[] = { LHS.getValueType(), OType }; 373041ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling SDValue Ops[] = { Sum, Cmp }; 373141ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling 3732fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getNode(ISD::MERGE_VALUES, dl, 3733ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen DAG.getVTList(&ValueVTs[0], 2), 3734aaffa05d0a652dd3eae76a941d02d6b0469fa821Duncan Sands &Ops[0], 2); 373541ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling SDNode *RNode = Result.getNode(); 3736c23e4968790395053f3f52aeb3342637fcaafdbfDan Gohman DAG.ReplaceAllUsesWith(Node, RNode); 373741ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling break; 373841ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling } 373941ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling } 374041ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling 37418ac0d4b4fb10406278cd600214cd3ee6d76620cdBill Wendling break; 37428ac0d4b4fb10406278cd600214cd3ee6d76620cdBill Wendling } 374374c376529101acbe141a256d0bf23a44eb454c84Bill Wendling case ISD::SMULO: 374474c376529101acbe141a256d0bf23a44eb454c84Bill Wendling case ISD::UMULO: { 374574c376529101acbe141a256d0bf23a44eb454c84Bill Wendling MVT VT = Node->getValueType(0); 374674c376529101acbe141a256d0bf23a44eb454c84Bill Wendling switch (TLI.getOperationAction(Node->getOpcode(), VT)) { 374774c376529101acbe141a256d0bf23a44eb454c84Bill Wendling default: assert(0 && "This action is not supported at all!"); 374874c376529101acbe141a256d0bf23a44eb454c84Bill Wendling case TargetLowering::Custom: 374974c376529101acbe141a256d0bf23a44eb454c84Bill Wendling Result = TLI.LowerOperation(Op, DAG); 375074c376529101acbe141a256d0bf23a44eb454c84Bill Wendling if (Result.getNode()) break; 375174c376529101acbe141a256d0bf23a44eb454c84Bill Wendling // Fall Thru 375274c376529101acbe141a256d0bf23a44eb454c84Bill Wendling case TargetLowering::Legal: 375374c376529101acbe141a256d0bf23a44eb454c84Bill Wendling // FIXME: According to Hacker's Delight, this can be implemented in 375474c376529101acbe141a256d0bf23a44eb454c84Bill Wendling // target independent lowering, but it would be inefficient, since it 3755bc5e15eafb3c39a214631087b6827a5691e9b25cBill Wendling // requires a division + a branch. 3756fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel assert(0 && "Target independent lowering is not supported for SMULO/UMULO!"); 375774c376529101acbe141a256d0bf23a44eb454c84Bill Wendling break; 375874c376529101acbe141a256d0bf23a44eb454c84Bill Wendling } 375974c376529101acbe141a256d0bf23a44eb454c84Bill Wendling break; 376074c376529101acbe141a256d0bf23a44eb454c84Bill Wendling } 376174c376529101acbe141a256d0bf23a44eb454c84Bill Wendling 376245b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 3763fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 37644ddd283f6928fc337c1bf3277566d7b31526e8d9Chris Lattner assert(Result.getValueType() == Op.getValueType() && 37654ddd283f6928fc337c1bf3277566d7b31526e8d9Chris Lattner "Bad legalization!"); 3766fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 3767456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner // Make sure that the generated code is itself legal. 3768456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner if (Result != Op) 3769456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Result = LegalizeOp(Result); 37703e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 377145982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 377245982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 377345982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner AddLegalizedOperand(Op, Result); 37743e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return Result; 37753e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 37763e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 37777f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman/// ExpandEXTRACT_VECTOR_ELT - Expand an EXTRACT_VECTOR_ELT operation into 37787f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman/// a legal EXTRACT_VECTOR_ELT operation, scalar code, or memory traffic, 37797f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman/// based on the vector type. The return type of this matches the element type 37807f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman/// of the vector, which may not be legal for the target. 3781475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::ExpandEXTRACT_VECTOR_ELT(SDValue Op) { 37821597221eace1c53ce5f84a7018397497d11a8393Chris Lattner // We know that operand #0 is the Vec vector. If the index is a constant 37831597221eace1c53ce5f84a7018397497d11a8393Chris Lattner // or if the invec is a supported hardware type, we can use it. Otherwise, 37841597221eace1c53ce5f84a7018397497d11a8393Chris Lattner // lower to a store then an indexed load. 3785475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Vec = Op.getOperand(0); 3786475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Idx = Op.getOperand(1); 37876f38cb61a94b3abab70f0ee463bdcf55d86d334eDale Johannesen DebugLoc dl = Op.getDebugLoc(); 3788fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 378983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT TVT = Vec.getValueType(); 379083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned NumElems = TVT.getVectorNumElements(); 3791fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 37927f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman switch (TLI.getOperationAction(ISD::EXTRACT_VECTOR_ELT, TVT)) { 37937f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman default: assert(0 && "This action is not supported yet!"); 37947f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman case TargetLowering::Custom: { 37957f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman Vec = LegalizeOp(Vec); 37967f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman Op = DAG.UpdateNodeOperands(Op, Vec, Idx); 3797475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp3 = TLI.LowerOperation(Op, DAG); 3798ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp3.getNode()) 37997f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman return Tmp3; 38007f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman break; 38017f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman } 38027f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman case TargetLowering::Legal: 38037f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman if (isTypeLegal(TVT)) { 38047f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman Vec = LegalizeOp(Vec); 38057f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman Op = DAG.UpdateNodeOperands(Op, Vec, Idx); 3806844228a631f47bb39f71f617063831fb83c3843bChristopher Lamb return Op; 38077f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman } 38087f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman break; 38090c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang case TargetLowering::Promote: 38100c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang assert(TVT.isVector() && "not vector type"); 38110c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang // fall thru to expand since vectors are by default are promote 38127f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman case TargetLowering::Expand: 38137f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman break; 38147f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman } 38157f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman 38161fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman if (NumElems == 1) 38171597221eace1c53ce5f84a7018397497d11a8393Chris Lattner // This must be an access of the only element. Return it. 38181fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman return DAG.getNode(ISD::BIT_CONVERT, dl, Op.getValueType(), Vec); 38191fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman else 38201fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman return ExpandExtractFromVectorThroughStack(Op); 38211597221eace1c53ce5f84a7018397497d11a8393Chris Lattner} 38221597221eace1c53ce5f84a7018397497d11a8393Chris Lattner 38233d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli FriedmanSDValue SelectionDAGLegalize::ExpandExtractFromVectorThroughStack(SDValue Op) { 38243d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman SDValue Vec = Op.getOperand(0); 38253d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman SDValue Idx = Op.getOperand(1); 38263d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman DebugLoc dl = Op.getDebugLoc(); 38273d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman // Store the value to a temporary stack slot, then LOAD the returned part. 38283d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman SDValue StackPtr = DAG.CreateStackTemporary(Vec.getValueType()); 38293d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr, NULL, 0); 38303d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman 38313d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman // Add the offset to the index. 38322a35b1c54ba55a917e01e0043efcf67e20505953Eli Friedman unsigned EltSize = 38332a35b1c54ba55a917e01e0043efcf67e20505953Eli Friedman Vec.getValueType().getVectorElementType().getSizeInBits()/8; 38343d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman Idx = DAG.getNode(ISD::MUL, dl, Idx.getValueType(), Idx, 38353d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman DAG.getConstant(EltSize, Idx.getValueType())); 38363d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman 38373d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman if (Idx.getValueType().bitsGT(TLI.getPointerTy())) 38383d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman Idx = DAG.getNode(ISD::TRUNCATE, dl, TLI.getPointerTy(), Idx); 38393d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman else 38403d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman Idx = DAG.getNode(ISD::ZERO_EXTEND, dl, TLI.getPointerTy(), Idx); 38413d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman 38423d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman StackPtr = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, StackPtr); 38433d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman 38443d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman return DAG.getLoad(Op.getValueType(), dl, Ch, StackPtr, NULL, 0); 38453d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman} 38463d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman 3847750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman/// LegalizeSetCCOperands - Attempts to create a legal LHS and RHS for a SETCC 3848750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman/// with condition CC on the current target. This usually involves legalizing 3849750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman/// or promoting the arguments. In the case where LHS and RHS must be expanded, 3850750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman/// there may be no choice but to create a new SetCC node to represent the 3851750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman/// legalized value of setcc lhs, rhs. In this case, the value is returned in 3852475871a144eb604ddaf37503397ba0941442e5fbDan Gohman/// LHS, and the SDValue returned in RHS has a nil SDNode value. 3853475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid SelectionDAGLegalize::LegalizeSetCCOperands(SDValue &LHS, 3854475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &RHS, 3855bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue &CC, 3856bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl) { 385774807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman LHS = LegalizeOp(LHS); 385874807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman RHS = LegalizeOp(RHS); 385974807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman} 3860750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman 38617f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng/// LegalizeSetCCCondCode - Legalize a SETCC with given LHS and RHS and 38627f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng/// condition code CC on the current target. This routine assumes LHS and rHS 38637f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng/// have already been legalized by LegalizeSetCCOperands. It expands SETCC with 38647f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng/// illegal condition code into AND / OR of multiple SETCC values. 38657f042681764c6f8eae22781d8b4cb4c218a86b76Evan Chengvoid SelectionDAGLegalize::LegalizeSetCCCondCode(MVT VT, 38667f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng SDValue &LHS, SDValue &RHS, 3867bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue &CC, 3868bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl) { 38697f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng MVT OpVT = LHS.getValueType(); 38707f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng ISD::CondCode CCCode = cast<CondCodeSDNode>(CC)->get(); 38717f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng switch (TLI.getCondCodeAction(CCCode, OpVT)) { 38727f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng default: assert(0 && "Unknown condition code action!"); 38737f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng case TargetLowering::Legal: 38747f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng // Nothing to do. 38757f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng break; 38767f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng case TargetLowering::Expand: { 38777f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng ISD::CondCode CC1 = ISD::SETCC_INVALID, CC2 = ISD::SETCC_INVALID; 38787f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng unsigned Opc = 0; 38797f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng switch (CCCode) { 38807f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng default: assert(0 && "Don't know how to expand this condition!"); abort(); 3881e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETOEQ: CC1 = ISD::SETEQ; CC2 = ISD::SETO; Opc = ISD::AND; break; 3882e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETOGT: CC1 = ISD::SETGT; CC2 = ISD::SETO; Opc = ISD::AND; break; 3883e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETOGE: CC1 = ISD::SETGE; CC2 = ISD::SETO; Opc = ISD::AND; break; 3884e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETOLT: CC1 = ISD::SETLT; CC2 = ISD::SETO; Opc = ISD::AND; break; 3885e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETOLE: CC1 = ISD::SETLE; CC2 = ISD::SETO; Opc = ISD::AND; break; 3886e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETONE: CC1 = ISD::SETNE; CC2 = ISD::SETO; Opc = ISD::AND; break; 3887e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETUEQ: CC1 = ISD::SETEQ; CC2 = ISD::SETUO; Opc = ISD::OR; break; 3888e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETUGT: CC1 = ISD::SETGT; CC2 = ISD::SETUO; Opc = ISD::OR; break; 3889e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETUGE: CC1 = ISD::SETGE; CC2 = ISD::SETUO; Opc = ISD::OR; break; 3890e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETULT: CC1 = ISD::SETLT; CC2 = ISD::SETUO; Opc = ISD::OR; break; 3891e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETULE: CC1 = ISD::SETLE; CC2 = ISD::SETUO; Opc = ISD::OR; break; 3892e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETUNE: CC1 = ISD::SETNE; CC2 = ISD::SETUO; Opc = ISD::OR; break; 38937f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng // FIXME: Implement more expansions. 38947f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng } 38957f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng 3896bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue SetCC1 = DAG.getSetCC(dl, VT, LHS, RHS, CC1); 3897bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue SetCC2 = DAG.getSetCC(dl, VT, LHS, RHS, CC2); 3898bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen LHS = DAG.getNode(Opc, dl, VT, SetCC1, SetCC2); 38997f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng RHS = SDValue(); 39007f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng CC = SDValue(); 39017f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng break; 39027f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng } 39037f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng } 39047f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng} 39057f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng 39061401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner/// EmitStackConvert - Emit a store/load combination to the stack. This stores 39071401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner/// SrcOp to a stack slot of type SlotVT, truncating it if needed. It then does 39081401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner/// a load from the stack slot to DestVT, extending it if needed. 39091401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner/// The resultant code need not be legal. 3910475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::EmitStackConvert(SDValue SrcOp, 3911475871a144eb604ddaf37503397ba0941442e5fbDan Gohman MVT SlotVT, 39128a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen MVT DestVT, 39138a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DebugLoc dl) { 391435481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner // Create the stack frame object. 3915ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson unsigned SrcAlign = 3916ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson TLI.getTargetData()->getPrefTypeAlignment(SrcOp.getValueType(). 3917ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson getTypeForMVT()); 3918475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue FIPtr = DAG.CreateStackTemporary(SlotVT, SrcAlign); 3919fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 3920bbbbb9c3dd4160990f856854d16a3beaead1f354Dan Gohman FrameIndexSDNode *StackPtrFI = cast<FrameIndexSDNode>(FIPtr); 392169de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman int SPFI = StackPtrFI->getIndex(); 392215b3830bcda4f9958abf1c65e6e1c64c5cbb484dDan Gohman const Value *SV = PseudoSourceValue::getFixedStack(SPFI); 392315b3830bcda4f9958abf1c65e6e1c64c5cbb484dDan Gohman 392483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned SrcSize = SrcOp.getValueType().getSizeInBits(); 392583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned SlotSize = SlotVT.getSizeInBits(); 392683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned DestSize = DestVT.getSizeInBits(); 3927ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson unsigned DestAlign = 3928ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson TLI.getTargetData()->getPrefTypeAlignment(DestVT.getTypeForMVT()); 3929fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 39301401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner // Emit a store to the stack slot. Use a truncstore if the input value is 39311401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner // later than DestVT. 3932475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Store; 3933fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 39341401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner if (SrcSize > SlotSize) 39358a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Store = DAG.getTruncStore(DAG.getEntryNode(), dl, SrcOp, FIPtr, 393615b3830bcda4f9958abf1c65e6e1c64c5cbb484dDan Gohman SV, 0, SlotVT, false, SrcAlign); 39371401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner else { 39381401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner assert(SrcSize == SlotSize && "Invalid store"); 39398a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Store = DAG.getStore(DAG.getEntryNode(), dl, SrcOp, FIPtr, 394015b3830bcda4f9958abf1c65e6e1c64c5cbb484dDan Gohman SV, 0, false, SrcAlign); 39411401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner } 3942fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 394335481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner // Result is a load from the stack slot. 39441401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner if (SlotSize == DestSize) 39458a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getLoad(DestVT, dl, Store, FIPtr, SV, 0, false, DestAlign); 3946fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 39471401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner assert(SlotSize < DestSize && "Unknown extension!"); 39488a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getExtLoad(ISD::EXTLOAD, dl, DestVT, Store, FIPtr, SV, 0, SlotVT, 3949364d73ddab43b699ab90240f11b7a2eb5cf69bd8Mon P Wang false, DestAlign); 395035481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner} 395135481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner 3952475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::ExpandSCALAR_TO_VECTOR(SDNode *Node) { 39538a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DebugLoc dl = Node->getDebugLoc(); 39544352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner // Create a vector sized/aligned stack slot, store the value to element #0, 39554352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner // then load the whole vector back out. 3956475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue StackPtr = DAG.CreateStackTemporary(Node->getValueType(0)); 395769de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman 3958bbbbb9c3dd4160990f856854d16a3beaead1f354Dan Gohman FrameIndexSDNode *StackPtrFI = cast<FrameIndexSDNode>(StackPtr); 395969de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman int SPFI = StackPtrFI->getIndex(); 396069de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman 3961b10b5ac8d9da43ca2db61401a20af6b676c98438Duncan Sands SDValue Ch = DAG.getTruncStore(DAG.getEntryNode(), dl, Node->getOperand(0), 3962b10b5ac8d9da43ca2db61401a20af6b676c98438Duncan Sands StackPtr, 3963b10b5ac8d9da43ca2db61401a20af6b676c98438Duncan Sands PseudoSourceValue::getFixedStack(SPFI), 0, 3964b10b5ac8d9da43ca2db61401a20af6b676c98438Duncan Sands Node->getValueType(0).getVectorElementType()); 39658a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getLoad(Node->getValueType(0), dl, Ch, StackPtr, 3966a54cf176613f9ae8301519a61b8935652c0fb8aeDan Gohman PseudoSourceValue::getFixedStack(SPFI), 0); 39674352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner} 39684352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner 39694352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner 3970ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner/// ExpandBUILD_VECTOR - Expand a BUILD_VECTOR node on targets that don't 397107a96765daedf180a7102d39fe56c499878312b7Dan Gohman/// support the operation, but do support the resultant vector type. 3972475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::ExpandBUILD_VECTOR(SDNode *Node) { 397326cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson unsigned NumElems = Node->getNumOperands(); 397426cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson SDValue SplatValue = Node->getOperand(0); 397526cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson DebugLoc dl = Node->getDebugLoc(); 397626cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson MVT VT = Node->getValueType(0); 397726cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson MVT OpVT = SplatValue.getValueType(); 397826cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson MVT EltVT = VT.getVectorElementType(); 3979fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 3980fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // If the only non-undef value is the low element, turn this into a 398187100e0b83b808757bf44dabecd1d1048255d1adChris Lattner // SCALAR_TO_VECTOR node. If this is { X, X, X, X }, determine X. 3982ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner bool isOnlyLowElement = true; 3983fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 3984475871a144eb604ddaf37503397ba0941442e5fbDan Gohman // FIXME: it would be far nicer to change this into map<SDValue,uint64_t> 3985f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner // and use a bitmask instead of a list of elements. 39869008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman // FIXME: this doesn't treat <0, u, 0, u> for example, as a splat. 3987475871a144eb604ddaf37503397ba0941442e5fbDan Gohman std::map<SDValue, std::vector<unsigned> > Values; 3988033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng Values[SplatValue].push_back(0); 39892eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner bool isConstant = true; 39902eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner if (!isa<ConstantFPSDNode>(SplatValue) && !isa<ConstantSDNode>(SplatValue) && 39912eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner SplatValue.getOpcode() != ISD::UNDEF) 39922eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner isConstant = false; 3993fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 3994033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng for (unsigned i = 1; i < NumElems; ++i) { 3995475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue V = Node->getOperand(i); 399689a1b380a475cbe477e50ff4b94335596b37f21aChris Lattner Values[V].push_back(i); 3997033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng if (V.getOpcode() != ISD::UNDEF) 3998ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner isOnlyLowElement = false; 3999033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng if (SplatValue != V) 4000ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson SplatValue = SDValue(0, 0); 40012eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner 40022eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner // If this isn't a constant element or an undef, we can't use a constant 40032eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner // pool load. 40042eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner if (!isa<ConstantFPSDNode>(V) && !isa<ConstantSDNode>(V) && 40052eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner V.getOpcode() != ISD::UNDEF) 40062eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner isConstant = false; 4007ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } 4008fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 4009ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner if (isOnlyLowElement) { 4010ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // If the low element is an undef too, then this whole things is an undef. 4011ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner if (Node->getOperand(0).getOpcode() == ISD::UNDEF) 401226cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson return DAG.getUNDEF(VT); 4013ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // Otherwise, turn this into a scalar_to_vector node. 401426cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Node->getOperand(0)); 4015ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } 4016fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 40172eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner // If all elements are constants, create a load from the constant pool. 4018ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner if (isConstant) { 4019ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner std::vector<Constant*> CV; 4020033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng for (unsigned i = 0, e = NumElems; i != e; ++i) { 4021fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel if (ConstantFPSDNode *V = 4022ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner dyn_cast<ConstantFPSDNode>(Node->getOperand(i))) { 40234fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman CV.push_back(const_cast<ConstantFP *>(V->getConstantFPValue())); 4024fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel } else if (ConstantSDNode *V = 4025ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson dyn_cast<ConstantSDNode>(Node->getOperand(i))) { 40264fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman CV.push_back(const_cast<ConstantInt *>(V->getConstantIntValue())); 4027ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } else { 4028ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner assert(Node->getOperand(i).getOpcode() == ISD::UNDEF); 402926cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson const Type *OpNTy = OpVT.getTypeForMVT(); 4030ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner CV.push_back(UndefValue::get(OpNTy)); 4031ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } 4032ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } 40339d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer Constant *CP = ConstantVector::get(CV); 4034475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue CPIdx = DAG.getConstantPool(CP, TLI.getPointerTy()); 40351606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned Alignment = cast<ConstantPoolSDNode>(CPIdx)->getAlignment(); 40368a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx, 403750284d81f863a6576582e1a171a22eb0f012ddf3Dan Gohman PseudoSourceValue::getConstantPool(), 0, 403850284d81f863a6576582e1a171a22eb0f012ddf3Dan Gohman false, Alignment); 4039ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } 4040fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 4041ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (SplatValue.getNode()) { // Splat of one value? 40422eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner // Build the shuffle constant vector: <0, 0, 0, 0> 40439008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman SmallVector<int, 8> ZeroVec(NumElems, 0); 4044033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng 40452eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner // If the target supports VECTOR_SHUFFLE and this shuffle mask, use it. 40469008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman if (TLI.isShuffleMaskLegal(ZeroVec, Node->getValueType(0))) { 40472eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner // Get the splatted value into the low element of a vector register. 4048fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel SDValue LowValVec = 404926cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, SplatValue); 4050fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 40512eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner // Return shuffle(LowValVec, undef, <0,0,0,0>) 40529008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman return DAG.getVectorShuffle(VT, dl, LowValVec, DAG.getUNDEF(VT), 40539008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman &ZeroVec[0]); 40542eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner } 40552eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner } 4056fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 4057033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng // If there are only two unique elements, we may be able to turn this into a 4058033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng // vector shuffle. 4059033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng if (Values.size() == 2) { 4060f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner // Get the two values in deterministic order. 4061475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Val1 = Node->getOperand(1); 4062475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Val2; 4063475871a144eb604ddaf37503397ba0941442e5fbDan Gohman std::map<SDValue, std::vector<unsigned> >::iterator MI = Values.begin(); 4064f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner if (MI->first != Val1) 4065f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner Val2 = MI->first; 4066f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner else 4067f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner Val2 = (++MI)->first; 4068fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 4069ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson // If Val1 is an undef, make sure it ends up as Val2, to ensure that our 4070f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner // vector shuffle has the undef vector on the RHS. 4071f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner if (Val1.getOpcode() == ISD::UNDEF) 4072f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner std::swap(Val1, Val2); 4073fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 4074033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng // Build the shuffle constant vector: e.g. <0, 4, 0, 4> 40759008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman SmallVector<int, 8> ShuffleMask(NumElems, -1); 4076f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner 4077f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner // Set elements of the shuffle mask for Val1. 4078f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner std::vector<unsigned> &Val1Elts = Values[Val1]; 4079f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner for (unsigned i = 0, e = Val1Elts.size(); i != e; ++i) 40809008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman ShuffleMask[Val1Elts[i]] = 0; 4081f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner 4082f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner // Set elements of the shuffle mask for Val2. 4083f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner std::vector<unsigned> &Val2Elts = Values[Val2]; 4084f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner for (unsigned i = 0, e = Val2Elts.size(); i != e; ++i) 4085f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner if (Val2.getOpcode() != ISD::UNDEF) 40869008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman ShuffleMask[Val2Elts[i]] = NumElems; 4087033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng 4088f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner // If the target supports SCALAR_TO_VECTOR and this shuffle mask, use it. 408926cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson if (TLI.isOperationLegalOrCustom(ISD::SCALAR_TO_VECTOR, VT) && 40909008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman TLI.isShuffleMaskLegal(ShuffleMask, VT)) { 409126cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson Val1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Val1); 409226cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson Val2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Val2); 40939008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman return DAG.getVectorShuffle(VT, dl, Val1, Val2, &ShuffleMask[0]); 4094033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng } 4095033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng } 4096fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 4097ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // Otherwise, we can't handle this case efficiently. Allocate a sufficiently 4098ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // aligned object on the stack, store each element into it, then load 4099ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // the result as a vector. 4100ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // Create the stack frame object. 4101475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue FIPtr = DAG.CreateStackTemporary(VT); 410215b3830bcda4f9958abf1c65e6e1c64c5cbb484dDan Gohman int FI = cast<FrameIndexSDNode>(FIPtr.getNode())->getIndex(); 410315b3830bcda4f9958abf1c65e6e1c64c5cbb484dDan Gohman const Value *SV = PseudoSourceValue::getFixedStack(FI); 410415b3830bcda4f9958abf1c65e6e1c64c5cbb484dDan Gohman 4105ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // Emit a store of each element to the stack slot. 4106475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 8> Stores; 410726cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson unsigned TypeByteSize = OpVT.getSizeInBits() / 8; 4108ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // Store (in the right endianness) the elements to memory. 4109ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 4110ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // Ignore undef elements. 4111ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner if (Node->getOperand(i).getOpcode() == ISD::UNDEF) continue; 4112fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 4113841c882f5dae8c953ea99b5824108313549cfaf8Chris Lattner unsigned Offset = TypeByteSize*i; 4114fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 4115475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Idx = DAG.getConstant(Offset, FIPtr.getValueType()); 41168a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Idx = DAG.getNode(ISD::ADD, dl, FIPtr.getValueType(), FIPtr, Idx); 4117fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 41188a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Stores.push_back(DAG.getStore(DAG.getEntryNode(), dl, Node->getOperand(i), 41198a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Idx, SV, Offset)); 4120ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } 4121fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 4122475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue StoreChain; 4123ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner if (!Stores.empty()) // Not all undef elements? 41248a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen StoreChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, 4125bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &Stores[0], Stores.size()); 4126ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner else 4127ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner StoreChain = DAG.getEntryNode(); 4128fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 4129ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // Result is a load from the stack slot. 41308a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getLoad(VT, dl, StoreChain, FIPtr, SV, 0); 4131ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner} 4132ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner 413377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// ExpandLibCall - Expand a node into a call to a libcall. If the result value 413477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// does not fit into a register, return the lo part and set the hi part to the 413577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// by-reg argument. If it does fit into a single register, return the result 413677e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// and leave the Hi part unset. 4137475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::ExpandLibCall(RTLIB::Libcall LC, SDNode *Node, 4138475871a144eb604ddaf37503397ba0941442e5fbDan Gohman bool isSigned, SDValue &Hi) { 41396831a815999dde4cf801e2076e66b4943964daf2Chris Lattner assert(!IsLegalizingCall && "Cannot overlap legalization of calls!"); 4140fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // The input chain to this libcall is the entry node of the function. 41416831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Legalizing the call will automatically add the previous call to the 41426831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // dependence. 4143475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue InChain = DAG.getEntryNode(); 4144fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 414577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 414647857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TargetLowering::ArgListEntry Entry; 414777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 414883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT ArgVT = Node->getOperand(i).getValueType(); 414983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands const Type *ArgTy = ArgVT.getTypeForMVT(); 4150fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Entry.Node = Node->getOperand(i); Entry.Ty = ArgTy; 4151d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Entry.isSExt = isSigned; 415200fee65fd21f9615d1a604b8b7d42cd16a3f6b47Duncan Sands Entry.isZExt = !isSigned; 415347857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Args.push_back(Entry); 415477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 4155056292fd738924f3f7703725d8f630983794b5a5Bill Wendling SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC), 41560c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang TLI.getPointerTy()); 4157edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 41580d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Splice the libcall in wherever FindInputOutputChains tells us to. 415983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands const Type *RetTy = Node->getValueType(0).getTypeForMVT(); 4160ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson std::pair<SDValue, SDValue> CallInfo = 416186098bd6a63d2cdf0c9be9ef3151bd2728281fd7Dale Johannesen TLI.LowerCallTo(InChain, RetTy, isSigned, !isSigned, false, false, 41627d2ad624fa749a6d3edac0d94e9c107989c16304Dale Johannesen CallingConv::C, false, Callee, Args, DAG, 41637d2ad624fa749a6d3edac0d94e9c107989c16304Dale Johannesen Node->getDebugLoc()); 41640d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 41656831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Legalize the call sequence, starting with the chain. This will advance 41666831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // the LastCALLSEQ_END to the legalized version of the CALLSEQ_END node that 41676831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // was added by LowerCallTo (guaranteeing proper serialization of calls). 41686831a815999dde4cf801e2076e66b4943964daf2Chris Lattner LegalizeOp(CallInfo.second); 416974807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman return CallInfo.first; 417022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner} 417122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 41727f8613e5b8398b688080e3c944ab8c11593e1ed0Dan Gohman/// LegalizeINT_TO_FP - Legalize a [US]INT_TO_FP operation. 41737f8613e5b8398b688080e3c944ab8c11593e1ed0Dan Gohman/// 41747f8613e5b8398b688080e3c944ab8c11593e1ed0Dan GohmanSDValue SelectionDAGLegalize:: 4175af435274e56af687b51f33b5bc6f005fe99ad46fDale JohannesenLegalizeINT_TO_FP(SDValue Result, bool isSigned, MVT DestTy, SDValue Op, 4176af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl) { 41777f8613e5b8398b688080e3c944ab8c11593e1ed0Dan Gohman bool isCustom = false; 41787f8613e5b8398b688080e3c944ab8c11593e1ed0Dan Gohman SDValue Tmp1; 417974807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman switch (TLI.getOperationAction(isSigned ? ISD::SINT_TO_FP : ISD::UINT_TO_FP, 418074807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman Op.getValueType())) { 418174807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman default: assert(0 && "Unknown operation action!"); 418274807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman case TargetLowering::Custom: 418374807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman isCustom = true; 418474807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman // FALLTHROUGH 418574807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman case TargetLowering::Legal: 418674807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman Tmp1 = LegalizeOp(Op); 4187ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Result.getNode()) 41887f8613e5b8398b688080e3c944ab8c11593e1ed0Dan Gohman Result = DAG.UpdateNodeOperands(Result, Tmp1); 41897f8613e5b8398b688080e3c944ab8c11593e1ed0Dan Gohman else 4190af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen Result = DAG.getNode(isSigned ? ISD::SINT_TO_FP : ISD::UINT_TO_FP, dl, 41917f8613e5b8398b688080e3c944ab8c11593e1ed0Dan Gohman DestTy, Tmp1); 419274807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman if (isCustom) { 419374807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman Tmp1 = TLI.LowerOperation(Result, DAG); 419474807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman if (Tmp1.getNode()) Result = Tmp1; 41954c6cfad85e63e2dbe273431bdf20533b495c955dEvan Cheng } 419674807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman break; 419722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case TargetLowering::Expand: 419874807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman Result = ExpandLegalINT_TO_FP(isSigned, LegalizeOp(Op), DestTy, dl); 419974807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman break; 420074807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman case TargetLowering::Promote: 420174807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman Result = PromoteLegalINT_TO_FP(LegalizeOp(Op), DestTy, isSigned, dl); 420274807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman break; 4203034f60ed24c53c1e37f7695965f782faec2dff2bDan Gohman } 4204a2e9485e34f1348526ed104dbdc194673e291077Dan Gohman return Result; 420522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner} 420622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 420722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// ExpandLegalINT_TO_FP - This function is responsible for legalizing a 420822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// INT_TO_FP operation of the specified operand when the target requests that 420922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// we expand it. At this point, we know that the result and operand types are 421022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// legal for the target. 4211475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::ExpandLegalINT_TO_FP(bool isSigned, 4212475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op0, 4213af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen MVT DestVT, 4214af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl) { 421522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (Op0.getValueType() == MVT::i32) { 421622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // simple 32-bit [signed|unsigned] integer to float/double expansion 4217fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 421823594d4537fb88a963c6d6993af5027eac9bfbacChris Lattner // Get the stack frame index of a 8 byte buffer. 4219475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue StackSlot = DAG.CreateStackTemporary(MVT::f64); 4220fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 422122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // word offset constant for Hi/Lo address computation 4222475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue WordOff = DAG.getConstant(sizeof(int), TLI.getPointerTy()); 422322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // set up Hi and Lo (into buffer) address based on endian 4224475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Hi = StackSlot; 4225fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel SDValue Lo = DAG.getNode(ISD::ADD, dl, 4226ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson TLI.getPointerTy(), StackSlot, WordOff); 4227408c428096df3a3970a8387f9dd258ae948663a6Chris Lattner if (TLI.isLittleEndian()) 4228408c428096df3a3970a8387f9dd258ae948663a6Chris Lattner std::swap(Hi, Lo); 4229fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 423022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // if signed map to unsigned space 4231475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op0Mapped; 423222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (isSigned) { 423322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // constant used to invert sign bit (signed to unsigned mapping) 4234475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue SignBit = DAG.getConstant(0x80000000u, MVT::i32); 4235af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen Op0Mapped = DAG.getNode(ISD::XOR, dl, MVT::i32, Op0, SignBit); 423622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } else { 423722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner Op0Mapped = Op0; 423822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 423922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // store the lo of the constructed double - based on integer input 4240af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue Store1 = DAG.getStore(DAG.getEntryNode(), dl, 4241ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson Op0Mapped, Lo, NULL, 0); 424222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // initial hi portion of constructed double 4243475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue InitialHi = DAG.getConstant(0x43300000u, MVT::i32); 424422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // store the hi of the constructed double - biased exponent 4245af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue Store2=DAG.getStore(Store1, dl, InitialHi, Hi, NULL, 0); 424622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // load the constructed double 4247af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue Load = DAG.getLoad(MVT::f64, dl, Store2, StackSlot, NULL, 0); 424822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // FP constant to bias correct the final result 4249475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Bias = DAG.getConstantFP(isSigned ? 4250ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson BitsToDouble(0x4330000080000000ULL) : 4251ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson BitsToDouble(0x4330000000000000ULL), 425222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner MVT::f64); 425322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // subtract the bias 4254af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::f64, Load, Bias); 425522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // final result 4256475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Result; 425722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // handle final rounding 425822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (DestVT == MVT::f64) { 425922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // do nothing 426022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner Result = Sub; 42618e4eb09b1e3571965f49edcdfb56b1375b1b7551Duncan Sands } else if (DestVT.bitsLT(MVT::f64)) { 4262af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen Result = DAG.getNode(ISD::FP_ROUND, dl, DestVT, Sub, 42630bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(0)); 42648e4eb09b1e3571965f49edcdfb56b1375b1b7551Duncan Sands } else if (DestVT.bitsGT(MVT::f64)) { 4265af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen Result = DAG.getNode(ISD::FP_EXTEND, dl, DestVT, Sub); 426622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 426722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner return Result; 426822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 426922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner assert(!isSigned && "Legalize cannot Expand SINT_TO_FP for i64 yet"); 4270af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue Tmp1 = DAG.getNode(ISD::SINT_TO_FP, dl, DestVT, Op0); 427122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 4272af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue SignSet = DAG.getSetCC(dl, TLI.getSetCCResultType(Op0.getValueType()), 42735480c0469e5c0323ffb12f1ead2abd169d6cc0e7Duncan Sands Op0, DAG.getConstant(0, Op0.getValueType()), 42745480c0469e5c0323ffb12f1ead2abd169d6cc0e7Duncan Sands ISD::SETLT); 4275475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Zero = DAG.getIntPtrConstant(0), Four = DAG.getIntPtrConstant(4); 4276af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue CstOffset = DAG.getNode(ISD::SELECT, dl, Zero.getValueType(), 427722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner SignSet, Four, Zero); 427822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 427922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // If the sign bit of the integer is set, the large number will be treated 428022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // as a negative number. To counteract this, the dynamic code adds an 428122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // offset depending on the data type. 428222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner uint64_t FF; 428383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands switch (Op0.getValueType().getSimpleVT()) { 428422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner default: assert(0 && "Unsupported integer type!"); 428522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case MVT::i8 : FF = 0x43800000ULL; break; // 2^8 (as a float) 428622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case MVT::i16: FF = 0x47800000ULL; break; // 2^16 (as a float) 428722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case MVT::i32: FF = 0x4F800000ULL; break; // 2^32 (as a float) 428822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case MVT::i64: FF = 0x5F800000ULL; break; // 2^64 (as a float) 428922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 429022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (TLI.isLittleEndian()) FF <<= 32; 4291d2e936a513b01b2c5df91a9c0d80070e8c752aceChris Lattner Constant *FudgeFactor = ConstantInt::get(Type::Int64Ty, FF); 429222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 4293475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy()); 42941606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned Alignment = cast<ConstantPoolSDNode>(CPIdx)->getAlignment(); 4295af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen CPIdx = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(), CPIdx, CstOffset); 429687a0f10dc7eff8cf5e83a754f75adf9cb3991435Dan Gohman Alignment = std::min(Alignment, 4u); 4297475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue FudgeInReg; 429822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (DestVT == MVT::f32) 4299af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen FudgeInReg = DAG.getLoad(MVT::f32, dl, DAG.getEntryNode(), CPIdx, 430050284d81f863a6576582e1a171a22eb0f012ddf3Dan Gohman PseudoSourceValue::getConstantPool(), 0, 430150284d81f863a6576582e1a171a22eb0f012ddf3Dan Gohman false, Alignment); 430222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner else { 430369de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman FudgeInReg = 4304af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen LegalizeOp(DAG.getExtLoad(ISD::EXTLOAD, dl, DestVT, 430569de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman DAG.getEntryNode(), CPIdx, 43063069b8743769527ce7af6cfb6591a2f0fc2faee4Dan Gohman PseudoSourceValue::getConstantPool(), 0, 430750284d81f863a6576582e1a171a22eb0f012ddf3Dan Gohman MVT::f32, false, Alignment)); 430822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 430922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 4310af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen return DAG.getNode(ISD::FADD, dl, DestVT, Tmp1, FudgeInReg); 431122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner} 431222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 431322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// PromoteLegalINT_TO_FP - This function is responsible for legalizing a 431422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// *INT_TO_FP operation of the specified operand when the target requests that 431522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// we promote it. At this point, we know that the result and operand types are 431622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// legal for the target, and that there is a legal UINT_TO_FP or SINT_TO_FP 431722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// operation that takes a larger input. 4318475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::PromoteLegalINT_TO_FP(SDValue LegalOp, 4319475871a144eb604ddaf37503397ba0941442e5fbDan Gohman MVT DestVT, 4320af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen bool isSigned, 4321af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl) { 432222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // First step, figure out the appropriate *INT_TO_FP operation to use. 432383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NewInTy = LegalOp.getValueType(); 432422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 432522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner unsigned OpToUse = 0; 432622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 432722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // Scan for the appropriate larger type to use. 432822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner while (1) { 432983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands NewInTy = (MVT::SimpleValueType)(NewInTy.getSimpleVT()+1); 433083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(NewInTy.isInteger() && "Ran out of possibilities!"); 433122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 433222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // If the target supports SINT_TO_FP of this type, use it. 433322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner switch (TLI.getOperationAction(ISD::SINT_TO_FP, NewInTy)) { 433422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner default: break; 433522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case TargetLowering::Legal: 433622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (!TLI.isTypeLegal(NewInTy)) 433722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner break; // Can't use this datatype. 433822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // FALL THROUGH. 433922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case TargetLowering::Custom: 434022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner OpToUse = ISD::SINT_TO_FP; 434122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner break; 434222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 434322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (OpToUse) break; 434422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (isSigned) continue; 434522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 434622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // If the target supports UINT_TO_FP of this type, use it. 434722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner switch (TLI.getOperationAction(ISD::UINT_TO_FP, NewInTy)) { 434822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner default: break; 434922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case TargetLowering::Legal: 435022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (!TLI.isTypeLegal(NewInTy)) 435122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner break; // Can't use this datatype. 435222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // FALL THROUGH. 435322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case TargetLowering::Custom: 435422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner OpToUse = ISD::UINT_TO_FP; 435522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner break; 435622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 435722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (OpToUse) break; 435822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 435922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // Otherwise, try a larger type. 436022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 436122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 436222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // Okay, we found the operation and type to use. Zero extend our input to the 436322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // desired type then run the operation on it. 4364af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen return DAG.getNode(OpToUse, dl, DestVT, 436522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, 4366af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen dl, NewInTy, LegalOp)); 436777e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 436877e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 436922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// PromoteLegalFP_TO_INT - This function is responsible for legalizing a 437022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// FP_TO_*INT operation of the specified operand when the target requests that 437122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// we promote it. At this point, we know that the result and operand types are 437222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// legal for the target, and that there is a legal FP_TO_UINT or FP_TO_SINT 437322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// operation that returns a larger result. 4374475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::PromoteLegalFP_TO_INT(SDValue LegalOp, 4375475871a144eb604ddaf37503397ba0941442e5fbDan Gohman MVT DestVT, 4376af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen bool isSigned, 4377af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl) { 437822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // First step, figure out the appropriate FP_TO*INT operation to use. 437983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NewOutTy = DestVT; 43809c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 438122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner unsigned OpToUse = 0; 4382e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 438322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // Scan for the appropriate larger type to use. 438422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner while (1) { 438583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands NewOutTy = (MVT::SimpleValueType)(NewOutTy.getSimpleVT()+1); 438683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(NewOutTy.isInteger() && "Ran out of possibilities!"); 438766de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner 438822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // If the target supports FP_TO_SINT returning this type, use it. 438922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner switch (TLI.getOperationAction(ISD::FP_TO_SINT, NewOutTy)) { 439022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner default: break; 439122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case TargetLowering::Legal: 439222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (!TLI.isTypeLegal(NewOutTy)) 439322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner break; // Can't use this datatype. 439422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // FALL THROUGH. 439522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case TargetLowering::Custom: 439622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner OpToUse = ISD::FP_TO_SINT; 439722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner break; 439822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 439922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (OpToUse) break; 4400e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 440122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // If the target supports FP_TO_UINT of this type, use it. 440222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner switch (TLI.getOperationAction(ISD::FP_TO_UINT, NewOutTy)) { 440322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner default: break; 440422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case TargetLowering::Legal: 440522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (!TLI.isTypeLegal(NewOutTy)) 440622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner break; // Can't use this datatype. 440722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // FALL THROUGH. 440822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case TargetLowering::Custom: 440922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner OpToUse = ISD::FP_TO_UINT; 441022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner break; 4411e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner } 441222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (OpToUse) break; 44130d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 441422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // Otherwise, try a larger type. 4415a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner } 4416a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner 4417fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 441827a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner // Okay, we found the operation and type to use. 4419af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue Operation = DAG.getNode(OpToUse, dl, NewOutTy, LegalOp); 4420126d90770bdb17e6925b2fe26de99aa079b7b9b3Duncan Sands 442127a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner // If the operation produces an invalid type, it must be custom lowered. Use 442227a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner // the target lowering hooks to expand it. Just keep the low part of the 442327a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner // expanded operation, we know that we're truncating anyway. 442427a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner if (getTypeAction(NewOutTy) == Expand) { 44251607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands SmallVector<SDValue, 2> Results; 44261607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands TLI.ReplaceNodeResults(Operation.getNode(), Results, DAG); 44271607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands assert(Results.size() == 1 && "Incorrect FP_TO_XINT lowering!"); 44281607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands Operation = Results[0]; 442927a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner } 4430126d90770bdb17e6925b2fe26de99aa079b7b9b3Duncan Sands 443127a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner // Truncate the result of the extended FP_TO_*INT operation to the desired 443227a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner // size. 4433af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen return DAG.getNode(ISD::TRUNCATE, dl, DestVT, Operation); 443422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner} 443513689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner 443622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// ExpandBSWAP - Open code the operations for BSWAP of the specified operation. 443722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// 44388a782a2a8c2f0c82f292d03a3f707232b0bae27bDale JohannesenSDValue SelectionDAGLegalize::ExpandBSWAP(SDValue Op, DebugLoc dl) { 443983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Op.getValueType(); 444083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT SHVT = TLI.getShiftAmountTy(); 4441475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp1, Tmp2, Tmp3, Tmp4, Tmp5, Tmp6, Tmp7, Tmp8; 444283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands switch (VT.getSimpleVT()) { 444322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner default: assert(0 && "Unhandled Expand type in BSWAP!"); abort(); 444422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case MVT::i16: 44458a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, SHVT)); 44468a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, SHVT)); 44478a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getNode(ISD::OR, dl, VT, Tmp1, Tmp2); 444822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case MVT::i32: 44498a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp4 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(24, SHVT)); 44508a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp3 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, SHVT)); 44518a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, SHVT)); 44528a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(24, SHVT)); 44538a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp3 = DAG.getNode(ISD::AND, dl, VT, Tmp3, DAG.getConstant(0xFF0000, VT)); 44548a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp2, DAG.getConstant(0xFF00, VT)); 44558a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp3); 44568a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp1); 44578a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp2); 445822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case MVT::i64: 44598a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp8 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(56, SHVT)); 44608a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp7 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(40, SHVT)); 44618a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp6 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(24, SHVT)); 44628a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp5 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, SHVT)); 44638a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp4 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, SHVT)); 44648a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp3 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(24, SHVT)); 44658a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(40, SHVT)); 44668a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(56, SHVT)); 44678a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp7 = DAG.getNode(ISD::AND, dl, VT, Tmp7, DAG.getConstant(255ULL<<48, VT)); 44688a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp6 = DAG.getNode(ISD::AND, dl, VT, Tmp6, DAG.getConstant(255ULL<<40, VT)); 44698a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp5 = DAG.getNode(ISD::AND, dl, VT, Tmp5, DAG.getConstant(255ULL<<32, VT)); 44708a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp4 = DAG.getNode(ISD::AND, dl, VT, Tmp4, DAG.getConstant(255ULL<<24, VT)); 44718a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp3 = DAG.getNode(ISD::AND, dl, VT, Tmp3, DAG.getConstant(255ULL<<16, VT)); 44728a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp2, DAG.getConstant(255ULL<<8 , VT)); 44738a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp8 = DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp7); 44748a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp6 = DAG.getNode(ISD::OR, dl, VT, Tmp6, Tmp5); 44758a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp3); 44768a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp1); 44778a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp8 = DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp6); 44788a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp2); 44798a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp4); 44800d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner } 448177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 4482edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 448322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// ExpandBitCount - Expand the specified bitcount instruction into operations. 448422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// 4485fdc40a0a696c658d550d894ea03772e5f8af2c94Scott MichelSDValue SelectionDAGLegalize::ExpandBitCount(unsigned Opc, SDValue Op, 44868a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DebugLoc dl) { 448722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner switch (Opc) { 448822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner default: assert(0 && "Cannot expand this yet!"); 448922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case ISD::CTPOP: { 449022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner static const uint64_t mask[6] = { 449122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 0x5555555555555555ULL, 0x3333333333333333ULL, 449222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 0x0F0F0F0F0F0F0F0FULL, 0x00FF00FF00FF00FFULL, 449322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 0x0000FFFF0000FFFFULL, 0x00000000FFFFFFFFULL 449422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner }; 449583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Op.getValueType(); 449683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT ShVT = TLI.getShiftAmountTy(); 449783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned len = VT.getSizeInBits(); 449822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 449922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner //x = (x & mask[i][len/8]) + (x >> (1 << i) & mask[i][len/8]) 4500b0d5cdd52e8448f769cd71aaee6a4b8592dc08b1Duncan Sands unsigned EltSize = VT.isVector() ? 4501b0d5cdd52e8448f769cd71aaee6a4b8592dc08b1Duncan Sands VT.getVectorElementType().getSizeInBits() : len; 4502b0d5cdd52e8448f769cd71aaee6a4b8592dc08b1Duncan Sands SDValue Tmp2 = DAG.getConstant(APInt(EltSize, mask[i]), VT); 4503475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp3 = DAG.getConstant(1ULL << i, ShVT); 4504fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Op = DAG.getNode(ISD::ADD, dl, VT, 4505e72c5964d5263f2489bf2c7e9d32f71271d205fcDale Johannesen DAG.getNode(ISD::AND, dl, VT, Op, Tmp2), 45068a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DAG.getNode(ISD::AND, dl, VT, 45078a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DAG.getNode(ISD::SRL, dl, VT, Op, Tmp3), 45088a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2)); 450922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 451022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner return Op; 451122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 451222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case ISD::CTLZ: { 451322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // for now, we do this: 451422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // x = x | (x >> 1); 451522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // x = x | (x >> 2); 451622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // ... 451722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // x = x | (x >>16); 451822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // x = x | (x >>32); // for 64-bit input 451922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // return popcount(~x); 452022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // 452122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // but see also: http://www.hackersdelight.org/HDcode/nlz.cc 452283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Op.getValueType(); 452383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT ShVT = TLI.getShiftAmountTy(); 452483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned len = VT.getSizeInBits(); 452522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 4526475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp3 = DAG.getConstant(1ULL << i, ShVT); 4527fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Op = DAG.getNode(ISD::OR, dl, VT, Op, 4528e72c5964d5263f2489bf2c7e9d32f71271d205fcDale Johannesen DAG.getNode(ISD::SRL, dl, VT, Op, Tmp3)); 452922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 45308a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Op = DAG.getNOT(dl, Op, VT); 45318a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getNode(ISD::CTPOP, dl, VT, Op); 453222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 453322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case ISD::CTTZ: { 453422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // for now, we use: { return popcount(~x & (x - 1)); } 453522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // unless the target has ctlz but not ctpop, in which case we use: 453622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // { return 32 - nlz(~x & (x-1)); } 453722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // see also http://www.hackersdelight.org/HDcode/ntz.cc 453883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Op.getValueType(); 45398a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen SDValue Tmp3 = DAG.getNode(ISD::AND, dl, VT, 45408a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DAG.getNOT(dl, Op, VT), 45418a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DAG.getNode(ISD::SUB, dl, VT, Op, 45427581bfa2757a3149c6d17c0fe592e5c3808aa843Bill Wendling DAG.getConstant(1, VT))); 454322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // If ISD::CTLZ is legal and CTPOP isn't, then do that instead. 4544f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman if (!TLI.isOperationLegalOrCustom(ISD::CTPOP, VT) && 4545f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman TLI.isOperationLegalOrCustom(ISD::CTLZ, VT)) 45468a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getNode(ISD::SUB, dl, VT, 454783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(VT.getSizeInBits(), VT), 45488a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DAG.getNode(ISD::CTLZ, dl, VT, Tmp3)); 45498a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getNode(ISD::CTPOP, dl, VT, Tmp3); 455022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 455122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 455222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner} 4553e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 45543e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// SelectionDAG::Legalize - This is the entry point for the file. 45553e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 455698a366d547772010e94609e4584489b3e5ce0043Bill Wendlingvoid SelectionDAG::Legalize(bool TypesNeedLegalizing, 455798a366d547772010e94609e4584489b3e5ce0043Bill Wendling CodeGenOpt::Level OptLevel) { 45583e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// run - This is the main entry point to this class. 45593e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 45601fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman SelectionDAGLegalize(*this, OptLevel).LegalizeDAG(); 45613e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 45623e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 4563