LegalizeDAG.cpp revision 26ea8f982fb58245d3735b80ce04bc8050348a19
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, 1283f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman SDValue Idx, DebugLoc dl); 1293f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman SDValue ExpandINSERT_VECTOR_ELT(SDValue Vec, SDValue Val, 1303f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman SDValue Idx, DebugLoc dl); 131826695281344e3a4c4d44d73dd155107aafd689bDan Gohman 132f007a8b931e229eb325319c97363be8507311e2eMon P Wang /// Useful 16 element vector type that is used to pass operands for widening. 133fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel typedef SmallVector<SDValue, 16> SDValueVector; 134fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1355a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman /// ShuffleWithNarrowerEltType - Return a vector shuffle operation which 1365a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman /// performs the same shuffe in terms of order or result bytes, but on a type 1375a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman /// whose vector element type is narrower than the original shuffle type. 1385a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman /// e.g. <v4i32> <0, 1, 0, 1> -> v8i16 <0, 1, 2, 3, 0, 1, 2, 3> 1395a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman SDValue ShuffleWithNarrowerEltType(MVT NVT, MVT VT, DebugLoc dl, 1405a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman SDValue N1, SDValue N2, 1415a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman SmallVectorImpl<int> &Mask) const; 142fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 143c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner bool LegalizeAllNodesNotLeadingTo(SDNode *N, SDNode *Dest, 14400755df36c1448ac4728a74d907aa09e3d8b2d49Chris Lattner SmallPtrSet<SDNode*, 32> &NodesLeadingTo); 1456831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 146bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen void LegalizeSetCCOperands(SDValue &LHS, SDValue &RHS, SDValue &CC, 147bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl); 148bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen void LegalizeSetCCCondCode(MVT VT, SDValue &LHS, SDValue &RHS, SDValue &CC, 149bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl); 150bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen void LegalizeSetCC(MVT VT, SDValue &LHS, SDValue &RHS, SDValue &CC, 151bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl) { 152bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen LegalizeSetCCOperands(LHS, RHS, CC, dl); 153bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen LegalizeSetCCCondCode(VT, LHS, RHS, CC, dl); 1547f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng } 155fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 15647b41f7e20b6af7aaaf0e050200102d55d038b9dEli Friedman SDValue ExpandLibCall(RTLIB::Libcall LC, SDNode *Node, bool isSigned); 157f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman SDValue ExpandFPLibCall(SDNode *Node, RTLIB::Libcall Call_F32, 158f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_F64, RTLIB::Libcall Call_F80, 159f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_PPCF128); 160f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman SDValue ExpandIntLibCall(SDNode *Node, bool isSigned, RTLIB::Libcall Call_I16, 161f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_I32, RTLIB::Libcall Call_I64, 162f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_I128); 163475871a144eb604ddaf37503397ba0941442e5fbDan Gohman 1648a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen SDValue EmitStackConvert(SDValue SrcOp, MVT SlotVT, MVT DestVT, DebugLoc dl); 165475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue ExpandBUILD_VECTOR(SDNode *Node); 166475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue ExpandSCALAR_TO_VECTOR(SDNode *Node); 167af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue ExpandLegalINT_TO_FP(bool isSigned, SDValue LegalOp, MVT DestVT, 168af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl); 169af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue PromoteLegalINT_TO_FP(SDValue LegalOp, MVT DestVT, bool isSigned, 170af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl); 171af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue PromoteLegalFP_TO_INT(SDValue LegalOp, MVT DestVT, bool isSigned, 172af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl); 173475871a144eb604ddaf37503397ba0941442e5fbDan Gohman 1748a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen SDValue ExpandBSWAP(SDValue Op, DebugLoc dl); 1758a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen SDValue ExpandBitCount(unsigned Opc, SDValue Op, DebugLoc dl); 176475871a144eb604ddaf37503397ba0941442e5fbDan Gohman 1773d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman SDValue ExpandExtractFromVectorThroughStack(SDValue Op); 1788c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman 1798c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman void ExpandNode(SDNode *Node, SmallVectorImpl<SDValue> &Results); 1808c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman void PromoteNode(SDNode *Node, SmallVectorImpl<SDValue> &Results); 1813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner}; 1823e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 1833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 1845a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman/// ShuffleWithNarrowerEltType - Return a vector shuffle operation which 1855a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman/// performs the same shuffe in terms of order or result bytes, but on a type 1865a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman/// whose vector element type is narrower than the original shuffle type. 1879008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman/// e.g. <v4i32> <0, 1, 0, 1> -> v8i16 <0, 1, 2, 3, 0, 1, 2, 3> 1885a5ca1519e04310f585197c20e7ae584b7f2d11fNate BegemanSDValue 1895a5ca1519e04310f585197c20e7ae584b7f2d11fNate BegemanSelectionDAGLegalize::ShuffleWithNarrowerEltType(MVT NVT, MVT VT, DebugLoc dl, 1905a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman SDValue N1, SDValue N2, 1919008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman SmallVectorImpl<int> &Mask) const { 1929008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman MVT EltVT = NVT.getVectorElementType(); 1935a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman unsigned NumMaskElts = VT.getVectorNumElements(); 1945a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman unsigned NumDestElts = NVT.getVectorNumElements(); 1959008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman unsigned NumEltsGrowth = NumDestElts / NumMaskElts; 1969008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman 1979008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman assert(NumEltsGrowth && "Cannot promote to vector type with fewer elts!"); 1989008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman 1999008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman if (NumEltsGrowth == 1) 2009008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman return DAG.getVectorShuffle(NVT, dl, N1, N2, &Mask[0]); 2019008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman 2029008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman SmallVector<int, 8> NewMask; 2035a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman for (unsigned i = 0; i != NumMaskElts; ++i) { 2049008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman int Idx = Mask[i]; 2059008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman for (unsigned j = 0; j != NumEltsGrowth; ++j) { 2069008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman if (Idx < 0) 2079008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman NewMask.push_back(-1); 2089008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman else 2099008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman NewMask.push_back(Idx * NumEltsGrowth + j); 2104352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner } 21115684b29552393553524171bff1913e750f390f8Rafael Espindola } 2125a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman assert(NewMask.size() == NumDestElts && "Non-integer NumEltsGrowth?"); 2139008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman assert(TLI.isShuffleMaskLegal(NewMask, NVT) && "Shuffle not legal?"); 2149008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman return DAG.getVectorShuffle(NVT, dl, N1, N2, &NewMask[0]); 2154352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner} 2164352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner 2175aa4977fba97e816b5735f0bc53f16a46b24de63Bill WendlingSelectionDAGLegalize::SelectionDAGLegalize(SelectionDAG &dag, 2181fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman CodeGenOpt::Level ol) 219be8cc2a3dedeb7685f07e68cdc4b9502eb97eb2bBill Wendling : TLI(dag.getTargetLoweringInfo()), DAG(dag), OptLevel(ol), 2201fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman ValueTypeActions(TLI.getValueTypeActions()) { 2216a648614e88586e85a36ceb5c1d3b84e4f55b458Nate Begeman assert(MVT::LAST_VALUETYPE <= 32 && 2223e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner "Too many value types for ValueTypeActions to hold!"); 2233e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 2243e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattnervoid SelectionDAGLegalize::LegalizeDAG() { 2266831a815999dde4cf801e2076e66b4943964daf2Chris Lattner LastCALLSEQ_END = DAG.getEntryNode(); 2276831a815999dde4cf801e2076e66b4943964daf2Chris Lattner IsLegalizingCall = false; 228e5ab34e05d701da042619bf540046efc3c7bc41fMon P Wang 229ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // The legalize process is inherently a bottom-up recursive process (users 230ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // legalize their uses before themselves). Given infinite stack space, we 231ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // could just start legalizing on the root and traverse the whole graph. In 232ab510a76d6fed412f2dbbb29b3e123eef34f9c0aChris Lattner // practice however, this causes us to run out of stack space on large basic 23332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // blocks. To avoid this problem, compute an ordering of the nodes where each 23432fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // node is only legalized after all of its operands are legalized. 235f06c835f769aa1cf67801ed1f6bd366a447c18b1Dan Gohman DAG.AssignTopologicalOrder(); 236f06c835f769aa1cf67801ed1f6bd366a447c18b1Dan Gohman for (SelectionDAG::allnodes_iterator I = DAG.allnodes_begin(), 237f06c835f769aa1cf67801ed1f6bd366a447c18b1Dan Gohman E = prior(DAG.allnodes_end()); I != next(E); ++I) 238f06c835f769aa1cf67801ed1f6bd366a447c18b1Dan Gohman HandleOp(SDValue(I, 0)); 23932fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner 24032fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner // Finally, it's possible the root changed. Get the new root. 241475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue OldRoot = DAG.getRoot(); 24232fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner assert(LegalizedNodes.count(OldRoot) && "Root didn't get legalized?"); 24332fca00a23a9872c31999d054b4dd7c724276d9dChris Lattner DAG.setRoot(LegalizedNodes[OldRoot]); 2443e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2453e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner LegalizedNodes.clear(); 2463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Remove dead nodes now. 248190a418bf6b49a4ef1c1980229a2f0d516e8a2cdChris Lattner DAG.RemoveDeadNodes(); 2493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 2503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 2516831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 2526831a815999dde4cf801e2076e66b4943964daf2Chris Lattner/// FindCallEndFromCallStart - Given a chained node that is part of a call 2536831a815999dde4cf801e2076e66b4943964daf2Chris Lattner/// sequence, find the CALLSEQ_END node that terminates the call sequence. 2546831a815999dde4cf801e2076e66b4943964daf2Chris Lattnerstatic SDNode *FindCallEndFromCallStart(SDNode *Node) { 2556831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_END) 2566831a815999dde4cf801e2076e66b4943964daf2Chris Lattner return Node; 2576831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (Node->use_empty()) 2586831a815999dde4cf801e2076e66b4943964daf2Chris Lattner return 0; // No CallSeqEnd 259fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2606831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // The chain is usually at the end. 261475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue TheChain(Node, Node->getNumValues()-1); 2626831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (TheChain.getValueType() != MVT::Other) { 2636831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Sometimes it's at the beginning. 264475871a144eb604ddaf37503397ba0941442e5fbDan Gohman TheChain = SDValue(Node, 0); 2656831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (TheChain.getValueType() != MVT::Other) { 2666831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Otherwise, hunt for it. 2676831a815999dde4cf801e2076e66b4943964daf2Chris Lattner for (unsigned i = 1, e = Node->getNumValues(); i != e; ++i) 2686831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (Node->getValueType(i) == MVT::Other) { 269475871a144eb604ddaf37503397ba0941442e5fbDan Gohman TheChain = SDValue(Node, i); 2706831a815999dde4cf801e2076e66b4943964daf2Chris Lattner break; 2716831a815999dde4cf801e2076e66b4943964daf2Chris Lattner } 272fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 273fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // Otherwise, we walked into a node without a chain. 2746831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (TheChain.getValueType() != MVT::Other) 2756831a815999dde4cf801e2076e66b4943964daf2Chris Lattner return 0; 2766831a815999dde4cf801e2076e66b4943964daf2Chris Lattner } 2776831a815999dde4cf801e2076e66b4943964daf2Chris Lattner } 278fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2796831a815999dde4cf801e2076e66b4943964daf2Chris Lattner for (SDNode::use_iterator UI = Node->use_begin(), 2806831a815999dde4cf801e2076e66b4943964daf2Chris Lattner E = Node->use_end(); UI != E; ++UI) { 281fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2826831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Make sure to only follow users of our token chain. 2838968450305c28444edc3c272d8752a8db0c2f34aDan Gohman SDNode *User = *UI; 2846831a815999dde4cf801e2076e66b4943964daf2Chris Lattner for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i) 2856831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (User->getOperand(i) == TheChain) 2866831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (SDNode *Result = FindCallEndFromCallStart(User)) 2876831a815999dde4cf801e2076e66b4943964daf2Chris Lattner return Result; 2886831a815999dde4cf801e2076e66b4943964daf2Chris Lattner } 2896831a815999dde4cf801e2076e66b4943964daf2Chris Lattner return 0; 2906831a815999dde4cf801e2076e66b4943964daf2Chris Lattner} 2916831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 292fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel/// FindCallStartFromCallEnd - Given a chained node that is part of a call 2936831a815999dde4cf801e2076e66b4943964daf2Chris Lattner/// sequence, find the CALLSEQ_START node that initiates the call sequence. 2946831a815999dde4cf801e2076e66b4943964daf2Chris Lattnerstatic SDNode *FindCallStartFromCallEnd(SDNode *Node) { 2956831a815999dde4cf801e2076e66b4943964daf2Chris Lattner assert(Node && "Didn't find callseq_start for a call??"); 2966831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (Node->getOpcode() == ISD::CALLSEQ_START) return Node; 297fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2986831a815999dde4cf801e2076e66b4943964daf2Chris Lattner assert(Node->getOperand(0).getValueType() == MVT::Other && 2996831a815999dde4cf801e2076e66b4943964daf2Chris Lattner "Node doesn't have a token chain argument!"); 300ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return FindCallStartFromCallEnd(Node->getOperand(0).getNode()); 3016831a815999dde4cf801e2076e66b4943964daf2Chris Lattner} 3026831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 3036831a815999dde4cf801e2076e66b4943964daf2Chris Lattner/// LegalizeAllNodesNotLeadingTo - Recursively walk the uses of N, looking to 304fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel/// see if any uses can reach Dest. If no dest operands can get to dest, 3056831a815999dde4cf801e2076e66b4943964daf2Chris Lattner/// legalize them, legalize ourself, and return false, otherwise, return true. 306c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner/// 307c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner/// Keep track of the nodes we fine that actually do lead to Dest in 308c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner/// NodesLeadingTo. This avoids retraversing them exponential number of times. 309c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner/// 310c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattnerbool SelectionDAGLegalize::LegalizeAllNodesNotLeadingTo(SDNode *N, SDNode *Dest, 31100755df36c1448ac4728a74d907aa09e3d8b2d49Chris Lattner SmallPtrSet<SDNode*, 32> &NodesLeadingTo) { 3126831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (N == Dest) return true; // N certainly leads to Dest :) 313fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 314c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner // If we've already processed this node and it does lead to Dest, there is no 315c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner // need to reprocess it. 316c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner if (NodesLeadingTo.count(N)) return true; 317fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 3186831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // If the first result of this node has been already legalized, then it cannot 3196831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // reach N. 32074807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman if (LegalizedNodes.count(SDValue(N, 0))) return false; 321fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 3226831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Okay, this node has not already been legalized. Check and legalize all 3236831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // operands. If none lead to Dest, then we can legalize this node. 3246831a815999dde4cf801e2076e66b4943964daf2Chris Lattner bool OperandsLeadToDest = false; 3256831a815999dde4cf801e2076e66b4943964daf2Chris Lattner for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) 3266831a815999dde4cf801e2076e66b4943964daf2Chris Lattner OperandsLeadToDest |= // If an operand leads to Dest, so do we. 327ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif LegalizeAllNodesNotLeadingTo(N->getOperand(i).getNode(), Dest, NodesLeadingTo); 3286831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 329c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner if (OperandsLeadToDest) { 330c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner NodesLeadingTo.insert(N); 331c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner return true; 332c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner } 3336831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 3346831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Okay, this node looks safe, legalize it and return false. 335475871a144eb604ddaf37503397ba0941442e5fbDan Gohman HandleOp(SDValue(N, 0)); 3366831a815999dde4cf801e2076e66b4943964daf2Chris Lattner return false; 3376831a815999dde4cf801e2076e66b4943964daf2Chris Lattner} 3386831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 3390c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang/// HandleOp - Legalize, Promote, Widen, or Expand the specified operand as 340c7029805ef35ce9805931067b841e6af11db382eChris Lattner/// appropriate for its type. 341475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid SelectionDAGLegalize::HandleOp(SDValue Op) { 3421fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman // Don't touch TargetConstants 3431fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman if (Op.getOpcode() == ISD::TargetConstant) 3441fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman return; 34583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Op.getValueType(); 3461fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman // We should never see any illegal result types here. 3471fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman assert(isTypeLegal(VT) && "Illegal type introduced after type legalization?"); 34874807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman (void)LegalizeOp(Op); 349c7029805ef35ce9805931067b841e6af11db382eChris Lattner} 3506831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 3519f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng/// ExpandConstantFP - Expands the ConstantFP node to an integer constant or 3529f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng/// a load from the constant pool. 353475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanstatic SDValue ExpandConstantFP(ConstantFPSDNode *CFP, bool UseCP, 3540d137d7f35fba98f668098b3badf644efacf0e08Dan Gohman SelectionDAG &DAG, const TargetLowering &TLI) { 355004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng bool Extend = false; 35633c960f523f2308482d5b2816af46a7ec90a6d3dDale Johannesen DebugLoc dl = CFP->getDebugLoc(); 357004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng 358004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng // If a FP immediate is precise when represented as a float and if the 359004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng // target can do an extending load from float to double, we put it into 360004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng // the constant pool as a float, even if it's is statically typed as a 361aa2acbbbf06348f20274f4eeb77f9761c654a589Chris Lattner // double. This shrinks FP constants and canonicalizes them for targets where 362aa2acbbbf06348f20274f4eeb77f9761c654a589Chris Lattner // an FP extending load is the same cost as a normal load (such as on the x87 363aa2acbbbf06348f20274f4eeb77f9761c654a589Chris Lattner // fp stack or PPC FP unit). 36483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = CFP->getValueType(0); 3654fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman ConstantFP *LLVMC = const_cast<ConstantFP*>(CFP->getConstantFPValue()); 3669f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng if (!UseCP) { 367d2e936a513b01b2c5df91a9c0d80070e8c752aceChris Lattner assert((VT == MVT::f64 || VT == MVT::f32) && "Invalid type expansion"); 3687111b02c734c992b8c97d9918118768026dad79eDale Johannesen return DAG.getConstant(LLVMC->getValueAPF().bitcastToAPInt(), 369ef12057737229452c17983faa20857dba441ef05Evan Cheng (VT == MVT::f64) ? MVT::i64 : MVT::i32); 370279101eb1ac61e2d5b83d5bdcc5be56e710d2cd7Evan Cheng } 371279101eb1ac61e2d5b83d5bdcc5be56e710d2cd7Evan Cheng 37283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT OrigVT = VT; 37383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT SVT = VT; 374ef12057737229452c17983faa20857dba441ef05Evan Cheng while (SVT != MVT::f32) { 37583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands SVT = (MVT::SimpleValueType)(SVT.getSimpleVT() - 1); 376ef12057737229452c17983faa20857dba441ef05Evan Cheng if (CFP->isValueValidForType(SVT, CFP->getValueAPF()) && 377ef12057737229452c17983faa20857dba441ef05Evan Cheng // Only do this if the target has a native EXTLOAD instruction from 378ef12057737229452c17983faa20857dba441ef05Evan Cheng // smaller type. 3790329466b6b4927f4e6f5d144891fef06a027fec5Evan Cheng TLI.isLoadExtLegal(ISD::EXTLOAD, SVT) && 380aa2acbbbf06348f20274f4eeb77f9761c654a589Chris Lattner TLI.ShouldShrinkFPConstant(OrigVT)) { 38183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands const Type *SType = SVT.getTypeForMVT(); 382ef12057737229452c17983faa20857dba441ef05Evan Cheng LLVMC = cast<ConstantFP>(ConstantExpr::getFPTrunc(LLVMC, SType)); 383ef12057737229452c17983faa20857dba441ef05Evan Cheng VT = SVT; 384ef12057737229452c17983faa20857dba441ef05Evan Cheng Extend = true; 385ef12057737229452c17983faa20857dba441ef05Evan Cheng } 386004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng } 387004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng 388475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue CPIdx = DAG.getConstantPool(LLVMC, TLI.getPointerTy()); 3891606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned Alignment = cast<ConstantPoolSDNode>(CPIdx)->getAlignment(); 390ef12057737229452c17983faa20857dba441ef05Evan Cheng if (Extend) 39133c960f523f2308482d5b2816af46a7ec90a6d3dDale Johannesen return DAG.getExtLoad(ISD::EXTLOAD, dl, 39239355f9fea790c5a1b12ef0fdcfeac3f533232eaDale Johannesen OrigVT, DAG.getEntryNode(), 3933069b8743769527ce7af6cfb6591a2f0fc2faee4Dan Gohman CPIdx, PseudoSourceValue::getConstantPool(), 39450284d81f863a6576582e1a171a22eb0f012ddf3Dan Gohman 0, VT, false, Alignment); 39533c960f523f2308482d5b2816af46a7ec90a6d3dDale Johannesen return DAG.getLoad(OrigVT, dl, DAG.getEntryNode(), CPIdx, 39650284d81f863a6576582e1a171a22eb0f012ddf3Dan Gohman PseudoSourceValue::getConstantPool(), 0, false, Alignment); 397004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng} 398004952140f3cf92ee098c2c5b8cdee1449bdc2edEvan Cheng 399f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio/// ExpandUnalignedStore - Expands an unaligned store to 2 half-size stores. 400f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venanciostatic 401475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue ExpandUnalignedStore(StoreSDNode *ST, SelectionDAG &DAG, 4020d137d7f35fba98f668098b3badf644efacf0e08Dan Gohman const TargetLowering &TLI) { 403475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Chain = ST->getChain(); 404475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ptr = ST->getBasePtr(); 405475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Val = ST->getValue(); 40683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Val.getValueType(); 407907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen int Alignment = ST->getAlignment(); 408907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen int SVOffset = ST->getSrcValueOffset(); 409bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl = ST->getDebugLoc(); 41083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (ST->getMemoryVT().isFloatingPoint() || 41183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands ST->getMemoryVT().isVector()) { 41205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands MVT intVT = MVT::getIntegerVT(VT.getSizeInBits()); 41305e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands if (TLI.isTypeLegal(intVT)) { 41405e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Expand to a bitconvert of the value to the integer type of the 41505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // same size, then a (misaligned) int store. 41605e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // FIXME: Does not handle truncating floating point stores! 417bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Result = DAG.getNode(ISD::BIT_CONVERT, dl, intVT, Val); 418bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen return DAG.getStore(Chain, dl, Result, Ptr, ST->getSrcValue(), 41905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SVOffset, ST->isVolatile(), Alignment); 42005e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands } else { 42105e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Do a (aligned) store to a stack slot, then copy from the stack slot 42205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // to the final destination using (unaligned) integer loads and stores. 42305e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands MVT StoredVT = ST->getMemoryVT(); 42405e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands MVT RegVT = 42505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands TLI.getRegisterType(MVT::getIntegerVT(StoredVT.getSizeInBits())); 42605e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands unsigned StoredBytes = StoredVT.getSizeInBits() / 8; 42705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands unsigned RegBytes = RegVT.getSizeInBits() / 8; 42805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands unsigned NumRegs = (StoredBytes + RegBytes - 1) / RegBytes; 42905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 430fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands // Make sure the stack slot is also aligned for the register type. 431fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands SDValue StackPtr = DAG.CreateStackTemporary(StoredVT, RegVT); 432fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands 433fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands // Perform the original store, only redirected to the stack slot. 434fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel SDValue Store = DAG.getTruncStore(Chain, dl, 435ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson Val, StackPtr, NULL, 0, StoredVT); 43605e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SDValue Increment = DAG.getConstant(RegBytes, TLI.getPointerTy()); 43705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SmallVector<SDValue, 8> Stores; 43805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands unsigned Offset = 0; 43905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 44005e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Do all but one copies using the full register width. 44105e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands for (unsigned i = 1; i < NumRegs; i++) { 44205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Load one integer register's worth from the stack slot. 443bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Load = DAG.getLoad(RegVT, dl, Store, StackPtr, NULL, 0); 44405e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Store it to the final location. Remember the store. 445bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Stores.push_back(DAG.getStore(Load.getValue(1), dl, Load, Ptr, 44605e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands ST->getSrcValue(), SVOffset + Offset, 44705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands ST->isVolatile(), 44805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands MinAlign(ST->getAlignment(), Offset))); 44905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Increment the pointers. 45005e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands Offset += RegBytes; 451bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr, 45205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands Increment); 453bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment); 45405e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands } 45505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 456fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands // The last store may be partial. Do a truncating store. On big-endian 457fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands // machines this requires an extending load from the stack slot to ensure 458fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands // that the bits are in the right place. 459fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands MVT MemVT = MVT::getIntegerVT(8 * (StoredBytes - Offset)); 460fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands 461fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands // Load from the stack slot. 462bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, RegVT, Store, StackPtr, 463fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands NULL, 0, MemVT); 46405e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 465bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Stores.push_back(DAG.getTruncStore(Load.getValue(1), dl, Load, Ptr, 46605e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands ST->getSrcValue(), SVOffset + Offset, 467fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands MemVT, ST->isVolatile(), 46805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands MinAlign(ST->getAlignment(), Offset))); 46905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // The order of the stores doesn't matter - say it with a TokenFactor. 470bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &Stores[0], 47105e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands Stores.size()); 47205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands } 473907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen } 47483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(ST->getMemoryVT().isInteger() && 47583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands !ST->getMemoryVT().isVector() && 476907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen "Unaligned store of unknown type."); 477f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // Get the half-size VT 47883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NewStoredVT = 47983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands (MVT::SimpleValueType)(ST->getMemoryVT().getSimpleVT() - 1); 48083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands int NumBits = NewStoredVT.getSizeInBits(); 481f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio int IncrementSize = NumBits / 8; 482f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 483f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // Divide the stored value in two parts. 484475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue ShiftAmount = DAG.getConstant(NumBits, TLI.getShiftAmountTy()); 485475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Lo = Val; 486bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Hi = DAG.getNode(ISD::SRL, dl, VT, Val, ShiftAmount); 487f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 488f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // Store the two parts 489475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Store1, Store2; 490bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Store1 = DAG.getTruncStore(Chain, dl, TLI.isLittleEndian()?Lo:Hi, Ptr, 491f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio ST->getSrcValue(), SVOffset, NewStoredVT, 492f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio ST->isVolatile(), Alignment); 493bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, 494f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio DAG.getConstant(IncrementSize, TLI.getPointerTy())); 495dc84650679b6330e0fcdd4cf8bc2a351387db7caDuncan Sands Alignment = MinAlign(Alignment, IncrementSize); 496bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Store2 = DAG.getTruncStore(Chain, dl, TLI.isLittleEndian()?Hi:Lo, Ptr, 497f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio ST->getSrcValue(), SVOffset + IncrementSize, 498f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio NewStoredVT, ST->isVolatile(), Alignment); 499f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 500bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Store1, Store2); 501f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio} 502f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 503f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio/// ExpandUnalignedLoad - Expands an unaligned load to 2 half-size loads. 504f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venanciostatic 505475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue ExpandUnalignedLoad(LoadSDNode *LD, SelectionDAG &DAG, 506e9530ecae4897fe8157bd4d7616043bd8c0484e2Dan Gohman const TargetLowering &TLI) { 507f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio int SVOffset = LD->getSrcValueOffset(); 508475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Chain = LD->getChain(); 509475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ptr = LD->getBasePtr(); 51083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = LD->getValueType(0); 51183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT LoadedVT = LD->getMemoryVT(); 512bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl = LD->getDebugLoc(); 51383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (VT.isFloatingPoint() || VT.isVector()) { 51405e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands MVT intVT = MVT::getIntegerVT(LoadedVT.getSizeInBits()); 51505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands if (TLI.isTypeLegal(intVT)) { 51605e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Expand to a (misaligned) integer load of the same size, 51705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // then bitconvert to floating point or vector. 518bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue newLoad = DAG.getLoad(intVT, dl, Chain, Ptr, LD->getSrcValue(), 51905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SVOffset, LD->isVolatile(), 520907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen LD->getAlignment()); 521bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Result = DAG.getNode(ISD::BIT_CONVERT, dl, LoadedVT, newLoad); 52205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands if (VT.isFloatingPoint() && LoadedVT != VT) 523bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Result = DAG.getNode(ISD::FP_EXTEND, dl, VT, Result); 524907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen 52505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SDValue Ops[] = { Result, Chain }; 526bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen return DAG.getMergeValues(Ops, 2, dl); 52705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands } else { 52805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Copy the value to a (aligned) stack slot using (unaligned) integer 52905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // loads and stores, then do a (aligned) load from the stack slot. 53005e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands MVT RegVT = TLI.getRegisterType(intVT); 53105e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands unsigned LoadedBytes = LoadedVT.getSizeInBits() / 8; 53205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands unsigned RegBytes = RegVT.getSizeInBits() / 8; 53305e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands unsigned NumRegs = (LoadedBytes + RegBytes - 1) / RegBytes; 53405e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 535fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands // Make sure the stack slot is also aligned for the register type. 536fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands SDValue StackBase = DAG.CreateStackTemporary(LoadedVT, RegVT); 537fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands 53805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SDValue Increment = DAG.getConstant(RegBytes, TLI.getPointerTy()); 53905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SmallVector<SDValue, 8> Stores; 54005e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SDValue StackPtr = StackBase; 54105e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands unsigned Offset = 0; 54205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 54305e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Do all but one copies using the full register width. 54405e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands for (unsigned i = 1; i < NumRegs; i++) { 54505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Load one integer register's worth from the original location. 546bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Load = DAG.getLoad(RegVT, dl, Chain, Ptr, LD->getSrcValue(), 54705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SVOffset + Offset, LD->isVolatile(), 54805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands MinAlign(LD->getAlignment(), Offset)); 54905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Follow the load with a store to the stack slot. Remember the store. 550bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Stores.push_back(DAG.getStore(Load.getValue(1), dl, Load, StackPtr, 55105e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands NULL, 0)); 55205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Increment the pointers. 55305e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands Offset += RegBytes; 554bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment); 555bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr, 55605e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands Increment); 55705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands } 55805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 55905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // The last copy may be partial. Do an extending load. 560fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands MVT MemVT = MVT::getIntegerVT(8 * (LoadedBytes - Offset)); 561bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, RegVT, Chain, Ptr, 56205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands LD->getSrcValue(), SVOffset + Offset, 563fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands MemVT, LD->isVolatile(), 56405e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands MinAlign(LD->getAlignment(), Offset)); 56505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Follow the load with a store to the stack slot. Remember the store. 566fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands // On big-endian machines this requires a truncating store to ensure 567fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands // that the bits end up in the right place. 568bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Stores.push_back(DAG.getTruncStore(Load.getValue(1), dl, Load, StackPtr, 569fd6673cf7fd5c0c1e6817e5fcf460a289712ee57Duncan Sands NULL, 0, MemVT)); 57005e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 57105e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // The order of the stores doesn't matter - say it with a TokenFactor. 572bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &Stores[0], 57305e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands Stores.size()); 57405e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 57505e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Finally, perform the original load only redirected to the stack slot. 576bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Load = DAG.getExtLoad(LD->getExtensionType(), dl, VT, TF, StackBase, 57705e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands NULL, 0, LoadedVT); 57805e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands 57905e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands // Callers expect a MERGE_VALUES node. 58005e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands SDValue Ops[] = { Load, TF }; 581bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen return DAG.getMergeValues(Ops, 2, dl); 58205e11fab87102a230551327bfc8434ffad7a88d4Duncan Sands } 583907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen } 58483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(LoadedVT.isInteger() && !LoadedVT.isVector() && 585e400af83b3f8b69407a8963f1d2e2c82fa766f33Chris Lattner "Unaligned load of unsupported type."); 586e400af83b3f8b69407a8963f1d2e2c82fa766f33Chris Lattner 5878155d64c2ffab8b17e0fd8e3b7a66fcef6a8ec9dDale Johannesen // Compute the new VT that is half the size of the old one. This is an 5888155d64c2ffab8b17e0fd8e3b7a66fcef6a8ec9dDale Johannesen // integer MVT. 58983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned NumBits = LoadedVT.getSizeInBits(); 59083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NewLoadedVT; 59183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands NewLoadedVT = MVT::getIntegerVT(NumBits/2); 592e400af83b3f8b69407a8963f1d2e2c82fa766f33Chris Lattner NumBits >>= 1; 593fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 594e400af83b3f8b69407a8963f1d2e2c82fa766f33Chris Lattner unsigned Alignment = LD->getAlignment(); 595e400af83b3f8b69407a8963f1d2e2c82fa766f33Chris Lattner unsigned IncrementSize = NumBits / 8; 596f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio ISD::LoadExtType HiExtType = LD->getExtensionType(); 597f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 598f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // If the original load is NON_EXTLOAD, the hi part load must be ZEXTLOAD. 599f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio if (HiExtType == ISD::NON_EXTLOAD) 600f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio HiExtType = ISD::ZEXTLOAD; 601f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 602f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // Load the value in two parts 603475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Lo, Hi; 604f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio if (TLI.isLittleEndian()) { 605bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, VT, Chain, Ptr, LD->getSrcValue(), 606f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio SVOffset, NewLoadedVT, LD->isVolatile(), Alignment); 607bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, 608f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio DAG.getConstant(IncrementSize, TLI.getPointerTy())); 609bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Hi = DAG.getExtLoad(HiExtType, dl, VT, Chain, Ptr, LD->getSrcValue(), 610f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio SVOffset + IncrementSize, NewLoadedVT, LD->isVolatile(), 611dc84650679b6330e0fcdd4cf8bc2a351387db7caDuncan Sands MinAlign(Alignment, IncrementSize)); 612f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } else { 613bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Hi = DAG.getExtLoad(HiExtType, dl, VT, Chain, Ptr, LD->getSrcValue(), 614ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson SVOffset, NewLoadedVT, LD->isVolatile(), Alignment); 615bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, 616f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio DAG.getConstant(IncrementSize, TLI.getPointerTy())); 617bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, VT, Chain, Ptr, LD->getSrcValue(), 618f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio SVOffset + IncrementSize, NewLoadedVT, LD->isVolatile(), 619dc84650679b6330e0fcdd4cf8bc2a351387db7caDuncan Sands MinAlign(Alignment, IncrementSize)); 620f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 621f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 622f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // aggregate the two parts 623475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue ShiftAmount = DAG.getConstant(NumBits, TLI.getShiftAmountTy()); 624bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Result = DAG.getNode(ISD::SHL, dl, VT, Hi, ShiftAmount); 625bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Result = DAG.getNode(ISD::OR, dl, VT, Result, Lo); 626f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 627bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1), 628f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio Hi.getValue(1)); 629f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio 630475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Result, TF }; 631bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen return DAG.getMergeValues(Ops, 2, dl); 632f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio} 633912095becac923ff614d7b07728eb345ada67765Evan Cheng 6346867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman/// PerformInsertVectorEltInMemory - Some target cannot handle a variable 6356867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman/// insertion index for the INSERT_VECTOR_ELT instruction. In this case, it 6366867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman/// is necessary to spill the vector being inserted into to memory, perform 6376867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman/// the insert there, and then read the result back. 638475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize:: 639bb5da918545efb54857a09c983a5a7f22a7e04d4Dale JohannesenPerformInsertVectorEltInMemory(SDValue Vec, SDValue Val, SDValue Idx, 640bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl) { 641475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp1 = Vec; 642475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp2 = Val; 643475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp3 = Idx; 644fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 6456867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // If the target doesn't support this, we have to spill the input vector 6466867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // to a temporary stack slot, update the element, then reload it. This is 6476867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // badness. We could also load the value into a vector register (either 6486867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // with a "move to register" or "extload into register" instruction, then 6496867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // permute it into place, if the idx is a constant and if the idx is 6506867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // supported by the target. 65183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Tmp1.getValueType(); 65283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT EltVT = VT.getVectorElementType(); 65383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT IdxVT = Tmp3.getValueType(); 65483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT PtrVT = TLI.getPointerTy(); 655475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue StackPtr = DAG.CreateStackTemporary(VT); 6566867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman 657ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex(); 6586867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman 6596867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // Store the vector. 660bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, Tmp1, StackPtr, 6610c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang PseudoSourceValue::getFixedStack(SPFI), 0); 6626867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman 6636867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // Truncate or zero extend offset to target pointer type. 6648e4eb09b1e3571965f49edcdfb56b1375b1b7551Duncan Sands unsigned CastOpc = IdxVT.bitsGT(PtrVT) ? ISD::TRUNCATE : ISD::ZERO_EXTEND; 665bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Tmp3 = DAG.getNode(CastOpc, dl, PtrVT, Tmp3); 6666867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // Add the offset to the index. 66783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned EltSize = EltVT.getSizeInBits()/8; 668bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Tmp3 = DAG.getNode(ISD::MUL, dl, IdxVT, Tmp3,DAG.getConstant(EltSize, IdxVT)); 669bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue StackPtr2 = DAG.getNode(ISD::ADD, dl, IdxVT, Tmp3, StackPtr); 6706867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // Store the scalar value. 671bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Ch = DAG.getTruncStore(Ch, dl, Tmp2, StackPtr2, 672a54cf176613f9ae8301519a61b8935652c0fb8aeDan Gohman PseudoSourceValue::getFixedStack(SPFI), 0, EltVT); 6736867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman // Load the updated vector. 674bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen return DAG.getLoad(VT, dl, Ch, StackPtr, 675a54cf176613f9ae8301519a61b8935652c0fb8aeDan Gohman PseudoSourceValue::getFixedStack(SPFI), 0); 6766867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman} 6776867991d541d08ca95d86841eca5f7c1d5096864Nate Begeman 678e9f1015d1f184a51aaadfd03be0846bd5e7d08a2Mon P Wang 6793f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli FriedmanSDValue SelectionDAGLegalize:: 6803f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli FriedmanExpandINSERT_VECTOR_ELT(SDValue Vec, SDValue Val, SDValue Idx, DebugLoc dl) { 6813f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman if (ConstantSDNode *InsertPos = dyn_cast<ConstantSDNode>(Idx)) { 6823f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // SCALAR_TO_VECTOR requires that the type of the value being inserted 6833f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // match the element type of the vector being created, except for 6843f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // integers in which case the inserted value can be over width. 6853f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman MVT EltVT = Vec.getValueType().getVectorElementType(); 6863f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman if (Val.getValueType() == EltVT || 6873f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman (EltVT.isInteger() && Val.getValueType().bitsGE(EltVT))) { 6883f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman SDValue ScVec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, 6893f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman Vec.getValueType(), Val); 6903f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman 6913f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman unsigned NumElts = Vec.getValueType().getVectorNumElements(); 6923f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // We generate a shuffle of InVec and ScVec, so the shuffle mask 6933f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // should be 0,1,2,3,4,5... with the appropriate element replaced with 6943f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // elt 0 of the RHS. 6953f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman SmallVector<int, 8> ShufOps; 6963f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman for (unsigned i = 0; i != NumElts; ++i) 6973f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman ShufOps.push_back(i != InsertPos->getZExtValue() ? i : NumElts); 6983f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman 6993f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman return DAG.getVectorShuffle(Vec.getValueType(), dl, Vec, ScVec, 7003f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman &ShufOps[0]); 7013f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman } 7023f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman } 7033f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman return PerformInsertVectorEltInMemory(Vec, Val, Idx, dl); 7043f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman} 7053f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman 706a346615d11f0a560c6e7280c1e614301d9f93051Dan Gohman/// LegalizeOp - We know that the specified value has a legal type, and 707a346615d11f0a560c6e7280c1e614301d9f93051Dan Gohman/// that its operands are legal. Now ensure that the operation itself 708a346615d11f0a560c6e7280c1e614301d9f93051Dan Gohman/// is legal, recursively ensuring that the operands' operations remain 709a346615d11f0a560c6e7280c1e614301d9f93051Dan Gohman/// legal. 710475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::LegalizeOp(SDValue Op) { 71109ec1b058331aadb29a348091611d23892b5c492Chris Lattner if (Op.getOpcode() == ISD::TargetConstant) // Allow illegal target nodes. 71209ec1b058331aadb29a348091611d23892b5c492Chris Lattner return Op; 713fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 714ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif SDNode *Node = Op.getNode(); 7157d2ad624fa749a6d3edac0d94e9c107989c16304Dale Johannesen DebugLoc dl = Node->getDebugLoc(); 716e3304a3d24afc952d3cb415d1b504d973573c5c5Chris Lattner 7171fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 7181fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman assert(getTypeAction(Node->getValueType(i)) == Legal && 7191fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman "Unexpected illegal type!"); 7201fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman 7211fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) 7221fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman assert((isTypeLegal(Node->getOperand(i).getValueType()) || 7231fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman Node->getOperand(i).getOpcode() == ISD::TargetConstant) && 7241fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman "Unexpected illegal type!"); 7253e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 72645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 72745982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 728475871a144eb604ddaf37503397ba0941442e5fbDan Gohman DenseMap<SDValue, SDValue>::iterator I = LegalizedNodes.find(Op); 729e1bd822ddb0099406d9f280535461033dfeeb190Chris Lattner if (I != LegalizedNodes.end()) return I->second; 7303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 731475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp1, Tmp2, Tmp3, Tmp4; 732475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Result = Op; 733456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner bool isCustom = false; 734fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 7358c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // Figure out the correct action; the way to query this varies by opcode 7368c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman TargetLowering::LegalizeAction Action; 7378c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman bool SimpleFinishLegalizing = true; 7383e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner switch (Node->getOpcode()) { 7398c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::INTRINSIC_W_CHAIN: 7408c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::INTRINSIC_WO_CHAIN: 7418c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::INTRINSIC_VOID: 7428c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::VAARG: 7438c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::STACKSAVE: 7448c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Action = TLI.getOperationAction(Node->getOpcode(), MVT::Other); 7458c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 7468c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SINT_TO_FP: 7478c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::UINT_TO_FP: 7488c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::EXTRACT_VECTOR_ELT: 7498c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Action = TLI.getOperationAction(Node->getOpcode(), 7508c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOperand(0).getValueType()); 7518c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 7528c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FP_ROUND_INREG: 7538c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SIGN_EXTEND_INREG: { 7548c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman MVT InnerType = cast<VTSDNode>(Node->getOperand(1))->getVT(); 7558c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Action = TLI.getOperationAction(Node->getOpcode(), InnerType); 7568c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 7578c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 7588c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::LOAD: 7598c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::STORE: 7608c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::BR_CC: 7618c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FORMAL_ARGUMENTS: 7628c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::CALL: 7638c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::CALLSEQ_START: 7648c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::CALLSEQ_END: 7658c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SELECT_CC: 7668c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SETCC: 7678c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // These instructions have properties that aren't modeled in the 7688c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // generic codepath 7698c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman SimpleFinishLegalizing = false; 7708c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 7718c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::EXTRACT_ELEMENT: 7728c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FLT_ROUNDS_: 7738c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SADDO: 7748c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SSUBO: 7758c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::UADDO: 7768c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::USUBO: 7778c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SMULO: 7788c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::UMULO: 7798c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FPOWI: 7808c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::MERGE_VALUES: 7818c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::EH_RETURN: 7828c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FRAME_TO_ARGS_OFFSET: 783f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman // These operations lie about being legal: when they claim to be legal, 784f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman // they should actually be expanded. 7858c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Action = TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0)); 7868c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (Action == TargetLowering::Legal) 7878c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Action = TargetLowering::Expand; 7888c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 7898c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::TRAMPOLINE: 7908c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FRAMEADDR: 7918c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::RETURNADDR: 792f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman // These operations lie about being legal: they must always be 793f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman // custom-lowered. 7948c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Action = TargetLowering::Custom; 7958c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 7968c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::BUILD_VECTOR: 7978c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // A weird case: when a BUILD_VECTOR is custom-lowered, it doesn't legalize 7988c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // its operands first! 7998c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman SimpleFinishLegalizing = false; 800948c1b1cda280c6428dbeaa03a6c2c559dbb93f4Chris Lattner break; 8013e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner default: 802d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner if (Node->getOpcode() >= ISD::BUILTIN_OP_END) { 8038c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Action = TargetLowering::Legal; 8048c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } else { 8058c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Action = TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0)); 8068c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 8078c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 8088c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 809d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner 8108c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (SimpleFinishLegalizing) { 8118c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman SmallVector<SDValue, 8> Ops, ResultVals; 8128c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) 8138c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Ops.push_back(LegalizeOp(Node->getOperand(i))); 8148c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman switch (Node->getOpcode()) { 8158c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman default: break; 8168c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::BR: 8178c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::BRIND: 8188c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::BR_JT: 8198c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::BR_CC: 8208c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::BRCOND: 8218c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::RET: 8228c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // Branches tweak the chain to include LastCALLSEQ_END 8238c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Ops[0] = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Ops[0], 8248c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman LastCALLSEQ_END); 8258c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Ops[0] = LegalizeOp(Ops[0]); 8268c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman LastCALLSEQ_END = DAG.getEntryNode(); 8278c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 8288c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SHL: 8298c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SRL: 8308c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SRA: 8318c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::ROTL: 8328c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::ROTR: 8338c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // Legalizing shifts/rotates requires adjusting the shift amount 8348c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // to the appropriate width. 8358c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (!Ops[1].getValueType().isVector()) 8368c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Ops[1] = LegalizeOp(DAG.getShiftAmountOperand(Ops[1])); 8378c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 8388c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 8398c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman 8408c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Result = DAG.UpdateNodeOperands(Result.getValue(0), Ops.data(), 8418c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Ops.size()); 8428c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman switch (Action) { 8438c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case TargetLowering::Legal: 844d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 8458c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman ResultVals.push_back(Result.getValue(i)); 8468c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 8478c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case TargetLowering::Custom: 8488c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // FIXME: The handling for custom lowering with multiple results is 8498c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // a complete mess. 8508c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = TLI.LowerOperation(Result, DAG); 8518c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (Tmp1.getNode()) { 8528c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) { 8538c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (e == 1) 8548c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman ResultVals.push_back(Tmp1); 8558c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman else 8568c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman ResultVals.push_back(Tmp1.getValue(i)); 8578c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 8588c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 8598c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 8608c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman 8618c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // FALL THROUGH 8628c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case TargetLowering::Expand: 8638c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman ExpandNode(Result.getNode(), ResultVals); 8648c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 8658c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case TargetLowering::Promote: 8668c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman PromoteNode(Result.getNode(), ResultVals); 8678c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 8688c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 8698c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (!ResultVals.empty()) { 8708c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman for (unsigned i = 0, e = ResultVals.size(); i != e; ++i) { 8718c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (ResultVals[i] != SDValue(Node, i)) 8728c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman ResultVals[i] = LegalizeOp(ResultVals[i]); 8738c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman AddLegalizedOperand(SDValue(Node, i), ResultVals[i]); 8748c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 8758c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman return ResultVals[Op.getResNo()]; 876d73cc5d0585e86bf6d350ab9fd9caf85bdfc8b52Chris Lattner } 8778c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 8788c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman 8798c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman switch (Node->getOpcode()) { 8808c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman default: 881e37fe9b3a1cadceb42ac27fa0718f5a10ea2f0e6Jim Laskey#ifndef NDEBUG 88239833585556a69de12053ca1e104fe7edfd86cbdDan Gohman cerr << "NODE: "; Node->dump(&DAG); cerr << "\n"; 883e37fe9b3a1cadceb42ac27fa0718f5a10ea2f0e6Jim Laskey#endif 8843e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner assert(0 && "Do not know how to legalize this operator!"); 8853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner abort(); 8867f460203b0c5350e9b2c592f438e40f7a7de6e45Dan Gohman case ISD::DBG_STOPPOINT: 8877f460203b0c5350e9b2c592f438e40f7a7de6e45Dan Gohman assert(Node->getNumOperands() == 1 && "Invalid DBG_STOPPOINT node!"); 88836ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the input chain. 889fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 8907f460203b0c5350e9b2c592f438e40f7a7de6e45Dan Gohman switch (TLI.getOperationAction(ISD::DBG_STOPPOINT, MVT::Other)) { 89136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner case TargetLowering::Promote: 89236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner default: assert(0 && "This action is not supported yet!"); 89392c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling case TargetLowering::Expand: { 89492c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling DwarfWriter *DW = DAG.getDwarfWriter(); 89592c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling bool useDEBUG_LOC = TLI.isOperationLegalOrCustom(ISD::DEBUG_LOC, 89692c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling MVT::Other); 89792c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling bool useLABEL = TLI.isOperationLegalOrCustom(ISD::DBG_LABEL, MVT::Other); 898fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 89992c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling const DbgStopPointSDNode *DSP = cast<DbgStopPointSDNode>(Node); 90092c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling GlobalVariable *CU_GV = cast<GlobalVariable>(DSP->getCompileUnit()); 90192c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling if (DW && (useDEBUG_LOC || useLABEL) && !CU_GV->isDeclaration()) { 90292c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling DICompileUnit CU(cast<GlobalVariable>(DSP->getCompileUnit())); 903fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 90492c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling unsigned Line = DSP->getLine(); 90592c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling unsigned Col = DSP->getColumn(); 90686e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling 90798a366d547772010e94609e4584489b3e5ce0043Bill Wendling if (OptLevel == CodeGenOpt::None) { 90886e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling // A bit self-referential to have DebugLoc on Debug_Loc nodes, but it 90986e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling // won't hurt anything. 91086e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling if (useDEBUG_LOC) { 91186e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling SDValue Ops[] = { Tmp1, DAG.getConstant(Line, MVT::i32), 91292c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling DAG.getConstant(Col, MVT::i32), 913a26eae64ddf607549f9e47046d46ea5b9ec648b4Argyrios Kyrtzidis DAG.getSrcValue(CU.getGV()) }; 91486e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling Result = DAG.getNode(ISD::DEBUG_LOC, dl, MVT::Other, Ops, 4); 91586e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling } else { 916a26eae64ddf607549f9e47046d46ea5b9ec648b4Argyrios Kyrtzidis unsigned ID = DW->RecordSourceLine(Line, Col, CU); 91786e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling Result = DAG.getLabel(ISD::DBG_LABEL, dl, Tmp1, ID); 91886e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling } 91992c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } else { 92086e6cb924b85e7a288a4d8bfde5d1a8fb9810c88Bill Wendling Result = Tmp1; // chain 92192c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 92292c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } else { 92392c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling Result = Tmp1; // chain 92492c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 92536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner break; 92692c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 9275274a4afb720858bf1ab927fc90068f1a8f12eb2Sanjiv Gupta case TargetLowering::Custom: 9285274a4afb720858bf1ab927fc90068f1a8f12eb2Sanjiv Gupta Result = TLI.LowerOperation(Op, DAG); 929ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson if (Result.getNode()) 9305274a4afb720858bf1ab927fc90068f1a8f12eb2Sanjiv Gupta break; 93171e8685633e7938ee752004cceedccbd0d850527Evan Cheng case TargetLowering::Legal: { 93274807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman if (Tmp1 == Node->getOperand(0)) 93371e8685633e7938ee752004cceedccbd0d850527Evan Cheng break; 93471e8685633e7938ee752004cceedccbd0d850527Evan Cheng 935475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 8> Ops; 93671e8685633e7938ee752004cceedccbd0d850527Evan Cheng Ops.push_back(Tmp1); 93774807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman Ops.push_back(Node->getOperand(1)); // line # must be legal. 93874807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman Ops.push_back(Node->getOperand(2)); // col # must be legal. 93971e8685633e7938ee752004cceedccbd0d850527Evan Cheng Ops.push_back(Node->getOperand(3)); // filename must be legal. 94071e8685633e7938ee752004cceedccbd0d850527Evan Cheng Ops.push_back(Node->getOperand(4)); // working dir # must be legal. 94171e8685633e7938ee752004cceedccbd0d850527Evan Cheng Result = DAG.UpdateNodeOperands(Result, &Ops[0], Ops.size()); 94236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner break; 94336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 94471e8685633e7938ee752004cceedccbd0d850527Evan Cheng } 94536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner break; 9463e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::ConstantFP: { 9473e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // Spill FP immediates to the constant pool if the target cannot directly 9483e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // codegen them. Targets often have some immediate values that can be 9493e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // efficiently generated into an FP register without a load. We explicitly 9503e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner // leave these constants as ConstantFP nodes for the target to deal with. 9513e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner ConstantFPSDNode *CFP = cast<ConstantFPSDNode>(Node); 9523e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 9533181a771ff5b2090b7ed55f9b18a684ea8fe625aChris Lattner switch (TLI.getOperationAction(ISD::ConstantFP, CFP->getValueType(0))) { 9543181a771ff5b2090b7ed55f9b18a684ea8fe625aChris Lattner default: assert(0 && "This action is not supported yet!"); 955e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman case TargetLowering::Legal: 956e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman break; 9573181a771ff5b2090b7ed55f9b18a684ea8fe625aChris Lattner case TargetLowering::Custom: 9583181a771ff5b2090b7ed55f9b18a684ea8fe625aChris Lattner Tmp3 = TLI.LowerOperation(Result, DAG); 959ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp3.getNode()) { 9603181a771ff5b2090b7ed55f9b18a684ea8fe625aChris Lattner Result = Tmp3; 9613181a771ff5b2090b7ed55f9b18a684ea8fe625aChris Lattner break; 9623181a771ff5b2090b7ed55f9b18a684ea8fe625aChris Lattner } 9633181a771ff5b2090b7ed55f9b18a684ea8fe625aChris Lattner // FALLTHROUGH 964e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman case TargetLowering::Expand: { 965e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman // Check to see if this FP immediate is already legal. 966e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman bool isLegal = false; 967e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman for (TargetLowering::legal_fpimm_iterator I = TLI.legal_fpimm_begin(), 968e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman E = TLI.legal_fpimm_end(); I != E; ++I) { 969e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman if (CFP->isExactlyValue(*I)) { 970e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman isLegal = true; 971e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman break; 972e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman } 973e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman } 974e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman // If this is a legal constant, turn it into a TargetConstantFP node. 975e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman if (isLegal) 976e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman break; 977279101eb1ac61e2d5b83d5bdcc5be56e710d2cd7Evan Cheng Result = ExpandConstantFP(CFP, true, DAG, TLI); 9783e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 979e179584f9b740cf3a36bde70f8cab40de59b8081Nate Begeman } 9803e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 9813e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 982fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case ISD::FORMAL_ARGUMENTS: 983f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case ISD::CALL: 984fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // The only option for this is to custom lower it. 985b248e16afd105fd8c01e08d8bf997b08ff08d127Chris Lattner Tmp3 = TLI.LowerOperation(Result.getValue(0), DAG); 986ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif assert(Tmp3.getNode() && "Target didn't custom lower this node!"); 9870ea0356dff38dfd0420b8c0a2fdf2fae7898c024Dale Johannesen // A call within a calling sequence must be legalized to something 9880ea0356dff38dfd0420b8c0a2fdf2fae7898c024Dale Johannesen // other than the normal CALLSEQ_END. Violating this gets Legalize 9890ea0356dff38dfd0420b8c0a2fdf2fae7898c024Dale Johannesen // into an infinite loop. 9900ea0356dff38dfd0420b8c0a2fdf2fae7898c024Dale Johannesen assert ((!IsLegalizingCall || 9910ea0356dff38dfd0420b8c0a2fdf2fae7898c024Dale Johannesen Node->getOpcode() != ISD::CALL || 992ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Tmp3.getNode()->getOpcode() != ISD::CALLSEQ_END) && 9930ea0356dff38dfd0420b8c0a2fdf2fae7898c024Dale Johannesen "Nested CALLSEQ_START..CALLSEQ_END not supported."); 9940f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling 9950f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling // The number of incoming and outgoing values should match; unless the final 9960f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling // outgoing value is a flag. 997ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif assert((Tmp3.getNode()->getNumValues() == Result.getNode()->getNumValues() || 998ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif (Tmp3.getNode()->getNumValues() == Result.getNode()->getNumValues() + 1 && 999ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Tmp3.getNode()->getValueType(Tmp3.getNode()->getNumValues() - 1) == 10000f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling MVT::Flag)) && 1001b248e16afd105fd8c01e08d8bf997b08ff08d127Chris Lattner "Lowering call/formal_arguments produced unexpected # results!"); 1002fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1003f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // Since CALL/FORMAL_ARGUMENTS nodes produce multiple values, make sure to 1004e2e41730ccfa9bebfabbd17ab3454aa2bb620b2aChris Lattner // remember that we legalized all of them, so it doesn't get relegalized. 1005ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif for (unsigned i = 0, e = Tmp3.getNode()->getNumValues(); i != e; ++i) { 1006ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp3.getNode()->getValueType(i) == MVT::Flag) 10070f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling continue; 1008b248e16afd105fd8c01e08d8bf997b08ff08d127Chris Lattner Tmp1 = LegalizeOp(Tmp3.getValue(i)); 100999a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif if (Op.getResNo() == i) 1010e2e41730ccfa9bebfabbd17ab3454aa2bb620b2aChris Lattner Tmp2 = Tmp1; 1011475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, i), Tmp1); 1012e2e41730ccfa9bebfabbd17ab3454aa2bb620b2aChris Lattner } 1013e2e41730ccfa9bebfabbd17ab3454aa2bb620b2aChris Lattner return Tmp2; 1014b2827b0901162169bb2692b77a839c9767849134Chris Lattner case ISD::BUILD_VECTOR: 1015b2827b0901162169bb2692b77a839c9767849134Chris Lattner switch (TLI.getOperationAction(ISD::BUILD_VECTOR, Node->getValueType(0))) { 10162332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner default: assert(0 && "This action is not supported yet!"); 10172332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner case TargetLowering::Custom: 10182332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner Tmp3 = TLI.LowerOperation(Result, DAG); 1019ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp3.getNode()) { 10202332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner Result = Tmp3; 10212332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner break; 10222332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner } 10232332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner // FALLTHROUGH 1024ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner case TargetLowering::Expand: 1025ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Result = ExpandBUILD_VECTOR(Result.getNode()); 1026b2827b0901162169bb2692b77a839c9767849134Chris Lattner break; 10272332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner } 10282332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner break; 10299008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman case ISD::VECTOR_SHUFFLE: { 103087100e0b83b808757bf44dabecd1d1048255d1adChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the input vectors, 103187100e0b83b808757bf44dabecd1d1048255d1adChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // but not the shuffle mask. 10329008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); 10339008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman MVT VT = Result.getValueType(); 10349008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman 10355a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman // Copy the Mask to a local SmallVector for use with isShuffleMaskLegal. 10369008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman SmallVector<int, 8> Mask; 10379008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman cast<ShuffleVectorSDNode>(Result)->getMask(Mask); 103887100e0b83b808757bf44dabecd1d1048255d1adChris Lattner 103987100e0b83b808757bf44dabecd1d1048255d1adChris Lattner // Allow targets to custom lower the SHUFFLEs they support. 10409008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman switch (TLI.getOperationAction(ISD::VECTOR_SHUFFLE, VT)) { 10414352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner default: assert(0 && "Unknown operation action!"); 10424352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner case TargetLowering::Legal: 10439008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman assert(TLI.isShuffleMaskLegal(Mask, VT) && 10444352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner "vector shuffle should not be created if not legal!"); 10454352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner break; 10464352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner case TargetLowering::Custom: 104718dd6d0a2aeb3b827391f46996a7b40c9b1f907aEvan Cheng Tmp3 = TLI.LowerOperation(Result, DAG); 1048ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp3.getNode()) { 104918dd6d0a2aeb3b827391f46996a7b40c9b1f907aEvan Cheng Result = Tmp3; 105018dd6d0a2aeb3b827391f46996a7b40c9b1f907aEvan Cheng break; 105118dd6d0a2aeb3b827391f46996a7b40c9b1f907aEvan Cheng } 105218dd6d0a2aeb3b827391f46996a7b40c9b1f907aEvan Cheng // FALLTHROUGH 105318dd6d0a2aeb3b827391f46996a7b40c9b1f907aEvan Cheng case TargetLowering::Expand: { 105483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT EltVT = VT.getVectorElementType(); 10555a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman unsigned NumElems = VT.getVectorNumElements(); 1056ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson SmallVector<SDValue, 8> Ops; 10575a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman for (unsigned i = 0; i != NumElems; ++i) { 10589008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman if (Mask[i] < 0) { 1059e8d7230f480654cdb8ff1c3d0a38e1e9ab0bd55fDale Johannesen Ops.push_back(DAG.getUNDEF(EltVT)); 10609008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman continue; 106118dd6d0a2aeb3b827391f46996a7b40c9b1f907aEvan Cheng } 10625a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman unsigned Idx = Mask[i]; 10639008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman if (Idx < NumElems) 10649008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, Tmp1, 10659008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman DAG.getIntPtrConstant(Idx))); 10669008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman else 10679008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, Tmp2, 10689008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman DAG.getIntPtrConstant(Idx - NumElems))); 106918dd6d0a2aeb3b827391f46996a7b40c9b1f907aEvan Cheng } 1070a87008d90b7d894cfca53d407642acfd7be2af3cEvan Cheng Result = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &Ops[0], Ops.size()); 10714352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner break; 107218dd6d0a2aeb3b827391f46996a7b40c9b1f907aEvan Cheng } 10734352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner case TargetLowering::Promote: { 10744352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner // Change base type to a different vector type. 107583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT OVT = Node->getValueType(0); 107683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); 10774352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner 10784352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner // Cast the two input vectors. 1079ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::BIT_CONVERT, dl, NVT, Tmp1); 1080ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::BIT_CONVERT, dl, NVT, Tmp2); 1081fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 10824352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner // Convert the shuffle mask to the right # elements. 10835a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman Result = ShuffleWithNarrowerEltType(NVT, OVT, dl, Tmp1, Tmp2, Mask); 1084ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::BIT_CONVERT, dl, OVT, Result); 10854352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner break; 10864352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner } 108787100e0b83b808757bf44dabecd1d1048255d1adChris Lattner } 108887100e0b83b808757bf44dabecd1d1048255d1adChris Lattner break; 10899008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman } 10900c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang case ISD::CONCAT_VECTORS: { 10915ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson // Legalize the operands. 10920c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang SmallVector<SDValue, 8> Ops; 10935ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) 10945ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson Ops.push_back(LegalizeOp(Node->getOperand(i))); 10955ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson Result = DAG.UpdateNodeOperands(Result, &Ops[0], Ops.size()); 10965ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson 10975ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson switch (TLI.getOperationAction(ISD::CONCAT_VECTORS, 10985ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson Node->getValueType(0))) { 10995ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson default: assert(0 && "Unknown operation action!"); 11005ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson case TargetLowering::Legal: 11015ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson break; 11025ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson case TargetLowering::Custom: 11035ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson Tmp3 = TLI.LowerOperation(Result, DAG); 11045ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson if (Tmp3.getNode()) { 11055ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson Result = Tmp3; 11065ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson break; 11075ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson } 11085ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson // FALLTHROUGH 11095ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson case TargetLowering::Expand: { 11105ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson // Use extract/insert/build vector for now. We might try to be 11115ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson // more clever later. 11125ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson MVT PtrVT = TLI.getPointerTy(); 11135ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson SmallVector<SDValue, 8> Ops; 11145ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson unsigned NumOperands = Node->getNumOperands(); 11155ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson for (unsigned i=0; i < NumOperands; ++i) { 11165ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson SDValue SubOp = Node->getOperand(i); 11175ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson MVT VVT = SubOp.getNode()->getValueType(0); 11185ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson MVT EltVT = VVT.getVectorElementType(); 11195ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson unsigned NumSubElem = VVT.getVectorNumElements(); 11205ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson for (unsigned j=0; j < NumSubElem; ++j) { 11215ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, SubOp, 11225ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson DAG.getConstant(j, PtrVT))); 11235ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson } 11240c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang } 11255ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson return LegalizeOp(DAG.getNode(ISD::BUILD_VECTOR, dl, 11265ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson Node->getValueType(0), 11275ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson &Ops[0], Ops.size())); 11280c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang } 11295ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson } 11305ee24e54d76ab86279fe196c03d6e03f5b4b3b3bBob Wilson break; 11310c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang } 11320c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang 11336831a815999dde4cf801e2076e66b4943964daf2Chris Lattner case ISD::CALLSEQ_START: { 11346831a815999dde4cf801e2076e66b4943964daf2Chris Lattner SDNode *CallEnd = FindCallEndFromCallStart(Node); 1135fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 11366831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Recursively Legalize all of the inputs of the call end that do not lead 11376831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // to this call start. This ensures that any libcalls that need be inserted 11386831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // are inserted *before* the CALLSEQ_START. 113900755df36c1448ac4728a74d907aa09e3d8b2d49Chris Lattner {SmallPtrSet<SDNode*, 32> NodesLeadingTo; 11406831a815999dde4cf801e2076e66b4943964daf2Chris Lattner for (unsigned i = 0, e = CallEnd->getNumOperands(); i != e; ++i) 1141ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif LegalizeAllNodesNotLeadingTo(CallEnd->getOperand(i).getNode(), Node, 1142c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner NodesLeadingTo); 1143c9cf4f1a7573ac7e379efd6ad15d7bd0a84a097cChris Lattner } 11446831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 11456831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Now that we legalized all of the inputs (which may have inserted 11466831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // libcalls) create the new CALLSEQ_START node. 11476831a815999dde4cf801e2076e66b4943964daf2Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 11486831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 11496831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Merge in the last call, to ensure that this call start after the last 11506831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // call ended. 1151c5d7d7c715f7b7a4eeea1ceaafefc3d1d6df2addChris Lattner if (LastCALLSEQ_END.getOpcode() != ISD::EntryToken) { 1152fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Tmp1 = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, 1153ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1, LastCALLSEQ_END); 1154b248e16afd105fd8c01e08d8bf997b08ff08d127Chris Lattner Tmp1 = LegalizeOp(Tmp1); 1155b248e16afd105fd8c01e08d8bf997b08ff08d127Chris Lattner } 1156fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 11576831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Do not try to legalize the target-specific arguments (#1+). 11586831a815999dde4cf801e2076e66b4943964daf2Chris Lattner if (Tmp1 != Node->getOperand(0)) { 1159475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 8> Ops(Node->op_begin(), Node->op_end()); 11606831a815999dde4cf801e2076e66b4943964daf2Chris Lattner Ops[0] = Tmp1; 1161f06f35e30b4c4d7db304f717a3d4dc6595fbd078Chris Lattner Result = DAG.UpdateNodeOperands(Result, &Ops[0], Ops.size()); 11626831a815999dde4cf801e2076e66b4943964daf2Chris Lattner } 1163fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 11646831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Remember that the CALLSEQ_START is legalized. 11654b653a0405bb16b555334d134c1eb8a97366ec3dChris Lattner AddLegalizedOperand(Op.getValue(0), Result); 11664b653a0405bb16b555334d134c1eb8a97366ec3dChris Lattner if (Node->getNumValues() == 2) // If this has a flag result, remember it. 11674b653a0405bb16b555334d134c1eb8a97366ec3dChris Lattner AddLegalizedOperand(Op.getValue(1), Result.getValue(1)); 1168fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 11696831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Now that the callseq_start and all of the non-call nodes above this call 1170fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // sequence have been legalized, legalize the call itself. During this 11716831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // process, no libcalls can/will be inserted, guaranteeing that no calls 11726831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // can overlap. 11736831a815999dde4cf801e2076e66b4943964daf2Chris Lattner assert(!IsLegalizingCall && "Inconsistent sequentialization of calls!"); 11746831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Note that we are selecting this call! 1175475871a144eb604ddaf37503397ba0941442e5fbDan Gohman LastCALLSEQ_END = SDValue(CallEnd, 0); 11766831a815999dde4cf801e2076e66b4943964daf2Chris Lattner IsLegalizingCall = true; 1177fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 11786831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Legalize the call, starting from the CALLSEQ_END. 11796831a815999dde4cf801e2076e66b4943964daf2Chris Lattner LegalizeOp(LastCALLSEQ_END); 11806831a815999dde4cf801e2076e66b4943964daf2Chris Lattner assert(!IsLegalizingCall && "CALLSEQ_END should have cleared this!"); 11816831a815999dde4cf801e2076e66b4943964daf2Chris Lattner return Result; 11826831a815999dde4cf801e2076e66b4943964daf2Chris Lattner } 118316cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner case ISD::CALLSEQ_END: 11846831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // If the CALLSEQ_START node hasn't been legalized first, legalize it. This 11856831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // will cause this node to be legalized as well as handling libcalls right. 1186ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (LastCALLSEQ_END.getNode() != Node) { 1187475871a144eb604ddaf37503397ba0941442e5fbDan Gohman LegalizeOp(SDValue(FindCallStartFromCallEnd(Node), 0)); 1188475871a144eb604ddaf37503397ba0941442e5fbDan Gohman DenseMap<SDValue, SDValue>::iterator I = LegalizedNodes.find(Op); 11896831a815999dde4cf801e2076e66b4943964daf2Chris Lattner assert(I != LegalizedNodes.end() && 11906831a815999dde4cf801e2076e66b4943964daf2Chris Lattner "Legalizing the call start should have legalized this node!"); 11916831a815999dde4cf801e2076e66b4943964daf2Chris Lattner return I->second; 11926831a815999dde4cf801e2076e66b4943964daf2Chris Lattner } 1193fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1194fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // Otherwise, the call start has been legalized and everything is going 11956831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // according to plan. Just legalize ourselves normally here. 11963e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 119770814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner // Do not try to legalize the target-specific arguments (#1+), except for 119870814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner // an optional flag input. 119970814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner if (Node->getOperand(Node->getNumOperands()-1).getValueType() != MVT::Flag){ 120070814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner if (Tmp1 != Node->getOperand(0)) { 1201475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 8> Ops(Node->op_begin(), Node->op_end()); 120270814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner Ops[0] = Tmp1; 1203f06f35e30b4c4d7db304f717a3d4dc6595fbd078Chris Lattner Result = DAG.UpdateNodeOperands(Result, &Ops[0], Ops.size()); 120470814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner } 120570814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner } else { 120670814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(Node->getNumOperands()-1)); 120770814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner if (Tmp1 != Node->getOperand(0) || 120870814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner Tmp2 != Node->getOperand(Node->getNumOperands()-1)) { 1209475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 8> Ops(Node->op_begin(), Node->op_end()); 121070814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner Ops[0] = Tmp1; 121170814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner Ops.back() = Tmp2; 1212f06f35e30b4c4d7db304f717a3d4dc6595fbd078Chris Lattner Result = DAG.UpdateNodeOperands(Result, &Ops[0], Ops.size()); 121370814bc38435d61a8c7cc32f2375c09e21f12a8aChris Lattner } 12146a5428934ba6159c1acc541944332e51a6cfa59aChris Lattner } 12154b653a0405bb16b555334d134c1eb8a97366ec3dChris Lattner assert(IsLegalizingCall && "Call sequence imbalance between start/end?"); 12166831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // This finishes up call legalization. 12176831a815999dde4cf801e2076e66b4943964daf2Chris Lattner IsLegalizingCall = false; 1218fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 12194b653a0405bb16b555334d134c1eb8a97366ec3dChris Lattner // If the CALLSEQ_END node has a flag, remember that we legalized it. 1220475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 0), Result.getValue(0)); 12214b653a0405bb16b555334d134c1eb8a97366ec3dChris Lattner if (Node->getNumValues() == 2) 1222475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 1), Result.getValue(1)); 122399a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Result.getValue(Op.getResNo()); 1224a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng case ISD::DYNAMIC_STACKALLOC: { 122583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 1226fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 1227fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the size. 1228fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the alignment. 1229c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3); 1230fa404e8a76abfdafefb8806b35f596d288609496Chris Lattner 1231c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp1 = Result.getValue(0); 12325f652295c27826f26547cf5eb4096a59d86b56b8Chris Lattner Tmp2 = Result.getValue(1); 123361bbbabe3da27479cc9a3a36e49091a1141ba7a3Evan Cheng switch (TLI.getOperationAction(Node->getOpcode(), VT)) { 1234a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng default: assert(0 && "This action is not supported yet!"); 1235903d278a9b7398d8905c90832e587e0556c52789Chris Lattner case TargetLowering::Expand: { 1236903d278a9b7398d8905c90832e587e0556c52789Chris Lattner unsigned SPReg = TLI.getStackPointerRegisterToSaveRestore(); 1237903d278a9b7398d8905c90832e587e0556c52789Chris Lattner assert(SPReg && "Target cannot require DYNAMIC_STACKALLOC expansion and" 1238903d278a9b7398d8905c90832e587e0556c52789Chris Lattner " not tell us which reg is the stack pointer!"); 1239475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Chain = Tmp1.getOperand(0); 12400f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling 12410f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling // Chain the dynamic stack allocation so that it doesn't modify the stack 12420f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling // pointer when other instructions are using the stack. 1243e563bbc312f8b11ecfe12b8187176f667df1dff3Chris Lattner Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(0, true)); 12440f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling 1245475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Size = Tmp2.getOperand(1); 1246c460ae90019ddb19d4c07b2cd2fbaecfa7adf67dDale Johannesen SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, VT); 124761bbbabe3da27479cc9a3a36e49091a1141ba7a3Evan Cheng Chain = SP.getValue(1); 1248f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman unsigned Align = cast<ConstantSDNode>(Tmp3)->getZExtValue(); 124961bbbabe3da27479cc9a3a36e49091a1141ba7a3Evan Cheng unsigned StackAlign = 125061bbbabe3da27479cc9a3a36e49091a1141ba7a3Evan Cheng TLI.getTargetMachine().getFrameInfo()->getStackAlignment(); 125161bbbabe3da27479cc9a3a36e49091a1141ba7a3Evan Cheng if (Align > StackAlign) 1252ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SP = DAG.getNode(ISD::AND, dl, VT, SP, 12533e20bba5eb5df2fdd3e6655c8470084cf05032d4Evan Cheng DAG.getConstant(-(uint64_t)Align, VT)); 1254ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::SUB, dl, VT, SP, Size); // Value 1255c460ae90019ddb19d4c07b2cd2fbaecfa7adf67dDale Johannesen Chain = DAG.getCopyToReg(Chain, dl, SPReg, Tmp1); // Output chain 12560f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling 1257ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(0, true), 1258e563bbc312f8b11ecfe12b8187176f667df1dff3Chris Lattner DAG.getIntPtrConstant(0, true), SDValue()); 12590f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling 1260c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp1 = LegalizeOp(Tmp1); 1261c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp2 = LegalizeOp(Tmp2); 1262903d278a9b7398d8905c90832e587e0556c52789Chris Lattner break; 1263903d278a9b7398d8905c90832e587e0556c52789Chris Lattner } 1264903d278a9b7398d8905c90832e587e0556c52789Chris Lattner case TargetLowering::Custom: 12655f652295c27826f26547cf5eb4096a59d86b56b8Chris Lattner Tmp3 = TLI.LowerOperation(Tmp1, DAG); 1266ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp3.getNode()) { 1267c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp1 = LegalizeOp(Tmp3); 1268c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp2 = LegalizeOp(Tmp3.getValue(1)); 1269a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng } 1270903d278a9b7398d8905c90832e587e0556c52789Chris Lattner break; 1271a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng case TargetLowering::Legal: 1272903d278a9b7398d8905c90832e587e0556c52789Chris Lattner break; 1273a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng } 1274903d278a9b7398d8905c90832e587e0556c52789Chris Lattner // Since this op produce two values, make sure to remember that we 1275903d278a9b7398d8905c90832e587e0556c52789Chris Lattner // legalized both of them. 1276475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 0), Tmp1); 1277475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 1), Tmp2); 127899a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Op.getResNo() ? Tmp2 : Tmp1; 1279a7dce3c6c29fb9513d215c1bc44b01865571b4c2Evan Cheng } 12808c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::BR_JT: 12818c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 12828c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // Ensure that libcalls are emitted before a branch. 12838c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Tmp1, LastCALLSEQ_END); 12848c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = LegalizeOp(Tmp1); 12858c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman LastCALLSEQ_END = DAG.getEntryNode(); 128625a022c7801b047b31d7610386e8a9ddca878cb1Chris Lattner 12878c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the jumptable node. 12888c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Node->getOperand(2)); 12893d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng 1290fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel switch (TLI.getOperationAction(ISD::BR_JT, MVT::Other)) { 12913d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng default: assert(0 && "This action is not supported yet!"); 12923d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng case TargetLowering::Legal: break; 12933d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng case TargetLowering::Custom: 12943d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng Tmp1 = TLI.LowerOperation(Result, DAG); 1295ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 12963d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng break; 12973d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng case TargetLowering::Expand: { 1298475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Chain = Result.getOperand(0); 1299475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Table = Result.getOperand(1); 1300475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Index = Result.getOperand(2); 13013d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng 130283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT PTy = TLI.getPointerTy(); 1303acd80ac7bb19f8bdfa55336d567c9ecbe695c8b8Jim Laskey MachineFunction &MF = DAG.getMachineFunction(); 1304acd80ac7bb19f8bdfa55336d567c9ecbe695c8b8Jim Laskey unsigned EntrySize = MF.getJumpTableInfo()->getEntrySize(); 1305fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Index= DAG.getNode(ISD::MUL, dl, PTy, 1306ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Index, DAG.getConstant(EntrySize, PTy)); 1307ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue Addr = DAG.getNode(ISD::ADD, dl, PTy, Index, Table); 1308acd80ac7bb19f8bdfa55336d567c9ecbe695c8b8Jim Laskey 1309712f7b3f549644190e90210a07988753f53daa0aDuncan Sands MVT MemVT = MVT::getIntegerVT(EntrySize * 8); 1310ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue LD = DAG.getExtLoad(ISD::SEXTLOAD, dl, PTy, Chain, Addr, 1311712f7b3f549644190e90210a07988753f53daa0aDuncan Sands PseudoSourceValue::getJumpTable(), 0, MemVT); 1312cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Cheng Addr = LD; 1313acd80ac7bb19f8bdfa55336d567c9ecbe695c8b8Jim Laskey if (TLI.getTargetMachine().getRelocationModel() == Reloc::PIC_) { 13143d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng // For PIC, the sequence is: 13153d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng // BRIND(load(Jumptable + index) + RelocBase) 1316cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Cheng // RelocBase can be JumpTable, GOT or some sort of global base. 1317ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Addr = DAG.getNode(ISD::ADD, dl, PTy, Addr, 1318cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Cheng TLI.getPICJumpTableRelocBase(Table, DAG)); 13193d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng } 1320ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::BRIND, dl, MVT::Other, LD.getValue(1), Addr); 13213d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng } 13223d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng } 13233d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng break; 1324c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner case ISD::BRCOND: 1325c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 13266831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Ensure that libcalls are emitted before a return. 1327ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Tmp1, LastCALLSEQ_END); 13286831a815999dde4cf801e2076e66b4943964daf2Chris Lattner Tmp1 = LegalizeOp(Tmp1); 13296831a815999dde4cf801e2076e66b4943964daf2Chris Lattner LastCALLSEQ_END = DAG.getEntryNode(); 13306831a815999dde4cf801e2076e66b4943964daf2Chris Lattner 1331957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the condition. 1332456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner 1333456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner // Basic block destination (Op#2) is always legal. 1334c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Node->getOperand(2)); 1335fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1336fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel switch (TLI.getOperationAction(ISD::BRCOND, MVT::Other)) { 13377cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman default: assert(0 && "This action is not supported yet!"); 1338456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Legal: break; 1339456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 1340456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp1 = TLI.LowerOperation(Result, DAG); 1341ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 1342456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner break; 13437cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case TargetLowering::Expand: 13447cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Expand brcond's setcc into its constituent parts and create a BR_CC 13457cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // Node. 13467cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman if (Tmp2.getOpcode() == ISD::SETCC) { 1347fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getNode(ISD::BR_CC, dl, MVT::Other, 1348ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1, Tmp2.getOperand(2), 13497cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp2.getOperand(0), Tmp2.getOperand(1), 13507cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 13517cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } else { 1352fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getNode(ISD::BR_CC, dl, MVT::Other, Tmp1, 13537cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getCondCode(ISD::SETNE), Tmp2, 13547cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman DAG.getConstant(0, Tmp2.getValueType()), 13557cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Node->getOperand(2)); 13567cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 13577cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 13587cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 13597cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman break; 13607cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman case ISD::BR_CC: 13617cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 13626831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Ensure that libcalls are emitted before a branch. 1363ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Tmp1, LastCALLSEQ_END); 13646831a815999dde4cf801e2076e66b4943964daf2Chris Lattner Tmp1 = LegalizeOp(Tmp1); 1365fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Tmp2 = Node->getOperand(2); // LHS 1366750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp3 = Node->getOperand(3); // RHS 1367750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp4 = Node->getOperand(1); // CC 1368181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner 1369fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel LegalizeSetCC(TLI.getSetCCResultType(Tmp2.getValueType()), 1370bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Tmp2, Tmp3, Tmp4, dl); 1371722cb360690e5d7742b01a9f497fdb65bf8079d5Evan Cheng LastCALLSEQ_END = DAG.getEntryNode(); 1372722cb360690e5d7742b01a9f497fdb65bf8079d5Evan Cheng 13737f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng // If we didn't get both a LHS and RHS back from LegalizeSetCC, 1374750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman // the LHS is a legal SETCC itself. In this case, we need to compare 1375750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman // the result against zero to select between true and false values. 1376ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp3.getNode() == 0) { 1377750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp3 = DAG.getConstant(0, Tmp2.getValueType()); 1378750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp4 = DAG.getCondCode(ISD::SETNE); 1379750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman } 1380fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1381fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp4, Tmp2, Tmp3, 1382750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Node->getOperand(4)); 1383fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1384181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner switch (TLI.getOperationAction(ISD::BR_CC, Tmp3.getValueType())) { 1385181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner default: assert(0 && "Unexpected action for BR_CC!"); 1386456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Legal: break; 1387456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 1388456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp4 = TLI.LowerOperation(Result, DAG); 1389ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp4.getNode()) Result = Tmp4; 1390181b7a382fbdd3d03ce373a6ffac2204e763f9c3Chris Lattner break; 13917cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman } 1392c18ae4cb6a263cf31283c0ef51ace24350f8d72bChris Lattner break; 1393f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case ISD::LOAD: { 1394466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng LoadSDNode *LD = cast<LoadSDNode>(Node); 1395466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng Tmp1 = LegalizeOp(LD->getChain()); // Legalize the chain. 1396466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng Tmp2 = LegalizeOp(LD->getBasePtr()); // Legalize the base pointer. 13972d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 1398466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng ISD::LoadExtType ExtType = LD->getExtensionType(); 1399466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng if (ExtType == ISD::NON_EXTLOAD) { 140083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 1401466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, LD->getOffset()); 1402466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng Tmp3 = Result.getValue(0); 1403466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng Tmp4 = Result.getValue(1); 1404fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1405466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng switch (TLI.getOperationAction(Node->getOpcode(), VT)) { 1406466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng default: assert(0 && "This action is not supported yet!"); 1407f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio case TargetLowering::Legal: 1408f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // If this is an unaligned load and the target doesn't support it, 1409f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // expand it. 1410f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio if (!TLI.allowsUnalignedMemoryAccesses()) { 1411f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio unsigned ABIAlignment = TLI.getTargetData()-> 141283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands getABITypeAlignment(LD->getMemoryVT().getTypeForMVT()); 1413f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio if (LD->getAlignment() < ABIAlignment){ 1414ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Result = ExpandUnalignedLoad(cast<LoadSDNode>(Result.getNode()), DAG, 1415f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio TLI); 1416f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio Tmp3 = Result.getOperand(0); 1417f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio Tmp4 = Result.getOperand(1); 1418907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen Tmp3 = LegalizeOp(Tmp3); 1419907f28ce3032e67c02a50095659e901de867dd3cDale Johannesen Tmp4 = LegalizeOp(Tmp4); 1420f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 1421f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 1422f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio break; 1423466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng case TargetLowering::Custom: 1424466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng Tmp1 = TLI.LowerOperation(Tmp3, DAG); 1425ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) { 1426466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng Tmp3 = LegalizeOp(Tmp1); 1427466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng Tmp4 = LegalizeOp(Tmp1.getValue(1)); 1428466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng } 1429466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng break; 1430466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng case TargetLowering::Promote: { 1431466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng // Only promote a load of vector type to another. 143283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(VT.isVector() && "Cannot promote this load!"); 1433466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng // Change base type to a different vector type. 143483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), VT); 1435466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng 1436ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getLoad(NVT, dl, Tmp1, Tmp2, LD->getSrcValue(), 1437d6fd1bc122ba791c698255d8be158b8ec424e248Dan Gohman LD->getSrcValueOffset(), 1438d6fd1bc122ba791c698255d8be158b8ec424e248Dan Gohman LD->isVolatile(), LD->getAlignment()); 1439b300d2aa3ef08b5074449e2c05804717f488f4e4Dale Johannesen Tmp3 = LegalizeOp(DAG.getNode(ISD::BIT_CONVERT, dl, VT, Tmp1)); 144041f6cbbeb21d7d4376b8c0302b9766c3e43be5f2Evan Cheng Tmp4 = LegalizeOp(Tmp1.getValue(1)); 1441466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng break; 1442f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 1443466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng } 1444fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // Since loads produce two values, make sure to remember that we 1445466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng // legalized both of them. 1446475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 0), Tmp3); 1447475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 1), Tmp4); 144899a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Op.getResNo() ? Tmp4 : Tmp3; 1449466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng } else { 145083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT SrcVT = LD->getMemoryVT(); 145183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned SrcWidth = SrcVT.getSizeInBits(); 1452f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands int SVOffset = LD->getSrcValueOffset(); 1453f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands unsigned Alignment = LD->getAlignment(); 1454f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands bool isVolatile = LD->isVolatile(); 1455f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 145683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (SrcWidth != SrcVT.getStoreSizeInBits() && 1457f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Some targets pretend to have an i1 loading operation, and actually 1458f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // load an i8. This trick is correct for ZEXTLOAD because the top 7 1459f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // bits are guaranteed to be zero; it helps the optimizers understand 1460f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // that these bits are zero. It is also useful for EXTLOAD, since it 1461f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // tells the optimizers that those bits are undefined. It would be 1462f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // nice to have an effective generic way of getting these benefits... 1463f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Until such a way is found, don't insist on promoting i1 here. 1464f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands (SrcVT != MVT::i1 || 14650329466b6b4927f4e6f5d144891fef06a027fec5Evan Cheng TLI.getLoadExtAction(ExtType, MVT::i1) == TargetLowering::Promote)) { 1466f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Promote to a byte-sized load if not loading an integral number of 1467f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // bytes. For example, promote EXTLOAD:i20 -> EXTLOAD:i24. 146883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned NewWidth = SrcVT.getStoreSizeInBits(); 146983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = MVT::getIntegerVT(NewWidth); 1470475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ch; 1471f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1472f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // The extra bits are guaranteed to be zero, since we stored them that 1473f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // way. A zext load from NVT thus automatically gives zext from SrcVT. 1474f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1475f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands ISD::LoadExtType NewExtType = 1476f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands ExtType == ISD::ZEXTLOAD ? ISD::ZEXTLOAD : ISD::EXTLOAD; 1477f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1478ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getExtLoad(NewExtType, dl, Node->getValueType(0), 1479f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1, Tmp2, LD->getSrcValue(), SVOffset, 1480f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands NVT, isVolatile, Alignment); 1481f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1482f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Ch = Result.getValue(1); // The chain. 1483f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1484f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands if (ExtType == ISD::SEXTLOAD) 1485f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Having the top bits zero doesn't help when sign extending. 1486fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, 1487ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result.getValueType(), 1488f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Result, DAG.getValueType(SrcVT)); 1489f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands else if (ExtType == ISD::ZEXTLOAD || NVT == Result.getValueType()) 1490f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // All the top bits are guaranteed to be zero - inform the optimizers. 1491fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getNode(ISD::AssertZext, dl, 1492ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result.getValueType(), Result, 1493f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands DAG.getValueType(SrcVT)); 1494f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1495f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1 = LegalizeOp(Result); 1496f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp2 = LegalizeOp(Ch); 1497f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands } else if (SrcWidth & (SrcWidth - 1)) { 1498f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // If not loading a power-of-2 number of bits, expand as two loads. 149983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(SrcVT.isExtended() && !SrcVT.isVector() && 1500f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands "Unsupported extload!"); 1501f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands unsigned RoundWidth = 1 << Log2_32(SrcWidth); 1502f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands assert(RoundWidth < SrcWidth); 1503f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands unsigned ExtraWidth = SrcWidth - RoundWidth; 1504f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands assert(ExtraWidth < RoundWidth); 1505f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands assert(!(RoundWidth % 8) && !(ExtraWidth % 8) && 1506f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands "Load size not an integral number of bytes!"); 150783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT RoundVT = MVT::getIntegerVT(RoundWidth); 150883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT ExtraVT = MVT::getIntegerVT(ExtraWidth); 1509475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Lo, Hi, Ch; 1510f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands unsigned IncrementSize; 1511f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1512f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands if (TLI.isLittleEndian()) { 1513f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // EXTLOAD:i24 -> ZEXTLOAD:i16 | (shl EXTLOAD@+2:i8, 16) 1514f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Load the bottom RoundWidth bits. 1515ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, 1516ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Node->getValueType(0), Tmp1, Tmp2, 1517f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands LD->getSrcValue(), SVOffset, RoundVT, isVolatile, 1518f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Alignment); 1519f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1520f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Load the remaining ExtraWidth bits. 1521f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands IncrementSize = RoundWidth / 8; 1522ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2, 1523f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands DAG.getIntPtrConstant(IncrementSize)); 1524ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getExtLoad(ExtType, dl, Node->getValueType(0), Tmp1, Tmp2, 1525f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands LD->getSrcValue(), SVOffset + IncrementSize, 1526f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands ExtraVT, isVolatile, 1527f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands MinAlign(Alignment, IncrementSize)); 1528f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1529f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Build a factor node to remember that this load is independent of the 1530f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // other one. 1531ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1), 1532f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Hi.getValue(1)); 1533f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1534f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Move the top bits to the right place. 1535ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getNode(ISD::SHL, dl, Hi.getValueType(), Hi, 1536f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands DAG.getConstant(RoundWidth, TLI.getShiftAmountTy())); 1537f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1538f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Join the hi and lo parts. 1539ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::OR, dl, Node->getValueType(0), Lo, Hi); 1540f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } else { 1541f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Big endian - avoid unaligned loads. 1542f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // EXTLOAD:i24 -> (shl EXTLOAD:i16, 8) | ZEXTLOAD@+2:i8 1543f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Load the top RoundWidth bits. 1544ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getExtLoad(ExtType, dl, Node->getValueType(0), Tmp1, Tmp2, 1545f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands LD->getSrcValue(), SVOffset, RoundVT, isVolatile, 1546f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Alignment); 1547f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1548f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Load the remaining ExtraWidth bits. 1549f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands IncrementSize = RoundWidth / 8; 1550ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2, 1551f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands DAG.getIntPtrConstant(IncrementSize)); 1552fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, 1553ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Node->getValueType(0), Tmp1, Tmp2, 1554f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands LD->getSrcValue(), SVOffset + IncrementSize, 1555f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands ExtraVT, isVolatile, 1556f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands MinAlign(Alignment, IncrementSize)); 1557f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1558f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Build a factor node to remember that this load is independent of the 1559f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // other one. 1560ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1), 1561f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Hi.getValue(1)); 1562f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1563f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Move the top bits to the right place. 1564ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getNode(ISD::SHL, dl, Hi.getValueType(), Hi, 1565f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands DAG.getConstant(ExtraWidth, TLI.getShiftAmountTy())); 1566f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1567f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Join the hi and lo parts. 1568ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::OR, dl, Node->getValueType(0), Lo, Hi); 1569f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands } 1570f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1571f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1 = LegalizeOp(Result); 1572f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp2 = LegalizeOp(Ch); 1573f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands } else { 15740329466b6b4927f4e6f5d144891fef06a027fec5Evan Cheng switch (TLI.getLoadExtAction(ExtType, SrcVT)) { 1575f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands default: assert(0 && "This action is not supported yet!"); 1576f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands case TargetLowering::Custom: 1577f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands isCustom = true; 1578f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // FALLTHROUGH 1579f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands case TargetLowering::Legal: 1580f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, LD->getOffset()); 1581f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1 = Result.getValue(0); 1582f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp2 = Result.getValue(1); 1583f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1584f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands if (isCustom) { 1585f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp3 = TLI.LowerOperation(Result, DAG); 1586ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp3.getNode()) { 1587f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1 = LegalizeOp(Tmp3); 1588f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp2 = LegalizeOp(Tmp3.getValue(1)); 1589f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands } 1590f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands } else { 1591f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // If this is an unaligned load and the target doesn't support it, 1592f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // expand it. 1593f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands if (!TLI.allowsUnalignedMemoryAccesses()) { 1594f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands unsigned ABIAlignment = TLI.getTargetData()-> 159583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands getABITypeAlignment(LD->getMemoryVT().getTypeForMVT()); 1596f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands if (LD->getAlignment() < ABIAlignment){ 1597ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Result = ExpandUnalignedLoad(cast<LoadSDNode>(Result.getNode()), DAG, 1598f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands TLI); 1599f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1 = Result.getOperand(0); 1600f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp2 = Result.getOperand(1); 1601f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1 = LegalizeOp(Tmp1); 1602f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp2 = LegalizeOp(Tmp2); 1603f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands } 1604f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 1605f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 1606f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands break; 1607f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands case TargetLowering::Expand: 1608f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // f64 = EXTLOAD f32 should expand to LOAD, FP_EXTEND 1609f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands if (SrcVT == MVT::f32 && Node->getValueType(0) == MVT::f64) { 1610ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue Load = DAG.getLoad(SrcVT, dl, Tmp1, Tmp2, LD->getSrcValue(), 1611f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands LD->getSrcValueOffset(), 1612f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands LD->isVolatile(), LD->getAlignment()); 1613fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getNode(ISD::FP_EXTEND, dl, 1614ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Node->getValueType(0), Load); 1615f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1 = LegalizeOp(Result); // Relegalize new nodes. 1616f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp2 = LegalizeOp(Load.getValue(1)); 1617f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands break; 1618f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands } 1619f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands assert(ExtType != ISD::EXTLOAD &&"EXTLOAD should always be supported!"); 1620f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // Turn the unsupported load into an EXTLOAD followed by an explicit 1621f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands // zero/sign extend inreg. 1622ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getExtLoad(ISD::EXTLOAD, dl, Node->getValueType(0), 1623f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1, Tmp2, LD->getSrcValue(), 1624f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands LD->getSrcValueOffset(), SrcVT, 1625f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands LD->isVolatile(), LD->getAlignment()); 1626475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue ValRes; 1627f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands if (ExtType == ISD::SEXTLOAD) 1628ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen ValRes = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, 1629ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result.getValueType(), 1630f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Result, DAG.getValueType(SrcVT)); 1631f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands else 1632ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen ValRes = DAG.getZeroExtendInReg(Result, dl, SrcVT); 1633f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp1 = LegalizeOp(ValRes); // Relegalize new nodes. 1634f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands Tmp2 = LegalizeOp(Result.getValue(1)); // Relegalize new nodes. 1635466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng break; 1636466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng } 16379d416f713e8b9e4f0c0c2b3f6f57ce2dd8993209Andrew Lenharth } 1638f9c98e650d2795b8edfae8e1560c221029df218bDuncan Sands 1639466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng // Since loads produce two values, make sure to remember that we legalized 1640466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng // both of them. 1641475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 0), Tmp1); 1642475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 1), Tmp2); 164399a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Op.getResNo() ? Tmp2 : Tmp1; 164401ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 164501ff7216dd7829d4094754086baf28aa2d7149acChris Lattner } 1646f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng case ISD::STORE: { 16478b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng StoreSDNode *ST = cast<StoreSDNode>(Node); 16488b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng Tmp1 = LegalizeOp(ST->getChain()); // Legalize the chain. 16498b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng Tmp2 = LegalizeOp(ST->getBasePtr()); // Legalize the pointer. 1650d6fd1bc122ba791c698255d8be158b8ec424e248Dan Gohman int SVOffset = ST->getSrcValueOffset(); 1651d6fd1bc122ba791c698255d8be158b8ec424e248Dan Gohman unsigned Alignment = ST->getAlignment(); 1652d6fd1bc122ba791c698255d8be158b8ec424e248Dan Gohman bool isVolatile = ST->isVolatile(); 16538b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng 16548b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng if (!ST->isTruncatingStore()) { 1655d93d46ee7e0a0e539d42139b85c71b2b8c3968feChris Lattner // Turn 'store float 1.0, Ptr' -> 'store int 0x12345678, Ptr' 1656d93d46ee7e0a0e539d42139b85c71b2b8c3968feChris Lattner // FIXME: We shouldn't do this for TargetConstantFP's. 1657d93d46ee7e0a0e539d42139b85c71b2b8c3968feChris Lattner // FIXME: move this to the DAG Combiner! Note that we can't regress due 1658d93d46ee7e0a0e539d42139b85c71b2b8c3968feChris Lattner // to phase ordering between legalized code and the dag combiner. This 1659d93d46ee7e0a0e539d42139b85c71b2b8c3968feChris Lattner // probably means that we need to integrate dag combiner and legalizer 1660d93d46ee7e0a0e539d42139b85c71b2b8c3968feChris Lattner // together. 16619e3d3abd937c9bb79d56d25ec0e0724c7cbba67cDale Johannesen // We generally can't do this one for long doubles. 16622b4c279a8e203fa8b13adf7ba3a5d4c8bef70df3Chris Lattner if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(ST->getValue())) { 1663fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel if (CFP->getValueType(0) == MVT::f32 && 16643cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner getTypeAction(MVT::i32) == Legal) { 16656cf9b8adf43b0a460fb4ba8ddbff2787f5aa9d5eDan Gohman Tmp3 = DAG.getConstant(CFP->getValueAPF(). 16667111b02c734c992b8c97d9918118768026dad79eDale Johannesen bitcastToAPInt().zextOrTrunc(32), 16673f6eb7419de437436265831fce92f62498556e08Dale Johannesen MVT::i32); 1668ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getStore(Tmp1, dl, Tmp3, Tmp2, ST->getSrcValue(), 16699e3d3abd937c9bb79d56d25ec0e0724c7cbba67cDale Johannesen SVOffset, isVolatile, Alignment); 16709e3d3abd937c9bb79d56d25ec0e0724c7cbba67cDale Johannesen break; 16719e3d3abd937c9bb79d56d25ec0e0724c7cbba67cDale Johannesen } else if (CFP->getValueType(0) == MVT::f64) { 16723cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner // If this target supports 64-bit registers, do a single 64-bit store. 16733cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner if (getTypeAction(MVT::i64) == Legal) { 16747111b02c734c992b8c97d9918118768026dad79eDale Johannesen Tmp3 = DAG.getConstant(CFP->getValueAPF().bitcastToAPInt(). 16756cf9b8adf43b0a460fb4ba8ddbff2787f5aa9d5eDan Gohman zextOrTrunc(64), MVT::i64); 1676ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getStore(Tmp1, dl, Tmp3, Tmp2, ST->getSrcValue(), 16773cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner SVOffset, isVolatile, Alignment); 16783cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner break; 1679d4b9c17fb705c2f58ceef4f37d789ddb56783584Duncan Sands } else if (getTypeAction(MVT::i32) == Legal && !ST->isVolatile()) { 16803cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner // Otherwise, if the target supports 32-bit registers, use 2 32-bit 16813cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner // stores. If the target supports neither 32- nor 64-bits, this 16823cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner // xform is certainly not worth it. 16837111b02c734c992b8c97d9918118768026dad79eDale Johannesen const APInt &IntVal =CFP->getValueAPF().bitcastToAPInt(); 1684475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Lo = DAG.getConstant(APInt(IntVal).trunc(32), MVT::i32); 1685475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Hi = DAG.getConstant(IntVal.lshr(32).trunc(32), MVT::i32); 16860753fc1850a1ca4d17acca854d830d67737fd623Duncan Sands if (TLI.isBigEndian()) std::swap(Lo, Hi); 16873cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner 1688ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Lo = DAG.getStore(Tmp1, dl, Lo, Tmp2, ST->getSrcValue(), 16893cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner SVOffset, isVolatile, Alignment); 1690ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2, 16910bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(4)); 1692ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getStore(Tmp1, dl, Hi, Tmp2, ST->getSrcValue(), SVOffset+4, 1693dc84650679b6330e0fcdd4cf8bc2a351387db7caDuncan Sands isVolatile, MinAlign(Alignment, 4U)); 16943cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner 1695ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi); 16963cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner break; 16973cb9351e8a3691ee8cad6960601c6e3d4b293352Chris Lattner } 1698d93d46ee7e0a0e539d42139b85c71b2b8c3968feChris Lattner } 1699d93d46ee7e0a0e539d42139b85c71b2b8c3968feChris Lattner } 1700fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1701957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman { 17028b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng Tmp3 = LegalizeOp(ST->getValue()); 1703fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp3, Tmp2, 17048b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng ST->getOffset()); 17058b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng 170683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Tmp3.getValueType(); 17078b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng switch (TLI.getOperationAction(ISD::STORE, VT)) { 17088b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng default: assert(0 && "This action is not supported yet!"); 1709f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio case TargetLowering::Legal: 1710f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // If this is an unaligned store and the target doesn't support it, 1711f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio // expand it. 1712f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio if (!TLI.allowsUnalignedMemoryAccesses()) { 1713f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio unsigned ABIAlignment = TLI.getTargetData()-> 171483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands getABITypeAlignment(ST->getMemoryVT().getTypeForMVT()); 1715f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio if (ST->getAlignment() < ABIAlignment) 1716ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Result = ExpandUnalignedStore(cast<StoreSDNode>(Result.getNode()), DAG, 1717f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio TLI); 1718f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 1719f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio break; 17208b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng case TargetLowering::Custom: 17218b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng Tmp1 = TLI.LowerOperation(Result, DAG); 1722ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 17238b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng break; 17248b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng case TargetLowering::Promote: 172583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(VT.isVector() && "Unknown legal promote case!"); 1726fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Tmp3 = DAG.getNode(ISD::BIT_CONVERT, dl, 17278b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng TLI.getTypeToPromoteTo(ISD::STORE, VT), Tmp3); 1728ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getStore(Tmp1, dl, Tmp3, Tmp2, 1729d6fd1bc122ba791c698255d8be158b8ec424e248Dan Gohman ST->getSrcValue(), SVOffset, isVolatile, 1730d6fd1bc122ba791c698255d8be158b8ec424e248Dan Gohman Alignment); 17318b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng break; 17328b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng } 17332efce0a589e2a688a1a06b5dc2ed0db32ae79924Chris Lattner break; 1734f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 17358b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng } else { 1736957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp3 = LegalizeOp(ST->getValue()); 17377e857201f387d004571e6058e2ea709163500f38Duncan Sands 173883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT StVT = ST->getMemoryVT(); 173983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned StWidth = StVT.getSizeInBits(); 17407e857201f387d004571e6058e2ea709163500f38Duncan Sands 174183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (StWidth != StVT.getStoreSizeInBits()) { 17427e857201f387d004571e6058e2ea709163500f38Duncan Sands // Promote to a byte-sized store with upper bits zero if not 17437e857201f387d004571e6058e2ea709163500f38Duncan Sands // storing an integral number of bytes. For example, promote 17447e857201f387d004571e6058e2ea709163500f38Duncan Sands // TRUNCSTORE:i1 X -> TRUNCSTORE:i8 (and X, 1) 174583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = MVT::getIntegerVT(StVT.getStoreSizeInBits()); 1746ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp3 = DAG.getZeroExtendInReg(Tmp3, dl, StVT); 1747ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getTruncStore(Tmp1, dl, Tmp3, Tmp2, ST->getSrcValue(), 17487e857201f387d004571e6058e2ea709163500f38Duncan Sands SVOffset, NVT, isVolatile, Alignment); 17497e857201f387d004571e6058e2ea709163500f38Duncan Sands } else if (StWidth & (StWidth - 1)) { 17507e857201f387d004571e6058e2ea709163500f38Duncan Sands // If not storing a power-of-2 number of bits, expand as two stores. 175183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(StVT.isExtended() && !StVT.isVector() && 17527e857201f387d004571e6058e2ea709163500f38Duncan Sands "Unsupported truncstore!"); 17537e857201f387d004571e6058e2ea709163500f38Duncan Sands unsigned RoundWidth = 1 << Log2_32(StWidth); 17547e857201f387d004571e6058e2ea709163500f38Duncan Sands assert(RoundWidth < StWidth); 17557e857201f387d004571e6058e2ea709163500f38Duncan Sands unsigned ExtraWidth = StWidth - RoundWidth; 17567e857201f387d004571e6058e2ea709163500f38Duncan Sands assert(ExtraWidth < RoundWidth); 17577e857201f387d004571e6058e2ea709163500f38Duncan Sands assert(!(RoundWidth % 8) && !(ExtraWidth % 8) && 17587e857201f387d004571e6058e2ea709163500f38Duncan Sands "Store size not an integral number of bytes!"); 175983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT RoundVT = MVT::getIntegerVT(RoundWidth); 176083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT ExtraVT = MVT::getIntegerVT(ExtraWidth); 1761475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Lo, Hi; 17627e857201f387d004571e6058e2ea709163500f38Duncan Sands unsigned IncrementSize; 17637e857201f387d004571e6058e2ea709163500f38Duncan Sands 17647e857201f387d004571e6058e2ea709163500f38Duncan Sands if (TLI.isLittleEndian()) { 17657e857201f387d004571e6058e2ea709163500f38Duncan Sands // TRUNCSTORE:i24 X -> TRUNCSTORE:i16 X, TRUNCSTORE@+2:i8 (srl X, 16) 17667e857201f387d004571e6058e2ea709163500f38Duncan Sands // Store the bottom RoundWidth bits. 1767ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Lo = DAG.getTruncStore(Tmp1, dl, Tmp3, Tmp2, ST->getSrcValue(), 17687e857201f387d004571e6058e2ea709163500f38Duncan Sands SVOffset, RoundVT, 17697e857201f387d004571e6058e2ea709163500f38Duncan Sands isVolatile, Alignment); 17707e857201f387d004571e6058e2ea709163500f38Duncan Sands 17717e857201f387d004571e6058e2ea709163500f38Duncan Sands // Store the remaining ExtraWidth bits. 17727e857201f387d004571e6058e2ea709163500f38Duncan Sands IncrementSize = RoundWidth / 8; 1773ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2, 17747e857201f387d004571e6058e2ea709163500f38Duncan Sands DAG.getIntPtrConstant(IncrementSize)); 1775ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getNode(ISD::SRL, dl, Tmp3.getValueType(), Tmp3, 17767e857201f387d004571e6058e2ea709163500f38Duncan Sands DAG.getConstant(RoundWidth, TLI.getShiftAmountTy())); 1777ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getTruncStore(Tmp1, dl, Hi, Tmp2, ST->getSrcValue(), 17787e857201f387d004571e6058e2ea709163500f38Duncan Sands SVOffset + IncrementSize, ExtraVT, isVolatile, 17797e857201f387d004571e6058e2ea709163500f38Duncan Sands MinAlign(Alignment, IncrementSize)); 17807e857201f387d004571e6058e2ea709163500f38Duncan Sands } else { 17817e857201f387d004571e6058e2ea709163500f38Duncan Sands // Big endian - avoid unaligned stores. 17827e857201f387d004571e6058e2ea709163500f38Duncan Sands // TRUNCSTORE:i24 X -> TRUNCSTORE:i16 (srl X, 8), TRUNCSTORE@+2:i8 X 17837e857201f387d004571e6058e2ea709163500f38Duncan Sands // Store the top RoundWidth bits. 1784ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getNode(ISD::SRL, dl, Tmp3.getValueType(), Tmp3, 17857e857201f387d004571e6058e2ea709163500f38Duncan Sands DAG.getConstant(ExtraWidth, TLI.getShiftAmountTy())); 1786ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Hi = DAG.getTruncStore(Tmp1, dl, Hi, Tmp2, ST->getSrcValue(), 1787ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SVOffset, RoundVT, isVolatile, Alignment); 17887e857201f387d004571e6058e2ea709163500f38Duncan Sands 17897e857201f387d004571e6058e2ea709163500f38Duncan Sands // Store the remaining ExtraWidth bits. 17907e857201f387d004571e6058e2ea709163500f38Duncan Sands IncrementSize = RoundWidth / 8; 1791ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2, 17927e857201f387d004571e6058e2ea709163500f38Duncan Sands DAG.getIntPtrConstant(IncrementSize)); 1793ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Lo = DAG.getTruncStore(Tmp1, dl, Tmp3, Tmp2, ST->getSrcValue(), 17947e857201f387d004571e6058e2ea709163500f38Duncan Sands SVOffset + IncrementSize, ExtraVT, isVolatile, 17957e857201f387d004571e6058e2ea709163500f38Duncan Sands MinAlign(Alignment, IncrementSize)); 17967e857201f387d004571e6058e2ea709163500f38Duncan Sands } 1797c7029805ef35ce9805931067b841e6af11db382eChris Lattner 17987e857201f387d004571e6058e2ea709163500f38Duncan Sands // The order of the stores doesn't matter. 1799ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi); 18007e857201f387d004571e6058e2ea709163500f38Duncan Sands } else { 18017e857201f387d004571e6058e2ea709163500f38Duncan Sands if (Tmp1 != ST->getChain() || Tmp3 != ST->getValue() || 18027e857201f387d004571e6058e2ea709163500f38Duncan Sands Tmp2 != ST->getBasePtr()) 18037e857201f387d004571e6058e2ea709163500f38Duncan Sands Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp3, Tmp2, 18047e857201f387d004571e6058e2ea709163500f38Duncan Sands ST->getOffset()); 18057e857201f387d004571e6058e2ea709163500f38Duncan Sands 18067e857201f387d004571e6058e2ea709163500f38Duncan Sands switch (TLI.getTruncStoreAction(ST->getValue().getValueType(), StVT)) { 18077e857201f387d004571e6058e2ea709163500f38Duncan Sands default: assert(0 && "This action is not supported yet!"); 18087e857201f387d004571e6058e2ea709163500f38Duncan Sands case TargetLowering::Legal: 18097e857201f387d004571e6058e2ea709163500f38Duncan Sands // If this is an unaligned store and the target doesn't support it, 18107e857201f387d004571e6058e2ea709163500f38Duncan Sands // expand it. 18117e857201f387d004571e6058e2ea709163500f38Duncan Sands if (!TLI.allowsUnalignedMemoryAccesses()) { 18127e857201f387d004571e6058e2ea709163500f38Duncan Sands unsigned ABIAlignment = TLI.getTargetData()-> 181383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands getABITypeAlignment(ST->getMemoryVT().getTypeForMVT()); 18147e857201f387d004571e6058e2ea709163500f38Duncan Sands if (ST->getAlignment() < ABIAlignment) 1815ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif Result = ExpandUnalignedStore(cast<StoreSDNode>(Result.getNode()), DAG, 18167e857201f387d004571e6058e2ea709163500f38Duncan Sands TLI); 18177e857201f387d004571e6058e2ea709163500f38Duncan Sands } 18187e857201f387d004571e6058e2ea709163500f38Duncan Sands break; 18197e857201f387d004571e6058e2ea709163500f38Duncan Sands case TargetLowering::Custom: 18207e857201f387d004571e6058e2ea709163500f38Duncan Sands Result = TLI.LowerOperation(Result, DAG); 18217e857201f387d004571e6058e2ea709163500f38Duncan Sands break; 18227e857201f387d004571e6058e2ea709163500f38Duncan Sands case Expand: 18237e857201f387d004571e6058e2ea709163500f38Duncan Sands // TRUNCSTORE:i16 i32 -> STORE i16 18247e857201f387d004571e6058e2ea709163500f38Duncan Sands assert(isTypeLegal(StVT) && "Do not know how to expand this store!"); 1825ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp3 = DAG.getNode(ISD::TRUNCATE, dl, StVT, Tmp3); 1826ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getStore(Tmp1, dl, Tmp3, Tmp2, ST->getSrcValue(), 1827ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SVOffset, isVolatile, Alignment); 18287e857201f387d004571e6058e2ea709163500f38Duncan Sands break; 1829f3c13c82e34b8e90f1080cfe06c6f1328a2d44e1Lauro Ramos Venancio } 18308b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng } 18313e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 18323e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1833f3fd9fe20dbcb40f3dffc1518ab955a0b5d6fa23Evan Cheng } 18342ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner case ISD::SELECT: 1835957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the condition. 18363e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner Tmp2 = LegalizeOp(Node->getOperand(1)); // TrueVal 18372ee743ff9be43c350075a2fa15d11a79bff36775Chris Lattner Tmp3 = LegalizeOp(Node->getOperand(2)); // FalseVal 183855ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner 1839c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3); 1840fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1841b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman switch (TLI.getOperationAction(ISD::SELECT, Tmp2.getValueType())) { 184255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner default: assert(0 && "This action is not supported yet!"); 1843456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Legal: break; 1844456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: { 1845456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp1 = TLI.LowerOperation(Result, DAG); 1846ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 1847456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner break; 1848456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner } 18499373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman case TargetLowering::Expand: 18509373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman if (Tmp1.getOpcode() == ISD::SETCC) { 1851fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getSelectCC(dl, Tmp1.getOperand(0), Tmp1.getOperand(1), 18529373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, 18539373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman cast<CondCodeSDNode>(Tmp1.getOperand(2))->get()); 18549373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } else { 1855fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getSelectCC(dl, Tmp1, 18569373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman DAG.getConstant(0, Tmp1.getValueType()), 18579373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp2, Tmp3, ISD::SETNE); 18589373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 185955ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 186055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner case TargetLowering::Promote: { 186183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NVT = 186255ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner TLI.getTypeToPromoteTo(ISD::SELECT, Tmp2.getValueType()); 186355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner unsigned ExtOp, TruncOp; 186483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (Tmp2.getValueType().isVector()) { 186541f6cbbeb21d7d4376b8c0302b9766c3e43be5f2Evan Cheng ExtOp = ISD::BIT_CONVERT; 186641f6cbbeb21d7d4376b8c0302b9766c3e43be5f2Evan Cheng TruncOp = ISD::BIT_CONVERT; 186783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands } else if (Tmp2.getValueType().isInteger()) { 1868456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner ExtOp = ISD::ANY_EXTEND; 1869456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner TruncOp = ISD::TRUNCATE; 187055ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } else { 1871456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner ExtOp = ISD::FP_EXTEND; 1872456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner TruncOp = ISD::FP_ROUND; 187355ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 187455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Promote each of the values to the new type. 1875ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ExtOp, dl, NVT, Tmp2); 1876ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp3 = DAG.getNode(ExtOp, dl, NVT, Tmp3); 187755ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner // Perform the larger operation, then round down. 1878ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson Result = DAG.getNode(ISD::SELECT, dl, NVT, Tmp1, Tmp2, Tmp3); 18790bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner if (TruncOp != ISD::FP_ROUND) 1880ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(TruncOp, dl, Node->getValueType(0), Result); 18810bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner else 1882ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(TruncOp, dl, Node->getValueType(0), Result, 18830bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(0)); 188455ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner break; 188555ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 188655ba8fba750ee0a51a9d74fa33b7242d24a4ff35Chris Lattner } 18873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 1888750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman case ISD::SELECT_CC: { 1889750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp1 = Node->getOperand(0); // LHS 1890750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp2 = Node->getOperand(1); // RHS 18919373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp3 = LegalizeOp(Node->getOperand(2)); // True 18929373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman Tmp4 = LegalizeOp(Node->getOperand(3)); // False 1893475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue CC = Node->getOperand(4); 1894fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1895fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel LegalizeSetCC(TLI.getSetCCResultType(Tmp1.getValueType()), 1896bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen Tmp1, Tmp2, CC, dl); 1897fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 18987f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng // If we didn't get both a LHS and RHS back from LegalizeSetCC, 1899750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman // the LHS is a legal SETCC itself. In this case, we need to compare 1900750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman // the result against zero to select between true and false values. 1901ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp2.getNode() == 0) { 1902750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp2 = DAG.getConstant(0, Tmp1.getValueType()); 1903750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman CC = DAG.getCondCode(ISD::SETNE); 1904750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman } 1905750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3, Tmp4, CC); 1906750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman 1907750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman // Everything is legal, see if we should expand this op or something. 1908750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman switch (TLI.getOperationAction(ISD::SELECT_CC, Tmp3.getValueType())) { 1909750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman default: assert(0 && "This action is not supported yet!"); 1910750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman case TargetLowering::Legal: break; 1911750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman case TargetLowering::Custom: 1912750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp1 = TLI.LowerOperation(Result, DAG); 1913ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 19149373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 19159373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 19169373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman break; 1917750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman } 19183e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner case ISD::SETCC: 1919750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp1 = Node->getOperand(0); 1920750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp2 = Node->getOperand(1); 1921750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Tmp3 = Node->getOperand(2); 1922bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen LegalizeSetCC(Node->getValueType(0), Tmp1, Tmp2, Tmp3, dl); 1923fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1924fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // If we had to Expand the SetCC operands into a SELECT node, then it may 1925fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // not always be possible to return a true LHS & RHS. In this case, just 1926750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman // return the value we legalized, returned in the LHS 1927ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp2.getNode() == 0) { 1928750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman Result = Tmp1; 19293e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 19303e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner } 1931b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman 193273e142f2b6a3b5223de2d557d646f319ca8168cfChris Lattner switch (TLI.getOperationAction(ISD::SETCC, Tmp1.getValueType())) { 1933456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner default: assert(0 && "Cannot handle this action for SETCC yet!"); 1934456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 1935456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner isCustom = true; 1936456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner // FALLTHROUGH. 1937456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Legal: 19382b49c500838666dd0186d021389d4dd70ffda240Evan Cheng Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3); 1939456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner if (isCustom) { 19402b49c500838666dd0186d021389d4dd70ffda240Evan Cheng Tmp4 = TLI.LowerOperation(Result, DAG); 1941ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp4.getNode()) Result = Tmp4; 1942456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner } 1943b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1944ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth case TargetLowering::Promote: { 1945ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // First step, figure out the appropriate operation to use. 1946ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Allow SETCC to not be supported for all legal data types 1947ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Mostly this targets FP 194883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NewInTy = Node->getOperand(0).getValueType(); 194983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT OldVT = NewInTy; OldVT = OldVT; 1950ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 1951ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // Scan for the appropriate larger type to use. 1952ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth while (1) { 195383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands NewInTy = (MVT::SimpleValueType)(NewInTy.getSimpleVT()+1); 1954ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth 195583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(NewInTy.isInteger() == OldVT.isInteger() && 1956ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth "Fell off of the edge of the integer world"); 195783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(NewInTy.isFloatingPoint() == OldVT.isFloatingPoint() && 1958ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth "Fell off of the edge of the floating point world"); 1959fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1960ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth // If the target supports SETCC of this type, use it. 1961f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman if (TLI.isOperationLegalOrCustom(ISD::SETCC, NewInTy)) 1962ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth break; 1963ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 196483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands if (NewInTy.isInteger()) 1965ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth assert(0 && "Cannot promote Legal Integer SETCC yet"); 1966ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth else { 1967ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::FP_EXTEND, dl, NewInTy, Tmp1); 1968ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::FP_EXTEND, dl, NewInTy, Tmp2); 1969ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 1970c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp1 = LegalizeOp(Tmp1); 1971c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Tmp2 = LegalizeOp(Tmp2); 19722b49c500838666dd0186d021389d4dd70ffda240Evan Cheng Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3); 1973433f8acefb78f1c8a2cf79c12b101ce7c4b20202Evan Cheng Result = LegalizeOp(Result); 19745e3efbc2ca459621400211f7370d7f121d4827d9Andrew Lenharth break; 1975ae35575957a3ab446e2766aa05d03020ced27d14Andrew Lenharth } 1976b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman case TargetLowering::Expand: 1977b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // Expand a setcc node into a select_cc of the same condition, lhs, and 1978b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman // rhs that selects between const 1 (true) and const 0 (false). 197983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 1980fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getNode(ISD::SELECT_CC, dl, VT, Tmp1, Tmp2, 1981b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman DAG.getConstant(1, VT), DAG.getConstant(0, VT), 19822b49c500838666dd0186d021389d4dd70ffda240Evan Cheng Tmp3); 1983b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman break; 1984b942a3dd5f9318b2c57f137d2991440c2f0262adNate Begeman } 19853e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner break; 19862c8086f4b9916b2d02842be5e375276023225fbaChris Lattner 19872c8086f4b9916b2d02842be5e375276023225fbaChris Lattner // Binary operators 1988a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner case ISD::FCOPYSIGN: // FCOPYSIGN does not require LHS/RHS to match type! 1989a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 1990957bffaeca6a0e2ccc684d753df1d87e8e053fe2Eli Friedman Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the RHS. 1991fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1992a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); 1993fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1994a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 1995a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner default: assert(0 && "Operation not supported"); 1996a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner case TargetLowering::Custom: 1997a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner Tmp1 = TLI.LowerOperation(Result, DAG); 1998ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 19998f4191d61978529e9e9d7ddc24dbcd528ef7dd4cChris Lattner break; 2000a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner case TargetLowering::Legal: break; 2001912095becac923ff614d7b07728eb345ada67765Evan Cheng case TargetLowering::Expand: { 2002ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman assert((Tmp2.getValueType() == MVT::f32 || 200357f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman Tmp2.getValueType() == MVT::f64) && 2004ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman "Ugly special-cased code!"); 2005ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman // Get the sign bit of the RHS. 200657f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman SDValue SignBit; 200757f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman MVT IVT = Tmp2.getValueType() == MVT::f64 ? MVT::i64 : MVT::i32; 200857f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman if (isTypeLegal(IVT)) { 200957f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman SignBit = DAG.getNode(ISD::BIT_CONVERT, dl, IVT, Tmp2); 201057f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman } else { 201157f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman assert(isTypeLegal(TLI.getPointerTy()) && 201257f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman (TLI.getPointerTy() == MVT::i32 || 201357f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman TLI.getPointerTy() == MVT::i64) && 201457f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman "Legal type for load?!"); 201557f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman SDValue StackPtr = DAG.CreateStackTemporary(Tmp2.getValueType()); 201657f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman SDValue StorePtr = StackPtr, LoadPtr = StackPtr; 201757f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman SDValue Ch = 201857f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman DAG.getStore(DAG.getEntryNode(), dl, Tmp2, StorePtr, NULL, 0); 201957f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman if (Tmp2.getValueType() == MVT::f64 && TLI.isLittleEndian()) 202057f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman LoadPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), 202157f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman LoadPtr, DAG.getIntPtrConstant(4)); 202257f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman SignBit = DAG.getExtLoad(ISD::SEXTLOAD, dl, TLI.getPointerTy(), 202357f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman Ch, LoadPtr, NULL, 0, MVT::i32); 202457f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman } 202557f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman SignBit = 202657f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman DAG.getSetCC(dl, TLI.getSetCCResultType(SignBit.getValueType()), 202757f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman SignBit, DAG.getConstant(0, SignBit.getValueType()), 202857f1a4bc40e9103cd41cf541b9d6a73b92f0acbaEli Friedman ISD::SETLT); 2029ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman // Get the absolute value of the result. 2030ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman SDValue AbsVal = DAG.getNode(ISD::FABS, dl, Tmp1.getValueType(), Tmp1); 2031ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman // Select between the nabs and abs value based on the sign bit of 2032ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman // the input. 2033ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman Result = DAG.getNode(ISD::SELECT, dl, AbsVal.getValueType(), SignBit, 2034ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman DAG.getNode(ISD::FNEG, dl, AbsVal.getValueType(), 2035ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman AbsVal), 2036ed2f8c557a86612ee14fea25e7be2d3c1445951aEli Friedman AbsVal); 2037912095becac923ff614d7b07728eb345ada67765Evan Cheng Result = LegalizeOp(Result); 2038a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner break; 2039a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner } 2040912095becac923ff614d7b07728eb345ada67765Evan Cheng } 2041a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner break; 2042419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case ISD::BUILD_PAIR: { 204383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT PairTy = Node->getValueType(0); 2044419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman // TODO: handle the case where the Lo and Hi operands are not of legal type 2045419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Lo 2046419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // Hi 2047419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman switch (TLI.getOperationAction(ISD::BUILD_PAIR, PairTy)) { 2048456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Promote: 2049456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 2050456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner assert(0 && "Cannot promote/custom this yet!"); 2051419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Legal: 2052419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) 2053ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::BUILD_PAIR, dl, PairTy, Tmp1, Tmp2); 2054419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 2055419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman case TargetLowering::Expand: 2056ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, PairTy, Tmp1); 2057ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::ANY_EXTEND, dl, PairTy, Tmp2); 2058ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp2 = DAG.getNode(ISD::SHL, dl, PairTy, Tmp2, 205983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(PairTy.getSizeInBits()/2, 2060419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman TLI.getShiftAmountTy())); 2061ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getNode(ISD::OR, dl, PairTy, Tmp1, Tmp2); 2062419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 2063419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman } 2064419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman break; 2065419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman } 2066419f8b62f73541dd783aa98c9eda6e483a487d51Nate Begeman 2067c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::UREM: 2068c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman case ISD::SREM: 2069c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS 2070c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS 2071456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner 2072c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { 2073456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Promote: assert(0 && "Cannot promote this yet!"); 2074456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 2075456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner isCustom = true; 2076456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner // FALLTHROUGH 207757030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth case TargetLowering::Legal: 2078c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); 2079456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner if (isCustom) { 2080456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp1 = TLI.LowerOperation(Result, DAG); 2081ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp1.getNode()) Result = Tmp1; 2082456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner } 208357030e36e41ebd982a24632e7cea5b584b2d49fcAndrew Lenharth break; 2084525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman case TargetLowering::Expand: { 20856b5578f052c2405c0d622192ccacfd47563c99a8Evan Cheng unsigned DivOpc= (Node->getOpcode() == ISD::UREM) ? ISD::UDIV : ISD::SDIV; 208647857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer bool isSigned = DivOpc == ISD::SDIV; 208783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 2088fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2089525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman // See if remainder can be lowered using two-result operations. 2090525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman SDVTList VTs = DAG.getVTList(VT, VT); 2091525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman if (Node->getOpcode() == ISD::SREM && 2092f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman TLI.isOperationLegalOrCustom(ISD::SDIVREM, VT)) { 2093fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = SDValue(DAG.getNode(ISD::SDIVREM, dl, 2094ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen VTs, Tmp1, Tmp2).getNode(), 1); 2095525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman break; 2096525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman } 2097525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman if (Node->getOpcode() == ISD::UREM && 2098f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman TLI.isOperationLegalOrCustom(ISD::UDIVREM, VT)) { 2099ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = SDValue(DAG.getNode(ISD::UDIVREM, dl, 2100ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen VTs, Tmp1, Tmp2).getNode(), 1); 2101525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman break; 2102525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman } 2103525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman 210458c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov if (VT.isInteger() && 210558c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov TLI.getOperationAction(DivOpc, VT) == TargetLowering::Legal) { 210658c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov // X % Y -> X-X/Y*Y 210758c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov Result = DAG.getNode(DivOpc, dl, VT, Tmp1, Tmp2); 210858c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov Result = DAG.getNode(ISD::MUL, dl, VT, Result, Tmp2); 210958c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov Result = DAG.getNode(ISD::SUB, dl, VT, Tmp1, Result); 211058c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov break; 211158c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov } 211258c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov 211358c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov // Check to see if we have a libcall for this operator. 211458c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL; 211558c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov switch (Node->getOpcode()) { 211658c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov default: break; 211758c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov case ISD::UREM: 211858c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov case ISD::SREM: 211958c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov if (VT == MVT::i16) 212058c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov LC = (isSigned ? RTLIB::SREM_I16 : RTLIB::UREM_I16); 212158c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov else if (VT == MVT::i32) 212258c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov LC = (isSigned ? RTLIB::SREM_I32 : RTLIB::UREM_I32); 212358c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov else if (VT == MVT::i64) 212458c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov LC = (isSigned ? RTLIB::SREM_I64 : RTLIB::UREM_I64); 212558c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov else if (VT == MVT::i128) 212658c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov LC = (isSigned ? RTLIB::SREM_I128 : RTLIB::UREM_I128); 212758c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov break; 212858c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov } 212958c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov 213058c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov if (LC != RTLIB::UNKNOWN_LIBCALL) { 213147b41f7e20b6af7aaaf0e050200102d55d038b9dEli Friedman Result = ExpandLibCall(LC, Node, isSigned); 213258c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov break; 2133c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 213458c04e149629956185cdaa3b021793189008c0d2Anton Korobeynikov 213574807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman assert(0 && "Cannot expand this binary operator!"); 2136c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 2137c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman } 2138525178cdbf00720ea8bce297a7d65b0cca0ab439Dan Gohman } 2139c105e19864f2792c52bc6bb765d365308f38f461Nate Begeman break; 2140acc398c195a697795bff3245943d104eb19192b9Nate Begeman case ISD::VAARG: { 2141acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. 2142acc398c195a697795bff3245943d104eb19192b9Nate Begeman Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. 2143acc398c195a697795bff3245943d104eb19192b9Nate Begeman 214483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Node->getValueType(0); 2145acc398c195a697795bff3245943d104eb19192b9Nate Begeman switch (TLI.getOperationAction(Node->getOpcode(), MVT::Other)) { 2146acc398c195a697795bff3245943d104eb19192b9Nate Begeman default: assert(0 && "This action is not supported yet!"); 2147456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner case TargetLowering::Custom: 2148456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner isCustom = true; 2149456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner // FALLTHROUGH 2150acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Legal: 2151c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Node->getOperand(2)); 2152c52ad4f04ea5f51a1b4c67e585acea5c0525fc3dChris Lattner Result = Result.getValue(0); 2153456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp1 = Result.getValue(1); 2154456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner 2155456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner if (isCustom) { 2156456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp2 = TLI.LowerOperation(Result, DAG); 2157ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (Tmp2.getNode()) { 2158456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Result = LegalizeOp(Tmp2); 2159456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp1 = LegalizeOp(Tmp2.getValue(1)); 2160456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner } 2161456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner } 2162acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 2163acc398c195a697795bff3245943d104eb19192b9Nate Begeman case TargetLowering::Expand: { 216469de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman const Value *V = cast<SrcValueSDNode>(Node->getOperand(2))->getValue(); 2165ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue VAList = DAG.getLoad(TLI.getPointerTy(), dl, Tmp1, Tmp2, V, 0); 2166acc398c195a697795bff3245943d104eb19192b9Nate Begeman // Increment the pointer, VAList, to the next vaarg 2167ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp3 = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(), VAList, 2168ceb4d1aecb9deffe59b3dcdc9a783ffde8477be9Duncan Sands DAG.getConstant(TLI.getTargetData()-> 2169777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands getTypeAllocSize(VT.getTypeForMVT()), 2170ceb4d1aecb9deffe59b3dcdc9a783ffde8477be9Duncan Sands TLI.getPointerTy())); 2171acc398c195a697795bff3245943d104eb19192b9Nate Begeman // Store the incremented VAList to the legalized pointer 2172ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Tmp3 = DAG.getStore(VAList.getValue(1), dl, Tmp3, Tmp2, V, 0); 2173acc398c195a697795bff3245943d104eb19192b9Nate Begeman // Load the actual argument out of the pointer VAList 2174ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen Result = DAG.getLoad(VT, dl, Tmp3, VAList, NULL, 0); 2175456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Tmp1 = LegalizeOp(Result.getValue(1)); 2176acc398c195a697795bff3245943d104eb19192b9Nate Begeman Result = LegalizeOp(Result); 2177acc398c195a697795bff3245943d104eb19192b9Nate Begeman break; 2178acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 2179acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 2180fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // Since VAARG produces two values, make sure to remember that we 2181acc398c195a697795bff3245943d104eb19192b9Nate Begeman // legalized both of them. 2182475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 0), Result); 2183475871a144eb604ddaf37503397ba0941442e5fbDan Gohman AddLegalizedOperand(SDValue(Node, 1), Tmp1); 218499a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif return Op.getResNo() ? Tmp1 : Result; 2185acc398c195a697795bff3245943d104eb19192b9Nate Begeman } 218674c376529101acbe141a256d0bf23a44eb454c84Bill Wendling case ISD::SADDO: 218774c376529101acbe141a256d0bf23a44eb454c84Bill Wendling case ISD::SSUBO: { 2188c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling MVT VT = Node->getValueType(0); 2189c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling switch (TLI.getOperationAction(Node->getOpcode(), VT)) { 2190c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling default: assert(0 && "This action not supported for this op yet!"); 2191c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling case TargetLowering::Custom: 2192c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling Result = TLI.LowerOperation(Op, DAG); 2193c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling if (Result.getNode()) break; 2194c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling // FALLTHROUGH 2195c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling case TargetLowering::Legal: { 2196c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling SDValue LHS = LegalizeOp(Node->getOperand(0)); 2197c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling SDValue RHS = LegalizeOp(Node->getOperand(1)); 2198c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling 2199fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel SDValue Sum = DAG.getNode(Node->getOpcode() == ISD::SADDO ? 2200ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen ISD::ADD : ISD::SUB, dl, LHS.getValueType(), 220174c376529101acbe141a256d0bf23a44eb454c84Bill Wendling LHS, RHS); 2202c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling MVT OType = Node->getValueType(1); 2203c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling 2204a6af91ae124d0713cfabcea8c5f508091dd7a556Bill Wendling SDValue Zero = DAG.getConstant(0, LHS.getValueType()); 2205c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling 2206740464e6164e503f3c01d2b13a52c0261042abe0Bill Wendling // LHSSign -> LHS >= 0 2207740464e6164e503f3c01d2b13a52c0261042abe0Bill Wendling // RHSSign -> RHS >= 0 2208740464e6164e503f3c01d2b13a52c0261042abe0Bill Wendling // SumSign -> Sum >= 0 2209740464e6164e503f3c01d2b13a52c0261042abe0Bill Wendling // 221074c376529101acbe141a256d0bf23a44eb454c84Bill Wendling // Add: 2211740464e6164e503f3c01d2b13a52c0261042abe0Bill Wendling // Overflow -> (LHSSign == RHSSign) && (LHSSign != SumSign) 221274c376529101acbe141a256d0bf23a44eb454c84Bill Wendling // Sub: 221374c376529101acbe141a256d0bf23a44eb454c84Bill Wendling // Overflow -> (LHSSign != RHSSign) && (LHSSign != SumSign) 2214740464e6164e503f3c01d2b13a52c0261042abe0Bill Wendling // 2215ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue LHSSign = DAG.getSetCC(dl, OType, LHS, Zero, ISD::SETGE); 2216ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue RHSSign = DAG.getSetCC(dl, OType, RHS, Zero, ISD::SETGE); 2217fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel SDValue SignsMatch = DAG.getSetCC(dl, OType, LHSSign, RHSSign, 2218fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Node->getOpcode() == ISD::SADDO ? 221974c376529101acbe141a256d0bf23a44eb454c84Bill Wendling ISD::SETEQ : ISD::SETNE); 2220740464e6164e503f3c01d2b13a52c0261042abe0Bill Wendling 2221ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue SumSign = DAG.getSetCC(dl, OType, Sum, Zero, ISD::SETGE); 2222ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue SumSignNE = DAG.getSetCC(dl, OType, LHSSign, SumSign, ISD::SETNE); 2223740464e6164e503f3c01d2b13a52c0261042abe0Bill Wendling 2224ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue Cmp = DAG.getNode(ISD::AND, dl, OType, SignsMatch, SumSignNE); 2225c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling 2226c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling MVT ValueVTs[] = { LHS.getValueType(), OType }; 2227c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling SDValue Ops[] = { Sum, Cmp }; 2228c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling 2229fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getNode(ISD::MERGE_VALUES, dl, 2230ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen DAG.getVTList(&ValueVTs[0], 2), 2231aaffa05d0a652dd3eae76a941d02d6b0469fa821Duncan Sands &Ops[0], 2); 2232c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling SDNode *RNode = Result.getNode(); 2233c23e4968790395053f3f52aeb3342637fcaafdbfDan Gohman DAG.ReplaceAllUsesWith(Node, RNode); 2234c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling break; 2235c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling } 2236c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling } 2237c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling 2238c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling break; 2239c0062fb7557c9f4eb66b7d8fa7b6b0c765e579b8Bill Wendling } 224074c376529101acbe141a256d0bf23a44eb454c84Bill Wendling case ISD::UADDO: 224174c376529101acbe141a256d0bf23a44eb454c84Bill Wendling case ISD::USUBO: { 224241ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling MVT VT = Node->getValueType(0); 224341ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling switch (TLI.getOperationAction(Node->getOpcode(), VT)) { 224441ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling default: assert(0 && "This action not supported for this op yet!"); 224541ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling case TargetLowering::Custom: 224641ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling Result = TLI.LowerOperation(Op, DAG); 224741ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling if (Result.getNode()) break; 224841ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling // FALLTHROUGH 224941ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling case TargetLowering::Legal: { 225041ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling SDValue LHS = LegalizeOp(Node->getOperand(0)); 225141ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling SDValue RHS = LegalizeOp(Node->getOperand(1)); 225241ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling 225374c376529101acbe141a256d0bf23a44eb454c84Bill Wendling SDValue Sum = DAG.getNode(Node->getOpcode() == ISD::UADDO ? 2254ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen ISD::ADD : ISD::SUB, dl, LHS.getValueType(), 225574c376529101acbe141a256d0bf23a44eb454c84Bill Wendling LHS, RHS); 225641ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling MVT OType = Node->getValueType(1); 2257ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen SDValue Cmp = DAG.getSetCC(dl, OType, Sum, LHS, 2258fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Node->getOpcode () == ISD::UADDO ? 225974c376529101acbe141a256d0bf23a44eb454c84Bill Wendling ISD::SETULT : ISD::SETUGT); 226041ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling 226141ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling MVT ValueVTs[] = { LHS.getValueType(), OType }; 226241ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling SDValue Ops[] = { Sum, Cmp }; 226341ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling 2264fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Result = DAG.getNode(ISD::MERGE_VALUES, dl, 2265ca57b84729303d6f0c5abf951563efcde97010cdDale Johannesen DAG.getVTList(&ValueVTs[0], 2), 2266aaffa05d0a652dd3eae76a941d02d6b0469fa821Duncan Sands &Ops[0], 2); 226741ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling SDNode *RNode = Result.getNode(); 2268c23e4968790395053f3f52aeb3342637fcaafdbfDan Gohman DAG.ReplaceAllUsesWith(Node, RNode); 226941ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling break; 227041ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling } 227141ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling } 227241ea7e7eb3a6a269f2bfed0bdc191ea046d18e5eBill Wendling 22738ac0d4b4fb10406278cd600214cd3ee6d76620cdBill Wendling break; 22748ac0d4b4fb10406278cd600214cd3ee6d76620cdBill Wendling } 227545b8caf1c5a1fd8337038d64c6da8fba2d299fdfChris Lattner } 2276fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 22774ddd283f6928fc337c1bf3277566d7b31526e8d9Chris Lattner assert(Result.getValueType() == Op.getValueType() && 22784ddd283f6928fc337c1bf3277566d7b31526e8d9Chris Lattner "Bad legalization!"); 2279fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2280456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner // Make sure that the generated code is itself legal. 2281456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner if (Result != Op) 2282456a93afcec7740c45cafa8354317f7b17987a6dChris Lattner Result = LegalizeOp(Result); 22833e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 228445982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // Note that LegalizeOp may be reentered even from single-use nodes, which 228545982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner // means that we always must cache transformed nodes. 228645982dad53cd184fe8947a1b0206b0b16964f359Chris Lattner AddLegalizedOperand(Op, Result); 22873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner return Result; 22883e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 22893e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 22903d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli FriedmanSDValue SelectionDAGLegalize::ExpandExtractFromVectorThroughStack(SDValue Op) { 22913d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman SDValue Vec = Op.getOperand(0); 22923d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman SDValue Idx = Op.getOperand(1); 22933d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman DebugLoc dl = Op.getDebugLoc(); 22943d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman // Store the value to a temporary stack slot, then LOAD the returned part. 22953d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman SDValue StackPtr = DAG.CreateStackTemporary(Vec.getValueType()); 22963d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr, NULL, 0); 22973d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman 22983d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman // Add the offset to the index. 22992a35b1c54ba55a917e01e0043efcf67e20505953Eli Friedman unsigned EltSize = 23002a35b1c54ba55a917e01e0043efcf67e20505953Eli Friedman Vec.getValueType().getVectorElementType().getSizeInBits()/8; 23013d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman Idx = DAG.getNode(ISD::MUL, dl, Idx.getValueType(), Idx, 23023d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman DAG.getConstant(EltSize, Idx.getValueType())); 23033d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman 23043d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman if (Idx.getValueType().bitsGT(TLI.getPointerTy())) 23053d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman Idx = DAG.getNode(ISD::TRUNCATE, dl, TLI.getPointerTy(), Idx); 23063d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman else 23073d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman Idx = DAG.getNode(ISD::ZERO_EXTEND, dl, TLI.getPointerTy(), Idx); 23083d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman 23093d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman StackPtr = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, StackPtr); 23103d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman 23113d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman return DAG.getLoad(Op.getValueType(), dl, Ch, StackPtr, NULL, 0); 23123d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman} 23133d43b3f6d7e1d3516052f20bf2d14727ebddb8ffEli Friedman 2314750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman/// LegalizeSetCCOperands - Attempts to create a legal LHS and RHS for a SETCC 2315750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman/// with condition CC on the current target. This usually involves legalizing 2316750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman/// or promoting the arguments. In the case where LHS and RHS must be expanded, 2317750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman/// there may be no choice but to create a new SetCC node to represent the 2318750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman/// legalized value of setcc lhs, rhs. In this case, the value is returned in 2319475871a144eb604ddaf37503397ba0941442e5fbDan Gohman/// LHS, and the SDValue returned in RHS has a nil SDNode value. 2320475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid SelectionDAGLegalize::LegalizeSetCCOperands(SDValue &LHS, 2321475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &RHS, 2322bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue &CC, 2323bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl) { 232474807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman LHS = LegalizeOp(LHS); 232574807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman RHS = LegalizeOp(RHS); 232674807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman} 2327750ac1bdfa6f09bddfd9efce1d6360dde8fa74c0Nate Begeman 23287f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng/// LegalizeSetCCCondCode - Legalize a SETCC with given LHS and RHS and 23297f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng/// condition code CC on the current target. This routine assumes LHS and rHS 23307f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng/// have already been legalized by LegalizeSetCCOperands. It expands SETCC with 23317f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng/// illegal condition code into AND / OR of multiple SETCC values. 23327f042681764c6f8eae22781d8b4cb4c218a86b76Evan Chengvoid SelectionDAGLegalize::LegalizeSetCCCondCode(MVT VT, 23337f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng SDValue &LHS, SDValue &RHS, 2334bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue &CC, 2335bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen DebugLoc dl) { 23367f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng MVT OpVT = LHS.getValueType(); 23377f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng ISD::CondCode CCCode = cast<CondCodeSDNode>(CC)->get(); 23387f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng switch (TLI.getCondCodeAction(CCCode, OpVT)) { 23397f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng default: assert(0 && "Unknown condition code action!"); 23407f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng case TargetLowering::Legal: 23417f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng // Nothing to do. 23427f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng break; 23437f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng case TargetLowering::Expand: { 23447f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng ISD::CondCode CC1 = ISD::SETCC_INVALID, CC2 = ISD::SETCC_INVALID; 23457f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng unsigned Opc = 0; 23467f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng switch (CCCode) { 23477f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng default: assert(0 && "Don't know how to expand this condition!"); abort(); 2348e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETOEQ: CC1 = ISD::SETEQ; CC2 = ISD::SETO; Opc = ISD::AND; break; 2349e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETOGT: CC1 = ISD::SETGT; CC2 = ISD::SETO; Opc = ISD::AND; break; 2350e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETOGE: CC1 = ISD::SETGE; CC2 = ISD::SETO; Opc = ISD::AND; break; 2351e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETOLT: CC1 = ISD::SETLT; CC2 = ISD::SETO; Opc = ISD::AND; break; 2352e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETOLE: CC1 = ISD::SETLE; CC2 = ISD::SETO; Opc = ISD::AND; break; 2353e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETONE: CC1 = ISD::SETNE; CC2 = ISD::SETO; Opc = ISD::AND; break; 2354e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETUEQ: CC1 = ISD::SETEQ; CC2 = ISD::SETUO; Opc = ISD::OR; break; 2355e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETUGT: CC1 = ISD::SETGT; CC2 = ISD::SETUO; Opc = ISD::OR; break; 2356e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETUGE: CC1 = ISD::SETGE; CC2 = ISD::SETUO; Opc = ISD::OR; break; 2357e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETULT: CC1 = ISD::SETLT; CC2 = ISD::SETUO; Opc = ISD::OR; break; 2358e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETULE: CC1 = ISD::SETLE; CC2 = ISD::SETUO; Opc = ISD::OR; break; 2359e7d238ea239e6ab8a2c60ecd27468f3cfc1bb08bDan Gohman case ISD::SETUNE: CC1 = ISD::SETNE; CC2 = ISD::SETUO; Opc = ISD::OR; break; 23607f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng // FIXME: Implement more expansions. 23617f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng } 23627f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng 2363bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue SetCC1 = DAG.getSetCC(dl, VT, LHS, RHS, CC1); 2364bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen SDValue SetCC2 = DAG.getSetCC(dl, VT, LHS, RHS, CC2); 2365bb5da918545efb54857a09c983a5a7f22a7e04d4Dale Johannesen LHS = DAG.getNode(Opc, dl, VT, SetCC1, SetCC2); 23667f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng RHS = SDValue(); 23677f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng CC = SDValue(); 23687f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng break; 23697f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng } 23707f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng } 23717f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng} 23727f042681764c6f8eae22781d8b4cb4c218a86b76Evan Cheng 23731401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner/// EmitStackConvert - Emit a store/load combination to the stack. This stores 23741401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner/// SrcOp to a stack slot of type SlotVT, truncating it if needed. It then does 23751401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner/// a load from the stack slot to DestVT, extending it if needed. 23761401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner/// The resultant code need not be legal. 2377475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::EmitStackConvert(SDValue SrcOp, 2378475871a144eb604ddaf37503397ba0941442e5fbDan Gohman MVT SlotVT, 23798a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen MVT DestVT, 23808a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DebugLoc dl) { 238135481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner // Create the stack frame object. 2382ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson unsigned SrcAlign = 2383ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson TLI.getTargetData()->getPrefTypeAlignment(SrcOp.getValueType(). 2384ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson getTypeForMVT()); 2385475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue FIPtr = DAG.CreateStackTemporary(SlotVT, SrcAlign); 2386fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2387bbbbb9c3dd4160990f856854d16a3beaead1f354Dan Gohman FrameIndexSDNode *StackPtrFI = cast<FrameIndexSDNode>(FIPtr); 238869de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman int SPFI = StackPtrFI->getIndex(); 238915b3830bcda4f9958abf1c65e6e1c64c5cbb484dDan Gohman const Value *SV = PseudoSourceValue::getFixedStack(SPFI); 239015b3830bcda4f9958abf1c65e6e1c64c5cbb484dDan Gohman 239183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned SrcSize = SrcOp.getValueType().getSizeInBits(); 239283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned SlotSize = SlotVT.getSizeInBits(); 239383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned DestSize = DestVT.getSizeInBits(); 2394ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson unsigned DestAlign = 2395ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson TLI.getTargetData()->getPrefTypeAlignment(DestVT.getTypeForMVT()); 2396fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 23971401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner // Emit a store to the stack slot. Use a truncstore if the input value is 23981401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner // later than DestVT. 2399475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Store; 2400fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 24011401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner if (SrcSize > SlotSize) 24028a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Store = DAG.getTruncStore(DAG.getEntryNode(), dl, SrcOp, FIPtr, 240315b3830bcda4f9958abf1c65e6e1c64c5cbb484dDan Gohman SV, 0, SlotVT, false, SrcAlign); 24041401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner else { 24051401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner assert(SrcSize == SlotSize && "Invalid store"); 24068a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Store = DAG.getStore(DAG.getEntryNode(), dl, SrcOp, FIPtr, 240715b3830bcda4f9958abf1c65e6e1c64c5cbb484dDan Gohman SV, 0, false, SrcAlign); 24081401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner } 2409fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 241035481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner // Result is a load from the stack slot. 24111401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner if (SlotSize == DestSize) 24128a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getLoad(DestVT, dl, Store, FIPtr, SV, 0, false, DestAlign); 2413fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 24141401d15c99b284ead81b8476a6db95328c5f28fdChris Lattner assert(SlotSize < DestSize && "Unknown extension!"); 24158a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getExtLoad(ISD::EXTLOAD, dl, DestVT, Store, FIPtr, SV, 0, SlotVT, 2416364d73ddab43b699ab90240f11b7a2eb5cf69bd8Mon P Wang false, DestAlign); 241735481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner} 241835481892da1e5634bf497c8a0cabb1bb5a8b8fefChris Lattner 2419475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::ExpandSCALAR_TO_VECTOR(SDNode *Node) { 24208a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DebugLoc dl = Node->getDebugLoc(); 24214352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner // Create a vector sized/aligned stack slot, store the value to element #0, 24224352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner // then load the whole vector back out. 2423475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue StackPtr = DAG.CreateStackTemporary(Node->getValueType(0)); 242469de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman 2425bbbbb9c3dd4160990f856854d16a3beaead1f354Dan Gohman FrameIndexSDNode *StackPtrFI = cast<FrameIndexSDNode>(StackPtr); 242669de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman int SPFI = StackPtrFI->getIndex(); 242769de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman 2428b10b5ac8d9da43ca2db61401a20af6b676c98438Duncan Sands SDValue Ch = DAG.getTruncStore(DAG.getEntryNode(), dl, Node->getOperand(0), 2429b10b5ac8d9da43ca2db61401a20af6b676c98438Duncan Sands StackPtr, 2430b10b5ac8d9da43ca2db61401a20af6b676c98438Duncan Sands PseudoSourceValue::getFixedStack(SPFI), 0, 2431b10b5ac8d9da43ca2db61401a20af6b676c98438Duncan Sands Node->getValueType(0).getVectorElementType()); 24328a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getLoad(Node->getValueType(0), dl, Ch, StackPtr, 2433a54cf176613f9ae8301519a61b8935652c0fb8aeDan Gohman PseudoSourceValue::getFixedStack(SPFI), 0); 24344352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner} 24354352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner 24364352cc9e217e4482ad53f5a7b92c3543f569eb6eChris Lattner 2437ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner/// ExpandBUILD_VECTOR - Expand a BUILD_VECTOR node on targets that don't 243807a96765daedf180a7102d39fe56c499878312b7Dan Gohman/// support the operation, but do support the resultant vector type. 2439475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::ExpandBUILD_VECTOR(SDNode *Node) { 244026cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson unsigned NumElems = Node->getNumOperands(); 244126cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson SDValue SplatValue = Node->getOperand(0); 244226cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson DebugLoc dl = Node->getDebugLoc(); 244326cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson MVT VT = Node->getValueType(0); 244426cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson MVT OpVT = SplatValue.getValueType(); 244526cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson MVT EltVT = VT.getVectorElementType(); 2446fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2447fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // If the only non-undef value is the low element, turn this into a 244887100e0b83b808757bf44dabecd1d1048255d1adChris Lattner // SCALAR_TO_VECTOR node. If this is { X, X, X, X }, determine X. 2449ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner bool isOnlyLowElement = true; 2450fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2451475871a144eb604ddaf37503397ba0941442e5fbDan Gohman // FIXME: it would be far nicer to change this into map<SDValue,uint64_t> 2452f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner // and use a bitmask instead of a list of elements. 24539008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman // FIXME: this doesn't treat <0, u, 0, u> for example, as a splat. 2454475871a144eb604ddaf37503397ba0941442e5fbDan Gohman std::map<SDValue, std::vector<unsigned> > Values; 2455033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng Values[SplatValue].push_back(0); 24562eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner bool isConstant = true; 24572eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner if (!isa<ConstantFPSDNode>(SplatValue) && !isa<ConstantSDNode>(SplatValue) && 24582eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner SplatValue.getOpcode() != ISD::UNDEF) 24592eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner isConstant = false; 2460fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2461033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng for (unsigned i = 1; i < NumElems; ++i) { 2462475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue V = Node->getOperand(i); 246389a1b380a475cbe477e50ff4b94335596b37f21aChris Lattner Values[V].push_back(i); 2464033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng if (V.getOpcode() != ISD::UNDEF) 2465ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner isOnlyLowElement = false; 2466033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng if (SplatValue != V) 2467ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson SplatValue = SDValue(0, 0); 24682eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner 24692eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner // If this isn't a constant element or an undef, we can't use a constant 24702eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner // pool load. 24712eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner if (!isa<ConstantFPSDNode>(V) && !isa<ConstantSDNode>(V) && 24722eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner V.getOpcode() != ISD::UNDEF) 24732eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner isConstant = false; 2474ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } 2475fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2476ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner if (isOnlyLowElement) { 2477ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // If the low element is an undef too, then this whole things is an undef. 2478ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner if (Node->getOperand(0).getOpcode() == ISD::UNDEF) 247926cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson return DAG.getUNDEF(VT); 2480ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // Otherwise, turn this into a scalar_to_vector node. 248126cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Node->getOperand(0)); 2482ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } 2483fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 24842eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner // If all elements are constants, create a load from the constant pool. 2485ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner if (isConstant) { 2486ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner std::vector<Constant*> CV; 2487033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng for (unsigned i = 0, e = NumElems; i != e; ++i) { 2488fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel if (ConstantFPSDNode *V = 2489ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner dyn_cast<ConstantFPSDNode>(Node->getOperand(i))) { 24904fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman CV.push_back(const_cast<ConstantFP *>(V->getConstantFPValue())); 2491fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel } else if (ConstantSDNode *V = 2492ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson dyn_cast<ConstantSDNode>(Node->getOperand(i))) { 24934fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman CV.push_back(const_cast<ConstantInt *>(V->getConstantIntValue())); 2494ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } else { 2495ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner assert(Node->getOperand(i).getOpcode() == ISD::UNDEF); 249626cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson const Type *OpNTy = OpVT.getTypeForMVT(); 2497ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner CV.push_back(UndefValue::get(OpNTy)); 2498ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } 2499ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } 25009d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer Constant *CP = ConstantVector::get(CV); 2501475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue CPIdx = DAG.getConstantPool(CP, TLI.getPointerTy()); 25021606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned Alignment = cast<ConstantPoolSDNode>(CPIdx)->getAlignment(); 25038a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx, 250450284d81f863a6576582e1a171a22eb0f012ddf3Dan Gohman PseudoSourceValue::getConstantPool(), 0, 250550284d81f863a6576582e1a171a22eb0f012ddf3Dan Gohman false, Alignment); 2506ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } 2507fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2508ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif if (SplatValue.getNode()) { // Splat of one value? 25092eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner // Build the shuffle constant vector: <0, 0, 0, 0> 25109008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman SmallVector<int, 8> ZeroVec(NumElems, 0); 2511033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng 25122eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner // If the target supports VECTOR_SHUFFLE and this shuffle mask, use it. 25139008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman if (TLI.isShuffleMaskLegal(ZeroVec, Node->getValueType(0))) { 25142eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner // Get the splatted value into the low element of a vector register. 2515fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel SDValue LowValVec = 251626cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, SplatValue); 2517fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 25182eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner // Return shuffle(LowValVec, undef, <0,0,0,0>) 25199008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman return DAG.getVectorShuffle(VT, dl, LowValVec, DAG.getUNDEF(VT), 25209008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman &ZeroVec[0]); 25212eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner } 25222eb8653157ccd318b357af74bfd517c76ef166b8Chris Lattner } 2523fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2524033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng // If there are only two unique elements, we may be able to turn this into a 2525033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng // vector shuffle. 2526033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng if (Values.size() == 2) { 2527f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner // Get the two values in deterministic order. 2528475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Val1 = Node->getOperand(1); 2529475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Val2; 2530475871a144eb604ddaf37503397ba0941442e5fbDan Gohman std::map<SDValue, std::vector<unsigned> >::iterator MI = Values.begin(); 2531f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner if (MI->first != Val1) 2532f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner Val2 = MI->first; 2533f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner else 2534f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner Val2 = (++MI)->first; 2535fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2536ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson // If Val1 is an undef, make sure it ends up as Val2, to ensure that our 2537f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner // vector shuffle has the undef vector on the RHS. 2538f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner if (Val1.getOpcode() == ISD::UNDEF) 2539f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner std::swap(Val1, Val2); 2540fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2541033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng // Build the shuffle constant vector: e.g. <0, 4, 0, 4> 25429008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman SmallVector<int, 8> ShuffleMask(NumElems, -1); 2543f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner 2544f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner // Set elements of the shuffle mask for Val1. 2545f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner std::vector<unsigned> &Val1Elts = Values[Val1]; 2546f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner for (unsigned i = 0, e = Val1Elts.size(); i != e; ++i) 25479008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman ShuffleMask[Val1Elts[i]] = 0; 2548f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner 2549f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner // Set elements of the shuffle mask for Val2. 2550f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner std::vector<unsigned> &Val2Elts = Values[Val2]; 2551f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner for (unsigned i = 0, e = Val2Elts.size(); i != e; ++i) 2552f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner if (Val2.getOpcode() != ISD::UNDEF) 25539008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman ShuffleMask[Val2Elts[i]] = NumElems; 2554033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng 2555f9d95c8835bc4f9072c33e1f9ebaa581a4d3268dChris Lattner // If the target supports SCALAR_TO_VECTOR and this shuffle mask, use it. 255626cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson if (TLI.isOperationLegalOrCustom(ISD::SCALAR_TO_VECTOR, VT) && 25579008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman TLI.isShuffleMaskLegal(ShuffleMask, VT)) { 255826cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson Val1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Val1); 255926cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson Val2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Val2); 25609008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman return DAG.getVectorShuffle(VT, dl, Val1, Val2, &ShuffleMask[0]); 2561033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng } 2562033e6816668da71ff0866a61f5c0a7e7e795d069Evan Cheng } 2563fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2564ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // Otherwise, we can't handle this case efficiently. Allocate a sufficiently 2565ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // aligned object on the stack, store each element into it, then load 2566ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // the result as a vector. 2567ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // Create the stack frame object. 2568475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue FIPtr = DAG.CreateStackTemporary(VT); 256915b3830bcda4f9958abf1c65e6e1c64c5cbb484dDan Gohman int FI = cast<FrameIndexSDNode>(FIPtr.getNode())->getIndex(); 257015b3830bcda4f9958abf1c65e6e1c64c5cbb484dDan Gohman const Value *SV = PseudoSourceValue::getFixedStack(FI); 257115b3830bcda4f9958abf1c65e6e1c64c5cbb484dDan Gohman 2572ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // Emit a store of each element to the stack slot. 2573475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 8> Stores; 257426cbf9eb99c779b8992f4865c6cf308318d39723Bob Wilson unsigned TypeByteSize = OpVT.getSizeInBits() / 8; 2575ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // Store (in the right endianness) the elements to memory. 2576ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 2577ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // Ignore undef elements. 2578ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner if (Node->getOperand(i).getOpcode() == ISD::UNDEF) continue; 2579fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2580841c882f5dae8c953ea99b5824108313549cfaf8Chris Lattner unsigned Offset = TypeByteSize*i; 2581fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2582475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Idx = DAG.getConstant(Offset, FIPtr.getValueType()); 25838a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Idx = DAG.getNode(ISD::ADD, dl, FIPtr.getValueType(), FIPtr, Idx); 2584fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 25858a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Stores.push_back(DAG.getStore(DAG.getEntryNode(), dl, Node->getOperand(i), 25868a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Idx, SV, Offset)); 2587ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner } 2588fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2589475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue StoreChain; 2590ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner if (!Stores.empty()) // Not all undef elements? 25918a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen StoreChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, 2592bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &Stores[0], Stores.size()); 2593ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner else 2594ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner StoreChain = DAG.getEntryNode(); 2595fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 2596ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner // Result is a load from the stack slot. 25978a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getLoad(VT, dl, StoreChain, FIPtr, SV, 0); 2598ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner} 2599ce87215131efcc68dcf7fca61055ad783a7aeb0eChris Lattner 260077e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// ExpandLibCall - Expand a node into a call to a libcall. If the result value 260177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// does not fit into a register, return the lo part and set the hi part to the 260277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// by-reg argument. If it does fit into a single register, return the result 260377e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner// and leave the Hi part unset. 2604475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::ExpandLibCall(RTLIB::Libcall LC, SDNode *Node, 260547b41f7e20b6af7aaaf0e050200102d55d038b9dEli Friedman bool isSigned) { 26066831a815999dde4cf801e2076e66b4943964daf2Chris Lattner assert(!IsLegalizingCall && "Cannot overlap legalization of calls!"); 2607fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel // The input chain to this libcall is the entry node of the function. 26086831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Legalizing the call will automatically add the previous call to the 26096831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // dependence. 2610475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue InChain = DAG.getEntryNode(); 2611fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 261277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner TargetLowering::ArgListTy Args; 261347857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TargetLowering::ArgListEntry Entry; 261477e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { 261583ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT ArgVT = Node->getOperand(i).getValueType(); 261683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands const Type *ArgTy = ArgVT.getTypeForMVT(); 2617fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Entry.Node = Node->getOperand(i); Entry.Ty = ArgTy; 2618d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Entry.isSExt = isSigned; 261900fee65fd21f9615d1a604b8b7d42cd16a3f6b47Duncan Sands Entry.isZExt = !isSigned; 262047857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Args.push_back(Entry); 262177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner } 2622056292fd738924f3f7703725d8f630983794b5a5Bill Wendling SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC), 26230c39719bfc7d0b3e61fbd55e1115184a1d5f6ae7Mon P Wang TLI.getPointerTy()); 2624edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 26250d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner // Splice the libcall in wherever FindInputOutputChains tells us to. 262683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands const Type *RetTy = Node->getValueType(0).getTypeForMVT(); 2627ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson std::pair<SDValue, SDValue> CallInfo = 262886098bd6a63d2cdf0c9be9ef3151bd2728281fd7Dale Johannesen TLI.LowerCallTo(InChain, RetTy, isSigned, !isSigned, false, false, 26297d2ad624fa749a6d3edac0d94e9c107989c16304Dale Johannesen CallingConv::C, false, Callee, Args, DAG, 26307d2ad624fa749a6d3edac0d94e9c107989c16304Dale Johannesen Node->getDebugLoc()); 26310d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 26326831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // Legalize the call sequence, starting with the chain. This will advance 26336831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // the LastCALLSEQ_END to the legalized version of the CALLSEQ_END node that 26346831a815999dde4cf801e2076e66b4943964daf2Chris Lattner // was added by LowerCallTo (guaranteeing proper serialization of calls). 26356831a815999dde4cf801e2076e66b4943964daf2Chris Lattner LegalizeOp(CallInfo.second); 263674807f2520715056be399a2bc59dfc8b6f8f3eb2Eli Friedman return CallInfo.first; 263722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner} 263822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 2639f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli FriedmanSDValue SelectionDAGLegalize::ExpandFPLibCall(SDNode* Node, 2640f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_F32, 2641f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_F64, 2642f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_F80, 2643f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_PPCF128) { 2644f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall LC; 2645f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman switch (Node->getValueType(0).getSimpleVT()) { 2646f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman default: assert(0 && "Unexpected request for libcall!"); 2647f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case MVT::f32: LC = Call_F32; break; 2648f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case MVT::f64: LC = Call_F64; break; 2649f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case MVT::f80: LC = Call_F80; break; 2650f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case MVT::ppcf128: LC = Call_PPCF128; break; 2651f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman } 2652f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman return ExpandLibCall(LC, Node, false); 2653f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman} 2654f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman 2655f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli FriedmanSDValue SelectionDAGLegalize::ExpandIntLibCall(SDNode* Node, bool isSigned, 2656f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_I16, 2657f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_I32, 2658f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_I64, 2659f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall Call_I128) { 2660f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::Libcall LC; 2661f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman switch (Node->getValueType(0).getSimpleVT()) { 2662f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman default: assert(0 && "Unexpected request for libcall!"); 2663f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case MVT::i16: LC = Call_I16; break; 2664f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case MVT::i32: LC = Call_I32; break; 2665f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case MVT::i64: LC = Call_I64; break; 2666f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case MVT::i128: LC = Call_I128; break; 2667f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman } 2668f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman return ExpandLibCall(LC, Node, isSigned); 2669f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman} 2670f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman 267122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// ExpandLegalINT_TO_FP - This function is responsible for legalizing a 267222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// INT_TO_FP operation of the specified operand when the target requests that 267322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// we expand it. At this point, we know that the result and operand types are 267422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// legal for the target. 2675475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::ExpandLegalINT_TO_FP(bool isSigned, 2676475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op0, 2677af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen MVT DestVT, 2678af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl) { 267922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (Op0.getValueType() == MVT::i32) { 268022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // simple 32-bit [signed|unsigned] integer to float/double expansion 2681fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 268223594d4537fb88a963c6d6993af5027eac9bfbacChris Lattner // Get the stack frame index of a 8 byte buffer. 2683475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue StackSlot = DAG.CreateStackTemporary(MVT::f64); 2684fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 268522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // word offset constant for Hi/Lo address computation 2686475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue WordOff = DAG.getConstant(sizeof(int), TLI.getPointerTy()); 268722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // set up Hi and Lo (into buffer) address based on endian 2688475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Hi = StackSlot; 2689fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel SDValue Lo = DAG.getNode(ISD::ADD, dl, 2690ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson TLI.getPointerTy(), StackSlot, WordOff); 2691408c428096df3a3970a8387f9dd258ae948663a6Chris Lattner if (TLI.isLittleEndian()) 2692408c428096df3a3970a8387f9dd258ae948663a6Chris Lattner std::swap(Hi, Lo); 2693fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 269422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // if signed map to unsigned space 2695475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op0Mapped; 269622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (isSigned) { 269722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // constant used to invert sign bit (signed to unsigned mapping) 2698475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue SignBit = DAG.getConstant(0x80000000u, MVT::i32); 2699af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen Op0Mapped = DAG.getNode(ISD::XOR, dl, MVT::i32, Op0, SignBit); 270022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } else { 270122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner Op0Mapped = Op0; 270222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 270322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // store the lo of the constructed double - based on integer input 2704af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue Store1 = DAG.getStore(DAG.getEntryNode(), dl, 2705ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson Op0Mapped, Lo, NULL, 0); 270622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // initial hi portion of constructed double 2707475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue InitialHi = DAG.getConstant(0x43300000u, MVT::i32); 270822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // store the hi of the constructed double - biased exponent 2709af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue Store2=DAG.getStore(Store1, dl, InitialHi, Hi, NULL, 0); 271022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // load the constructed double 2711af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue Load = DAG.getLoad(MVT::f64, dl, Store2, StackSlot, NULL, 0); 271222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // FP constant to bias correct the final result 2713475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Bias = DAG.getConstantFP(isSigned ? 2714ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson BitsToDouble(0x4330000080000000ULL) : 2715ec15bbfd2f8a3667313dcfa0f9a11497ae6732b8Bob Wilson BitsToDouble(0x4330000000000000ULL), 271622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner MVT::f64); 271722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // subtract the bias 2718af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::f64, Load, Bias); 271922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // final result 2720475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Result; 272122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // handle final rounding 272222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (DestVT == MVT::f64) { 272322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // do nothing 272422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner Result = Sub; 27258e4eb09b1e3571965f49edcdfb56b1375b1b7551Duncan Sands } else if (DestVT.bitsLT(MVT::f64)) { 2726af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen Result = DAG.getNode(ISD::FP_ROUND, dl, DestVT, Sub, 27270bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(0)); 27288e4eb09b1e3571965f49edcdfb56b1375b1b7551Duncan Sands } else if (DestVT.bitsGT(MVT::f64)) { 2729af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen Result = DAG.getNode(ISD::FP_EXTEND, dl, DestVT, Sub); 273022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 273122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner return Result; 273222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 273322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner assert(!isSigned && "Legalize cannot Expand SINT_TO_FP for i64 yet"); 2734af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue Tmp1 = DAG.getNode(ISD::SINT_TO_FP, dl, DestVT, Op0); 273522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 2736af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue SignSet = DAG.getSetCC(dl, TLI.getSetCCResultType(Op0.getValueType()), 27375480c0469e5c0323ffb12f1ead2abd169d6cc0e7Duncan Sands Op0, DAG.getConstant(0, Op0.getValueType()), 27385480c0469e5c0323ffb12f1ead2abd169d6cc0e7Duncan Sands ISD::SETLT); 2739475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Zero = DAG.getIntPtrConstant(0), Four = DAG.getIntPtrConstant(4); 2740af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue CstOffset = DAG.getNode(ISD::SELECT, dl, Zero.getValueType(), 274122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner SignSet, Four, Zero); 274222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 274322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // If the sign bit of the integer is set, the large number will be treated 274422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // as a negative number. To counteract this, the dynamic code adds an 274522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // offset depending on the data type. 274622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner uint64_t FF; 274783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands switch (Op0.getValueType().getSimpleVT()) { 274822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner default: assert(0 && "Unsupported integer type!"); 274922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case MVT::i8 : FF = 0x43800000ULL; break; // 2^8 (as a float) 275022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case MVT::i16: FF = 0x47800000ULL; break; // 2^16 (as a float) 275122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case MVT::i32: FF = 0x4F800000ULL; break; // 2^32 (as a float) 275222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case MVT::i64: FF = 0x5F800000ULL; break; // 2^64 (as a float) 275322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 275422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (TLI.isLittleEndian()) FF <<= 32; 2755d2e936a513b01b2c5df91a9c0d80070e8c752aceChris Lattner Constant *FudgeFactor = ConstantInt::get(Type::Int64Ty, FF); 275622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 2757475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy()); 27581606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned Alignment = cast<ConstantPoolSDNode>(CPIdx)->getAlignment(); 2759af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen CPIdx = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(), CPIdx, CstOffset); 276087a0f10dc7eff8cf5e83a754f75adf9cb3991435Dan Gohman Alignment = std::min(Alignment, 4u); 2761475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue FudgeInReg; 276222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (DestVT == MVT::f32) 2763af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen FudgeInReg = DAG.getLoad(MVT::f32, dl, DAG.getEntryNode(), CPIdx, 276450284d81f863a6576582e1a171a22eb0f012ddf3Dan Gohman PseudoSourceValue::getConstantPool(), 0, 276550284d81f863a6576582e1a171a22eb0f012ddf3Dan Gohman false, Alignment); 276622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner else { 276769de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman FudgeInReg = 2768af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen LegalizeOp(DAG.getExtLoad(ISD::EXTLOAD, dl, DestVT, 276969de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman DAG.getEntryNode(), CPIdx, 27703069b8743769527ce7af6cfb6591a2f0fc2faee4Dan Gohman PseudoSourceValue::getConstantPool(), 0, 277150284d81f863a6576582e1a171a22eb0f012ddf3Dan Gohman MVT::f32, false, Alignment)); 277222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 277322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 2774af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen return DAG.getNode(ISD::FADD, dl, DestVT, Tmp1, FudgeInReg); 277522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner} 277622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 277722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// PromoteLegalINT_TO_FP - This function is responsible for legalizing a 277822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// *INT_TO_FP operation of the specified operand when the target requests that 277922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// we promote it. At this point, we know that the result and operand types are 278022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// legal for the target, and that there is a legal UINT_TO_FP or SINT_TO_FP 278122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// operation that takes a larger input. 2782475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::PromoteLegalINT_TO_FP(SDValue LegalOp, 2783475871a144eb604ddaf37503397ba0941442e5fbDan Gohman MVT DestVT, 2784af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen bool isSigned, 2785af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl) { 278622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // First step, figure out the appropriate *INT_TO_FP operation to use. 278783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NewInTy = LegalOp.getValueType(); 278822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 278922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner unsigned OpToUse = 0; 279022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 279122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // Scan for the appropriate larger type to use. 279222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner while (1) { 279383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands NewInTy = (MVT::SimpleValueType)(NewInTy.getSimpleVT()+1); 279483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(NewInTy.isInteger() && "Ran out of possibilities!"); 279522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 279622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // If the target supports SINT_TO_FP of this type, use it. 279722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner switch (TLI.getOperationAction(ISD::SINT_TO_FP, NewInTy)) { 279822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner default: break; 279922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case TargetLowering::Legal: 280022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (!TLI.isTypeLegal(NewInTy)) 280122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner break; // Can't use this datatype. 280222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // FALL THROUGH. 280322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case TargetLowering::Custom: 280422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner OpToUse = ISD::SINT_TO_FP; 280522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner break; 280622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 280722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (OpToUse) break; 280822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (isSigned) continue; 280922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 281022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // If the target supports UINT_TO_FP of this type, use it. 281122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner switch (TLI.getOperationAction(ISD::UINT_TO_FP, NewInTy)) { 281222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner default: break; 281322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case TargetLowering::Legal: 281422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (!TLI.isTypeLegal(NewInTy)) 281522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner break; // Can't use this datatype. 281622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // FALL THROUGH. 281722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case TargetLowering::Custom: 281822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner OpToUse = ISD::UINT_TO_FP; 281922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner break; 282022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 282122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (OpToUse) break; 282222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 282322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // Otherwise, try a larger type. 282422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 282522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 282622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // Okay, we found the operation and type to use. Zero extend our input to the 282722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // desired type then run the operation on it. 2828af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen return DAG.getNode(OpToUse, dl, DestVT, 282922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, 2830af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen dl, NewInTy, LegalOp)); 283177e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 283277e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner 283322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// PromoteLegalFP_TO_INT - This function is responsible for legalizing a 283422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// FP_TO_*INT operation of the specified operand when the target requests that 283522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// we promote it. At this point, we know that the result and operand types are 283622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// legal for the target, and that there is a legal FP_TO_UINT or FP_TO_SINT 283722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// operation that returns a larger result. 2838475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue SelectionDAGLegalize::PromoteLegalFP_TO_INT(SDValue LegalOp, 2839475871a144eb604ddaf37503397ba0941442e5fbDan Gohman MVT DestVT, 2840af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen bool isSigned, 2841af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen DebugLoc dl) { 284222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // First step, figure out the appropriate FP_TO*INT operation to use. 284383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT NewOutTy = DestVT; 28449c32d3b798dc6caeebe6cea2effe80ca5e84e66eChris Lattner 284522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner unsigned OpToUse = 0; 2846e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 284722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // Scan for the appropriate larger type to use. 284822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner while (1) { 284983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands NewOutTy = (MVT::SimpleValueType)(NewOutTy.getSimpleVT()+1); 285083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands assert(NewOutTy.isInteger() && "Ran out of possibilities!"); 285166de05b606cf31f1f23ed0c4eb1f097738cd1506Chris Lattner 285222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // If the target supports FP_TO_SINT returning this type, use it. 285322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner switch (TLI.getOperationAction(ISD::FP_TO_SINT, NewOutTy)) { 285422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner default: break; 285522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case TargetLowering::Legal: 285622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (!TLI.isTypeLegal(NewOutTy)) 285722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner break; // Can't use this datatype. 285822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // FALL THROUGH. 285922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case TargetLowering::Custom: 286022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner OpToUse = ISD::FP_TO_SINT; 286122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner break; 286222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 286322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (OpToUse) break; 2864e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner 286522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // If the target supports FP_TO_UINT of this type, use it. 286622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner switch (TLI.getOperationAction(ISD::FP_TO_UINT, NewOutTy)) { 286722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner default: break; 286822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case TargetLowering::Legal: 286922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (!TLI.isTypeLegal(NewOutTy)) 287022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner break; // Can't use this datatype. 287122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // FALL THROUGH. 287222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case TargetLowering::Custom: 287322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner OpToUse = ISD::FP_TO_UINT; 287422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner break; 2875e9c35e7309a8293852ba71d874fa4dc99e07e6feChris Lattner } 287622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner if (OpToUse) break; 28770d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner 287822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // Otherwise, try a larger type. 2879a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner } 2880a88a260dbd874a3bdd3e47f4f15ab0d7c7803044Chris Lattner 2881fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 288227a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner // Okay, we found the operation and type to use. 2883af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen SDValue Operation = DAG.getNode(OpToUse, dl, NewOutTy, LegalOp); 2884126d90770bdb17e6925b2fe26de99aa079b7b9b3Duncan Sands 288527a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner // If the operation produces an invalid type, it must be custom lowered. Use 288627a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner // the target lowering hooks to expand it. Just keep the low part of the 288727a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner // expanded operation, we know that we're truncating anyway. 288827a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner if (getTypeAction(NewOutTy) == Expand) { 28891607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands SmallVector<SDValue, 2> Results; 28901607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands TLI.ReplaceNodeResults(Operation.getNode(), Results, DAG); 28911607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands assert(Results.size() == 1 && "Incorrect FP_TO_XINT lowering!"); 28921607f05cb7d77d01ce521a30232faa389dbed4e2Duncan Sands Operation = Results[0]; 289327a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner } 2894126d90770bdb17e6925b2fe26de99aa079b7b9b3Duncan Sands 289527a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner // Truncate the result of the extended FP_TO_*INT operation to the desired 289627a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner // size. 2897af435274e56af687b51f33b5bc6f005fe99ad46fDale Johannesen return DAG.getNode(ISD::TRUNCATE, dl, DestVT, Operation); 289822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner} 289913689e2009e71f7982d1313ed699e0e6a50157d0Chris Lattner 290022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// ExpandBSWAP - Open code the operations for BSWAP of the specified operation. 290122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// 29028a782a2a8c2f0c82f292d03a3f707232b0bae27bDale JohannesenSDValue SelectionDAGLegalize::ExpandBSWAP(SDValue Op, DebugLoc dl) { 290383ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Op.getValueType(); 290483ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT SHVT = TLI.getShiftAmountTy(); 2905475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp1, Tmp2, Tmp3, Tmp4, Tmp5, Tmp6, Tmp7, Tmp8; 290683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands switch (VT.getSimpleVT()) { 290722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner default: assert(0 && "Unhandled Expand type in BSWAP!"); abort(); 290822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case MVT::i16: 29098a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, SHVT)); 29108a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, SHVT)); 29118a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getNode(ISD::OR, dl, VT, Tmp1, Tmp2); 291222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case MVT::i32: 29138a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp4 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(24, SHVT)); 29148a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp3 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, SHVT)); 29158a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, SHVT)); 29168a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(24, SHVT)); 29178a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp3 = DAG.getNode(ISD::AND, dl, VT, Tmp3, DAG.getConstant(0xFF0000, VT)); 29188a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp2, DAG.getConstant(0xFF00, VT)); 29198a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp3); 29208a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp1); 29218a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp2); 292222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case MVT::i64: 29238a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp8 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(56, SHVT)); 29248a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp7 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(40, SHVT)); 29258a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp6 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(24, SHVT)); 29268a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp5 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, SHVT)); 29278a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp4 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, SHVT)); 29288a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp3 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(24, SHVT)); 29298a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(40, SHVT)); 29308a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(56, SHVT)); 29318a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp7 = DAG.getNode(ISD::AND, dl, VT, Tmp7, DAG.getConstant(255ULL<<48, VT)); 29328a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp6 = DAG.getNode(ISD::AND, dl, VT, Tmp6, DAG.getConstant(255ULL<<40, VT)); 29338a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp5 = DAG.getNode(ISD::AND, dl, VT, Tmp5, DAG.getConstant(255ULL<<32, VT)); 29348a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp4 = DAG.getNode(ISD::AND, dl, VT, Tmp4, DAG.getConstant(255ULL<<24, VT)); 29358a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp3 = DAG.getNode(ISD::AND, dl, VT, Tmp3, DAG.getConstant(255ULL<<16, VT)); 29368a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp2, DAG.getConstant(255ULL<<8 , VT)); 29378a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp8 = DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp7); 29388a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp6 = DAG.getNode(ISD::OR, dl, VT, Tmp6, Tmp5); 29398a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp3); 29408a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp1); 29418a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp8 = DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp6); 29428a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp2); 29438a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp4); 29440d67f0c80f0295aa44f826ec1402ea73d6b4bd22Chris Lattner } 294577e77a6aa0ab25a812947aed477220dd11220a18Chris Lattner} 2946edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 294722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// ExpandBitCount - Expand the specified bitcount instruction into operations. 294822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner/// 2949fdc40a0a696c658d550d894ea03772e5f8af2c94Scott MichelSDValue SelectionDAGLegalize::ExpandBitCount(unsigned Opc, SDValue Op, 29508a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DebugLoc dl) { 295122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner switch (Opc) { 295222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner default: assert(0 && "Cannot expand this yet!"); 295322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case ISD::CTPOP: { 295422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner static const uint64_t mask[6] = { 295522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 0x5555555555555555ULL, 0x3333333333333333ULL, 295622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 0x0F0F0F0F0F0F0F0FULL, 0x00FF00FF00FF00FFULL, 295722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner 0x0000FFFF0000FFFFULL, 0x00000000FFFFFFFFULL 295822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner }; 295983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Op.getValueType(); 296083ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT ShVT = TLI.getShiftAmountTy(); 296183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned len = VT.getSizeInBits(); 296222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 296322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner //x = (x & mask[i][len/8]) + (x >> (1 << i) & mask[i][len/8]) 2964b0d5cdd52e8448f769cd71aaee6a4b8592dc08b1Duncan Sands unsigned EltSize = VT.isVector() ? 2965b0d5cdd52e8448f769cd71aaee6a4b8592dc08b1Duncan Sands VT.getVectorElementType().getSizeInBits() : len; 2966b0d5cdd52e8448f769cd71aaee6a4b8592dc08b1Duncan Sands SDValue Tmp2 = DAG.getConstant(APInt(EltSize, mask[i]), VT); 2967475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp3 = DAG.getConstant(1ULL << i, ShVT); 2968fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Op = DAG.getNode(ISD::ADD, dl, VT, 2969e72c5964d5263f2489bf2c7e9d32f71271d205fcDale Johannesen DAG.getNode(ISD::AND, dl, VT, Op, Tmp2), 29708a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DAG.getNode(ISD::AND, dl, VT, 29718a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DAG.getNode(ISD::SRL, dl, VT, Op, Tmp3), 29728a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Tmp2)); 297322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 297422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner return Op; 297522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 297622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case ISD::CTLZ: { 297722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // for now, we do this: 297822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // x = x | (x >> 1); 297922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // x = x | (x >> 2); 298022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // ... 298122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // x = x | (x >>16); 298222cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // x = x | (x >>32); // for 64-bit input 298322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // return popcount(~x); 298422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // 298522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // but see also: http://www.hackersdelight.org/HDcode/nlz.cc 298683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Op.getValueType(); 298783ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT ShVT = TLI.getShiftAmountTy(); 298883ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands unsigned len = VT.getSizeInBits(); 298922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner for (unsigned i = 0; (1U << i) <= (len / 2); ++i) { 2990475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Tmp3 = DAG.getConstant(1ULL << i, ShVT); 2991fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel Op = DAG.getNode(ISD::OR, dl, VT, Op, 2992e72c5964d5263f2489bf2c7e9d32f71271d205fcDale Johannesen DAG.getNode(ISD::SRL, dl, VT, Op, Tmp3)); 299322cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 29948a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen Op = DAG.getNOT(dl, Op, VT); 29958a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getNode(ISD::CTPOP, dl, VT, Op); 299622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 299722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner case ISD::CTTZ: { 299822cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // for now, we use: { return popcount(~x & (x - 1)); } 299922cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // unless the target has ctlz but not ctpop, in which case we use: 300022cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // { return 32 - nlz(~x & (x-1)); } 300122cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // see also http://www.hackersdelight.org/HDcode/ntz.cc 300283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands MVT VT = Op.getValueType(); 30038a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen SDValue Tmp3 = DAG.getNode(ISD::AND, dl, VT, 30048a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DAG.getNOT(dl, Op, VT), 30058a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DAG.getNode(ISD::SUB, dl, VT, Op, 30067581bfa2757a3149c6d17c0fe592e5c3808aa843Bill Wendling DAG.getConstant(1, VT))); 300722cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner // If ISD::CTLZ is legal and CTPOP isn't, then do that instead. 3008f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman if (!TLI.isOperationLegalOrCustom(ISD::CTPOP, VT) && 3009f560ffae1f1f6591859c7b70636a3eca6c03f083Dan Gohman TLI.isOperationLegalOrCustom(ISD::CTLZ, VT)) 30108a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getNode(ISD::SUB, dl, VT, 301183ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands DAG.getConstant(VT.getSizeInBits(), VT), 30128a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen DAG.getNode(ISD::CTLZ, dl, VT, Tmp3)); 30138a782a2a8c2f0c82f292d03a3f707232b0bae27bDale Johannesen return DAG.getNode(ISD::CTPOP, dl, VT, Tmp3); 301422cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 301522cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner } 301622cde6a518782cafc2115ad8d8233f79c9e9d52eChris Lattner} 3017e34b396ab7d28469bf3d9679a748b643d8e30458Chris Lattner 30188c377c7296d8a8104231442c3f6c27296249ec5fEli Friedmanvoid SelectionDAGLegalize::ExpandNode(SDNode *Node, 30198c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman SmallVectorImpl<SDValue> &Results) { 30208c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman DebugLoc dl = Node->getDebugLoc(); 3021f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman SDValue Tmp1, Tmp2, Tmp3; 30228c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman switch (Node->getOpcode()) { 30238c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::CTPOP: 30248c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::CTLZ: 30258c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::CTTZ: 30268c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = ExpandBitCount(Node->getOpcode(), Node->getOperand(0), dl); 30278c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 30288c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 30298c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::BSWAP: 30308c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(ExpandBSWAP(Node->getOperand(0), dl)); 30318c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 30328c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FRAMEADDR: 30338c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::RETURNADDR: 30348c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FRAME_TO_ARGS_OFFSET: 30358c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(DAG.getConstant(0, Node->getValueType(0))); 30368c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 30378c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FLT_ROUNDS_: 30388c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(DAG.getConstant(1, Node->getValueType(0))); 30398c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 30408c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::EH_RETURN: 30418c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::DECLARE: 30428c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::DBG_LABEL: 30438c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::EH_LABEL: 30448c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::PREFETCH: 30458c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::MEMBARRIER: 30468c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::VAEND: 30478c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Node->getOperand(0)); 30488c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 30498c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::MERGE_VALUES: 30508c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman for (unsigned i = 0; i < Node->getNumValues(); i++) 30518c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Node->getOperand(i)); 30528c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 30538c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::UNDEF: { 30548c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman MVT VT = Node->getValueType(0); 30558c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (VT.isInteger()) 30568c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(DAG.getConstant(0, VT)); 30578c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman else if (VT.isFloatingPoint()) 30588c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(DAG.getConstantFP(0, VT)); 30598c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman else 30608c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman assert(0 && "Unknown value type!"); 30618c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 30628c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 30638c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::TRAP: { 30648c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // If this operation is not supported, lower it to 'abort()' call 30658c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman TargetLowering::ArgListTy Args; 30668c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman std::pair<SDValue, SDValue> CallResult = 30678c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman TLI.LowerCallTo(Node->getOperand(0), Type::VoidTy, 30688c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman false, false, false, false, CallingConv::C, false, 30698c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman DAG.getExternalSymbol("abort", TLI.getPointerTy()), 30708c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Args, DAG, dl); 30718c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(CallResult.second); 30728c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 30738c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 30748c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FP_ROUND: 30758c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::BIT_CONVERT: 30768c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = EmitStackConvert(Node->getOperand(0), Node->getValueType(0), 30778c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getValueType(0), dl); 30788c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 30798c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 30808c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FP_EXTEND: 30818c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = EmitStackConvert(Node->getOperand(0), 30828c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOperand(0).getValueType(), 30838c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getValueType(0), dl); 30848c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 30858c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 30868c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SIGN_EXTEND_INREG: { 30878c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // NOTE: we could fall back on load/store here too for targets without 30888c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // SAR. However, it is doubtful that any exist. 30898c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman MVT ExtraVT = cast<VTSDNode>(Node->getOperand(1))->getVT(); 30908c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman unsigned BitsDiff = Node->getValueType(0).getSizeInBits() - 30918c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman ExtraVT.getSizeInBits(); 30928c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman SDValue ShiftCst = DAG.getConstant(BitsDiff, TLI.getShiftAmountTy()); 30938c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::SHL, dl, Node->getValueType(0), 30948c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOperand(0), ShiftCst); 30958c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::SRA, dl, Node->getValueType(0), Tmp1, ShiftCst); 30968c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 30978c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 30988c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 30998c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FP_ROUND_INREG: { 31008c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // The only way we can lower this is to turn it into a TRUNCSTORE, 31018c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // EXTLOAD pair, targetting a temporary location (a stack slot). 31028c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman 31038c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // NOTE: there is a choice here between constantly creating new stack 31048c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // slots and always reusing the same one. We currently always create 31058c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // new ones, as reuse may inhibit scheduling. 31068c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman MVT ExtraVT = cast<VTSDNode>(Node->getOperand(1))->getVT(); 31078c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = EmitStackConvert(Node->getOperand(0), ExtraVT, 31088c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getValueType(0), dl); 31098c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 31108c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 31118c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 31128c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SINT_TO_FP: 31138c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::UINT_TO_FP: 31148c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = ExpandLegalINT_TO_FP(Node->getOpcode() == ISD::SINT_TO_FP, 31158c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOperand(0), Node->getValueType(0), dl); 31168c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 31178c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 31188c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FP_TO_UINT: { 31198c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman SDValue True, False; 31208c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman MVT VT = Node->getOperand(0).getValueType(); 31218c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman MVT NVT = Node->getValueType(0); 31228c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman const uint64_t zero[] = {0, 0}; 31238c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman APFloat apf = APFloat(APInt(VT.getSizeInBits(), 2, zero)); 31248c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman APInt x = APInt::getSignBit(NVT.getSizeInBits()); 31258c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman (void)apf.convertFromAPInt(x, false, APFloat::rmNearestTiesToEven); 31268c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getConstantFP(apf, VT); 31278c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(VT), 31288c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOperand(0), 31298c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1, ISD::SETLT); 31308c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman True = DAG.getNode(ISD::FP_TO_SINT, dl, NVT, Node->getOperand(0)); 31318c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman False = DAG.getNode(ISD::FP_TO_SINT, dl, NVT, 31328c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman DAG.getNode(ISD::FSUB, dl, VT, 31338c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOperand(0), Tmp1)); 31348c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman False = DAG.getNode(ISD::XOR, dl, NVT, False, 31358c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman DAG.getConstant(x, NVT)); 31368c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::SELECT, dl, NVT, Tmp2, True, False); 31378c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 31388c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 31398c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 31408c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::VACOPY: { 31418c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // This defaults to loading a pointer from the input and storing it to the 31428c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // output, returning the chain. 31438c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman const Value *VD = cast<SrcValueSDNode>(Node->getOperand(3))->getValue(); 31448c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman const Value *VS = cast<SrcValueSDNode>(Node->getOperand(4))->getValue(); 31458c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getLoad(TLI.getPointerTy(), dl, Node->getOperand(0), 31468c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOperand(2), VS, 0); 31478c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getStore(Tmp1.getValue(1), dl, Tmp1, Node->getOperand(1), VD, 0); 31488c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 31498c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 31508c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 31518c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::EXTRACT_VECTOR_ELT: 31528c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (Node->getOperand(0).getValueType().getVectorNumElements() == 1) 31538c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // This must be an access of the only element. Return it. 31548c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::BIT_CONVERT, dl, Node->getValueType(0), 31558c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOperand(0)); 31568c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman else 31578c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = ExpandExtractFromVectorThroughStack(SDValue(Node, 0)); 31588c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 31598c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 31608c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::EXTRACT_SUBVECTOR: 31618c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(ExpandExtractFromVectorThroughStack(SDValue(Node, 0))); 31628c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 31638c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SCALAR_TO_VECTOR: 31648c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(ExpandSCALAR_TO_VECTOR(Node)); 31658c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 31663f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::INSERT_VECTOR_ELT: 31673f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman Results.push_back(ExpandINSERT_VECTOR_ELT(Node->getOperand(0), 31683f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman Node->getOperand(1), 31693f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman Node->getOperand(2), dl)); 31703f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman break; 31718c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::EXTRACT_ELEMENT: { 31728c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman MVT OpTy = Node->getOperand(0).getValueType(); 31738c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (cast<ConstantSDNode>(Node->getOperand(1))->getZExtValue()) { 31748c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // 1 -> Hi 31758c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::SRL, dl, OpTy, Node->getOperand(0), 31768c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman DAG.getConstant(OpTy.getSizeInBits()/2, 31778c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman TLI.getShiftAmountTy())); 31788c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::TRUNCATE, dl, Node->getValueType(0), Tmp1); 31798c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } else { 31808c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // 0 -> Lo 31818c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::TRUNCATE, dl, Node->getValueType(0), 31828c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOperand(0)); 31838c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 31848c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 31858c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 31868c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 31873f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::STACKSAVE: 31883f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // Expand to CopyFromReg if the target set 31893f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // StackPointerRegisterToSaveRestore. 31903f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman if (unsigned SP = TLI.getStackPointerRegisterToSaveRestore()) { 31913f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman Results.push_back(DAG.getCopyFromReg(Node->getOperand(0), dl, SP, 31923f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman Node->getValueType(0))); 31933f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman Results.push_back(Results[0].getValue(1)); 31943f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman } else { 31953f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman Results.push_back(DAG.getUNDEF(Node->getValueType(0))); 31963f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman Results.push_back(Node->getOperand(0)); 31973f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman } 31983f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman break; 31993f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::STACKRESTORE: 32003f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // Expand to CopyToReg if the target set 32013f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // StackPointerRegisterToSaveRestore. 32023f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman if (unsigned SP = TLI.getStackPointerRegisterToSaveRestore()) { 32033f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman Results.push_back(DAG.getCopyToReg(Node->getOperand(0), dl, SP, 32043f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman Node->getOperand(1))); 32053f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman } else { 32063f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman Results.push_back(Node->getOperand(0)); 32073f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman } 32083f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman break; 3209f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FNEG: 3210f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman // Expand Y = FNEG(X) -> Y = SUB -0.0, X 3211f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Tmp1 = DAG.getConstantFP(-0.0, Node->getValueType(0)); 3212f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Tmp1 = DAG.getNode(ISD::FSUB, dl, Node->getValueType(0), Tmp1, 3213f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Node->getOperand(0)); 3214f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(Tmp1); 3215f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3216f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FABS: { 3217f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman // Expand Y = FABS(X) -> Y = (X >u 0.0) ? X : fneg(X). 3218f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman MVT VT = Node->getValueType(0); 3219f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Tmp1 = Node->getOperand(0); 3220f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Tmp2 = DAG.getConstantFP(0.0, VT); 3221f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Tmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(Tmp1.getValueType()), 3222f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Tmp1, Tmp2, ISD::SETUGT); 3223f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Tmp3 = DAG.getNode(ISD::FNEG, dl, VT, Tmp1); 3224f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Tmp1 = DAG.getNode(ISD::SELECT, dl, VT, Tmp2, Tmp1, Tmp3); 3225f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(Tmp1); 3226f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3227f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman } 3228f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FSQRT: 3229f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(ExpandFPLibCall(Node, RTLIB::SQRT_F32, RTLIB::SQRT_F64, 3230f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::SQRT_F80, RTLIB::SQRT_PPCF128)); 3231f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3232f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FSIN: 3233f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(ExpandFPLibCall(Node, RTLIB::SIN_F32, RTLIB::SIN_F64, 3234f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::SIN_F80, RTLIB::SIN_PPCF128)); 3235f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3236f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FCOS: 3237f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(ExpandFPLibCall(Node, RTLIB::COS_F32, RTLIB::COS_F64, 3238f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::COS_F80, RTLIB::COS_PPCF128)); 3239f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3240f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FLOG: 3241f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(ExpandFPLibCall(Node, RTLIB::LOG_F32, RTLIB::LOG_F64, 3242f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::LOG_F80, RTLIB::LOG_PPCF128)); 3243f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3244f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FLOG2: 3245f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(ExpandFPLibCall(Node, RTLIB::LOG2_F32, RTLIB::LOG2_F64, 3246f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::LOG2_F80, RTLIB::LOG2_PPCF128)); 3247f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3248f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FLOG10: 3249f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(ExpandFPLibCall(Node, RTLIB::LOG10_F32, RTLIB::LOG10_F64, 3250f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::LOG10_F80, RTLIB::LOG10_PPCF128)); 3251f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3252f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FEXP: 3253f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(ExpandFPLibCall(Node, RTLIB::EXP_F32, RTLIB::EXP_F64, 3254f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::EXP_F80, RTLIB::EXP_PPCF128)); 3255f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3256f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FEXP2: 3257f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(ExpandFPLibCall(Node, RTLIB::EXP2_F32, RTLIB::EXP2_F64, 3258f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::EXP2_F80, RTLIB::EXP2_PPCF128)); 3259f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3260f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FTRUNC: 3261f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(ExpandFPLibCall(Node, RTLIB::TRUNC_F32, RTLIB::TRUNC_F64, 3262f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::TRUNC_F80, RTLIB::TRUNC_PPCF128)); 3263f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3264f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FFLOOR: 3265f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(ExpandFPLibCall(Node, RTLIB::FLOOR_F32, RTLIB::FLOOR_F64, 3266f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::FLOOR_F80, RTLIB::FLOOR_PPCF128)); 3267f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3268f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FCEIL: 3269f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(ExpandFPLibCall(Node, RTLIB::CEIL_F32, RTLIB::CEIL_F64, 3270f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::CEIL_F80, RTLIB::CEIL_PPCF128)); 3271f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3272f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FRINT: 3273f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(ExpandFPLibCall(Node, RTLIB::RINT_F32, RTLIB::RINT_F64, 3274f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::RINT_F80, RTLIB::RINT_PPCF128)); 3275f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3276f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FNEARBYINT: 3277f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(ExpandFPLibCall(Node, RTLIB::NEARBYINT_F32, 3278f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::NEARBYINT_F64, 3279f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::NEARBYINT_F80, 3280f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::NEARBYINT_PPCF128)); 3281f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3282f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FPOWI: 3283f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(ExpandFPLibCall(Node, RTLIB::POWI_F32, RTLIB::POWI_F64, 3284f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::POWI_F80, RTLIB::POWI_PPCF128)); 3285f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3286f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FPOW: 3287f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(ExpandFPLibCall(Node, RTLIB::POW_F32, RTLIB::POW_F64, 3288f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::POW_F80, RTLIB::POW_PPCF128)); 3289f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3290f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FDIV: 3291f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(ExpandFPLibCall(Node, RTLIB::DIV_F32, RTLIB::DIV_F64, 3292f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::DIV_F80, RTLIB::DIV_PPCF128)); 3293f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 3294f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::FREM: 3295f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(ExpandFPLibCall(Node, RTLIB::REM_F32, RTLIB::REM_F64, 3296f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman RTLIB::REM_F80, RTLIB::REM_PPCF128)); 3297f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 329826ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman case ISD::EHSELECTION: { 329926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman unsigned Reg = TLI.getExceptionSelectorRegister(); 330026ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman assert(Reg && "Can't expand to unknown register!"); 330126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Results.push_back(DAG.getCopyFromReg(Node->getOperand(1), dl, Reg, 330226ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Node->getValueType(0))); 330326ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Results.push_back(Results[0].getValue(1)); 330426ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman break; 330526ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } 330626ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman case ISD::EXCEPTIONADDR: { 330726ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman unsigned Reg = TLI.getExceptionAddressRegister(); 330826ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman assert(Reg && "Can't expand to unknown register!"); 330926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Results.push_back(DAG.getCopyFromReg(Node->getOperand(0), dl, Reg, 331026ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Node->getValueType(0))); 331126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Results.push_back(Results[0].getValue(1)); 331226ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman break; 331326ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } 331426ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman case ISD::SUB: { 331526ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman MVT VT = Node->getValueType(0); 331626ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman assert(TLI.isOperationLegalOrCustom(ISD::ADD, VT) && 331726ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman TLI.isOperationLegalOrCustom(ISD::XOR, VT) && 331826ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman "Don't know how to expand this subtraction!"); 331926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Tmp1 = DAG.getNode(ISD::XOR, dl, VT, Node->getOperand(1), 332026ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman DAG.getConstant(APInt::getAllOnesValue(VT.getSizeInBits()), VT)); 332126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Tmp1 = DAG.getNode(ISD::ADD, dl, VT, Tmp2, DAG.getConstant(1, VT)); 332226ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Results.push_back(DAG.getNode(ISD::ADD, dl, VT, Node->getOperand(0), Tmp1)); 332326ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman break; 332426ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } 332526ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman case ISD::UDIV: 332626ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman case ISD::UREM: { 332726ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman bool isRem = Node->getOpcode() == ISD::UREM; 332826ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman MVT VT = Node->getValueType(0); 332926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman SDVTList VTs = DAG.getVTList(VT, VT); 333026ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman if (TLI.isOperationLegalOrCustom(ISD::UDIVREM, VT)) 333126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Tmp1 = DAG.getNode(ISD::UDIVREM, dl, VTs, Node->getOperand(0), 333226ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Node->getOperand(1)).getValue(isRem); 333326ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman else if (isRem) 333426ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Tmp1 = ExpandIntLibCall(Node, false, RTLIB::UREM_I16, RTLIB::UREM_I32, 333526ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman RTLIB::UREM_I64, RTLIB::UREM_I128); 333626ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman else 333726ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Tmp1 = ExpandIntLibCall(Node, false, RTLIB::UDIV_I16, RTLIB::UDIV_I32, 333826ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman RTLIB::UDIV_I64, RTLIB::UDIV_I128); 333926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Results.push_back(Tmp1); 334026ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman break; 334126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } 334226ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman case ISD::SDIV: 334326ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman case ISD::SREM: { 334426ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman bool isRem = Node->getOpcode() == ISD::SREM; 334526ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman MVT VT = Node->getValueType(0); 334626ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman SDVTList VTs = DAG.getVTList(VT, VT); 334726ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman if (TLI.isOperationLegalOrCustom(ISD::SDIVREM, VT)) 334826ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Tmp1 = DAG.getNode(ISD::SDIVREM, dl, VTs, Node->getOperand(0), 334926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Node->getOperand(1)).getValue(isRem); 335026ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman else if (isRem) 335126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Tmp1 = ExpandIntLibCall(Node, true, RTLIB::SREM_I16, RTLIB::SREM_I32, 335226ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman RTLIB::SREM_I64, RTLIB::SREM_I128); 335326ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman else 335426ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Tmp1 = ExpandIntLibCall(Node, true, RTLIB::SDIV_I16, RTLIB::SDIV_I32, 335526ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman RTLIB::SDIV_I64, RTLIB::SDIV_I128); 335626ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Results.push_back(Tmp1); 335726ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman break; 335826ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } 335926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman case ISD::MULHU: 336026ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman case ISD::MULHS: { 336126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman unsigned ExpandOpcode = Node->getOpcode() == ISD::MULHU ? ISD::UMUL_LOHI : 336226ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman ISD::SMUL_LOHI; 336326ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman MVT VT = Node->getValueType(0); 336426ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman SDVTList VTs = DAG.getVTList(VT, VT); 336526ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman assert(TLI.isOperationLegalOrCustom(ExpandOpcode, VT) && 336626ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman "If this wasn't legal, it shouldn't have been created!"); 336726ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Tmp1 = DAG.getNode(ExpandOpcode, dl, VTs, Node->getOperand(0), 336826ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Node->getOperand(1)); 336926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Results.push_back(Tmp1.getValue(1)); 337026ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman break; 337126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } 337226ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman case ISD::MUL: { 337326ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman MVT VT = Node->getValueType(0); 337426ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman SDVTList VTs = DAG.getVTList(VT, VT); 337526ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman // See if multiply or divide can be lowered using two-result operations. 337626ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman // We just need the low half of the multiply; try both the signed 337726ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman // and unsigned forms. If the target supports both SMUL_LOHI and 337826ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman // UMUL_LOHI, form a preference by checking which forms of plain 337926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman // MULH it supports. 338026ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman bool HasSMUL_LOHI = TLI.isOperationLegalOrCustom(ISD::SMUL_LOHI, VT); 338126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman bool HasUMUL_LOHI = TLI.isOperationLegalOrCustom(ISD::UMUL_LOHI, VT); 338226ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman bool HasMULHS = TLI.isOperationLegalOrCustom(ISD::MULHS, VT); 338326ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman bool HasMULHU = TLI.isOperationLegalOrCustom(ISD::MULHU, VT); 338426ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman unsigned OpToUse = 0; 338526ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman if (HasSMUL_LOHI && !HasMULHS) { 338626ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman OpToUse = ISD::SMUL_LOHI; 338726ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } else if (HasUMUL_LOHI && !HasMULHU) { 338826ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman OpToUse = ISD::UMUL_LOHI; 338926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } else if (HasSMUL_LOHI) { 339026ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman OpToUse = ISD::SMUL_LOHI; 339126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } else if (HasUMUL_LOHI) { 339226ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman OpToUse = ISD::UMUL_LOHI; 339326ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } 339426ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman if (OpToUse) { 339526ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Results.push_back(DAG.getNode(OpToUse, dl, VTs, Tmp1, Tmp2)); 339626ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman break; 339726ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } 339826ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Tmp1 = ExpandIntLibCall(Node, false, RTLIB::MUL_I16, RTLIB::MUL_I32, 339926ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman RTLIB::MUL_I64, RTLIB::MUL_I128); 340026ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman Results.push_back(Tmp1); 340126ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman break; 340226ea8f982fb58245d3735b80ce04bc8050348a19Eli Friedman } 34033f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::GLOBAL_OFFSET_TABLE: 34043f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::GlobalAddress: 34053f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::GlobalTLSAddress: 34063f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::ExternalSymbol: 34073f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::ConstantPool: 34083f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::JumpTable: 34093f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::INTRINSIC_W_CHAIN: 34103f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::INTRINSIC_WO_CHAIN: 34113f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman case ISD::INTRINSIC_VOID: 34123f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman // FIXME: Custom lowering for these operations shouldn't return null! 34133f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman for (unsigned i = 0, e = Node->getNumValues(); i != e; ++i) 34143f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman Results.push_back(SDValue(Node, i)); 34153f727d6c1b68e90a3ab2d95ec2229f8b2c40b84bEli Friedman break; 34168c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 34178c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman} 34188c377c7296d8a8104231442c3f6c27296249ec5fEli Friedmanvoid SelectionDAGLegalize::PromoteNode(SDNode *Node, 34198c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman SmallVectorImpl<SDValue> &Results) { 34208c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman MVT OVT = Node->getValueType(0); 34218c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (Node->getOpcode() == ISD::UINT_TO_FP || 34228c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOpcode() == ISD::SINT_TO_FP) { 34238c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman OVT = Node->getOperand(0).getValueType(); 34248c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 34258c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman MVT NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); 34268c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman DebugLoc dl = Node->getDebugLoc(); 34278c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman SDValue Tmp1, Tmp2; 34288c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman switch (Node->getOpcode()) { 34298c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::CTTZ: 34308c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::CTLZ: 34318c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::CTPOP: 34328c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // Zero extend the argument. 34338c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Node->getOperand(0)); 34348c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // Perform the larger operation. 34358c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(Node->getOpcode(), dl, Node->getValueType(0), Tmp1); 34368c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman if (Node->getOpcode() == ISD::CTTZ) { 34378c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman //if Tmp1 == sizeinbits(NVT) then Tmp1 = sizeinbits(Old VT) 34388c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(Tmp1.getValueType()), 34398c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1, DAG.getConstant(NVT.getSizeInBits(), NVT), 34408c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman ISD::SETEQ); 34418c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::SELECT, dl, NVT, Tmp2, 34428c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman DAG.getConstant(OVT.getSizeInBits(), NVT), Tmp1); 34438c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } else if (Node->getOpcode() == ISD::CTLZ) { 34448c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman // Tmp1 = Tmp1 - (sizeinbits(NVT) - sizeinbits(Old VT)) 34458c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::SUB, dl, NVT, Tmp1, 34468c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman DAG.getConstant(NVT.getSizeInBits() - 34478c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman OVT.getSizeInBits(), NVT)); 34488c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 34498c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 34508c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 34518c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::BSWAP: { 34528c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman unsigned DiffBits = NVT.getSizeInBits() - OVT.getSizeInBits(); 34538c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Tmp1); 34548c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::BSWAP, dl, NVT, Tmp1); 34558c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = DAG.getNode(ISD::SRL, dl, NVT, Tmp1, 34568c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman DAG.getConstant(DiffBits, TLI.getShiftAmountTy())); 34578c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 34588c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 34598c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 34608c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FP_TO_UINT: 34618c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::FP_TO_SINT: 34628c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = PromoteLegalFP_TO_INT(Node->getOperand(0), Node->getValueType(0), 34638c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOpcode() == ISD::FP_TO_SINT, dl); 34648c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 34658c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 34668c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::UINT_TO_FP: 34678c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman case ISD::SINT_TO_FP: 34688c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Tmp1 = PromoteLegalINT_TO_FP(Node->getOperand(0), Node->getValueType(0), 34698c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Node->getOpcode() == ISD::SINT_TO_FP, dl); 34708c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman Results.push_back(Tmp1); 34718c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman break; 3472f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::AND: 3473f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::OR: 3474f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman case ISD::XOR: 3475f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman assert(OVT.isVector() && "Don't know how to promote scalar logic ops"); 3476f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman // Bit convert each of the values to the new type. 3477f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Tmp1 = DAG.getNode(ISD::BIT_CONVERT, dl, NVT, Node->getOperand(0)); 3478f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Tmp2 = DAG.getNode(ISD::BIT_CONVERT, dl, NVT, Node->getOperand(1)); 3479f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Tmp1 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1, Tmp2); 3480f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman // Bit convert the result back the original type. 3481f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman Results.push_back(DAG.getNode(ISD::BIT_CONVERT, dl, OVT, Tmp1)); 3482f6b23bfc79cf9f605a2e74942c90799ff4f1a17eEli Friedman break; 34838c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman } 34848c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman} 34858c377c7296d8a8104231442c3f6c27296249ec5fEli Friedman 34863e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// SelectionDAG::Legalize - This is the entry point for the file. 34873e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner// 348898a366d547772010e94609e4584489b3e5ce0043Bill Wendlingvoid SelectionDAG::Legalize(bool TypesNeedLegalizing, 348998a366d547772010e94609e4584489b3e5ce0043Bill Wendling CodeGenOpt::Level OptLevel) { 34903e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// run - This is the main entry point to this class. 34913e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner /// 34921fde9c5f771922f12fefc903850c4eca303297d9Eli Friedman SelectionDAGLegalize(*this, OptLevel).LegalizeDAG(); 34933e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner} 34943e928bbd6153eb08641cbd0ad7d8487378a8b12aChris Lattner 3495