SelectionDAG.h revision 3853f74aba301ef08b699bac2fa8e53230714a58
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; 36b4e6a5df5dada0cd919cc6e2717eb3118db9cc45Bill Wendlingclass SDNodeOrdering; 37bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesenclass SDDbgValue; 38b4e6a5df5dada0cd919cc6e2717eb3118db9cc45Bill Wendlingclass TargetLowering; 39ff7a562751604a9fe13efc75bd59622244b54d35Dan Gohmanclass TargetSelectionDAGInfo; 40e4b4edd72ae596ac8d1fdbc6e77f61e331f6775dChandler Carruthclass TargetTransformInfo; 41fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman 428e4018e2de52c534405d7155c7009d0b35afb861Cedric Venettemplate<> struct ilist_traits<SDNode> : public ilist_default_traits<SDNode> { 438e4018e2de52c534405d7155c7009d0b35afb861Cedric Venetprivate: 447309be6735666143bd9835b275dc8501617a2591Gabor Greif mutable ilist_half_node<SDNode> Sentinel; 45fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohmanpublic: 46fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman SDNode *createSentinel() const { 47c7f6b8c5d40e17bf43fd3a1549d7d89c9da735e1Gabor Greif return static_cast<SDNode*>(&Sentinel); 48fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman } 49fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman static void destroySentinel(SDNode *) {} 50fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman 51c23b8719ef9d6b1220e854b37d40e9e1c48a82bcGabor Greif SDNode *provideInitialHead() const { return createSentinel(); } 52c23b8719ef9d6b1220e854b37d40e9e1c48a82bcGabor Greif SDNode *ensureHead(SDNode*) const { return createSentinel(); } 53f3841fcbd587c31aa9842b3f33bd57de40c9f443Gabor Greif static void noteHead(SDNode*, SDNode*) {} 54c23b8719ef9d6b1220e854b37d40e9e1c48a82bcGabor Greif 55fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman static void deleteNode(SDNode *) { 5650bee42b54cd9aec5f49566307df2b0cf23afcf6Craig Topper llvm_unreachable("ilist_traits<SDNode> shouldn't see a deleteNode call!"); 57fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman } 58fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohmanprivate: 59fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman static void createNode(const SDNode &); 60fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman}; 61c3aae25116e66c177579b0b79182b09340b19753Chris Lattner 62bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen/// SDDbgInfo - Keeps track of dbg_value information through SDISel. We do 63bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen/// not build SDNodes for these so as not to perturb the generated code; 64bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng/// instead the info is kept off to the side in this structure. Each SDNode may 65bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng/// have one or more associated dbg_value entries. This information is kept in 66bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng/// DbgValMap. 67fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen/// Byval parameters are handled separately because they don't use alloca's, 68fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen/// which busts the normal mechanism. There is good reason for handling all 69fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen/// parameters separately: they may not have code generated for them, they 70fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen/// should always go at the beginning of the function regardless of other code 71fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen/// motion, and debug info for them is potentially useful even if the parameter 72fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen/// is unused. Right now only byval parameters are handled separately. 73bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesenclass SDDbgInfo { 74bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng SmallVector<SDDbgValue*, 32> DbgValues; 75fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen SmallVector<SDDbgValue*, 32> ByvalParmDbgValues; 76d4c6c3a7c3140ce487a805138b6f53f82ff6b783Devang Patel DenseMap<const SDNode*, SmallVector<SDDbgValue*, 2> > DbgValMap; 77bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen 78001d3dc976d7cda8a3dd8c7fd4020b0b96033f4eCraig Topper void operator=(const SDDbgInfo&) LLVM_DELETED_FUNCTION; 79001d3dc976d7cda8a3dd8c7fd4020b0b96033f4eCraig Topper SDDbgInfo(const SDDbgInfo&) LLVM_DELETED_FUNCTION; 80bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesenpublic: 81bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen SDDbgInfo() {} 82bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen 83fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen void add(SDDbgValue *V, const SDNode *Node, bool isParameter) { 84fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen if (isParameter) { 85fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen ByvalParmDbgValues.push_back(V); 86fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen } else DbgValues.push_back(V); 87bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng if (Node) 88d4c6c3a7c3140ce487a805138b6f53f82ff6b783Devang Patel DbgValMap[Node].push_back(V); 89bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen } 90bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng 91bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen void clear() { 92d4c6c3a7c3140ce487a805138b6f53f82ff6b783Devang Patel DbgValMap.clear(); 93bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng DbgValues.clear(); 94fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen ByvalParmDbgValues.clear(); 95bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng } 96bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng 97bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng bool empty() const { 98fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen return DbgValues.empty() && ByvalParmDbgValues.empty(); 99bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen } 100bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng 10122a54c1cd711afccd4558374918d12a939e1cca5Benjamin Kramer ArrayRef<SDDbgValue*> getSDDbgValues(const SDNode *Node) { 10222a54c1cd711afccd4558374918d12a939e1cca5Benjamin Kramer DenseMap<const SDNode*, SmallVector<SDDbgValue*, 2> >::iterator I = 10322a54c1cd711afccd4558374918d12a939e1cca5Benjamin Kramer DbgValMap.find(Node); 10422a54c1cd711afccd4558374918d12a939e1cca5Benjamin Kramer if (I != DbgValMap.end()) 10522a54c1cd711afccd4558374918d12a939e1cca5Benjamin Kramer return I->second; 10622a54c1cd711afccd4558374918d12a939e1cca5Benjamin Kramer return ArrayRef<SDDbgValue*>(); 107bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen } 108bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng 109bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng typedef SmallVector<SDDbgValue*,32>::iterator DbgIterator; 110bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng DbgIterator DbgBegin() { return DbgValues.begin(); } 111bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng DbgIterator DbgEnd() { return DbgValues.end(); } 112fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen DbgIterator ByvalParmDbgBegin() { return ByvalParmDbgValues.begin(); } 113fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen DbgIterator ByvalParmDbgEnd() { return ByvalParmDbgValues.end(); } 114bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen}; 115bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen 116cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greeneclass SelectionDAG; 117cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greenevoid checkForCycles(const SDNode *N); 118cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greenevoid checkForCycles(const SelectionDAG *DAG); 119cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene 120c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// SelectionDAG class - This is used to represent a portion of an LLVM function 121c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// in a low-level Data Dependence DAG representation suitable for instruction 122c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// selection. This DAG is constructed as the first step of instruction 123c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// selection in order to allow implementation of machine specific optimizations 124c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// and code simplifications. 125c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// 126c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// The representation used by the SelectionDAG is a target-independent 127c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// representation, which has some similarities to the GCC RTL representation, 128c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// but is significantly more simple, powerful, and is a graph form instead of a 129c3aae25116e66c177579b0b79182b09340b19753Chris Lattner/// linear form. 130cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner/// 131cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattnerclass SelectionDAG { 13250d2b1ac029d63500ea9b9347561b1454fa6ed6aDan Gohman const TargetMachine &TM; 133d858e90f039f5fcdc2fa93035e911a5a9505cc50Dan Gohman const TargetLowering &TLI; 134ff7a562751604a9fe13efc75bd59622244b54d35Dan Gohman const TargetSelectionDAGInfo &TSI; 135e4b4edd72ae596ac8d1fdbc6e77f61e331f6775dChandler Carruth const TargetTransformInfo *TTI; 1367c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman MachineFunction *MF; 137512063dd0f91a76b9dd904dfff72a52b4d09e89fChris Lattner LLVMContext *Context; 1380508d047fefef36d4f943ee13c82c18cf3a943abDevang Patel CodeGenOpt::Level OptLevel; 139cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 140f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman /// EntryNode - The starting token. 141f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman SDNode EntryNode; 142f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman 143f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman /// Root - The root of the entire DAG. 144f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman SDValue Root; 145cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 146213a16c637926bfc38ba373d3aba6778e181e3ecChris Lattner /// AllNodes - A linked list of nodes in the current DAG. 147fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman ilist<SDNode> AllNodes; 148fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman 149f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman /// NodeAllocatorType - The AllocatorType for allocating SDNodes. We use 150f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman /// pool allocation with recycling. 151f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman typedef RecyclingAllocator<BumpPtrAllocator, SDNode, sizeof(LargestSDNode), 152f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman AlignOf<MostAlignedSDNode>::Alignment> 153f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman NodeAllocatorType; 154f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman 155f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman /// NodeAllocator - Pool allocation for nodes. 156f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman NodeAllocatorType NodeAllocator; 157691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth 158213a16c637926bfc38ba373d3aba6778e181e3ecChris Lattner /// CSEMap - This structure is used to memoize nodes, automatically performing 159d23b33435ae722ff5aa5ab97135a4f31041959e2Bob Wilson /// CSE with existing nodes when a duplicate is requested. 160583bd47f777fe3eb8305872fa0eadab31e833dffJim Laskey FoldingSet<SDNode> CSEMap; 161213a16c637926bfc38ba373d3aba6778e181e3ecChris Lattner 162f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman /// OperandAllocator - Pool allocation for machine-opcode SDNode operands. 163f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman BumpPtrAllocator OperandAllocator; 164f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman 165e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// Allocator - Pool allocation for misc. objects that are created once per 166e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// SelectionDAG. 167e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman BumpPtrAllocator Allocator; 168e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman 169b4e6a5df5dada0cd919cc6e2717eb3118db9cc45Bill Wendling /// SDNodeOrdering - The ordering of the SDNodes. It roughly corresponds to 170b4e6a5df5dada0cd919cc6e2717eb3118db9cc45Bill Wendling /// the ordering of the original LLVM instructions. 171b4e6a5df5dada0cd919cc6e2717eb3118db9cc45Bill Wendling SDNodeOrdering *Ordering; 172819309efec6f11ba752bd7cbfe186495745f020bDaniel Dunbar 173bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen /// DbgInfo - Tracks dbg_value information through SDISel. 174bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen SDDbgInfo *DbgInfo; 175bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen 176bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesenpublic: 177bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// DAGUpdateListener - Clients of various APIs that cause global effects on 178bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// the DAG can optionally implement this interface. This allows the clients 179bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// to handle the various sorts of updates that happen. 180bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// 181bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// A DAGUpdateListener automatically registers itself with DAG when it is 182bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// constructed, and removes itself when destroyed in RAII fashion. 183bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen struct DAGUpdateListener { 184bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen DAGUpdateListener *const Next; 185bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen SelectionDAG &DAG; 186bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen 187bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen explicit DAGUpdateListener(SelectionDAG &D) 188bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen : Next(D.UpdateListeners), DAG(D) { 189bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen DAG.UpdateListeners = this; 190bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen } 191bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen 192bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen virtual ~DAGUpdateListener() { 193bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen assert(DAG.UpdateListeners == this && 194bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen "DAGUpdateListeners must be destroyed in LIFO order"); 195bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen DAG.UpdateListeners = Next; 196bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen } 197bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen 198bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// NodeDeleted - The node N that was deleted and, if E is not null, an 199bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// equivalent node E that replaced it. 200bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen virtual void NodeDeleted(SDNode *N, SDNode *E); 201bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen 202bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// NodeUpdated - The node N that was updated. 203bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen virtual void NodeUpdated(SDNode *N); 204bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen }; 205bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen 206bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesenprivate: 207bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// DAGUpdateListener is a friend so it can manipulate the listener stack. 208bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen friend struct DAGUpdateListener; 209bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen 210bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// UpdateListeners - Linked list of registered DAGUpdateListener instances. 211bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen /// This stack is maintained by DAGUpdateListener RAII. 212bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen DAGUpdateListener *UpdateListeners; 213bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen 214c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene /// setGraphColorHelper - Implementation of setSubgraphColor. 215c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene /// Return whether we had to truncate the search. 216c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene /// 217c23b8719ef9d6b1220e854b37d40e9e1c48a82bcGabor Greif bool setSubgraphColorHelper(SDNode *N, const char *Color, 218c23b8719ef9d6b1220e854b37d40e9e1c48a82bcGabor Greif DenseSet<SDNode *> &visited, 219c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene int level, bool &printed); 220c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene 221001d3dc976d7cda8a3dd8c7fd4020b0b96033f4eCraig Topper void operator=(const SelectionDAG&) LLVM_DELETED_FUNCTION; 222001d3dc976d7cda8a3dd8c7fd4020b0b96033f4eCraig Topper SelectionDAG(const SelectionDAG&) LLVM_DELETED_FUNCTION; 223819309efec6f11ba752bd7cbfe186495745f020bDaniel Dunbar 224cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattnerpublic: 2250508d047fefef36d4f943ee13c82c18cf3a943abDevang Patel explicit SelectionDAG(const TargetMachine &TM, llvm::CodeGenOpt::Level); 226cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner ~SelectionDAG(); 227cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 2287c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman /// init - Prepare this SelectionDAG to process code in the given 2297c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman /// MachineFunction. 2307c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman /// 231e4b4edd72ae596ac8d1fdbc6e77f61e331f6775dChandler Carruth void init(MachineFunction &mf, const TargetTransformInfo *TTI); 2327c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman 2337c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman /// clear - Clear state and free memory necessary to make this 234f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman /// SelectionDAG ready to process a new block. 235f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman /// 2367c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman void clear(); 237f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman 2387c3234c6be0dc0bdf4b5d6f848cd728a77f349d7Dan Gohman MachineFunction &getMachineFunction() const { return *MF; } 23950d2b1ac029d63500ea9b9347561b1454fa6ed6aDan Gohman const TargetMachine &getTarget() const { return TM; } 240d858e90f039f5fcdc2fa93035e911a5a9505cc50Dan Gohman const TargetLowering &getTargetLoweringInfo() const { return TLI; } 241ff7a562751604a9fe13efc75bd59622244b54d35Dan Gohman const TargetSelectionDAGInfo &getSelectionDAGInfo() const { return TSI; } 242e4b4edd72ae596ac8d1fdbc6e77f61e331f6775dChandler Carruth const TargetTransformInfo *getTargetTransformInfo() const { return TTI; } 243d1474d09cbe5fdeec8ba0d6c6b52f316f3422532Owen Anderson LLVMContext *getContext() const {return Context; } 244cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 245ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey /// viewGraph - Pop up a GraphViz/gv window with the DAG rendered using 'dot'. 2461080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner /// 247462dc7f4960e5074ddf4769ec8b2ef1ba7a4d2c8Dan Gohman void viewGraph(const std::string &Title); 2480b12aef49087b57d276ed760a83525d1e2602144Dan Gohman void viewGraph(); 249fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 250ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey#ifndef NDEBUG 251ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey std::map<const SDNode *, std::string> NodeGraphAttrs; 252ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey#endif 2531080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner 254ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey /// clearGraphAttrs - Clear all previously defined node graph attributes. 255ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey /// Intended to be used from a debugging tool (eg. gdb). 256ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey void clearGraphAttrs(); 257fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 258ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey /// setGraphAttrs - Set graph attributes for a node. (eg. "color=red".) 259ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey /// 260ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey void setGraphAttrs(const SDNode *N, const char *Attrs); 261fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 262ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey /// getGraphAttrs - Get graph attributes for a node. (eg. "color=red".) 263ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey /// Used from getNodeAttributes. 264ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey const std::string getGraphAttrs(const SDNode *N) const; 265fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 266ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey /// setGraphColor - Convenience for setting node color attribute. 267ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey /// 268ec20402c90b605afeedbcf0e3aabe6f8054f23ddJim Laskey void setGraphColor(const SDNode *N, const char *Color); 2691080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner 270c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene /// setGraphColor - Convenience for setting subgraph color attribute. 271c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene /// 272c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene void setSubgraphColor(SDNode *N, const char *Color); 273c5e7e8d87d4a3b10edd5ac93ba1f3cdb4d1b449aDavid Greene 274fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman typedef ilist<SDNode>::const_iterator allnodes_const_iterator; 275b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner allnodes_const_iterator allnodes_begin() const { return AllNodes.begin(); } 276b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner allnodes_const_iterator allnodes_end() const { return AllNodes.end(); } 277fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman typedef ilist<SDNode>::iterator allnodes_iterator; 278b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner allnodes_iterator allnodes_begin() { return AllNodes.begin(); } 279b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner allnodes_iterator allnodes_end() { return AllNodes.end(); } 280fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman ilist<SDNode>::size_type allnodes_size() const { 2810e5f1306b059b62d7725f324e087efbc8e7a782dDan Gohman return AllNodes.size(); 2820e5f1306b059b62d7725f324e087efbc8e7a782dDan Gohman } 283fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 284c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// getRoot - Return the root tag of the SelectionDAG. 285cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner /// 286475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue &getRoot() const { return Root; } 287cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 288c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// getEntryNode - Return the token chain corresponding to the entry of the 289c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// function. 290f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman SDValue getEntryNode() const { 291f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman return SDValue(const_cast<SDNode *>(&EntryNode), 0); 292f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman } 293cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 294c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// setRoot - Set the current root tag of the SelectionDAG. 295cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner /// 296475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue &setRoot(SDValue N) { 297825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson assert((!N.getNode() || N.getValueType() == MVT::Other) && 298acaf09dbe4a6781163857db1321bbd5795e7d410Dan Gohman "DAG root value is not a chain!"); 299cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene if (N.getNode()) 300cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene checkForCycles(N.getNode()); 301cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene Root = N; 302cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene if (N.getNode()) 303cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene checkForCycles(this); 304cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene return Root; 305acaf09dbe4a6781163857db1321bbd5795e7d410Dan Gohman } 306cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 3071d4d41411190dd9e62764e56713753d4155764ddNate Begeman /// Combine - This iterates over the nodes in the SelectionDAG, folding 30825cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands /// certain types of nodes together, or eliminating superfluous nodes. The 30925cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands /// Level argument controls whether Combine is allowed to produce nodes and 31025cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands /// types that are illegal on the target. 31198a366d547772010e94609e4584489b3e5ce0043Bill Wendling void Combine(CombineLevel Level, AliasAnalysis &AA, 31298a366d547772010e94609e4584489b3e5ce0043Bill Wendling CodeGenOpt::Level OptLevel); 31325cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands 31401d029b82cb08367d81aa10cdc94d05360466649Chris Lattner /// LegalizeTypes - This transforms the SelectionDAG into a SelectionDAG that 31525cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands /// only uses types natively supported by the target. Returns "true" if it 31625cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands /// made any changes. 31701d029b82cb08367d81aa10cdc94d05360466649Chris Lattner /// 31801d029b82cb08367d81aa10cdc94d05360466649Chris Lattner /// Note that this is an involved process that may invalidate pointers into 31901d029b82cb08367d81aa10cdc94d05360466649Chris Lattner /// the graph. 32025cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands bool LegalizeTypes(); 32125cf2275ff7de3de3bc0e508abaf457413d74725Duncan Sands 322c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// Legalize - This transforms the SelectionDAG into a SelectionDAG that is 323c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// compatible with the target instruction selector, as indicated by the 324c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// TargetLowering object. 325cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner /// 326c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// Note that this is an involved process that may invalidate pointers into 327c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// the graph. 328975716af1b9a09274df6c2d92683449015bd8564Dan Gohman void Legalize(); 329c3aae25116e66c177579b0b79182b09340b19753Chris Lattner 3305c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// LegalizeVectors - This transforms the SelectionDAG into a SelectionDAG 3315c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// that only uses vector math operations supported by the target. This is 3325c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// necessary as a separate step from Legalize because unrolling a vector 3335c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// operation can introduce illegal types, which requires running 3345c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// LegalizeTypes again. 3355c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// 3365c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// This returns true if it made any changes; in that case, LegalizeTypes 3375c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// is called again before Legalize. 3385c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// 3395c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// Note that this is an involved process that may invalidate pointers into 3405c22c8074404797f1313b1334757254fb5c6487aEli Friedman /// the graph. 3415c22c8074404797f1313b1334757254fb5c6487aEli Friedman bool LegalizeVectors(); 3425c22c8074404797f1313b1334757254fb5c6487aEli Friedman 343d1fc96499b7619356c7542200d32da898b79f7c1Chris Lattner /// RemoveDeadNodes - This method deletes all unreachable nodes in the 344190a418bf6b49a4ef1c1980229a2f0d516e8a2cdChris Lattner /// SelectionDAG. 345190a418bf6b49a4ef1c1980229a2f0d516e8a2cdChris Lattner void RemoveDeadNodes(); 346130a6471b90f66e99b1f9f42877fdf611c330ac6Evan Cheng 347130a6471b90f66e99b1f9f42877fdf611c330ac6Evan Cheng /// DeleteNode - Remove the specified node from the system. This node must 348130a6471b90f66e99b1f9f42877fdf611c330ac6Evan Cheng /// have no referrers. 349130a6471b90f66e99b1f9f42877fdf611c330ac6Evan Cheng void DeleteNode(SDNode *N); 350130a6471b90f66e99b1f9f42877fdf611c330ac6Evan Cheng 35170046e920fa37989a041af663ada2b2b646e258fChris Lattner /// getVTList - Return an SDVTList that represents the list of values 35270046e920fa37989a041af663ada2b2b646e258fChris Lattner /// specified. 353e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDVTList getVTList(EVT VT); 354e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDVTList getVTList(EVT VT1, EVT VT2); 355e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3); 356e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3, EVT VT4); 357e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDVTList getVTList(const EVT *VTs, unsigned NumVTs); 358fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 3591b1a49714ef26225a42199cf2930529f31868322Chris Lattner //===--------------------------------------------------------------------===// 36070046e920fa37989a041af663ada2b2b646e258fChris Lattner // Node creation methods. 36170046e920fa37989a041af663ada2b2b646e258fChris Lattner // 362e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getConstant(uint64_t Val, EVT VT, bool isTarget = false); 363e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getConstant(const APInt &Val, EVT VT, bool isTarget = false); 364e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getConstant(const ConstantInt &Val, EVT VT, bool isTarget = false); 365475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue getIntPtrConstant(uint64_t Val, bool isTarget = false); 366e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getTargetConstant(uint64_t Val, EVT VT) { 367cbea3045ce0bdd061c494a831d0ce2d5834211ccChris Lattner return getConstant(Val, VT, true); 368cbea3045ce0bdd061c494a831d0ce2d5834211ccChris Lattner } 369e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getTargetConstant(const APInt &Val, EVT VT) { 3706394b099e836f56a937cdcc7332c9487b504ca68Dan Gohman return getConstant(Val, VT, true); 3716394b099e836f56a937cdcc7332c9487b504ca68Dan Gohman } 372e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getTargetConstant(const ConstantInt &Val, EVT VT) { 3734fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman return getConstant(Val, VT, true); 3744fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman } 3750a406ae0d940d92c51ee145b48ff7a483a366849Dale Johannesen // The forms below that take a double should only be used for simple 3760a406ae0d940d92c51ee145b48ff7a483a366849Dale Johannesen // constants that can be exactly represented in VT. No checks are made. 377e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getConstantFP(double Val, EVT VT, bool isTarget = false); 378e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getConstantFP(const APFloat& Val, EVT VT, bool isTarget = false); 379e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getConstantFP(const ConstantFP &CF, EVT VT, bool isTarget = false); 380e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getTargetConstantFP(double Val, EVT VT) { 381c9f8f416800784ca6453222b307bc44ad24739b0Chris Lattner return getConstantFP(Val, VT, true); 382c9f8f416800784ca6453222b307bc44ad24739b0Chris Lattner } 383e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getTargetConstantFP(const APFloat& Val, EVT VT) { 384f04afdbb48568ef09f11fd10ac03426101f2dbf8Dale Johannesen return getConstantFP(Val, VT, true); 385f04afdbb48568ef09f11fd10ac03426101f2dbf8Dale Johannesen } 386e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getTargetConstantFP(const ConstantFP &Val, EVT VT) { 3874fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman return getConstantFP(Val, VT, true); 3884fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman } 3890d881dabc1a4e1aefad6dd38de166d8358285638Devang Patel SDValue getGlobalAddress(const GlobalValue *GV, DebugLoc DL, EVT VT, 3902a4ed82ce2ba4a02f2a02eb4ed8ce5186f3f93daChris Lattner int64_t offset = 0, bool isTargetGA = false, 3912a4ed82ce2ba4a02f2a02eb4ed8ce5186f3f93daChris Lattner unsigned char TargetFlags = 0); 3920d881dabc1a4e1aefad6dd38de166d8358285638Devang Patel SDValue getTargetGlobalAddress(const GlobalValue *GV, DebugLoc DL, EVT VT, 3932a4ed82ce2ba4a02f2a02eb4ed8ce5186f3f93daChris Lattner int64_t offset = 0, 3942a4ed82ce2ba4a02f2a02eb4ed8ce5186f3f93daChris Lattner unsigned char TargetFlags = 0) { 3950d881dabc1a4e1aefad6dd38de166d8358285638Devang Patel return getGlobalAddress(GV, DL, VT, offset, true, TargetFlags); 396cbea3045ce0bdd061c494a831d0ce2d5834211ccChris Lattner } 397e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getFrameIndex(int FI, EVT VT, bool isTarget = false); 398e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getTargetFrameIndex(int FI, EVT VT) { 399c9f8f416800784ca6453222b307bc44ad24739b0Chris Lattner return getFrameIndex(FI, VT, true); 400c9f8f416800784ca6453222b307bc44ad24739b0Chris Lattner } 401e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getJumpTable(int JTI, EVT VT, bool isTarget = false, 402f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner unsigned char TargetFlags = 0); 403e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getTargetJumpTable(int JTI, EVT VT, unsigned char TargetFlags = 0) { 404f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner return getJumpTable(JTI, VT, true, TargetFlags); 405c9f8f416800784ca6453222b307bc44ad24739b0Chris Lattner } 40646510a73e977273ec67747eb34cbdb43f815e451Dan Gohman SDValue getConstantPool(const Constant *C, EVT VT, 407f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner unsigned Align = 0, int Offs = 0, bool isT=false, 408f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner unsigned char TargetFlags = 0); 40946510a73e977273ec67747eb34cbdb43f815e451Dan Gohman SDValue getTargetConstantPool(const Constant *C, EVT VT, 410f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner unsigned Align = 0, int Offset = 0, 411f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner unsigned char TargetFlags = 0) { 412f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner return getConstantPool(C, VT, Align, Offset, true, TargetFlags); 413c9f8f416800784ca6453222b307bc44ad24739b0Chris Lattner } 414e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getConstantPool(MachineConstantPoolValue *C, EVT VT, 415f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner unsigned Align = 0, int Offs = 0, bool isT=false, 416f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner unsigned char TargetFlags = 0); 417475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue getTargetConstantPool(MachineConstantPoolValue *C, 418e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT, unsigned Align = 0, 419f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner int Offset = 0, unsigned char TargetFlags=0) { 420f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner return getConstantPool(C, VT, Align, Offset, true, TargetFlags); 421d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng } 42274500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen SDValue getTargetIndex(int Index, EVT VT, int64_t Offset = 0, 42374500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen unsigned char TargetFlags = 0); 4248ad9b43e690e8773cf836b30e8da26bc71e18844Dale Johannesen // When generating a branch to a BB, we don't in general know enough 4258ad9b43e690e8773cf836b30e8da26bc71e18844Dale Johannesen // to provide debug info for the BB at that time, so keep this one around. 426475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue getBasicBlock(MachineBasicBlock *MBB); 427e8c17335c53f0f37262ee342f46b0d00ac0c1493Dale Johannesen SDValue getBasicBlock(MachineBasicBlock *MBB, DebugLoc dl); 428e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getExternalSymbol(const char *Sym, EVT VT); 429e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getExternalSymbol(const char *Sym, DebugLoc dl, EVT VT); 430e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getTargetExternalSymbol(const char *Sym, EVT VT, 4311af2231da64a14d638406d133c7912bfc1c8a9ceChris Lattner unsigned char TargetFlags = 0); 432e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getValueType(EVT); 433e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getRegister(unsigned Reg, EVT VT); 4349cf37e8b48732fccd4c301ed51aafed7074bd84eJakob Stoklund Olesen SDValue getRegisterMask(const uint32_t *RegMask); 4357561d480953e0a2faa4af9be0a00b1180097c4bdChris Lattner SDValue getEHLabel(DebugLoc dl, SDValue Root, MCSymbol *Label); 43646510a73e977273ec67747eb34cbdb43f815e451Dan Gohman SDValue getBlockAddress(const BlockAddress *BA, EVT VT, 4376c7ccaa3fd1d6e96d0bf922554b09d2b17c3b0e3Michael Liao int64_t Offset = 0, bool isTarget = false, 4386c7ccaa3fd1d6e96d0bf922554b09d2b17c3b0e3Michael Liao unsigned char TargetFlags = 0); 4396c7ccaa3fd1d6e96d0bf922554b09d2b17c3b0e3Michael Liao SDValue getTargetBlockAddress(const BlockAddress *BA, EVT VT, 4406c7ccaa3fd1d6e96d0bf922554b09d2b17c3b0e3Michael Liao int64_t Offset = 0, 4416c7ccaa3fd1d6e96d0bf922554b09d2b17c3b0e3Michael Liao unsigned char TargetFlags = 0) { 4426c7ccaa3fd1d6e96d0bf922554b09d2b17c3b0e3Michael Liao return getBlockAddress(BA, VT, Offset, true, TargetFlags); 4436c7ccaa3fd1d6e96d0bf922554b09d2b17c3b0e3Michael Liao } 444c3aae25116e66c177579b0b79182b09340b19753Chris Lattner 4450f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen SDValue getCopyToReg(SDValue Chain, DebugLoc dl, unsigned Reg, SDValue N) { 446825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return getNode(ISD::CopyToReg, dl, MVT::Other, Chain, 4470f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen getRegister(Reg, N.getValueType()), N); 4480f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen } 449cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 450e3f1026683c38f6605ccaf698b7082f1b0a0f8c8Chris Lattner // This version of the getCopyToReg method takes an extra operand, which 45129d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner // indicates that there is potentially an incoming glue value (if Glue is not 45229d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner // null) and that there should be a glue result. 4530f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen SDValue getCopyToReg(SDValue Chain, DebugLoc dl, unsigned Reg, SDValue N, 45429d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner SDValue Glue) { 455f1b4eafbfec976f939ec0ea3e8acf91cef5363e3Chris Lattner SDVTList VTs = getVTList(MVT::Other, MVT::Glue); 45629d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner SDValue Ops[] = { Chain, getRegister(Reg, N.getValueType()), N, Glue }; 45729d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner return getNode(ISD::CopyToReg, dl, VTs, Ops, Glue.getNode() ? 4 : 3); 4580f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen } 45966a48bbc3565b40ea0e6f2d58cf5e3a8e64802efEvan Cheng 460475871a144eb604ddaf37503397ba0941442e5fbDan Gohman // Similar to last getCopyToReg() except parameter Reg is a SDValue 4610f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen SDValue getCopyToReg(SDValue Chain, DebugLoc dl, SDValue Reg, SDValue N, 46229d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner SDValue Glue) { 463f1b4eafbfec976f939ec0ea3e8acf91cef5363e3Chris Lattner SDVTList VTs = getVTList(MVT::Other, MVT::Glue); 46429d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner SDValue Ops[] = { Chain, Reg, N, Glue }; 46529d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner return getNode(ISD::CopyToReg, dl, VTs, Ops, Glue.getNode() ? 4 : 3); 4660f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen } 467fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 468e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getCopyFromReg(SDValue Chain, DebugLoc dl, unsigned Reg, EVT VT) { 469825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson SDVTList VTs = getVTList(VT, MVT::Other); 4700f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen SDValue Ops[] = { Chain, getRegister(Reg, VT) }; 471fc1665793e62eb4f26d24b8a19eecf59cd872e2aDan Gohman return getNode(ISD::CopyFromReg, dl, VTs, Ops, 2); 4720f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen } 473fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 474e3f1026683c38f6605ccaf698b7082f1b0a0f8c8Chris Lattner // This version of the getCopyFromReg method takes an extra operand, which 47529d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner // indicates that there is potentially an incoming glue value (if Glue is not 47629d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner // null) and that there should be a glue result. 477e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getCopyFromReg(SDValue Chain, DebugLoc dl, unsigned Reg, EVT VT, 47829d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner SDValue Glue) { 479f1b4eafbfec976f939ec0ea3e8acf91cef5363e3Chris Lattner SDVTList VTs = getVTList(VT, MVT::Other, MVT::Glue); 48029d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner SDValue Ops[] = { Chain, getRegister(Reg, VT), Glue }; 48129d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner return getNode(ISD::CopyFromReg, dl, VTs, Ops, Glue.getNode() ? 3 : 2); 4820f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen } 48318c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner 484475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue getCondCode(ISD::CondCode Cond); 485cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 48677cdf30742284a173fe818417eb482224cdee8d4Mon P Wang /// Returns the ConvertRndSat Note: Avoid using this node because it may 48777cdf30742284a173fe818417eb482224cdee8d4Mon P Wang /// disappear in the future and most targets don't support it. 488e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getConvertRndSat(EVT VT, DebugLoc dl, SDValue Val, SDValue DTy, 4890f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen SDValue STy, 4900f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen SDValue Rnd, SDValue Sat, ISD::CvtCode Code); 4916154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson 4929008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman /// getVectorShuffle - Return an ISD::VECTOR_SHUFFLE node. The number of 4939008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman /// elements in VT, which must be a vector type, must match the number of 4945a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman /// mask elements NumElts. A integer mask element equal to -1 is treated as 4959008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman /// undefined. 4966154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson SDValue getVectorShuffle(EVT VT, DebugLoc dl, SDValue N1, SDValue N2, 4979008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman const int *MaskElts); 49877cdf30742284a173fe818417eb482224cdee8d4Mon P Wang 499a3c42f3d4e5d14c8f4fb9bb123e7759c425d041bNadav Rotem /// getAnyExtOrTrunc - Convert Op, which must be of integer type, to the 500a3c42f3d4e5d14c8f4fb9bb123e7759c425d041bNadav Rotem /// integer type VT, by either any-extending or truncating it. 501a3c42f3d4e5d14c8f4fb9bb123e7759c425d041bNadav Rotem SDValue getAnyExtOrTrunc(SDValue Op, DebugLoc DL, EVT VT); 502a3c42f3d4e5d14c8f4fb9bb123e7759c425d041bNadav Rotem 5033a66a68b0cc81193abfc074b1d360a4950151d38Duncan Sands /// getSExtOrTrunc - Convert Op, which must be of integer type, to the 5043a66a68b0cc81193abfc074b1d360a4950151d38Duncan Sands /// integer type VT, by either sign-extending or truncating it. 5053a66a68b0cc81193abfc074b1d360a4950151d38Duncan Sands SDValue getSExtOrTrunc(SDValue Op, DebugLoc DL, EVT VT); 5063a66a68b0cc81193abfc074b1d360a4950151d38Duncan Sands 5073a66a68b0cc81193abfc074b1d360a4950151d38Duncan Sands /// getZExtOrTrunc - Convert Op, which must be of integer type, to the 5083a66a68b0cc81193abfc074b1d360a4950151d38Duncan Sands /// integer type VT, by either zero-extending or truncating it. 5093a66a68b0cc81193abfc074b1d360a4950151d38Duncan Sands SDValue getZExtOrTrunc(SDValue Op, DebugLoc DL, EVT VT); 5103a66a68b0cc81193abfc074b1d360a4950151d38Duncan Sands 5111ccae666f596d5aeca5c9942995763600b622062Chris Lattner /// getZeroExtendInReg - Return the expression required to zero extend the Op 5121ccae666f596d5aeca5c9942995763600b622062Chris Lattner /// value assuming it was the smaller SrcTy value. 513e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getZeroExtendInReg(SDValue Op, DebugLoc DL, EVT SrcTy); 514fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 5154c2454623841f05c6c665659b34c214950d12d7eBob Wilson /// getNOT - Create a bitwise NOT operation as (XOR Val, -1). 516e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getNOT(DebugLoc DL, SDValue Val, EVT VT); 5174c2454623841f05c6c665659b34c214950d12d7eBob Wilson 5186a5b6d7633c96c72ca7d5f8ba0c855e4690ada04Chris Lattner /// getCALLSEQ_START - Return a new CALLSEQ_START node, which always must have 51929d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner /// a glue result (to ensure it's not CSE'd). CALLSEQ_START does not have a 520e8d7230f480654cdb8ff1c3d0a38e1e9ab0bd55fDale Johannesen /// useful DebugLoc. 521475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue getCALLSEQ_START(SDValue Chain, SDValue Op) { 522f1b4eafbfec976f939ec0ea3e8acf91cef5363e3Chris Lattner SDVTList VTs = getVTList(MVT::Other, MVT::Glue); 523475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ops[] = { Chain, Op }; 524b494ccf02ce17318d3f2a7b2d674bec60781fc73Chris Lattner return getNode(ISD::CALLSEQ_START, DebugLoc(), VTs, Ops, 2); 5256a5b6d7633c96c72ca7d5f8ba0c855e4690ada04Chris Lattner } 5261ccae666f596d5aeca5c9942995763600b622062Chris Lattner 5270f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling /// getCALLSEQ_END - Return a new CALLSEQ_END node, which always must have a 52829d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner /// glue result (to ensure it's not CSE'd). CALLSEQ_END does not have 529e8d7230f480654cdb8ff1c3d0a38e1e9ab0bd55fDale Johannesen /// a useful DebugLoc. 530475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue getCALLSEQ_END(SDValue Chain, SDValue Op1, SDValue Op2, 53129d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner SDValue InGlue) { 532f1b4eafbfec976f939ec0ea3e8acf91cef5363e3Chris Lattner SDVTList NodeTys = getVTList(MVT::Other, MVT::Glue); 533475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SmallVector<SDValue, 4> Ops; 5340f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling Ops.push_back(Chain); 5350f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling Ops.push_back(Op1); 5360f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling Ops.push_back(Op2); 53729d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner Ops.push_back(InGlue); 538b494ccf02ce17318d3f2a7b2d674bec60781fc73Chris Lattner return getNode(ISD::CALLSEQ_END, DebugLoc(), NodeTys, &Ops[0], 53929d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner (unsigned)Ops.size() - (InGlue.getNode() == 0 ? 1 : 0)); 5400f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling } 5410f8d9c04d9feef86cee35cf5fecfb348a6b3de50Bill Wendling 542e8d7230f480654cdb8ff1c3d0a38e1e9ab0bd55fDale Johannesen /// getUNDEF - Return an UNDEF node. UNDEF does not have a useful DebugLoc. 543e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getUNDEF(EVT VT) { 544b494ccf02ce17318d3f2a7b2d674bec60781fc73Chris Lattner return getNode(ISD::UNDEF, DebugLoc(), VT); 545e8d7230f480654cdb8ff1c3d0a38e1e9ab0bd55fDale Johannesen } 546e8d7230f480654cdb8ff1c3d0a38e1e9ab0bd55fDale Johannesen 547b300d2aa3ef08b5074449e2c05804717f488f4e4Dale Johannesen /// getGLOBAL_OFFSET_TABLE - Return a GLOBAL_OFFSET_TABLE node. This does 548b300d2aa3ef08b5074449e2c05804717f488f4e4Dale Johannesen /// not have a useful DebugLoc. 549e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getGLOBAL_OFFSET_TABLE(EVT VT) { 550b494ccf02ce17318d3f2a7b2d674bec60781fc73Chris Lattner return getNode(ISD::GLOBAL_OFFSET_TABLE, DebugLoc(), VT); 551b300d2aa3ef08b5074449e2c05804717f488f4e4Dale Johannesen } 552b300d2aa3ef08b5074449e2c05804717f488f4e4Dale Johannesen 553c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// getNode - Gets or creates the specified node. 554cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner /// 555e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getNode(unsigned Opcode, DebugLoc DL, EVT VT); 556e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getNode(unsigned Opcode, DebugLoc DL, EVT VT, SDValue N); 557e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getNode(unsigned Opcode, DebugLoc DL, EVT VT, SDValue N1, SDValue N2); 558e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getNode(unsigned Opcode, DebugLoc DL, EVT VT, 5597ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue N1, SDValue N2, SDValue N3); 560e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getNode(unsigned Opcode, DebugLoc DL, EVT VT, 5617ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue N1, SDValue N2, SDValue N3, SDValue N4); 562e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getNode(unsigned Opcode, DebugLoc DL, EVT VT, 5637ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue N1, SDValue N2, SDValue N3, SDValue N4, 5647ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue N5); 565e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getNode(unsigned Opcode, DebugLoc DL, EVT VT, 5667ade28cd62f5188951387e1056a46001388a21f9Bill Wendling const SDUse *Ops, unsigned NumOps); 567e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getNode(unsigned Opcode, DebugLoc DL, EVT VT, 5687ade28cd62f5188951387e1056a46001388a21f9Bill Wendling const SDValue *Ops, unsigned NumOps); 5697ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue getNode(unsigned Opcode, DebugLoc DL, 5703853f74aba301ef08b699bac2fa8e53230714a58Benjamin Kramer ArrayRef<EVT> ResultTys, 5717ade28cd62f5188951387e1056a46001388a21f9Bill Wendling const SDValue *Ops, unsigned NumOps); 572e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getNode(unsigned Opcode, DebugLoc DL, const EVT *VTs, unsigned NumVTs, 5737ade28cd62f5188951387e1056a46001388a21f9Bill Wendling const SDValue *Ops, unsigned NumOps); 5747ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue getNode(unsigned Opcode, DebugLoc DL, SDVTList VTs, 5757ade28cd62f5188951387e1056a46001388a21f9Bill Wendling const SDValue *Ops, unsigned NumOps); 5767ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue getNode(unsigned Opcode, DebugLoc DL, SDVTList VTs); 5777ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue getNode(unsigned Opcode, DebugLoc DL, SDVTList VTs, SDValue N); 5787ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue getNode(unsigned Opcode, DebugLoc DL, SDVTList VTs, 5797ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue N1, SDValue N2); 5807ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue getNode(unsigned Opcode, DebugLoc DL, SDVTList VTs, 5817ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue N1, SDValue N2, SDValue N3); 5827ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue getNode(unsigned Opcode, DebugLoc DL, SDVTList VTs, 5837ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue N1, SDValue N2, SDValue N3, SDValue N4); 5847ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue getNode(unsigned Opcode, DebugLoc DL, SDVTList VTs, 5857ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue N1, SDValue N2, SDValue N3, SDValue N4, 5867ade28cd62f5188951387e1056a46001388a21f9Bill Wendling SDValue N5); 587475871a144eb604ddaf37503397ba0941442e5fbDan Gohman 58898ca4f2a325f72374a477f9deba7d09e8999c29bDan Gohman /// getStackArgumentTokenFactor - Compute a TokenFactor to force all 58998ca4f2a325f72374a477f9deba7d09e8999c29bDan Gohman /// the incoming stack arguments to be loaded from the stack. This is 59098ca4f2a325f72374a477f9deba7d09e8999c29bDan Gohman /// used in tail call lowering to protect stack arguments from being 59198ca4f2a325f72374a477f9deba7d09e8999c29bDan Gohman /// clobbered. 59298ca4f2a325f72374a477f9deba7d09e8999c29bDan Gohman SDValue getStackArgumentTokenFactor(SDValue Chain); 59398ca4f2a325f72374a477f9deba7d09e8999c29bDan Gohman 5940f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen SDValue getMemcpy(SDValue Chain, DebugLoc dl, SDValue Dst, SDValue Src, 59520adc9dc4650313f017b27d9818eb2176238113dMon P Wang SDValue Size, unsigned Align, bool isVol, bool AlwaysInline, 596e72f2027e9116c55a5b39ac72732df8d6c45d37cChris Lattner MachinePointerInfo DstPtrInfo, 597e72f2027e9116c55a5b39ac72732df8d6c45d37cChris Lattner MachinePointerInfo SrcPtrInfo); 5985c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola 5990f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen SDValue getMemmove(SDValue Chain, DebugLoc dl, SDValue Dst, SDValue Src, 60020adc9dc4650313f017b27d9818eb2176238113dMon P Wang SDValue Size, unsigned Align, bool isVol, 601e72f2027e9116c55a5b39ac72732df8d6c45d37cChris Lattner MachinePointerInfo DstPtrInfo, 602e72f2027e9116c55a5b39ac72732df8d6c45d37cChris Lattner MachinePointerInfo SrcPtrInfo); 6035c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola 6040f502f6f44f2756f5cb7b17d8f1d8eae000d51b4Dale Johannesen SDValue getMemset(SDValue Chain, DebugLoc dl, SDValue Dst, SDValue Src, 60520adc9dc4650313f017b27d9818eb2176238113dMon P Wang SDValue Size, unsigned Align, bool isVol, 606e72f2027e9116c55a5b39ac72732df8d6c45d37cChris Lattner MachinePointerInfo DstPtrInfo); 6075c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola 6087cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner /// getSetCC - Helper function to make it easier to build SetCC's if you just 609475871a144eb604ddaf37503397ba0941442e5fbDan Gohman /// have an ISD::CondCode instead of an SDValue. 6107cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner /// 611e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getSetCC(DebugLoc DL, EVT VT, SDValue LHS, SDValue RHS, 612d69c3141ed6d237ad19fdfbfcef8901491b24c2eBill Wendling ISD::CondCode Cond) { 61328b77e968d2b01fc9da724762bd8ddcd80650e32Duncan Sands assert(LHS.getValueType().isVector() == RHS.getValueType().isVector() && 61428b77e968d2b01fc9da724762bd8ddcd80650e32Duncan Sands "Cannot compare scalars to vectors"); 61528b77e968d2b01fc9da724762bd8ddcd80650e32Duncan Sands assert(LHS.getValueType().isVector() == VT.isVector() && 61628b77e968d2b01fc9da724762bd8ddcd80650e32Duncan Sands "Cannot compare scalars to vectors"); 617d69c3141ed6d237ad19fdfbfcef8901491b24c2eBill Wendling return getNode(ISD::SETCC, DL, VT, LHS, RHS, getCondCode(Cond)); 6187cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner } 6199373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman 6209373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman /// getSelectCC - Helper function to make it easier to build SelectCC's if you 621475871a144eb604ddaf37503397ba0941442e5fbDan Gohman /// just have an ISD::CondCode instead of an SDValue. 6229373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman /// 623d69c3141ed6d237ad19fdfbfcef8901491b24c2eBill Wendling SDValue getSelectCC(DebugLoc DL, SDValue LHS, SDValue RHS, 624d69c3141ed6d237ad19fdfbfcef8901491b24c2eBill Wendling SDValue True, SDValue False, ISD::CondCode Cond) { 625d69c3141ed6d237ad19fdfbfcef8901491b24c2eBill Wendling return getNode(ISD::SELECT_CC, DL, True.getValueType(), 626d69c3141ed6d237ad19fdfbfcef8901491b24c2eBill Wendling LHS, RHS, True, False, getCondCode(Cond)); 6279373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman } 628fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 629acc398c195a697795bff3245943d104eb19192b9Nate Begeman /// getVAArg - VAArg produces a result and token chain, and takes a pointer 630acc398c195a697795bff3245943d104eb19192b9Nate Begeman /// and a source value as input. 631e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getVAArg(EVT VT, DebugLoc dl, SDValue Chain, SDValue Ptr, 632cbeeae23c31d32b833c9c7c3e8984e4cbcf22f45Rafael Espindola SDValue SV, unsigned Align); 6337cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 634fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel /// getAtomic - Gets a node for an atomic op, produces result and chain and 635c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang /// takes 3 operands 636e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT, SDValue Chain, 63760bddc8bcd787be645d2f3b64117fee884270e6aChris Lattner SDValue Ptr, SDValue Cmp, SDValue Swp, 63855ba816883842e793cdeb32fcb805c4e011b527fEli Friedman MachinePointerInfo PtrInfo, unsigned Alignment, 63955ba816883842e793cdeb32fcb805c4e011b527fEli Friedman AtomicOrdering Ordering, 64055ba816883842e793cdeb32fcb805c4e011b527fEli Friedman SynchronizationScope SynchScope); 641c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman SDValue getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT, SDValue Chain, 642c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman SDValue Ptr, SDValue Cmp, SDValue Swp, 64355ba816883842e793cdeb32fcb805c4e011b527fEli Friedman MachineMemOperand *MMO, 64455ba816883842e793cdeb32fcb805c4e011b527fEli Friedman AtomicOrdering Ordering, 64555ba816883842e793cdeb32fcb805c4e011b527fEli Friedman SynchronizationScope SynchScope); 646ab0b949e0e9de452f3b052b11634ab761e008b23Andrew Lenharth 647327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman /// getAtomic - Gets a node for an atomic op, produces result (if relevant) 648327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman /// and chain and takes 2 operands. 649e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT, SDValue Chain, 650e8c17335c53f0f37262ee342f46b0d00ac0c1493Dale Johannesen SDValue Ptr, SDValue Val, const Value* PtrVal, 651327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman unsigned Alignment, AtomicOrdering Ordering, 652327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman SynchronizationScope SynchScope); 653327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman SDValue getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT, SDValue Chain, 654327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman SDValue Ptr, SDValue Val, MachineMemOperand *MMO, 655327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman AtomicOrdering Ordering, 656327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman SynchronizationScope SynchScope); 657327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman 658327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman /// getAtomic - Gets a node for an atomic op, produces result and chain and 659327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman /// takes 1 operand. 660327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman SDValue getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT, EVT VT, 661327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman SDValue Chain, SDValue Ptr, const Value* PtrVal, 66255ba816883842e793cdeb32fcb805c4e011b527fEli Friedman unsigned Alignment, 66355ba816883842e793cdeb32fcb805c4e011b527fEli Friedman AtomicOrdering Ordering, 66455ba816883842e793cdeb32fcb805c4e011b527fEli Friedman SynchronizationScope SynchScope); 665327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman SDValue getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT, EVT VT, 666327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman SDValue Chain, SDValue Ptr, MachineMemOperand *MMO, 66755ba816883842e793cdeb32fcb805c4e011b527fEli Friedman AtomicOrdering Ordering, 66855ba816883842e793cdeb32fcb805c4e011b527fEli Friedman SynchronizationScope SynchScope); 669ab0b949e0e9de452f3b052b11634ab761e008b23Andrew Lenharth 670c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang /// getMemIntrinsicNode - Creates a MemIntrinsicNode that may produce a 671c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// result and takes a list of operands. Opcode may be INTRINSIC_VOID, 672c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// INTRINSIC_W_CHAIN, or a target-specific opcode with a value not 673c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// less than FIRST_TARGET_MEMORY_OPCODE. 674e8c17335c53f0f37262ee342f46b0d00ac0c1493Dale Johannesen SDValue getMemIntrinsicNode(unsigned Opcode, DebugLoc dl, 675e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson const EVT *VTs, unsigned NumVTs, 676e8c17335c53f0f37262ee342f46b0d00ac0c1493Dale Johannesen const SDValue *Ops, unsigned NumOps, 677e9ba5dd236f48708a00bd3bb0519148f943cc897Chris Lattner EVT MemVT, MachinePointerInfo PtrInfo, 678e8c17335c53f0f37262ee342f46b0d00ac0c1493Dale Johannesen unsigned Align = 0, bool Vol = false, 679e8c17335c53f0f37262ee342f46b0d00ac0c1493Dale Johannesen bool ReadMem = true, bool WriteMem = true); 680c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang 681e8c17335c53f0f37262ee342f46b0d00ac0c1493Dale Johannesen SDValue getMemIntrinsicNode(unsigned Opcode, DebugLoc dl, SDVTList VTList, 682e8c17335c53f0f37262ee342f46b0d00ac0c1493Dale Johannesen const SDValue *Ops, unsigned NumOps, 683e9ba5dd236f48708a00bd3bb0519148f943cc897Chris Lattner EVT MemVT, MachinePointerInfo PtrInfo, 684e8c17335c53f0f37262ee342f46b0d00ac0c1493Dale Johannesen unsigned Align = 0, bool Vol = false, 685e8c17335c53f0f37262ee342f46b0d00ac0c1493Dale Johannesen bool ReadMem = true, bool WriteMem = true); 686c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang 687c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman SDValue getMemIntrinsicNode(unsigned Opcode, DebugLoc dl, SDVTList VTList, 688c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman const SDValue *Ops, unsigned NumOps, 689c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman EVT MemVT, MachineMemOperand *MMO); 690c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman 6914bdcb61af33399d4e01fdf3c47ca1f1f5356e370Duncan Sands /// getMergeValues - Create a MERGE_VALUES node from the given operands. 69254c94525f420cab274af60e98a77f081f96e59c2Dale Johannesen SDValue getMergeValues(const SDValue *Ops, unsigned NumOps, DebugLoc dl); 693f9516208e57364ab1e7d8748af1f59a2ea5fb572Duncan Sands 694c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// getLoad - Loads are not normal binary operators: their result type is not 695c3aae25116e66c177579b0b79182b09340b19753Chris Lattner /// determined by their operands, and they produce a value AND a token chain. 696cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner /// 697e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue getLoad(EVT VT, DebugLoc dl, SDValue Chain, SDValue Ptr, 698e72f2027e9116c55a5b39ac72732df8d6c45d37cChris Lattner MachinePointerInfo PtrInfo, bool isVolatile, 699d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper bool isNonTemporal, bool isInvariant, unsigned Alignment, 70095d594cac3737ae1594a391276942a443cac426bRafael Espindola const MDNode *TBAAInfo = 0, const MDNode *Ranges = 0); 701a901129169194881a78b7fd8953e09f55b846d10Stuart Hastings SDValue getExtLoad(ISD::LoadExtType ExtType, DebugLoc dl, EVT VT, 702e72f2027e9116c55a5b39ac72732df8d6c45d37cChris Lattner SDValue Chain, SDValue Ptr, MachinePointerInfo PtrInfo, 703e72f2027e9116c55a5b39ac72732df8d6c45d37cChris Lattner EVT MemVT, bool isVolatile, 704f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman bool isNonTemporal, unsigned Alignment, 705f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman const MDNode *TBAAInfo = 0); 706e8c17335c53f0f37262ee342f46b0d00ac0c1493Dale Johannesen SDValue getIndexedLoad(SDValue OrigLoad, DebugLoc dl, SDValue Base, 707bcc8017c738e92d9c1af221b11c4916cb524184eEvan Cheng SDValue Offset, ISD::MemIndexedMode AM); 708bcc8017c738e92d9c1af221b11c4916cb524184eEvan Cheng SDValue getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, 709bcc8017c738e92d9c1af221b11c4916cb524184eEvan Cheng EVT VT, DebugLoc dl, 710bcc8017c738e92d9c1af221b11c4916cb524184eEvan Cheng SDValue Chain, SDValue Ptr, SDValue Offset, 7115c5cb2a1717f8e30b1849d7ec1cf269bc5d66877Chris Lattner MachinePointerInfo PtrInfo, EVT MemVT, 712d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper bool isVolatile, bool isNonTemporal, bool isInvariant, 71395d594cac3737ae1594a391276942a443cac426bRafael Espindola unsigned Alignment, const MDNode *TBAAInfo = 0, 71495d594cac3737ae1594a391276942a443cac426bRafael Espindola const MDNode *Ranges = 0); 7155c5cb2a1717f8e30b1849d7ec1cf269bc5d66877Chris Lattner SDValue getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, 7165c5cb2a1717f8e30b1849d7ec1cf269bc5d66877Chris Lattner EVT VT, DebugLoc dl, 7175c5cb2a1717f8e30b1849d7ec1cf269bc5d66877Chris Lattner SDValue Chain, SDValue Ptr, SDValue Offset, 718c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman EVT MemVT, MachineMemOperand *MMO); 7192d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 720ad071e1cd1a4b880019f1b2e827ee81867815f82Evan Cheng /// getStore - Helper function to build ISD::STORE nodes. 721ad071e1cd1a4b880019f1b2e827ee81867815f82Evan Cheng /// 722e8c17335c53f0f37262ee342f46b0d00ac0c1493Dale Johannesen SDValue getStore(SDValue Chain, DebugLoc dl, SDValue Val, SDValue Ptr, 7235c5cb2a1717f8e30b1849d7ec1cf269bc5d66877Chris Lattner MachinePointerInfo PtrInfo, bool isVolatile, 724f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman bool isNonTemporal, unsigned Alignment, 725f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman const MDNode *TBAAInfo = 0); 7265c5cb2a1717f8e30b1849d7ec1cf269bc5d66877Chris Lattner SDValue getStore(SDValue Chain, DebugLoc dl, SDValue Val, SDValue Ptr, 727c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman MachineMemOperand *MMO); 7285c5cb2a1717f8e30b1849d7ec1cf269bc5d66877Chris Lattner SDValue getTruncStore(SDValue Chain, DebugLoc dl, SDValue Val, SDValue Ptr, 7295c5cb2a1717f8e30b1849d7ec1cf269bc5d66877Chris Lattner MachinePointerInfo PtrInfo, EVT TVT, 7305c5cb2a1717f8e30b1849d7ec1cf269bc5d66877Chris Lattner bool isNonTemporal, bool isVolatile, 731f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman unsigned Alignment, 732f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman const MDNode *TBAAInfo = 0); 733e8c17335c53f0f37262ee342f46b0d00ac0c1493Dale Johannesen SDValue getTruncStore(SDValue Chain, DebugLoc dl, SDValue Val, SDValue Ptr, 734c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman EVT TVT, MachineMemOperand *MMO); 735e8c17335c53f0f37262ee342f46b0d00ac0c1493Dale Johannesen SDValue getIndexedStore(SDValue OrigStoe, DebugLoc dl, SDValue Base, 736e8c17335c53f0f37262ee342f46b0d00ac0c1493Dale Johannesen SDValue Offset, ISD::MemIndexedMode AM); 737ad071e1cd1a4b880019f1b2e827ee81867815f82Evan Cheng 738101a90f3d3c3ad9159676ba744b59b3a9d0b4af5Dan Gohman /// getSrcValue - Construct a node to track a Value* through the backend. 739475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue getSrcValue(const Value *v); 74069de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman 741decc2671516e6c52ee2f29f7746f8d02753845eaChris Lattner /// getMDNode - Return an MDNodeSDNode which holds an MDNode. 742decc2671516e6c52ee2f29f7746f8d02753845eaChris Lattner SDValue getMDNode(const MDNode *MD); 7436154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson 74492abc62399881ba9c525be80362c134ad836e2d9Duncan Sands /// getShiftAmountOperand - Return the specified value casted to 74592abc62399881ba9c525be80362c134ad836e2d9Duncan Sands /// the target's desired shift amount type. 7466154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson SDValue getShiftAmountOperand(EVT LHSTy, SDValue Op); 74792abc62399881ba9c525be80362c134ad836e2d9Duncan Sands 748b9aff659e82e4ec1a507e6e7fe7969379a431613Chris Lattner /// UpdateNodeOperands - *Mutate* the specified node in-place to have the 749b9aff659e82e4ec1a507e6e7fe7969379a431613Chris Lattner /// specified operands. If the resultant node already exists in the DAG, 750b9aff659e82e4ec1a507e6e7fe7969379a431613Chris Lattner /// this does not modify the specified node, instead it returns the node that 751b9aff659e82e4ec1a507e6e7fe7969379a431613Chris Lattner /// already exists. If the resultant node does not exist in the DAG, the 752b9aff659e82e4ec1a507e6e7fe7969379a431613Chris Lattner /// input node is returned. As a degenerate case, if you specify the same 753b9aff659e82e4ec1a507e6e7fe7969379a431613Chris Lattner /// input operands as the node already has, the input node is returned. 754027657db7cf60bcbf40403496d7e4a170f9ce1ecDan Gohman SDNode *UpdateNodeOperands(SDNode *N, SDValue Op); 755027657db7cf60bcbf40403496d7e4a170f9ce1ecDan Gohman SDNode *UpdateNodeOperands(SDNode *N, SDValue Op1, SDValue Op2); 756027657db7cf60bcbf40403496d7e4a170f9ce1ecDan Gohman SDNode *UpdateNodeOperands(SDNode *N, SDValue Op1, SDValue Op2, 757475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op3); 758027657db7cf60bcbf40403496d7e4a170f9ce1ecDan Gohman SDNode *UpdateNodeOperands(SDNode *N, SDValue Op1, SDValue Op2, 759475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op3, SDValue Op4); 760027657db7cf60bcbf40403496d7e4a170f9ce1ecDan Gohman SDNode *UpdateNodeOperands(SDNode *N, SDValue Op1, SDValue Op2, 761475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op3, SDValue Op4, SDValue Op5); 762027657db7cf60bcbf40403496d7e4a170f9ce1ecDan Gohman SDNode *UpdateNodeOperands(SDNode *N, 763475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue *Ops, unsigned NumOps); 764fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 7651b95095857b78e12138c22e76c7936611c51355bChris Lattner /// SelectNodeTo - These are used for target selectors to *mutate* the 7661b95095857b78e12138c22e76c7936611c51355bChris Lattner /// specified node to have the specified return type, Target opcode, and 7671b95095857b78e12138c22e76c7936611c51355bChris Lattner /// operands. Note that target opcodes are stored as 768e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// ~TargetOpcode in the node opcode field. The resultant node is returned. 769e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT); 770e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT, SDValue Op1); 771e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT, 772475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op1, SDValue Op2); 773e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT, 774475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Op1, SDValue Op2, SDValue Op3); 775e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT, 776475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue *Ops, unsigned NumOps); 777e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT1, EVT VT2); 778e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT1, 779e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT2, const SDValue *Ops, unsigned NumOps); 780e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT1, 781e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT2, EVT VT3, const SDValue *Ops, unsigned NumOps); 782e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1, 783e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT2, EVT VT3, EVT VT4, const SDValue *Ops, 78413d6d446f62f908e8cf74acb3a4df65ea5f497ceBill Wendling unsigned NumOps); 785e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT1, 786e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT2, SDValue Op1); 787e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT1, 788e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT2, SDValue Op1, SDValue Op2); 789e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT1, 790e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT2, SDValue Op1, SDValue Op2, SDValue Op3); 791e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT1, 792e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT2, EVT VT3, SDValue Op1, SDValue Op2, SDValue Op3); 793cd920d9ecfcefff13c3619a32b58399cac2e3630Dan Gohman SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, SDVTList VTs, 794475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue *Ops, unsigned NumOps); 795694481ee01bfe507c6e37de0dc1c64cff455eefdEvan Cheng 796df51247725143acb781c224faffd848cc7cf95d8Chris Lattner /// MorphNodeTo - This *mutates* the specified node to have the specified 797e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// return type, opcode, and operands. 798e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman SDNode *MorphNodeTo(SDNode *N, unsigned Opc, SDVTList VTs, 799475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue *Ops, unsigned NumOps); 800753c8f20e45f6e4198c7cf4096ecc8948a029e9cChris Lattner 801602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman /// getMachineNode - These are used for target selectors to create a new node 802602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman /// with specified return type(s), MachineInstr opcode, and operands. 8036ae46c4c8757237bca2b78b589c96c37015bc356Evan Cheng /// 804602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman /// Note that getMachineNode returns the resultant node. If there is already 805602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman /// a node of the specified opcode and operands, it returns that node instead 806602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman /// of the current one. 807c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT); 808c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT, 809c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman SDValue Op1); 810c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT, 811c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman SDValue Op1, SDValue Op2); 812c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT, 813602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman SDValue Op1, SDValue Op2, SDValue Op3); 814c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT, 815602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman const SDValue *Ops, unsigned NumOps); 816c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, EVT VT2); 817c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, EVT VT2, 818602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman SDValue Op1); 819c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, 820602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman EVT VT2, SDValue Op1, SDValue Op2); 821c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, 822602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman EVT VT2, SDValue Op1, SDValue Op2, SDValue Op3); 823c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, EVT VT2, 824602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman const SDValue *Ops, unsigned NumOps); 825c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, EVT VT2, 826602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman EVT VT3, SDValue Op1, SDValue Op2); 827c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, EVT VT2, 828602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman EVT VT3, SDValue Op1, SDValue Op2, SDValue Op3); 829c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, EVT VT2, 830602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman EVT VT3, const SDValue *Ops, unsigned NumOps); 831c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, EVT VT2, 832602b0c8c17f458d2c80f2deb3c8e554d516ee316Dan Gohman EVT VT3, EVT VT4, const SDValue *Ops, unsigned NumOps); 833c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, 8343853f74aba301ef08b699bac2fa8e53230714a58Benjamin Kramer ArrayRef<EVT> ResultTys, const SDValue *Ops, 835c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman unsigned NumOps); 836c81b783e2777b70f4533a4750489d058b6b74ad9Dan Gohman MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, SDVTList VTs, 837c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman const SDValue *Ops, unsigned NumOps); 83808b1173971a51eb89d7d6ee0992c39170c86994aEvan Cheng 8396a402dc952ccad3f8fd0d9e272dbdd261f50854eDan Gohman /// getTargetExtractSubreg - A convenience function for creating 8406a402dc952ccad3f8fd0d9e272dbdd261f50854eDan Gohman /// TargetInstrInfo::EXTRACT_SUBREG nodes. 8416a402dc952ccad3f8fd0d9e272dbdd261f50854eDan Gohman SDValue getTargetExtractSubreg(int SRIdx, DebugLoc DL, EVT VT, 8426a402dc952ccad3f8fd0d9e272dbdd261f50854eDan Gohman SDValue Operand); 8436a402dc952ccad3f8fd0d9e272dbdd261f50854eDan Gohman 8445fcbf0d26ecb99d54c182f542bf8db43ff048d6dBob Wilson /// getTargetInsertSubreg - A convenience function for creating 8455fcbf0d26ecb99d54c182f542bf8db43ff048d6dBob Wilson /// TargetInstrInfo::INSERT_SUBREG nodes. 8465fcbf0d26ecb99d54c182f542bf8db43ff048d6dBob Wilson SDValue getTargetInsertSubreg(int SRIdx, DebugLoc DL, EVT VT, 8475fcbf0d26ecb99d54c182f542bf8db43ff048d6dBob Wilson SDValue Operand, SDValue Subreg); 8485fcbf0d26ecb99d54c182f542bf8db43ff048d6dBob Wilson 84908b1173971a51eb89d7d6ee0992c39170c86994aEvan Cheng /// getNodeIfExists - Get the specified node if it's already available, or 85008b1173971a51eb89d7d6ee0992c39170c86994aEvan Cheng /// else return NULL. 85108b1173971a51eb89d7d6ee0992c39170c86994aEvan Cheng SDNode *getNodeIfExists(unsigned Opcode, SDVTList VTs, 852475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue *Ops, unsigned NumOps); 853fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 85431441b7e95e0840e1ae144e5db6f791d6a36bc60Evan Cheng /// getDbgValue - Creates a SDDbgValue node. 85531441b7e95e0840e1ae144e5db6f791d6a36bc60Evan Cheng /// 85631441b7e95e0840e1ae144e5db6f791d6a36bc60Evan Cheng SDDbgValue *getDbgValue(MDNode *MDPtr, SDNode *N, unsigned R, uint64_t Off, 85731441b7e95e0840e1ae144e5db6f791d6a36bc60Evan Cheng DebugLoc DL, unsigned O); 85846510a73e977273ec67747eb34cbdb43f815e451Dan Gohman SDDbgValue *getDbgValue(MDNode *MDPtr, const Value *C, uint64_t Off, 85931441b7e95e0840e1ae144e5db6f791d6a36bc60Evan Cheng DebugLoc DL, unsigned O); 86031441b7e95e0840e1ae144e5db6f791d6a36bc60Evan Cheng SDDbgValue *getDbgValue(MDNode *MDPtr, unsigned FI, uint64_t Off, 86131441b7e95e0840e1ae144e5db6f791d6a36bc60Evan Cheng DebugLoc DL, unsigned O); 86231441b7e95e0840e1ae144e5db6f791d6a36bc60Evan Cheng 863f8dc0617baceeba8ccd67c8881eb88eb1be2902cChris Lattner /// RemoveDeadNode - Remove the specified node from the system. If any of its 864f8dc0617baceeba8ccd67c8881eb88eb1be2902cChris Lattner /// operands then becomes dead, remove them as well. Inform UpdateListener 865f8dc0617baceeba8ccd67c8881eb88eb1be2902cChris Lattner /// for each node deleted. 866bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen void RemoveDeadNode(SDNode *N); 867fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 8680fe9c6e7babb3c0731d9cb864ec498ec4184760fDan Gohman /// RemoveDeadNodes - This method deletes the unreachable nodes in the 8690fe9c6e7babb3c0731d9cb864ec498ec4184760fDan Gohman /// given list, and any nodes that become unreachable as a result. 870bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen void RemoveDeadNodes(SmallVectorImpl<SDNode *> &DeadNodes); 8710fe9c6e7babb3c0731d9cb864ec498ec4184760fDan Gohman 8726542d950609208de3e1cde704c5f89aad864c0d9Chris Lattner /// ReplaceAllUsesWith - Modify anything using 'From' to use 'To' instead. 87326005b1b672aebd437edc561d381c5dd19a03ddbChris Lattner /// This can cause recursive merging of nodes in the DAG. Use the first 87426005b1b672aebd437edc561d381c5dd19a03ddbChris Lattner /// version if 'From' is known to have a single result, use the second 875c23e4968790395053f3f52aeb3342637fcaafdbfDan Gohman /// if you have two nodes with identical results (or if 'To' has a superset 876c23e4968790395053f3f52aeb3342637fcaafdbfDan Gohman /// of the results of 'From'), use the third otherwise. 8776542d950609208de3e1cde704c5f89aad864c0d9Chris Lattner /// 878fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel /// These methods all take an optional UpdateListener, which (if not null) is 879f8dc0617baceeba8ccd67c8881eb88eb1be2902cChris Lattner /// informed about nodes that are deleted and modified due to recursive 880f8dc0617baceeba8ccd67c8881eb88eb1be2902cChris Lattner /// changes in the dag. 881fde3f3061d665babeb78443119a09876098fc35eChris Lattner /// 8829ad136c851e0a66eb471573aac9fec47d53a61baDan Gohman /// These functions only replace all existing uses. It's possible that as 8839ad136c851e0a66eb471573aac9fec47d53a61baDan Gohman /// these replacements are being performed, CSE may cause the From node 8849ad136c851e0a66eb471573aac9fec47d53a61baDan Gohman /// to be given new uses. These new uses of From are left in place, and 8857a2bdde0a0eebcd2125055e0eacaca040f0b766cChris Lattner /// not automatically transferred to To. 8869ad136c851e0a66eb471573aac9fec47d53a61baDan Gohman /// 887bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen void ReplaceAllUsesWith(SDValue From, SDValue Op); 888bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen void ReplaceAllUsesWith(SDNode *From, SDNode *To); 889bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen void ReplaceAllUsesWith(SDNode *From, const SDValue *To); 890fae9f1cb34d6d2c4dbd007f2d748a70b67776a82Evan Cheng 89180274268b99e5a066825c8cc5aba58dbc5ad0a52Chris Lattner /// ReplaceAllUsesOfValueWith - Replace any uses of From with To, leaving 892f8dc0617baceeba8ccd67c8881eb88eb1be2902cChris Lattner /// uses of other values produced by From.Val alone. 893bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen void ReplaceAllUsesOfValueWith(SDValue From, SDValue To); 89480274268b99e5a066825c8cc5aba58dbc5ad0a52Chris Lattner 895e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// ReplaceAllUsesOfValuesWith - Like ReplaceAllUsesOfValueWith, but 896e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// for multiple values at once. This correctly handles the case where 897e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// there is an overlap between the From values and the To values. 898475871a144eb604ddaf37503397ba0941442e5fbDan Gohman void ReplaceAllUsesOfValuesWith(const SDValue *From, const SDValue *To, 899bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen unsigned Num); 900e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman 901f06c835f769aa1cf67801ed1f6bd366a447c18b1Dan Gohman /// AssignTopologicalOrder - Topological-sort the AllNodes list and a 902f06c835f769aa1cf67801ed1f6bd366a447c18b1Dan Gohman /// assign a unique node id for each node in the DAG based on their 903f06c835f769aa1cf67801ed1f6bd366a447c18b1Dan Gohman /// topological order. Returns the number of nodes. 904f06c835f769aa1cf67801ed1f6bd366a447c18b1Dan Gohman unsigned AssignTopologicalOrder(); 905e6f35d8a5cc92d776cf460200e2b815e8c301b14Evan Cheng 9068be6bbe5bfd50945ac6c5542e0f54a0924a5db8dDan Gohman /// RepositionNode - Move node N in the AllNodes list to be immediately 9078be6bbe5bfd50945ac6c5542e0f54a0924a5db8dDan Gohman /// before the given iterator Position. This may be used to update the 9088be6bbe5bfd50945ac6c5542e0f54a0924a5db8dDan Gohman /// topological ordering when the list of nodes is modified. 9098be6bbe5bfd50945ac6c5542e0f54a0924a5db8dDan Gohman void RepositionNode(allnodes_iterator Position, SDNode *N) { 9108be6bbe5bfd50945ac6c5542e0f54a0924a5db8dDan Gohman AllNodes.insert(Position, AllNodes.remove(N)); 9118be6bbe5bfd50945ac6c5542e0f54a0924a5db8dDan Gohman } 9128be6bbe5bfd50945ac6c5542e0f54a0924a5db8dDan Gohman 9131efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng /// isCommutativeBinOp - Returns true if the opcode is a commutative binary 9141efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng /// operation. 9151efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng static bool isCommutativeBinOp(unsigned Opcode) { 9164ae9e0c5301126d7f2d4b2975eb86ed21f7b574dChris Lattner // FIXME: This should get its info from the td file, so that we can include 9174ae9e0c5301126d7f2d4b2975eb86ed21f7b574dChris Lattner // target info. 9181efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng switch (Opcode) { 9191efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::ADD: 9201efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::MUL: 9211efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::MULHU: 9221efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::MULHS: 923b6c7437568f0472548ede2710458f52cfad4532eDan Gohman case ISD::SMUL_LOHI: 924b6c7437568f0472548ede2710458f52cfad4532eDan Gohman case ISD::UMUL_LOHI: 9251efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::FADD: 9261efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::FMUL: 9271efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::AND: 9281efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::OR: 9291efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::XOR: 93056e04a80b3cbd348aaf8f1828ed28fb4a9de2312Dan Gohman case ISD::SADDO: 93156e04a80b3cbd348aaf8f1828ed28fb4a9de2312Dan Gohman case ISD::UADDO: 932fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel case ISD::ADDC: 9331efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng case ISD::ADDE: return true; 9341efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng default: return false; 9351efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng } 9361efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng } 9371efba0ecb4d0b3807c48e6e0f74e3ce5c9fad809Evan Cheng 9380a29cb045444c13160e90fe7942a9d7c720185edTim Northover /// Returns an APFloat semantics tag appropriate for the given type. If VT is 9390a29cb045444c13160e90fe7942a9d7c720185edTim Northover /// a vector type, the element semantics are returned. 9400a29cb045444c13160e90fe7942a9d7c720185edTim Northover static const fltSemantics &EVTToAPFloatSemantics(EVT VT) { 9410a29cb045444c13160e90fe7942a9d7c720185edTim Northover switch (VT.getScalarType().getSimpleVT().SimpleTy) { 9420a29cb045444c13160e90fe7942a9d7c720185edTim Northover default: llvm_unreachable("Unknown FP format"); 9430a29cb045444c13160e90fe7942a9d7c720185edTim Northover case MVT::f16: return APFloat::IEEEhalf; 9440a29cb045444c13160e90fe7942a9d7c720185edTim Northover case MVT::f32: return APFloat::IEEEsingle; 9450a29cb045444c13160e90fe7942a9d7c720185edTim Northover case MVT::f64: return APFloat::IEEEdouble; 9460a29cb045444c13160e90fe7942a9d7c720185edTim Northover case MVT::f80: return APFloat::x87DoubleExtended; 9470a29cb045444c13160e90fe7942a9d7c720185edTim Northover case MVT::f128: return APFloat::IEEEquad; 9480a29cb045444c13160e90fe7942a9d7c720185edTim Northover case MVT::ppcf128: return APFloat::PPCDoubleDouble; 9490a29cb045444c13160e90fe7942a9d7c720185edTim Northover } 9500a29cb045444c13160e90fe7942a9d7c720185edTim Northover } 9510a29cb045444c13160e90fe7942a9d7c720185edTim Northover 952b4e6a5df5dada0cd919cc6e2717eb3118db9cc45Bill Wendling /// AssignOrdering - Assign an order to the SDNode. 9534533cac557cdcc13e7c990942758ec8338d9172aBill Wendling void AssignOrdering(const SDNode *SD, unsigned Order); 954b4e6a5df5dada0cd919cc6e2717eb3118db9cc45Bill Wendling 9550777e927214c61c5d681e5b7dd5d00665c81133aBill Wendling /// GetOrdering - Get the order for the SDNode. 9560777e927214c61c5d681e5b7dd5d00665c81133aBill Wendling unsigned GetOrdering(const SDNode *SD) const; 9570777e927214c61c5d681e5b7dd5d00665c81133aBill Wendling 958bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng /// AddDbgValue - Add a dbg_value SDNode. If SD is non-null that means the 959bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng /// value is produced by SD. 960fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen void AddDbgValue(SDDbgValue *DB, SDNode *SD, bool isParameter); 961bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen 962bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng /// GetDbgValues - Get the debug values which reference the given SDNode. 96322a54c1cd711afccd4558374918d12a939e1cca5Benjamin Kramer ArrayRef<SDDbgValue*> GetDbgValues(const SDNode* SD) { 964bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng return DbgInfo->getSDDbgValues(SD); 965bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng } 9666154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson 967a2e868d34ccfed46310e98338ded6a74b2b01308Devang Patel /// TransferDbgValues - Transfer SDDbgValues. 968a2e868d34ccfed46310e98338ded6a74b2b01308Devang Patel void TransferDbgValues(SDValue From, SDValue To); 969bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen 970bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng /// hasDebugValues - Return true if there are any SDDbgValue nodes associated 971bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng /// with this SelectionDAG. 972bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng bool hasDebugValues() const { return !DbgInfo->empty(); } 973bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen 974bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng SDDbgInfo::DbgIterator DbgBegin() { return DbgInfo->DbgBegin(); } 975bfcb3051899b7141a946d769fcf6e8a8453bc530Evan Cheng SDDbgInfo::DbgIterator DbgEnd() { return DbgInfo->DbgEnd(); } 9766154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson SDDbgInfo::DbgIterator ByvalParmDbgBegin() { 9776154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson return DbgInfo->ByvalParmDbgBegin(); 978fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen } 9796154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson SDDbgInfo::DbgIterator ByvalParmDbgEnd() { 9806154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson return DbgInfo->ByvalParmDbgEnd(); 981fdb42fa5fe794cc2c89e2ed7f57a89ed24d9952aDale Johannesen } 982bfdf7f38523bd38ae0538861a2bfd8bdc46e5c33Dale Johannesen 983cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner void dump() const; 984d1fc96499b7619356c7542200d32da898b79f7c1Chris Lattner 98537ce9df0da6cddc3b8bfef9b63d33d058a0f2f15Chris Lattner /// CreateStackTemporary - Create a stack temporary, suitable for holding the 986364d73ddab43b699ab90240f11b7a2eb5cf69bd8Mon P Wang /// specified value type. If minAlign is specified, the slot size will have 987364d73ddab43b699ab90240f11b7a2eb5cf69bd8Mon P Wang /// at least that alignment. 988e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue CreateStackTemporary(EVT VT, unsigned minAlign = 1); 98947d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 99047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands /// CreateStackTemporary - Create a stack temporary suitable for holding 99147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands /// either of the specified value types. 992e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue CreateStackTemporary(EVT VT1, EVT VT2); 99347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 994fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel /// FoldConstantArithmetic - 9954969310052f45b1e2e5d21735e38641a20be0e21Benjamin Kramer SDValue FoldConstantArithmetic(unsigned Opcode, EVT VT, 9964969310052f45b1e2e5d21735e38641a20be0e21Benjamin Kramer SDNode *Cst1, SDNode *Cst2); 997f3cbca279db891403659208a99f8e1cceb8c9ea6Bill Wendling 99851dabfb28375be7bc5848806ae31cd068b6133f8Chris Lattner /// FoldSetCC - Constant fold a setcc to true or false. 999e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson SDValue FoldSetCC(EVT VT, SDValue N1, 1000ff97d4fe81ef0dcee9fe490bed8ab08e40251905Dale Johannesen SDValue N2, ISD::CondCode Cond, DebugLoc dl); 1001fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 10022e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman /// SignBitIsZero - Return true if the sign bit of Op is known to be zero. We 10032e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman /// use this predicate to simplify operations downstream. 1004475871a144eb604ddaf37503397ba0941442e5fbDan Gohman bool SignBitIsZero(SDValue Op, unsigned Depth = 0) const; 10052e68b6f52d0979575b2f02ed29717d907ba0684cDan Gohman 1006ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// MaskedValueIsZero - Return true if 'Op & Mask' is known to be zero. We 1007ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// use this predicate to simplify operations downstream. Op and Mask are 1008ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// known to be the same type. 1009475871a144eb604ddaf37503397ba0941442e5fbDan Gohman bool MaskedValueIsZero(SDValue Op, const APInt &Mask, unsigned Depth = 0) 1010ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman const; 1011fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1012ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// ComputeMaskedBits - Determine which of the bits specified in Mask are 1013ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// known to be either zero or one and return them in the KnownZero/KnownOne 1014ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// bitsets. This code only analyzes bits in Mask, in order to short-circuit 1015fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel /// processing. Targets can implement the computeMaskedBitsForTargetNode 1016ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// method in the TargetLowering class to allow target nodes to be understood. 101726c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola void ComputeMaskedBits(SDValue Op, APInt &KnownZero, APInt &KnownOne, 101826c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola unsigned Depth = 0) const; 1019fd29e0eb060ea8b4d490860329234d2ae5f5952eDan Gohman 1020ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// ComputeNumSignBits - Return the number of times the sign bit of the 1021ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// register is replicated into the other bits. We know that at least 1 bit 1022ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// is always equal to the sign bit (itself), but other cases can give us 1023ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// information. For example, immediately after an "SRA X, 2", we know that 1024ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// the top 3 bits are all equal to each other, so we return 3. Targets can 1025ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// implement the ComputeNumSignBitsForTarget method in the TargetLowering 1026ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman /// class to allow target nodes to be understood. 1027475871a144eb604ddaf37503397ba0941442e5fbDan Gohman unsigned ComputeNumSignBits(SDValue Op, unsigned Depth = 0) const; 1028a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng 1029a18da59d4028a2e3f5751294e5f487281649299cChris Lattner /// isBaseWithConstantOffset - Return true if the specified operand is an 1030a18da59d4028a2e3f5751294e5f487281649299cChris Lattner /// ISD::ADD with a ConstantSDNode on the right-hand side, or if it is an 1031a18da59d4028a2e3f5751294e5f487281649299cChris Lattner /// ISD::OR with a ConstantSDNode that is guaranteed to have the same 1032a18da59d4028a2e3f5751294e5f487281649299cChris Lattner /// semantics as an ADD. This handles the equivalence: 103394c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru /// X|Cst == X+Cst iff X&Cst = 0. 1034a18da59d4028a2e3f5751294e5f487281649299cChris Lattner bool isBaseWithConstantOffset(SDValue Op) const; 10356154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson 10368d44b28bc6f615b9ad79b066987d53b1ea2a2942Dan Gohman /// isKnownNeverNan - Test whether the given SDValue is known to never be NaN. 10378d44b28bc6f615b9ad79b066987d53b1ea2a2942Dan Gohman bool isKnownNeverNaN(SDValue Op) const; 10388d44b28bc6f615b9ad79b066987d53b1ea2a2942Dan Gohman 1039e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman /// isKnownNeverZero - Test whether the given SDValue is known to never be 1040e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman /// positive or negative Zero. 1041e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman bool isKnownNeverZero(SDValue Op) const; 1042e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman 1043e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman /// isEqualTo - Test whether two SDValues are known to compare equal. This 1044e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman /// is true if they are the same value, or if one is negative zero and the 1045e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman /// other positive zero. 1046e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman bool isEqualTo(SDValue A, SDValue B) const; 1047e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman 1048cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang /// UnrollVectorOp - Utility function used by legalize and lowering to 1049cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang /// "unroll" a vector operation by splitting out the scalars and operating 1050cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang /// on each element individually. If the ResNE is 0, fully unroll the vector 1051cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang /// op. If ResNE is less than the width of the vector op, unroll up to ResNE. 1052cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang /// If the ResNE is greater than the width of the vector op, unroll the 1053cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang /// vector op and fill the end of the resulting vector with UNDEFS. 1054cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang SDValue UnrollVectorOp(SDNode *N, unsigned ResNE = 0); 1055cd6e725f21852e2f8cdf5fd0e65eb42c224776f8Mon P Wang 10566154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson /// isConsecutiveLoad - Return true if LD is loading 'Bytes' bytes from a 10576154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson /// location that is 'Dist' units away from the location that the 'Base' load 105864fa4a9584113f63eccc1a650e7e0cc4ddbab3f6Evan Cheng /// is loading from. 105964fa4a9584113f63eccc1a650e7e0cc4ddbab3f6Evan Cheng bool isConsecutiveLoad(LoadSDNode *LD, LoadSDNode *Base, 106064fa4a9584113f63eccc1a650e7e0cc4ddbab3f6Evan Cheng unsigned Bytes, int Dist) const; 106164fa4a9584113f63eccc1a650e7e0cc4ddbab3f6Evan Cheng 1062f2dc5c785dea1816cbc064b58b4b6ea23c4fd7d4Evan Cheng /// InferPtrAlignment - Infer alignment of a load / store address. Return 0 if 1063f2dc5c785dea1816cbc064b58b4b6ea23c4fd7d4Evan Cheng /// it cannot be inferred. 10647ced2e0b304e76ab746c7d9a54ad8d4930445a38Evan Cheng unsigned InferPtrAlignment(SDValue Ptr) const; 1065f2dc5c785dea1816cbc064b58b4b6ea23c4fd7d4Evan Cheng 1066d1fc96499b7619356c7542200d32da898b79f7c1Chris Lattnerprivate: 1067095cc29f321382e1f7d295e262a28197f92c5491Dan Gohman bool RemoveNodeFromCSEMaps(SDNode *N); 1068bc7d448f242b1bbc1031fb87cd69c285ff9aaffaJakob Stoklund Olesen void AddModifiedNodeToCSEMaps(SDNode *N); 1069475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDNode *FindModifiedNodeSlot(SDNode *N, SDValue Op, void *&InsertPos); 1070475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDNode *FindModifiedNodeSlot(SDNode *N, SDValue Op1, SDValue Op2, 1071a5682853b9921bbb0dd2ee175c9bd44142d4819eChris Lattner void *&InsertPos); 1072475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDNode *FindModifiedNodeSlot(SDNode *N, const SDValue *Ops, unsigned NumOps, 1073a5682853b9921bbb0dd2ee175c9bd44142d4819eChris Lattner void *&InsertPos); 10740508d047fefef36d4f943ee13c82c18cf3a943abDevang Patel SDNode *UpdadeDebugLocOnMergedSDNode(SDNode *N, DebugLoc loc); 1075b9aff659e82e4ec1a507e6e7fe7969379a431613Chris Lattner 1076fde3f3061d665babeb78443119a09876098fc35eChris Lattner void DeleteNodeNotInCSEMaps(SDNode *N); 1077c53361294957b63a9c1e405256c6f0a81db1685cDan Gohman void DeallocateNode(SDNode *N); 10789c6e70eca9a49c146b26621cbcbb9464ceeac024Dan Gohman 1079e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson unsigned getEVTAlignment(EVT MemoryVT) const; 1080f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman 1081f350b277f32d7d47f86c0e54f4aec4d470500618Dan Gohman void allnodes_clear(); 1082fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1083101a90f3d3c3ad9159676ba744b59b3a9d0b4af5Dan Gohman /// VTList - List of non-single value types. 1084e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman std::vector<SDVTList> VTList; 1085fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1086101a90f3d3c3ad9159676ba744b59b3a9d0b4af5Dan Gohman /// CondCodeNodes - Maps to auto-CSE operations. 10877cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner std::vector<CondCodeSDNode*> CondCodeNodes; 10881cff05c7c216eea0e9173738c2a60b70c2b3c013Chris Lattner 108915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner std::vector<SDNode*> ValueTypeNodes; 1090e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson std::map<EVT, SDNode*, EVT::compareRawBits> ExtendedValueTypeNodes; 1091056292fd738924f3f7703725d8f630983794b5a5Bill Wendling StringMap<SDNode*> ExternalSymbols; 10926154f6c9292179fab6346ae8336f2ad790b52028Owen Anderson 10931af2231da64a14d638406d133c7912bfc1c8a9ceChris Lattner std::map<std::pair<std::string, unsigned char>,SDNode*> TargetExternalSymbols; 1094cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner}; 1095cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 10961080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattnertemplate <> struct GraphTraits<SelectionDAG*> : public GraphTraits<SDNode*> { 10971080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner typedef SelectionDAG::allnodes_iterator nodes_iterator; 10981080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner static nodes_iterator nodes_begin(SelectionDAG *G) { 10991080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner return G->allnodes_begin(); 11001080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 11011080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner static nodes_iterator nodes_end(SelectionDAG *G) { 11021080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner return G->allnodes_end(); 11031080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 11041080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner}; 11051080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner 1106b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner} // end namespace llvm 1107cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner 1108cacf462915344c2af25eef1af1f3ee2c7280ff56Chris Lattner#endif 1109