SelectionDAG.h revision cd81d94322a39503e4a3e87b6ee03d4fcb3465fb
1c3aae25116e66c177579b0b79182b09340b19753Chris Lattner//===-- llvm/CodeGen/SelectionDAG.h - InstSelection DAG ---------*- C++ -*-===// 2ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman// 36fbcc26f1460eaee4e0eb8b426fc1ff0c7af11beJohn Criswell// The LLVM Compiler Infrastructure 46fbcc26f1460eaee4e0eb8b426fc1ff0c7af11beJohn Criswell// 57ed47a13356daed2a34cd2209a31f92552e3bdd8Chris Lattner// This file is distributed under the University of Illinois Open Source 67ed47a13356daed2a34cd2209a31f92552e3bdd8Chris Lattner// License. See LICENSE.TXT for details. 7ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman// 86fbcc26f1460eaee4e0eb8b426fc1ff0c7af11beJohn Criswell//===----------------------------------------------------------------------===// 9ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman// 10c3aae25116e66c177579b0b79182b09340b19753Chris Lattner// This file declares the SelectionDAG class, and transitively defines the 11c3aae25116e66c177579b0b79182b09340b19753Chris Lattner// SDNode class and subclasses. 12ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman// 13cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner//===----------------------------------------------------------------------===// 14cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 15cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner#ifndef LLVM_CODEGEN_SELECTIONDAG_H 16cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner#define LLVM_CODEGEN_SELECTIONDAG_H 17cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 18c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene#include "llvm/ADT/DenseSet.h" 194b84086e89d86fb16f562166d9fea8df37db6be7Dan Gohman#include "llvm/ADT/StringMap.h" 20255f89faee13dc491cb64fbeae3c763e7e2ea4e6Chandler Carruth#include "llvm/ADT/ilist.h" 21444b4bf5c84c80833ff283244de0885124091a13Nadav Rotem#include "llvm/CodeGen/DAGCombine.h" 22583bd47f777fe3eb8305872fa0eadab31e833dffJim Laskey#include "llvm/CodeGen/SelectionDAGNodes.h" 23c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman#include "llvm/Support/RecyclingAllocator.h" 2498a366d547772010e94609e4584489b3e5ce0043Bill Wendling#include "llvm/Target/TargetMachine.h" 25acaf09dbe4a6781163857db1321bbd5795e7d410Dan Gohman#include <cassert> 26322812e603705e1c2037313633e72f689524b163Evan Cheng#include <map> 27eb19e40efbd3cae80c908a30cdf4d33450733c45Chris Lattner#include <string> 28255f89faee13dc491cb64fbeae3c763e7e2ea4e6Chandler Carruth#include <vector> 29d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 30d0fde30ce850b78371fd1386338350591f9ff494Brian Gaekenamespace llvm { 31fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman 32fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohmanclass AliasAnalysis; 33b4e6a5df5dada0cd919cc6e2717eb3118db9cc45Bill Wendlingclass MachineConstantPoolValue; 34b4e6a5df5dada0cd919cc6e2717eb3118db9cc45Bill Wendlingclass MachineFunction; 3531441b7e95e0840e1ae144e5db6f791d6a36bc60Evan Chengclass MDNode; 36bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesenclass SDDbgValue; 37b4e6a5df5dada0cd919cc6e2717eb3118db9cc45Bill Wendlingclass TargetLowering; 38ff7a562751604a9fe13efc75bd59622244b54d35Dan Gohmanclass TargetSelectionDAGInfo; 39fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman 408c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofeiclass SDVTListNode : public FoldingSetNode { 418c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei friend struct FoldingSetTrait<SDVTListNode>; 428c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei /// FastID - A reference to an Interned FoldingSetNodeID for this node. 438c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei /// The Allocator in SelectionDAG holds the data. 448c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei /// SDVTList contains all types which are frequently accessed in SelectionDAG. 458c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei /// The size of this list is not expected big so it won't introduce memory penalty. 468c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei FoldingSetNodeIDRef FastID; 478c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei const EVT *VTs; 488c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei unsigned int NumVTs; 498c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei /// The hash value for SDVTList is fixed so cache it to avoid hash calculation 508c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei unsigned HashValue; 518c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofeipublic: 528c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei SDVTListNode(const FoldingSetNodeIDRef ID, const EVT *VT, unsigned int Num) : 538c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei FastID(ID), VTs(VT), NumVTs(Num) { 548c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei HashValue = ID.ComputeHash(); 558c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei } 568c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei SDVTList getSDVTList() { 578c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei SDVTList result = {VTs, NumVTs}; 588c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei return result; 598c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei } 608c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei}; 618c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei 628c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei// Specialize FoldingSetTrait for SDVTListNode 638c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei// To avoid computing temp FoldingSetNodeID and hash value. 648c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofeitemplate<> struct FoldingSetTrait<SDVTListNode> : DefaultFoldingSetTrait<SDVTListNode> { 658c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei static void Profile(const SDVTListNode &X, FoldingSetNodeID& ID) { 668c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei ID = X.FastID; 678c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei } 688c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei static bool Equals(const SDVTListNode &X, const FoldingSetNodeID &ID, 698c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei unsigned IDHash, FoldingSetNodeID &TempID) { 708c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei if (X.HashValue != IDHash) 718c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei return false; 728c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei return ID == X.FastID; 738c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei } 748c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei static unsigned ComputeHash(const SDVTListNode &X, FoldingSetNodeID &TempID) { 758c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei return X.HashValue; 768c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei } 778c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei}; 788c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei 798e4018e2de52c534405d7155c7009d0b35afb861Cedric Venettemplate<> struct ilist_traits<SDNode> : public ilist_default_traits<SDNode> { 808e4018e2de52c534405d7155c7009d0b35afb861Cedric Venetprivate: 817309be6735666143bd9835b275dc8501617a2591Gabor Greif mutable ilist_half_node<SDNode> Sentinel; 82fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohmanpublic: 83fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman SDNode *createSentinel() const { 84c7f6b8c5d40e17bf43fd3a1549d7d89c9da735e1Gabor Greif return static_cast<SDNode*>(&Sentinel); 85fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman } 86fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman static void destroySentinel(SDNode *) {} 87fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman 88c23b8719ef9d6b1220e854b37d40e9e1c48a82bcGabor Greif SDNode *provideInitialHead() const { return createSentinel(); } 89c23b8719ef9d6b1220e854b37d40e9e1c48a82bcGabor Greif SDNode *ensureHead(SDNode*) const { return createSentinel(); } 90f3841fcbd587c31aa9842b3f33bd57de40c9f443Gabor Greif static void noteHead(SDNode*, SDNode*) {} 91c23b8719ef9d6b1220e854b37d40e9e1c48a82bcGabor Greif 92fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman static void deleteNode(SDNode *) { 9350bee42b54cd9aec5f49566307df2b0cf23afcf6Craig Topper llvm_unreachable("ilist_traits<SDNode> shouldn't see a deleteNode call!"); 94fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman } 95fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohmanprivate: 96fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman static void createNode(const SDNode &); 97fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman}; 98c3aae25116e66c177579b0b79182b09340b19753Chris Lattner 99bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen/// SDDbgInfo - Keeps track of dbg_value information through SDISel. We do 100bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen/// not build SDNodes for these so as not to perturb the generated code; 101bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng/// instead the info is kept off to the side in this structure. Each SDNode may 102bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng/// have one or more associated dbg_value entries. This information is kept in 103bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng/// DbgValMap. 104fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen/// Byval parameters are handled separately because they don't use alloca's, 105fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen/// which busts the normal mechanism. There is good reason for handling all 106fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen/// parameters separately: they may not have code generated for them, they 107fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen/// should always go at the beginning of the function regardless of other code 108fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen/// motion, and debug info for them is potentially useful even if the parameter 109fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen/// is unused. Right now only byval parameters are handled separately. 110bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesenclass SDDbgInfo { 111bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng SmallVector<SDDbgValue*, 32> DbgValues; 112fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen SmallVector<SDDbgValue*, 32> ByvalParmDbgValues; 113f22fd3f7b557a967b1edc1fa9ae770006a39e97cCraig Topper typedef DenseMap<const SDNode*, SmallVector<SDDbgValue*, 2> > DbgValMapType; 114f22fd3f7b557a967b1edc1fa9ae770006a39e97cCraig Topper DbgValMapType DbgValMap; 115bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen 116001d3dc976d7cda8a3dd8c7fd4020b0b96033f4eCraig Topper void operator=(const SDDbgInfo&) LLVM_DELETED_FUNCTION; 117001d3dc976d7cda8a3dd8c7fd4020b0b96033f4eCraig Topper SDDbgInfo(const SDDbgInfo&) LLVM_DELETED_FUNCTION; 118bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesenpublic: 119bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen SDDbgInfo() {} 120bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen 121fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen void add(SDDbgValue *V, const SDNode *Node, bool isParameter) { 122fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen if (isParameter) { 123fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen ByvalParmDbgValues.push_back(V); 124fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen } else DbgValues.push_back(V); 125bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng if (Node) 126d4c6c3a7c3140ce487a805138b6f53f82ff6b783Devang Patel DbgValMap[Node].push_back(V); 127bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen } 128bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng 129bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen void clear() { 130d4c6c3a7c3140ce487a805138b6f53f82ff6b783Devang Patel DbgValMap.clear(); 131bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng DbgValues.clear(); 132fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen ByvalParmDbgValues.clear(); 133bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng } 134bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng 135bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng bool empty() const { 136fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen return DbgValues.empty() && ByvalParmDbgValues.empty(); 137bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen } 138bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng 13922a54c1cd711afccd4558374918d12a939e1cca5Benjamin Kramer ArrayRef<SDDbgValue*> getSDDbgValues(const SDNode *Node) { 140f22fd3f7b557a967b1edc1fa9ae770006a39e97cCraig Topper DbgValMapType::iterator I = DbgValMap.find(Node); 14122a54c1cd711afccd4558374918d12a939e1cca5Benjamin Kramer if (I != DbgValMap.end()) 14222a54c1cd711afccd4558374918d12a939e1cca5Benjamin Kramer return I->second; 14322a54c1cd711afccd4558374918d12a939e1cca5Benjamin Kramer return ArrayRef<SDDbgValue*>(); 144bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen } 145bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng 146f22fd3f7b557a967b1edc1fa9ae770006a39e97cCraig Topper typedef SmallVectorImpl<SDDbgValue*>::iterator DbgIterator; 147bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng DbgIterator DbgBegin() { return DbgValues.begin(); } 148bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng DbgIterator DbgEnd() { return DbgValues.end(); } 149fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen DbgIterator ByvalParmDbgBegin() { return ByvalParmDbgValues.begin(); } 150fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen DbgIterator ByvalParmDbgEnd() { return ByvalParmDbgValues.end(); } 151bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen}; 152bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen 153cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greeneclass SelectionDAG; 154cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hinesvoid checkForCycles(const SelectionDAG *DAG, bool force = false); 155cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene 156c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// SelectionDAG class - This is used to represent a portion of an LLVM function 157c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// in a low-level Data Dependence DAG representation suitable for instruction 158c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// selection. This DAG is constructed as the first step of instruction 159c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// selection in order to allow implementation of machine specific optimizations 160c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// and code simplifications. 161c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// 162c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// The representation used by the SelectionDAG is a target-independent 163c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// representation, which has some similarities to the GCC RTL representation, 164c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// but is significantly more simple, powerful, and is a graph form instead of a 165c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// linear form. 166cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner/// 167cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattnerclass SelectionDAG { 16850d2b1ac029d63500ea9b9347561b1454fa6ed6aDan Gohman const TargetMachine &TM; 169ff7a562751604a9fe13efc75bd59622244b54d35Dan Gohman const TargetSelectionDAGInfo &TSI; 170ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling const TargetLowering *TLI; 1717c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman MachineFunction *MF; 172512063dd0f91a76b9dd904dfff72a52b4d09e89fChris Lattner LLVMContext *Context; 1730508d047fefef36d4f943ee13c82c18cf3a943abDevang Patel CodeGenOpt::Level OptLevel; 174cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 175f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman /// EntryNode - The starting token. 176f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman SDNode EntryNode; 177f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman 178f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman /// Root - The root of the entire DAG. 179f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman SDValue Root; 180cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 181213a16c637926bfc38ba373d3aba6778e181e3ecChris Lattner /// AllNodes - A linked list of nodes in the current DAG. 182fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman ilist<SDNode> AllNodes; 183fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman 184f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman /// NodeAllocatorType - The AllocatorType for allocating SDNodes. We use 185f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman /// pool allocation with recycling. 186f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman typedef RecyclingAllocator<BumpPtrAllocator, SDNode, sizeof(LargestSDNode), 187f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman AlignOf<MostAlignedSDNode>::Alignment> 188f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman NodeAllocatorType; 189f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman 190f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman /// NodeAllocator - Pool allocation for nodes. 191f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman NodeAllocatorType NodeAllocator; 192691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth 193213a16c637926bfc38ba373d3aba6778e181e3ecChris Lattner /// CSEMap - This structure is used to memoize nodes, automatically performing 194d23b33435ae722ff5aa5ab97135a4f31041959e2Bob Wilson /// CSE with existing nodes when a duplicate is requested. 195583bd47f777fe3eb8305872fa0eadab31e833dffJim Laskey FoldingSet<SDNode> CSEMap; 196213a16c637926bfc38ba373d3aba6778e181e3ecChris Lattner 197f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman /// OperandAllocator - Pool allocation for machine-opcode SDNode operands. 198f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman BumpPtrAllocator OperandAllocator; 199f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman 200e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// Allocator - Pool allocation for misc. objects that are created once per 201e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// SelectionDAG. 202e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman BumpPtrAllocator Allocator; 203e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman 204bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen /// DbgInfo - Tracks dbg_value information through SDISel. 205bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen SDDbgInfo *DbgInfo; 206bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen 207bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesenpublic: 208bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// DAGUpdateListener - Clients of various APIs that cause global effects on 209bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// the DAG can optionally implement this interface. This allows the clients 210bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// to handle the various sorts of updates that happen. 211bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// 212bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// A DAGUpdateListener automatically registers itself with DAG when it is 213bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// constructed, and removes itself when destroyed in RAII fashion. 214bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen struct DAGUpdateListener { 215bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen DAGUpdateListener *const Next; 216bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen SelectionDAG &DAG; 217bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen 218bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen explicit DAGUpdateListener(SelectionDAG &D) 219bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen : Next(D.UpdateListeners), DAG(D) { 220bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen DAG.UpdateListeners = this; 221bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen } 222bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen 223bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen virtual ~DAGUpdateListener() { 224bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen assert(DAG.UpdateListeners == this && 225bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen "DAGUpdateListeners must be destroyed in LIFO order"); 226bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen DAG.UpdateListeners = Next; 227bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen } 228bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen 229bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// NodeDeleted - The node N that was deleted and, if E is not null, an 230bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// equivalent node E that replaced it. 231bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen virtual void NodeDeleted(SDNode *N, SDNode *E); 232bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen 233bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// NodeUpdated - The node N that was updated. 234bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen virtual void NodeUpdated(SDNode *N); 235bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen }; 236bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen 237ea28aafa83fc2b6dd632041278c9a18e5a2b2b41Daniel Sanders /// NewNodesMustHaveLegalTypes - When true, additional steps are taken to 238ea28aafa83fc2b6dd632041278c9a18e5a2b2b41Daniel Sanders /// ensure that getConstant() and similar functions return DAG nodes that 239ea28aafa83fc2b6dd632041278c9a18e5a2b2b41Daniel Sanders /// have legal types. This is important after type legalization since 240ea28aafa83fc2b6dd632041278c9a18e5a2b2b41Daniel Sanders /// any illegally typed nodes generated after this point will not experience 241ea28aafa83fc2b6dd632041278c9a18e5a2b2b41Daniel Sanders /// type legalization. 242ea28aafa83fc2b6dd632041278c9a18e5a2b2b41Daniel Sanders bool NewNodesMustHaveLegalTypes; 243ea28aafa83fc2b6dd632041278c9a18e5a2b2b41Daniel Sanders 244bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesenprivate: 245bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// DAGUpdateListener is a friend so it can manipulate the listener stack. 246bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen friend struct DAGUpdateListener; 247bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen 248bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// UpdateListeners - Linked list of registered DAGUpdateListener instances. 249bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// This stack is maintained by DAGUpdateListener RAII. 250bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen DAGUpdateListener *UpdateListeners; 251bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen 252c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene /// setGraphColorHelper - Implementation of setSubgraphColor. 253c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene /// Return whether we had to truncate the search. 254c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene /// 255c23b8719ef9d6b1220e854b37d40e9e1c48a82bcGabor Greif bool setSubgraphColorHelper(SDNode *N, const char *Color, 256c23b8719ef9d6b1220e854b37d40e9e1c48a82bcGabor Greif DenseSet<SDNode *> &visited, 257c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene int level, bool &printed); 258c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene 259001d3dc976d7cda8a3dd8c7fd4020b0b96033f4eCraig Topper void operator=(const SelectionDAG&) LLVM_DELETED_FUNCTION; 260001d3dc976d7cda8a3dd8c7fd4020b0b96033f4eCraig Topper SelectionDAG(const SelectionDAG&) LLVM_DELETED_FUNCTION; 261819309efec6f11ba752bd7cbfe186495745f020bDaniel Dunbar 262cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattnerpublic: 2630508d047fefef36d4f943ee13c82c18cf3a943abDevang Patel explicit SelectionDAG(const TargetMachine &TM, llvm::CodeGenOpt::Level); 264cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner ~SelectionDAG(); 265cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 2667c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman /// init - Prepare this SelectionDAG to process code in the given 2677c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman /// MachineFunction. 2687c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman /// 26936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines void init(MachineFunction &mf, const TargetLowering *TLI); 2707c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman 2717c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman /// clear - Clear state and free memory necessary to make this 272f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman /// SelectionDAG ready to process a new block. 273f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman /// 2747c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman void clear(); 275f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman 2767c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman MachineFunction &getMachineFunction() const { return *MF; } 27750d2b1ac029d63500ea9b9347561b1454fa6ed6aDan Gohman const TargetMachine &getTarget() const { return TM; } 278ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling const TargetLowering &getTargetLoweringInfo() const { return *TLI; } 279ff7a562751604a9fe13efc75bd59622244b54d35Dan Gohman const TargetSelectionDAGInfo &getSelectionDAGInfo() const { return TSI; } 280d1474d09cbe5fdeec8ba0d6c6b52f316f3422532Owen Anderson LLVMContext *getContext() const {return Context; } 281cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 282ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey /// viewGraph - Pop up a GraphViz/gv window with the DAG rendered using 'dot'. 2831080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner /// 284462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman void viewGraph(const std::string &Title); 2850b12aef49087b57d276ed760a83525d1e2602144Dan Gohman void viewGraph(); 286fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 287ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey#ifndef NDEBUG 288ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey std::map<const SDNode *, std::string> NodeGraphAttrs; 289ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey#endif 2901080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner 291ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey /// clearGraphAttrs - Clear all previously defined node graph attributes. 292ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey /// Intended to be used from a debugging tool (eg. gdb). 293ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey void clearGraphAttrs(); 294fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 295ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey /// setGraphAttrs - Set graph attributes for a node. (eg. "color=red".) 296ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey /// 297ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey void setGraphAttrs(const SDNode *N, const char *Attrs); 298fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 299ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey /// getGraphAttrs - Get graph attributes for a node. (eg. "color=red".) 300ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey /// Used from getNodeAttributes. 301ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey const std::string getGraphAttrs(const SDNode *N) const; 302fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 303ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey /// setGraphColor - Convenience for setting node color attribute. 304ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey /// 305ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey void setGraphColor(const SDNode *N, const char *Color); 3061080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner 307c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene /// setGraphColor - Convenience for setting subgraph color attribute. 308c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene /// 309c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene void setSubgraphColor(SDNode *N, const char *Color); 310c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene 311fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman typedef ilist<SDNode>::const_iterator allnodes_const_iterator; 312b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner allnodes_const_iterator allnodes_begin() const { return AllNodes.begin(); } 313b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner allnodes_const_iterator allnodes_end() const { return AllNodes.end(); } 314fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman typedef ilist<SDNode>::iterator allnodes_iterator; 315b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner allnodes_iterator allnodes_begin() { return AllNodes.begin(); } 316b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner allnodes_iterator allnodes_end() { return AllNodes.end(); } 317fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman ilist<SDNode>::size_type allnodes_size() const { 3180e5f1306b059b62d7725f324e087efbc8e7a782dDan Gohman return AllNodes.size(); 3190e5f1306b059b62d7725f324e087efbc8e7a782dDan Gohman } 320fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 321c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// getRoot - Return the root tag of the SelectionDAG. 322cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner /// 323475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue &getRoot() const { return Root; } 324cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 325c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// getEntryNode - Return the token chain corresponding to the entry of the 326c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// function. 327f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman SDValue getEntryNode() const { 328f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman return SDValue(const_cast<SDNode *>(&EntryNode), 0); 329f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman } 330cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 331c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// setRoot - Set the current root tag of the SelectionDAG. 332cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner /// 333475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue &setRoot(SDValue N) { 334825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson assert((!N.getNode() || N.getValueType() == MVT::Other) && 335acaf09dbe4a6781163857db1321bbd5795e7d410Dan Gohman "DAG root value is not a chain!"); 336cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene if (N.getNode()) 337cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines checkForCycles(N.getNode(), this); 338cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene Root = N; 339cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene if (N.getNode()) 340cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene checkForCycles(this); 341cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene return Root; 342acaf09dbe4a6781163857db1321bbd5795e7d410Dan Gohman } 343cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 3441d4d41411190dd9e62764e56713753d4155764ddNate Begeman /// Combine - This iterates over the nodes in the SelectionDAG, folding 34525cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands /// certain types of nodes together, or eliminating superfluous nodes. The 34625cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands /// Level argument controls whether Combine is allowed to produce nodes and 34725cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands /// types that are illegal on the target. 34898a366d547772010e94609e4584489b3e5ce0043Bill Wendling void Combine(CombineLevel Level, AliasAnalysis &AA, 34998a366d547772010e94609e4584489b3e5ce0043Bill Wendling CodeGenOpt::Level OptLevel); 35025cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands 35101d029b82cb08367d81aa10cdc94d05360466649Chris Lattner /// LegalizeTypes - This transforms the SelectionDAG into a SelectionDAG that 35225cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands /// only uses types natively supported by the target. Returns "true" if it 35325cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands /// made any changes. 35401d029b82cb08367d81aa10cdc94d05360466649Chris Lattner /// 35501d029b82cb08367d81aa10cdc94d05360466649Chris Lattner /// Note that this is an involved process that may invalidate pointers into 35601d029b82cb08367d81aa10cdc94d05360466649Chris Lattner /// the graph. 35725cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands bool LegalizeTypes(); 35825cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands 359c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// Legalize - This transforms the SelectionDAG into a SelectionDAG that is 360c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// compatible with the target instruction selector, as indicated by the 361c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// TargetLowering object. 362cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner /// 363c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// Note that this is an involved process that may invalidate pointers into 364c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// the graph. 365975716af1b9a09274df6c2d92683449015bd8564Dan Gohman void Legalize(); 366c3aae25116e66c177579b0b79182b09340b19753Chris Lattner 3675c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// LegalizeVectors - This transforms the SelectionDAG into a SelectionDAG 3685c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// that only uses vector math operations supported by the target. This is 3695c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// necessary as a separate step from Legalize because unrolling a vector 3705c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// operation can introduce illegal types, which requires running 3715c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// LegalizeTypes again. 3725c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// 3735c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// This returns true if it made any changes; in that case, LegalizeTypes 3745c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// is called again before Legalize. 3755c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// 3765c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// Note that this is an involved process that may invalidate pointers into 3775c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// the graph. 3785c22c8074404797f1313b1334757254fb5c6487aEli Friedman bool LegalizeVectors(); 3795c22c8074404797f1313b1334757254fb5c6487aEli Friedman 380d1fc96499b7619356c7542200d32da898b79f7c1Chris Lattner /// RemoveDeadNodes - This method deletes all unreachable nodes in the 381190a418bf6b49a4ef1c1980229a2f0d516e8a2cdChris Lattner /// SelectionDAG. 382190a418bf6b49a4ef1c1980229a2f0d516e8a2cdChris Lattner void RemoveDeadNodes(); 383130a6471b90f66e99b1f9f42877fdf611c330ac6Evan Cheng 384130a6471b90f66e99b1f9f42877fdf611c330ac6Evan Cheng /// DeleteNode - Remove the specified node from the system. This node must 385130a6471b90f66e99b1f9f42877fdf611c330ac6Evan Cheng /// have no referrers. 386130a6471b90f66e99b1f9f42877fdf611c330ac6Evan Cheng void DeleteNode(SDNode *N); 387130a6471b90f66e99b1f9f42877fdf611c330ac6Evan Cheng 38870046e920fa37989a041af663ada2b2b646e258fChris Lattner /// getVTList - Return an SDVTList that represents the list of values 38970046e920fa37989a041af663ada2b2b646e258fChris Lattner /// specified. 390e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDVTList getVTList(EVT VT); 391e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDVTList getVTList(EVT VT1, EVT VT2); 392e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3); 393e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3, EVT VT4); 394dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SDVTList getVTList(ArrayRef<EVT> VTs); 395fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 3961b1a49714ef26225a42199cf2930529f31868322Chris Lattner //===--------------------------------------------------------------------===// 39770046e920fa37989a041af663ada2b2b646e258fChris Lattner // Node creation methods. 39870046e920fa37989a041af663ada2b2b646e258fChris Lattner // 39936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SDValue getConstant(uint64_t Val, EVT VT, bool isTarget = false, 40036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool isOpaque = false); 40136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SDValue getConstant(const APInt &Val, EVT VT, bool isTarget = false, 40236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool isOpaque = false); 40336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SDValue getConstant(const ConstantInt &Val, EVT VT, bool isTarget = false, 40436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool isOpaque = false); 405475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue getIntPtrConstant(uint64_t Val, bool isTarget = false); 40636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SDValue getTargetConstant(uint64_t Val, EVT VT, bool isOpaque = false) { 40736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return getConstant(Val, VT, true, isOpaque); 408cbea3045ce0bdd061c494a831d0ce2d5834211ccChris Lattner } 40936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SDValue getTargetConstant(const APInt &Val, EVT VT, bool isOpaque = false) { 41036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return getConstant(Val, VT, true, isOpaque); 4116394b099e836f56a937cdcc7332c9487b504ca68Dan Gohman } 41236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SDValue getTargetConstant(const ConstantInt &Val, EVT VT, 41336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool isOpaque = false) { 41436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return getConstant(Val, VT, true, isOpaque); 4154fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman } 4160a406ae0d940d92c51ee145b48ff7a483a366849Dale Johannesen // The forms below that take a double should only be used for simple 4170a406ae0d940d92c51ee145b48ff7a483a366849Dale Johannesen // constants that can be exactly represented in VT. No checks are made. 418e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getConstantFP(double Val, EVT VT, bool isTarget = false); 419e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getConstantFP(const APFloat& Val, EVT VT, bool isTarget = false); 420e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getConstantFP(const ConstantFP &CF, EVT VT, bool isTarget = false); 421e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getTargetConstantFP(double Val, EVT VT) { 422c9f8f416800784ca6453222b307bc44ad24739b0Chris Lattner return getConstantFP(Val, VT, true); 423c9f8f416800784ca6453222b307bc44ad24739b0Chris Lattner } 424e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getTargetConstantFP(const APFloat& Val, EVT VT) { 425f04afdbb48568ef09f11fd10ac03426101f2dbf8Dale Johannesen return getConstantFP(Val, VT, true); 426f04afdbb48568ef09f11fd10ac03426101f2dbf8Dale Johannesen } 427e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getTargetConstantFP(const ConstantFP &Val, EVT VT) { 4284fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman return getConstantFP(Val, VT, true); 4294fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman } 430ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getGlobalAddress(const GlobalValue *GV, SDLoc DL, EVT VT, 4312a4ed82ce2ba4a02f2a02eb4ed8ce5186f3f93daChris Lattner int64_t offset = 0, bool isTargetGA = false, 4322a4ed82ce2ba4a02f2a02eb4ed8ce5186f3f93daChris Lattner unsigned char TargetFlags = 0); 433ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getTargetGlobalAddress(const GlobalValue *GV, SDLoc DL, EVT VT, 4342a4ed82ce2ba4a02f2a02eb4ed8ce5186f3f93daChris Lattner int64_t offset = 0, 4352a4ed82ce2ba4a02f2a02eb4ed8ce5186f3f93daChris Lattner unsigned char TargetFlags = 0) { 4360d881dabc1a4e1aefad6dd38de166d8358285638Devang Patel return getGlobalAddress(GV, DL, VT, offset, true, TargetFlags); 437cbea3045ce0bdd061c494a831d0ce2d5834211ccChris Lattner } 438e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getFrameIndex(int FI, EVT VT, bool isTarget = false); 439e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getTargetFrameIndex(int FI, EVT VT) { 440c9f8f416800784ca6453222b307bc44ad24739b0Chris Lattner return getFrameIndex(FI, VT, true); 441c9f8f416800784ca6453222b307bc44ad24739b0Chris Lattner } 442e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getJumpTable(int JTI, EVT VT, bool isTarget = false, 443f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner unsigned char TargetFlags = 0); 444e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getTargetJumpTable(int JTI, EVT VT, unsigned char TargetFlags = 0) { 445f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner return getJumpTable(JTI, VT, true, TargetFlags); 446c9f8f416800784ca6453222b307bc44ad24739b0Chris Lattner } 44746510a73e977273ec67747eb34cbdb43f815e451Dan Gohman SDValue getConstantPool(const Constant *C, EVT VT, 448f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner unsigned Align = 0, int Offs = 0, bool isT=false, 449f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner unsigned char TargetFlags = 0); 45046510a73e977273ec67747eb34cbdb43f815e451Dan Gohman SDValue getTargetConstantPool(const Constant *C, EVT VT, 451f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner unsigned Align = 0, int Offset = 0, 452f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner unsigned char TargetFlags = 0) { 453f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner return getConstantPool(C, VT, Align, Offset, true, TargetFlags); 454c9f8f416800784ca6453222b307bc44ad24739b0Chris Lattner } 455e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getConstantPool(MachineConstantPoolValue *C, EVT VT, 456f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner unsigned Align = 0, int Offs = 0, bool isT=false, 457f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner unsigned char TargetFlags = 0); 458475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue getTargetConstantPool(MachineConstantPoolValue *C, 459e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT, unsigned Align = 0, 460f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner int Offset = 0, unsigned char TargetFlags=0) { 461f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner return getConstantPool(C, VT, Align, Offset, true, TargetFlags); 462d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng } 46374500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen SDValue getTargetIndex(int Index, EVT VT, int64_t Offset = 0, 46474500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen unsigned char TargetFlags = 0); 4658ad9b43e690e8773cf836b30e8da26bc71e18844Dale Johannesen // When generating a branch to a BB, we don't in general know enough 4668ad9b43e690e8773cf836b30e8da26bc71e18844Dale Johannesen // to provide debug info for the BB at that time, so keep this one around. 467475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue getBasicBlock(MachineBasicBlock *MBB); 468ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getBasicBlock(MachineBasicBlock *MBB, SDLoc dl); 469e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getExternalSymbol(const char *Sym, EVT VT); 470ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getExternalSymbol(const char *Sym, SDLoc dl, EVT VT); 471e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getTargetExternalSymbol(const char *Sym, EVT VT, 4721af2231da64a14d638406d133c7912bfc1c8a9ceChris Lattner unsigned char TargetFlags = 0); 473e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getValueType(EVT); 474e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getRegister(unsigned Reg, EVT VT); 4759cf37e8b48732fccd4c301ed51aafed7074bd84eJakob Stoklund Olesen SDValue getRegisterMask(const uint32_t *RegMask); 476ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getEHLabel(SDLoc dl, SDValue Root, MCSymbol *Label); 47746510a73e977273ec67747eb34cbdb43f815e451Dan Gohman SDValue getBlockAddress(const BlockAddress *BA, EVT VT, 4786c7ccaa3fd1d6e96d0bf922554b09d2b17c3b0e3Michael Liao int64_t Offset = 0, bool isTarget = false, 4796c7ccaa3fd1d6e96d0bf922554b09d2b17c3b0e3Michael Liao unsigned char TargetFlags = 0); 4806c7ccaa3fd1d6e96d0bf922554b09d2b17c3b0e3Michael Liao SDValue getTargetBlockAddress(const BlockAddress *BA, EVT VT, 4816c7ccaa3fd1d6e96d0bf922554b09d2b17c3b0e3Michael Liao int64_t Offset = 0, 4826c7ccaa3fd1d6e96d0bf922554b09d2b17c3b0e3Michael Liao unsigned char TargetFlags = 0) { 4836c7ccaa3fd1d6e96d0bf922554b09d2b17c3b0e3Michael Liao return getBlockAddress(BA, VT, Offset, true, TargetFlags); 4846c7ccaa3fd1d6e96d0bf922554b09d2b17c3b0e3Michael Liao } 485c3aae25116e66c177579b0b79182b09340b19753Chris Lattner 486ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getCopyToReg(SDValue Chain, SDLoc dl, unsigned Reg, SDValue N) { 487825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return getNode(ISD::CopyToReg, dl, MVT::Other, Chain, 4880f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen getRegister(Reg, N.getValueType()), N); 4890f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen } 490cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 491e3f1026683c38f6605ccaf698b7082f1b0a0f8c8Chris Lattner // This version of the getCopyToReg method takes an extra operand, which 49229d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner // indicates that there is potentially an incoming glue value (if Glue is not 49329d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner // null) and that there should be a glue result. 494ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getCopyToReg(SDValue Chain, SDLoc dl, unsigned Reg, SDValue N, 49529d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner SDValue Glue) { 496f1b4eafbfec976f939ec0ea3e8acf91cef5363e3Chris Lattner SDVTList VTs = getVTList(MVT::Other, MVT::Glue); 49729d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner SDValue Ops[] = { Chain, getRegister(Reg, N.getValueType()), N, Glue }; 498dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return getNode(ISD::CopyToReg, dl, VTs, 499dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ArrayRef<SDValue>(Ops, Glue.getNode() ? 4 : 3)); 5000f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen } 50166a48bbc3565b40ea0e6f2d58cf5e3a8e64802efEvan Cheng 502475871a144eb604ddaf37503397ba0941442e5fbDan Gohman // Similar to last getCopyToReg() except parameter Reg is a SDValue 503ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getCopyToReg(SDValue Chain, SDLoc dl, SDValue Reg, SDValue N, 50429d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner SDValue Glue) { 505f1b4eafbfec976f939ec0ea3e8acf91cef5363e3Chris Lattner SDVTList VTs = getVTList(MVT::Other, MVT::Glue); 50629d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner SDValue Ops[] = { Chain, Reg, N, Glue }; 507dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return getNode(ISD::CopyToReg, dl, VTs, 508dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ArrayRef<SDValue>(Ops, Glue.getNode() ? 4 : 3)); 5090f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen } 510fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 511ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getCopyFromReg(SDValue Chain, SDLoc dl, unsigned Reg, EVT VT) { 512825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson SDVTList VTs = getVTList(VT, MVT::Other); 5130f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen SDValue Ops[] = { Chain, getRegister(Reg, VT) }; 514dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return getNode(ISD::CopyFromReg, dl, VTs, Ops); 5150f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen } 516fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 517e3f1026683c38f6605ccaf698b7082f1b0a0f8c8Chris Lattner // This version of the getCopyFromReg method takes an extra operand, which 51829d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner // indicates that there is potentially an incoming glue value (if Glue is not 51929d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner // null) and that there should be a glue result. 520ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getCopyFromReg(SDValue Chain, SDLoc dl, unsigned Reg, EVT VT, 52129d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner SDValue Glue) { 522f1b4eafbfec976f939ec0ea3e8acf91cef5363e3Chris Lattner SDVTList VTs = getVTList(VT, MVT::Other, MVT::Glue); 52329d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner SDValue Ops[] = { Chain, getRegister(Reg, VT), Glue }; 524dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return getNode(ISD::CopyFromReg, dl, VTs, 525dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ArrayRef<SDValue>(Ops, Glue.getNode() ? 3 : 2)); 5260f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen } 52718c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner 528475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue getCondCode(ISD::CondCode Cond); 529cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 53077cdf30742284a173fe818417eb482224cdee8d4Mon P Wang /// Returns the ConvertRndSat Note: Avoid using this node because it may 53177cdf30742284a173fe818417eb482224cdee8d4Mon P Wang /// disappear in the future and most targets don't support it. 532ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getConvertRndSat(EVT VT, SDLoc dl, SDValue Val, SDValue DTy, 5330f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen SDValue STy, 5340f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen SDValue Rnd, SDValue Sat, ISD::CvtCode Code); 5356154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson 5369008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman /// getVectorShuffle - Return an ISD::VECTOR_SHUFFLE node. The number of 5379008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman /// elements in VT, which must be a vector type, must match the number of 5385a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman /// mask elements NumElts. A integer mask element equal to -1 is treated as 5399008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman /// undefined. 540ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getVectorShuffle(EVT VT, SDLoc dl, SDValue N1, SDValue N2, 5419008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman const int *MaskElts); 542cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue getVectorShuffle(EVT VT, SDLoc dl, SDValue N1, SDValue N2, 543cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines ArrayRef<int> MaskElts) { 544cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines assert(VT.getVectorNumElements() == MaskElts.size() && 545cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines "Must have the same number of vector elements as mask elements!"); 546cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines return getVectorShuffle(VT, dl, N1, N2, MaskElts.data()); 547cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines } 54877cdf30742284a173fe818417eb482224cdee8d4Mon P Wang 549a3c42f3d4e5d14c8f4fb9bb123e7759c425d041bNadav Rotem /// getAnyExtOrTrunc - Convert Op, which must be of integer type, to the 550a3c42f3d4e5d14c8f4fb9bb123e7759c425d041bNadav Rotem /// integer type VT, by either any-extending or truncating it. 551ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getAnyExtOrTrunc(SDValue Op, SDLoc DL, EVT VT); 552a3c42f3d4e5d14c8f4fb9bb123e7759c425d041bNadav Rotem 5533a66a68b0cc81193abfc074b1d360a4950151d38Duncan Sands /// getSExtOrTrunc - Convert Op, which must be of integer type, to the 5543a66a68b0cc81193abfc074b1d360a4950151d38Duncan Sands /// integer type VT, by either sign-extending or truncating it. 555ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getSExtOrTrunc(SDValue Op, SDLoc DL, EVT VT); 5563a66a68b0cc81193abfc074b1d360a4950151d38Duncan Sands 5573a66a68b0cc81193abfc074b1d360a4950151d38Duncan Sands /// getZExtOrTrunc - Convert Op, which must be of integer type, to the 5583a66a68b0cc81193abfc074b1d360a4950151d38Duncan Sands /// integer type VT, by either zero-extending or truncating it. 559ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getZExtOrTrunc(SDValue Op, SDLoc DL, EVT VT); 5603a66a68b0cc81193abfc074b1d360a4950151d38Duncan Sands 5611ccae666f596d5aeca5c9942995763600b622062Chris Lattner /// getZeroExtendInReg - Return the expression required to zero extend the Op 5621ccae666f596d5aeca5c9942995763600b622062Chris Lattner /// value assuming it was the smaller SrcTy value. 563ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getZeroExtendInReg(SDValue Op, SDLoc DL, EVT SrcTy); 564fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 565cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// getAnyExtendVectorInReg - Return an operation which will any-extend the 566cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// low lanes of the operand into the specified vector type. For example, 567cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// this can convert a v16i8 into a v4i32 by any-extending the low four 568cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// lanes of the operand from i8 to i32. 569cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue getAnyExtendVectorInReg(SDValue Op, SDLoc DL, EVT VT); 570cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 571cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// getSignExtendVectorInReg - Return an operation which will sign extend the 572cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// low lanes of the operand into the specified vector type. For example, 573cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// this can convert a v16i8 into a v4i32 by sign extending the low four 574cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// lanes of the operand from i8 to i32. 575cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue getSignExtendVectorInReg(SDValue Op, SDLoc DL, EVT VT); 576cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 577cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// getZeroExtendVectorInReg - Return an operation which will zero extend the 578cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// low lanes of the operand into the specified vector type. For example, 579cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// this can convert a v16i8 into a v4i32 by zero extending the low four 580cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// lanes of the operand from i8 to i32. 581cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue getZeroExtendVectorInReg(SDValue Op, SDLoc DL, EVT VT); 582cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 583dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines /// getBoolExtOrTrunc - Convert Op, which must be of integer type, to the 584dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines /// integer type VT, by using an extension appropriate for the target's 585cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// BooleanContent for type OpVT or truncating it. 586cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue getBoolExtOrTrunc(SDValue Op, SDLoc SL, EVT VT, EVT OpVT); 587dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 5884c2454623841f05c6c665659b34c214950d12d7eBob Wilson /// getNOT - Create a bitwise NOT operation as (XOR Val, -1). 589ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getNOT(SDLoc DL, SDValue Val, EVT VT); 5904c2454623841f05c6c665659b34c214950d12d7eBob Wilson 591dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines /// \brief Create a logical NOT operation as (XOR Val, BooleanOne). 592dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SDValue getLogicalNOT(SDLoc DL, SDValue Val, EVT VT); 593dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 5946a5b6d7633c96c72ca7d5f8ba0c855e4690ada04Chris Lattner /// getCALLSEQ_START - Return a new CALLSEQ_START node, which always must have 59529d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner /// a glue result (to ensure it's not CSE'd). CALLSEQ_START does not have a 596ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick /// useful SDLoc. 5976e0b2a0cb0d398f175a5294bf0ad5488c714e8c2Andrew Trick SDValue getCALLSEQ_START(SDValue Chain, SDValue Op, SDLoc DL) { 598f1b4eafbfec976f939ec0ea3e8acf91cef5363e3Chris Lattner SDVTList VTs = getVTList(MVT::Other, MVT::Glue); 599475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Chain, Op }; 600dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return getNode(ISD::CALLSEQ_START, DL, VTs, Ops); 6016a5b6d7633c96c72ca7d5f8ba0c855e4690ada04Chris Lattner } 6021ccae666f596d5aeca5c9942995763600b622062Chris Lattner 6030f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling /// getCALLSEQ_END - Return a new CALLSEQ_END node, which always must have a 60429d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner /// glue result (to ensure it's not CSE'd). CALLSEQ_END does not have 605ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick /// a useful SDLoc. 606475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue getCALLSEQ_END(SDValue Chain, SDValue Op1, SDValue Op2, 6076e0b2a0cb0d398f175a5294bf0ad5488c714e8c2Andrew Trick SDValue InGlue, SDLoc DL) { 608f1b4eafbfec976f939ec0ea3e8acf91cef5363e3Chris Lattner SDVTList NodeTys = getVTList(MVT::Other, MVT::Glue); 609475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 4> Ops; 6100f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling Ops.push_back(Chain); 6110f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling Ops.push_back(Op1); 6120f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling Ops.push_back(Op2); 613dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (InGlue.getNode()) 614dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Ops.push_back(InGlue); 615dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return getNode(ISD::CALLSEQ_END, DL, NodeTys, Ops); 6160f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling } 6170f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling 618ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick /// getUNDEF - Return an UNDEF node. UNDEF does not have a useful SDLoc. 619e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getUNDEF(EVT VT) { 620ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick return getNode(ISD::UNDEF, SDLoc(), VT); 621e8d7230f480654cdb8ff1c3d0a38e1e9ab0bd55fDale Johannesen } 622e8d7230f480654cdb8ff1c3d0a38e1e9ab0bd55fDale Johannesen 623b300d2aa3ef08b5074449e2c05804717f488f4e4Dale Johannesen /// getGLOBAL_OFFSET_TABLE - Return a GLOBAL_OFFSET_TABLE node. This does 624ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick /// not have a useful SDLoc. 625e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getGLOBAL_OFFSET_TABLE(EVT VT) { 626ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick return getNode(ISD::GLOBAL_OFFSET_TABLE, SDLoc(), VT); 627b300d2aa3ef08b5074449e2c05804717f488f4e4Dale Johannesen } 628b300d2aa3ef08b5074449e2c05804717f488f4e4Dale Johannesen 629c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// getNode - Gets or creates the specified node. 630cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner /// 631ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getNode(unsigned Opcode, SDLoc DL, EVT VT); 632ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getNode(unsigned Opcode, SDLoc DL, EVT VT, SDValue N); 633cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue getNode(unsigned Opcode, SDLoc DL, EVT VT, SDValue N1, SDValue N2, 634cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines bool nuw = false, bool nsw = false, bool exact = false); 635cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue getNode(unsigned Opcode, SDLoc DL, EVT VT, SDValue N1, SDValue N2, 636cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue N3); 637cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue getNode(unsigned Opcode, SDLoc DL, EVT VT, SDValue N1, SDValue N2, 638cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue N3, SDValue N4); 639cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue getNode(unsigned Opcode, SDLoc DL, EVT VT, SDValue N1, SDValue N2, 640cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue N3, SDValue N4, SDValue N5); 641dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SDValue getNode(unsigned Opcode, SDLoc DL, EVT VT, ArrayRef<SDUse> Ops); 642ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getNode(unsigned Opcode, SDLoc DL, EVT VT, 643dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ArrayRef<SDValue> Ops); 644ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getNode(unsigned Opcode, SDLoc DL, 6453853f74aba301ef08b699bac2fa8e53230714a58Benjamin Kramer ArrayRef<EVT> ResultTys, 646dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ArrayRef<SDValue> Ops); 647ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getNode(unsigned Opcode, SDLoc DL, SDVTList VTs, 648dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ArrayRef<SDValue> Ops); 649ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getNode(unsigned Opcode, SDLoc DL, SDVTList VTs); 650ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getNode(unsigned Opcode, SDLoc DL, SDVTList VTs, SDValue N); 651ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getNode(unsigned Opcode, SDLoc DL, SDVTList VTs, 6527ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue N1, SDValue N2); 653ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getNode(unsigned Opcode, SDLoc DL, SDVTList VTs, 6547ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue N1, SDValue N2, SDValue N3); 655ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getNode(unsigned Opcode, SDLoc DL, SDVTList VTs, 6567ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue N1, SDValue N2, SDValue N3, SDValue N4); 657ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getNode(unsigned Opcode, SDLoc DL, SDVTList VTs, 6587ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue N1, SDValue N2, SDValue N3, SDValue N4, 6597ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue N5); 660475871a144eb604ddaf37503397ba0941442e5fbDan Gohman 66198ca4f2a325f72374a477f9deba7d09e8999c29bDan Gohman /// getStackArgumentTokenFactor - Compute a TokenFactor to force all 66298ca4f2a325f72374a477f9deba7d09e8999c29bDan Gohman /// the incoming stack arguments to be loaded from the stack. This is 66398ca4f2a325f72374a477f9deba7d09e8999c29bDan Gohman /// used in tail call lowering to protect stack arguments from being 66498ca4f2a325f72374a477f9deba7d09e8999c29bDan Gohman /// clobbered. 66598ca4f2a325f72374a477f9deba7d09e8999c29bDan Gohman SDValue getStackArgumentTokenFactor(SDValue Chain); 66698ca4f2a325f72374a477f9deba7d09e8999c29bDan Gohman 667ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getMemcpy(SDValue Chain, SDLoc dl, SDValue Dst, SDValue Src, 66820adc9dc4650313f017b27d9818eb2176238113dMon P Wang SDValue Size, unsigned Align, bool isVol, bool AlwaysInline, 669e72f2027e9116c55a5b39ac72732df8d6c45d37cChris Lattner MachinePointerInfo DstPtrInfo, 670e72f2027e9116c55a5b39ac72732df8d6c45d37cChris Lattner MachinePointerInfo SrcPtrInfo); 6715c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola 672ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getMemmove(SDValue Chain, SDLoc dl, SDValue Dst, SDValue Src, 67320adc9dc4650313f017b27d9818eb2176238113dMon P Wang SDValue Size, unsigned Align, bool isVol, 674e72f2027e9116c55a5b39ac72732df8d6c45d37cChris Lattner MachinePointerInfo DstPtrInfo, 675e72f2027e9116c55a5b39ac72732df8d6c45d37cChris Lattner MachinePointerInfo SrcPtrInfo); 6765c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola 677ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getMemset(SDValue Chain, SDLoc dl, SDValue Dst, SDValue Src, 67820adc9dc4650313f017b27d9818eb2176238113dMon P Wang SDValue Size, unsigned Align, bool isVol, 679e72f2027e9116c55a5b39ac72732df8d6c45d37cChris Lattner MachinePointerInfo DstPtrInfo); 6805c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola 6817cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner /// getSetCC - Helper function to make it easier to build SetCC's if you just 682475871a144eb604ddaf37503397ba0941442e5fbDan Gohman /// have an ISD::CondCode instead of an SDValue. 6837cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner /// 684ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getSetCC(SDLoc DL, EVT VT, SDValue LHS, SDValue RHS, 685d69c3141ed6d237ad19fdfbfcef8901491b24c2eBill Wendling ISD::CondCode Cond) { 68628b77e968d2b01fc9da724762bd8ddcd80650e32Duncan Sands assert(LHS.getValueType().isVector() == RHS.getValueType().isVector() && 68728b77e968d2b01fc9da724762bd8ddcd80650e32Duncan Sands "Cannot compare scalars to vectors"); 68828b77e968d2b01fc9da724762bd8ddcd80650e32Duncan Sands assert(LHS.getValueType().isVector() == VT.isVector() && 68928b77e968d2b01fc9da724762bd8ddcd80650e32Duncan Sands "Cannot compare scalars to vectors"); 69085cc4d840256841ac231858c3c916e91fe469269Matt Arsenault assert(Cond != ISD::SETCC_INVALID && 69185cc4d840256841ac231858c3c916e91fe469269Matt Arsenault "Cannot create a setCC of an invalid node."); 692d69c3141ed6d237ad19fdfbfcef8901491b24c2eBill Wendling return getNode(ISD::SETCC, DL, VT, LHS, RHS, getCondCode(Cond)); 6937cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner } 6949373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman 69585cc4d840256841ac231858c3c916e91fe469269Matt Arsenault // getSelect - Helper function to make it easier to build Select's if you just 69685cc4d840256841ac231858c3c916e91fe469269Matt Arsenault // have operands and don't want to check for vector. 69785cc4d840256841ac231858c3c916e91fe469269Matt Arsenault SDValue getSelect(SDLoc DL, EVT VT, SDValue Cond, 69885cc4d840256841ac231858c3c916e91fe469269Matt Arsenault SDValue LHS, SDValue RHS) { 69985cc4d840256841ac231858c3c916e91fe469269Matt Arsenault assert(LHS.getValueType() == RHS.getValueType() && 70085cc4d840256841ac231858c3c916e91fe469269Matt Arsenault "Cannot use select on differing types"); 70185cc4d840256841ac231858c3c916e91fe469269Matt Arsenault assert(VT.isVector() == LHS.getValueType().isVector() && 70285cc4d840256841ac231858c3c916e91fe469269Matt Arsenault "Cannot mix vectors and scalars"); 70385cc4d840256841ac231858c3c916e91fe469269Matt Arsenault return getNode(Cond.getValueType().isVector() ? ISD::VSELECT : ISD::SELECT, DL, VT, 70485cc4d840256841ac231858c3c916e91fe469269Matt Arsenault Cond, LHS, RHS); 70585cc4d840256841ac231858c3c916e91fe469269Matt Arsenault } 70685cc4d840256841ac231858c3c916e91fe469269Matt Arsenault 7079373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman /// getSelectCC - Helper function to make it easier to build SelectCC's if you 708475871a144eb604ddaf37503397ba0941442e5fbDan Gohman /// just have an ISD::CondCode instead of an SDValue. 7099373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman /// 710ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getSelectCC(SDLoc DL, SDValue LHS, SDValue RHS, 711d69c3141ed6d237ad19fdfbfcef8901491b24c2eBill Wendling SDValue True, SDValue False, ISD::CondCode Cond) { 712d69c3141ed6d237ad19fdfbfcef8901491b24c2eBill Wendling return getNode(ISD::SELECT_CC, DL, True.getValueType(), 713d69c3141ed6d237ad19fdfbfcef8901491b24c2eBill Wendling LHS, RHS, True, False, getCondCode(Cond)); 7149373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 715fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 716acc398c195a697795bff3245943d104eb19192b9Nate Begeman /// getVAArg - VAArg produces a result and token chain, and takes a pointer 717acc398c195a697795bff3245943d104eb19192b9Nate Begeman /// and a source value as input. 718ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getVAArg(EVT VT, SDLoc dl, SDValue Chain, SDValue Ptr, 719cbeeae23c31d32b833c9c7c3e8984e4cbcf22f45Rafael Espindola SDValue SV, unsigned Align); 7207cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 721cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// getAtomicCmpSwap - Gets a node for an atomic cmpxchg op. There are two 722cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// valid Opcodes. ISD::ATOMIC_CMO_SWAP produces a the value loaded and a 723cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// chain result. ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS produces the value loaded, 724cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// a success flag (initially i1), and a chain. 725cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue getAtomicCmpSwap(unsigned Opcode, SDLoc dl, EVT MemVT, SDVTList VTs, 726cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue Chain, SDValue Ptr, SDValue Cmp, SDValue Swp, 727cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines MachinePointerInfo PtrInfo, unsigned Alignment, 728cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines AtomicOrdering SuccessOrdering, 729cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines AtomicOrdering FailureOrdering, 730cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SynchronizationScope SynchScope); 731cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue getAtomicCmpSwap(unsigned Opcode, SDLoc dl, EVT MemVT, SDVTList VTs, 732cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue Chain, SDValue Ptr, SDValue Cmp, SDValue Swp, 733cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines MachineMemOperand *MMO, 734cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines AtomicOrdering SuccessOrdering, 735cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines AtomicOrdering FailureOrdering, 736cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SynchronizationScope SynchScope); 737ab0b949e0e9de452f3b052b11634ab761e008b23Andrew Lenharth 738327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman /// getAtomic - Gets a node for an atomic op, produces result (if relevant) 739327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman /// and chain and takes 2 operands. 740ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT, SDValue Chain, 741dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SDValue Ptr, SDValue Val, const Value *PtrVal, 742327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman unsigned Alignment, AtomicOrdering Ordering, 743327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman SynchronizationScope SynchScope); 744ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT, SDValue Chain, 745327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman SDValue Ptr, SDValue Val, MachineMemOperand *MMO, 746327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman AtomicOrdering Ordering, 747327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman SynchronizationScope SynchScope); 748327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman 749327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman /// getAtomic - Gets a node for an atomic op, produces result and chain and 750327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman /// takes 1 operand. 751ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT, EVT VT, 752327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman SDValue Chain, SDValue Ptr, MachineMemOperand *MMO, 75355ba816883842e793cdeb32fcb805c4e011b527fEli Friedman AtomicOrdering Ordering, 75455ba816883842e793cdeb32fcb805c4e011b527fEli Friedman SynchronizationScope SynchScope); 755ab0b949e0e9de452f3b052b11634ab761e008b23Andrew Lenharth 756268c743a3ba44ada364938bc5ff9b1be219df54fAmara Emerson /// getAtomic - Gets a node for an atomic op, produces result and chain and 757268c743a3ba44ada364938bc5ff9b1be219df54fAmara Emerson /// takes N operands. 758268c743a3ba44ada364938bc5ff9b1be219df54fAmara Emerson SDValue getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT, SDVTList VTList, 759dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ArrayRef<SDValue> Ops, MachineMemOperand *MMO, 76036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines AtomicOrdering SuccessOrdering, 76136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines AtomicOrdering FailureOrdering, 762268c743a3ba44ada364938bc5ff9b1be219df54fAmara Emerson SynchronizationScope SynchScope); 76336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SDValue getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT, SDVTList VTList, 764dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ArrayRef<SDValue> Ops, MachineMemOperand *MMO, 76536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines AtomicOrdering Ordering, SynchronizationScope SynchScope); 766268c743a3ba44ada364938bc5ff9b1be219df54fAmara Emerson 767c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang /// getMemIntrinsicNode - Creates a MemIntrinsicNode that may produce a 768c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// result and takes a list of operands. Opcode may be INTRINSIC_VOID, 769c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// INTRINSIC_W_CHAIN, or a target-specific opcode with a value not 770c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// less than FIRST_TARGET_MEMORY_OPCODE. 771ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getMemIntrinsicNode(unsigned Opcode, SDLoc dl, SDVTList VTList, 772dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ArrayRef<SDValue> Ops, 773e9ba5dd236f48708a00bd3bb0519148f943cc897Chris Lattner EVT MemVT, MachinePointerInfo PtrInfo, 774e8c17335c53f0f37262ee342f46b0d00ac0c1493Dale Johannesen unsigned Align = 0, bool Vol = false, 775e8c17335c53f0f37262ee342f46b0d00ac0c1493Dale Johannesen bool ReadMem = true, bool WriteMem = true); 776c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang 777ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getMemIntrinsicNode(unsigned Opcode, SDLoc dl, SDVTList VTList, 778dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ArrayRef<SDValue> Ops, 779c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman EVT MemVT, MachineMemOperand *MMO); 780c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman 7814bdcb61af33399d4e01fdf3c47ca1f1f5356e370Duncan Sands /// getMergeValues - Create a MERGE_VALUES node from the given operands. 782dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SDValue getMergeValues(ArrayRef<SDValue> Ops, SDLoc dl); 783f9516208e57364ab1e7d8748af1f59a2ea5fb572Duncan Sands 784c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// getLoad - Loads are not normal binary operators: their result type is not 785c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// determined by their operands, and they produce a value AND a token chain. 786cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner /// 787ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getLoad(EVT VT, SDLoc dl, SDValue Chain, SDValue Ptr, 788e72f2027e9116c55a5b39ac72732df8d6c45d37cChris Lattner MachinePointerInfo PtrInfo, bool isVolatile, 789d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper bool isNonTemporal, bool isInvariant, unsigned Alignment, 790dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const MDNode *TBAAInfo = nullptr, 791dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const MDNode *Ranges = nullptr); 79266589dcc8fb5dcf0894a9a80a8dee890a4f3a379Richard Sandiford SDValue getLoad(EVT VT, SDLoc dl, SDValue Chain, SDValue Ptr, 79366589dcc8fb5dcf0894a9a80a8dee890a4f3a379Richard Sandiford MachineMemOperand *MMO); 794ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getExtLoad(ISD::LoadExtType ExtType, SDLoc dl, EVT VT, 795e72f2027e9116c55a5b39ac72732df8d6c45d37cChris Lattner SDValue Chain, SDValue Ptr, MachinePointerInfo PtrInfo, 796e72f2027e9116c55a5b39ac72732df8d6c45d37cChris Lattner EVT MemVT, bool isVolatile, 797f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman bool isNonTemporal, unsigned Alignment, 798dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const MDNode *TBAAInfo = nullptr); 79966589dcc8fb5dcf0894a9a80a8dee890a4f3a379Richard Sandiford SDValue getExtLoad(ISD::LoadExtType ExtType, SDLoc dl, EVT VT, 80066589dcc8fb5dcf0894a9a80a8dee890a4f3a379Richard Sandiford SDValue Chain, SDValue Ptr, EVT MemVT, 80166589dcc8fb5dcf0894a9a80a8dee890a4f3a379Richard Sandiford MachineMemOperand *MMO); 802ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getIndexedLoad(SDValue OrigLoad, SDLoc dl, SDValue Base, 803bcc8017c738e92d9c1af221b11c4916cb524184eEvan Cheng SDValue Offset, ISD::MemIndexedMode AM); 804bcc8017c738e92d9c1af221b11c4916cb524184eEvan Cheng SDValue getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, 805ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick EVT VT, SDLoc dl, 806bcc8017c738e92d9c1af221b11c4916cb524184eEvan Cheng SDValue Chain, SDValue Ptr, SDValue Offset, 8075c5cb2a1717f8e30b1849d7ec1cf269bc5d66877Chris Lattner MachinePointerInfo PtrInfo, EVT MemVT, 808d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper bool isVolatile, bool isNonTemporal, bool isInvariant, 809dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines unsigned Alignment, const MDNode *TBAAInfo = nullptr, 810dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const MDNode *Ranges = nullptr); 8115c5cb2a1717f8e30b1849d7ec1cf269bc5d66877Chris Lattner SDValue getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, 812ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick EVT VT, SDLoc dl, 8135c5cb2a1717f8e30b1849d7ec1cf269bc5d66877Chris Lattner SDValue Chain, SDValue Ptr, SDValue Offset, 814c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman EVT MemVT, MachineMemOperand *MMO); 8152d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 816ad071e1cd1a4b880019f1b2e827ee81867815f82Evan Cheng /// getStore - Helper function to build ISD::STORE nodes. 817ad071e1cd1a4b880019f1b2e827ee81867815f82Evan Cheng /// 818ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getStore(SDValue Chain, SDLoc dl, SDValue Val, SDValue Ptr, 8195c5cb2a1717f8e30b1849d7ec1cf269bc5d66877Chris Lattner MachinePointerInfo PtrInfo, bool isVolatile, 820f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman bool isNonTemporal, unsigned Alignment, 821dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const MDNode *TBAAInfo = nullptr); 822ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getStore(SDValue Chain, SDLoc dl, SDValue Val, SDValue Ptr, 823c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman MachineMemOperand *MMO); 824ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getTruncStore(SDValue Chain, SDLoc dl, SDValue Val, SDValue Ptr, 8255c5cb2a1717f8e30b1849d7ec1cf269bc5d66877Chris Lattner MachinePointerInfo PtrInfo, EVT TVT, 8265c5cb2a1717f8e30b1849d7ec1cf269bc5d66877Chris Lattner bool isNonTemporal, bool isVolatile, 827f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman unsigned Alignment, 828dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const MDNode *TBAAInfo = nullptr); 829ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getTruncStore(SDValue Chain, SDLoc dl, SDValue Val, SDValue Ptr, 830c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman EVT TVT, MachineMemOperand *MMO); 831ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getIndexedStore(SDValue OrigStoe, SDLoc dl, SDValue Base, 832e8c17335c53f0f37262ee342f46b0d00ac0c1493Dale Johannesen SDValue Offset, ISD::MemIndexedMode AM); 833ad071e1cd1a4b880019f1b2e827ee81867815f82Evan Cheng 834101a90f3d3c3ad9159676ba744b59b3a9d0b4af5Dan Gohman /// getSrcValue - Construct a node to track a Value* through the backend. 835475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue getSrcValue(const Value *v); 83669de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman 837decc2671516e6c52ee2f29f7746f8d02753845eaChris Lattner /// getMDNode - Return an MDNodeSDNode which holds an MDNode. 838decc2671516e6c52ee2f29f7746f8d02753845eaChris Lattner SDValue getMDNode(const MDNode *MD); 8396154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson 84059d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault /// getAddrSpaceCast - Return an AddrSpaceCastSDNode. 84159d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault SDValue getAddrSpaceCast(SDLoc dl, EVT VT, SDValue Ptr, 84259d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault unsigned SrcAS, unsigned DestAS); 84359d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault 84492abc62399881ba9c525be80362c134ad836e2d9Duncan Sands /// getShiftAmountOperand - Return the specified value casted to 84592abc62399881ba9c525be80362c134ad836e2d9Duncan Sands /// the target's desired shift amount type. 8466154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson SDValue getShiftAmountOperand(EVT LHSTy, SDValue Op); 84792abc62399881ba9c525be80362c134ad836e2d9Duncan Sands 848b9aff659e82e4ec1a507e6e7fe7969379a431613Chris Lattner /// UpdateNodeOperands - *Mutate* the specified node in-place to have the 849b9aff659e82e4ec1a507e6e7fe7969379a431613Chris Lattner /// specified operands. If the resultant node already exists in the DAG, 850b9aff659e82e4ec1a507e6e7fe7969379a431613Chris Lattner /// this does not modify the specified node, instead it returns the node that 851b9aff659e82e4ec1a507e6e7fe7969379a431613Chris Lattner /// already exists. If the resultant node does not exist in the DAG, the 852b9aff659e82e4ec1a507e6e7fe7969379a431613Chris Lattner /// input node is returned. As a degenerate case, if you specify the same 853b9aff659e82e4ec1a507e6e7fe7969379a431613Chris Lattner /// input operands as the node already has, the input node is returned. 854027657db7cf60bcbf40403496d7e4a170f9ce1ecDan Gohman SDNode *UpdateNodeOperands(SDNode *N, SDValue Op); 855027657db7cf60bcbf40403496d7e4a170f9ce1ecDan Gohman SDNode *UpdateNodeOperands(SDNode *N, SDValue Op1, SDValue Op2); 856027657db7cf60bcbf40403496d7e4a170f9ce1ecDan Gohman SDNode *UpdateNodeOperands(SDNode *N, SDValue Op1, SDValue Op2, 857475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op3); 858027657db7cf60bcbf40403496d7e4a170f9ce1ecDan Gohman SDNode *UpdateNodeOperands(SDNode *N, SDValue Op1, SDValue Op2, 859475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op3, SDValue Op4); 860027657db7cf60bcbf40403496d7e4a170f9ce1ecDan Gohman SDNode *UpdateNodeOperands(SDNode *N, SDValue Op1, SDValue Op2, 861475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op3, SDValue Op4, SDValue Op5); 862dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SDNode *UpdateNodeOperands(SDNode *N, ArrayRef<SDValue> Ops); 863fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 8641b95095857b78e12138c22e76c7936611c51355bChris Lattner /// SelectNodeTo - These are used for target selectors to *mutate* the 8651b95095857b78e12138c22e76c7936611c51355bChris Lattner /// specified node to have the specified return type, Target opcode, and 8661b95095857b78e12138c22e76c7936611c51355bChris Lattner /// operands. Note that target opcodes are stored as 867e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// ~TargetOpcode in the node opcode field. The resultant node is returned. 868e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT); 869e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT, SDValue Op1); 870e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT, 871475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op1, SDValue Op2); 872e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT, 873475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op1, SDValue Op2, SDValue Op3); 874e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT, 875dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ArrayRef<SDValue> Ops); 876e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT1, EVT VT2); 877e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT1, 878dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines EVT VT2, ArrayRef<SDValue> Ops); 879e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT1, 880dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines EVT VT2, EVT VT3, ArrayRef<SDValue> Ops); 881e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1, 882dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines EVT VT2, EVT VT3, EVT VT4, ArrayRef<SDValue> Ops); 883e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT1, 884e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT2, SDValue Op1); 885e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT1, 886e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT2, SDValue Op1, SDValue Op2); 887e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT1, 888e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT2, SDValue Op1, SDValue Op2, SDValue Op3); 889e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT1, 890e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT2, EVT VT3, SDValue Op1, SDValue Op2, SDValue Op3); 891cd920d9ecfcefff13c3619a32b58399cac2e3630Dan Gohman SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, SDVTList VTs, 892dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ArrayRef<SDValue> Ops); 893694481ee01bfe507c6e37de0dc1c64cff455eefdEvan Cheng 894df51247725143acb781c224faffd848cc7cf95d8Chris Lattner /// MorphNodeTo - This *mutates* the specified node to have the specified 895e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// return type, opcode, and operands. 896e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman SDNode *MorphNodeTo(SDNode *N, unsigned Opc, SDVTList VTs, 897dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ArrayRef<SDValue> Ops); 898753c8f20e45f6e4198c7cf4096ecc8948a029e9cChris Lattner 899602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman /// getMachineNode - These are used for target selectors to create a new node 900602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman /// with specified return type(s), MachineInstr opcode, and operands. 9016ae46c4c8757237bca2b78b589c96c37015bc356Evan Cheng /// 902602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman /// Note that getMachineNode returns the resultant node. If there is already 903602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman /// a node of the specified opcode and operands, it returns that node instead 904602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman /// of the current one. 905ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT); 906ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT, 907c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman SDValue Op1); 908ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT, 909c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman SDValue Op1, SDValue Op2); 910ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT, 9112a8bea7a8eba9bfa05dcc7a87e9152a0043841b2Michael Liao SDValue Op1, SDValue Op2, SDValue Op3); 912ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT, 9132a8bea7a8eba9bfa05dcc7a87e9152a0043841b2Michael Liao ArrayRef<SDValue> Ops); 914ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2); 915ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2, 9162a8bea7a8eba9bfa05dcc7a87e9152a0043841b2Michael Liao SDValue Op1); 917ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2, 9182a8bea7a8eba9bfa05dcc7a87e9152a0043841b2Michael Liao SDValue Op1, SDValue Op2); 919ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2, 9202a8bea7a8eba9bfa05dcc7a87e9152a0043841b2Michael Liao SDValue Op1, SDValue Op2, SDValue Op3); 921ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2, 9222a8bea7a8eba9bfa05dcc7a87e9152a0043841b2Michael Liao ArrayRef<SDValue> Ops); 923ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2, 9242a8bea7a8eba9bfa05dcc7a87e9152a0043841b2Michael Liao EVT VT3, SDValue Op1, SDValue Op2); 925ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2, 9262a8bea7a8eba9bfa05dcc7a87e9152a0043841b2Michael Liao EVT VT3, SDValue Op1, SDValue Op2, 9272a8bea7a8eba9bfa05dcc7a87e9152a0043841b2Michael Liao SDValue Op3); 928ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2, 9292a8bea7a8eba9bfa05dcc7a87e9152a0043841b2Michael Liao EVT VT3, ArrayRef<SDValue> Ops); 930ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2, 9312a8bea7a8eba9bfa05dcc7a87e9152a0043841b2Michael Liao EVT VT3, EVT VT4, ArrayRef<SDValue> Ops); 932ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, 9332a8bea7a8eba9bfa05dcc7a87e9152a0043841b2Michael Liao ArrayRef<EVT> ResultTys, 9342a8bea7a8eba9bfa05dcc7a87e9152a0043841b2Michael Liao ArrayRef<SDValue> Ops); 935ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, SDVTList VTs, 9362a8bea7a8eba9bfa05dcc7a87e9152a0043841b2Michael Liao ArrayRef<SDValue> Ops); 93708b1173971a51eb89d7d6ee0992c39170c86994aEvan Cheng 9386a402dc952ccad3f8fd0d9e272dbdd261f50854eDan Gohman /// getTargetExtractSubreg - A convenience function for creating 9396a402dc952ccad3f8fd0d9e272dbdd261f50854eDan Gohman /// TargetInstrInfo::EXTRACT_SUBREG nodes. 940ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getTargetExtractSubreg(int SRIdx, SDLoc DL, EVT VT, 9416a402dc952ccad3f8fd0d9e272dbdd261f50854eDan Gohman SDValue Operand); 9426a402dc952ccad3f8fd0d9e272dbdd261f50854eDan Gohman 9435fcbf0d26ecb99d54c182f542bf8db43ff048d6dBob Wilson /// getTargetInsertSubreg - A convenience function for creating 9445fcbf0d26ecb99d54c182f542bf8db43ff048d6dBob Wilson /// TargetInstrInfo::INSERT_SUBREG nodes. 945ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue getTargetInsertSubreg(int SRIdx, SDLoc DL, EVT VT, 9465fcbf0d26ecb99d54c182f542bf8db43ff048d6dBob Wilson SDValue Operand, SDValue Subreg); 9475fcbf0d26ecb99d54c182f542bf8db43ff048d6dBob Wilson 94808b1173971a51eb89d7d6ee0992c39170c86994aEvan Cheng /// getNodeIfExists - Get the specified node if it's already available, or 94908b1173971a51eb89d7d6ee0992c39170c86994aEvan Cheng /// else return NULL. 950cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDNode *getNodeIfExists(unsigned Opcode, SDVTList VTs, ArrayRef<SDValue> Ops, 951cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines bool nuw = false, bool nsw = false, 952cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines bool exact = false); 953fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 95431441b7e95e0840e1ae144e5db6f791d6a36bc60Evan Cheng /// getDbgValue - Creates a SDDbgValue node. 95531441b7e95e0840e1ae144e5db6f791d6a36bc60Evan Cheng /// 956dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SDDbgValue *getDbgValue(MDNode *MDPtr, SDNode *N, unsigned R, 957dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines bool IsIndirect, uint64_t Off, 95831441b7e95e0840e1ae144e5db6f791d6a36bc60Evan Cheng DebugLoc DL, unsigned O); 959dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines /// Constant. 960dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SDDbgValue *getConstantDbgValue(MDNode *MDPtr, const Value *C, uint64_t Off, 961dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines DebugLoc DL, unsigned O); 962dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines /// Frame index. 963dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SDDbgValue *getFrameIndexDbgValue(MDNode *MDPtr, unsigned FI, uint64_t Off, 964dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines DebugLoc DL, unsigned O); 96531441b7e95e0840e1ae144e5db6f791d6a36bc60Evan Cheng 966f8dc0617baceeba8ccd67c8881eb88eb1be2902cChris Lattner /// RemoveDeadNode - Remove the specified node from the system. If any of its 967f8dc0617baceeba8ccd67c8881eb88eb1be2902cChris Lattner /// operands then becomes dead, remove them as well. Inform UpdateListener 968f8dc0617baceeba8ccd67c8881eb88eb1be2902cChris Lattner /// for each node deleted. 969bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen void RemoveDeadNode(SDNode *N); 970fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 9710fe9c6e7babb3c0731d9cb864ec498ec4184760fDan Gohman /// RemoveDeadNodes - This method deletes the unreachable nodes in the 9720fe9c6e7babb3c0731d9cb864ec498ec4184760fDan Gohman /// given list, and any nodes that become unreachable as a result. 973bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen void RemoveDeadNodes(SmallVectorImpl<SDNode *> &DeadNodes); 9740fe9c6e7babb3c0731d9cb864ec498ec4184760fDan Gohman 9756542d950609208de3e1cde704c5f89aad864c0d9Chris Lattner /// ReplaceAllUsesWith - Modify anything using 'From' to use 'To' instead. 97626005b1b672aebd437edc561d381c5dd19a03ddbChris Lattner /// This can cause recursive merging of nodes in the DAG. Use the first 97726005b1b672aebd437edc561d381c5dd19a03ddbChris Lattner /// version if 'From' is known to have a single result, use the second 978c23e4968790395053f3f52aeb3342637fcaafdbfDan Gohman /// if you have two nodes with identical results (or if 'To' has a superset 979c23e4968790395053f3f52aeb3342637fcaafdbfDan Gohman /// of the results of 'From'), use the third otherwise. 9806542d950609208de3e1cde704c5f89aad864c0d9Chris Lattner /// 981fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel /// These methods all take an optional UpdateListener, which (if not null) is 982f8dc0617baceeba8ccd67c8881eb88eb1be2902cChris Lattner /// informed about nodes that are deleted and modified due to recursive 983f8dc0617baceeba8ccd67c8881eb88eb1be2902cChris Lattner /// changes in the dag. 984fde3f3061d665babeb78443119a09876098fc35eChris Lattner /// 9859ad136c851e0a66eb471573aac9fec47d53a61baDan Gohman /// These functions only replace all existing uses. It's possible that as 9869ad136c851e0a66eb471573aac9fec47d53a61baDan Gohman /// these replacements are being performed, CSE may cause the From node 9879ad136c851e0a66eb471573aac9fec47d53a61baDan Gohman /// to be given new uses. These new uses of From are left in place, and 9887a2bdde0a0eebcd2125055e0eacaca040f0b766cChris Lattner /// not automatically transferred to To. 9899ad136c851e0a66eb471573aac9fec47d53a61baDan Gohman /// 990bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen void ReplaceAllUsesWith(SDValue From, SDValue Op); 991bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen void ReplaceAllUsesWith(SDNode *From, SDNode *To); 992bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen void ReplaceAllUsesWith(SDNode *From, const SDValue *To); 993fae9f1cb34d6d2c4dbd007f2d748a70b67776a82Evan Cheng 99480274268b99e5a066825c8cc5aba58dbc5ad0a52Chris Lattner /// ReplaceAllUsesOfValueWith - Replace any uses of From with To, leaving 995f8dc0617baceeba8ccd67c8881eb88eb1be2902cChris Lattner /// uses of other values produced by From.Val alone. 996bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen void ReplaceAllUsesOfValueWith(SDValue From, SDValue To); 99780274268b99e5a066825c8cc5aba58dbc5ad0a52Chris Lattner 998e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// ReplaceAllUsesOfValuesWith - Like ReplaceAllUsesOfValueWith, but 999e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// for multiple values at once. This correctly handles the case where 1000e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// there is an overlap between the From values and the To values. 1001475871a144eb604ddaf37503397ba0941442e5fbDan Gohman void ReplaceAllUsesOfValuesWith(const SDValue *From, const SDValue *To, 1002bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen unsigned Num); 1003e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman 1004f06c835f769aa1cf67801ed1f6bd366a447c18b1Dan Gohman /// AssignTopologicalOrder - Topological-sort the AllNodes list and a 1005f06c835f769aa1cf67801ed1f6bd366a447c18b1Dan Gohman /// assign a unique node id for each node in the DAG based on their 1006f06c835f769aa1cf67801ed1f6bd366a447c18b1Dan Gohman /// topological order. Returns the number of nodes. 1007f06c835f769aa1cf67801ed1f6bd366a447c18b1Dan Gohman unsigned AssignTopologicalOrder(); 1008e6f35d8a5cc92d776cf460200e2b815e8c301b14Evan Cheng 10098be6bbe5bfd50945ac6c5542e0f54a0924a5db8dDan Gohman /// RepositionNode - Move node N in the AllNodes list to be immediately 10108be6bbe5bfd50945ac6c5542e0f54a0924a5db8dDan Gohman /// before the given iterator Position. This may be used to update the 10118be6bbe5bfd50945ac6c5542e0f54a0924a5db8dDan Gohman /// topological ordering when the list of nodes is modified. 10128be6bbe5bfd50945ac6c5542e0f54a0924a5db8dDan Gohman void RepositionNode(allnodes_iterator Position, SDNode *N) { 10138be6bbe5bfd50945ac6c5542e0f54a0924a5db8dDan Gohman AllNodes.insert(Position, AllNodes.remove(N)); 10148be6bbe5bfd50945ac6c5542e0f54a0924a5db8dDan Gohman } 10158be6bbe5bfd50945ac6c5542e0f54a0924a5db8dDan Gohman 10161efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng /// isCommutativeBinOp - Returns true if the opcode is a commutative binary 10171efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng /// operation. 10181efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng static bool isCommutativeBinOp(unsigned Opcode) { 10194ae9e0c5301126d7f2d4b2975eb86ed21f7b574dChris Lattner // FIXME: This should get its info from the td file, so that we can include 10204ae9e0c5301126d7f2d4b2975eb86ed21f7b574dChris Lattner // target info. 10211efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng switch (Opcode) { 10221efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::ADD: 10231efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::MUL: 10241efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::MULHU: 10251efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::MULHS: 1026b6c7437568f0472548ede2710458f52cfad4532eDan Gohman case ISD::SMUL_LOHI: 1027b6c7437568f0472548ede2710458f52cfad4532eDan Gohman case ISD::UMUL_LOHI: 10281efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::FADD: 10291efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::FMUL: 10301efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::AND: 10311efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::OR: 10321efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::XOR: 103356e04a80b3cbd348aaf8f1828ed28fb4a9de2312Dan Gohman case ISD::SADDO: 103456e04a80b3cbd348aaf8f1828ed28fb4a9de2312Dan Gohman case ISD::UADDO: 1035fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel case ISD::ADDC: 10361efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::ADDE: return true; 10371efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng default: return false; 10381efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng } 10391efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng } 10401efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng 10410a29cb045444c13160e90fe7942a9d7c720185edTim Northover /// Returns an APFloat semantics tag appropriate for the given type. If VT is 10420a29cb045444c13160e90fe7942a9d7c720185edTim Northover /// a vector type, the element semantics are returned. 10430a29cb045444c13160e90fe7942a9d7c720185edTim Northover static const fltSemantics &EVTToAPFloatSemantics(EVT VT) { 10440a29cb045444c13160e90fe7942a9d7c720185edTim Northover switch (VT.getScalarType().getSimpleVT().SimpleTy) { 10450a29cb045444c13160e90fe7942a9d7c720185edTim Northover default: llvm_unreachable("Unknown FP format"); 10460a29cb045444c13160e90fe7942a9d7c720185edTim Northover case MVT::f16: return APFloat::IEEEhalf; 10470a29cb045444c13160e90fe7942a9d7c720185edTim Northover case MVT::f32: return APFloat::IEEEsingle; 10480a29cb045444c13160e90fe7942a9d7c720185edTim Northover case MVT::f64: return APFloat::IEEEdouble; 10490a29cb045444c13160e90fe7942a9d7c720185edTim Northover case MVT::f80: return APFloat::x87DoubleExtended; 10500a29cb045444c13160e90fe7942a9d7c720185edTim Northover case MVT::f128: return APFloat::IEEEquad; 10510a29cb045444c13160e90fe7942a9d7c720185edTim Northover case MVT::ppcf128: return APFloat::PPCDoubleDouble; 10520a29cb045444c13160e90fe7942a9d7c720185edTim Northover } 10530a29cb045444c13160e90fe7942a9d7c720185edTim Northover } 10540a29cb045444c13160e90fe7942a9d7c720185edTim Northover 1055bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng /// AddDbgValue - Add a dbg_value SDNode. If SD is non-null that means the 1056bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng /// value is produced by SD. 1057fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen void AddDbgValue(SDDbgValue *DB, SDNode *SD, bool isParameter); 1058bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen 1059bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng /// GetDbgValues - Get the debug values which reference the given SDNode. 106022a54c1cd711afccd4558374918d12a939e1cca5Benjamin Kramer ArrayRef<SDDbgValue*> GetDbgValues(const SDNode* SD) { 1061bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng return DbgInfo->getSDDbgValues(SD); 1062bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng } 10636154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson 1064a2e868d34ccfed46310e98338ded6a74b2b01308Devang Patel /// TransferDbgValues - Transfer SDDbgValues. 1065a2e868d34ccfed46310e98338ded6a74b2b01308Devang Patel void TransferDbgValues(SDValue From, SDValue To); 1066bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen 1067bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng /// hasDebugValues - Return true if there are any SDDbgValue nodes associated 1068bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng /// with this SelectionDAG. 1069bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng bool hasDebugValues() const { return !DbgInfo->empty(); } 1070bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen 1071bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng SDDbgInfo::DbgIterator DbgBegin() { return DbgInfo->DbgBegin(); } 1072bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng SDDbgInfo::DbgIterator DbgEnd() { return DbgInfo->DbgEnd(); } 10736154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson SDDbgInfo::DbgIterator ByvalParmDbgBegin() { 10746154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson return DbgInfo->ByvalParmDbgBegin(); 1075fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen } 10766154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson SDDbgInfo::DbgIterator ByvalParmDbgEnd() { 10776154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson return DbgInfo->ByvalParmDbgEnd(); 1078fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen } 1079bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen 1080cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner void dump() const; 1081d1fc96499b7619356c7542200d32da898b79f7c1Chris Lattner 108237ce9df0da6cddc3b8bfef9b63d33d058a0f2f15Chris Lattner /// CreateStackTemporary - Create a stack temporary, suitable for holding the 1083364d73ddab43b699ab90240f11b7a2eb5cf69bd8Mon P Wang /// specified value type. If minAlign is specified, the slot size will have 1084364d73ddab43b699ab90240f11b7a2eb5cf69bd8Mon P Wang /// at least that alignment. 1085e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue CreateStackTemporary(EVT VT, unsigned minAlign = 1); 108647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 108747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands /// CreateStackTemporary - Create a stack temporary suitable for holding 108847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands /// either of the specified value types. 1089e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue CreateStackTemporary(EVT VT1, EVT VT2); 109047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 1091fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel /// FoldConstantArithmetic - 10924969310052f45b1e2e5d21735e38641a20be0e21Benjamin Kramer SDValue FoldConstantArithmetic(unsigned Opcode, EVT VT, 10934969310052f45b1e2e5d21735e38641a20be0e21Benjamin Kramer SDNode *Cst1, SDNode *Cst2); 1094f3cbca279db891403659208a99f8e1cceb8c9ea6Bill Wendling 109551dabfb28375be7bc5848806ae31cd068b6133f8Chris Lattner /// FoldSetCC - Constant fold a setcc to true or false. 1096e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue FoldSetCC(EVT VT, SDValue N1, 1097ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue N2, ISD::CondCode Cond, SDLoc dl); 1098fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 10992e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman /// SignBitIsZero - Return true if the sign bit of Op is known to be zero. We 11002e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman /// use this predicate to simplify operations downstream. 1101475871a144eb604ddaf37503397ba0941442e5fbDan Gohman bool SignBitIsZero(SDValue Op, unsigned Depth = 0) const; 11022e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman 1103ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// MaskedValueIsZero - Return true if 'Op & Mask' is known to be zero. We 1104ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// use this predicate to simplify operations downstream. Op and Mask are 1105ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// known to be the same type. 1106475871a144eb604ddaf37503397ba0941442e5fbDan Gohman bool MaskedValueIsZero(SDValue Op, const APInt &Mask, unsigned Depth = 0) 1107ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman const; 1108fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1109dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines /// Determine which bits of Op are known to be either zero or one and return 1110dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines /// them in the KnownZero/KnownOne bitsets. Targets can implement the 1111dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines /// computeKnownBitsForTargetNode method in the TargetLowering class to allow 1112dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines /// target nodes to be understood. 1113dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines void computeKnownBits(SDValue Op, APInt &KnownZero, APInt &KnownOne, 1114dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines unsigned Depth = 0) const; 1115fd29e0eb060ea8b4d490860329234d2ae5f5952eDan Gohman 1116ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// ComputeNumSignBits - Return the number of times the sign bit of the 1117ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// register is replicated into the other bits. We know that at least 1 bit 1118ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// is always equal to the sign bit (itself), but other cases can give us 1119ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// information. For example, immediately after an "SRA X, 2", we know that 1120ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// the top 3 bits are all equal to each other, so we return 3. Targets can 1121ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// implement the ComputeNumSignBitsForTarget method in the TargetLowering 1122ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// class to allow target nodes to be understood. 1123475871a144eb604ddaf37503397ba0941442e5fbDan Gohman unsigned ComputeNumSignBits(SDValue Op, unsigned Depth = 0) const; 1124a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng 1125a18da59d4028a2e3f5751294e5f487281649299cChris Lattner /// isBaseWithConstantOffset - Return true if the specified operand is an 1126a18da59d4028a2e3f5751294e5f487281649299cChris Lattner /// ISD::ADD with a ConstantSDNode on the right-hand side, or if it is an 1127a18da59d4028a2e3f5751294e5f487281649299cChris Lattner /// ISD::OR with a ConstantSDNode that is guaranteed to have the same 1128a18da59d4028a2e3f5751294e5f487281649299cChris Lattner /// semantics as an ADD. This handles the equivalence: 112994c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru /// X|Cst == X+Cst iff X&Cst = 0. 1130a18da59d4028a2e3f5751294e5f487281649299cChris Lattner bool isBaseWithConstantOffset(SDValue Op) const; 11316154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson 11328d44b28bc6f615b9ad79b066987d53b1ea2a2942Dan Gohman /// isKnownNeverNan - Test whether the given SDValue is known to never be NaN. 11338d44b28bc6f615b9ad79b066987d53b1ea2a2942Dan Gohman bool isKnownNeverNaN(SDValue Op) const; 11348d44b28bc6f615b9ad79b066987d53b1ea2a2942Dan Gohman 1135e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman /// isKnownNeverZero - Test whether the given SDValue is known to never be 1136e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman /// positive or negative Zero. 1137e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman bool isKnownNeverZero(SDValue Op) const; 1138e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman 1139e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman /// isEqualTo - Test whether two SDValues are known to compare equal. This 1140e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman /// is true if they are the same value, or if one is negative zero and the 1141e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman /// other positive zero. 1142e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman bool isEqualTo(SDValue A, SDValue B) const; 1143e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman 1144cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang /// UnrollVectorOp - Utility function used by legalize and lowering to 1145cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang /// "unroll" a vector operation by splitting out the scalars and operating 1146cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang /// on each element individually. If the ResNE is 0, fully unroll the vector 1147cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang /// op. If ResNE is less than the width of the vector op, unroll up to ResNE. 1148cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang /// If the ResNE is greater than the width of the vector op, unroll the 1149cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang /// vector op and fill the end of the resulting vector with UNDEFS. 1150cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang SDValue UnrollVectorOp(SDNode *N, unsigned ResNE = 0); 1151cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang 11526154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson /// isConsecutiveLoad - Return true if LD is loading 'Bytes' bytes from a 11536154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson /// location that is 'Dist' units away from the location that the 'Base' load 115464fa4a9584113f63eccc1a650e7e0cc4ddbab3f6Evan Cheng /// is loading from. 115564fa4a9584113f63eccc1a650e7e0cc4ddbab3f6Evan Cheng bool isConsecutiveLoad(LoadSDNode *LD, LoadSDNode *Base, 115664fa4a9584113f63eccc1a650e7e0cc4ddbab3f6Evan Cheng unsigned Bytes, int Dist) const; 115764fa4a9584113f63eccc1a650e7e0cc4ddbab3f6Evan Cheng 1158f2dc5c785dea1816cbc064b58b4b6ea23c4fd7d4Evan Cheng /// InferPtrAlignment - Infer alignment of a load / store address. Return 0 if 1159f2dc5c785dea1816cbc064b58b4b6ea23c4fd7d4Evan Cheng /// it cannot be inferred. 11607ced2e0b304e76ab746c7d9a54ad8d4930445a38Evan Cheng unsigned InferPtrAlignment(SDValue Ptr) const; 1161f2dc5c785dea1816cbc064b58b4b6ea23c4fd7d4Evan Cheng 1162ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling /// GetSplitDestVTs - Compute the VTs needed for the low/hi parts of a type 1163ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling /// which is split (or expanded) into two not necessarily identical pieces. 1164ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling std::pair<EVT, EVT> GetSplitDestVTs(const EVT &VT) const; 1165ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling 1166ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling /// SplitVector - Split the vector with EXTRACT_SUBVECTOR using the provides 1167ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling /// VTs and return the low/high part. 1168ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling std::pair<SDValue, SDValue> SplitVector(const SDValue &N, const SDLoc &DL, 1169ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling const EVT &LoVT, const EVT &HiVT); 1170ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling 1171ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling /// SplitVector - Split the vector with EXTRACT_SUBVECTOR and return the 1172ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling /// low/high part. 1173ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling std::pair<SDValue, SDValue> SplitVector(const SDValue &N, const SDLoc &DL) { 1174ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling EVT LoVT, HiVT; 117536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines std::tie(LoVT, HiVT) = GetSplitDestVTs(N.getValueType()); 1176ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling return SplitVector(N, DL, LoVT, HiVT); 1177ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling } 1178ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling 1179ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling /// SplitVectorOperand - Split the node's operand with EXTRACT_SUBVECTOR and 1180ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling /// return the low/high part. 1181f62b274a93d4014d56fa3a656f4fac6e7d827358Bill Wendling std::pair<SDValue, SDValue> SplitVectorOperand(const SDNode *N, unsigned OpNo) 1182f62b274a93d4014d56fa3a656f4fac6e7d827358Bill Wendling { 1183ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling return SplitVector(N->getOperand(OpNo), SDLoc(N)); 1184ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling } 1185ee287ca22abcce9f769618c107ff3f46aa2d0cbaBill Wendling 1186dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines /// ExtractVectorElements - Append the extracted elements from Start to Count 1187dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines /// out of the vector Op in Args. If Count is 0, all of the elements will be 1188dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines /// extracted. 1189dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines void ExtractVectorElements(SDValue Op, SmallVectorImpl<SDValue> &Args, 1190dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines unsigned Start = 0, unsigned Count = 0); 1191dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 1192dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines unsigned getEVTAlignment(EVT MemoryVT) const; 1193dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 1194d1fc96499b7619356c7542200d32da898b79f7c1Chris Lattnerprivate: 1195095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman bool RemoveNodeFromCSEMaps(SDNode *N); 1196bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen void AddModifiedNodeToCSEMaps(SDNode *N); 1197475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDNode *FindModifiedNodeSlot(SDNode *N, SDValue Op, void *&InsertPos); 1198475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDNode *FindModifiedNodeSlot(SDNode *N, SDValue Op1, SDValue Op2, 1199a5682853b9921bbb0dd2ee175c9bd44142d4819eChris Lattner void *&InsertPos); 1200dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SDNode *FindModifiedNodeSlot(SDNode *N, ArrayRef<SDValue> Ops, 1201a5682853b9921bbb0dd2ee175c9bd44142d4819eChris Lattner void *&InsertPos); 1202ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDNode *UpdadeSDLocOnMergedSDNode(SDNode *N, SDLoc loc); 1203b9aff659e82e4ec1a507e6e7fe7969379a431613Chris Lattner 1204fde3f3061d665babeb78443119a09876098fc35eChris Lattner void DeleteNodeNotInCSEMaps(SDNode *N); 1205c53361294957b63a9c1e405256c6f0a81db1685cDan Gohman void DeallocateNode(SDNode *N); 12069c6e70eca9a49c146b26621cbcbb9464ceeac024Dan Gohman 1207f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman void allnodes_clear(); 1208fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1209cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines BinarySDNode *GetBinarySDNode(unsigned Opcode, SDLoc DL, SDVTList VTs, 1210cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue N1, SDValue N2, bool nuw, bool nsw, 1211cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines bool exact); 1212cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 1213101a90f3d3c3ad9159676ba744b59b3a9d0b4af5Dan Gohman /// VTList - List of non-single value types. 12148c955ea858b0c99c856c7c10a3eee7576d13abd1Wan Xiaofei FoldingSet<SDVTListNode> VTListMap; 1215fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1216101a90f3d3c3ad9159676ba744b59b3a9d0b4af5Dan Gohman /// CondCodeNodes - Maps to auto-CSE operations. 12177cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner std::vector<CondCodeSDNode*> CondCodeNodes; 12181cff05c7c216eea0e9173738c2a60b70c2b3c013Chris Lattner 121915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner std::vector<SDNode*> ValueTypeNodes; 1220e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson std::map<EVT, SDNode*, EVT::compareRawBits> ExtendedValueTypeNodes; 1221056292fd738924f3f7703725d8f630983794b5a5Bill Wendling StringMap<SDNode*> ExternalSymbols; 12226154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson 12231af2231da64a14d638406d133c7912bfc1c8a9ceChris Lattner std::map<std::pair<std::string, unsigned char>,SDNode*> TargetExternalSymbols; 1224cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner}; 1225cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 12261080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattnertemplate <> struct GraphTraits<SelectionDAG*> : public GraphTraits<SDNode*> { 12271080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner typedef SelectionDAG::allnodes_iterator nodes_iterator; 12281080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner static nodes_iterator nodes_begin(SelectionDAG *G) { 12291080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner return G->allnodes_begin(); 12301080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 12311080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner static nodes_iterator nodes_end(SelectionDAG *G) { 12321080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner return G->allnodes_end(); 12331080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 12341080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner}; 12351080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner 1236b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner} // end namespace llvm 1237cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 1238cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner#endif 1239