SelectionDAGNodes.h revision efec751a1b786724862ceff52748df94873a807e
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 222d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth#include "llvm/Value.h" 23583bd47f777fe3eb8305872fa0eadab31e833dffJim Laskey#include "llvm/ADT/FoldingSet.h" 241080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner#include "llvm/ADT/GraphTraits.h" 251080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner#include "llvm/ADT/iterator" 268bb369b8072c919ef5802f639a52b17620201190Dale Johannesen#include "llvm/ADT/APFloat.h" 276394b099e836f56a937cdcc7332c9487b504ca68Dan Gohman#include "llvm/ADT/APInt.h" 28d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng#include "llvm/CodeGen/ValueTypes.h" 2969de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman#include "llvm/CodeGen/MemOperand.h" 3039931a3dbac1aa2fe2ec14f26001c8c29102940cJeff Cohen#include "llvm/Support/DataTypes.h" 3163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner#include <cassert> 3263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 3363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnernamespace llvm { 3463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 3563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass SelectionDAG; 3663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass GlobalValue; 3763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass MachineBasicBlock; 38d6594ae54cfde4db4d30272192645c0a45fb9902Evan Chengclass MachineConstantPoolValue; 3963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass SDNode; 4076c1b97e4020faace8c95a127f1eab66c278fb58Chris Lattnertemplate <typename T> struct DenseMapInfo; 4163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnertemplate <typename T> struct simplify_type; 42b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattnertemplate <typename T> struct ilist_traits; 43b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattnertemplate<typename NodeTy, typename Traits> class iplist; 44b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattnertemplate<typename NodeTy> class ilist_iterator; 4563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 460b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner/// SDVTList - This represents a list of ValueType's that has been intern'd by 470b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner/// a SelectionDAG. Instances of this simple value class are returned by 480b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner/// SelectionDAG::getVTList(...). 490b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner/// 500b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattnerstruct SDVTList { 510b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner const MVT::ValueType *VTs; 520b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner unsigned short NumVTs; 530b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner}; 540b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner 5563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// ISD namespace - This namespace contains an enum which represents all of the 5663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// SelectionDAG node types and value types. 5763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// 5863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnernamespace ISD { 59d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov namespace ParamFlags { 60d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov enum Flags { 61d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov NoFlagSet = 0, 62d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov ZExt = 1<<0, ///< Parameter should be zero extended 63d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov ZExtOffs = 0, 64d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov SExt = 1<<1, ///< Parameter should be sign extended 65d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov SExtOffs = 1, 66d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov InReg = 1<<2, ///< Parameter should be passed in register 67d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov InRegOffs = 2, 68d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov StructReturn = 1<<3, ///< Hidden struct-return pointer 69d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov StructReturnOffs = 3, 701aa7efbd2c98e761f50992197473304b99257ca9Rafael Espindola ByVal = 1<<4, ///< Struct passed by value 711aa7efbd2c98e761f50992197473304b99257ca9Rafael Espindola ByValOffs = 4, 7236397f50343639ce9a25996f2d790c656791ab92Duncan Sands Nest = 1<<5, ///< Parameter is nested function static chain 7336397f50343639ce9a25996f2d790c656791ab92Duncan Sands NestOffs = 5, 74594d37e21aea4ef841d9ee5d9c328c4bf1c6bed7Rafael Espindola ByValAlign = 0xF << 6, //< The alignment of the struct 75594d37e21aea4ef841d9ee5d9c328c4bf1c6bed7Rafael Espindola ByValAlignOffs = 6, 76594d37e21aea4ef841d9ee5d9c328c4bf1c6bed7Rafael Espindola ByValSize = 0x1ffff << 10, //< The size of the struct 77594d37e21aea4ef841d9ee5d9c328c4bf1c6bed7Rafael Espindola ByValSizeOffs = 10, 78d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov OrigAlignment = 0x1F<<27, 79d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov OrigAlignmentOffs = 27 80d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov }; 81d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov } 82d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov 8363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner //===--------------------------------------------------------------------===// 8463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// ISD::NodeType enum - This enum defines all of the operators valid in a 8563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// SelectionDAG. 8663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// 8763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner enum NodeType { 883258ed6a361bf405a89f7af0b1885841d9909516Chris Lattner // DELETED_NODE - This is an illegal flag value that is used to catch 893258ed6a361bf405a89f7af0b1885841d9909516Chris Lattner // errors. This opcode is not a legal opcode for any node. 903258ed6a361bf405a89f7af0b1885841d9909516Chris Lattner DELETED_NODE, 913258ed6a361bf405a89f7af0b1885841d9909516Chris Lattner 928a496fcffdcba757412fc5cc6c772260ccfde000Chris Lattner // EntryToken - This is the marker used to indicate the start of the region. 938a496fcffdcba757412fc5cc6c772260ccfde000Chris Lattner EntryToken, 948a496fcffdcba757412fc5cc6c772260ccfde000Chris Lattner 958c4bde36a339b1c538002e819daff84caae4cbadReid Spencer // Token factor - This node takes multiple tokens as input and produces a 968a496fcffdcba757412fc5cc6c772260ccfde000Chris Lattner // single token result. This is used to represent the fact that the operand 978a496fcffdcba757412fc5cc6c772260ccfde000Chris Lattner // operators are independent of each other. 988a496fcffdcba757412fc5cc6c772260ccfde000Chris Lattner TokenFactor, 99f7f3d321916c1ef3a82b2a175a368a148b1ede46Nate Begeman 100f7f3d321916c1ef3a82b2a175a368a148b1ede46Nate Begeman // AssertSext, AssertZext - These nodes record if a register contains a 101f7f3d321916c1ef3a82b2a175a368a148b1ede46Nate Begeman // value that has already been zero or sign extended from a narrower type. 102f7f3d321916c1ef3a82b2a175a368a148b1ede46Nate Begeman // These nodes take two operands. The first is the node that has already 103f7f3d321916c1ef3a82b2a175a368a148b1ede46Nate Begeman // been extended, and the second is a value type node indicating the width 104f7f3d321916c1ef3a82b2a175a368a148b1ede46Nate Begeman // of the extension 105f7f3d321916c1ef3a82b2a175a368a148b1ede46Nate Begeman AssertSext, AssertZext, 106ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman 1078a496fcffdcba757412fc5cc6c772260ccfde000Chris Lattner // Various leaf nodes. 1081ab7d859cf5c490612799d7e132c0b1c39f8f497Evan Cheng STRING, BasicBlock, VALUETYPE, CONDCODE, Register, 1091ab7d859cf5c490612799d7e132c0b1c39f8f497Evan Cheng Constant, ConstantFP, 110b3a0417cad8b625acc3033bd5e24afb9ffd0b084Lauro Ramos Venancio GlobalAddress, GlobalTLSAddress, FrameIndex, 111b3a0417cad8b625acc3033bd5e24afb9ffd0b084Lauro Ramos Venancio JumpTable, ConstantPool, ExternalSymbol, 1121ab7d859cf5c490612799d7e132c0b1c39f8f497Evan Cheng 11382c3d8f81ab20dc7571f29ffc46a5bb1b7ed8323Andrew Lenharth // The address of the GOT 11482c3d8f81ab20dc7571f29ffc46a5bb1b7ed8323Andrew Lenharth GLOBAL_OFFSET_TABLE, 115bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman 116bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman // FRAMEADDR, RETURNADDR - These nodes represent llvm.frameaddress and 117bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman // llvm.returnaddress on the DAG. These nodes take one operand, the index 118bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman // of the frame or return address to return. An index of zero corresponds 119bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman // to the current function's frame or return address, an index of one to the 120bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman // parent's frame or return address, and so on. 121bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman FRAMEADDR, RETURNADDR, 1222365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov 1232365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov // FRAME_TO_ARGS_OFFSET - This node represents offset from frame pointer to 1242365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov // first (possible) on-stack argument. This is needed for correct stack 1252365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov // adjustment during unwind. 1262365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov FRAME_TO_ARGS_OFFSET, 127f09f2e304dc82010d2e02a9b40a8c5fb0091490cJim Laskey 128f09f2e304dc82010d2e02a9b40a8c5fb0091490cJim Laskey // RESULT, OUTCHAIN = EXCEPTIONADDR(INCHAIN) - This node represents the 129f09f2e304dc82010d2e02a9b40a8c5fb0091490cJim Laskey // address of the exception block on entry to an landing pad block. 130f09f2e304dc82010d2e02a9b40a8c5fb0091490cJim Laskey EXCEPTIONADDR, 131f09f2e304dc82010d2e02a9b40a8c5fb0091490cJim Laskey 132f09f2e304dc82010d2e02a9b40a8c5fb0091490cJim Laskey // RESULT, OUTCHAIN = EHSELECTION(INCHAIN, EXCEPTION) - This node represents 133f09f2e304dc82010d2e02a9b40a8c5fb0091490cJim Laskey // the selection index of the exception thrown. 134f09f2e304dc82010d2e02a9b40a8c5fb0091490cJim Laskey EHSELECTION, 135beec30eaf301bd6882cd06800b5175b94f033f9dAndrew Lenharth 1362365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov // OUTCHAIN = EH_RETURN(INCHAIN, OFFSET, HANDLER) - This node represents 1372365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov // 'eh_return' gcc dwarf builtin, which is used to return from 1382365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov // exception. The general meaning is: adjust stack by OFFSET and pass 1392365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov // execution to HANDLER. Many platform-related details also :) 1402365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov EH_RETURN, 1412365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov 142ac0d7238258defe72b1aad53d7f48201b91df795Chris Lattner // TargetConstant* - Like Constant*, but the DAG does not do any folding or 143ac0d7238258defe72b1aad53d7f48201b91df795Chris Lattner // simplification of the constant. 144056f9f61d071c6c583951678f2bf543a1316efccChris Lattner TargetConstant, 145ac0d7238258defe72b1aad53d7f48201b91df795Chris Lattner TargetConstantFP, 146f6b184981e429ff03742d66cf7111debd9e2bc61Chris Lattner 147f6b184981e429ff03742d66cf7111debd9e2bc61Chris Lattner // TargetGlobalAddress - Like GlobalAddress, but the DAG does no folding or 148f6b184981e429ff03742d66cf7111debd9e2bc61Chris Lattner // anything else with this node, and this is valid in the target-specific 149f6b184981e429ff03742d66cf7111debd9e2bc61Chris Lattner // dag, turning into a GlobalAddress operand. 150f6b184981e429ff03742d66cf7111debd9e2bc61Chris Lattner TargetGlobalAddress, 151b3a0417cad8b625acc3033bd5e24afb9ffd0b084Lauro Ramos Venancio TargetGlobalTLSAddress, 152afb2dd43de61f4585e75d1f3ab93a9ac4b3b7592Chris Lattner TargetFrameIndex, 15337efe6764568a3829fee26aba532283131d1a104Nate Begeman TargetJumpTable, 154aaaaf79d4aaa172c2f2ae0e327bbae523a045bf5Chris Lattner TargetConstantPool, 1552a2de66db2093a5bc1fd620d1b6ae7992a552b24Andrew Lenharth TargetExternalSymbol, 15672601cac6051a9571ca4db3b32d6a73e40b40bd1Chris Lattner 157ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner /// RESULT = INTRINSIC_WO_CHAIN(INTRINSICID, arg1, arg2, ...) 158ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner /// This node represents a target intrinsic function with no side effects. 159ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner /// The first operand is the ID number of the intrinsic from the 160ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner /// llvm::Intrinsic namespace. The operands to the intrinsic follow. The 161ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner /// node has returns the result of the intrinsic. 162ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner INTRINSIC_WO_CHAIN, 163ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner 164ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner /// RESULT,OUTCHAIN = INTRINSIC_W_CHAIN(INCHAIN, INTRINSICID, arg1, ...) 165ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner /// This node represents a target intrinsic function with side effects that 166ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner /// returns a result. The first operand is a chain pointer. The second is 167ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner /// the ID number of the intrinsic from the llvm::Intrinsic namespace. The 168ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner /// operands to the intrinsic follow. The node has two results, the result 169ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner /// of the intrinsic and an output chain. 170ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner INTRINSIC_W_CHAIN, 17163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 172ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner /// OUTCHAIN = INTRINSIC_VOID(INCHAIN, INTRINSICID, arg1, arg2, ...) 173ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner /// This node represents a target intrinsic function with side effects that 174ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner /// does not return a result. The first operand is a chain pointer. The 175ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner /// second is the ID number of the intrinsic from the llvm::Intrinsic 176ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner /// namespace. The operands to the intrinsic follow. 177ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner INTRINSIC_VOID, 178ef8ef916348ad0da964687358e8be614e2470d67Chris Lattner 179d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // CopyToReg - This node has three operands: a chain, a register number to 180d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // set to this value, and a value. 18163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner CopyToReg, 18263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 18363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // CopyFromReg - This node indicates that the input value is a virtual or 18463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // physical register that is defined outside of the scope of this 185ab2a7542546bf781fa373e20095be0e344f5b3ccDan Gohman // SelectionDAG. The register is available from the RegisterSDNode object. 18663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner CopyFromReg, 18763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 188fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman // UNDEF - An undefined node 189fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman UNDEF, 190681ee1c1c3f7c3558c29a5bf3a668c1d0784c399Chris Lattner 191b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov /// FORMAL_ARGUMENTS(CHAIN, CC#, ISVARARG, FLAG0, ..., FLAGn) - This node 192b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov /// represents the formal arguments for a function. CC# is a Constant value 193b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov /// indicating the calling convention of the function, and ISVARARG is a 194b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov /// flag that indicates whether the function is varargs or not. This node 195b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov /// has one result value for each incoming argument, plus one for the output 196b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov /// chain. It must be custom legalized. See description of CALL node for 197b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov /// FLAG argument contents explanation. 198c1a8ad71e11123f1e3c8d9913a7f51978b9967d5Chris Lattner /// 199681ee1c1c3f7c3558c29a5bf3a668c1d0784c399Chris Lattner FORMAL_ARGUMENTS, 2006c0bfc723779366698d3936b63dcddc6164c2d33Chris Lattner 2016c0bfc723779366698d3936b63dcddc6164c2d33Chris Lattner /// RV1, RV2...RVn, CHAIN = CALL(CHAIN, CC#, ISVARARG, ISTAILCALL, CALLEE, 202b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov /// ARG0, FLAG0, ARG1, FLAG1, ... ARGn, FLAGn) 2036c0bfc723779366698d3936b63dcddc6164c2d33Chris Lattner /// This node represents a fully general function call, before the legalizer 204b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov /// runs. This has one result value for each argument / flag pair, plus 205b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov /// a chain result. It must be custom legalized. Flag argument indicates 206b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov /// misc. argument attributes. Currently: 207b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov /// Bit 0 - signness 208b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov /// Bit 1 - 'inreg' attribute 209b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov /// Bit 2 - 'sret' attribute 210594d37e21aea4ef841d9ee5d9c328c4bf1c6bed7Rafael Espindola /// Bit 4 - 'byval' attribute 211594d37e21aea4ef841d9ee5d9c328c4bf1c6bed7Rafael Espindola /// Bit 5 - 'nest' attribute 212594d37e21aea4ef841d9ee5d9c328c4bf1c6bed7Rafael Espindola /// Bit 6-9 - alignment of byval structures 213594d37e21aea4ef841d9ee5d9c328c4bf1c6bed7Rafael Espindola /// Bit 10-26 - size of byval structures 21413a3cee13133711eb95174a004dca4421ccd1cd9Lauro Ramos Venancio /// Bits 31:27 - argument ABI alignment in the first argument piece and 21513a3cee13133711eb95174a004dca4421ccd1cd9Lauro Ramos Venancio /// alignment '1' in other argument pieces. 2166c0bfc723779366698d3936b63dcddc6164c2d33Chris Lattner CALL, 217fc1b1dad88a256ab5ab16dd548ad82df8efa2ca9Nate Begeman 21863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // EXTRACT_ELEMENT - This is used to get the first or second (determined by 21963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // a Constant, which is required to be operand #1), element of the aggregate 22063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // value specified as operand #0. This is only for use before legalization, 22163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // for values that will be broken into multiple registers. 22263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner EXTRACT_ELEMENT, 22363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 22463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // BUILD_PAIR - This is the opposite of EXTRACT_ELEMENT in some ways. Given 22563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // two values of the same integer value type, this produces a value twice as 22663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // big. Like EXTRACT_ELEMENT, this can only be used before legalization. 22763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner BUILD_PAIR, 228006e3e3649b2e19762b7bc134292b781569685b0Chris Lattner 229006e3e3649b2e19762b7bc134292b781569685b0Chris Lattner // MERGE_VALUES - This node takes multiple discrete operands and returns 230006e3e3649b2e19762b7bc134292b781569685b0Chris Lattner // them all as its individual results. This nodes has exactly the same 231006e3e3649b2e19762b7bc134292b781569685b0Chris Lattner // number of inputs and outputs, and is only valid before legalization. 232006e3e3649b2e19762b7bc134292b781569685b0Chris Lattner // This node is useful for some pieces of the code generator that want to 233006e3e3649b2e19762b7bc134292b781569685b0Chris Lattner // think about a single node with multiple results, not multiple nodes. 234006e3e3649b2e19762b7bc134292b781569685b0Chris Lattner MERGE_VALUES, 23563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 236615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner // Simple integer binary arithmetic operators. 237bede0b7dd7c70792b09f6d38f6f2dfe7c1feb1d1Chris Lattner ADD, SUB, MUL, SDIV, UDIV, SREM, UREM, 238fdd04d5ddecb1d1f3030839520109308137b73dcDan Gohman 239fdd04d5ddecb1d1f3030839520109308137b73dcDan Gohman // SMUL_LOHI/UMUL_LOHI - Multiply two integers of type iN, producing 240b36904be918b72cc4c714552d42d6a713f27bbf5Duncan Sands // a signed/unsigned value of type i[2*N], and return the full value as 241fdd04d5ddecb1d1f3030839520109308137b73dcDan Gohman // two results, each of type iN. 242fdd04d5ddecb1d1f3030839520109308137b73dcDan Gohman SMUL_LOHI, UMUL_LOHI, 243fdd04d5ddecb1d1f3030839520109308137b73dcDan Gohman 244fdd04d5ddecb1d1f3030839520109308137b73dcDan Gohman // SDIVREM/UDIVREM - Divide two integers and produce both a quotient and 245fdd04d5ddecb1d1f3030839520109308137b73dcDan Gohman // remainder result. 246fdd04d5ddecb1d1f3030839520109308137b73dcDan Gohman SDIVREM, UDIVREM, 247615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner 24855e34eb31741f7902445cfa94fddde7a6910c408Chris Lattner // CARRY_FALSE - This node is used when folding other nodes, 24955e34eb31741f7902445cfa94fddde7a6910c408Chris Lattner // like ADDC/SUBC, which indicate the carry result is always false. 25055e34eb31741f7902445cfa94fddde7a6910c408Chris Lattner CARRY_FALSE, 25155e34eb31741f7902445cfa94fddde7a6910c408Chris Lattner 252551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman // Carry-setting nodes for multiple precision addition and subtraction. 253551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman // These nodes take two operands of the same value type, and produce two 254551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman // results. The first result is the normal add or sub result, the second 255551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman // result is the carry flag result. 256551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman ADDC, SUBC, 257551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman 258551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman // Carry-using nodes for multiple precision addition and subtraction. These 259551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman // nodes take three operands: The first two are the normal lhs and rhs to 260551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman // the add or sub, and the third is the input carry flag. These nodes 261551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman // produce two results; the normal result of the add or sub, and the output 262551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman // carry flag. These nodes both read and write a carry flag to allow them 263551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman // to them to be chained together for add and sub of arbitrarily large 264551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman // values. 265551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman ADDE, SUBE, 266551bf3f80058a026b6a128dffd5530019e1df1b9Nate Begeman 267615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner // Simple binary floating point operators. 268615c2d0920862ae7d4d766ee3da660ecf2197308Chris Lattner FADD, FSUB, FMUL, FDIV, FREM, 26938bf3bffe3abfd00169d6dcf4fad7e2197808dbfChris Lattner 27038bf3bffe3abfd00169d6dcf4fad7e2197808dbfChris Lattner // FCOPYSIGN(X, Y) - Return the value of X with the sign of Y. NOTE: This 27138bf3bffe3abfd00169d6dcf4fad7e2197808dbfChris Lattner // DAG node does not require that X and Y have the same type, just that they 27238bf3bffe3abfd00169d6dcf4fad7e2197808dbfChris Lattner // are both floating point. X and the result must have the same type. 27338bf3bffe3abfd00169d6dcf4fad7e2197808dbfChris Lattner // FCOPYSIGN(f32, f64) is allowed. 27438bf3bffe3abfd00169d6dcf4fad7e2197808dbfChris Lattner FCOPYSIGN, 275fa984b61e42c94ad7e66cf2880ca826dba488d30Chris Lattner 2761a3048bb8e0f3de0b4e56704c15c556c71565f4bChris Lattner // INT = FGETSIGN(FP) - Return the sign bit of the specified floating point 2771a3048bb8e0f3de0b4e56704c15c556c71565f4bChris Lattner // value as an integer 0/1 value. 2781a3048bb8e0f3de0b4e56704c15c556c71565f4bChris Lattner FGETSIGN, 2791a3048bb8e0f3de0b4e56704c15c556c71565f4bChris Lattner 280664e9546d674096c5a012536f1a424b1681ece51Dan Gohman /// BUILD_VECTOR(ELT0, ELT1, ELT2, ELT3,...) - Return a vector 28122232f659bec0f4c23ec46445d3bd3c4deb68686Chris Lattner /// with the specified, possibly variable, elements. The number of elements 28222232f659bec0f4c23ec46445d3bd3c4deb68686Chris Lattner /// is required to be a power of two. 28322232f659bec0f4c23ec46445d3bd3c4deb68686Chris Lattner BUILD_VECTOR, 28422232f659bec0f4c23ec46445d3bd3c4deb68686Chris Lattner 2857f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman /// INSERT_VECTOR_ELT(VECTOR, VAL, IDX) - Returns VECTOR with the element 2867f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman /// at IDX replaced with VAL. 28722232f659bec0f4c23ec46445d3bd3c4deb68686Chris Lattner INSERT_VECTOR_ELT, 2884b8db6c453fd3a7b07bc7c0e8092018530701ffdChris Lattner 2894b8db6c453fd3a7b07bc7c0e8092018530701ffdChris Lattner /// EXTRACT_VECTOR_ELT(VECTOR, IDX) - Returns a single element from VECTOR 2907f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman /// identified by the (potentially variable) element number IDX. 2914b8db6c453fd3a7b07bc7c0e8092018530701ffdChris Lattner EXTRACT_VECTOR_ELT, 29222232f659bec0f4c23ec46445d3bd3c4deb68686Chris Lattner 2937f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman /// CONCAT_VECTORS(VECTOR0, VECTOR1, ...) - Given a number of values of 2947f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman /// vector type with the same length and element type, this produces a 2957f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman /// concatenated vector result value, with length equal to the sum of the 296b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman /// lengths of the input vectors. 2977f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman CONCAT_VECTORS, 2986595635175764f402e7a5e53216c8d46bdce8c28Dan Gohman 2997f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman /// EXTRACT_SUBVECTOR(VECTOR, IDX) - Returns a subvector from VECTOR (an 3007f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman /// vector value) starting with the (potentially variable) element number 3017f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman /// IDX, which must be a multiple of the result vector length. 3027f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman EXTRACT_SUBVECTOR, 3036595635175764f402e7a5e53216c8d46bdce8c28Dan Gohman 30449c6d3eba8869cf945f6c55ea243466e2b406fe8Chris Lattner /// VECTOR_SHUFFLE(VEC1, VEC2, SHUFFLEVEC) - Returns a vector, of the same 30549c6d3eba8869cf945f6c55ea243466e2b406fe8Chris Lattner /// type as VEC1/VEC2. SHUFFLEVEC is a BUILD_VECTOR of constant int values 30649c6d3eba8869cf945f6c55ea243466e2b406fe8Chris Lattner /// (regardless of whether its datatype is legal or not) that indicate 30749c6d3eba8869cf945f6c55ea243466e2b406fe8Chris Lattner /// which value each result element will get. The elements of VEC1/VEC2 are 30849c6d3eba8869cf945f6c55ea243466e2b406fe8Chris Lattner /// enumerated in order. This is quite similar to the Altivec 'vperm' 30949c6d3eba8869cf945f6c55ea243466e2b406fe8Chris Lattner /// instruction, except that the indices must be constants and are in terms 31049c6d3eba8869cf945f6c55ea243466e2b406fe8Chris Lattner /// of the element size of VEC1/VEC2, not in terms of bytes. 31149c6d3eba8869cf945f6c55ea243466e2b406fe8Chris Lattner VECTOR_SHUFFLE, 31249c6d3eba8869cf945f6c55ea243466e2b406fe8Chris Lattner 313210721aecc0916315f61660dc387a96b89ec423bChris Lattner /// SCALAR_TO_VECTOR(VAL) - This represents the operation of loading a 314a95afe2b5fb7a716ff4cc7bb623995a0a4c56411Nate Begeman /// scalar value into element 0 of the resultant vector type. The top 315a95afe2b5fb7a716ff4cc7bb623995a0a4c56411Nate Begeman /// elements 1 to N-1 of the N-element vector are undefined. 316210721aecc0916315f61660dc387a96b89ec423bChris Lattner SCALAR_TO_VECTOR, 317210721aecc0916315f61660dc387a96b89ec423bChris Lattner 318557c3631d320c5731e55b6f818a1c7b2d4d97176Christopher Lamb // EXTRACT_SUBREG - This node is used to extract a sub-register value. 319557c3631d320c5731e55b6f818a1c7b2d4d97176Christopher Lamb // This node takes a superreg and a constant sub-register index as operands. 320557c3631d320c5731e55b6f818a1c7b2d4d97176Christopher Lamb EXTRACT_SUBREG, 321557c3631d320c5731e55b6f818a1c7b2d4d97176Christopher Lamb 322557c3631d320c5731e55b6f818a1c7b2d4d97176Christopher Lamb // INSERT_SUBREG - This node is used to insert a sub-register value. 323557c3631d320c5731e55b6f818a1c7b2d4d97176Christopher Lamb // This node takes a superreg, a subreg value, and a constant sub-register 324557c3631d320c5731e55b6f818a1c7b2d4d97176Christopher Lamb // index as operands. 325557c3631d320c5731e55b6f818a1c7b2d4d97176Christopher Lamb INSERT_SUBREG, 326557c3631d320c5731e55b6f818a1c7b2d4d97176Christopher Lamb 327bede0b7dd7c70792b09f6d38f6f2dfe7c1feb1d1Chris Lattner // MULHU/MULHS - Multiply high - Multiply two integers of type iN, producing 328b36904be918b72cc4c714552d42d6a713f27bbf5Duncan Sands // an unsigned/signed value of type i[2*N], then return the top part. 329bede0b7dd7c70792b09f6d38f6f2dfe7c1feb1d1Chris Lattner MULHU, MULHS, 33063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 33135ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman // Bitwise operators - logical and, logical or, logical xor, shift left, 33235ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman // shift right algebraic (shift in sign bits), shift right logical (shift in 33335ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman // zeroes), rotate left, rotate right, and byteswap. 33435ef913ec21de0f4f1b39c811b4335438717a9b8Nate Begeman AND, OR, XOR, SHL, SRA, SRL, ROTL, ROTR, BSWAP, 33563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 336691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth // Counting operators 337691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth CTTZ, CTLZ, CTPOP, 338691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth 339fa984b61e42c94ad7e66cf2880ca826dba488d30Chris Lattner // Select(COND, TRUEVAL, FALSEVAL) 3409373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman SELECT, 3419373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman 3429373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman // Select with condition operator - This selects between a true value and 3439373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman // a false value (ops #2 and #3) based on the boolean result of comparing 3449373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman // the lhs and rhs (ops #0 and #1) of a conditional expression with the 3459373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman // condition code in op #4, a CondCodeSDNode. 3469373a81e53ce5f9f2c06c4209b8b886605aece08Nate Begeman SELECT_CC, 34763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 34863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // SetCC operator - This evaluates to a boolean (i1) true value if the 3497cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner // condition is true. The operands to this are the left and right operands 3507cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner // to compare (ops #0, and #1) and the condition code to compare them with 3517cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner // (op #2) as a CondCodeSDNode. 35263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETCC, 35363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 35414c5b53c037a6a175118ed1a7d7e0e74153d56c4Chris Lattner // SHL_PARTS/SRA_PARTS/SRL_PARTS - These operators are used for expanded 35514c5b53c037a6a175118ed1a7d7e0e74153d56c4Chris Lattner // integer shift operations, just like ADD/SUB_PARTS. The operation 35614c5b53c037a6a175118ed1a7d7e0e74153d56c4Chris Lattner // ordering is: 3576b8f2d649c1e96e0222be9de1e5d6c79e3eef021Chris Lattner // [Lo,Hi] = op [LoLHS,HiLHS], Amt 35814c5b53c037a6a175118ed1a7d7e0e74153d56c4Chris Lattner SHL_PARTS, SRA_PARTS, SRL_PARTS, 35914c5b53c037a6a175118ed1a7d7e0e74153d56c4Chris Lattner 36063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // Conversion operators. These are all single input single output 36163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // operations. For all of these, the result type must be strictly 36263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // wider or narrower (depending on the operation) than the source 36363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // type. 36463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 36563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // SIGN_EXTEND - Used for integer types, replicating the sign bit 36663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // into new bits. 36763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SIGN_EXTEND, 36863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 36963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // ZERO_EXTEND - Used for integer types, zeroing the new bits. 37063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner ZERO_EXTEND, 37163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 3727e122db776d9731dfe5acb7faa9da4f3c33ee5a1Chris Lattner // ANY_EXTEND - Used for integer types. The high bits are undefined. 3737e122db776d9731dfe5acb7faa9da4f3c33ee5a1Chris Lattner ANY_EXTEND, 3747e122db776d9731dfe5acb7faa9da4f3c33ee5a1Chris Lattner 37563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // TRUNCATE - Completely drop the high bits. 37663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner TRUNCATE, 37763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 3781645ed0b93901ec678cd54024c8b09bca632b296Chris Lattner // [SU]INT_TO_FP - These operators convert integers (whose interpreted sign 3791645ed0b93901ec678cd54024c8b09bca632b296Chris Lattner // depends on the first letter) to floating point. 3801645ed0b93901ec678cd54024c8b09bca632b296Chris Lattner SINT_TO_FP, 3811645ed0b93901ec678cd54024c8b09bca632b296Chris Lattner UINT_TO_FP, 3821645ed0b93901ec678cd54024c8b09bca632b296Chris Lattner 383ea5761068956b157832d67bcc9d5e8ba706f545cChris Lattner // SIGN_EXTEND_INREG - This operator atomically performs a SHL/SRA pair to 384ea5761068956b157832d67bcc9d5e8ba706f545cChris Lattner // sign extend a small value in a large integer register (e.g. sign 385ea5761068956b157832d67bcc9d5e8ba706f545cChris Lattner // extending the low 8 bits of a 32-bit register to fill the top 24 bits 38615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner // with the 7th bit). The size of the smaller type is indicated by the 1th 38715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner // operand, a ValueType node. 388859157daee6a4b49e99921832e1dde065167b317Chris Lattner SIGN_EXTEND_INREG, 389859157daee6a4b49e99921832e1dde065167b317Chris Lattner 3900bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// FP_TO_[US]INT - Convert a floating point value to a signed or unsigned 3910bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// integer. 3921645ed0b93901ec678cd54024c8b09bca632b296Chris Lattner FP_TO_SINT, 3931645ed0b93901ec678cd54024c8b09bca632b296Chris Lattner FP_TO_UINT, 3941645ed0b93901ec678cd54024c8b09bca632b296Chris Lattner 3950bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// X = FP_ROUND(Y, TRUNC) - Rounding 'Y' from a larger floating point type 3960bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// down to the precision of the destination VT. TRUNC is a flag, which is 3970bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// always an integer that is zero or one. If TRUNC is 0, this is a 3980bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// normal rounding, if it is 1, this FP_ROUND is known to not change the 3990bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// value of Y. 4000bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// 4010bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// The TRUNC = 1 case is used in cases where we know that the value will 4020bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// not be modified by the node, because Y is not using any of the extra 4030bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// precision of source type. This allows certain transformations like 4040bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// FP_EXTEND(FP_ROUND(X,1)) -> X which are not safe for 4050bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// FP_EXTEND(FP_ROUND(X,0)) because the extra bits aren't removed. 40663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner FP_ROUND, 4070bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner 4081a0248690aaa9f7baaf1247e5f65a1c0c9e3783cDan Gohman // FLT_ROUNDS_ - Returns current rounding mode: 409917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov // -1 Undefined 410917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov // 0 Round to 0 411917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov // 1 Round to nearest 412917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov // 2 Round to +inf 413917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov // 3 Round to -inf 4141a0248690aaa9f7baaf1247e5f65a1c0c9e3783cDan Gohman FLT_ROUNDS_, 415917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov 4160bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// X = FP_ROUND_INREG(Y, VT) - This operator takes an FP register, and 4170bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// rounds it to a floating point value. It then promotes it and returns it 4180bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// in a register of the same size. This operation effectively just 4190bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// discards excess precision. The type to round down to is specified by 4200bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// the VT operand, a VTSDNode. 421859157daee6a4b49e99921832e1dde065167b317Chris Lattner FP_ROUND_INREG, 422859157daee6a4b49e99921832e1dde065167b317Chris Lattner 4230bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner /// X = FP_EXTEND(Y) - Extend a smaller FP type into a larger FP type. 42463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner FP_EXTEND, 42563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 4261ac1c4b9d2877bd2d15bcf578bc617a605d815b0Chris Lattner // BIT_CONVERT - Theis operator converts between integer and FP values, as 4271ac1c4b9d2877bd2d15bcf578bc617a605d815b0Chris Lattner // if one was stored to memory as integer and the other was loaded from the 42880f55abf009c86bc03821e10746832f88f8a735fChris Lattner // same address (or equivalently for vector format conversions, etc). The 42980f55abf009c86bc03821e10746832f88f8a735fChris Lattner // source and result are required to have the same bit size (e.g. 43080f55abf009c86bc03821e10746832f88f8a735fChris Lattner // f32 <-> i32). This can also be used for int-to-int or fp-to-fp 43180f55abf009c86bc03821e10746832f88f8a735fChris Lattner // conversions, but that is a noop, deleted by getNode(). 4321ac1c4b9d2877bd2d15bcf578bc617a605d815b0Chris Lattner BIT_CONVERT, 4331ac1c4b9d2877bd2d15bcf578bc617a605d815b0Chris Lattner 43407f04fd574a59c690f297fd10c2e0dd14093675eDan Gohman // FNEG, FABS, FSQRT, FSIN, FCOS, FPOWI, FPOW - Perform unary floating point 43507f04fd574a59c690f297fd10c2e0dd14093675eDan Gohman // negation, absolute value, square root, sine and cosine, powi, and pow 436dd2afb0e1f65bc41d2c0053468fcddfd696a8231Chris Lattner // operations. 43707f04fd574a59c690f297fd10c2e0dd14093675eDan Gohman FNEG, FABS, FSQRT, FSIN, FCOS, FPOWI, FPOW, 43838bf3bffe3abfd00169d6dcf4fad7e2197808dbfChris Lattner 4398862ef148100070b7bf28beead3951464250c926Evan Cheng // LOAD and STORE have token chains as their first operand, then the same 4408862ef148100070b7bf28beead3951464250c926Evan Cheng // operands as an LLVM load/store instruction, then an offset node that 4418862ef148100070b7bf28beead3951464250c926Evan Cheng // is added / subtracted from the base pointer to form the address (for 4428862ef148100070b7bf28beead3951464250c926Evan Cheng // indexed memory ops). 44363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner LOAD, STORE, 4445fbb5d2459a5410590f285250faa604576308a93Nate Begeman 44563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // DYNAMIC_STACKALLOC - Allocate some number of bytes on the stack aligned 44657fc00d5cf47343ba762493b8781ca0b14489c35Anton Korobeynikov // to a specified boundary. This node always has two return values: a new 44757fc00d5cf47343ba762493b8781ca0b14489c35Anton Korobeynikov // stack pointer value and a chain. The first operand is the token chain, 44857fc00d5cf47343ba762493b8781ca0b14489c35Anton Korobeynikov // the second is the number of bytes to allocate, and the third is the 44957fc00d5cf47343ba762493b8781ca0b14489c35Anton Korobeynikov // alignment boundary. The size is guaranteed to be a multiple of the stack 45057fc00d5cf47343ba762493b8781ca0b14489c35Anton Korobeynikov // alignment, and the alignment is guaranteed to be bigger than the stack 45174fe063e90045931eefaba561730e6a9175ced78Chris Lattner // alignment (if required) or 0 to get standard stack alignment. 45263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner DYNAMIC_STACKALLOC, 45363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 45463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // Control flow instructions. These all have token chains. 455ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman 45663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // BR - Unconditional branch. The first operand is the chain 45763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // operand, the second is the MBB to branch to. 45863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner BR, 45963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 46037efe6764568a3829fee26aba532283131d1a104Nate Begeman // BRIND - Indirect branch. The first operand is the chain, the second 46137efe6764568a3829fee26aba532283131d1a104Nate Begeman // is the value to branch to, which must be of the same type as the target's 46237efe6764568a3829fee26aba532283131d1a104Nate Begeman // pointer type. 46337efe6764568a3829fee26aba532283131d1a104Nate Begeman BRIND, 464c41cd9c391f1f69adf416145a5a1308d7ce342fcEvan Cheng 465c41cd9c391f1f69adf416145a5a1308d7ce342fcEvan Cheng // BR_JT - Jumptable branch. The first operand is the chain, the second 466c41cd9c391f1f69adf416145a5a1308d7ce342fcEvan Cheng // is the jumptable index, the last one is the jumptable entry index. 467c41cd9c391f1f69adf416145a5a1308d7ce342fcEvan Cheng BR_JT, 46837efe6764568a3829fee26aba532283131d1a104Nate Begeman 46963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // BRCOND - Conditional branch. The first operand is the chain, 47063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // the second is the condition, the third is the block to branch 47163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // to if the condition is true. 47263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner BRCOND, 47363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 4747cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // BR_CC - Conditional branch. The behavior is like that of SELECT_CC, in 4757cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // that the condition is represented as condition code, and two nodes to 4767cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // compare, rather than as a combined SetCC node. The operands in order are 4777cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman // chain, cc, lhs, rhs, block to branch to if condition is true. 4787cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman BR_CC, 4797cbd525ba85ebe440d15fa359ec940e404d14906Nate Begeman 48063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // RET - Return from function. The first operand is the chain, 4818e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng // and any subsequent operands are pairs of return value and return value 4828e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng // signness for the function. This operation can have variable number of 4838e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng // operands. 48463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner RET, 48563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 4867572eb81eee93b0c666ddc5f5ff0ff72f17574fdChris Lattner // INLINEASM - Represents an inline asm block. This node always has two 4877572eb81eee93b0c666ddc5f5ff0ff72f17574fdChris Lattner // return values: a chain and a flag result. The inputs are as follows: 4887572eb81eee93b0c666ddc5f5ff0ff72f17574fdChris Lattner // Operand #0 : Input chain. 4897572eb81eee93b0c666ddc5f5ff0ff72f17574fdChris Lattner // Operand #1 : a ExternalSymbolSDNode with a pointer to the asm string. 4907572eb81eee93b0c666ddc5f5ff0ff72f17574fdChris Lattner // Operand #2n+2: A RegisterNode. 4917572eb81eee93b0c666ddc5f5ff0ff72f17574fdChris Lattner // Operand #2n+3: A TargetConstant, indicating if the reg is a use/def 4927572eb81eee93b0c666ddc5f5ff0ff72f17574fdChris Lattner // Operand #last: Optional, an incoming flag. 4937572eb81eee93b0c666ddc5f5ff0ff72f17574fdChris Lattner INLINEASM, 4941ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey 4951ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey // LABEL - Represents a label in mid basic block used to track 4961ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey // locations needed for debug and exception handling tables. This node 4971ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey // returns a chain. 4981ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey // Operand #0 : input chain. 4991ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey // Operand #1 : module unique number use to identify the label. 500bb81d97feb396a8bb21d074db1c57e9f66525f40Evan Cheng // Operand #2 : 0 indicates a debug label (e.g. stoppoint), 1 indicates 501bb81d97feb396a8bb21d074db1c57e9f66525f40Evan Cheng // a EH label, 2 indicates unknown label type. 5021ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey LABEL, 503a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng 504a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng // DECLARE - Represents a llvm.dbg.declare intrinsic. It's used to track 505a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng // local variable declarations for debugging information. First operand is 506a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng // a chain, while the next two operands are first two arguments (address 507a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng // and variable) of a llvm.dbg.declare instruction. 508a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng DECLARE, 509f09f2e304dc82010d2e02a9b40a8c5fb0091490cJim Laskey 5105a67afc118d47a0061ca9809c763451ea3125306Chris Lattner // STACKSAVE - STACKSAVE has one operand, an input chain. It produces a 5115a67afc118d47a0061ca9809c763451ea3125306Chris Lattner // value, the same type as the pointer type for the system, and an output 5125a67afc118d47a0061ca9809c763451ea3125306Chris Lattner // chain. 5135a67afc118d47a0061ca9809c763451ea3125306Chris Lattner STACKSAVE, 5145a67afc118d47a0061ca9809c763451ea3125306Chris Lattner 5155a67afc118d47a0061ca9809c763451ea3125306Chris Lattner // STACKRESTORE has two operands, an input chain and a pointer to restore to 5165a67afc118d47a0061ca9809c763451ea3125306Chris Lattner // it returns an output chain. 5175a67afc118d47a0061ca9809c763451ea3125306Chris Lattner STACKRESTORE, 5185a67afc118d47a0061ca9809c763451ea3125306Chris Lattner 5195c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola // MEMSET/MEMCPY/MEMMOVE - The first operand is the chain. The following 5205c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola // correspond to the operands of the LLVM intrinsic functions and the last 5215c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola // one is AlwaysInline. The only result is a token chain. The alignment 5225c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola // argument is guaranteed to be a Constant node. 523ef36aa75d7df2bb67e8bfb0da7c43c1b331611e4Chris Lattner MEMSET, 524ef36aa75d7df2bb67e8bfb0da7c43c1b331611e4Chris Lattner MEMMOVE, 525ef36aa75d7df2bb67e8bfb0da7c43c1b331611e4Chris Lattner MEMCPY, 526ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman 52716cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // CALLSEQ_START/CALLSEQ_END - These operators mark the beginning and end of 52816cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // a call sequence, and carry arbitrary information that target might want 52916cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // to know. The first operand is a chain, the rest are specified by the 53016cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner // target and not touched by the DAG optimizers. 53116cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner CALLSEQ_START, // Beginning of a call sequence 53216cd04d26c53c6f81313cafb85f6c0e7a07cdff6Chris Lattner CALLSEQ_END, // End of a call sequence 533acc398c195a697795bff3245943d104eb19192b9Nate Begeman 534acc398c195a697795bff3245943d104eb19192b9Nate Begeman // VAARG - VAARG has three operands: an input chain, a pointer, and a 535acc398c195a697795bff3245943d104eb19192b9Nate Begeman // SRCVALUE. It returns a pair of values: the vaarg value and a new chain. 536acc398c195a697795bff3245943d104eb19192b9Nate Begeman VAARG, 537acc398c195a697795bff3245943d104eb19192b9Nate Begeman 538acc398c195a697795bff3245943d104eb19192b9Nate Begeman // VACOPY - VACOPY has five operands: an input chain, a destination pointer, 539acc398c195a697795bff3245943d104eb19192b9Nate Begeman // a source pointer, a SRCVALUE for the destination, and a SRCVALUE for the 540acc398c195a697795bff3245943d104eb19192b9Nate Begeman // source. 541acc398c195a697795bff3245943d104eb19192b9Nate Begeman VACOPY, 542acc398c195a697795bff3245943d104eb19192b9Nate Begeman 543acc398c195a697795bff3245943d104eb19192b9Nate Begeman // VAEND, VASTART - VAEND and VASTART have three operands: an input chain, a 544acc398c195a697795bff3245943d104eb19192b9Nate Begeman // pointer, and a SRCVALUE. 545acc398c195a697795bff3245943d104eb19192b9Nate Begeman VAEND, VASTART, 54663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 54769de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman // SRCVALUE - This is a node type that holds a Value* that is used to 54869de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman // make reference to a value in the LLVM IR. 54921074f43ed5165828717ea3606eb2bd222a39b26Chris Lattner SRCVALUE, 55021074f43ed5165828717ea3606eb2bd222a39b26Chris Lattner 55169de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman // MEMOPERAND - This is a node that contains a MemOperand which records 55269de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman // information about a memory reference. This is used to make AliasAnalysis 55369de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman // queries from the backend. 55469de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman MEMOPERAND, 55569de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman 556e3f570c3f9048bc71a9f5841343eae63719e439bMisha Brukman // PCMARKER - This corresponds to the pcmarker intrinsic. 55795762124a1d781cc0f8cbc4c22e9c5c1358d7ea0Andrew Lenharth PCMARKER, 55863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 559aeef8fc5c6124a34bd2a723071a3982b559c26f2Andrew Lenharth // READCYCLECOUNTER - This corresponds to the readcyclecounter intrinsic. 5608b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth // The only operand is a chain and a value and a chain are produced. The 5618b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth // value is the contents of the architecture specific cycle counter like 5628b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth // register (or other high accuracy low latency clock source) 563aeef8fc5c6124a34bd2a723071a3982b559c26f2Andrew Lenharth READCYCLECOUNTER, 564aeef8fc5c6124a34bd2a723071a3982b559c26f2Andrew Lenharth 565d623e953fc5f46b013994dfa4651cff4d17af159Chris Lattner // HANDLENODE node - Used as a handle for various purposes. 566d623e953fc5f46b013994dfa4651cff4d17af159Chris Lattner HANDLENODE, 5672d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 56847725d059b259f8a0c145478300c9e9caa006b59Chris Lattner // LOCATION - This node is used to represent a source location for debug 56947725d059b259f8a0c145478300c9e9caa006b59Chris Lattner // info. It takes token chain as input, then a line number, then a column 57047725d059b259f8a0c145478300c9e9caa006b59Chris Lattner // number, then a filename, then a working dir. It produces a token chain 57147725d059b259f8a0c145478300c9e9caa006b59Chris Lattner // as output. 57247725d059b259f8a0c145478300c9e9caa006b59Chris Lattner LOCATION, 57347725d059b259f8a0c145478300c9e9caa006b59Chris Lattner 574f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey // DEBUG_LOC - This node is used to represent source line information 575abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey // embedded in the code. It takes a token chain as input, then a line 57644c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey // number, then a column then a file id (provided by MachineModuleInfo.) It 577abf6d1784b2d4bbcb7d20ab64881f77d755059f6Jim Laskey // produces a token chain as output. 578f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey DEBUG_LOC, 57936397f50343639ce9a25996f2d790c656791ab92Duncan Sands 58036397f50343639ce9a25996f2d790c656791ab92Duncan Sands // TRAMPOLINE - This corresponds to the init_trampoline intrinsic. 58136397f50343639ce9a25996f2d790c656791ab92Duncan Sands // It takes as input a token chain, the pointer to the trampoline, 58236397f50343639ce9a25996f2d790c656791ab92Duncan Sands // the pointer to the nested function, the pointer to pass for the 58336397f50343639ce9a25996f2d790c656791ab92Duncan Sands // 'nest' parameter, a SRCVALUE for the trampoline and another for 58436397f50343639ce9a25996f2d790c656791ab92Duncan Sands // the nested function (allowing targets to access the original 585f7331b3dd72409e644833ecaf62a0f6db03c97eeDuncan Sands // Function*). It produces the result of the intrinsic and a token 586f7331b3dd72409e644833ecaf62a0f6db03c97eeDuncan Sands // chain as output. 58736397f50343639ce9a25996f2d790c656791ab92Duncan Sands TRAMPOLINE, 58836397f50343639ce9a25996f2d790c656791ab92Duncan Sands 58966fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov // TRAP - Trapping instruction 59066fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov TRAP, 59166fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov 59222c5c1b2dfcb1da6a7ebfebea903401fc77d56e6Andrew Lenharth // OUTCHAIN = MEMBARRIER(INCHAIN, load-load, load-store, store-load, 59322c5c1b2dfcb1da6a7ebfebea903401fc77d56e6Andrew Lenharth // store-store, device) 59422c5c1b2dfcb1da6a7ebfebea903401fc77d56e6Andrew Lenharth // This corresponds to the atomic.barrier intrinsic. 59522c5c1b2dfcb1da6a7ebfebea903401fc77d56e6Andrew Lenharth // it takes an input chain, 4 operands to specify the type of barrier, an 59622c5c1b2dfcb1da6a7ebfebea903401fc77d56e6Andrew Lenharth // operand specifying if the barrier applies to device and uncached memory 59722c5c1b2dfcb1da6a7ebfebea903401fc77d56e6Andrew Lenharth // and produces an output chain. 59822c5c1b2dfcb1da6a7ebfebea903401fc77d56e6Andrew Lenharth MEMBARRIER, 59922c5c1b2dfcb1da6a7ebfebea903401fc77d56e6Andrew Lenharth 60063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // BUILTIN_OP_END - This must be the last enum value in this list. 601410354fe0c052141dadeca939395743f8dd58e38Chris Lattner BUILTIN_OP_END 60263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner }; 60363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 604322dcd379eb19ea8d01478a661920ea1ce62fa0dChris Lattner /// Node predicates 605322dcd379eb19ea8d01478a661920ea1ce62fa0dChris Lattner 606a8df166fbef047c90adba3c673162a1b1f6681c4Evan Cheng /// isBuildVectorAllOnes - Return true if the specified node is a 607322dcd379eb19ea8d01478a661920ea1ce62fa0dChris Lattner /// BUILD_VECTOR where all of the elements are ~0 or undef. 608a8df166fbef047c90adba3c673162a1b1f6681c4Evan Cheng bool isBuildVectorAllOnes(const SDNode *N); 6094a147842eb24a7611fcd7bfb37c55185b4664927Evan Cheng 6104a147842eb24a7611fcd7bfb37c55185b4664927Evan Cheng /// isBuildVectorAllZeros - Return true if the specified node is a 6114a147842eb24a7611fcd7bfb37c55185b4664927Evan Cheng /// BUILD_VECTOR where all of the elements are 0 or undef. 6124a147842eb24a7611fcd7bfb37c55185b4664927Evan Cheng bool isBuildVectorAllZeros(const SDNode *N); 613bb81d97feb396a8bb21d074db1c57e9f66525f40Evan Cheng 614efec751a1b786724862ceff52748df94873a807eEvan Cheng /// isScalarToVector - Return true if the specified node is a 615efec751a1b786724862ceff52748df94873a807eEvan Cheng /// ISD::SCALAR_TO_VECTOR node or a BUILD_VECTOR node where only the low 616efec751a1b786724862ceff52748df94873a807eEvan Cheng /// element is not an undef. 617efec751a1b786724862ceff52748df94873a807eEvan Cheng bool isScalarToVector(const SDNode *N); 618efec751a1b786724862ceff52748df94873a807eEvan Cheng 619bb81d97feb396a8bb21d074db1c57e9f66525f40Evan Cheng /// isDebugLabel - Return true if the specified node represents a debug 620fc718542a3e73558af9c0272b0eea67a189e5397Evan Cheng /// label (i.e. ISD::LABEL or TargetInstrInfo::LABEL node and third operand 621bb81d97feb396a8bb21d074db1c57e9f66525f40Evan Cheng /// is 0). 622bb81d97feb396a8bb21d074db1c57e9f66525f40Evan Cheng bool isDebugLabel(const SDNode *N); 623322dcd379eb19ea8d01478a661920ea1ce62fa0dChris Lattner 62463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner //===--------------------------------------------------------------------===// 625144d8f09e139f691cafadbc17873943ba4c465f3Evan Cheng /// MemIndexedMode enum - This enum defines the load / store indexed 626144d8f09e139f691cafadbc17873943ba4c465f3Evan Cheng /// addressing modes. 62724446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// 62824446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// UNINDEXED "Normal" load / store. The effective address is already 62924446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// computed and is available in the base pointer. The offset 63081c384578828dde08f63a4f030f4860a92391cddEvan Cheng /// operand is always undefined. In addition to producing a 63181c384578828dde08f63a4f030f4860a92391cddEvan Cheng /// chain, an unindexed load produces one value (result of the 63281c384578828dde08f63a4f030f4860a92391cddEvan Cheng /// load); an unindexed store does not produces a value. 63324446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// 63435acd30a2e96a5a4ad9fa837971af2cc583bcd1fEvan Cheng /// PRE_INC Similar to the unindexed mode where the effective address is 6358862ef148100070b7bf28beead3951464250c926Evan Cheng /// PRE_DEC the value of the base pointer add / subtract the offset. 6368862ef148100070b7bf28beead3951464250c926Evan Cheng /// It considers the computation as being folded into the load / 63724446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// store operation (i.e. the load / store does the address 63824446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// computation as well as performing the memory transaction). 63981c384578828dde08f63a4f030f4860a92391cddEvan Cheng /// The base operand is always undefined. In addition to 64081c384578828dde08f63a4f030f4860a92391cddEvan Cheng /// producing a chain, pre-indexed load produces two values 64181c384578828dde08f63a4f030f4860a92391cddEvan Cheng /// (result of the load and the result of the address 64281c384578828dde08f63a4f030f4860a92391cddEvan Cheng /// computation); a pre-indexed store produces one value (result 64381c384578828dde08f63a4f030f4860a92391cddEvan Cheng /// of the address computation). 64424446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// 64535acd30a2e96a5a4ad9fa837971af2cc583bcd1fEvan Cheng /// POST_INC The effective address is the value of the base pointer. The 6468862ef148100070b7bf28beead3951464250c926Evan Cheng /// POST_DEC value of the offset operand is then added to / subtracted 6478862ef148100070b7bf28beead3951464250c926Evan Cheng /// from the base after memory transaction. In addition to 6488862ef148100070b7bf28beead3951464250c926Evan Cheng /// producing a chain, post-indexed load produces two values 6498862ef148100070b7bf28beead3951464250c926Evan Cheng /// (the result of the load and the result of the base +/- offset 6508862ef148100070b7bf28beead3951464250c926Evan Cheng /// computation); a post-indexed store produces one value (the 6518862ef148100070b7bf28beead3951464250c926Evan Cheng /// the result of the base +/- offset computation). 65224446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// 653144d8f09e139f691cafadbc17873943ba4c465f3Evan Cheng enum MemIndexedMode { 65424446e253a17720f6462288255ab5ebd13b8491fEvan Cheng UNINDEXED = 0, 65535acd30a2e96a5a4ad9fa837971af2cc583bcd1fEvan Cheng PRE_INC, 65635acd30a2e96a5a4ad9fa837971af2cc583bcd1fEvan Cheng PRE_DEC, 65735acd30a2e96a5a4ad9fa837971af2cc583bcd1fEvan Cheng POST_INC, 658144d8f09e139f691cafadbc17873943ba4c465f3Evan Cheng POST_DEC, 659144d8f09e139f691cafadbc17873943ba4c465f3Evan Cheng LAST_INDEXED_MODE 66024446e253a17720f6462288255ab5ebd13b8491fEvan Cheng }; 66124446e253a17720f6462288255ab5ebd13b8491fEvan Cheng 66224446e253a17720f6462288255ab5ebd13b8491fEvan Cheng //===--------------------------------------------------------------------===// 663c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng /// LoadExtType enum - This enum defines the three variants of LOADEXT 664c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng /// (load with extension). 665c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng /// 66624446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// SEXTLOAD loads the integer operand and sign extends it to a larger 66724446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// integer result type. 66824446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// ZEXTLOAD loads the integer operand and zero extends it to a larger 66924446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// integer result type. 67024446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// EXTLOAD is used for three things: floating point extending loads, 67124446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// integer extending loads [the top bits are undefined], and vector 67224446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// extending loads [load into low elt]. 67324446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// 674c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng enum LoadExtType { 67524446e253a17720f6462288255ab5ebd13b8491fEvan Cheng NON_EXTLOAD = 0, 676c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng EXTLOAD, 677c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng SEXTLOAD, 678c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng ZEXTLOAD, 679c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng LAST_LOADX_TYPE 680c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng }; 681c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng 682c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng //===--------------------------------------------------------------------===// 68363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// ISD::CondCode enum - These are ordered carefully to make the bitfields 68463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// below work out, when considering SETFALSE (something that never exists 68563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// dynamically) as 0. "U" -> Unsigned (for integer operands) or Unordered 68663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// (for floating point), "L" -> Less than, "G" -> Greater than, "E" -> Equal 68763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// to. If the "N" column is 1, the result of the comparison is undefined if 68863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// the input is a NAN. 68963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// 69063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// All of these (except for the 'always folded ops') should be handled for 69163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// floating point. For integer, only the SETEQ,SETNE,SETLT,SETLE,SETGT, 69263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// SETGE,SETULT,SETULE,SETUGT, and SETUGE opcodes are used. 69363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// 69463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// Note that these are laid out in a specific order to allow bit-twiddling 69563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// to transform conditions. 69663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner enum CondCode { 69763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // Opcode N U L G E Intuitive operation 69863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETFALSE, // 0 0 0 0 Always false (always folded) 69963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETOEQ, // 0 0 0 1 True if ordered and equal 70063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETOGT, // 0 0 1 0 True if ordered and greater than 70163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETOGE, // 0 0 1 1 True if ordered and greater than or equal 70263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETOLT, // 0 1 0 0 True if ordered and less than 70363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETOLE, // 0 1 0 1 True if ordered and less than or equal 70463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETONE, // 0 1 1 0 True if ordered and operands are unequal 70563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETO, // 0 1 1 1 True if ordered (no nans) 70663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETUO, // 1 0 0 0 True if unordered: isnan(X) | isnan(Y) 70763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETUEQ, // 1 0 0 1 True if unordered or equal 70863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETUGT, // 1 0 1 0 True if unordered or greater than 70963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETUGE, // 1 0 1 1 True if unordered, greater than, or equal 71063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETULT, // 1 1 0 0 True if unordered or less than 711ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman SETULE, // 1 1 0 1 True if unordered, less than, or equal 71263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETUNE, // 1 1 1 0 True if unordered or not equal 71363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETTRUE, // 1 1 1 1 Always true (always folded) 71463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // Don't care operations: undefined if the input is a nan. 71563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETFALSE2, // 1 X 0 0 0 Always false (always folded) 71663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETEQ, // 1 X 0 0 1 True if equal 71763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETGT, // 1 X 0 1 0 True if greater than 71863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETGE, // 1 X 0 1 1 True if greater than or equal 71963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETLT, // 1 X 1 0 0 True if less than 720ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman SETLE, // 1 X 1 0 1 True if less than or equal 72163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETNE, // 1 X 1 1 0 True if not equal 72263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SETTRUE2, // 1 X 1 1 1 Always true (always folded) 72363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 724410354fe0c052141dadeca939395743f8dd58e38Chris Lattner SETCC_INVALID // Marker value. 72563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner }; 72663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 72763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// isSignedIntSetCC - Return true if this is a setcc instruction that 72863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// performs a signed comparison when used with integer operands. 72963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner inline bool isSignedIntSetCC(CondCode Code) { 73063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner return Code == SETGT || Code == SETGE || Code == SETLT || Code == SETLE; 73163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 73263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 73363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// isUnsignedIntSetCC - Return true if this is a setcc instruction that 73463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// performs an unsigned comparison when used with integer operands. 73563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner inline bool isUnsignedIntSetCC(CondCode Code) { 73663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner return Code == SETUGT || Code == SETUGE || Code == SETULT || Code == SETULE; 73763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 73863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 73963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// isTrueWhenEqual - Return true if the specified condition returns true if 74063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// the two operands to the condition are equal. Note that if one of the two 74163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// operands is a NaN, this value is meaningless. 74263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner inline bool isTrueWhenEqual(CondCode Cond) { 74363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner return ((int)Cond & 1) != 0; 74463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 74563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 74663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// getUnorderedFlavor - This function returns 0 if the condition is always 74763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// false if an operand is a NaN, 1 if the condition is always true if the 74863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// operand is a NaN, and 2 if the condition is undefined if the operand is a 74963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// NaN. 75063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner inline unsigned getUnorderedFlavor(CondCode Cond) { 75163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner return ((int)Cond >> 3) & 3; 75263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 75363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 75463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// getSetCCInverse - Return the operation corresponding to !(X op Y), where 75563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// 'op' is a valid SetCC operation. 75663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner CondCode getSetCCInverse(CondCode Operation, bool isInteger); 75763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 75863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// getSetCCSwappedOperands - Return the operation corresponding to (Y op X) 75963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// when given the operation for (X op Y). 76063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner CondCode getSetCCSwappedOperands(CondCode Operation); 76163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 76263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// getSetCCOrOperation - Return the result of a logical OR between different 76363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// comparisons of identical values: ((X op1 Y) | (X op2 Y)). This 76463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// function returns SETCC_INVALID if it is not possible to represent the 76563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// resultant comparison. 76663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner CondCode getSetCCOrOperation(CondCode Op1, CondCode Op2, bool isInteger); 76763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 76863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// getSetCCAndOperation - Return the result of a logical AND between 76963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// different comparisons of identical values: ((X op1 Y) & (X op2 Y)). This 77063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// function returns SETCC_INVALID if it is not possible to represent the 77163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// resultant comparison. 77263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner CondCode getSetCCAndOperation(CondCode Op1, CondCode Op2, bool isInteger); 77363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner} // end llvm::ISD namespace 77463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 77563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 77663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner//===----------------------------------------------------------------------===// 77763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// SDOperand - Unlike LLVM values, Selection DAG nodes may return multiple 77863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// values as the result of a computation. Many nodes return multiple values, 77963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// from loads (which define a token and a return value) to ADDC (which returns 78063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// a result and a carry value), to calls (which may return an arbitrary number 78163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// of values). 78263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// 78363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// As such, each use of a SelectionDAG computation must indicate the node that 78463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// computes it as well as which return value to use from that node. This pair 78563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// of information is represented with the SDOperand value type. 78663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// 787f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattnerclass SDOperand { 788f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattnerpublic: 78963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SDNode *Val; // The node defining the value we are using. 79063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner unsigned ResNo; // Which return value of the node we are using. 79163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 792ace44dbbabe9ee0498834957632df2af0dbf9c59Reid Spencer SDOperand() : Val(0), ResNo(0) {} 79363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SDOperand(SDNode *val, unsigned resno) : Val(val), ResNo(resno) {} 79463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 79563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner bool operator==(const SDOperand &O) const { 79663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner return Val == O.Val && ResNo == O.ResNo; 79763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 79863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner bool operator!=(const SDOperand &O) const { 79963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner return !operator==(O); 80063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 80163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner bool operator<(const SDOperand &O) const { 80263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner return Val < O.Val || (Val == O.Val && ResNo < O.ResNo); 80363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 80463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 80563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner SDOperand getValue(unsigned R) const { 80663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner return SDOperand(Val, R); 80763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 80863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 809bfa284f69752c54f81bffc2b0d15d5c1e618a659Evan Cheng // isOperand - Return true if this node is an operand of N. 810bfa284f69752c54f81bffc2b0d15d5c1e618a659Evan Cheng bool isOperand(SDNode *N) const; 811bfa284f69752c54f81bffc2b0d15d5c1e618a659Evan Cheng 81263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// getValueType - Return the ValueType of the referenced return value. 81363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// 81463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner inline MVT::ValueType getValueType() const; 815ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman 81663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // Forwarding methods - These forward to the corresponding methods in SDNode. 81763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner inline unsigned getOpcode() const; 81863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner inline unsigned getNumOperands() const; 81963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner inline const SDOperand &getOperand(unsigned i) const; 820c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng inline uint64_t getConstantOperandVal(unsigned i) const; 8210f66a9172175aa7c3055333358170581c999219bNate Begeman inline bool isTargetOpcode() const; 8220f66a9172175aa7c3055333358170581c999219bNate Begeman inline unsigned getTargetOpcode() const; 823a44f4aeca77c6c1627568fe68e92af9c7e33dc7eChris Lattner 824572dee71af1313e6742e1dfd5274fff326b9ef1cChris Lattner 825572dee71af1313e6742e1dfd5274fff326b9ef1cChris Lattner /// reachesChainWithoutSideEffects - Return true if this operand (which must 826572dee71af1313e6742e1dfd5274fff326b9ef1cChris Lattner /// be a chain) reaches the specified operand without crossing any 827572dee71af1313e6742e1dfd5274fff326b9ef1cChris Lattner /// side-effecting instructions. In practice, this looks through token 828572dee71af1313e6742e1dfd5274fff326b9ef1cChris Lattner /// factors and non-volatile loads. In order to remain efficient, this only 829572dee71af1313e6742e1dfd5274fff326b9ef1cChris Lattner /// looks a couple of nodes in, it does not do an exhaustive search. 830572dee71af1313e6742e1dfd5274fff326b9ef1cChris Lattner bool reachesChainWithoutSideEffects(SDOperand Dest, unsigned Depth = 2) const; 831572dee71af1313e6742e1dfd5274fff326b9ef1cChris Lattner 832a44f4aeca77c6c1627568fe68e92af9c7e33dc7eChris Lattner /// hasOneUse - Return true if there is exactly one operation using this 833a44f4aeca77c6c1627568fe68e92af9c7e33dc7eChris Lattner /// result value of the defining operator. 834a44f4aeca77c6c1627568fe68e92af9c7e33dc7eChris Lattner inline bool hasOneUse() const; 835e1b50639a860934685dff840e1826b16dbe6a344Dan Gohman 836e1b50639a860934685dff840e1826b16dbe6a344Dan Gohman /// use_empty - Return true if there are no operations using this 837e1b50639a860934685dff840e1826b16dbe6a344Dan Gohman /// result value of the defining operator. 838e1b50639a860934685dff840e1826b16dbe6a344Dan Gohman inline bool use_empty() const; 83963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 84063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 84163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 84276c1b97e4020faace8c95a127f1eab66c278fb58Chris Lattnertemplate<> struct DenseMapInfo<SDOperand> { 843c63d391c9a886d58c6a53a7f565fbd544b076d9fEvan Cheng static inline SDOperand getEmptyKey() { return SDOperand((SDNode*)-1, -1U); } 844c63d391c9a886d58c6a53a7f565fbd544b076d9fEvan Cheng static inline SDOperand getTombstoneKey() { return SDOperand((SDNode*)-1, 0);} 845c63d391c9a886d58c6a53a7f565fbd544b076d9fEvan Cheng static unsigned getHashValue(const SDOperand &Val) { 846c63d391c9a886d58c6a53a7f565fbd544b076d9fEvan Cheng return (unsigned)((uintptr_t)Val.Val >> 4) ^ 847c63d391c9a886d58c6a53a7f565fbd544b076d9fEvan Cheng (unsigned)((uintptr_t)Val.Val >> 9) + Val.ResNo; 848c63d391c9a886d58c6a53a7f565fbd544b076d9fEvan Cheng } 84976c1b97e4020faace8c95a127f1eab66c278fb58Chris Lattner static bool isEqual(const SDOperand &LHS, const SDOperand &RHS) { 85076c1b97e4020faace8c95a127f1eab66c278fb58Chris Lattner return LHS == RHS; 85176c1b97e4020faace8c95a127f1eab66c278fb58Chris Lattner } 852c63d391c9a886d58c6a53a7f565fbd544b076d9fEvan Cheng static bool isPod() { return true; } 853c63d391c9a886d58c6a53a7f565fbd544b076d9fEvan Cheng}; 854c63d391c9a886d58c6a53a7f565fbd544b076d9fEvan Cheng 85563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// simplify_type specializations - Allow casting operators to work directly on 85663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// SDOperands as if they were SDNode*'s. 85763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnertemplate<> struct simplify_type<SDOperand> { 85863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner typedef SDNode* SimpleType; 85963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static SimpleType getSimplifiedValue(const SDOperand &Val) { 86063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner return static_cast<SimpleType>(Val.Val); 86163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 86263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 86363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnertemplate<> struct simplify_type<const SDOperand> { 86463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner typedef SDNode* SimpleType; 86563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static SimpleType getSimplifiedValue(const SDOperand &Val) { 86663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner return static_cast<SimpleType>(Val.Val); 86763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 86863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 86963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 87063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 87163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// SDNode - Represents one node in the SelectionDAG. 87263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner/// 873583bd47f777fe3eb8305872fa0eadab31e833dffJim Laskeyclass SDNode : public FoldingSetNode { 8740442fbfadbeea21eee9df88dc466d95e040dde6bChris Lattner /// NodeType - The operation that this node performs. 8750442fbfadbeea21eee9df88dc466d95e040dde6bChris Lattner /// 8760442fbfadbeea21eee9df88dc466d95e040dde6bChris Lattner unsigned short NodeType; 87763e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner 87863e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner /// OperandsNeedDelete - This is true if OperandList was new[]'d. If true, 87963e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner /// then they will be delete[]'d when the node is destroyed. 88063e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner bool OperandsNeedDelete : 1; 8810442fbfadbeea21eee9df88dc466d95e040dde6bChris Lattner 882b9ee9e60a905b90fa3e84c5c6091af6e5a0382d2Evan Cheng /// NodeId - Unique id per SDNode in the DAG. 883b9ee9e60a905b90fa3e84c5c6091af6e5a0382d2Evan Cheng int NodeId; 8840442fbfadbeea21eee9df88dc466d95e040dde6bChris Lattner 885f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner /// OperandList - The values that are used by this operation. 8860442fbfadbeea21eee9df88dc466d95e040dde6bChris Lattner /// 887f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner SDOperand *OperandList; 888f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner 889f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner /// ValueList - The types of the values this node defines. SDNode's may 890f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner /// define multiple values simultaneously. 8912fa6d3b1fcadbde90eaee0e8e89aebd81630b662Chris Lattner const MVT::ValueType *ValueList; 89263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 893f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner /// NumOperands/NumValues - The number of entries in the Operand/Value list. 894f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner unsigned short NumOperands, NumValues; 895b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner 896b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner /// Prev/Next pointers - These pointers form the linked list of of the 897b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner /// AllNodes list in the current DAG. 898b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner SDNode *Prev, *Next; 899b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner friend struct ilist_traits<SDNode>; 90063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 90163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// Uses - These are all of the SDNode's that use a value produced by this 90263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// node. 9035892d47a625638a90afeb31dd4f6f80a2f9bacdeChris Lattner SmallVector<SDNode*,3> Uses; 904917d2c9dc2cc8879ed97533e7f75f3f92fa26b61Chris Lattner 905917d2c9dc2cc8879ed97533e7f75f3f92fa26b61Chris Lattner // Out-of-line virtual method to give class a home. 906917d2c9dc2cc8879ed97533e7f75f3f92fa26b61Chris Lattner virtual void ANCHOR(); 90763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 908b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner virtual ~SDNode() { 909b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner assert(NumOperands == 0 && "Operand list not cleared before deletion"); 9103258ed6a361bf405a89f7af0b1885841d9909516Chris Lattner NodeType = ISD::DELETED_NODE; 911b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner } 912b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner 91363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner //===--------------------------------------------------------------------===// 91463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // Accessors 91563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner // 91663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner unsigned getOpcode() const { return NodeType; } 9170f66a9172175aa7c3055333358170581c999219bNate Begeman bool isTargetOpcode() const { return NodeType >= ISD::BUILTIN_OP_END; } 9180f66a9172175aa7c3055333358170581c999219bNate Begeman unsigned getTargetOpcode() const { 9190f66a9172175aa7c3055333358170581c999219bNate Begeman assert(isTargetOpcode() && "Not a target opcode!"); 9200f66a9172175aa7c3055333358170581c999219bNate Begeman return NodeType - ISD::BUILTIN_OP_END; 9210f66a9172175aa7c3055333358170581c999219bNate Begeman } 92263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 92363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner size_t use_size() const { return Uses.size(); } 92463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner bool use_empty() const { return Uses.empty(); } 92563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner bool hasOneUse() const { return Uses.size() == 1; } 92663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 927b9ee9e60a905b90fa3e84c5c6091af6e5a0382d2Evan Cheng /// getNodeId - Return the unique node id. 928b9ee9e60a905b90fa3e84c5c6091af6e5a0382d2Evan Cheng /// 929b9ee9e60a905b90fa3e84c5c6091af6e5a0382d2Evan Cheng int getNodeId() const { return NodeId; } 9300442fbfadbeea21eee9df88dc466d95e040dde6bChris Lattner 9312e07d33f04c513f3c2da3d7b1acfc098f02c7a6eEvan Cheng /// setNodeId - Set unique node id. 9322e07d33f04c513f3c2da3d7b1acfc098f02c7a6eEvan Cheng void setNodeId(int Id) { NodeId = Id; } 9332e07d33f04c513f3c2da3d7b1acfc098f02c7a6eEvan Cheng 9345892d47a625638a90afeb31dd4f6f80a2f9bacdeChris Lattner typedef SmallVector<SDNode*,3>::const_iterator use_iterator; 9357ece380440238ad0630a225b85a09a2dbed1165aChris Lattner use_iterator use_begin() const { return Uses.begin(); } 9367ece380440238ad0630a225b85a09a2dbed1165aChris Lattner use_iterator use_end() const { return Uses.end(); } 9377ece380440238ad0630a225b85a09a2dbed1165aChris Lattner 938b18a2f816cc9d1351ca8e380a6db5c5ef981943eChris Lattner /// hasNUsesOfValue - Return true if there are exactly NUSES uses of the 939b18a2f816cc9d1351ca8e380a6db5c5ef981943eChris Lattner /// indicated value. This method ignores uses of other values defined by this 940b18a2f816cc9d1351ca8e380a6db5c5ef981943eChris Lattner /// operation. 9414ee621125876cc954cba5280dd9395552755a871Evan Cheng bool hasNUsesOfValue(unsigned NUses, unsigned Value) const; 9424ee621125876cc954cba5280dd9395552755a871Evan Cheng 94333d5595d667ba4a880bd7fe785724e8197bef70cEvan Cheng /// hasAnyUseOfValue - Return true if there are any use of the indicated 94433d5595d667ba4a880bd7fe785724e8197bef70cEvan Cheng /// value. This method ignores uses of other values defined by this operation. 94533d5595d667ba4a880bd7fe785724e8197bef70cEvan Cheng bool hasAnyUseOfValue(unsigned Value) const; 94633d5595d667ba4a880bd7fe785724e8197bef70cEvan Cheng 947e6e97e66a366cc7d2d103ac58db56e4bfd700b10Evan Cheng /// isOnlyUse - Return true if this node is the only use of N. 948e6e97e66a366cc7d2d103ac58db56e4bfd700b10Evan Cheng /// 9494ee621125876cc954cba5280dd9395552755a871Evan Cheng bool isOnlyUse(SDNode *N) const; 950b18a2f816cc9d1351ca8e380a6db5c5ef981943eChris Lattner 951e6e97e66a366cc7d2d103ac58db56e4bfd700b10Evan Cheng /// isOperand - Return true if this node is an operand of N. 952e6e97e66a366cc7d2d103ac58db56e4bfd700b10Evan Cheng /// 95380d8eaae05d9bcb25abf6c6f0385ec2554355f26Evan Cheng bool isOperand(SDNode *N) const; 95480d8eaae05d9bcb25abf6c6f0385ec2554355f26Evan Cheng 955e6e97e66a366cc7d2d103ac58db56e4bfd700b10Evan Cheng /// isPredecessor - Return true if this node is a predecessor of N. This node 956e6e97e66a366cc7d2d103ac58db56e4bfd700b10Evan Cheng /// is either an operand of N or it can be reached by recursively traversing 957e6e97e66a366cc7d2d103ac58db56e4bfd700b10Evan Cheng /// up the operands. 958e6e97e66a366cc7d2d103ac58db56e4bfd700b10Evan Cheng /// NOTE: this is an expensive method. Use it carefully. 9597ceebb437ebb18efefe72d8d2d0e9c762c3aa6b3Evan Cheng bool isPredecessor(SDNode *N) const; 9607ceebb437ebb18efefe72d8d2d0e9c762c3aa6b3Evan Cheng 96163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// getNumOperands - Return the number of values used by this operation. 96263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// 963f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner unsigned getNumOperands() const { return NumOperands; } 96463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 965c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng /// getConstantOperandVal - Helper method returns the integer value of a 966c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng /// ConstantSDNode operand. 967c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng uint64_t getConstantOperandVal(unsigned Num) const; 968c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng 96963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner const SDOperand &getOperand(unsigned Num) const { 970f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner assert(Num < NumOperands && "Invalid child # of SDNode!"); 971f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner return OperandList[Num]; 97263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 973c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng 974f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner typedef const SDOperand* op_iterator; 975f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner op_iterator op_begin() const { return OperandList; } 976f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner op_iterator op_end() const { return OperandList+NumOperands; } 97750f5a51f41d36c519de68ff11fbf7c7c76f45416Chris Lattner 97863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 9790b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner SDVTList getVTList() const { 9800b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner SDVTList X = { ValueList, NumValues }; 9810b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner return X; 9820b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner }; 9830b3e525a3a6b55b66dc5676675712b26e4c1ed9fChris Lattner 98463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// getNumValues - Return the number of values defined/returned by this 98563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// operator. 98663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// 987f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner unsigned getNumValues() const { return NumValues; } 98863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 98963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// getValueType - Return the type of a specified result. 99063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// 99163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner MVT::ValueType getValueType(unsigned ResNo) const { 992f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner assert(ResNo < NumValues && "Illegal result number!"); 993f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner return ValueList[ResNo]; 99463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 9959eb59ec548b861d6ede05b4e6dc22aabf645e665Jeff Cohen 996f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner typedef const MVT::ValueType* value_iterator; 997f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner value_iterator value_begin() const { return ValueList; } 998f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner value_iterator value_end() const { return ValueList+NumValues; } 99963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 10006e6e3ceb080e5a8bdfd3258d883a06ebbd8a1965Chris Lattner /// getOperationName - Return the opcode of this operation for printing. 10016e6e3ceb080e5a8bdfd3258d883a06ebbd8a1965Chris Lattner /// 1002ded5ed873fa7cd85f0b9d7c677b81dddf9a61eaaReid Spencer std::string getOperationName(const SelectionDAG *G = 0) const; 1003144d8f09e139f691cafadbc17873943ba4c465f3Evan Cheng static const char* getIndexedModeName(ISD::MemIndexedMode AM); 100463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner void dump() const; 1005efe58694050e48b61584b8454434dcd1ad886a71Chris Lattner void dump(const SelectionDAG *G) const; 100663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 100763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *) { return true; } 100863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 1009583bd47f777fe3eb8305872fa0eadab31e833dffJim Laskey /// Profile - Gather unique data for the node. 1010583bd47f777fe3eb8305872fa0eadab31e833dffJim Laskey /// 1011583bd47f777fe3eb8305872fa0eadab31e833dffJim Laskey void Profile(FoldingSetNodeID &ID); 1012583bd47f777fe3eb8305872fa0eadab31e833dffJim Laskey 101363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerprotected: 101463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 1015109654fae9c5b8b96bd3a829824cdbceb27ced06Chris Lattner 1016109654fae9c5b8b96bd3a829824cdbceb27ced06Chris Lattner /// getValueTypeList - Return a pointer to the specified value type. 1017109654fae9c5b8b96bd3a829824cdbceb27ced06Chris Lattner /// 1018547ca537b638c8fd5c8f4729e4c74898f8371e4eDan Gohman static const MVT::ValueType *getValueTypeList(MVT::ValueType VT); 101963e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner static SDVTList getSDVTList(MVT::ValueType VT) { 102063e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner SDVTList Ret = { getValueTypeList(VT), 1 }; 102163e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner return Ret; 10222d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth } 102363e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner 1024ab4ed595385d0b9421c0d45c809ec6324cf11f11Chris Lattner SDNode(unsigned Opc, SDVTList VTs, const SDOperand *Ops, unsigned NumOps) 1025b9ee9e60a905b90fa3e84c5c6091af6e5a0382d2Evan Cheng : NodeType(Opc), NodeId(-1) { 102663e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner OperandsNeedDelete = true; 1027f06f35e30b4c4d7db304f717a3d4dc6595fbd078Chris Lattner NumOperands = NumOps; 1028bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner OperandList = NumOps ? new SDOperand[NumOperands] : 0; 1029f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner 1030bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner for (unsigned i = 0; i != NumOps; ++i) { 1031f06f35e30b4c4d7db304f717a3d4dc6595fbd078Chris Lattner OperandList[i] = Ops[i]; 1032bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner Ops[i].Val->Uses.push_back(this); 10330442fbfadbeea21eee9df88dc466d95e040dde6bChris Lattner } 1034bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner 1035ab4ed595385d0b9421c0d45c809ec6324cf11f11Chris Lattner ValueList = VTs.VTs; 1036ab4ed595385d0b9421c0d45c809ec6324cf11f11Chris Lattner NumValues = VTs.NumVTs; 1037b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner Prev = 0; Next = 0; 1038f71e843f651ad94e19f85daa947fe24312b40d11Chris Lattner } 1039bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner SDNode(unsigned Opc, SDVTList VTs) : NodeType(Opc), NodeId(-1) { 1040bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner OperandsNeedDelete = false; // Operands set with InitOperands. 1041bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner NumOperands = 0; 1042bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner OperandList = 0; 1043bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner 1044bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner ValueList = VTs.VTs; 1045bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner NumValues = VTs.NumVTs; 1046bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner Prev = 0; Next = 0; 1047bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner } 1048bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner 1049bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner /// InitOperands - Initialize the operands list of this node with the 1050bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner /// specified values, which are part of the node (thus they don't need to be 1051bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner /// copied in or allocated). 1052bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner void InitOperands(SDOperand *Ops, unsigned NumOps) { 1053bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner assert(OperandList == 0 && "Operands already set!"); 1054bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner NumOperands = NumOps; 1055bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner OperandList = Ops; 1056bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner 1057bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner for (unsigned i = 0; i != NumOps; ++i) 1058bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner Ops[i].Val->Uses.push_back(this); 1059bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner } 1060bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner 1061d429bcd4ac734540ebbc15a0ee37d154ae1daf73Chris Lattner /// MorphNodeTo - This frees the operands of the current node, resets the 1062d429bcd4ac734540ebbc15a0ee37d154ae1daf73Chris Lattner /// opcode, types, and operands to the specified value. This should only be 1063d429bcd4ac734540ebbc15a0ee37d154ae1daf73Chris Lattner /// used by the SelectionDAG class. 1064d429bcd4ac734540ebbc15a0ee37d154ae1daf73Chris Lattner void MorphNodeTo(unsigned Opc, SDVTList L, 1065d429bcd4ac734540ebbc15a0ee37d154ae1daf73Chris Lattner const SDOperand *Ops, unsigned NumOps); 10661b95095857b78e12138c22e76c7936611c51355bChris Lattner 10678c3484c5181834e6b7060a6064ac769878101f23Chris Lattner void addUser(SDNode *User) { 10688c3484c5181834e6b7060a6064ac769878101f23Chris Lattner Uses.push_back(User); 10691b95095857b78e12138c22e76c7936611c51355bChris Lattner } 1070d1fc96499b7619356c7542200d32da898b79f7c1Chris Lattner void removeUser(SDNode *User) { 1071d1fc96499b7619356c7542200d32da898b79f7c1Chris Lattner // Remove this user from the operand's use list. 1072d1fc96499b7619356c7542200d32da898b79f7c1Chris Lattner for (unsigned i = Uses.size(); ; --i) { 1073d1fc96499b7619356c7542200d32da898b79f7c1Chris Lattner assert(i != 0 && "Didn't find user!"); 1074d1fc96499b7619356c7542200d32da898b79f7c1Chris Lattner if (Uses[i-1] == User) { 10758c3484c5181834e6b7060a6064ac769878101f23Chris Lattner Uses[i-1] = Uses.back(); 10768c3484c5181834e6b7060a6064ac769878101f23Chris Lattner Uses.pop_back(); 10778c3484c5181834e6b7060a6064ac769878101f23Chris Lattner return; 1078d1fc96499b7619356c7542200d32da898b79f7c1Chris Lattner } 1079d1fc96499b7619356c7542200d32da898b79f7c1Chris Lattner } 1080d1fc96499b7619356c7542200d32da898b79f7c1Chris Lattner } 108163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 108263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 108363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 108463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner// Define inline functions from the SDOperand class. 108563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 108663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerinline unsigned SDOperand::getOpcode() const { 108763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner return Val->getOpcode(); 108863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner} 108963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerinline MVT::ValueType SDOperand::getValueType() const { 109063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner return Val->getValueType(ResNo); 109163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner} 109263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerinline unsigned SDOperand::getNumOperands() const { 109363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner return Val->getNumOperands(); 109463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner} 109563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerinline const SDOperand &SDOperand::getOperand(unsigned i) const { 109663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner return Val->getOperand(i); 109763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner} 1098c548428c5d7328592f4db6f6cd815af18b3152a3Evan Chenginline uint64_t SDOperand::getConstantOperandVal(unsigned i) const { 1099c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng return Val->getConstantOperandVal(i); 1100c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng} 11010f66a9172175aa7c3055333358170581c999219bNate Begemaninline bool SDOperand::isTargetOpcode() const { 11020f66a9172175aa7c3055333358170581c999219bNate Begeman return Val->isTargetOpcode(); 11030f66a9172175aa7c3055333358170581c999219bNate Begeman} 11040f66a9172175aa7c3055333358170581c999219bNate Begemaninline unsigned SDOperand::getTargetOpcode() const { 11050f66a9172175aa7c3055333358170581c999219bNate Begeman return Val->getTargetOpcode(); 11060f66a9172175aa7c3055333358170581c999219bNate Begeman} 1107a44f4aeca77c6c1627568fe68e92af9c7e33dc7eChris Lattnerinline bool SDOperand::hasOneUse() const { 1108a44f4aeca77c6c1627568fe68e92af9c7e33dc7eChris Lattner return Val->hasNUsesOfValue(1, ResNo); 1109a44f4aeca77c6c1627568fe68e92af9c7e33dc7eChris Lattner} 1110e1b50639a860934685dff840e1826b16dbe6a344Dan Gohmaninline bool SDOperand::use_empty() const { 1111e1b50639a860934685dff840e1826b16dbe6a344Dan Gohman return !Val->hasAnyUseOfValue(ResNo); 1112e1b50639a860934685dff840e1826b16dbe6a344Dan Gohman} 111363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 11143f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner/// UnarySDNode - This class is used for single-operand SDNodes. This is solely 11153f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner/// to allow co-allocation of node operands with the node itself. 11163f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattnerclass UnarySDNode : public SDNode { 11173f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 11183f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner SDOperand Op; 11193f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattnerpublic: 11203f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner UnarySDNode(unsigned Opc, SDVTList VTs, SDOperand X) 11213f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner : SDNode(Opc, VTs), Op(X) { 11223f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner InitOperands(&Op, 1); 11233f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner } 11243f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner}; 11253f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner 11263f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner/// BinarySDNode - This class is used for two-operand SDNodes. This is solely 11273f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner/// to allow co-allocation of node operands with the node itself. 11283f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattnerclass BinarySDNode : public SDNode { 11293f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 11303f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner SDOperand Ops[2]; 11313f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattnerpublic: 11323f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner BinarySDNode(unsigned Opc, SDVTList VTs, SDOperand X, SDOperand Y) 11333f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner : SDNode(Opc, VTs) { 11343f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner Ops[0] = X; 11353f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner Ops[1] = Y; 11363f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner InitOperands(Ops, 2); 11373f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner } 11383f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner}; 11393f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner 11403f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner/// TernarySDNode - This class is used for three-operand SDNodes. This is solely 11413f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner/// to allow co-allocation of node operands with the node itself. 11423f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattnerclass TernarySDNode : public SDNode { 11433f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 11443f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner SDOperand Ops[3]; 11453f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattnerpublic: 11463f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner TernarySDNode(unsigned Opc, SDVTList VTs, SDOperand X, SDOperand Y, 11473f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner SDOperand Z) 11483f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner : SDNode(Opc, VTs) { 11493f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner Ops[0] = X; 11503f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner Ops[1] = Y; 11513f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner Ops[2] = Z; 11523f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner InitOperands(Ops, 3); 11533f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner } 11543f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner}; 11553f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner 11563f97eb449b08069e3370d4ba7566c60bdbf0babdChris Lattner 1157d623e953fc5f46b013994dfa4651cff4d17af159Chris Lattner/// HandleSDNode - This class is used to form a handle around another node that 1158d623e953fc5f46b013994dfa4651cff4d17af159Chris Lattner/// is persistant and is updated across invocations of replaceAllUsesWith on its 1159d623e953fc5f46b013994dfa4651cff4d17af159Chris Lattner/// operand. This node should be directly created by end-users and not added to 1160d623e953fc5f46b013994dfa4651cff4d17af159Chris Lattner/// the AllNodes list. 1161d623e953fc5f46b013994dfa4651cff4d17af159Chris Lattnerclass HandleSDNode : public SDNode { 1162c76e3c86026b9fa44bfbb0888881b52955078011Chris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 1163bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner SDOperand Op; 1164d623e953fc5f46b013994dfa4651cff4d17af159Chris Lattnerpublic: 1165423c2260f95883f7c84ac962e58ac66c3a11efacDan Gohman explicit HandleSDNode(SDOperand X) 1166bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner : SDNode(ISD::HANDLENODE, getSDVTList(MVT::Other)), Op(X) { 1167bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner InitOperands(&Op, 1); 1168bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner } 116948b85926524f9d29ae600123c90194cd73fd629eChris Lattner ~HandleSDNode(); 1170bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner SDOperand getValue() const { return Op; } 1171d623e953fc5f46b013994dfa4651cff4d17af159Chris Lattner}; 1172d623e953fc5f46b013994dfa4651cff4d17af159Chris Lattner 117347725d059b259f8a0c145478300c9e9caa006b59Chris Lattnerclass StringSDNode : public SDNode { 117447725d059b259f8a0c145478300c9e9caa006b59Chris Lattner std::string Value; 1175c76e3c86026b9fa44bfbb0888881b52955078011Chris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 117647725d059b259f8a0c145478300c9e9caa006b59Chris Lattnerprotected: 117747725d059b259f8a0c145478300c9e9caa006b59Chris Lattner friend class SelectionDAG; 1178423c2260f95883f7c84ac962e58ac66c3a11efacDan Gohman explicit StringSDNode(const std::string &val) 1179bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner : SDNode(ISD::STRING, getSDVTList(MVT::Other)), Value(val) { 118047725d059b259f8a0c145478300c9e9caa006b59Chris Lattner } 118147725d059b259f8a0c145478300c9e9caa006b59Chris Lattnerpublic: 118247725d059b259f8a0c145478300c9e9caa006b59Chris Lattner const std::string &getValue() const { return Value; } 118347725d059b259f8a0c145478300c9e9caa006b59Chris Lattner static bool classof(const StringSDNode *) { return true; } 118447725d059b259f8a0c145478300c9e9caa006b59Chris Lattner static bool classof(const SDNode *N) { 118547725d059b259f8a0c145478300c9e9caa006b59Chris Lattner return N->getOpcode() == ISD::STRING; 118647725d059b259f8a0c145478300c9e9caa006b59Chris Lattner } 118747725d059b259f8a0c145478300c9e9caa006b59Chris Lattner}; 118863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 118963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass ConstantSDNode : public SDNode { 11906394b099e836f56a937cdcc7332c9487b504ca68Dan Gohman APInt Value; 1191c76e3c86026b9fa44bfbb0888881b52955078011Chris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 119263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerprotected: 119363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 11946394b099e836f56a937cdcc7332c9487b504ca68Dan Gohman ConstantSDNode(bool isTarget, const APInt &val, MVT::ValueType VT) 1195bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner : SDNode(isTarget ? ISD::TargetConstant : ISD::Constant, getSDVTList(VT)), 1196bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner Value(val) { 119763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 119863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 119963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 12006394b099e836f56a937cdcc7332c9487b504ca68Dan Gohman const APInt &getAPIntValue() const { return Value; } 12016394b099e836f56a937cdcc7332c9487b504ca68Dan Gohman uint64_t getValue() const { return Value.getZExtValue(); } 120263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 120363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner int64_t getSignExtended() const { 120463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner unsigned Bits = MVT::getSizeInBits(getValueType(0)); 12056394b099e836f56a937cdcc7332c9487b504ca68Dan Gohman return ((int64_t)Value.getZExtValue() << (64-Bits)) >> (64-Bits); 120663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 120763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 120863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner bool isNullValue() const { return Value == 0; } 120963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner bool isAllOnesValue() const { 1210885a87ef8512a184a58a0ebe39705ccb221749efChris Lattner return Value == MVT::getIntVTBitMask(getValueType(0)); 121163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 121263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 121363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const ConstantSDNode *) { return true; } 121463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *N) { 1215056f9f61d071c6c583951678f2bf543a1316efccChris Lattner return N->getOpcode() == ISD::Constant || 1216056f9f61d071c6c583951678f2bf543a1316efccChris Lattner N->getOpcode() == ISD::TargetConstant; 121763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 121863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 121963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 122063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass ConstantFPSDNode : public SDNode { 12218bb369b8072c919ef5802f639a52b17620201190Dale Johannesen APFloat Value; 1222c76e3c86026b9fa44bfbb0888881b52955078011Chris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 122363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerprotected: 122463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 1225e6c1742914149d44360fbf05a653041a672282afDale Johannesen ConstantFPSDNode(bool isTarget, const APFloat& val, MVT::ValueType VT) 122687503a63d5756f1836f66f4c9723ec0ea30ec3caDale Johannesen : SDNode(isTarget ? ISD::TargetConstantFP : ISD::ConstantFP, 122787503a63d5756f1836f66f4c9723ec0ea30ec3caDale Johannesen getSDVTList(VT)), Value(val) { 122863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 122963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 123063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 1231e6c1742914149d44360fbf05a653041a672282afDale Johannesen const APFloat& getValueAPF() const { return Value; } 123263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 123363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// isExactlyValue - We don't rely on operator== working on double values, as 123463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// it returns true for things that are clearly not equal, like -0.0 and 0.0. 123563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// As such, this method can be used to do an exact bit-for-bit comparison of 123663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner /// two floating point values. 1237c4dd3c3b519aa2c2ed26ce03a4b1fbb992efeacaDale Johannesen 1238c4dd3c3b519aa2c2ed26ce03a4b1fbb992efeacaDale Johannesen /// We leave the version with the double argument here because it's just so 1239c4dd3c3b519aa2c2ed26ce03a4b1fbb992efeacaDale Johannesen /// convenient to write "2.0" and the like. Without this function we'd 1240c4dd3c3b519aa2c2ed26ce03a4b1fbb992efeacaDale Johannesen /// have to duplicate its logic everywhere it's called. 124187503a63d5756f1836f66f4c9723ec0ea30ec3caDale Johannesen bool isExactlyValue(double V) const { 124284cd0e7fa30af43c47ad9533d84debb144596e48Chris Lattner APFloat Tmp(V); 124384cd0e7fa30af43c47ad9533d84debb144596e48Chris Lattner Tmp.convert(Value.getSemantics(), APFloat::rmNearestTiesToEven); 124484cd0e7fa30af43c47ad9533d84debb144596e48Chris Lattner return isExactlyValue(Tmp); 124587503a63d5756f1836f66f4c9723ec0ea30ec3caDale Johannesen } 1246e6c1742914149d44360fbf05a653041a672282afDale Johannesen bool isExactlyValue(const APFloat& V) const; 124763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 1248f04afdbb48568ef09f11fd10ac03426101f2dbf8Dale Johannesen bool isValueValidForType(MVT::ValueType VT, const APFloat& Val); 1249f04afdbb48568ef09f11fd10ac03426101f2dbf8Dale Johannesen 125063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const ConstantFPSDNode *) { return true; } 125163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *N) { 1252ac0d7238258defe72b1aad53d7f48201b91df795Chris Lattner return N->getOpcode() == ISD::ConstantFP || 1253ac0d7238258defe72b1aad53d7f48201b91df795Chris Lattner N->getOpcode() == ISD::TargetConstantFP; 125463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 125563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 125663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 125763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass GlobalAddressSDNode : public SDNode { 125863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner GlobalValue *TheGlobal; 1259404cb4f9fa2df50eac4d84b8a77c84a92188c6d5Evan Cheng int Offset; 1260c76e3c86026b9fa44bfbb0888881b52955078011Chris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 126163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerprotected: 126263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 126361ca74bc3a29b2af2be7e4bd612289da8aae85b5Evan Cheng GlobalAddressSDNode(bool isTarget, const GlobalValue *GA, MVT::ValueType VT, 12642c5c111b6c144b05718404c85b9dfcc76b1619e7Lauro Ramos Venancio int o = 0); 126563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 126663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 126763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner GlobalValue *getGlobal() const { return TheGlobal; } 1268404cb4f9fa2df50eac4d84b8a77c84a92188c6d5Evan Cheng int getOffset() const { return Offset; } 126963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 127063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const GlobalAddressSDNode *) { return true; } 127163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *N) { 1272f6b184981e429ff03742d66cf7111debd9e2bc61Chris Lattner return N->getOpcode() == ISD::GlobalAddress || 1273b3a0417cad8b625acc3033bd5e24afb9ffd0b084Lauro Ramos Venancio N->getOpcode() == ISD::TargetGlobalAddress || 1274b3a0417cad8b625acc3033bd5e24afb9ffd0b084Lauro Ramos Venancio N->getOpcode() == ISD::GlobalTLSAddress || 1275b3a0417cad8b625acc3033bd5e24afb9ffd0b084Lauro Ramos Venancio N->getOpcode() == ISD::TargetGlobalTLSAddress; 127663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 127763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 127863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 127963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass FrameIndexSDNode : public SDNode { 128063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner int FI; 1281c76e3c86026b9fa44bfbb0888881b52955078011Chris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 128263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerprotected: 128363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 1284afb2dd43de61f4585e75d1f3ab93a9ac4b3b7592Chris Lattner FrameIndexSDNode(int fi, MVT::ValueType VT, bool isTarg) 1285bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner : SDNode(isTarg ? ISD::TargetFrameIndex : ISD::FrameIndex, getSDVTList(VT)), 1286bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner FI(fi) { 128763e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner } 128863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 128963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 129063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner int getIndex() const { return FI; } 129163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 129263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const FrameIndexSDNode *) { return true; } 129363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *N) { 1294afb2dd43de61f4585e75d1f3ab93a9ac4b3b7592Chris Lattner return N->getOpcode() == ISD::FrameIndex || 1295afb2dd43de61f4585e75d1f3ab93a9ac4b3b7592Chris Lattner N->getOpcode() == ISD::TargetFrameIndex; 129663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 129763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 129863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 129937efe6764568a3829fee26aba532283131d1a104Nate Begemanclass JumpTableSDNode : public SDNode { 130037efe6764568a3829fee26aba532283131d1a104Nate Begeman int JTI; 1301c76e3c86026b9fa44bfbb0888881b52955078011Chris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 130237efe6764568a3829fee26aba532283131d1a104Nate Begemanprotected: 130337efe6764568a3829fee26aba532283131d1a104Nate Begeman friend class SelectionDAG; 130437efe6764568a3829fee26aba532283131d1a104Nate Begeman JumpTableSDNode(int jti, MVT::ValueType VT, bool isTarg) 1305bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner : SDNode(isTarg ? ISD::TargetJumpTable : ISD::JumpTable, getSDVTList(VT)), 1306bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner JTI(jti) { 130763e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner } 130837efe6764568a3829fee26aba532283131d1a104Nate Begemanpublic: 130937efe6764568a3829fee26aba532283131d1a104Nate Begeman 131037efe6764568a3829fee26aba532283131d1a104Nate Begeman int getIndex() const { return JTI; } 131137efe6764568a3829fee26aba532283131d1a104Nate Begeman 131237efe6764568a3829fee26aba532283131d1a104Nate Begeman static bool classof(const JumpTableSDNode *) { return true; } 131337efe6764568a3829fee26aba532283131d1a104Nate Begeman static bool classof(const SDNode *N) { 131437efe6764568a3829fee26aba532283131d1a104Nate Begeman return N->getOpcode() == ISD::JumpTable || 131537efe6764568a3829fee26aba532283131d1a104Nate Begeman N->getOpcode() == ISD::TargetJumpTable; 131637efe6764568a3829fee26aba532283131d1a104Nate Begeman } 131737efe6764568a3829fee26aba532283131d1a104Nate Begeman}; 131837efe6764568a3829fee26aba532283131d1a104Nate Begeman 131963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass ConstantPoolSDNode : public SDNode { 1320d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng union { 1321d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng Constant *ConstVal; 1322d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng MachineConstantPoolValue *MachineCPVal; 1323d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng } Val; 1324baf4500b3ab128c78932e36f96086c0487c8c7d1Evan Cheng int Offset; // It's a MachineConstantPoolValue if top bit is set. 1325b8973bd8f50d7321635e1e07b81a880a0828d185Evan Cheng unsigned Alignment; 1326c76e3c86026b9fa44bfbb0888881b52955078011Chris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 132763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerprotected: 132863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 1329404cb4f9fa2df50eac4d84b8a77c84a92188c6d5Evan Cheng ConstantPoolSDNode(bool isTarget, Constant *c, MVT::ValueType VT, 1330404cb4f9fa2df50eac4d84b8a77c84a92188c6d5Evan Cheng int o=0) 1331ab4ed595385d0b9421c0d45c809ec6324cf11f11Chris Lattner : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 1332bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner getSDVTList(VT)), Offset(o), Alignment(0) { 1333d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng assert((int)Offset >= 0 && "Offset is too large"); 1334d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng Val.ConstVal = c; 1335d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng } 1336404cb4f9fa2df50eac4d84b8a77c84a92188c6d5Evan Cheng ConstantPoolSDNode(bool isTarget, Constant *c, MVT::ValueType VT, int o, 1337404cb4f9fa2df50eac4d84b8a77c84a92188c6d5Evan Cheng unsigned Align) 1338ab4ed595385d0b9421c0d45c809ec6324cf11f11Chris Lattner : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 1339bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner getSDVTList(VT)), Offset(o), Alignment(Align) { 1340d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng assert((int)Offset >= 0 && "Offset is too large"); 1341d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng Val.ConstVal = c; 1342d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng } 1343d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v, 1344d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng MVT::ValueType VT, int o=0) 1345ab4ed595385d0b9421c0d45c809ec6324cf11f11Chris Lattner : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 1346bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner getSDVTList(VT)), Offset(o), Alignment(0) { 1347d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng assert((int)Offset >= 0 && "Offset is too large"); 1348d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng Val.MachineCPVal = v; 1349d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng Offset |= 1 << (sizeof(unsigned)*8-1); 1350d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng } 1351d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v, 1352d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng MVT::ValueType VT, int o, unsigned Align) 1353ab4ed595385d0b9421c0d45c809ec6324cf11f11Chris Lattner : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 1354bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner getSDVTList(VT)), Offset(o), Alignment(Align) { 1355d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng assert((int)Offset >= 0 && "Offset is too large"); 1356d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng Val.MachineCPVal = v; 1357d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng Offset |= 1 << (sizeof(unsigned)*8-1); 1358d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng } 135963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 136063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 1361d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng bool isMachineConstantPoolEntry() const { 1362d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng return (int)Offset < 0; 1363d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng } 1364d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng 1365d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng Constant *getConstVal() const { 1366d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng assert(!isMachineConstantPoolEntry() && "Wrong constantpool type"); 1367d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng return Val.ConstVal; 1368d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng } 1369d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng 1370d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng MachineConstantPoolValue *getMachineCPVal() const { 1371d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng assert(isMachineConstantPoolEntry() && "Wrong constantpool type"); 1372d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng return Val.MachineCPVal; 1373d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng } 1374d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng 1375baf4500b3ab128c78932e36f96086c0487c8c7d1Evan Cheng int getOffset() const { 1376baf4500b3ab128c78932e36f96086c0487c8c7d1Evan Cheng return Offset & ~(1 << (sizeof(unsigned)*8-1)); 1377baf4500b3ab128c78932e36f96086c0487c8c7d1Evan Cheng } 1378ef3640aded552279f65bd6d18633e15ffb245157Chris Lattner 1379ef3640aded552279f65bd6d18633e15ffb245157Chris Lattner // Return the alignment of this constant pool object, which is either 0 (for 1380ef3640aded552279f65bd6d18633e15ffb245157Chris Lattner // default alignment) or log2 of the desired value. 1381b8973bd8f50d7321635e1e07b81a880a0828d185Evan Cheng unsigned getAlignment() const { return Alignment; } 138263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 1383d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng const Type *getType() const; 1384d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng 138563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const ConstantPoolSDNode *) { return true; } 138663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *N) { 1387aaaaf79d4aaa172c2f2ae0e327bbae523a045bf5Chris Lattner return N->getOpcode() == ISD::ConstantPool || 1388aaaaf79d4aaa172c2f2ae0e327bbae523a045bf5Chris Lattner N->getOpcode() == ISD::TargetConstantPool; 138963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 139063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 139163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 139263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass BasicBlockSDNode : public SDNode { 139363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner MachineBasicBlock *MBB; 1394c76e3c86026b9fa44bfbb0888881b52955078011Chris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 139563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerprotected: 139663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 1397423c2260f95883f7c84ac962e58ac66c3a11efacDan Gohman explicit BasicBlockSDNode(MachineBasicBlock *mbb) 1398bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner : SDNode(ISD::BasicBlock, getSDVTList(MVT::Other)), MBB(mbb) { 139963e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner } 140063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 140163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 140263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner MachineBasicBlock *getBasicBlock() const { return MBB; } 140363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 140463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const BasicBlockSDNode *) { return true; } 140563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *N) { 140663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner return N->getOpcode() == ISD::BasicBlock; 140763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 140863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 140963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 141014471be9ab531cb677658704ea73b06d4f0b7585Dan Gohman/// SrcValueSDNode - An SDNode that holds an arbitrary LLVM IR Value. This is 141114471be9ab531cb677658704ea73b06d4f0b7585Dan Gohman/// used when the SelectionDAG needs to make a simple reference to something 141214471be9ab531cb677658704ea73b06d4f0b7585Dan Gohman/// in the LLVM IR representation. 141314471be9ab531cb677658704ea73b06d4f0b7585Dan Gohman/// 141414471be9ab531cb677658704ea73b06d4f0b7585Dan Gohman/// Note that this is not used for carrying alias information; that is done 141514471be9ab531cb677658704ea73b06d4f0b7585Dan Gohman/// with MemOperandSDNode, which includes a Value which is required to be a 141614471be9ab531cb677658704ea73b06d4f0b7585Dan Gohman/// pointer, and several other fields specific to memory references. 141714471be9ab531cb677658704ea73b06d4f0b7585Dan Gohman/// 14182d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharthclass SrcValueSDNode : public SDNode { 14192d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth const Value *V; 1420c76e3c86026b9fa44bfbb0888881b52955078011Chris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 14212d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharthprotected: 14222d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth friend class SelectionDAG; 142369de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman /// Create a SrcValue for a general value. 142469de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman explicit SrcValueSDNode(const Value *v) 142569de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman : SDNode(ISD::SRCVALUE, getSDVTList(MVT::Other)), V(v) {} 14262d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 14272d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharthpublic: 142869de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman /// getValue - return the contained Value. 14292d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth const Value *getValue() const { return V; } 14302d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 14312d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth static bool classof(const SrcValueSDNode *) { return true; } 14322d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth static bool classof(const SDNode *N) { 14332d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth return N->getOpcode() == ISD::SRCVALUE; 14342d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth } 14352d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth}; 14362d86ea21dd76647cb054fd5d27df9e49efc672b6Andrew Lenharth 143763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 143869de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman/// MemOperandSDNode - An SDNode that holds a MemOperand. This is 143969de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman/// used to represent a reference to memory after ISD::LOAD 144069de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman/// and ISD::STORE have been lowered. 144169de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman/// 144269de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohmanclass MemOperandSDNode : public SDNode { 144369de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 144469de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohmanprotected: 144569de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman friend class SelectionDAG; 144669de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman /// Create a MemOperand node 1447f8df0ff9a5d1be41ca237bcd40ced821839b32faDan Gohman explicit MemOperandSDNode(const MemOperand &mo) 144869de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman : SDNode(ISD::MEMOPERAND, getSDVTList(MVT::Other)), MO(mo) {} 144969de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman 145069de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohmanpublic: 145169de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman /// MO - The contained MemOperand. 145269de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman const MemOperand MO; 145369de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman 145469de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman static bool classof(const MemOperandSDNode *) { return true; } 145569de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman static bool classof(const SDNode *N) { 145669de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman return N->getOpcode() == ISD::MEMOPERAND; 145769de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman } 145869de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman}; 145969de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman 146069de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman 1461d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattnerclass RegisterSDNode : public SDNode { 146263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner unsigned Reg; 1463c76e3c86026b9fa44bfbb0888881b52955078011Chris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 146463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerprotected: 146563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 1466d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner RegisterSDNode(unsigned reg, MVT::ValueType VT) 1467bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner : SDNode(ISD::Register, getSDVTList(VT)), Reg(reg) { 146863e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner } 146963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 147063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 147163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner unsigned getReg() const { return Reg; } 147263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 1473d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner static bool classof(const RegisterSDNode *) { return true; } 147463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *N) { 1475d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return N->getOpcode() == ISD::Register; 147663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 147763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 147863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 147963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerclass ExternalSymbolSDNode : public SDNode { 148063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner const char *Symbol; 1481c76e3c86026b9fa44bfbb0888881b52955078011Chris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 148263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerprotected: 148363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 14842a2de66db2093a5bc1fd620d1b6ae7992a552b24Andrew Lenharth ExternalSymbolSDNode(bool isTarget, const char *Sym, MVT::ValueType VT) 1485ab4ed595385d0b9421c0d45c809ec6324cf11f11Chris Lattner : SDNode(isTarget ? ISD::TargetExternalSymbol : ISD::ExternalSymbol, 1486bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner getSDVTList(VT)), Symbol(Sym) { 148763e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner } 148863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 148963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 149063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner const char *getSymbol() const { return Symbol; } 149163b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 149263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const ExternalSymbolSDNode *) { return true; } 149363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *N) { 14942a2de66db2093a5bc1fd620d1b6ae7992a552b24Andrew Lenharth return N->getOpcode() == ISD::ExternalSymbol || 14952a2de66db2093a5bc1fd620d1b6ae7992a552b24Andrew Lenharth N->getOpcode() == ISD::TargetExternalSymbol; 149663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 149763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 149863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 14997cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattnerclass CondCodeSDNode : public SDNode { 150063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner ISD::CondCode Condition; 1501c76e3c86026b9fa44bfbb0888881b52955078011Chris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 150263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerprotected: 150363b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner friend class SelectionDAG; 1504423c2260f95883f7c84ac962e58ac66c3a11efacDan Gohman explicit CondCodeSDNode(ISD::CondCode Cond) 1505bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner : SDNode(ISD::CONDCODE, getSDVTList(MVT::Other)), Condition(Cond) { 150663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 150763b570d49b7bf205d48749aae1467ef96152ea7aChris Lattnerpublic: 150863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 15097cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner ISD::CondCode get() const { return Condition; } 151063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 15117cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner static bool classof(const CondCodeSDNode *) { return true; } 151263b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner static bool classof(const SDNode *N) { 15137cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner return N->getOpcode() == ISD::CONDCODE; 151463b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner } 151563b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner}; 151663b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 151715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner/// VTSDNode - This class is used to represent MVT::ValueType's, which are used 151815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner/// to parameterize some operations. 151915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattnerclass VTSDNode : public SDNode { 152015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner MVT::ValueType ValueType; 1521c76e3c86026b9fa44bfbb0888881b52955078011Chris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 152215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattnerprotected: 152315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner friend class SelectionDAG; 1524423c2260f95883f7c84ac962e58ac66c3a11efacDan Gohman explicit VTSDNode(MVT::ValueType VT) 1525bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner : SDNode(ISD::VALUETYPE, getSDVTList(MVT::Other)), ValueType(VT) { 152663e3f14df6cf76f1a12de1153e1114f4b20b15a9Chris Lattner } 152715e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattnerpublic: 152815e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner 152915e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner MVT::ValueType getVT() const { return ValueType; } 153015e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner 153115e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner static bool classof(const VTSDNode *) { return true; } 153215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner static bool classof(const SDNode *N) { 153315e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner return N->getOpcode() == ISD::VALUETYPE; 153415e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner } 153515e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner}; 153615e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner 15379de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel/// LSBaseSDNode - Base class for LoadSDNode and StoreSDNode 15389de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel/// 15399de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michelclass LSBaseSDNode : public SDNode { 15409de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michelprivate: 1541b625f2f8960de32bc973092aaee8ac62863006feDan Gohman // AddrMode - unindexed, pre-indexed, post-indexed. 1542b625f2f8960de32bc973092aaee8ac62863006feDan Gohman ISD::MemIndexedMode AddrMode; 1543b625f2f8960de32bc973092aaee8ac62863006feDan Gohman 1544b625f2f8960de32bc973092aaee8ac62863006feDan Gohman // MemoryVT - VT of in-memory value. 1545b625f2f8960de32bc973092aaee8ac62863006feDan Gohman MVT::ValueType MemoryVT; 1546b625f2f8960de32bc973092aaee8ac62863006feDan Gohman 15479de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel //! SrcValue - Memory location for alias analysis. 15489de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel const Value *SrcValue; 15499de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel 15509de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel //! SVOffset - Memory location offset. 15519de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel int SVOffset; 15529de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel 15539de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel //! Alignment - Alignment of memory location in bytes. 15549de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel unsigned Alignment; 15559de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel 15569de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel //! IsVolatile - True if the store is volatile. 15579de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel bool IsVolatile; 15589de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michelprotected: 15599de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel //! Operand array for load and store 15609de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel /*! 15619de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel \note Moving this array to the base class captures more 15629de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel common functionality shared between LoadSDNode and 15639de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel StoreSDNode 15649de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel */ 15659de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel SDOperand Ops[4]; 15669de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michelpublic: 1567b625f2f8960de32bc973092aaee8ac62863006feDan Gohman LSBaseSDNode(ISD::NodeType NodeTy, SDOperand *Operands, unsigned NumOperands, 1568b625f2f8960de32bc973092aaee8ac62863006feDan Gohman SDVTList VTs, ISD::MemIndexedMode AM, MVT::ValueType VT, 1569b625f2f8960de32bc973092aaee8ac62863006feDan Gohman const Value *SV, int SVO, unsigned Align, bool Vol) 15709de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel : SDNode(NodeTy, VTs), 1571b625f2f8960de32bc973092aaee8ac62863006feDan Gohman AddrMode(AM), MemoryVT(VT), 15729de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel SrcValue(SV), SVOffset(SVO), Alignment(Align), IsVolatile(Vol) 1573b625f2f8960de32bc973092aaee8ac62863006feDan Gohman { 1574b625f2f8960de32bc973092aaee8ac62863006feDan Gohman for (unsigned i = 0; i != NumOperands; ++i) 1575b625f2f8960de32bc973092aaee8ac62863006feDan Gohman Ops[i] = Operands[i]; 1576b625f2f8960de32bc973092aaee8ac62863006feDan Gohman InitOperands(Ops, NumOperands); 1577b625f2f8960de32bc973092aaee8ac62863006feDan Gohman assert(Align != 0 && "Loads and stores should have non-zero aligment"); 1578b625f2f8960de32bc973092aaee8ac62863006feDan Gohman assert((getOffset().getOpcode() == ISD::UNDEF || isIndexed()) && 1579b625f2f8960de32bc973092aaee8ac62863006feDan Gohman "Only indexed loads and stores have a non-undef offset operand"); 1580b625f2f8960de32bc973092aaee8ac62863006feDan Gohman } 15819de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel 15829de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel const SDOperand getChain() const { 15839de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel return getOperand(0); 15849de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel } 15859de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel const SDOperand getBasePtr() const { 15869de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel return getOperand(getOpcode() == ISD::LOAD ? 1 : 2); 15879de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel } 15889de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel const SDOperand getOffset() const { 15899de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel return getOperand(getOpcode() == ISD::LOAD ? 2 : 3); 15909de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel } 15919de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel const SDOperand getValue() const { 15929de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel assert(getOpcode() == ISD::STORE); 15939de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel return getOperand(1); 15949de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel } 15959de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel 15969de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel const Value *getSrcValue() const { return SrcValue; } 15979de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel int getSrcValueOffset() const { return SVOffset; } 15989de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel unsigned getAlignment() const { return Alignment; } 1599b625f2f8960de32bc973092aaee8ac62863006feDan Gohman MVT::ValueType getMemoryVT() const { return MemoryVT; } 16009de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel bool isVolatile() const { return IsVolatile; } 16019de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel 1602b625f2f8960de32bc973092aaee8ac62863006feDan Gohman ISD::MemIndexedMode getAddressingMode() const { return AddrMode; } 1603b625f2f8960de32bc973092aaee8ac62863006feDan Gohman 1604b625f2f8960de32bc973092aaee8ac62863006feDan Gohman /// isIndexed - Return true if this is a pre/post inc/dec load/store. 1605b625f2f8960de32bc973092aaee8ac62863006feDan Gohman bool isIndexed() const { return AddrMode != ISD::UNINDEXED; } 1606b625f2f8960de32bc973092aaee8ac62863006feDan Gohman 1607b625f2f8960de32bc973092aaee8ac62863006feDan Gohman /// isUnindexed - Return true if this is NOT a pre/post inc/dec load/store. 1608b625f2f8960de32bc973092aaee8ac62863006feDan Gohman bool isUnindexed() const { return AddrMode == ISD::UNINDEXED; } 1609b625f2f8960de32bc973092aaee8ac62863006feDan Gohman 161069de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman /// getMemOperand - Return a MemOperand object describing the memory 161169de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman /// reference performed by this load or store. 161269de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman MemOperand getMemOperand() const; 161369de1932b350d7cdfc0ed1f4198d6f78c7822a02Dan Gohman 16149de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel static bool classof(const LSBaseSDNode *N) { return true; } 1615b625f2f8960de32bc973092aaee8ac62863006feDan Gohman static bool classof(const SDNode *N) { 1616b625f2f8960de32bc973092aaee8ac62863006feDan Gohman return N->getOpcode() == ISD::LOAD || 1617b625f2f8960de32bc973092aaee8ac62863006feDan Gohman N->getOpcode() == ISD::STORE; 1618b625f2f8960de32bc973092aaee8ac62863006feDan Gohman } 16199de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel}; 16209de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michel 162124446e253a17720f6462288255ab5ebd13b8491fEvan Cheng/// LoadSDNode - This class is used to represent ISD::LOAD nodes. 162224446e253a17720f6462288255ab5ebd13b8491fEvan Cheng/// 16239de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michelclass LoadSDNode : public LSBaseSDNode { 1624c76e3c86026b9fa44bfbb0888881b52955078011Chris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 1625bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner 162681c384578828dde08f63a4f030f4860a92391cddEvan Cheng // ExtType - non-ext, anyext, sext, zext. 162781c384578828dde08f63a4f030f4860a92391cddEvan Cheng ISD::LoadExtType ExtType; 162881c384578828dde08f63a4f030f4860a92391cddEvan Cheng 162924446e253a17720f6462288255ab5ebd13b8491fEvan Chengprotected: 163024446e253a17720f6462288255ab5ebd13b8491fEvan Cheng friend class SelectionDAG; 1631ab4ed595385d0b9421c0d45c809ec6324cf11f11Chris Lattner LoadSDNode(SDOperand *ChainPtrOff, SDVTList VTs, 1632144d8f09e139f691cafadbc17873943ba4c465f3Evan Cheng ISD::MemIndexedMode AM, ISD::LoadExtType ETy, MVT::ValueType LVT, 163395c218a83ecf77590b9dc40c636720772d2b5cd7Christopher Lamb const Value *SV, int O=0, unsigned Align=0, bool Vol=false) 1634b625f2f8960de32bc973092aaee8ac62863006feDan Gohman : LSBaseSDNode(ISD::LOAD, ChainPtrOff, 3, 1635b625f2f8960de32bc973092aaee8ac62863006feDan Gohman VTs, AM, LVT, SV, O, Align, Vol), 1636b625f2f8960de32bc973092aaee8ac62863006feDan Gohman ExtType(ETy) { } 163724446e253a17720f6462288255ab5ebd13b8491fEvan Chengpublic: 163824446e253a17720f6462288255ab5ebd13b8491fEvan Cheng 163924446e253a17720f6462288255ab5ebd13b8491fEvan Cheng ISD::LoadExtType getExtensionType() const { return ExtType; } 164039354cb743c5a1473de7a80b957c61e92cf76852Chris Lattner 164124446e253a17720f6462288255ab5ebd13b8491fEvan Cheng static bool classof(const LoadSDNode *) { return true; } 164224446e253a17720f6462288255ab5ebd13b8491fEvan Cheng static bool classof(const SDNode *N) { 164324446e253a17720f6462288255ab5ebd13b8491fEvan Cheng return N->getOpcode() == ISD::LOAD; 164424446e253a17720f6462288255ab5ebd13b8491fEvan Cheng } 164524446e253a17720f6462288255ab5ebd13b8491fEvan Cheng}; 164624446e253a17720f6462288255ab5ebd13b8491fEvan Cheng 164724446e253a17720f6462288255ab5ebd13b8491fEvan Cheng/// StoreSDNode - This class is used to represent ISD::STORE nodes. 164824446e253a17720f6462288255ab5ebd13b8491fEvan Cheng/// 16499de5d0dd42463f61c4ee2f9db5f3d08153c0dacfScott Michelclass StoreSDNode : public LSBaseSDNode { 1650c76e3c86026b9fa44bfbb0888881b52955078011Chris Lattner virtual void ANCHOR(); // Out-of-line virtual method to give class a home. 1651bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner 16523ec81c0ee73462b7b9acd355b0013827d06ad93cDuncan Sands // IsTruncStore - True if the op does a truncation before store. 165381c384578828dde08f63a4f030f4860a92391cddEvan Cheng bool IsTruncStore; 165424446e253a17720f6462288255ab5ebd13b8491fEvan Chengprotected: 165524446e253a17720f6462288255ab5ebd13b8491fEvan Cheng friend class SelectionDAG; 1656ab4ed595385d0b9421c0d45c809ec6324cf11f11Chris Lattner StoreSDNode(SDOperand *ChainValuePtrOff, SDVTList VTs, 1657144d8f09e139f691cafadbc17873943ba4c465f3Evan Cheng ISD::MemIndexedMode AM, bool isTrunc, MVT::ValueType SVT, 165824446e253a17720f6462288255ab5ebd13b8491fEvan Cheng const Value *SV, int O=0, unsigned Align=0, bool Vol=false) 1659b625f2f8960de32bc973092aaee8ac62863006feDan Gohman : LSBaseSDNode(ISD::STORE, ChainValuePtrOff, 4, 1660b625f2f8960de32bc973092aaee8ac62863006feDan Gohman VTs, AM, SVT, SV, O, Align, Vol), 1661b625f2f8960de32bc973092aaee8ac62863006feDan Gohman IsTruncStore(isTrunc) { } 166224446e253a17720f6462288255ab5ebd13b8491fEvan Chengpublic: 166324446e253a17720f6462288255ab5ebd13b8491fEvan Cheng 166424446e253a17720f6462288255ab5ebd13b8491fEvan Cheng bool isTruncatingStore() const { return IsTruncStore; } 166539354cb743c5a1473de7a80b957c61e92cf76852Chris Lattner 16666d0b3295777f0e9e9cce27f3473c19f78e88f700Evan Cheng static bool classof(const StoreSDNode *) { return true; } 166724446e253a17720f6462288255ab5ebd13b8491fEvan Cheng static bool classof(const SDNode *N) { 166824446e253a17720f6462288255ab5ebd13b8491fEvan Cheng return N->getOpcode() == ISD::STORE; 166924446e253a17720f6462288255ab5ebd13b8491fEvan Cheng } 167024446e253a17720f6462288255ab5ebd13b8491fEvan Cheng}; 167124446e253a17720f6462288255ab5ebd13b8491fEvan Cheng 167215e4b01920d6a0ffbe35d3e5aa88a4b42970b6a7Chris Lattner 16731080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattnerclass SDNodeIterator : public forward_iterator<SDNode, ptrdiff_t> { 16741080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner SDNode *Node; 16751080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner unsigned Operand; 1676ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman 16771080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner SDNodeIterator(SDNode *N, unsigned Op) : Node(N), Operand(Op) {} 16781080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattnerpublic: 16791080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner bool operator==(const SDNodeIterator& x) const { 16801080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner return Operand == x.Operand; 16811080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 16821080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner bool operator!=(const SDNodeIterator& x) const { return !operator==(x); } 16831080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner 16841080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner const SDNodeIterator &operator=(const SDNodeIterator &I) { 16851080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner assert(I.Node == Node && "Cannot assign iterators to two different nodes!"); 16861080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner Operand = I.Operand; 16871080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner return *this; 16881080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 1689ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman 16901080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner pointer operator*() const { 16911080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner return Node->getOperand(Operand).Val; 16921080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 16931080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner pointer operator->() const { return operator*(); } 1694ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman 16951080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner SDNodeIterator& operator++() { // Preincrement 16961080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner ++Operand; 16971080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner return *this; 16981080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 16991080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner SDNodeIterator operator++(int) { // Postincrement 1700ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman SDNodeIterator tmp = *this; ++*this; return tmp; 17011080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 17021080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner 17031080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner static SDNodeIterator begin(SDNode *N) { return SDNodeIterator(N, 0); } 17041080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner static SDNodeIterator end (SDNode *N) { 17051080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner return SDNodeIterator(N, N->getNumOperands()); 17061080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 17071080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner 17081080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner unsigned getOperand() const { return Operand; } 17091080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner const SDNode *getNode() const { return Node; } 17101080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner}; 17111080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner 17121080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattnertemplate <> struct GraphTraits<SDNode*> { 17131080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner typedef SDNode NodeType; 17141080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner typedef SDNodeIterator ChildIteratorType; 17151080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner static inline NodeType *getEntryNode(SDNode *N) { return N; } 1716ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman static inline ChildIteratorType child_begin(NodeType *N) { 17171080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner return SDNodeIterator::begin(N); 17181080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 1719ea61c358720aa6c7a159d51658b34276316aa841Misha Brukman static inline ChildIteratorType child_end(NodeType *N) { 17201080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner return SDNodeIterator::end(N); 17211080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner } 17221080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner}; 17231080b9ee534579c67f7c99364cc6fa11edbcd919Chris Lattner 1724b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattnertemplate<> 1725b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattnerstruct ilist_traits<SDNode> { 1726b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner static SDNode *getPrev(const SDNode *N) { return N->Prev; } 1727b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner static SDNode *getNext(const SDNode *N) { return N->Next; } 1728b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner 1729b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner static void setPrev(SDNode *N, SDNode *Prev) { N->Prev = Prev; } 1730b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner static void setNext(SDNode *N, SDNode *Next) { N->Next = Next; } 1731b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner 1732b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner static SDNode *createSentinel() { 1733bc2e26241d507ecd6c79598e5175f90852b716b3Chris Lattner return new SDNode(ISD::EntryToken, SDNode::getSDVTList(MVT::Other)); 1734b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner } 1735b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner static void destroySentinel(SDNode *N) { delete N; } 1736b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner //static SDNode *createNode(const SDNode &V) { return new SDNode(V); } 1737b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner 1738b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner 1739b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner void addNodeToList(SDNode *NTy) {} 1740b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner void removeNodeFromList(SDNode *NTy) {} 1741b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner void transferNodesFromList(iplist<SDNode, ilist_traits> &L2, 1742b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner const ilist_iterator<SDNode> &X, 1743b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner const ilist_iterator<SDNode> &Y) {} 1744b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner}; 1745b80e2be8894db9f843f32ebaffb9b7fd6b57d206Chris Lattner 1746c548428c5d7328592f4db6f6cd815af18b3152a3Evan Chengnamespace ISD { 1747186edc8fa13d0e02d3c17563ad2bd78ac5963a67Evan Cheng /// isNormalLoad - Returns true if the specified node is a non-extending 1748186edc8fa13d0e02d3c17563ad2bd78ac5963a67Evan Cheng /// and unindexed load. 1749186edc8fa13d0e02d3c17563ad2bd78ac5963a67Evan Cheng inline bool isNormalLoad(const SDNode *N) { 1750186edc8fa13d0e02d3c17563ad2bd78ac5963a67Evan Cheng if (N->getOpcode() != ISD::LOAD) 1751186edc8fa13d0e02d3c17563ad2bd78ac5963a67Evan Cheng return false; 1752186edc8fa13d0e02d3c17563ad2bd78ac5963a67Evan Cheng const LoadSDNode *Ld = cast<LoadSDNode>(N); 1753186edc8fa13d0e02d3c17563ad2bd78ac5963a67Evan Cheng return Ld->getExtensionType() == ISD::NON_EXTLOAD && 1754186edc8fa13d0e02d3c17563ad2bd78ac5963a67Evan Cheng Ld->getAddressingMode() == ISD::UNINDEXED; 1755186edc8fa13d0e02d3c17563ad2bd78ac5963a67Evan Cheng } 1756186edc8fa13d0e02d3c17563ad2bd78ac5963a67Evan Cheng 175724446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// isNON_EXTLoad - Returns true if the specified node is a non-extending 175824446e253a17720f6462288255ab5ebd13b8491fEvan Cheng /// load. 175924446e253a17720f6462288255ab5ebd13b8491fEvan Cheng inline bool isNON_EXTLoad(const SDNode *N) { 176024446e253a17720f6462288255ab5ebd13b8491fEvan Cheng return N->getOpcode() == ISD::LOAD && 176124446e253a17720f6462288255ab5ebd13b8491fEvan Cheng cast<LoadSDNode>(N)->getExtensionType() == ISD::NON_EXTLOAD; 176224446e253a17720f6462288255ab5ebd13b8491fEvan Cheng } 176324446e253a17720f6462288255ab5ebd13b8491fEvan Cheng 1764c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng /// isEXTLoad - Returns true if the specified node is a EXTLOAD. 1765c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng /// 1766c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng inline bool isEXTLoad(const SDNode *N) { 176724446e253a17720f6462288255ab5ebd13b8491fEvan Cheng return N->getOpcode() == ISD::LOAD && 176824446e253a17720f6462288255ab5ebd13b8491fEvan Cheng cast<LoadSDNode>(N)->getExtensionType() == ISD::EXTLOAD; 1769c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng } 1770c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng 1771c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng /// isSEXTLoad - Returns true if the specified node is a SEXTLOAD. 1772c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng /// 1773c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng inline bool isSEXTLoad(const SDNode *N) { 177424446e253a17720f6462288255ab5ebd13b8491fEvan Cheng return N->getOpcode() == ISD::LOAD && 177524446e253a17720f6462288255ab5ebd13b8491fEvan Cheng cast<LoadSDNode>(N)->getExtensionType() == ISD::SEXTLOAD; 1776c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng } 1777c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng 1778c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng /// isZEXTLoad - Returns true if the specified node is a ZEXTLOAD. 1779c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng /// 1780c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng inline bool isZEXTLoad(const SDNode *N) { 178124446e253a17720f6462288255ab5ebd13b8491fEvan Cheng return N->getOpcode() == ISD::LOAD && 178224446e253a17720f6462288255ab5ebd13b8491fEvan Cheng cast<LoadSDNode>(N)->getExtensionType() == ISD::ZEXTLOAD; 1783c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng } 17848b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng 178502c50e4891841c28b2a743731dfc60744bb78879Evan Cheng /// isUNINDEXEDLoad - Returns true if the specified node is a unindexed load. 178602c50e4891841c28b2a743731dfc60744bb78879Evan Cheng /// 178702c50e4891841c28b2a743731dfc60744bb78879Evan Cheng inline bool isUNINDEXEDLoad(const SDNode *N) { 178802c50e4891841c28b2a743731dfc60744bb78879Evan Cheng return N->getOpcode() == ISD::LOAD && 178902c50e4891841c28b2a743731dfc60744bb78879Evan Cheng cast<LoadSDNode>(N)->getAddressingMode() == ISD::UNINDEXED; 179002c50e4891841c28b2a743731dfc60744bb78879Evan Cheng } 179102c50e4891841c28b2a743731dfc60744bb78879Evan Cheng 17928b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng /// isNON_TRUNCStore - Returns true if the specified node is a non-truncating 17938b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng /// store. 17948b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng inline bool isNON_TRUNCStore(const SDNode *N) { 17958b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng return N->getOpcode() == ISD::STORE && 17968b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng !cast<StoreSDNode>(N)->isTruncatingStore(); 17978b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng } 17988b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng 17998b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng /// isTRUNCStore - Returns true if the specified node is a truncating 18008b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng /// store. 18018b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng inline bool isTRUNCStore(const SDNode *N) { 18028b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng return N->getOpcode() == ISD::STORE && 18038b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng cast<StoreSDNode>(N)->isTruncatingStore(); 18048b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng } 1805c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng} 1806c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng 1807c548428c5d7328592f4db6f6cd815af18b3152a3Evan Cheng 180863b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner} // end llvm namespace 180963b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner 181063b570d49b7bf205d48749aae1467ef96152ea7aChris Lattner#endif 1811