163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner//===-- llvm/CodeGen/SelectionDAGNodes.h - SelectionDAG Nodes ---*- C++ -*-===// 2ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman// 363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner// The LLVM Compiler Infrastructure 463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner// 57ed47a13356daed2a34cd2209a31f92552e3bdd8Chris Lattner// This file is distributed under the University of Illinois Open Source 67ed47a13356daed2a34cd2209a31f92552e3bdd8Chris Lattner// License. See LICENSE.TXT for details. 7ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman// 863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner//===----------------------------------------------------------------------===// 9ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman// 1063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner// This file declares the SDNode class and derived classes, which are used to 1163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner// represent the nodes and operations present in a SelectionDAG. These nodes 1263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner// and operations are machine code level operations, with some similarities to 1363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner// the GCC RTL representation. 1463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner// 1563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner// Clients should include the SelectionDAG.h file instead of this file directly. 1663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner// 1763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner//===----------------------------------------------------------------------===// 1863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 1963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner#ifndef LLVM_CODEGEN_SELECTIONDAGNODES_H 2063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner#define LLVM_CODEGEN_SELECTIONDAGNODES_H 2163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 22dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#include "llvm/ADT/iterator_range.h" 23cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines#include "llvm/ADT/BitVector.h" 24583bd47f777fe3eb8305872fa0eadab31e833dffJim Laskey#include "llvm/ADT/FoldingSet.h" 251080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner#include "llvm/ADT/GraphTraits.h" 26255f89faee13dc491cb64fbeae3c763e7e2ea4e6Chandler Carruth#include "llvm/ADT/STLExtras.h" 27944520f38c79f3cbf1abfca92a5414458d639029Lang Hames#include "llvm/ADT/SmallPtrSet.h" 289008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman#include "llvm/ADT/SmallVector.h" 29255f89faee13dc491cb64fbeae3c763e7e2ea4e6Chandler Carruth#include "llvm/ADT/ilist_node.h" 304031d59685cef09fad651dd39020ccca4c13ef89Dan Gohman#include "llvm/CodeGen/ISDOpcodes.h" 3136b5c1338a03453ba1c110b120269ca972fb65a3Dan Gohman#include "llvm/CodeGen/MachineMemOperand.h" 32255f89faee13dc491cb64fbeae3c763e7e2ea4e6Chandler Carruth#include "llvm/CodeGen/ValueTypes.h" 330b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Constants.h" 3436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/DebugLoc.h" 350b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instructions.h" 361f6efa3996dd1929fbc129203ce5009b620e6969Michael J. Spencer#include "llvm/Support/DataTypes.h" 37255f89faee13dc491cb64fbeae3c763e7e2ea4e6Chandler Carruth#include "llvm/Support/MathExtras.h" 3863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner#include <cassert> 3963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 4063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnernamespace llvm { 4163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 4263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass SelectionDAG; 4363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass GlobalValue; 4463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass MachineBasicBlock; 45d6594ae54cfde4db4d30272192645c0a45fb9902Evan Chengclass MachineConstantPoolValue; 4663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass SDNode; 4783489bb7700c69b7a4a8da59365c42d3f5c8129bDevang Patelclass Value; 487561d480953e0a2faa4af9be0a00b1180097c4bdChris Lattnerclass MCSymbol; 4976c1b97e4020faace8c95a127f1eab66c278fb58Chris Lattnertemplate <typename T> struct DenseMapInfo; 5063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnertemplate <typename T> struct simplify_type; 518e4018e2de52c534405d7155c7009d0b35afb861Cedric Venettemplate <typename T> struct ilist_traits; 5263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 53cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines/// isBinOpWithFlags - Returns true if the opcode is a binary operation 54cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines/// with flags. 55cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hinesstatic bool isBinOpWithFlags(unsigned Opcode) { 56cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines switch (Opcode) { 57cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines case ISD::SDIV: 58cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines case ISD::UDIV: 59cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines case ISD::SRA: 60cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines case ISD::SRL: 61cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines case ISD::MUL: 62cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines case ISD::ADD: 63cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines case ISD::SUB: 64cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines case ISD::SHL: 65cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines return true; 66cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines default: 67cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines return false; 68cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines } 69cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines} 70cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 71cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hinesvoid checkForCycles(const SDNode *N, const SelectionDAG *DAG = nullptr, 72cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines bool force = false); 73d92ee757c302b9174d5f6a8375e4c235db26a7d5Nadav Rotem 740b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner/// SDVTList - This represents a list of ValueType's that has been intern'd by 750b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner/// a SelectionDAG. Instances of this simple value class are returned by 760b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner/// SelectionDAG::getVTList(...). 770b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner/// 780b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattnerstruct SDVTList { 79e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson const EVT *VTs; 80168840662e66ef8eaff6cd6a9389c4451f606e73Dan Gohman unsigned int NumVTs; 810b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner}; 820b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner 8363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnernamespace ISD { 84322dcd379eb19ea8d01478a661920ea1ce62fa0dChris Lattner /// Node predicates 85322dcd379eb19ea8d01478a661920ea1ce62fa0dChris Lattner 86a8df166fbef047c90adba3c673162a1b1f6681c4Evan Cheng /// isBuildVectorAllOnes - Return true if the specified node is a 87322dcd379eb19ea8d01478a661920ea1ce62fa0dChris Lattner /// BUILD_VECTOR where all of the elements are ~0 or undef. 88a8df166fbef047c90adba3c673162a1b1f6681c4Evan Cheng bool isBuildVectorAllOnes(const SDNode *N); 894a147842eb24a7611fcd7bfb37c55185b4664927Evan Cheng 904a147842eb24a7611fcd7bfb37c55185b4664927Evan Cheng /// isBuildVectorAllZeros - Return true if the specified node is a 914a147842eb24a7611fcd7bfb37c55185b4664927Evan Cheng /// BUILD_VECTOR where all of the elements are 0 or undef. 924a147842eb24a7611fcd7bfb37c55185b4664927Evan Cheng bool isBuildVectorAllZeros(const SDNode *N); 93bb81d97feb396a8bb21d074db1c57e9f66525f40Evan Cheng 9436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines /// \brief Return true if the specified node is a BUILD_VECTOR node of 9536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines /// all ConstantSDNode or undef. 9636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool isBuildVectorOfConstantSDNodes(const SDNode *N); 9736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 98efec751a1b786724862ceff52748df94873a807eEvan Cheng /// isScalarToVector - Return true if the specified node is a 99efec751a1b786724862ceff52748df94873a807eEvan Cheng /// ISD::SCALAR_TO_VECTOR node or a BUILD_VECTOR node where only the low 100efec751a1b786724862ceff52748df94873a807eEvan Cheng /// element is not an undef. 101efec751a1b786724862ceff52748df94873a807eEvan Cheng bool isScalarToVector(const SDNode *N); 102b87bdac6a3de4ab83e23bf808f990e4bb7eade5eNadav Rotem 103b87bdac6a3de4ab83e23bf808f990e4bb7eade5eNadav Rotem /// allOperandsUndef - Return true if the node has at least one operand 104b87bdac6a3de4ab83e23bf808f990e4bb7eade5eNadav Rotem /// and all operands of the specified node are ISD::UNDEF. 105b87bdac6a3de4ab83e23bf808f990e4bb7eade5eNadav Rotem bool allOperandsUndef(const SDNode *N); 1064031d59685cef09fad651dd39020ccca4c13ef89Dan Gohman} // end llvm:ISD namespace 10763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 10863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner//===----------------------------------------------------------------------===// 109475871a144eb604ddaf37503397ba0941442e5fbDan Gohman/// SDValue - Unlike LLVM values, Selection DAG nodes may return multiple 11063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// values as the result of a computation. Many nodes return multiple values, 11163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// from loads (which define a token and a return value) to ADDC (which returns 11263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// a result and a carry value), to calls (which may return an arbitrary number 11363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// of values). 11463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// 11563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// As such, each use of a SelectionDAG computation must indicate the node that 11663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// computes it as well as which return value to use from that node. This pair 117475871a144eb604ddaf37503397ba0941442e5fbDan Gohman/// of information is represented with the SDValue value type. 11863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// 119475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanclass SDValue { 120ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif SDNode *Node; // The node defining the value we are using. 12163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner unsigned ResNo; // Which return value of the node we are using. 12299a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greifpublic: 123dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SDValue() : Node(nullptr), ResNo(0) {} 124ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif SDValue(SDNode *node, unsigned resno) : Node(node), ResNo(resno) {} 12563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 12699a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif /// get the index which selects a specific result in the SDNode 12799a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif unsigned getResNo() const { return ResNo; } 12899a6cb92d173c142073416c81efe6d3daeb80b49Gabor Greif 129ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif /// get the SDNode which holds the desired result 130ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif SDNode *getNode() const { return Node; } 131ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif 132ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif /// set the SDNode 133ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif void setNode(SDNode *N) { Node = N; } 134ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif 1359f06cb4fe5214c93cbe68b5359b43891875b30e5Chris Lattner inline SDNode *operator->() const { return Node; } 136d92ee757c302b9174d5f6a8375e4c235db26a7d5Nadav Rotem 137475871a144eb604ddaf37503397ba0941442e5fbDan Gohman bool operator==(const SDValue &O) const { 138ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return Node == O.Node && ResNo == O.ResNo; 13963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 140475871a144eb604ddaf37503397ba0941442e5fbDan Gohman bool operator!=(const SDValue &O) const { 14163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner return !operator==(O); 14263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 143475871a144eb604ddaf37503397ba0941442e5fbDan Gohman bool operator<(const SDValue &O) const { 14436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return std::tie(Node, ResNo) < std::tie(O.Node, O.ResNo); 14563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 146cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines LLVM_EXPLICIT operator bool() const { 147cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines return Node != nullptr; 148cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines } 14963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 150475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue getValue(unsigned R) const { 151ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return SDValue(Node, R); 15263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 15363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 154917be6814e0a4e529d290be5d806a054bbbc4a27Evan Cheng // isOperandOf - Return true if this node is an operand of N. 155917be6814e0a4e529d290be5d806a054bbbc4a27Evan Cheng bool isOperandOf(SDNode *N) const; 156bfa284f69752c54f81bffc2b0d15d5c1e618a659Evan Cheng 15763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// getValueType - Return the ValueType of the referenced return value. 15863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// 159e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson inline EVT getValueType() const; 160ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman 161a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund /// Return the simple ValueType of the referenced return value. 162a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund MVT getSimpleValueType() const { 163a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund return getValueType().getSimpleVT(); 164a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund } 165a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund 16683ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands /// getValueSizeInBits - Returns the size of the value in bits. 1674fc3d5dac255120e2f0c0b537044fcf56a30fa34Dan Gohman /// 1684fc3d5dac255120e2f0c0b537044fcf56a30fa34Dan Gohman unsigned getValueSizeInBits() const { 16983ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands return getValueType().getSizeInBits(); 1704fc3d5dac255120e2f0c0b537044fcf56a30fa34Dan Gohman } 1714fc3d5dac255120e2f0c0b537044fcf56a30fa34Dan Gohman 17236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned getScalarValueSizeInBits() const { 17336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return getValueType().getScalarType().getSizeInBits(); 17436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 17536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 17663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // Forwarding methods - These forward to the corresponding methods in SDNode. 17763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner inline unsigned getOpcode() const; 17863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner inline unsigned getNumOperands() const; 179475871a144eb604ddaf37503397ba0941442e5fbDan Gohman inline const SDValue &getOperand(unsigned i) const; 180c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng inline uint64_t getConstantOperandVal(unsigned i) const; 181c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman inline bool isTargetMemoryOpcode() const; 1820f66a9172175aa7c3055333358170581c999219bNate Begeman inline bool isTargetOpcode() const; 183e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman inline bool isMachineOpcode() const; 184e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman inline unsigned getMachineOpcode() const; 185124c7fdd69bd0eebdec8aab7caa2f8779a56d878Dale Johannesen inline const DebugLoc getDebugLoc() const; 18652b7ec68d221d65aacbe9b55de325c9b7370b59dNadav Rotem inline void dump() const; 18752b7ec68d221d65aacbe9b55de325c9b7370b59dNadav Rotem inline void dumpr() const; 188fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 189572dee71af1313e6742e1dfd5274fff326b9ef1cChris Lattner /// reachesChainWithoutSideEffects - Return true if this operand (which must 190fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel /// be a chain) reaches the specified operand without crossing any 191572dee71af1313e6742e1dfd5274fff326b9ef1cChris Lattner /// side-effecting instructions. In practice, this looks through token 192572dee71af1313e6742e1dfd5274fff326b9ef1cChris Lattner /// factors and non-volatile loads. In order to remain efficient, this only 193572dee71af1313e6742e1dfd5274fff326b9ef1cChris Lattner /// looks a couple of nodes in, it does not do an exhaustive search. 194fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel bool reachesChainWithoutSideEffects(SDValue Dest, 195dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein unsigned Depth = 2) const; 196fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1977a24cdc4ed5c357e9de4e36a39379e0aa67f6f9cDan Gohman /// use_empty - Return true if there are no nodes using value ResNo 198ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif /// of Node. 1997a24cdc4ed5c357e9de4e36a39379e0aa67f6f9cDan Gohman /// 200e1b50639a860934685dff840e1826b16dbe6a344Dan Gohman inline bool use_empty() const; 2017a24cdc4ed5c357e9de4e36a39379e0aa67f6f9cDan Gohman 202231fe7054160d2953e0cc6635f9a171a4b311af2Gabor Greif /// hasOneUse - Return true if there is exactly one node using value 203ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif /// ResNo of Node. 2047a24cdc4ed5c357e9de4e36a39379e0aa67f6f9cDan Gohman /// 2057a24cdc4ed5c357e9de4e36a39379e0aa67f6f9cDan Gohman inline bool hasOneUse() const; 20663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 20763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 20863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 209475871a144eb604ddaf37503397ba0941442e5fbDan Gohmantemplate<> struct DenseMapInfo<SDValue> { 210fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel static inline SDValue getEmptyKey() { 211fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel return SDValue((SDNode*)-1, -1U); 212dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein } 213fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel static inline SDValue getTombstoneKey() { 214475871a144eb604ddaf37503397ba0941442e5fbDan Gohman return SDValue((SDNode*)-1, 0); 215dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein } 216475871a144eb604ddaf37503397ba0941442e5fbDan Gohman static unsigned getHashValue(const SDValue &Val) { 217ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return ((unsigned)((uintptr_t)Val.getNode() >> 4) ^ 218ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif (unsigned)((uintptr_t)Val.getNode() >> 9)) + Val.getResNo(); 219c63d391c9a886d58c6a53a7f565fbd544b076d9fEvan Cheng } 220475871a144eb604ddaf37503397ba0941442e5fbDan Gohman static bool isEqual(const SDValue &LHS, const SDValue &RHS) { 22176c1b97e4020faace8c95a127f1eab66c278fb58Chris Lattner return LHS == RHS; 22276c1b97e4020faace8c95a127f1eab66c278fb58Chris Lattner } 223c63d391c9a886d58c6a53a7f565fbd544b076d9fEvan Cheng}; 2244bbf4ee1491637c247e195e19e3e4a8ee5ad72faChris Lattnertemplate <> struct isPodLike<SDValue> { static const bool value = true; }; 2254bbf4ee1491637c247e195e19e3e4a8ee5ad72faChris Lattner 226c63d391c9a886d58c6a53a7f565fbd544b076d9fEvan Cheng 22763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// simplify_type specializations - Allow casting operators to work directly on 228475871a144eb604ddaf37503397ba0941442e5fbDan Gohman/// SDValues as if they were SDNode*'s. 229475871a144eb604ddaf37503397ba0941442e5fbDan Gohmantemplate<> struct simplify_type<SDValue> { 230dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein typedef SDNode* SimpleType; 2317fe65d691dcce550d53ec9310913aab67ab6d654Rafael Espindola static SimpleType getSimplifiedValue(SDValue &Val) { 2327fe65d691dcce550d53ec9310913aab67ab6d654Rafael Espindola return Val.getNode(); 233dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein } 234dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein}; 235475871a144eb604ddaf37503397ba0941442e5fbDan Gohmantemplate<> struct simplify_type<const SDValue> { 2367fe65d691dcce550d53ec9310913aab67ab6d654Rafael Espindola typedef /*const*/ SDNode* SimpleType; 237475871a144eb604ddaf37503397ba0941442e5fbDan Gohman static SimpleType getSimplifiedValue(const SDValue &Val) { 2387fe65d691dcce550d53ec9310913aab67ab6d654Rafael Espindola return Val.getNode(); 239dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein } 240dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein}; 241dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 242e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman/// SDUse - Represents a use of a SDNode. This class holds an SDValue, 243e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman/// which records the SDNode being used and the result number, a 244e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman/// pointer to the SDNode using the value, and Next and Prev pointers, 245e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman/// which link together all the uses of an SDNode. 246e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman/// 2479cac5259fe237120a0c347d6d14e549005148f1bRoman Levensteinclass SDUse { 248e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// Val - The value being used. 249e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman SDValue Val; 250e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// User - The user of this value. 251e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman SDNode *User; 252fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel /// Prev, Next - Pointers to the uses list of the SDNode referred by 253dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein /// this operand. 2549cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein SDUse **Prev, *Next; 255dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 256001d3dc976d7cda8a3dd8c7fd4020b0b96033f4eCraig Topper SDUse(const SDUse &U) LLVM_DELETED_FUNCTION; 257001d3dc976d7cda8a3dd8c7fd4020b0b96033f4eCraig Topper void operator=(const SDUse &U) LLVM_DELETED_FUNCTION; 258dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 259e7852d014432a06c783de3c350eb96e686f10f92Dan Gohmanpublic: 260dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SDUse() : Val(), User(nullptr), Prev(nullptr), Next(nullptr) {} 261dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 262e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// Normally SDUse will just implicitly convert to an SDValue that it holds. 263e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman operator const SDValue&() const { return Val; } 264dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 265e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// If implicit conversion to SDValue doesn't work, the get() method returns 266e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// the SDValue. 267e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman const SDValue &get() const { return Val; } 268fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 269e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// getUser - This returns the SDNode that contains this Use. 27002819257a625d0d9a186845354baadd6e8f1890bRoman Levenstein SDNode *getUser() { return User; } 2719cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein 272e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// getNext - Get the next SDUse in the use list. 273e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman SDUse *getNext() const { return Next; } 2749cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein 275e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// getNode - Convenience function for get().getNode(). 276e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman SDNode *getNode() const { return Val.getNode(); } 277e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// getResNo - Convenience function for get().getResNo(). 278e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman unsigned getResNo() const { return Val.getResNo(); } 279e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// getValueType - Convenience function for get().getValueType(). 280e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT getValueType() const { return Val.getValueType(); } 2819cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein 282e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// operator== - Convenience function for get().operator== 283e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman bool operator==(const SDValue &V) const { 284e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman return Val == V; 2859cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein } 286fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 287e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// operator!= - Convenience function for get().operator!= 288e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman bool operator!=(const SDValue &V) const { 289e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman return Val != V; 2909cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein } 2919cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein 292e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// operator< - Convenience function for get().operator< 293e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman bool operator<(const SDValue &V) const { 294e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman return Val < V; 2959cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein } 2969cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein 297e7852d014432a06c783de3c350eb96e686f10f92Dan Gohmanprivate: 298e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman friend class SelectionDAG; 299e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman friend class SDNode; 300e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman 301e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman void setUser(SDNode *p) { User = p; } 302e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman 303e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// set - Remove this use from its existing use list, assign it the 304e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// given value, and add it to the new value's node's use list. 305e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman inline void set(const SDValue &V); 306e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// setInitial - like set, but only supports initializing a newly-allocated 307e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// SDUse with a non-null value. 308e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman inline void setInitial(const SDValue &V); 309e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// setNode - like set, but only sets the Node portion of the value, 310e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// leaving the ResNo portion unmodified. 311e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman inline void setNode(SDNode *N); 312e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman 3139cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein void addToList(SDUse **List) { 314dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein Next = *List; 315dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein if (Next) Next->Prev = &Next; 316dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein Prev = List; 317dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein *List = this; 318dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein } 319dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 320dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein void removeFromList() { 321dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein *Prev = Next; 322dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein if (Next) Next->Prev = Prev; 323dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein } 324dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein}; 325dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 326dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein/// simplify_type specializations - Allow casting operators to work directly on 327475871a144eb604ddaf37503397ba0941442e5fbDan Gohman/// SDValues as if they were SDNode*'s. 3289cac5259fe237120a0c347d6d14e549005148f1bRoman Levensteintemplate<> struct simplify_type<SDUse> { 32963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner typedef SDNode* SimpleType; 3307fe65d691dcce550d53ec9310913aab67ab6d654Rafael Espindola static SimpleType getSimplifiedValue(SDUse &Val) { 3317fe65d691dcce550d53ec9310913aab67ab6d654Rafael Espindola return Val.getNode(); 33263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 33363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 33463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 33563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 33663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// SDNode - Represents one node in the SelectionDAG. 33763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// 338fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohmanclass SDNode : public FoldingSetNode, public ilist_node<SDNode> { 339dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levensteinprivate: 3400442fbfadbeea21eee9df88dc466d95e040dde6bChris Lattner /// NodeType - The operation that this node performs. 3410442fbfadbeea21eee9df88dc466d95e040dde6bChris Lattner /// 342c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman int16_t NodeType; 343fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 34463e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner /// OperandsNeedDelete - This is true if OperandList was new[]'d. If true, 34563e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner /// then they will be delete[]'d when the node is destroyed. 346c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman uint16_t OperandsNeedDelete : 1; 3470442fbfadbeea21eee9df88dc466d95e040dde6bChris Lattner 34806a26637daff1bb785ef0945d1ba05f6ccdfab86Dale Johannesen /// HasDebugValue - This tracks whether this node has one or more dbg_value 34906a26637daff1bb785ef0945d1ba05f6ccdfab86Dale Johannesen /// nodes corresponding to it. 35006a26637daff1bb785ef0945d1ba05f6ccdfab86Dale Johannesen uint16_t HasDebugValue : 1; 35106a26637daff1bb785ef0945d1ba05f6ccdfab86Dale Johannesen 352ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohmanprotected: 353ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman /// SubclassData - This member is defined by this class, but is not used for 354ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman /// anything. Subclasses can use it to hold whatever state they find useful. 355ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman /// This field is initialized to zero by the ctor. 35606a26637daff1bb785ef0945d1ba05f6ccdfab86Dale Johannesen uint16_t SubclassData : 14; 357ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman 358ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohmanprivate: 359b9ee9e60a905b90fa3e84c5c6091af6e5a0382d2Evan Cheng /// NodeId - Unique id per SDNode in the DAG. 360b9ee9e60a905b90fa3e84c5c6091af6e5a0382d2Evan Cheng int NodeId; 3610442fbfadbeea21eee9df88dc466d95e040dde6bChris Lattner 362f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner /// OperandList - The values that are used by this operation. 3630442fbfadbeea21eee9df88dc466d95e040dde6bChris Lattner /// 3649cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein SDUse *OperandList; 365fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 366f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner /// ValueList - The types of the values this node defines. SDNode's may 367f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner /// define multiple values simultaneously. 368e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson const EVT *ValueList; 36963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 370e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// UseList - List of uses for this SDNode. 371e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman SDUse *UseList; 372dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 3738f1174d13d233fe6b8418475df15eeff87a52f37Dan Gohman /// NumOperands/NumValues - The number of entries in the Operand/Value list. 3748f1174d13d233fe6b8418475df15eeff87a52f37Dan Gohman unsigned short NumOperands, NumValues; 3758f1174d13d233fe6b8418475df15eeff87a52f37Dan Gohman 3768f1174d13d233fe6b8418475df15eeff87a52f37Dan Gohman /// debugLoc - source line information. 3778f1174d13d233fe6b8418475df15eeff87a52f37Dan Gohman DebugLoc debugLoc; 3788f1174d13d233fe6b8418475df15eeff87a52f37Dan Gohman 379ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick // The ordering of the SDNodes. It roughly corresponds to the ordering of the 380ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick // original LLVM instructions. 381ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick // This is used for turning off scheduling, because we'll forgo 382ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick // the normal scheduling algorithms and output the instructions according to 383ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick // this ordering. 384ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick unsigned IROrder; 385ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick 386e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// getValueTypeList - Return a pointer to the specified value type. 387e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson static const EVT *getValueTypeList(EVT VT); 388e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman 389e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman friend class SelectionDAG; 390e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman friend struct ilist_traits<SDNode>; 391dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 39263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 39363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner //===--------------------------------------------------------------------===// 39463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // Accessors 39563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // 396e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman 397e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// getOpcode - Return the SelectionDAG opcode value for this node. For 398e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// pre-isel nodes (those for which isMachineOpcode returns false), these 399e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// are the opcode values in the ISD and <target>ISD namespaces. For 400e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// post-isel opcodes, see getMachineOpcode. 401e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman unsigned getOpcode() const { return (unsigned short)NodeType; } 402e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman 403e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// isTargetOpcode - Test if this node has a target-specific opcode (in the 4040f8b53f19d29013ab18f3d444cea1e6305405611Dan Gohman /// \<target\>ISD namespace). 4050f66a9172175aa7c3055333358170581c999219bNate Begeman bool isTargetOpcode() const { return NodeType >= ISD::BUILTIN_OP_END; } 406e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman 4073af4d250676623b88436b89212108eb4fff897d3Jack Carter /// isTargetMemoryOpcode - Test if this node has a target-specific 408c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// memory-referencing opcode (in the \<target\>ISD namespace and 409c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// greater than FIRST_TARGET_MEMORY_OPCODE). 410c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman bool isTargetMemoryOpcode() const { 411c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman return NodeType >= ISD::FIRST_TARGET_MEMORY_OPCODE; 412c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman } 413c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman 414e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// isMachineOpcode - Test if this node has a post-isel opcode, directly 415e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// corresponding to a MachineInstr opcode. 416e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman bool isMachineOpcode() const { return NodeType < 0; } 417e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman 418e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// getMachineOpcode - This may only be called if isMachineOpcode returns 419e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// true. It returns the MachineInstr opcode value that the node's opcode 420e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// corresponds to. 421e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman unsigned getMachineOpcode() const { 422ec89a364b86ccd943fc6cf3ad8f84825ba1550fdDan Gohman assert(isMachineOpcode() && "Not a MachineInstr opcode!"); 423e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman return ~NodeType; 4240f66a9172175aa7c3055333358170581c999219bNate Begeman } 42563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 42606a26637daff1bb785ef0945d1ba05f6ccdfab86Dale Johannesen /// getHasDebugValue - get this bit. 42706a26637daff1bb785ef0945d1ba05f6ccdfab86Dale Johannesen bool getHasDebugValue() const { return HasDebugValue; } 42806a26637daff1bb785ef0945d1ba05f6ccdfab86Dale Johannesen 42906a26637daff1bb785ef0945d1ba05f6ccdfab86Dale Johannesen /// setHasDebugValue - set this bit. 43006a26637daff1bb785ef0945d1ba05f6ccdfab86Dale Johannesen void setHasDebugValue(bool b) { HasDebugValue = b; } 43106a26637daff1bb785ef0945d1ba05f6ccdfab86Dale Johannesen 4326da38a05f6d904bd4c2bf51d43938e28e00402abDan Gohman /// use_empty - Return true if there are no uses of this node. 4337a24cdc4ed5c357e9de4e36a39379e0aa67f6f9cDan Gohman /// 434dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines bool use_empty() const { return UseList == nullptr; } 4357a24cdc4ed5c357e9de4e36a39379e0aa67f6f9cDan Gohman 4366da38a05f6d904bd4c2bf51d43938e28e00402abDan Gohman /// hasOneUse - Return true if there is exactly one use of this node. 4377a24cdc4ed5c357e9de4e36a39379e0aa67f6f9cDan Gohman /// 438b9c33c32292d0ae5da2d75623a84a0e7796a2b63Dan Gohman bool hasOneUse() const { 43936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return !use_empty() && std::next(use_begin()) == use_end(); 440b9c33c32292d0ae5da2d75623a84a0e7796a2b63Dan Gohman } 44163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 4426da38a05f6d904bd4c2bf51d43938e28e00402abDan Gohman /// use_size - Return the number of uses of this node. This method takes 4437a24cdc4ed5c357e9de4e36a39379e0aa67f6f9cDan Gohman /// time proportional to the number of uses. 4447a24cdc4ed5c357e9de4e36a39379e0aa67f6f9cDan Gohman /// 4457a24cdc4ed5c357e9de4e36a39379e0aa67f6f9cDan Gohman size_t use_size() const { return std::distance(use_begin(), use_end()); } 4467a24cdc4ed5c357e9de4e36a39379e0aa67f6f9cDan Gohman 447b9ee9e60a905b90fa3e84c5c6091af6e5a0382d2Evan Cheng /// getNodeId - Return the unique node id. 448b9ee9e60a905b90fa3e84c5c6091af6e5a0382d2Evan Cheng /// 449b9ee9e60a905b90fa3e84c5c6091af6e5a0382d2Evan Cheng int getNodeId() const { return NodeId; } 4500442fbfadbeea21eee9df88dc466d95e040dde6bChris Lattner 4512e07d33f04c513f3c2da3d7b1acfc098f02c7a6eEvan Cheng /// setNodeId - Set unique node id. 4522e07d33f04c513f3c2da3d7b1acfc098f02c7a6eEvan Cheng void setNodeId(int Id) { NodeId = Id; } 4532e07d33f04c513f3c2da3d7b1acfc098f02c7a6eEvan Cheng 454ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick /// getIROrder - Return the node ordering. 455ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick /// 456ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick unsigned getIROrder() const { return IROrder; } 457ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick 458ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick /// setIROrder - Set the node ordering. 459ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick /// 460ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick void setIROrder(unsigned Order) { IROrder = Order; } 461ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick 4623b1a9c5bceb40a5cf0aecdaf7a389c72a855b52aDale Johannesen /// getDebugLoc - Return the source location info. 463124c7fdd69bd0eebdec8aab7caa2f8779a56d878Dale Johannesen const DebugLoc getDebugLoc() const { return debugLoc; } 4643b1a9c5bceb40a5cf0aecdaf7a389c72a855b52aDale Johannesen 465ab160cf371d6148d49b5401a903dd4ce381b2f8cDale Johannesen /// setDebugLoc - Set source location info. Try to avoid this, putting 466ab160cf371d6148d49b5401a903dd4ce381b2f8cDale Johannesen /// it in the constructor is preferable. 467124c7fdd69bd0eebdec8aab7caa2f8779a56d878Dale Johannesen void setDebugLoc(const DebugLoc dl) { debugLoc = dl; } 4683b1a9c5bceb40a5cf0aecdaf7a389c72a855b52aDale Johannesen 4699cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein /// use_iterator - This class provides iterator support for SDUse 470fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel /// operands that use a specific SDNode. 471dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein class use_iterator 472f0891be8bdbeeadb39da5575273b6645755fa383Gabor Greif : public std::iterator<std::forward_iterator_tag, SDUse, ptrdiff_t> { 4739cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein SDUse *Op; 4749cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein explicit use_iterator(SDUse *op) : Op(op) { 475dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein } 476dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein friend class SDNode; 477dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein public: 4787362ce08cb2c1f0b544b18dbc21630fb4baebcfcGabor Greif typedef std::iterator<std::forward_iterator_tag, 4797362ce08cb2c1f0b544b18dbc21630fb4baebcfcGabor Greif SDUse, ptrdiff_t>::reference reference; 4807362ce08cb2c1f0b544b18dbc21630fb4baebcfcGabor Greif typedef std::iterator<std::forward_iterator_tag, 4817362ce08cb2c1f0b544b18dbc21630fb4baebcfcGabor Greif SDUse, ptrdiff_t>::pointer pointer; 482dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 483dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein use_iterator(const use_iterator &I) : Op(I.Op) {} 484dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines use_iterator() : Op(nullptr) {} 485dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 486dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein bool operator==(const use_iterator &x) const { 487dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein return Op == x.Op; 488dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein } 489dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein bool operator!=(const use_iterator &x) const { 490dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein return !operator==(x); 491dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein } 492fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 493dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein /// atEnd - return true if this iterator is at the end of uses list. 494dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines bool atEnd() const { return Op == nullptr; } 495dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 496dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein // Iterator traversal: forward iteration only. 497dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein use_iterator &operator++() { // Preincrement 498dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein assert(Op && "Cannot increment end iterator!"); 499dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein Op = Op->getNext(); 500dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein return *this; 501dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein } 502dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 503dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein use_iterator operator++(int) { // Postincrement 504dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein use_iterator tmp = *this; ++*this; return tmp; 505dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein } 506dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 5078968450305c28444edc3c272d8752a8db0c2f34aDan Gohman /// Retrieve a pointer to the current user node. 5088968450305c28444edc3c272d8752a8db0c2f34aDan Gohman SDNode *operator*() const { 509dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein assert(Op && "Cannot dereference end iterator!"); 5108968450305c28444edc3c272d8752a8db0c2f34aDan Gohman return Op->getUser(); 511dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein } 512dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 5138968450305c28444edc3c272d8752a8db0c2f34aDan Gohman SDNode *operator->() const { return operator*(); } 5148968450305c28444edc3c272d8752a8db0c2f34aDan Gohman 5158968450305c28444edc3c272d8752a8db0c2f34aDan Gohman SDUse &getUse() const { return *Op; } 516dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 517174f938bd042a19d1a840eef6ed162fc938e2fd9Duncan Sands /// getOperandNo - Retrieve the operand # of this use in its user. 5188968450305c28444edc3c272d8752a8db0c2f34aDan Gohman /// 5198968450305c28444edc3c272d8752a8db0c2f34aDan Gohman unsigned getOperandNo() const { 520dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein assert(Op && "Cannot dereference end iterator!"); 5218968450305c28444edc3c272d8752a8db0c2f34aDan Gohman return (unsigned)(Op - Op->getUser()->OperandList); 522dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein } 523dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein }; 524dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 525dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein /// use_begin/use_end - Provide iteration support to walk over all uses 526dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein /// of an SDNode. 527dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 528dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein use_iterator use_begin() const { 529e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman return use_iterator(UseList); 530dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein } 531dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 532dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines static use_iterator use_end() { return use_iterator(nullptr); } 533dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein 534dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines inline iterator_range<use_iterator> uses() { 535dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return iterator_range<use_iterator>(use_begin(), use_end()); 536dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 537dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines inline iterator_range<use_iterator> uses() const { 538dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return iterator_range<use_iterator>(use_begin(), use_end()); 539dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 5407ece380440238ad0630a225b85a09a2dbed1165aChris Lattner 541b18a2f816cc9d1351ca8e380a6db5c5ef981943eChris Lattner /// hasNUsesOfValue - Return true if there are exactly NUSES uses of the 542b18a2f816cc9d1351ca8e380a6db5c5ef981943eChris Lattner /// indicated value. This method ignores uses of other values defined by this 543b18a2f816cc9d1351ca8e380a6db5c5ef981943eChris Lattner /// operation. 5444ee621125876cc954cba5280dd9395552755a871Evan Cheng bool hasNUsesOfValue(unsigned NUses, unsigned Value) const; 5454ee621125876cc954cba5280dd9395552755a871Evan Cheng 54633d5595d667ba4a880bd7fe785724e8197bef70cEvan Cheng /// hasAnyUseOfValue - Return true if there are any use of the indicated 54733d5595d667ba4a880bd7fe785724e8197bef70cEvan Cheng /// value. This method ignores uses of other values defined by this operation. 54833d5595d667ba4a880bd7fe785724e8197bef70cEvan Cheng bool hasAnyUseOfValue(unsigned Value) const; 54933d5595d667ba4a880bd7fe785724e8197bef70cEvan Cheng 5502a6299543fa22f389158409e897fe7099fda3812Dan Gohman /// isOnlyUserOf - Return true if this node is the only use of N. 551e6e97e66a366cc7d2d103ac58db56e4bfd700b10Evan Cheng /// 5522a6299543fa22f389158409e897fe7099fda3812Dan Gohman bool isOnlyUserOf(SDNode *N) const; 553b18a2f816cc9d1351ca8e380a6db5c5ef981943eChris Lattner 554917be6814e0a4e529d290be5d806a054bbbc4a27Evan Cheng /// isOperandOf - Return true if this node is an operand of N. 555e6e97e66a366cc7d2d103ac58db56e4bfd700b10Evan Cheng /// 556917be6814e0a4e529d290be5d806a054bbbc4a27Evan Cheng bool isOperandOf(SDNode *N) const; 55780d8eaae05d9bcb25abf6c6f0385ec2554355f26Evan Cheng 558944520f38c79f3cbf1abfca92a5414458d639029Lang Hames /// isPredecessorOf - Return true if this node is a predecessor of N. 559944520f38c79f3cbf1abfca92a5414458d639029Lang Hames /// NOTE: Implemented on top of hasPredecessor and every bit as 560944520f38c79f3cbf1abfca92a5414458d639029Lang Hames /// expensive. Use carefully. 5613af4d250676623b88436b89212108eb4fff897d3Jack Carter bool isPredecessorOf(const SDNode *N) const { 5623af4d250676623b88436b89212108eb4fff897d3Jack Carter return N->hasPredecessor(this); 5633af4d250676623b88436b89212108eb4fff897d3Jack Carter } 564944520f38c79f3cbf1abfca92a5414458d639029Lang Hames 565944520f38c79f3cbf1abfca92a5414458d639029Lang Hames /// hasPredecessor - Return true if N is a predecessor of this node. 566944520f38c79f3cbf1abfca92a5414458d639029Lang Hames /// N is either an operand of this node, or can be reached by recursively 567944520f38c79f3cbf1abfca92a5414458d639029Lang Hames /// traversing up the operands. 568944520f38c79f3cbf1abfca92a5414458d639029Lang Hames /// NOTE: This is an expensive method. Use it carefully. 569944520f38c79f3cbf1abfca92a5414458d639029Lang Hames bool hasPredecessor(const SDNode *N) const; 570944520f38c79f3cbf1abfca92a5414458d639029Lang Hames 571944520f38c79f3cbf1abfca92a5414458d639029Lang Hames /// hasPredecesorHelper - Return true if N is a predecessor of this node. 572944520f38c79f3cbf1abfca92a5414458d639029Lang Hames /// N is either an operand of this node, or can be reached by recursively 573917be6814e0a4e529d290be5d806a054bbbc4a27Evan Cheng /// traversing up the operands. 574944520f38c79f3cbf1abfca92a5414458d639029Lang Hames /// In this helper the Visited and worklist sets are held externally to 575944520f38c79f3cbf1abfca92a5414458d639029Lang Hames /// cache predecessors over multiple invocations. If you want to test for 576944520f38c79f3cbf1abfca92a5414458d639029Lang Hames /// multiple predecessors this method is preferable to multiple calls to 577944520f38c79f3cbf1abfca92a5414458d639029Lang Hames /// hasPredecessor. Be sure to clear Visited and Worklist if the DAG 578944520f38c79f3cbf1abfca92a5414458d639029Lang Hames /// changes. 579944520f38c79f3cbf1abfca92a5414458d639029Lang Hames /// NOTE: This is still very expensive. Use carefully. 580944520f38c79f3cbf1abfca92a5414458d639029Lang Hames bool hasPredecessorHelper(const SDNode *N, 581944520f38c79f3cbf1abfca92a5414458d639029Lang Hames SmallPtrSet<const SDNode *, 32> &Visited, 582a0ec3f9b7b826b9b40b80199923b664bad808cceCraig Topper SmallVectorImpl<const SDNode *> &Worklist) const; 5837ceebb437ebb18efefe72d8d2d0e9c762c3aa6b3Evan Cheng 58463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// getNumOperands - Return the number of values used by this operation. 58563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// 586f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner unsigned getNumOperands() const { return NumOperands; } 58763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 588fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel /// getConstantOperandVal - Helper method returns the integer value of a 589c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng /// ConstantSDNode operand. 590c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng uint64_t getConstantOperandVal(unsigned Num) const; 591c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng 592475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue &getOperand(unsigned Num) const { 593f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner assert(Num < NumOperands && "Invalid child # of SDNode!"); 594e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman return OperandList[Num]; 59563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 596c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng 5979cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein typedef SDUse* op_iterator; 598f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner op_iterator op_begin() const { return OperandList; } 599f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner op_iterator op_end() const { return OperandList+NumOperands; } 600cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines ArrayRef<SDUse> ops() const { return makeArrayRef(op_begin(), op_end()); } 60150f5a51f41d36c519de68ff11fbf7c7c76f45416Chris Lattner 6020b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner SDVTList getVTList() const { 6030b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner SDVTList X = { ValueList, NumValues }; 6040b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner return X; 605f8ca42ff59e01126c8bcfc41c3d35c8b73f1e8b3Douglas Gregor } 606d23e0f81bc76902052e9198cad3a0d87a412a632Dan Gohman 60729d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner /// getGluedNode - If this node has a glue operand, return the node 60829d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner /// to which the glue operand points. Otherwise return NULL. 60929d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner SDNode *getGluedNode() const { 610d23e0f81bc76902052e9198cad3a0d87a412a632Dan Gohman if (getNumOperands() != 0 && 611f1b4eafbfec976f939ec0ea3e8acf91cef5363e3Chris Lattner getOperand(getNumOperands()-1).getValueType() == MVT::Glue) 612d23e0f81bc76902052e9198cad3a0d87a412a632Dan Gohman return getOperand(getNumOperands()-1).getNode(); 613dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 614d23e0f81bc76902052e9198cad3a0d87a412a632Dan Gohman } 615fc54c552963545a81e4ea38e60460590afb2d5aeDan Gohman 616fc54c552963545a81e4ea38e60460590afb2d5aeDan Gohman // If this is a pseudo op, like copyfromreg, look to see if there is a 61729d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner // real target node glued to it. If so, return the target node. 61829d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner const SDNode *getGluedMachineNode() const { 619fc54c552963545a81e4ea38e60460590afb2d5aeDan Gohman const SDNode *FoundNode = this; 620fc54c552963545a81e4ea38e60460590afb2d5aeDan Gohman 62129d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner // Climb up glue edges until a machine-opcode node is found, or the 622fc54c552963545a81e4ea38e60460590afb2d5aeDan Gohman // end of the chain is reached. 623fc54c552963545a81e4ea38e60460590afb2d5aeDan Gohman while (!FoundNode->isMachineOpcode()) { 62429d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner const SDNode *N = FoundNode->getGluedNode(); 625fc54c552963545a81e4ea38e60460590afb2d5aeDan Gohman if (!N) break; 626fc54c552963545a81e4ea38e60460590afb2d5aeDan Gohman FoundNode = N; 627fc54c552963545a81e4ea38e60460590afb2d5aeDan Gohman } 628fc54c552963545a81e4ea38e60460590afb2d5aeDan Gohman 629fc54c552963545a81e4ea38e60460590afb2d5aeDan Gohman return FoundNode; 630fc54c552963545a81e4ea38e60460590afb2d5aeDan Gohman } 631fc54c552963545a81e4ea38e60460590afb2d5aeDan Gohman 63229d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner /// getGluedUser - If this node has a glue value with a user, return 633db4971259ce94cea26e555e9ade82672a3581f5cDan Gohman /// the user (there is at most one). Otherwise return NULL. 63429d8f0cae425f1bba583565227eaebf58f26ce73Chris Lattner SDNode *getGluedUser() const { 635db4971259ce94cea26e555e9ade82672a3581f5cDan Gohman for (use_iterator UI = use_begin(), UE = use_end(); UI != UE; ++UI) 636f1b4eafbfec976f939ec0ea3e8acf91cef5363e3Chris Lattner if (UI.getUse().get().getValueType() == MVT::Glue) 637db4971259ce94cea26e555e9ade82672a3581f5cDan Gohman return *UI; 638dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 639db4971259ce94cea26e555e9ade82672a3581f5cDan Gohman } 640db4971259ce94cea26e555e9ade82672a3581f5cDan Gohman 64163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// getNumValues - Return the number of values defined/returned by this 64263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// operator. 64363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// 644f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner unsigned getNumValues() const { return NumValues; } 64563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 64663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// getValueType - Return the type of a specified result. 64763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// 648e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT getValueType(unsigned ResNo) const { 649f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner assert(ResNo < NumValues && "Illegal result number!"); 650f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner return ValueList[ResNo]; 65163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 6529eb59ec548b861d6ede05b4e6dc22aabf645e665Jeff Cohen 653a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund /// Return the type of a specified result as a simple type. 654a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund /// 655a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund MVT getSimpleValueType(unsigned ResNo) const { 656a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund return getValueType(ResNo).getSimpleVT(); 657a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund } 658a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund 659825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson /// getValueSizeInBits - Returns MVT::getSizeInBits(getValueType(ResNo)). 6604fc3d5dac255120e2f0c0b537044fcf56a30fa34Dan Gohman /// 6614fc3d5dac255120e2f0c0b537044fcf56a30fa34Dan Gohman unsigned getValueSizeInBits(unsigned ResNo) const { 66283ec4b6711980242ef3c55a4fa36b2d7a39c1bfbDuncan Sands return getValueType(ResNo).getSizeInBits(); 6634fc3d5dac255120e2f0c0b537044fcf56a30fa34Dan Gohman } 6644fc3d5dac255120e2f0c0b537044fcf56a30fa34Dan Gohman 665e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson typedef const EVT* value_iterator; 666f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner value_iterator value_begin() const { return ValueList; } 667f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner value_iterator value_end() const { return ValueList+NumValues; } 66863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 6696e6e3ceb080e5a8bdfd3258d883a06ebbd8a1965Chris Lattner /// getOperationName - Return the opcode of this operation for printing. 6706e6e3ceb080e5a8bdfd3258d883a06ebbd8a1965Chris Lattner /// 671dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines std::string getOperationName(const SelectionDAG *G = nullptr) const; 672144d8f09e139f691cafadbc17873943ba4c465f3Evan Cheng static const char* getIndexedModeName(ISD::MemIndexedMode AM); 67380d6977e90c22313d5a62ac28811e0386a806affStuart Hastings void print_types(raw_ostream &OS, const SelectionDAG *G) const; 67480d6977e90c22313d5a62ac28811e0386a806affStuart Hastings void print_details(raw_ostream &OS, const SelectionDAG *G) const; 675dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines void print(raw_ostream &OS, const SelectionDAG *G = nullptr) const; 676dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines void printr(raw_ostream &OS, const SelectionDAG *G = nullptr) const; 677ce6715faa37b2e44edcf400084aa808ae30d7085David Greene 678ce6715faa37b2e44edcf400084aa808ae30d7085David Greene /// printrFull - Print a SelectionDAG node and all children down to 679ce6715faa37b2e44edcf400084aa808ae30d7085David Greene /// the leaves. The given SelectionDAG allows target-specific nodes 680ce6715faa37b2e44edcf400084aa808ae30d7085David Greene /// to be printed in human-readable form. Unlike printr, this will 681ce6715faa37b2e44edcf400084aa808ae30d7085David Greene /// print the whole DAG, including children that appear multiple 682ce6715faa37b2e44edcf400084aa808ae30d7085David Greene /// times. 683ac931c011fae9392b5d68e763ec64ee25181c267David Greene /// 684dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines void printrFull(raw_ostream &O, const SelectionDAG *G = nullptr) const; 685ce6715faa37b2e44edcf400084aa808ae30d7085David Greene 686ce6715faa37b2e44edcf400084aa808ae30d7085David Greene /// printrWithDepth - Print a SelectionDAG node and children up to 687ce6715faa37b2e44edcf400084aa808ae30d7085David Greene /// depth "depth." The given SelectionDAG allows target-specific 688ce6715faa37b2e44edcf400084aa808ae30d7085David Greene /// nodes to be printed in human-readable form. Unlike printr, this 689ce6715faa37b2e44edcf400084aa808ae30d7085David Greene /// will print children that appear multiple times wherever they are 690ce6715faa37b2e44edcf400084aa808ae30d7085David Greene /// used. 691ac931c011fae9392b5d68e763ec64ee25181c267David Greene /// 692dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines void printrWithDepth(raw_ostream &O, const SelectionDAG *G = nullptr, 693ce6715faa37b2e44edcf400084aa808ae30d7085David Greene unsigned depth = 100) const; 694ce6715faa37b2e44edcf400084aa808ae30d7085David Greene 695ce6715faa37b2e44edcf400084aa808ae30d7085David Greene 696cb8544fb9e89787f876c37fd1d81ee6c80a10fb5Dan Gohman /// dump - Dump this node, for debugging. 69763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner void dump() const; 698ce6715faa37b2e44edcf400084aa808ae30d7085David Greene 699cb8544fb9e89787f876c37fd1d81ee6c80a10fb5Dan Gohman /// dumpr - Dump (recursively) this node and its use-def subgraph. 70080d6977e90c22313d5a62ac28811e0386a806affStuart Hastings void dumpr() const; 701ce6715faa37b2e44edcf400084aa808ae30d7085David Greene 702cb8544fb9e89787f876c37fd1d81ee6c80a10fb5Dan Gohman /// dump - Dump this node, for debugging. 703cb8544fb9e89787f876c37fd1d81ee6c80a10fb5Dan Gohman /// The given SelectionDAG allows target-specific nodes to be printed 704cb8544fb9e89787f876c37fd1d81ee6c80a10fb5Dan Gohman /// in human-readable form. 705efe58694050e48b61584b8454434dcd1ad886a71Chris Lattner void dump(const SelectionDAG *G) const; 706ce6715faa37b2e44edcf400084aa808ae30d7085David Greene 707cb8544fb9e89787f876c37fd1d81ee6c80a10fb5Dan Gohman /// dumpr - Dump (recursively) this node and its use-def subgraph. 708cb8544fb9e89787f876c37fd1d81ee6c80a10fb5Dan Gohman /// The given SelectionDAG allows target-specific nodes to be printed 709cb8544fb9e89787f876c37fd1d81ee6c80a10fb5Dan Gohman /// in human-readable form. 7108fc13cb4f7a2997f993ffdfe6e488046ec6c834eDan Gohman void dumpr(const SelectionDAG *G) const; 711ce6715faa37b2e44edcf400084aa808ae30d7085David Greene 712ce6715faa37b2e44edcf400084aa808ae30d7085David Greene /// dumprFull - printrFull to dbgs(). The given SelectionDAG allows 713ce6715faa37b2e44edcf400084aa808ae30d7085David Greene /// target-specific nodes to be printed in human-readable form. 714ce6715faa37b2e44edcf400084aa808ae30d7085David Greene /// Unlike dumpr, this will print the whole DAG, including children 715ce6715faa37b2e44edcf400084aa808ae30d7085David Greene /// that appear multiple times. 716ac931c011fae9392b5d68e763ec64ee25181c267David Greene /// 717dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines void dumprFull(const SelectionDAG *G = nullptr) const; 718ce6715faa37b2e44edcf400084aa808ae30d7085David Greene 719ce6715faa37b2e44edcf400084aa808ae30d7085David Greene /// dumprWithDepth - printrWithDepth to dbgs(). The given 720ce6715faa37b2e44edcf400084aa808ae30d7085David Greene /// SelectionDAG allows target-specific nodes to be printed in 721ce6715faa37b2e44edcf400084aa808ae30d7085David Greene /// human-readable form. Unlike dumpr, this will print children 722ce6715faa37b2e44edcf400084aa808ae30d7085David Greene /// that appear multiple times wherever they are used. 723ac931c011fae9392b5d68e763ec64ee25181c267David Greene /// 724dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines void dumprWithDepth(const SelectionDAG *G = nullptr, 725dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines unsigned depth = 100) const; 726ce6715faa37b2e44edcf400084aa808ae30d7085David Greene 727583bd47f777fe3eb8305872fa0eadab31e833dffJim Laskey /// Profile - Gather unique data for the node. 728583bd47f777fe3eb8305872fa0eadab31e833dffJim Laskey /// 729b8d2f550b84523e8a73198f98e5d450ec3b4fee7Dan Gohman void Profile(FoldingSetNodeID &ID) const; 730583bd47f777fe3eb8305872fa0eadab31e833dffJim Laskey 731e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// addUse - This method should only be used by the SDUse class. 732109654fae9c5b8b96bd3a829824cdbceb27ced06Chris Lattner /// 733e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman void addUse(SDUse &U) { U.addToList(&UseList); } 734e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman 735e7852d014432a06c783de3c350eb96e686f10f92Dan Gohmanprotected: 736e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson static SDVTList getSDVTList(EVT VT) { 73763e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner SDVTList Ret = { getValueTypeList(VT), 1 }; 73863e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner return Ret; 7392d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth } 74063e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner 741ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDNode(unsigned Opc, unsigned Order, const DebugLoc dl, SDVTList VTs, 742dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ArrayRef<SDValue> Ops) 74306a26637daff1bb785ef0945d1ba05f6ccdfab86Dale Johannesen : NodeType(Opc), OperandsNeedDelete(true), HasDebugValue(false), 74406a26637daff1bb785ef0945d1ba05f6ccdfab86Dale Johannesen SubclassData(0), NodeId(-1), 745dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines OperandList(Ops.size() ? new SDUse[Ops.size()] : nullptr), 746dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ValueList(VTs.VTs), UseList(nullptr), 747dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines NumOperands(Ops.size()), NumValues(VTs.NumVTs), 748ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick debugLoc(dl), IROrder(Order) { 749dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (unsigned i = 0; i != Ops.size(); ++i) { 7503b1a9c5bceb40a5cf0aecdaf7a389c72a855b52aDale Johannesen OperandList[i].setUser(this); 7513b1a9c5bceb40a5cf0aecdaf7a389c72a855b52aDale Johannesen OperandList[i].setInitial(Ops[i]); 7523b1a9c5bceb40a5cf0aecdaf7a389c72a855b52aDale Johannesen } 753cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene checkForCycles(this); 7543b1a9c5bceb40a5cf0aecdaf7a389c72a855b52aDale Johannesen } 7553b1a9c5bceb40a5cf0aecdaf7a389c72a855b52aDale Johannesen 7563b1a9c5bceb40a5cf0aecdaf7a389c72a855b52aDale Johannesen /// This constructor adds no operands itself; operands can be 7573b1a9c5bceb40a5cf0aecdaf7a389c72a855b52aDale Johannesen /// set later with InitOperands. 758ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDNode(unsigned Opc, unsigned Order, const DebugLoc dl, SDVTList VTs) 759ae47e461eb0c5501ff985f7af19e1cff554f3af6Dale Johannesen : NodeType(Opc), OperandsNeedDelete(false), HasDebugValue(false), 760dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SubclassData(0), NodeId(-1), OperandList(nullptr), ValueList(VTs.VTs), 761dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines UseList(nullptr), NumOperands(0), NumValues(VTs.NumVTs), debugLoc(dl), 762dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines IROrder(Order) {} 763fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 764e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// InitOperands - Initialize the operands list of this with 1 operand. 765e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman void InitOperands(SDUse *Ops, const SDValue &Op0) { 766e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[0].setUser(this); 767e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[0].setInitial(Op0); 768e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman NumOperands = 1; 769bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner OperandList = Ops; 770cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene checkForCycles(this); 771e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman } 772e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman 773e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// InitOperands - Initialize the operands list of this with 2 operands. 774e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman void InitOperands(SDUse *Ops, const SDValue &Op0, const SDValue &Op1) { 775e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[0].setUser(this); 776e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[0].setInitial(Op0); 777e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[1].setUser(this); 778e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[1].setInitial(Op1); 779e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman NumOperands = 2; 780e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman OperandList = Ops; 781cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene checkForCycles(this); 782e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman } 783e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman 784e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// InitOperands - Initialize the operands list of this with 3 operands. 785e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman void InitOperands(SDUse *Ops, const SDValue &Op0, const SDValue &Op1, 786e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman const SDValue &Op2) { 787e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[0].setUser(this); 788e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[0].setInitial(Op0); 789e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[1].setUser(this); 790e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[1].setInitial(Op1); 791e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[2].setUser(this); 792e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[2].setInitial(Op2); 793e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman NumOperands = 3; 794e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman OperandList = Ops; 795cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene checkForCycles(this); 796e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman } 797e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman 798e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// InitOperands - Initialize the operands list of this with 4 operands. 799e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman void InitOperands(SDUse *Ops, const SDValue &Op0, const SDValue &Op1, 800e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman const SDValue &Op2, const SDValue &Op3) { 801e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[0].setUser(this); 802e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[0].setInitial(Op0); 803e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[1].setUser(this); 804e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[1].setInitial(Op1); 805e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[2].setUser(this); 806e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[2].setInitial(Op2); 807e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[3].setUser(this); 808e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[3].setInitial(Op3); 809e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman NumOperands = 4; 810e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman OperandList = Ops; 811cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene checkForCycles(this); 812e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman } 813e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman 814e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman /// InitOperands - Initialize the operands list of this with N operands. 815e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman void InitOperands(SDUse *Ops, const SDValue *Vals, unsigned N) { 816e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman for (unsigned i = 0; i != N; ++i) { 817e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[i].setUser(this); 818e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Ops[i].setInitial(Vals[i]); 819dc1adac582fa120861f18ae7221bfe1421fea59fRoman Levenstein } 820e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman NumOperands = N; 821e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman OperandList = Ops; 822cf495bc2e505e52ad018da55bed11c7b8bc97db5David Greene checkForCycles(this); 823bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner } 8240fe9c6e7babb3c0731d9cb864ec498ec4184760fDan Gohman 8250fe9c6e7babb3c0731d9cb864ec498ec4184760fDan Gohman /// DropOperands - Release the operands and set this node to have 826e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman /// zero operands. 8270fe9c6e7babb3c0731d9cb864ec498ec4184760fDan Gohman void DropOperands(); 82863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 82963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 830ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick/// Wrapper class for IR location info (IR ordering and DebugLoc) to be passed 831ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick/// into SDNode creation functions. 832ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick/// When an SDNode is created from the DAGBuilder, the DebugLoc is extracted 833ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick/// from the original Instruction, and IROrder is the ordinal position of 834ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick/// the instruction. 835ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick/// When an SDNode is created after the DAG is being built, both DebugLoc and 836ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick/// the IROrder are propagated from the original SDNode. 837ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick/// So SDLoc class provides two constructors besides the default one, one to 838ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick/// be used by the DAGBuilder, the other to be used by others. 839ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trickclass SDLoc { 840ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trickprivate: 841ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick // Ptr could be used for either Instruction* or SDNode*. It is used for 842ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick // Instruction* if IROrder is not -1. 843ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick const void *Ptr; 844ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick int IROrder; 845ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick 846ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trickpublic: 847dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SDLoc() : Ptr(nullptr), IROrder(0) {} 848ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick SDLoc(const SDNode *N) : Ptr(N), IROrder(-1) { 849ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick assert(N && "null SDNode"); 850ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick } 851ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick SDLoc(const SDValue V) : Ptr(V.getNode()), IROrder(-1) { 852ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick assert(Ptr && "null SDNode"); 853ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick } 854ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick SDLoc(const Instruction *I, int Order) : Ptr(I), IROrder(Order) { 855ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick assert(Order >= 0 && "bad IROrder"); 856ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick } 857ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick unsigned getIROrder() { 858dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (IROrder >= 0 || Ptr == nullptr) { 859ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick return (unsigned)IROrder; 860ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick } 861ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick const SDNode *N = (const SDNode*)(Ptr); 862ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick return N->getIROrder(); 863ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick } 864ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick DebugLoc getDebugLoc() { 865dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!Ptr) { 866ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick return DebugLoc(); 867ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick } 868ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick if (IROrder >= 0) { 869ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick const Instruction *I = (const Instruction*)(Ptr); 870ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick return I->getDebugLoc(); 871ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick } 872ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick const SDNode *N = (const SDNode*)(Ptr); 873ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick return N->getDebugLoc(); 874ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick } 875ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick}; 876ea5db0c315f1ab8ee3be52e0e765c32d3efff024Andrew Trick 87763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 878475871a144eb604ddaf37503397ba0941442e5fbDan Gohman// Define inline functions from the SDValue class. 87963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 880475871a144eb604ddaf37503397ba0941442e5fbDan Gohmaninline unsigned SDValue::getOpcode() const { 881ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return Node->getOpcode(); 88263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner} 883e50ed30282bb5b4a9ed952580523f2dda16215acOwen Andersoninline EVT SDValue::getValueType() const { 884ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return Node->getValueType(ResNo); 88563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner} 886475871a144eb604ddaf37503397ba0941442e5fbDan Gohmaninline unsigned SDValue::getNumOperands() const { 887ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return Node->getNumOperands(); 88863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner} 889475871a144eb604ddaf37503397ba0941442e5fbDan Gohmaninline const SDValue &SDValue::getOperand(unsigned i) const { 890ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return Node->getOperand(i); 89163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner} 892475871a144eb604ddaf37503397ba0941442e5fbDan Gohmaninline uint64_t SDValue::getConstantOperandVal(unsigned i) const { 893ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return Node->getConstantOperandVal(i); 894c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng} 895475871a144eb604ddaf37503397ba0941442e5fbDan Gohmaninline bool SDValue::isTargetOpcode() const { 896ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return Node->isTargetOpcode(); 8970f66a9172175aa7c3055333358170581c999219bNate Begeman} 898c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohmaninline bool SDValue::isTargetMemoryOpcode() const { 899c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman return Node->isTargetMemoryOpcode(); 900c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman} 901475871a144eb604ddaf37503397ba0941442e5fbDan Gohmaninline bool SDValue::isMachineOpcode() const { 902ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return Node->isMachineOpcode(); 903e8be6c63915e0389f1eef6b53c64300d13b2ce99Dan Gohman} 904475871a144eb604ddaf37503397ba0941442e5fbDan Gohmaninline unsigned SDValue::getMachineOpcode() const { 905ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return Node->getMachineOpcode(); 9060f66a9172175aa7c3055333358170581c999219bNate Begeman} 907475871a144eb604ddaf37503397ba0941442e5fbDan Gohmaninline bool SDValue::use_empty() const { 908ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return !Node->hasAnyUseOfValue(ResNo); 909e1b50639a860934685dff840e1826b16dbe6a344Dan Gohman} 910475871a144eb604ddaf37503397ba0941442e5fbDan Gohmaninline bool SDValue::hasOneUse() const { 911ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return Node->hasNUsesOfValue(1, ResNo); 9127a24cdc4ed5c357e9de4e36a39379e0aa67f6f9cDan Gohman} 913124c7fdd69bd0eebdec8aab7caa2f8779a56d878Dale Johanneseninline const DebugLoc SDValue::getDebugLoc() const { 9143b1a9c5bceb40a5cf0aecdaf7a389c72a855b52aDale Johannesen return Node->getDebugLoc(); 9153b1a9c5bceb40a5cf0aecdaf7a389c72a855b52aDale Johannesen} 91652b7ec68d221d65aacbe9b55de325c9b7370b59dNadav Roteminline void SDValue::dump() const { 91752b7ec68d221d65aacbe9b55de325c9b7370b59dNadav Rotem return Node->dump(); 91852b7ec68d221d65aacbe9b55de325c9b7370b59dNadav Rotem} 91952b7ec68d221d65aacbe9b55de325c9b7370b59dNadav Roteminline void SDValue::dumpr() const { 92052b7ec68d221d65aacbe9b55de325c9b7370b59dNadav Rotem return Node->dumpr(); 92152b7ec68d221d65aacbe9b55de325c9b7370b59dNadav Rotem} 922e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman// Define inline functions from the SDUse class. 923e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman 924e7852d014432a06c783de3c350eb96e686f10f92Dan Gohmaninline void SDUse::set(const SDValue &V) { 925e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman if (Val.getNode()) removeFromList(); 926e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Val = V; 927e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman if (V.getNode()) V.getNode()->addUse(*this); 928e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman} 929e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman 930e7852d014432a06c783de3c350eb96e686f10f92Dan Gohmaninline void SDUse::setInitial(const SDValue &V) { 931e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Val = V; 932e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman V.getNode()->addUse(*this); 933e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman} 934e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman 935e7852d014432a06c783de3c350eb96e686f10f92Dan Gohmaninline void SDUse::setNode(SDNode *N) { 936e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman if (Val.getNode()) removeFromList(); 937e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman Val.setNode(N); 938e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman if (N) N->addUse(*this); 939e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman} 940e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman 9413f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner/// UnarySDNode - This class is used for single-operand SDNodes. This is solely 9423f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner/// to allow co-allocation of node operands with the node itself. 9433f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattnerclass UnarySDNode : public SDNode { 9449cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein SDUse Op; 9453f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattnerpublic: 9463af4d250676623b88436b89212108eb4fff897d3Jack Carter UnarySDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs, 9473af4d250676623b88436b89212108eb4fff897d3Jack Carter SDValue X) 948ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick : SDNode(Opc, Order, dl, VTs) { 9493edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen InitOperands(&Op, X); 9503edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen } 9513f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner}; 9523f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner 9533f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner/// BinarySDNode - This class is used for two-operand SDNodes. This is solely 9543f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner/// to allow co-allocation of node operands with the node itself. 9553f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattnerclass BinarySDNode : public SDNode { 9569cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein SDUse Ops[2]; 9573f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattnerpublic: 9583af4d250676623b88436b89212108eb4fff897d3Jack Carter BinarySDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs, 9593af4d250676623b88436b89212108eb4fff897d3Jack Carter SDValue X, SDValue Y) 960ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick : SDNode(Opc, Order, dl, VTs) { 9613edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen InitOperands(Ops, X, Y); 9623edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen } 9633f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner}; 9643f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner 965cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines/// BinaryWithFlagsSDNode - This class is an extension of BinarySDNode 966cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines/// used from those opcodes that have associated extra flags. 967cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hinesclass BinaryWithFlagsSDNode : public BinarySDNode { 968cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines enum { NUW = (1 << 0), NSW = (1 << 1), EXACT = (1 << 2) }; 969cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 970cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hinespublic: 971cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines BinaryWithFlagsSDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs, 972cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue X, SDValue Y) 973cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines : BinarySDNode(Opc, Order, dl, VTs, X, Y) {} 974cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// getRawSubclassData - Return the SubclassData value, which contains an 975cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// encoding of the flags. 976cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// This function should be used to add subclass data to the NodeID value. 977cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines unsigned getRawSubclassData() const { return SubclassData; } 978cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines void setHasNoUnsignedWrap(bool b) { 979cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SubclassData = (SubclassData & ~NUW) | (b ? NUW : 0); 980cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines } 981cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines void setHasNoSignedWrap(bool b) { 982cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SubclassData = (SubclassData & ~NSW) | (b ? NSW : 0); 983cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines } 984cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines void setIsExact(bool b) { 985cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SubclassData = (SubclassData & ~EXACT) | (b ? EXACT : 0); 986cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines } 987cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines bool hasNoUnsignedWrap() const { return SubclassData & NUW; } 988cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines bool hasNoSignedWrap() const { return SubclassData & NSW; } 989cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines bool isExact() const { return SubclassData & EXACT; } 990cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines static bool classof(const SDNode *N) { 991cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines return isBinOpWithFlags(N->getOpcode()); 992cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines } 993cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines}; 994cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 9953f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner/// TernarySDNode - This class is used for three-operand SDNodes. This is solely 9963f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner/// to allow co-allocation of node operands with the node itself. 9973f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattnerclass TernarySDNode : public SDNode { 9989cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein SDUse Ops[3]; 9993f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattnerpublic: 1000ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick TernarySDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs, 1001ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDValue X, SDValue Y, SDValue Z) 1002ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick : SDNode(Opc, Order, dl, VTs) { 10033edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen InitOperands(Ops, X, Y, Z); 10043edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen } 10053f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner}; 10063f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner 10073f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner 1008d623e953fc5f46b013994dfa4651cff4d17af159Chris Lattner/// HandleSDNode - This class is used to form a handle around another node that 10097a2bdde0a0eebcd2125055e0eacaca040f0b766cChris Lattner/// is persistent and is updated across invocations of replaceAllUsesWith on its 1010d623e953fc5f46b013994dfa4651cff4d17af159Chris Lattner/// operand. This node should be directly created by end-users and not added to 1011d623e953fc5f46b013994dfa4651cff4d17af159Chris Lattner/// the AllNodes list. 1012d623e953fc5f46b013994dfa4651cff4d17af159Chris Lattnerclass HandleSDNode : public SDNode { 10139cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein SDUse Op; 1014d623e953fc5f46b013994dfa4651cff4d17af159Chris Lattnerpublic: 1015475871a144eb604ddaf37503397ba0941442e5fbDan Gohman explicit HandleSDNode(SDValue X) 1016ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick : SDNode(ISD::HANDLENODE, 0, DebugLoc(), getSDVTList(MVT::Other)) { 1017e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman InitOperands(&Op, X); 1018bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner } 1019fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel ~HandleSDNode(); 1020e7852d014432a06c783de3c350eb96e686f10f92Dan Gohman const SDValue &getValue() const { return Op; } 1021d623e953fc5f46b013994dfa4651cff4d17af159Chris Lattner}; 1022d623e953fc5f46b013994dfa4651cff4d17af159Chris Lattner 102359d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenaultclass AddrSpaceCastSDNode : public UnarySDNode { 102459d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenaultprivate: 102559d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault unsigned SrcAddrSpace; 102659d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault unsigned DestAddrSpace; 102759d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault 102859d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenaultpublic: 102959d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault AddrSpaceCastSDNode(unsigned Order, DebugLoc dl, EVT VT, SDValue X, 103059d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault unsigned SrcAS, unsigned DestAS); 103159d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault 103259d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault unsigned getSrcAddressSpace() const { return SrcAddrSpace; } 103359d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault unsigned getDestAddressSpace() const { return DestAddrSpace; } 103459d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault 103559d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault static bool classof(const SDNode *N) { 103659d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault return N->getOpcode() == ISD::ADDRSPACECAST; 103759d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault } 103859d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault}; 103959d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault 104028873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang/// Abstact virtual class for operations for memory operations 104128873106309db515d58889a4c4fa3e0a92d1b60eMon P Wangclass MemSDNode : public SDNode { 104228873106309db515d58889a4c4fa3e0a92d1b60eMon P Wangprivate: 10431ea58a52a4296afff10e9db1e54928f38e6d74c6Dan Gohman // MemoryVT - VT of in-memory value. 1044e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT MemoryVT; 10451ea58a52a4296afff10e9db1e54928f38e6d74c6Dan Gohman 1046c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohmanprotected: 1047c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// MMO - Memory reference information. 1048c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman MachineMemOperand *MMO; 104928873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang 105028873106309db515d58889a4c4fa3e0a92d1b60eMon P Wangpublic: 1051ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MemSDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs, 1052ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick EVT MemoryVT, MachineMemOperand *MMO); 10533edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen 10543af4d250676623b88436b89212108eb4fff897d3Jack Carter MemSDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs, 1055dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ArrayRef<SDValue> Ops, EVT MemoryVT, MachineMemOperand *MMO); 1056c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman 1057c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman bool readMem() const { return MMO->isLoad(); } 1058c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman bool writeMem() const { return MMO->isStore(); } 10593edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen 106028873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang /// Returns alignment and volatility of the memory access 10613af4d250676623b88436b89212108eb4fff897d3Jack Carter unsigned getOriginalAlignment() const { 1062c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman return MMO->getBaseAlignment(); 1063101b25c028706c61c7dd9fb92d0b3c1541cb12b6Nate Begeman } 1064101b25c028706c61c7dd9fb92d0b3c1541cb12b6Nate Begeman unsigned getAlignment() const { 1065c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman return MMO->getAlignment(); 1066101b25c028706c61c7dd9fb92d0b3c1541cb12b6Nate Begeman } 1067d254a7fc0c354d165caee7e085ca0a95face4fa3Dan Gohman 1068a7ce741ff0ab02510833854bfa6a1c8c265faee3Dan Gohman /// getRawSubclassData - Return the SubclassData value, which contains an 1069c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// encoding of the volatile flag, as well as bits used by subclasses. This 1070c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// function should only be used to compute a FoldingSetNodeID value. 1071a7ce741ff0ab02510833854bfa6a1c8c265faee3Dan Gohman unsigned getRawSubclassData() const { 1072a7ce741ff0ab02510833854bfa6a1c8c265faee3Dan Gohman return SubclassData; 1073a7ce741ff0ab02510833854bfa6a1c8c265faee3Dan Gohman } 1074a7ce741ff0ab02510833854bfa6a1c8c265faee3Dan Gohman 10751157f791c967668f0838bb6edb66103c760f1a5bDavid Greene // We access subclass data here so that we can check consistency 10761157f791c967668f0838bb6edb66103c760f1a5bDavid Greene // with MachineMemOperand information. 1077c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman bool isVolatile() const { return (SubclassData >> 5) & 1; } 10781157f791c967668f0838bb6edb66103c760f1a5bDavid Greene bool isNonTemporal() const { return (SubclassData >> 6) & 1; } 1079d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper bool isInvariant() const { return (SubclassData >> 7) & 1; } 1080c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman 108155ba816883842e793cdeb32fcb805c4e011b527fEli Friedman AtomicOrdering getOrdering() const { 1082d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper return AtomicOrdering((SubclassData >> 8) & 15); 108355ba816883842e793cdeb32fcb805c4e011b527fEli Friedman } 108455ba816883842e793cdeb32fcb805c4e011b527fEli Friedman SynchronizationScope getSynchScope() const { 1085d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper return SynchronizationScope((SubclassData >> 12) & 1); 108655ba816883842e793cdeb32fcb805c4e011b527fEli Friedman } 108755ba816883842e793cdeb32fcb805c4e011b527fEli Friedman 1088dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // Returns the offset from the location of the access. 1089c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman int64_t getSrcValueOffset() const { return MMO->getOffset(); } 1090d254a7fc0c354d165caee7e085ca0a95face4fa3Dan Gohman 1091f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman /// Returns the TBAAInfo that describes the dereference. 1092f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman const MDNode *getTBAAInfo() const { return MMO->getTBAAInfo(); } 1093f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman 109495d594cac3737ae1594a391276942a443cac426bRafael Espindola /// Returns the Ranges that describes the dereference. 109595d594cac3737ae1594a391276942a443cac426bRafael Espindola const MDNode *getRanges() const { return MMO->getRanges(); } 109695d594cac3737ae1594a391276942a443cac426bRafael Espindola 10971ea58a52a4296afff10e9db1e54928f38e6d74c6Dan Gohman /// getMemoryVT - Return the type of the in-memory value. 1098e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT getMemoryVT() const { return MemoryVT; } 1099d254a7fc0c354d165caee7e085ca0a95face4fa3Dan Gohman 110028873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang /// getMemOperand - Return a MachineMemOperand object describing the memory 110128873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang /// reference performed by operation. 1102c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman MachineMemOperand *getMemOperand() const { return MMO; } 1103c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman 110440a858f6e71ed8d68779d00c63dad15baded3562Chris Lattner const MachinePointerInfo &getPointerInfo() const { 110540a858f6e71ed8d68779d00c63dad15baded3562Chris Lattner return MMO->getPointerInfo(); 110640a858f6e71ed8d68779d00c63dad15baded3562Chris Lattner } 110763b8ab29c420703dc5ef32e6d76d9e4d8f60f19eMicah Villmow 110863b8ab29c420703dc5ef32e6d76d9e4d8f60f19eMicah Villmow /// getAddressSpace - Return the address space for the associated pointer 110963b8ab29c420703dc5ef32e6d76d9e4d8f60f19eMicah Villmow unsigned getAddressSpace() const { 111063b8ab29c420703dc5ef32e6d76d9e4d8f60f19eMicah Villmow return getPointerInfo().getAddrSpace(); 111163b8ab29c420703dc5ef32e6d76d9e4d8f60f19eMicah Villmow } 111263b8ab29c420703dc5ef32e6d76d9e4d8f60f19eMicah Villmow 1113c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// refineAlignment - Update this MemSDNode's MachineMemOperand information 1114c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// to reflect the alignment of NewMMO, if it has a greater alignment. 1115c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// This must only be used when the new alignment applies to all users of 1116c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// this MachineMemOperand. 1117c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman void refineAlignment(const MachineMemOperand *NewMMO) { 1118c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman MMO->refineAlignment(NewMMO); 1119c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman } 11201ea58a52a4296afff10e9db1e54928f38e6d74c6Dan Gohman 1121475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue &getChain() const { return getOperand(0); } 1122475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue &getBasePtr() const { 11231ea58a52a4296afff10e9db1e54928f38e6d74c6Dan Gohman return getOperand(getOpcode() == ISD::STORE ? 2 : 1); 11241ea58a52a4296afff10e9db1e54928f38e6d74c6Dan Gohman } 112528873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang 112628873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang // Methods to support isa and dyn_cast 112728873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang static bool classof(const SDNode *N) { 1128c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang // For some targets, we lower some target intrinsics to a MemIntrinsicNode 1129c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang // with either an intrinsic or a target opcode. 1130e00a8a2a2e11a37fd1ddf2504bd22d225d0994d0Dale Johannesen return N->getOpcode() == ISD::LOAD || 1131e00a8a2a2e11a37fd1ddf2504bd22d225d0994d0Dale Johannesen N->getOpcode() == ISD::STORE || 11321de4aa904e9672abfc2e755d798c926d324e2d36Dale Johannesen N->getOpcode() == ISD::PREFETCH || 11330b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_CMP_SWAP || 1134cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines N->getOpcode() == ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS || 11350b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_SWAP || 11360b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_ADD || 11370b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_SUB || 11380b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_AND || 11390b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_OR || 11400b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_XOR || 11410b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_NAND || 11420b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_MIN || 11430b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_MAX || 11440b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_UMIN || 11450b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_UMAX || 1146327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman N->getOpcode() == ISD::ATOMIC_LOAD || 1147327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman N->getOpcode() == ISD::ATOMIC_STORE || 1148c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman N->isTargetMemoryOpcode(); 1149d254a7fc0c354d165caee7e085ca0a95face4fa3Dan Gohman } 115028873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang}; 115128873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang 1152c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang/// AtomicSDNode - A SDNode reprenting atomic operations. 1153c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang/// 115428873106309db515d58889a4c4fa3e0a92d1b60eMon P Wangclass AtomicSDNode : public MemSDNode { 11559cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein SDUse Ops[4]; 1156d254a7fc0c354d165caee7e085ca0a95face4fa3Dan Gohman 115736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines /// For cmpxchg instructions, the ordering requirements when a store does not 115836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines /// occur. 115936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines AtomicOrdering FailureOrdering; 116036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 116136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines void InitAtomic(AtomicOrdering SuccessOrdering, 116236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines AtomicOrdering FailureOrdering, 116336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SynchronizationScope SynchScope) { 116455ba816883842e793cdeb32fcb805c4e011b527fEli Friedman // This must match encodeMemSDNodeFlags() in SelectionDAG.cpp. 116536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert((SuccessOrdering & 15) == SuccessOrdering && 116636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines "Ordering may not require more than 4 bits!"); 116736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert((FailureOrdering & 15) == FailureOrdering && 116855ba816883842e793cdeb32fcb805c4e011b527fEli Friedman "Ordering may not require more than 4 bits!"); 116955ba816883842e793cdeb32fcb805c4e011b527fEli Friedman assert((SynchScope & 1) == SynchScope && 117055ba816883842e793cdeb32fcb805c4e011b527fEli Friedman "SynchScope may not require more than 1 bit!"); 117136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SubclassData |= SuccessOrdering << 8; 1172d752e0f7e64585839cb3a458ef52456eaebbea3cPete Cooper SubclassData |= SynchScope << 12; 117336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines this->FailureOrdering = FailureOrdering; 117436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert(getSuccessOrdering() == SuccessOrdering && 117536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines "Ordering encoding error!"); 117636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert(getFailureOrdering() == FailureOrdering && 117736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines "Ordering encoding error!"); 117855ba816883842e793cdeb32fcb805c4e011b527fEli Friedman assert(getSynchScope() == SynchScope && "Synch-scope encoding error!"); 117955ba816883842e793cdeb32fcb805c4e011b527fEli Friedman } 118055ba816883842e793cdeb32fcb805c4e011b527fEli Friedman 1181c53361294957b63a9c1e405256c6f0a81db1685cDan Gohmanpublic: 118228873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang // Opc: opcode for atomic 118328873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang // VTL: value type list 118428873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang // Chain: memory chain for operaand 1185475871a144eb604ddaf37503397ba0941442e5fbDan Gohman // Ptr: address to update as a SDValue 118628873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang // Cmp: compare value 118728873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang // Swp: swap value 118828873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang // SrcVal: address to update as a Value (used for MemOperand) 118928873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang // Align: alignment of memory 11903af4d250676623b88436b89212108eb4fff897d3Jack Carter AtomicSDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTL, 119136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines EVT MemVT, SDValue Chain, SDValue Ptr, SDValue Cmp, SDValue Swp, 119236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MachineMemOperand *MMO, AtomicOrdering Ordering, 119336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SynchronizationScope SynchScope) 119436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines : MemSDNode(Opc, Order, dl, VTL, MemVT, MMO) { 119536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines InitAtomic(Ordering, Ordering, SynchScope); 11963edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen InitOperands(Ops, Chain, Ptr, Cmp, Swp); 11973edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen } 11983af4d250676623b88436b89212108eb4fff897d3Jack Carter AtomicSDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTL, 11993af4d250676623b88436b89212108eb4fff897d3Jack Carter EVT MemVT, 1200d254a7fc0c354d165caee7e085ca0a95face4fa3Dan Gohman SDValue Chain, SDValue Ptr, 120155ba816883842e793cdeb32fcb805c4e011b527fEli Friedman SDValue Val, MachineMemOperand *MMO, 120255ba816883842e793cdeb32fcb805c4e011b527fEli Friedman AtomicOrdering Ordering, SynchronizationScope SynchScope) 1203fd40d514ec7e95fe4a59a7a467c887b026364ff2Benjamin Kramer : MemSDNode(Opc, Order, dl, VTL, MemVT, MMO) { 120436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines InitAtomic(Ordering, Ordering, SynchScope); 12053edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen InitOperands(Ops, Chain, Ptr, Val); 12063edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen } 12073af4d250676623b88436b89212108eb4fff897d3Jack Carter AtomicSDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTL, 12083af4d250676623b88436b89212108eb4fff897d3Jack Carter EVT MemVT, 1209327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman SDValue Chain, SDValue Ptr, 1210327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman MachineMemOperand *MMO, 1211327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman AtomicOrdering Ordering, SynchronizationScope SynchScope) 1212fd40d514ec7e95fe4a59a7a467c887b026364ff2Benjamin Kramer : MemSDNode(Opc, Order, dl, VTL, MemVT, MMO) { 121336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines InitAtomic(Ordering, Ordering, SynchScope); 1214327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman InitOperands(Ops, Chain, Ptr); 1215327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman } 1216268c743a3ba44ada364938bc5ff9b1be219df54fAmara Emerson AtomicSDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTL, EVT MemVT, 1217dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const SDValue* AllOps, SDUse *DynOps, unsigned NumOps, 1218268c743a3ba44ada364938bc5ff9b1be219df54fAmara Emerson MachineMemOperand *MMO, 121936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines AtomicOrdering SuccessOrdering, AtomicOrdering FailureOrdering, 122036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SynchronizationScope SynchScope) 1221268c743a3ba44ada364938bc5ff9b1be219df54fAmara Emerson : MemSDNode(Opc, Order, dl, VTL, MemVT, MMO) { 122236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines InitAtomic(SuccessOrdering, FailureOrdering, SynchScope); 1223fd40d514ec7e95fe4a59a7a467c887b026364ff2Benjamin Kramer assert((DynOps || NumOps <= array_lengthof(Ops)) && 1224fd40d514ec7e95fe4a59a7a467c887b026364ff2Benjamin Kramer "Too many ops for internal storage!"); 1225fd40d514ec7e95fe4a59a7a467c887b026364ff2Benjamin Kramer InitOperands(DynOps ? DynOps : Ops, AllOps, NumOps); 1226268c743a3ba44ada364938bc5ff9b1be219df54fAmara Emerson } 1227d254a7fc0c354d165caee7e085ca0a95face4fa3Dan Gohman 1228475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue &getBasePtr() const { return getOperand(1); } 1229475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue &getVal() const { return getOperand(2); } 123028873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang 123136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines AtomicOrdering getSuccessOrdering() const { 123236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return getOrdering(); 123336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 123436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 123536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Not quite enough room in SubclassData for everything, so failure gets its 123636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // own field. 123736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines AtomicOrdering getFailureOrdering() const { 123836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return FailureOrdering; 123936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 124036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 1241d254a7fc0c354d165caee7e085ca0a95face4fa3Dan Gohman bool isCompareAndSwap() const { 1242d254a7fc0c354d165caee7e085ca0a95face4fa3Dan Gohman unsigned Op = getOpcode(); 1243cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines return Op == ISD::ATOMIC_CMP_SWAP || Op == ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS; 1244e00a8a2a2e11a37fd1ddf2504bd22d225d0994d0Dale Johannesen } 124528873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang 124628873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang // Methods to support isa and dyn_cast 124728873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang static bool classof(const SDNode *N) { 12480b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman return N->getOpcode() == ISD::ATOMIC_CMP_SWAP || 1249cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines N->getOpcode() == ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS || 12500b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_SWAP || 12510b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_ADD || 12520b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_SUB || 12530b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_AND || 12540b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_OR || 12550b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_XOR || 12560b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_NAND || 12570b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_MIN || 12580b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_MAX || 12590b1d4a798d1dd2f39521b6b381cd1c1911c9ab52Dan Gohman N->getOpcode() == ISD::ATOMIC_LOAD_UMIN || 1260327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman N->getOpcode() == ISD::ATOMIC_LOAD_UMAX || 1261327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman N->getOpcode() == ISD::ATOMIC_LOAD || 1262327236cd6c211e54fc6288b0ac2b413901cc0611Eli Friedman N->getOpcode() == ISD::ATOMIC_STORE; 126328873106309db515d58889a4c4fa3e0a92d1b60eMon P Wang } 1264ab0b949e0e9de452f3b052b11634ab761e008b23Andrew Lenharth}; 1265ab0b949e0e9de452f3b052b11634ab761e008b23Andrew Lenharth 1266c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman/// MemIntrinsicSDNode - This SDNode is used for target intrinsics that touch 1267c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman/// memory and need an associated MachineMemOperand. Its opcode may be 12681de4aa904e9672abfc2e755d798c926d324e2d36Dale Johannesen/// INTRINSIC_VOID, INTRINSIC_W_CHAIN, PREFETCH, or a target-specific opcode 12691de4aa904e9672abfc2e755d798c926d324e2d36Dale Johannesen/// with a value not less than FIRST_TARGET_MEMORY_OPCODE. 1270c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wangclass MemIntrinsicSDNode : public MemSDNode { 12713dbc4e350216e197e3014452400f43899f7ad620Dan Gohmanpublic: 1272ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MemIntrinsicSDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs, 1273dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ArrayRef<SDValue> Ops, EVT MemoryVT, 1274dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MachineMemOperand *MMO) 1275dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines : MemSDNode(Opc, Order, dl, VTs, Ops, MemoryVT, MMO) { 12763edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen } 1277c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang 1278c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang // Methods to support isa and dyn_cast 1279c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang static bool classof(const SDNode *N) { 1280c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang // We lower some target intrinsics to their target opcode 1281c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang // early a node with a target opcode can be of this class 1282c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang return N->getOpcode() == ISD::INTRINSIC_W_CHAIN || 1283c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang N->getOpcode() == ISD::INTRINSIC_VOID || 12841de4aa904e9672abfc2e755d798c926d324e2d36Dale Johannesen N->getOpcode() == ISD::PREFETCH || 1285c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman N->isTargetMemoryOpcode(); 1286c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang } 1287c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang}; 1288c4d1021ead43cfa7da08a8f7ddc9a059a8ba14c5Mon P Wang 12895a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman/// ShuffleVectorSDNode - This SDNode is used to implement the code generator 12905a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman/// support for the llvm IR shufflevector instruction. It combines elements 12915a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman/// from two input vectors into a new input vector, with the selection and 12925a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman/// ordering of elements determined by an array of integers, referred to as 12935a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman/// the shuffle mask. For input vectors of width N, mask indices of 0..N-1 12945a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman/// refer to elements from the LHS input, and indices from N to 2N-1 the RHS. 12955a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman/// An index of -1 is treated as undef, such that the code generator may put 12965a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman/// any value in the corresponding element of the result. 12979008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begemanclass ShuffleVectorSDNode : public SDNode { 12989008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman SDUse Ops[2]; 12995a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman 13005a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman // The memory for Mask is owned by the SelectionDAG's OperandAllocator, and 13015a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman // is freed when the SelectionDAG object is destroyed. 13025a5ca1519e04310f585197c20e7ae584b7f2d11fNate Begeman const int *Mask; 13039008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begemanprotected: 13049008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman friend class SelectionDAG; 13052c136f8120de04efbd4ef7f8f3a049a573a26432Craig Topper ShuffleVectorSDNode(EVT VT, unsigned Order, DebugLoc dl, SDValue N1, 13062c136f8120de04efbd4ef7f8f3a049a573a26432Craig Topper SDValue N2, const int *M) 1307ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick : SDNode(ISD::VECTOR_SHUFFLE, Order, dl, getSDVTList(VT)), Mask(M) { 13089008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman InitOperands(Ops, N1, N2); 13099008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman } 13109008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begemanpublic: 13119008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman 1312ed4c8c633c52a40ad1a3e8687f290be4aeb1f0e8Benjamin Kramer ArrayRef<int> getMask() const { 1313e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = getValueType(0); 1314ed4c8c633c52a40ad1a3e8687f290be4aeb1f0e8Benjamin Kramer return makeArrayRef(Mask, VT.getVectorNumElements()); 13159008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman } 13169008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman int getMaskElt(unsigned Idx) const { 13179008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman assert(Idx < getValueType(0).getVectorNumElements() && "Idx out of range!"); 13189008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman return Mask[Idx]; 13199008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman } 13202c136f8120de04efbd4ef7f8f3a049a573a26432Craig Topper 13219008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman bool isSplat() const { return isSplatMask(Mask, getValueType(0)); } 13222c136f8120de04efbd4ef7f8f3a049a573a26432Craig Topper int getSplatIndex() const { 13239008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman assert(isSplat() && "Cannot get splat index for non-splat!"); 13241c40e188c579c49f811eee499af2f371298c758cMon P Wang EVT VT = getValueType(0); 13251c40e188c579c49f811eee499af2f371298c758cMon P Wang for (unsigned i = 0, e = VT.getVectorNumElements(); i != e; ++i) { 13266e95b4c6cee371f3bdfd9ee8a73c4fa9e7dd1a3dCraig Topper if (Mask[i] >= 0) 13271c40e188c579c49f811eee499af2f371298c758cMon P Wang return Mask[i]; 13281c40e188c579c49f811eee499af2f371298c758cMon P Wang } 1329741373f6ab69ae9ad7bd309aac487ad504333ef3Craig Topper llvm_unreachable("Splat with all undef indices?"); 13309008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman } 1331e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson static bool isSplatMask(const int *Mask, EVT VT); 13329008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman 13339008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman static bool classof(const SDNode *N) { 13349008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman return N->getOpcode() == ISD::VECTOR_SHUFFLE; 13359008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman } 13369008ca6b6b4f638cfafccb593cbc5b1d3f5ab877Nate Begeman}; 13372c136f8120de04efbd4ef7f8f3a049a573a26432Craig Topper 133863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass ConstantSDNode : public SDNode { 13394fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman const ConstantInt *Value; 134063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 134136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ConstantSDNode(bool isTarget, bool isOpaque, const ConstantInt *val, EVT VT) 1342fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel : SDNode(isTarget ? ISD::TargetConstant : ISD::Constant, 1343ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick 0, DebugLoc(), getSDVTList(VT)), Value(val) { 134436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SubclassData |= (uint16_t)isOpaque; 134563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 134663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 134763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 13484fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman const ConstantInt *getConstantIntValue() const { return Value; } 13494fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman const APInt &getAPIntValue() const { return Value->getValue(); } 13504fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman uint64_t getZExtValue() const { return Value->getZExtValue(); } 13517810bfed5570c192e0714a8fd0e5130a0c38dd2eDan Gohman int64_t getSExtValue() const { return Value->getSExtValue(); } 135263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 1353e368b460a206fafa0d31d5d059b1779b94f7df8cDan Gohman bool isOne() const { return Value->isOne(); } 13544fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman bool isNullValue() const { return Value->isNullValue(); } 13554fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman bool isAllOnesValue() const { return Value->isAllOnesValue(); } 135663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 135736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool isOpaque() const { return SubclassData & 1; } 135836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 135963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *N) { 1360056f9f61d071c6c583951678f2bf543a1316efccChris Lattner return N->getOpcode() == ISD::Constant || 1361056f9f61d071c6c583951678f2bf543a1316efccChris Lattner N->getOpcode() == ISD::TargetConstant; 136263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 136363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 136463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 136563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass ConstantFPSDNode : public SDNode { 13664fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman const ConstantFP *Value; 136763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 1368e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson ConstantFPSDNode(bool isTarget, const ConstantFP *val, EVT VT) 136987503a63d5756f1836f66f4c9723ec0ea30ec3caDale Johannesen : SDNode(isTarget ? ISD::TargetConstantFP : ISD::ConstantFP, 1370ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick 0, DebugLoc(), getSDVTList(VT)), Value(val) { 137163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 137263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 137363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 13744fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman const APFloat& getValueAPF() const { return Value->getValueAPF(); } 13754fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman const ConstantFP *getConstantFPValue() const { return Value; } 137663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 1377e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman /// isZero - Return true if the value is positive or negative zero. 1378e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman bool isZero() const { return Value->isZero(); } 1379e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman 1380e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman /// isNaN - Return true if the value is a NaN. 1381e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman bool isNaN() const { return Value->isNaN(); } 1382e832693acbfc713bcaf44720efa8149e93a38027Dan Gohman 138363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// isExactlyValue - We don't rely on operator== working on double values, as 138463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// it returns true for things that are clearly not equal, like -0.0 and 0.0. 138563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// As such, this method can be used to do an exact bit-for-bit comparison of 138663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// two floating point values. 1387c4dd3c3b519aa2c2ed26ce03a4b1fbb992efeacaDale Johannesen 1388c4dd3c3b519aa2c2ed26ce03a4b1fbb992efeacaDale Johannesen /// We leave the version with the double argument here because it's just so 1389fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel /// convenient to write "2.0" and the like. Without this function we'd 1390c4dd3c3b519aa2c2ed26ce03a4b1fbb992efeacaDale Johannesen /// have to duplicate its logic everywhere it's called. 13919dd2ce46c58dd05f0835df77f308396715890d66Dale Johannesen bool isExactlyValue(double V) const { 139223a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen bool ignored; 139384cd0e7fa30af43c47ad9533d84debb144596e48Chris Lattner APFloat Tmp(V); 13944fbd796a1251a27e6590765a0a34876f436a0af9Dan Gohman Tmp.convert(Value->getValueAPF().getSemantics(), 139523a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen APFloat::rmNearestTiesToEven, &ignored); 139684cd0e7fa30af43c47ad9533d84debb144596e48Chris Lattner return isExactlyValue(Tmp); 139787503a63d5756f1836f66f4c9723ec0ea30ec3caDale Johannesen } 1398e6c1742914149d44360fbf05a653041a672282afDale Johannesen bool isExactlyValue(const APFloat& V) const; 139963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 14007720cb3823d5b5868f9b88b0127277820edcb562Dan Gohman static bool isValueValidForType(EVT VT, const APFloat& Val); 1401f04afdbb48568ef09f11fd10ac03426101f2dbf8Dale Johannesen 140263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *N) { 1403fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel return N->getOpcode() == ISD::ConstantFP || 1404ac0d7238258defe72b1aad53d7f48201b91df795Chris Lattner N->getOpcode() == ISD::TargetConstantFP; 140563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 140663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 140763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 140863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass GlobalAddressSDNode : public SDNode { 140946510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const GlobalValue *TheGlobal; 14106520e20e4fb31f2e65e25c38b372b19d33a83df4Dan Gohman int64_t Offset; 14112a4ed82ce2ba4a02f2a02eb4ed8ce5186f3f93daChris Lattner unsigned char TargetFlags; 141263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 14133af4d250676623b88436b89212108eb4fff897d3Jack Carter GlobalAddressSDNode(unsigned Opc, unsigned Order, DebugLoc DL, 14143af4d250676623b88436b89212108eb4fff897d3Jack Carter const GlobalValue *GA, EVT VT, int64_t o, 14153af4d250676623b88436b89212108eb4fff897d3Jack Carter unsigned char TargetFlags); 141663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 141763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 141846510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const GlobalValue *getGlobal() const { return TheGlobal; } 14196520e20e4fb31f2e65e25c38b372b19d33a83df4Dan Gohman int64_t getOffset() const { return Offset; } 14202a4ed82ce2ba4a02f2a02eb4ed8ce5186f3f93daChris Lattner unsigned char getTargetFlags() const { return TargetFlags; } 1421a3518a1d6a6a9a7519d3a8d434cde51617c1dc22Sanjiv Gupta // Return the address space this GlobalAddress belongs to. 1422a3518a1d6a6a9a7519d3a8d434cde51617c1dc22Sanjiv Gupta unsigned getAddressSpace() const; 142363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 142463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *N) { 1425f6b184981e429ff03742d66cf7111debd9e2bc61Chris Lattner return N->getOpcode() == ISD::GlobalAddress || 1426b3a0417cad8b625acc3033bd5e24afb9ffd0b084Lauro Ramos Venancio N->getOpcode() == ISD::TargetGlobalAddress || 1427b3a0417cad8b625acc3033bd5e24afb9ffd0b084Lauro Ramos Venancio N->getOpcode() == ISD::GlobalTLSAddress || 1428b3a0417cad8b625acc3033bd5e24afb9ffd0b084Lauro Ramos Venancio N->getOpcode() == ISD::TargetGlobalTLSAddress; 142963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 143063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 143163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 143263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass FrameIndexSDNode : public SDNode { 143363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner int FI; 143463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 1435e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson FrameIndexSDNode(int fi, EVT VT, bool isTarg) 1436fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel : SDNode(isTarg ? ISD::TargetFrameIndex : ISD::FrameIndex, 1437ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick 0, DebugLoc(), getSDVTList(VT)), FI(fi) { 143863e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner } 143963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 144063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 144163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner int getIndex() const { return FI; } 144263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 144363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *N) { 1444afb2dd43de61f4585e75d1f3ab93a9ac4b3b7592Chris Lattner return N->getOpcode() == ISD::FrameIndex || 1445afb2dd43de61f4585e75d1f3ab93a9ac4b3b7592Chris Lattner N->getOpcode() == ISD::TargetFrameIndex; 144663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 144763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 144863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 144937efe6764568a3829fee26aba532283131d1a104Nate Begemanclass JumpTableSDNode : public SDNode { 145037efe6764568a3829fee26aba532283131d1a104Nate Begeman int JTI; 1451f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner unsigned char TargetFlags; 145237efe6764568a3829fee26aba532283131d1a104Nate Begeman friend class SelectionDAG; 1453e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson JumpTableSDNode(int jti, EVT VT, bool isTarg, unsigned char TF) 145492570c4a1a11cbdaf5ffb13547428dbee1103875Dale Johannesen : SDNode(isTarg ? ISD::TargetJumpTable : ISD::JumpTable, 1455ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick 0, DebugLoc(), getSDVTList(VT)), JTI(jti), TargetFlags(TF) { 145663e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner } 145737efe6764568a3829fee26aba532283131d1a104Nate Begemanpublic: 1458fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 145959a8cdd36d644fd5d0d7c78c3c02b31f1ba29a95Chris Lattner int getIndex() const { return JTI; } 1460f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner unsigned char getTargetFlags() const { return TargetFlags; } 1461fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 146237efe6764568a3829fee26aba532283131d1a104Nate Begeman static bool classof(const SDNode *N) { 146337efe6764568a3829fee26aba532283131d1a104Nate Begeman return N->getOpcode() == ISD::JumpTable || 146437efe6764568a3829fee26aba532283131d1a104Nate Begeman N->getOpcode() == ISD::TargetJumpTable; 146537efe6764568a3829fee26aba532283131d1a104Nate Begeman } 146637efe6764568a3829fee26aba532283131d1a104Nate Begeman}; 146737efe6764568a3829fee26aba532283131d1a104Nate Begeman 146863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass ConstantPoolSDNode : public SDNode { 1469d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng union { 147046510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const Constant *ConstVal; 1471d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng MachineConstantPoolValue *MachineCPVal; 1472d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng } Val; 1473baf4500b3ab128c78932e36f96086c0487c8c7d1Evan Cheng int Offset; // It's a MachineConstantPoolValue if top bit is set. 14741606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned Alignment; // Minimum alignment requirement of CP (not log2 value). 1475f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner unsigned char TargetFlags; 147663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 147746510a73e977273ec67747eb34cbdb43f815e451Dan Gohman ConstantPoolSDNode(bool isTarget, const Constant *c, EVT VT, int o, 147846510a73e977273ec67747eb34cbdb43f815e451Dan Gohman unsigned Align, unsigned char TF) 14793af4d250676623b88436b89212108eb4fff897d3Jack Carter : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 0, 14803af4d250676623b88436b89212108eb4fff897d3Jack Carter DebugLoc(), getSDVTList(VT)), Offset(o), Alignment(Align), 14813af4d250676623b88436b89212108eb4fff897d3Jack Carter TargetFlags(TF) { 1482d683edc711ec2ff4eb035ad56e07799b7da52b36Jakub Staszak assert(Offset >= 0 && "Offset is too large"); 1483d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng Val.ConstVal = c; 1484d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng } 1485d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v, 1486e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT, int o, unsigned Align, unsigned char TF) 14873af4d250676623b88436b89212108eb4fff897d3Jack Carter : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 0, 14883af4d250676623b88436b89212108eb4fff897d3Jack Carter DebugLoc(), getSDVTList(VT)), Offset(o), Alignment(Align), 14893af4d250676623b88436b89212108eb4fff897d3Jack Carter TargetFlags(TF) { 1490d683edc711ec2ff4eb035ad56e07799b7da52b36Jakub Staszak assert(Offset >= 0 && "Offset is too large"); 1491d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng Val.MachineCPVal = v; 1492de551f91d8816632a76a065084caab9fab6aacffDan Gohman Offset |= 1 << (sizeof(unsigned)*CHAR_BIT-1); 1493d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng } 149463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 149563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 1496d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng bool isMachineConstantPoolEntry() const { 1497d683edc711ec2ff4eb035ad56e07799b7da52b36Jakub Staszak return Offset < 0; 1498d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng } 1499d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng 150046510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const Constant *getConstVal() const { 1501d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng assert(!isMachineConstantPoolEntry() && "Wrong constantpool type"); 1502d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng return Val.ConstVal; 1503d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng } 1504d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng 1505d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng MachineConstantPoolValue *getMachineCPVal() const { 1506d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng assert(isMachineConstantPoolEntry() && "Wrong constantpool type"); 1507d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng return Val.MachineCPVal; 1508d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng } 1509d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng 1510baf4500b3ab128c78932e36f96086c0487c8c7d1Evan Cheng int getOffset() const { 1511de551f91d8816632a76a065084caab9fab6aacffDan Gohman return Offset & ~(1 << (sizeof(unsigned)*CHAR_BIT-1)); 1512baf4500b3ab128c78932e36f96086c0487c8c7d1Evan Cheng } 1513fdc40a0a696c658d550d894ea03772e5f8af2c94Scott Michel 1514ef3640aded552279f65bd6d18633e15ffb245157Chris Lattner // Return the alignment of this constant pool object, which is either 0 (for 15151606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng // default alignment) or the desired value. 1516b8973bd8f50d7321635e1e07b81a880a0828d185Evan Cheng unsigned getAlignment() const { return Alignment; } 1517f5a5546f435a261c93078defb41ed18d9cafd7d3Chris Lattner unsigned char getTargetFlags() const { return TargetFlags; } 151863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 1519db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *getType() const; 1520d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng 152163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *N) { 1522aaaaf79d4aaa172c2f2ae0e327bbae523a045bf5Chris Lattner return N->getOpcode() == ISD::ConstantPool || 1523aaaaf79d4aaa172c2f2ae0e327bbae523a045bf5Chris Lattner N->getOpcode() == ISD::TargetConstantPool; 152463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 152563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 152663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 152774500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen/// Completely target-dependent object reference. 152874500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesenclass TargetIndexSDNode : public SDNode { 152974500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen unsigned char TargetFlags; 153074500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen int Index; 153174500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen int64_t Offset; 153274500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen friend class SelectionDAG; 153374500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesenpublic: 153474500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen 153574500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen TargetIndexSDNode(int Idx, EVT VT, int64_t Ofs, unsigned char TF) 1536ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick : SDNode(ISD::TargetIndex, 0, DebugLoc(), getSDVTList(VT)), 153774500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen TargetFlags(TF), Index(Idx), Offset(Ofs) {} 153874500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesenpublic: 153974500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen 154074500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen unsigned char getTargetFlags() const { return TargetFlags; } 154174500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen int getIndex() const { return Index; } 154274500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen int64_t getOffset() const { return Offset; } 154374500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen 154474500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen static bool classof(const SDNode *N) { 154574500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen return N->getOpcode() == ISD::TargetIndex; 154674500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen } 154774500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen}; 154874500bdba3eae36a1a8a17d8bad0b971b9c212ecJakob Stoklund Olesen 154963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass BasicBlockSDNode : public SDNode { 155063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner MachineBasicBlock *MBB; 155163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 155292570c4a1a11cbdaf5ffb13547428dbee1103875Dale Johannesen /// Debug info is meaningful and potentially useful here, but we create 155392570c4a1a11cbdaf5ffb13547428dbee1103875Dale Johannesen /// blocks out of order when they're jumped to, which makes it a bit 155492570c4a1a11cbdaf5ffb13547428dbee1103875Dale Johannesen /// harder. Let's see if we need it first. 1555423c2260f95883f7c84ac962e58ac66c3a11efacDan Gohman explicit BasicBlockSDNode(MachineBasicBlock *mbb) 15563af4d250676623b88436b89212108eb4fff897d3Jack Carter : SDNode(ISD::BasicBlock, 0, DebugLoc(), getSDVTList(MVT::Other)), MBB(mbb) 15573af4d250676623b88436b89212108eb4fff897d3Jack Carter {} 155863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 155963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 156063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner MachineBasicBlock *getBasicBlock() const { return MBB; } 156163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 156263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *N) { 156363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner return N->getOpcode() == ISD::BasicBlock; 156463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 156563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 156663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 1567a27ea9e89f38e9bcca4d67defb0bae887a16d72cBob Wilson/// BuildVectorSDNode - A "pseudo-class" with methods for operating on 1568a27ea9e89f38e9bcca4d67defb0bae887a16d72cBob Wilson/// BUILD_VECTORs. 1569a27ea9e89f38e9bcca4d67defb0bae887a16d72cBob Wilsonclass BuildVectorSDNode : public SDNode { 15701a6d31aee6acd2b9b715b4f11f09481608f13179Bob Wilson // These are constructed as SDNodes and then cast to BuildVectorSDNodes. 1571001d3dc976d7cda8a3dd8c7fd4020b0b96033f4eCraig Topper explicit BuildVectorSDNode() LLVM_DELETED_FUNCTION; 1572a27ea9e89f38e9bcca4d67defb0bae887a16d72cBob Wilsonpublic: 157324e338e8a3dab2923db30fe63d77a5ac95456ff9Bob Wilson /// isConstantSplat - Check if this is a constant splat, and if so, find the 157424e338e8a3dab2923db30fe63d77a5ac95456ff9Bob Wilson /// smallest element size that splats the vector. If MinSplatBits is 157524e338e8a3dab2923db30fe63d77a5ac95456ff9Bob Wilson /// nonzero, the element size must be at least that large. Note that the 157624e338e8a3dab2923db30fe63d77a5ac95456ff9Bob Wilson /// splat element may be the entire vector (i.e., a one element vector). 157724e338e8a3dab2923db30fe63d77a5ac95456ff9Bob Wilson /// Returns the splat element value in SplatValue. Any undefined bits in 157824e338e8a3dab2923db30fe63d77a5ac95456ff9Bob Wilson /// that value are zero, and the corresponding bits in the SplatUndef mask 157924e338e8a3dab2923db30fe63d77a5ac95456ff9Bob Wilson /// are set. The SplatBitSize value is set to the splat element size in 158024e338e8a3dab2923db30fe63d77a5ac95456ff9Bob Wilson /// bits. HasAnyUndefs is set to true if any bits in the vector are 15811e608819aa26c06b1552521469f2211339e3bfe0Dale Johannesen /// undefined. isBigEndian describes the endianness of the target. 158224e338e8a3dab2923db30fe63d77a5ac95456ff9Bob Wilson bool isConstantSplat(APInt &SplatValue, APInt &SplatUndef, 158324e338e8a3dab2923db30fe63d77a5ac95456ff9Bob Wilson unsigned &SplatBitSize, bool &HasAnyUndefs, 158436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned MinSplatBits = 0, 158536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool isBigEndian = false) const; 158636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 1587cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// \brief Returns the splatted value or a null value if this is not a splat. 1588cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// 1589cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// If passed a non-null UndefElements bitvector, it will resize it to match 1590cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// the vector width and set the bits where elements are undef. 1591cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SDValue getSplatValue(BitVector *UndefElements = nullptr) const; 1592cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 1593cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// \brief Returns the splatted constant or null if this is not a constant 1594cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// splat. 1595cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// 1596cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// If passed a non-null UndefElements bitvector, it will resize it to match 1597cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// the vector width and set the bits where elements are undef. 1598cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines ConstantSDNode * 1599cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines getConstantSplatNode(BitVector *UndefElements = nullptr) const; 1600cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 1601cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// \brief Returns the splatted constant FP or null if this is not a constant 1602cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// FP splat. 1603cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// 1604cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// If passed a non-null UndefElements bitvector, it will resize it to match 1605cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines /// the vector width and set the bits where elements are undef. 1606cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines ConstantFPSDNode * 1607cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines getConstantFPSplatNode(BitVector *UndefElements = nullptr) const; 160836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 160936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool isConstant() const; 1610a27ea9e89f38e9bcca4d67defb0bae887a16d72cBob Wilson 1611a27ea9e89f38e9bcca4d67defb0bae887a16d72cBob Wilson static inline bool classof(const SDNode *N) { 1612a27ea9e89f38e9bcca4d67defb0bae887a16d72cBob Wilson return N->getOpcode() == ISD::BUILD_VECTOR; 1613a27ea9e89f38e9bcca4d67defb0bae887a16d72cBob Wilson } 1614a27ea9e89f38e9bcca4d67defb0bae887a16d72cBob Wilson}; 1615a27ea9e89f38e9bcca4d67defb0bae887a16d72cBob Wilson 161614471be9ab531cb677658704ea73b06d4f0b7585Dan Gohman/// SrcValueSDNode - An SDNode that holds an arbitrary LLVM IR Value. This is 161714471be9ab531cb677658704ea73b06d4f0b7585Dan Gohman/// used when the SelectionDAG needs to make a simple reference to something 161814471be9ab531cb677658704ea73b06d4f0b7585Dan Gohman/// in the LLVM IR representation. 161914471be9ab531cb677658704ea73b06d4f0b7585Dan Gohman/// 16202d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharthclass SrcValueSDNode : public SDNode { 16212d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth const Value *V; 16222d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth friend class SelectionDAG; 162369de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman /// Create a SrcValue for a general value. 162469de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman explicit SrcValueSDNode(const Value *v) 1625ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick : SDNode(ISD::SRCVALUE, 0, DebugLoc(), getSDVTList(MVT::Other)), V(v) {} 16262d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 16272d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharthpublic: 162869de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman /// getValue - return the contained Value. 16292d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth const Value *getValue() const { return V; } 16302d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 16312d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth static bool classof(const SDNode *N) { 16322d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth return N->getOpcode() == ISD::SRCVALUE; 16332d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth } 16342d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth}; 16353af4d250676623b88436b89212108eb4fff897d3Jack Carter 1636decc2671516e6c52ee2f29f7746f8d02753845eaChris Lattnerclass MDNodeSDNode : public SDNode { 1637decc2671516e6c52ee2f29f7746f8d02753845eaChris Lattner const MDNode *MD; 1638decc2671516e6c52ee2f29f7746f8d02753845eaChris Lattner friend class SelectionDAG; 1639decc2671516e6c52ee2f29f7746f8d02753845eaChris Lattner explicit MDNodeSDNode(const MDNode *md) 16403af4d250676623b88436b89212108eb4fff897d3Jack Carter : SDNode(ISD::MDNODE_SDNODE, 0, DebugLoc(), getSDVTList(MVT::Other)), MD(md) 16413af4d250676623b88436b89212108eb4fff897d3Jack Carter {} 1642decc2671516e6c52ee2f29f7746f8d02753845eaChris Lattnerpublic: 16433af4d250676623b88436b89212108eb4fff897d3Jack Carter 1644decc2671516e6c52ee2f29f7746f8d02753845eaChris Lattner const MDNode *getMD() const { return MD; } 16453af4d250676623b88436b89212108eb4fff897d3Jack Carter 1646decc2671516e6c52ee2f29f7746f8d02753845eaChris Lattner static bool classof(const SDNode *N) { 1647decc2671516e6c52ee2f29f7746f8d02753845eaChris Lattner return N->getOpcode() == ISD::MDNODE_SDNODE; 1648decc2671516e6c52ee2f29f7746f8d02753845eaChris Lattner } 1649decc2671516e6c52ee2f29f7746f8d02753845eaChris Lattner}; 16502d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 1651d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattnerclass RegisterSDNode : public SDNode { 165263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner unsigned Reg; 165363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 1654e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson RegisterSDNode(unsigned reg, EVT VT) 1655ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick : SDNode(ISD::Register, 0, DebugLoc(), getSDVTList(VT)), Reg(reg) { 165663e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner } 165763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 165863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 165963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner unsigned getReg() const { return Reg; } 166063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 166163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *N) { 1662d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return N->getOpcode() == ISD::Register; 166363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 166463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 166563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 16669cf37e8b48732fccd4c301ed51aafed7074bd84eJakob Stoklund Olesenclass RegisterMaskSDNode : public SDNode { 16679cf37e8b48732fccd4c301ed51aafed7074bd84eJakob Stoklund Olesen // The memory for RegMask is not owned by the node. 16689cf37e8b48732fccd4c301ed51aafed7074bd84eJakob Stoklund Olesen const uint32_t *RegMask; 16699cf37e8b48732fccd4c301ed51aafed7074bd84eJakob Stoklund Olesen friend class SelectionDAG; 16709cf37e8b48732fccd4c301ed51aafed7074bd84eJakob Stoklund Olesen RegisterMaskSDNode(const uint32_t *mask) 1671ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick : SDNode(ISD::RegisterMask, 0, DebugLoc(), getSDVTList(MVT::Untyped)), 16729cf37e8b48732fccd4c301ed51aafed7074bd84eJakob Stoklund Olesen RegMask(mask) {} 16739cf37e8b48732fccd4c301ed51aafed7074bd84eJakob Stoklund Olesenpublic: 16749cf37e8b48732fccd4c301ed51aafed7074bd84eJakob Stoklund Olesen 16759cf37e8b48732fccd4c301ed51aafed7074bd84eJakob Stoklund Olesen const uint32_t *getRegMask() const { return RegMask; } 16769cf37e8b48732fccd4c301ed51aafed7074bd84eJakob Stoklund Olesen 16779cf37e8b48732fccd4c301ed51aafed7074bd84eJakob Stoklund Olesen static bool classof(const SDNode *N) { 16789cf37e8b48732fccd4c301ed51aafed7074bd84eJakob Stoklund Olesen return N->getOpcode() == ISD::RegisterMask; 16799cf37e8b48732fccd4c301ed51aafed7074bd84eJakob Stoklund Olesen } 16809cf37e8b48732fccd4c301ed51aafed7074bd84eJakob Stoklund Olesen}; 16819cf37e8b48732fccd4c301ed51aafed7074bd84eJakob Stoklund Olesen 16828c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohmanclass BlockAddressSDNode : public SDNode { 168346510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const BlockAddress *BA; 16846c7ccaa3fd1d6e96d0bf922554b09d2b17c3b0e3Michael Liao int64_t Offset; 168529cbade25aa094ca9a149a96a8614cf6f3247480Dan Gohman unsigned char TargetFlags; 16868c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman friend class SelectionDAG; 168746510a73e977273ec67747eb34cbdb43f815e451Dan Gohman BlockAddressSDNode(unsigned NodeTy, EVT VT, const BlockAddress *ba, 16886c7ccaa3fd1d6e96d0bf922554b09d2b17c3b0e3Michael Liao int64_t o, unsigned char Flags) 1689ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick : SDNode(NodeTy, 0, DebugLoc(), getSDVTList(VT)), 16906c7ccaa3fd1d6e96d0bf922554b09d2b17c3b0e3Michael Liao BA(ba), Offset(o), TargetFlags(Flags) { 16918c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman } 16928c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohmanpublic: 169346510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const BlockAddress *getBlockAddress() const { return BA; } 16946c7ccaa3fd1d6e96d0bf922554b09d2b17c3b0e3Michael Liao int64_t getOffset() const { return Offset; } 169529cbade25aa094ca9a149a96a8614cf6f3247480Dan Gohman unsigned char getTargetFlags() const { return TargetFlags; } 16968c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman 16978c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman static bool classof(const SDNode *N) { 16988c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman return N->getOpcode() == ISD::BlockAddress || 16998c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman N->getOpcode() == ISD::TargetBlockAddress; 17008c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman } 17018c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman}; 17028c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman 17037561d480953e0a2faa4af9be0a00b1180097c4bdChris Lattnerclass EHLabelSDNode : public SDNode { 17044406604047423576e36657c7ede266ca42e79642Dan Gohman SDUse Chain; 17057561d480953e0a2faa4af9be0a00b1180097c4bdChris Lattner MCSymbol *Label; 17064406604047423576e36657c7ede266ca42e79642Dan Gohman friend class SelectionDAG; 1707ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick EHLabelSDNode(unsigned Order, DebugLoc dl, SDValue ch, MCSymbol *L) 1708ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick : SDNode(ISD::EH_LABEL, Order, dl, getSDVTList(MVT::Other)), Label(L) { 17093edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen InitOperands(&Chain, ch); 17103edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen } 17114406604047423576e36657c7ede266ca42e79642Dan Gohmanpublic: 17127561d480953e0a2faa4af9be0a00b1180097c4bdChris Lattner MCSymbol *getLabel() const { return Label; } 17134406604047423576e36657c7ede266ca42e79642Dan Gohman 17144406604047423576e36657c7ede266ca42e79642Dan Gohman static bool classof(const SDNode *N) { 1715735afe14eea8049bf69210ce8a3512e391fc643fDan Gohman return N->getOpcode() == ISD::EH_LABEL; 17164406604047423576e36657c7ede266ca42e79642Dan Gohman } 17174406604047423576e36657c7ede266ca42e79642Dan Gohman}; 17184406604047423576e36657c7ede266ca42e79642Dan Gohman 1719056292fd738924f3f7703725d8f630983794b5a5Bill Wendlingclass ExternalSymbolSDNode : public SDNode { 172063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner const char *Symbol; 17211af2231da64a14d638406d133c7912bfc1c8a9ceChris Lattner unsigned char TargetFlags; 17223af4d250676623b88436b89212108eb4fff897d3Jack Carter 172363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 1724e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson ExternalSymbolSDNode(bool isTarget, const char *Sym, unsigned char TF, EVT VT) 1725056292fd738924f3f7703725d8f630983794b5a5Bill Wendling : SDNode(isTarget ? ISD::TargetExternalSymbol : ISD::ExternalSymbol, 1726ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick 0, DebugLoc(), getSDVTList(VT)), Symbol(Sym), TargetFlags(TF) { 17273edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen } 172863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 1729056292fd738924f3f7703725d8f630983794b5a5Bill Wendling 173063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner const char *getSymbol() const { return Symbol; } 17311af2231da64a14d638406d133c7912bfc1c8a9ceChris Lattner unsigned char getTargetFlags() const { return TargetFlags; } 173263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 173363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *N) { 1734056292fd738924f3f7703725d8f630983794b5a5Bill Wendling return N->getOpcode() == ISD::ExternalSymbol || 1735056292fd738924f3f7703725d8f630983794b5a5Bill Wendling N->getOpcode() == ISD::TargetExternalSymbol; 173663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 173763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 173863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 17397cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattnerclass CondCodeSDNode : public SDNode { 174063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner ISD::CondCode Condition; 174163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 1742423c2260f95883f7c84ac962e58ac66c3a11efacDan Gohman explicit CondCodeSDNode(ISD::CondCode Cond) 1743ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick : SDNode(ISD::CONDCODE, 0, DebugLoc(), getSDVTList(MVT::Other)), 1744b494ccf02ce17318d3f2a7b2d674bec60781fc73Chris Lattner Condition(Cond) { 174563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 174663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 174763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 17487cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::CondCode get() const { return Condition; } 174963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 175063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *N) { 17517cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner return N->getOpcode() == ISD::CONDCODE; 175263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 175363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 17543af4d250676623b88436b89212108eb4fff897d3Jack Carter 175577cdf30742284a173fe818417eb482224cdee8d4Mon P Wang/// CvtRndSatSDNode - NOTE: avoid using this node as this may disappear in the 175677cdf30742284a173fe818417eb482224cdee8d4Mon P Wang/// future and most targets don't support it. 175777cdf30742284a173fe818417eb482224cdee8d4Mon P Wangclass CvtRndSatSDNode : public SDNode { 175877cdf30742284a173fe818417eb482224cdee8d4Mon P Wang ISD::CvtCode CvtCode; 175977cdf30742284a173fe818417eb482224cdee8d4Mon P Wang friend class SelectionDAG; 17603af4d250676623b88436b89212108eb4fff897d3Jack Carter explicit CvtRndSatSDNode(EVT VT, unsigned Order, DebugLoc dl, 1761dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ArrayRef<SDValue> Ops, ISD::CvtCode Code) 1762dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines : SDNode(ISD::CONVERT_RNDSAT, Order, dl, getSDVTList(VT), Ops), 1763a04b75710910278334192b389c4c4c62600e162fDale Johannesen CvtCode(Code) { 1764dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines assert(Ops.size() == 5 && "wrong number of operations"); 1765a04b75710910278334192b389c4c4c62600e162fDale Johannesen } 176677cdf30742284a173fe818417eb482224cdee8d4Mon P Wangpublic: 176777cdf30742284a173fe818417eb482224cdee8d4Mon P Wang ISD::CvtCode getCvtCode() const { return CvtCode; } 176877cdf30742284a173fe818417eb482224cdee8d4Mon P Wang 176977cdf30742284a173fe818417eb482224cdee8d4Mon P Wang static bool classof(const SDNode *N) { 177077cdf30742284a173fe818417eb482224cdee8d4Mon P Wang return N->getOpcode() == ISD::CONVERT_RNDSAT; 177177cdf30742284a173fe818417eb482224cdee8d4Mon P Wang } 177277cdf30742284a173fe818417eb482224cdee8d4Mon P Wang}; 177377cdf30742284a173fe818417eb482224cdee8d4Mon P Wang 1774e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson/// VTSDNode - This class is used to represent EVT's, which are used 177515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner/// to parameterize some operations. 177615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattnerclass VTSDNode : public SDNode { 1777e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT ValueType; 177815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner friend class SelectionDAG; 1779e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson explicit VTSDNode(EVT VT) 1780ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick : SDNode(ISD::VALUETYPE, 0, DebugLoc(), getSDVTList(MVT::Other)), 1781b494ccf02ce17318d3f2a7b2d674bec60781fc73Chris Lattner ValueType(VT) { 178263e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner } 178315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattnerpublic: 178415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner 1785e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT getVT() const { return ValueType; } 178615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner 178715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner static bool classof(const SDNode *N) { 178815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner return N->getOpcode() == ISD::VALUETYPE; 178915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner } 179015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner}; 179115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner 17929de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel/// LSBaseSDNode - Base class for LoadSDNode and StoreSDNode 17939de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel/// 179428873106309db515d58889a4c4fa3e0a92d1b60eMon P Wangclass LSBaseSDNode : public MemSDNode { 17959de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel //! Operand array for load and store 17969de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel /*! 17979de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel \note Moving this array to the base class captures more 17989de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel common functionality shared between LoadSDNode and 17999de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel StoreSDNode 18009de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel */ 18019cac5259fe237120a0c347d6d14e549005148f1bRoman Levenstein SDUse Ops[4]; 18029de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michelpublic: 18033af4d250676623b88436b89212108eb4fff897d3Jack Carter LSBaseSDNode(ISD::NodeType NodeTy, unsigned Order, DebugLoc dl, 18043af4d250676623b88436b89212108eb4fff897d3Jack Carter SDValue *Operands, unsigned numOperands, 18053af4d250676623b88436b89212108eb4fff897d3Jack Carter SDVTList VTs, ISD::MemIndexedMode AM, EVT MemVT, 18063af4d250676623b88436b89212108eb4fff897d3Jack Carter MachineMemOperand *MMO) 1807ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) { 1808a7ce741ff0ab02510833854bfa6a1c8c265faee3Dan Gohman SubclassData |= AM << 2; 1809a7ce741ff0ab02510833854bfa6a1c8c265faee3Dan Gohman assert(getAddressingMode() == AM && "MemIndexedMode encoding error!"); 1810a7ce741ff0ab02510833854bfa6a1c8c265faee3Dan Gohman InitOperands(Ops, Operands, numOperands); 18113edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen assert((getOffset().getOpcode() == ISD::UNDEF || isIndexed()) && 18123edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen "Only indexed loads and stores have a non-undef offset operand"); 18133edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen } 18149de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel 1815475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue &getOffset() const { 181663602b8a69b2729f0789cd3c920aceef0ece64cbChris Lattner return getOperand(getOpcode() == ISD::LOAD ? 2 : 3); 181763602b8a69b2729f0789cd3c920aceef0ece64cbChris Lattner } 18189de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel 1819ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman /// getAddressingMode - Return the addressing mode for this load or store: 1820ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman /// unindexed, pre-inc, pre-dec, post-inc, or post-dec. 1821ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman ISD::MemIndexedMode getAddressingMode() const { 1822a7ce741ff0ab02510833854bfa6a1c8c265faee3Dan Gohman return ISD::MemIndexedMode((SubclassData >> 2) & 7); 1823ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman } 1824b625f2f8960de32bc973092aaee8ac62863006feDan Gohman 1825b625f2f8960de32bc973092aaee8ac62863006feDan Gohman /// isIndexed - Return true if this is a pre/post inc/dec load/store. 1826ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman bool isIndexed() const { return getAddressingMode() != ISD::UNINDEXED; } 1827b625f2f8960de32bc973092aaee8ac62863006feDan Gohman 1828b625f2f8960de32bc973092aaee8ac62863006feDan Gohman /// isUnindexed - Return true if this is NOT a pre/post inc/dec load/store. 1829ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman bool isUnindexed() const { return getAddressingMode() == ISD::UNINDEXED; } 1830b625f2f8960de32bc973092aaee8ac62863006feDan Gohman 1831b625f2f8960de32bc973092aaee8ac62863006feDan Gohman static bool classof(const SDNode *N) { 1832b625f2f8960de32bc973092aaee8ac62863006feDan Gohman return N->getOpcode() == ISD::LOAD || 1833b625f2f8960de32bc973092aaee8ac62863006feDan Gohman N->getOpcode() == ISD::STORE; 1834b625f2f8960de32bc973092aaee8ac62863006feDan Gohman } 18359de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel}; 18369de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel 183724446e253a17720f6462288255ab5ebd13b8491fEvan Cheng/// LoadSDNode - This class is used to represent ISD::LOAD nodes. 183824446e253a17720f6462288255ab5ebd13b8491fEvan Cheng/// 18399de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michelclass LoadSDNode : public LSBaseSDNode { 184024446e253a17720f6462288255ab5ebd13b8491fEvan Cheng friend class SelectionDAG; 1841ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick LoadSDNode(SDValue *ChainPtrOff, unsigned Order, DebugLoc dl, SDVTList VTs, 1842c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman ISD::MemIndexedMode AM, ISD::LoadExtType ETy, EVT MemVT, 1843c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman MachineMemOperand *MMO) 1844ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick : LSBaseSDNode(ISD::LOAD, Order, dl, ChainPtrOff, 3, VTs, AM, MemVT, MMO) { 1845a7ce741ff0ab02510833854bfa6a1c8c265faee3Dan Gohman SubclassData |= (unsigned short)ETy; 1846a7ce741ff0ab02510833854bfa6a1c8c265faee3Dan Gohman assert(getExtensionType() == ETy && "LoadExtType encoding error!"); 1847c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman assert(readMem() && "Load MachineMemOperand is not a load!"); 1848c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman assert(!writeMem() && "Load MachineMemOperand is a store!"); 18493edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen } 185024446e253a17720f6462288255ab5ebd13b8491fEvan Chengpublic: 185124446e253a17720f6462288255ab5ebd13b8491fEvan Cheng 1852ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman /// getExtensionType - Return whether this is a plain node, 1853ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman /// or one of the varieties of value-extending loads. 1854ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman ISD::LoadExtType getExtensionType() const { 1855a7ce741ff0ab02510833854bfa6a1c8c265faee3Dan Gohman return ISD::LoadExtType(SubclassData & 3); 1856ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman } 1857ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman 1858475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue &getBasePtr() const { return getOperand(1); } 1859475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue &getOffset() const { return getOperand(2); } 1860d254a7fc0c354d165caee7e085ca0a95face4fa3Dan Gohman 186124446e253a17720f6462288255ab5ebd13b8491fEvan Cheng static bool classof(const SDNode *N) { 186224446e253a17720f6462288255ab5ebd13b8491fEvan Cheng return N->getOpcode() == ISD::LOAD; 186324446e253a17720f6462288255ab5ebd13b8491fEvan Cheng } 186424446e253a17720f6462288255ab5ebd13b8491fEvan Cheng}; 186524446e253a17720f6462288255ab5ebd13b8491fEvan Cheng 186624446e253a17720f6462288255ab5ebd13b8491fEvan Cheng/// StoreSDNode - This class is used to represent ISD::STORE nodes. 186724446e253a17720f6462288255ab5ebd13b8491fEvan Cheng/// 18689de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michelclass StoreSDNode : public LSBaseSDNode { 186924446e253a17720f6462288255ab5ebd13b8491fEvan Cheng friend class SelectionDAG; 1870ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick StoreSDNode(SDValue *ChainValuePtrOff, unsigned Order, DebugLoc dl, 1871ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDVTList VTs, ISD::MemIndexedMode AM, bool isTrunc, EVT MemVT, 1872c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman MachineMemOperand *MMO) 1873ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick : LSBaseSDNode(ISD::STORE, Order, dl, ChainValuePtrOff, 4, 1874c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman VTs, AM, MemVT, MMO) { 1875a7ce741ff0ab02510833854bfa6a1c8c265faee3Dan Gohman SubclassData |= (unsigned short)isTrunc; 1876a7ce741ff0ab02510833854bfa6a1c8c265faee3Dan Gohman assert(isTruncatingStore() == isTrunc && "isTrunc encoding error!"); 1877c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman assert(!readMem() && "Store MachineMemOperand is a load!"); 1878c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman assert(writeMem() && "Store MachineMemOperand is not a store!"); 18793edb43e6208493dec85a2e87942f7a4d59073727Dale Johannesen } 188024446e253a17720f6462288255ab5ebd13b8491fEvan Chengpublic: 188124446e253a17720f6462288255ab5ebd13b8491fEvan Cheng 1882ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman /// isTruncatingStore - Return true if the op does a truncation before store. 1883ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman /// For integers this is the same as doing a TRUNCATE and storing the result. 1884ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman /// For floats, it is the same as doing an FP_ROUND and storing the result. 1885a7ce741ff0ab02510833854bfa6a1c8c265faee3Dan Gohman bool isTruncatingStore() const { return SubclassData & 1; } 1886ea8a8651fae10bfea6149a512c01c0ebade4973fDan Gohman 1887475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue &getValue() const { return getOperand(1); } 1888475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue &getBasePtr() const { return getOperand(2); } 1889475871a144eb604ddaf37503397ba0941442e5fbDan Gohman const SDValue &getOffset() const { return getOperand(3); } 1890d254a7fc0c354d165caee7e085ca0a95face4fa3Dan Gohman 189124446e253a17720f6462288255ab5ebd13b8491fEvan Cheng static bool classof(const SDNode *N) { 189224446e253a17720f6462288255ab5ebd13b8491fEvan Cheng return N->getOpcode() == ISD::STORE; 189324446e253a17720f6462288255ab5ebd13b8491fEvan Cheng } 189424446e253a17720f6462288255ab5ebd13b8491fEvan Cheng}; 189524446e253a17720f6462288255ab5ebd13b8491fEvan Cheng 1896c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman/// MachineSDNode - An SDNode that represents everything that will be needed 1897c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman/// to construct a MachineInstr. These nodes are created during the 1898c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman/// instruction selection proper phase. 1899c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman/// 1900c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohmanclass MachineSDNode : public SDNode { 1901c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohmanpublic: 1902c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman typedef MachineMemOperand **mmo_iterator; 1903c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman 1904c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohmanprivate: 1905c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman friend class SelectionDAG; 1906ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick MachineSDNode(unsigned Opc, unsigned Order, const DebugLoc DL, SDVTList VTs) 1907dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines : SDNode(Opc, Order, DL, VTs), MemRefs(nullptr), MemRefsEnd(nullptr) {} 1908c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman 1909c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// LocalOperands - Operands for this instruction, if they fit here. If 1910c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// they don't, this field is unused. 1911c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman SDUse LocalOperands[4]; 1912c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman 1913c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// MemRefs - Memory reference descriptions for this instruction. 1914c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman mmo_iterator MemRefs; 1915c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman mmo_iterator MemRefsEnd; 1916c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman 1917c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohmanpublic: 1918c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman mmo_iterator memoperands_begin() const { return MemRefs; } 1919c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman mmo_iterator memoperands_end() const { return MemRefsEnd; } 1920c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman bool memoperands_empty() const { return MemRefsEnd == MemRefs; } 1921c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman 1922c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// setMemRefs - Assign this MachineSDNodes's memory reference descriptor 1923c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman /// list. This does not transfer ownership. 1924c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman void setMemRefs(mmo_iterator NewMemRefs, mmo_iterator NewMemRefsEnd) { 192539fe397421a23ea44e19b991e64b04f335f7bde6Owen Anderson for (mmo_iterator MMI = NewMemRefs, MME = NewMemRefsEnd; MMI != MME; ++MMI) 192639fe397421a23ea44e19b991e64b04f335f7bde6Owen Anderson assert(*MMI && "Null mem ref detected!"); 1927c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman MemRefs = NewMemRefs; 1928c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman MemRefsEnd = NewMemRefsEnd; 1929c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman } 1930c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman 1931c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman static bool classof(const SDNode *N) { 1932c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman return N->isMachineOpcode(); 1933c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman } 1934c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman}; 193515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner 19367362ce08cb2c1f0b544b18dbc21630fb4baebcfcGabor Greifclass SDNodeIterator : public std::iterator<std::forward_iterator_tag, 19377362ce08cb2c1f0b544b18dbc21630fb4baebcfcGabor Greif SDNode, ptrdiff_t> { 1938141e99745adbd3ba9fa7315af3384c1d08c4c20cRoman Divacky const SDNode *Node; 19391080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner unsigned Operand; 1940ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman 1941141e99745adbd3ba9fa7315af3384c1d08c4c20cRoman Divacky SDNodeIterator(const SDNode *N, unsigned Op) : Node(N), Operand(Op) {} 19421080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattnerpublic: 19431080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner bool operator==(const SDNodeIterator& x) const { 19441080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner return Operand == x.Operand; 19451080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 19461080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner bool operator!=(const SDNodeIterator& x) const { return !operator==(x); } 19471080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner 19481080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner const SDNodeIterator &operator=(const SDNodeIterator &I) { 19491080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner assert(I.Node == Node && "Cannot assign iterators to two different nodes!"); 19501080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner Operand = I.Operand; 19511080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner return *this; 19521080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 1953ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman 19541080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner pointer operator*() const { 1955ba36cb5242eb02b12b277f82b9efe497f7da4d7fGabor Greif return Node->getOperand(Operand).getNode(); 19561080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 19571080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner pointer operator->() const { return operator*(); } 1958ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman 19591080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner SDNodeIterator& operator++() { // Preincrement 19601080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner ++Operand; 19611080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner return *this; 19621080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 19631080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner SDNodeIterator operator++(int) { // Postincrement 1964ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman SDNodeIterator tmp = *this; ++*this; return tmp; 19651080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 19665b69fe767ca0786ecb50e703f2da8ea09de5da7cDan Gohman size_t operator-(SDNodeIterator Other) const { 19675b69fe767ca0786ecb50e703f2da8ea09de5da7cDan Gohman assert(Node == Other.Node && 19685b69fe767ca0786ecb50e703f2da8ea09de5da7cDan Gohman "Cannot compare iterators of two different nodes!"); 19695b69fe767ca0786ecb50e703f2da8ea09de5da7cDan Gohman return Operand - Other.Operand; 19705b69fe767ca0786ecb50e703f2da8ea09de5da7cDan Gohman } 19711080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner 1972141e99745adbd3ba9fa7315af3384c1d08c4c20cRoman Divacky static SDNodeIterator begin(const SDNode *N) { return SDNodeIterator(N, 0); } 1973141e99745adbd3ba9fa7315af3384c1d08c4c20cRoman Divacky static SDNodeIterator end (const SDNode *N) { 19741080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner return SDNodeIterator(N, N->getNumOperands()); 19751080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 19761080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner 19771080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner unsigned getOperand() const { return Operand; } 19781080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner const SDNode *getNode() const { return Node; } 19791080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner}; 19801080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner 19811080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattnertemplate <> struct GraphTraits<SDNode*> { 19821080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner typedef SDNode NodeType; 19831080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner typedef SDNodeIterator ChildIteratorType; 19841080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner static inline NodeType *getEntryNode(SDNode *N) { return N; } 1985ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman static inline ChildIteratorType child_begin(NodeType *N) { 19861080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner return SDNodeIterator::begin(N); 19871080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 1988ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman static inline ChildIteratorType child_end(NodeType *N) { 19891080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner return SDNodeIterator::end(N); 19901080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 19911080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner}; 19921080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner 19930e5f1306b059b62d7725f324e087efbc8e7a782dDan Gohman/// LargestSDNode - The largest SDNode class. 19940e5f1306b059b62d7725f324e087efbc8e7a782dDan Gohman/// 1995268c743a3ba44ada364938bc5ff9b1be219df54fAmara Emersontypedef AtomicSDNode LargestSDNode; 19960e5f1306b059b62d7725f324e087efbc8e7a782dDan Gohman 1997fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman/// MostAlignedSDNode - The SDNode class with the greatest alignment 1998fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman/// requirement. 1999fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohman/// 200098ca4f2a325f72374a477f9deba7d09e8999c29bDan Gohmantypedef GlobalAddressSDNode MostAlignedSDNode; 2001b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner 2002c548428c5d7328592f4db6f6cd815af18b3152a3Evan Chengnamespace ISD { 2003186edc8fa13d0e02d3c17563ad2bd78ac5963a67Evan Cheng /// isNormalLoad - Returns true if the specified node is a non-extending 2004186edc8fa13d0e02d3c17563ad2bd78ac5963a67Evan Cheng /// and unindexed load. 2005186edc8fa13d0e02d3c17563ad2bd78ac5963a67Evan Cheng inline bool isNormalLoad(const SDNode *N) { 2006c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands const LoadSDNode *Ld = dyn_cast<LoadSDNode>(N); 2007c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands return Ld && Ld->getExtensionType() == ISD::NON_EXTLOAD && 2008186edc8fa13d0e02d3c17563ad2bd78ac5963a67Evan Cheng Ld->getAddressingMode() == ISD::UNINDEXED; 2009186edc8fa13d0e02d3c17563ad2bd78ac5963a67Evan Cheng } 2010186edc8fa13d0e02d3c17563ad2bd78ac5963a67Evan Cheng 201124446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// isNON_EXTLoad - Returns true if the specified node is a non-extending 201224446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// load. 201324446e253a17720f6462288255ab5ebd13b8491fEvan Cheng inline bool isNON_EXTLoad(const SDNode *N) { 2014c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands return isa<LoadSDNode>(N) && 201524446e253a17720f6462288255ab5ebd13b8491fEvan Cheng cast<LoadSDNode>(N)->getExtensionType() == ISD::NON_EXTLOAD; 201624446e253a17720f6462288255ab5ebd13b8491fEvan Cheng } 201724446e253a17720f6462288255ab5ebd13b8491fEvan Cheng 2018c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng /// isEXTLoad - Returns true if the specified node is a EXTLOAD. 2019c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng /// 2020c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng inline bool isEXTLoad(const SDNode *N) { 2021c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands return isa<LoadSDNode>(N) && 202224446e253a17720f6462288255ab5ebd13b8491fEvan Cheng cast<LoadSDNode>(N)->getExtensionType() == ISD::EXTLOAD; 2023c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng } 2024c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng 2025c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng /// isSEXTLoad - Returns true if the specified node is a SEXTLOAD. 2026c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng /// 2027c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng inline bool isSEXTLoad(const SDNode *N) { 2028c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands return isa<LoadSDNode>(N) && 202924446e253a17720f6462288255ab5ebd13b8491fEvan Cheng cast<LoadSDNode>(N)->getExtensionType() == ISD::SEXTLOAD; 2030c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng } 2031c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng 2032c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng /// isZEXTLoad - Returns true if the specified node is a ZEXTLOAD. 2033c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng /// 2034c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng inline bool isZEXTLoad(const SDNode *N) { 2035c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands return isa<LoadSDNode>(N) && 203624446e253a17720f6462288255ab5ebd13b8491fEvan Cheng cast<LoadSDNode>(N)->getExtensionType() == ISD::ZEXTLOAD; 2037c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng } 20388b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng 2039c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands /// isUNINDEXEDLoad - Returns true if the specified node is an unindexed load. 204002c50e4891841c28b2a743731dfc60744bb78879Evan Cheng /// 204102c50e4891841c28b2a743731dfc60744bb78879Evan Cheng inline bool isUNINDEXEDLoad(const SDNode *N) { 2042c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands return isa<LoadSDNode>(N) && 204302c50e4891841c28b2a743731dfc60744bb78879Evan Cheng cast<LoadSDNode>(N)->getAddressingMode() == ISD::UNINDEXED; 204402c50e4891841c28b2a743731dfc60744bb78879Evan Cheng } 204502c50e4891841c28b2a743731dfc60744bb78879Evan Cheng 2046c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands /// isNormalStore - Returns true if the specified node is a non-truncating 2047c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands /// and unindexed store. 2048c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands inline bool isNormalStore(const SDNode *N) { 2049c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands const StoreSDNode *St = dyn_cast<StoreSDNode>(N); 2050c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands return St && !St->isTruncatingStore() && 2051c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands St->getAddressingMode() == ISD::UNINDEXED; 2052c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands } 2053c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands 20548b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng /// isNON_TRUNCStore - Returns true if the specified node is a non-truncating 20558b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng /// store. 20568b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng inline bool isNON_TRUNCStore(const SDNode *N) { 2057c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands return isa<StoreSDNode>(N) && !cast<StoreSDNode>(N)->isTruncatingStore(); 20588b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng } 20598b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng 20608b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng /// isTRUNCStore - Returns true if the specified node is a truncating 20618b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng /// store. 20628b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng inline bool isTRUNCStore(const SDNode *N) { 2063c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands return isa<StoreSDNode>(N) && cast<StoreSDNode>(N)->isTruncatingStore(); 2064c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands } 2065c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands 2066c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands /// isUNINDEXEDStore - Returns true if the specified node is an 2067c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands /// unindexed store. 2068c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands inline bool isUNINDEXEDStore(const SDNode *N) { 2069c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands return isa<StoreSDNode>(N) && 2070c8f88cc8c0b4ce1664520d5390c623f2c44e4555Duncan Sands cast<StoreSDNode>(N)->getAddressingMode() == ISD::UNINDEXED; 20718b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng } 2072c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng} 2073c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng 207463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner} // end llvm namespace 207563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 207663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner#endif 2077