2005-01-07 07:45:27 +00:00
|
|
|
//===-- llvm/CodeGen/SelectionDAGNodes.h - SelectionDAG Nodes ---*- C++ -*-===//
|
2005-04-21 20:39:54 +00:00
|
|
|
//
|
2005-01-07 07:45:27 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file was developed by the LLVM research group and is distributed under
|
|
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
2005-04-21 20:39:54 +00:00
|
|
|
//
|
2005-01-07 07:45:27 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2005-04-21 20:39:54 +00:00
|
|
|
//
|
2005-01-07 07:45:27 +00:00
|
|
|
// This file declares the SDNode class and derived classes, which are used to
|
|
|
|
// represent the nodes and operations present in a SelectionDAG. These nodes
|
|
|
|
// and operations are machine code level operations, with some similarities to
|
|
|
|
// the GCC RTL representation.
|
|
|
|
//
|
|
|
|
// Clients should include the SelectionDAG.h file instead of this file directly.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#ifndef LLVM_CODEGEN_SELECTIONDAGNODES_H
|
|
|
|
#define LLVM_CODEGEN_SELECTIONDAGNODES_H
|
|
|
|
|
2005-04-27 20:10:01 +00:00
|
|
|
#include "llvm/Value.h"
|
2006-10-27 23:46:08 +00:00
|
|
|
#include "llvm/ADT/FoldingSet.h"
|
2005-01-10 23:05:53 +00:00
|
|
|
#include "llvm/ADT/GraphTraits.h"
|
|
|
|
#include "llvm/ADT/iterator"
|
2007-08-24 20:59:15 +00:00
|
|
|
#include "llvm/ADT/APFloat.h"
|
2006-09-12 21:00:35 +00:00
|
|
|
#include "llvm/CodeGen/ValueTypes.h"
|
2005-01-07 19:21:49 +00:00
|
|
|
#include "llvm/Support/DataTypes.h"
|
2005-01-07 07:45:27 +00:00
|
|
|
#include <cassert>
|
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
|
|
|
|
class SelectionDAG;
|
|
|
|
class GlobalValue;
|
|
|
|
class MachineBasicBlock;
|
2006-09-12 21:00:35 +00:00
|
|
|
class MachineConstantPoolValue;
|
2005-01-07 07:45:27 +00:00
|
|
|
class SDNode;
|
2007-09-17 18:34:04 +00:00
|
|
|
template <typename T> struct DenseMapInfo;
|
2005-01-07 07:45:27 +00:00
|
|
|
template <typename T> struct simplify_type;
|
2005-11-09 23:46:43 +00:00
|
|
|
template <typename T> struct ilist_traits;
|
|
|
|
template<typename NodeTy, typename Traits> class iplist;
|
|
|
|
template<typename NodeTy> class ilist_iterator;
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2006-08-15 19:11:05 +00:00
|
|
|
/// SDVTList - This represents a list of ValueType's that has been intern'd by
|
|
|
|
/// a SelectionDAG. Instances of this simple value class are returned by
|
|
|
|
/// SelectionDAG::getVTList(...).
|
|
|
|
///
|
|
|
|
struct SDVTList {
|
|
|
|
const MVT::ValueType *VTs;
|
|
|
|
unsigned short NumVTs;
|
|
|
|
};
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
/// ISD namespace - This namespace contains an enum which represents all of the
|
|
|
|
/// SelectionDAG node types and value types.
|
|
|
|
///
|
|
|
|
namespace ISD {
|
2007-03-07 16:25:09 +00:00
|
|
|
namespace ParamFlags {
|
|
|
|
enum Flags {
|
|
|
|
NoFlagSet = 0,
|
|
|
|
ZExt = 1<<0, ///< Parameter should be zero extended
|
|
|
|
ZExtOffs = 0,
|
|
|
|
SExt = 1<<1, ///< Parameter should be sign extended
|
|
|
|
SExtOffs = 1,
|
|
|
|
InReg = 1<<2, ///< Parameter should be passed in register
|
|
|
|
InRegOffs = 2,
|
|
|
|
StructReturn = 1<<3, ///< Hidden struct-return pointer
|
|
|
|
StructReturnOffs = 3,
|
2007-07-06 10:57:03 +00:00
|
|
|
ByVal = 1<<4, ///< Struct passed by value
|
|
|
|
ByValOffs = 4,
|
2007-07-27 12:58:54 +00:00
|
|
|
Nest = 1<<5, ///< Parameter is nested function static chain
|
|
|
|
NestOffs = 5,
|
2007-08-10 14:44:42 +00:00
|
|
|
ByValAlign = 0xF << 6, //< The alignment of the struct
|
|
|
|
ByValAlignOffs = 6,
|
|
|
|
ByValSize = 0x1ffff << 10, //< The size of the struct
|
|
|
|
ByValSizeOffs = 10,
|
2007-03-07 16:25:09 +00:00
|
|
|
OrigAlignment = 0x1F<<27,
|
|
|
|
OrigAlignmentOffs = 27
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// ISD::NodeType enum - This enum defines all of the operators valid in a
|
|
|
|
/// SelectionDAG.
|
|
|
|
///
|
|
|
|
enum NodeType {
|
2006-05-27 00:40:15 +00:00
|
|
|
// DELETED_NODE - This is an illegal flag value that is used to catch
|
|
|
|
// errors. This opcode is not a legal opcode for any node.
|
|
|
|
DELETED_NODE,
|
|
|
|
|
2005-01-13 17:58:35 +00:00
|
|
|
// EntryToken - This is the marker used to indicate the start of the region.
|
|
|
|
EntryToken,
|
|
|
|
|
2005-08-27 19:06:05 +00:00
|
|
|
// Token factor - This node takes multiple tokens as input and produces a
|
2005-01-13 17:58:35 +00:00
|
|
|
// single token result. This is used to represent the fact that the operand
|
|
|
|
// operators are independent of each other.
|
|
|
|
TokenFactor,
|
2005-08-30 02:39:32 +00:00
|
|
|
|
|
|
|
// AssertSext, AssertZext - These nodes record if a register contains a
|
|
|
|
// value that has already been zero or sign extended from a narrower type.
|
|
|
|
// These nodes take two operands. The first is the node that has already
|
|
|
|
// been extended, and the second is a value type node indicating the width
|
|
|
|
// of the extension
|
|
|
|
AssertSext, AssertZext,
|
2005-04-21 20:39:54 +00:00
|
|
|
|
2005-01-13 17:58:35 +00:00
|
|
|
// Various leaf nodes.
|
2006-03-01 00:51:13 +00:00
|
|
|
STRING, BasicBlock, VALUETYPE, CONDCODE, Register,
|
|
|
|
Constant, ConstantFP,
|
2007-04-20 21:38:10 +00:00
|
|
|
GlobalAddress, GlobalTLSAddress, FrameIndex,
|
|
|
|
JumpTable, ConstantPool, ExternalSymbol,
|
2006-03-01 00:51:13 +00:00
|
|
|
|
2006-10-11 04:29:42 +00:00
|
|
|
// The address of the GOT
|
|
|
|
GLOBAL_OFFSET_TABLE,
|
2007-01-29 22:58:52 +00:00
|
|
|
|
|
|
|
// FRAMEADDR, RETURNADDR - These nodes represent llvm.frameaddress and
|
|
|
|
// llvm.returnaddress on the DAG. These nodes take one operand, the index
|
|
|
|
// of the frame or return address to return. An index of zero corresponds
|
|
|
|
// to the current function's frame or return address, an index of one to the
|
|
|
|
// parent's frame or return address, and so on.
|
|
|
|
FRAMEADDR, RETURNADDR,
|
2007-07-14 14:06:15 +00:00
|
|
|
|
|
|
|
// FRAME_TO_ARGS_OFFSET - This node represents offset from frame pointer to
|
|
|
|
// first (possible) on-stack argument. This is needed for correct stack
|
|
|
|
// adjustment during unwind.
|
|
|
|
FRAME_TO_ARGS_OFFSET,
|
2007-02-21 22:37:22 +00:00
|
|
|
|
|
|
|
// RESULT, OUTCHAIN = EXCEPTIONADDR(INCHAIN) - This node represents the
|
|
|
|
// address of the exception block on entry to an landing pad block.
|
|
|
|
EXCEPTIONADDR,
|
|
|
|
|
|
|
|
// RESULT, OUTCHAIN = EHSELECTION(INCHAIN, EXCEPTION) - This node represents
|
|
|
|
// the selection index of the exception thrown.
|
|
|
|
EHSELECTION,
|
2006-09-24 19:45:58 +00:00
|
|
|
|
2007-07-14 14:06:15 +00:00
|
|
|
// OUTCHAIN = EH_RETURN(INCHAIN, OFFSET, HANDLER) - This node represents
|
|
|
|
// 'eh_return' gcc dwarf builtin, which is used to return from
|
|
|
|
// exception. The general meaning is: adjust stack by OFFSET and pass
|
|
|
|
// execution to HANDLER. Many platform-related details also :)
|
|
|
|
EH_RETURN,
|
|
|
|
|
2006-01-29 06:24:40 +00:00
|
|
|
// TargetConstant* - Like Constant*, but the DAG does not do any folding or
|
|
|
|
// simplification of the constant.
|
2005-08-17 00:33:30 +00:00
|
|
|
TargetConstant,
|
2006-01-29 06:24:40 +00:00
|
|
|
TargetConstantFP,
|
2005-08-19 22:31:34 +00:00
|
|
|
|
|
|
|
// TargetGlobalAddress - Like GlobalAddress, but the DAG does no folding or
|
|
|
|
// anything else with this node, and this is valid in the target-specific
|
|
|
|
// dag, turning into a GlobalAddress operand.
|
|
|
|
TargetGlobalAddress,
|
2007-04-20 21:38:10 +00:00
|
|
|
TargetGlobalTLSAddress,
|
2005-08-25 00:43:01 +00:00
|
|
|
TargetFrameIndex,
|
2006-04-22 18:53:45 +00:00
|
|
|
TargetJumpTable,
|
2005-08-25 05:02:41 +00:00
|
|
|
TargetConstantPool,
|
2005-10-23 03:40:17 +00:00
|
|
|
TargetExternalSymbol,
|
2006-03-24 01:03:55 +00:00
|
|
|
|
2006-03-28 00:39:06 +00:00
|
|
|
/// RESULT = INTRINSIC_WO_CHAIN(INTRINSICID, arg1, arg2, ...)
|
|
|
|
/// This node represents a target intrinsic function with no side effects.
|
|
|
|
/// The first operand is the ID number of the intrinsic from the
|
|
|
|
/// llvm::Intrinsic namespace. The operands to the intrinsic follow. The
|
|
|
|
/// node has returns the result of the intrinsic.
|
|
|
|
INTRINSIC_WO_CHAIN,
|
|
|
|
|
|
|
|
/// RESULT,OUTCHAIN = INTRINSIC_W_CHAIN(INCHAIN, INTRINSICID, arg1, ...)
|
|
|
|
/// This node represents a target intrinsic function with side effects that
|
|
|
|
/// returns a result. The first operand is a chain pointer. The second is
|
|
|
|
/// the ID number of the intrinsic from the llvm::Intrinsic namespace. The
|
|
|
|
/// operands to the intrinsic follow. The node has two results, the result
|
|
|
|
/// of the intrinsic and an output chain.
|
|
|
|
INTRINSIC_W_CHAIN,
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2006-03-28 00:39:06 +00:00
|
|
|
/// OUTCHAIN = INTRINSIC_VOID(INCHAIN, INTRINSICID, arg1, arg2, ...)
|
|
|
|
/// This node represents a target intrinsic function with side effects that
|
|
|
|
/// does not return a result. The first operand is a chain pointer. The
|
|
|
|
/// second is the ID number of the intrinsic from the llvm::Intrinsic
|
|
|
|
/// namespace. The operands to the intrinsic follow.
|
|
|
|
INTRINSIC_VOID,
|
|
|
|
|
2005-08-16 21:55:35 +00:00
|
|
|
// CopyToReg - This node has three operands: a chain, a register number to
|
|
|
|
// set to this value, and a value.
|
2005-01-07 07:45:27 +00:00
|
|
|
CopyToReg,
|
|
|
|
|
|
|
|
// CopyFromReg - This node indicates that the input value is a virtual or
|
|
|
|
// physical register that is defined outside of the scope of this
|
2005-01-13 20:50:02 +00:00
|
|
|
// SelectionDAG. The register is available from the RegSDNode object.
|
2005-01-07 07:45:27 +00:00
|
|
|
CopyFromReg,
|
|
|
|
|
2005-04-01 22:34:39 +00:00
|
|
|
// UNDEF - An undefined node
|
|
|
|
UNDEF,
|
2006-04-11 21:30:42 +00:00
|
|
|
|
2007-01-28 13:31:35 +00:00
|
|
|
/// FORMAL_ARGUMENTS(CHAIN, CC#, ISVARARG, FLAG0, ..., FLAGn) - This node
|
|
|
|
/// represents the formal arguments for a function. CC# is a Constant value
|
|
|
|
/// indicating the calling convention of the function, and ISVARARG is a
|
|
|
|
/// flag that indicates whether the function is varargs or not. This node
|
|
|
|
/// has one result value for each incoming argument, plus one for the output
|
|
|
|
/// chain. It must be custom legalized. See description of CALL node for
|
|
|
|
/// FLAG argument contents explanation.
|
2006-05-16 06:43:59 +00:00
|
|
|
///
|
2006-04-11 21:30:42 +00:00
|
|
|
FORMAL_ARGUMENTS,
|
2006-05-16 22:52:27 +00:00
|
|
|
|
|
|
|
/// RV1, RV2...RVn, CHAIN = CALL(CHAIN, CC#, ISVARARG, ISTAILCALL, CALLEE,
|
2007-01-28 13:31:35 +00:00
|
|
|
/// ARG0, FLAG0, ARG1, FLAG1, ... ARGn, FLAGn)
|
2006-05-16 22:52:27 +00:00
|
|
|
/// This node represents a fully general function call, before the legalizer
|
2007-01-28 13:31:35 +00:00
|
|
|
/// runs. This has one result value for each argument / flag pair, plus
|
|
|
|
/// a chain result. It must be custom legalized. Flag argument indicates
|
|
|
|
/// misc. argument attributes. Currently:
|
|
|
|
/// Bit 0 - signness
|
|
|
|
/// Bit 1 - 'inreg' attribute
|
|
|
|
/// Bit 2 - 'sret' attribute
|
2007-08-10 14:44:42 +00:00
|
|
|
/// Bit 4 - 'byval' attribute
|
|
|
|
/// Bit 5 - 'nest' attribute
|
|
|
|
/// Bit 6-9 - alignment of byval structures
|
|
|
|
/// Bit 10-26 - size of byval structures
|
2007-02-13 17:57:38 +00:00
|
|
|
/// Bits 31:27 - argument ABI alignment in the first argument piece and
|
|
|
|
/// alignment '1' in other argument pieces.
|
2006-05-16 22:52:27 +00:00
|
|
|
CALL,
|
2005-04-01 22:34:39 +00:00
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
// EXTRACT_ELEMENT - This is used to get the first or second (determined by
|
|
|
|
// a Constant, which is required to be operand #1), element of the aggregate
|
|
|
|
// value specified as operand #0. This is only for use before legalization,
|
|
|
|
// for values that will be broken into multiple registers.
|
|
|
|
EXTRACT_ELEMENT,
|
|
|
|
|
|
|
|
// BUILD_PAIR - This is the opposite of EXTRACT_ELEMENT in some ways. Given
|
|
|
|
// two values of the same integer value type, this produces a value twice as
|
|
|
|
// big. Like EXTRACT_ELEMENT, this can only be used before legalization.
|
|
|
|
BUILD_PAIR,
|
2005-11-20 22:55:57 +00:00
|
|
|
|
|
|
|
// MERGE_VALUES - This node takes multiple discrete operands and returns
|
|
|
|
// them all as its individual results. This nodes has exactly the same
|
|
|
|
// number of inputs and outputs, and is only valid before legalization.
|
|
|
|
// This node is useful for some pieces of the code generator that want to
|
|
|
|
// think about a single node with multiple results, not multiple nodes.
|
|
|
|
MERGE_VALUES,
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2005-09-28 22:29:58 +00:00
|
|
|
// Simple integer binary arithmetic operators.
|
2005-04-06 04:21:29 +00:00
|
|
|
ADD, SUB, MUL, SDIV, UDIV, SREM, UREM,
|
2007-10-05 14:07:56 +00:00
|
|
|
|
|
|
|
// SMUL_LOHI/UMUL_LOHI - Multiply two integers of type iN, producing
|
|
|
|
// a signed/unsigned value of type i[2*n], and return the full value as
|
|
|
|
// two results, each of type iN.
|
|
|
|
SMUL_LOHI, UMUL_LOHI,
|
|
|
|
|
|
|
|
// SDIVREM/UDIVREM - Divide two integers and produce both a quotient and
|
|
|
|
// remainder result.
|
|
|
|
SDIVREM, UDIVREM,
|
2005-09-28 22:29:58 +00:00
|
|
|
|
2007-03-04 20:40:06 +00:00
|
|
|
// CARRY_FALSE - This node is used when folding other nodes,
|
|
|
|
// like ADDC/SUBC, which indicate the carry result is always false.
|
|
|
|
CARRY_FALSE,
|
|
|
|
|
2006-02-17 05:43:56 +00:00
|
|
|
// Carry-setting nodes for multiple precision addition and subtraction.
|
|
|
|
// These nodes take two operands of the same value type, and produce two
|
|
|
|
// results. The first result is the normal add or sub result, the second
|
|
|
|
// result is the carry flag result.
|
|
|
|
ADDC, SUBC,
|
|
|
|
|
|
|
|
// Carry-using nodes for multiple precision addition and subtraction. These
|
|
|
|
// nodes take three operands: The first two are the normal lhs and rhs to
|
|
|
|
// the add or sub, and the third is the input carry flag. These nodes
|
|
|
|
// produce two results; the normal result of the add or sub, and the output
|
|
|
|
// carry flag. These nodes both read and write a carry flag to allow them
|
|
|
|
// to them to be chained together for add and sub of arbitrarily large
|
|
|
|
// values.
|
|
|
|
ADDE, SUBE,
|
|
|
|
|
2005-09-28 22:29:58 +00:00
|
|
|
// Simple binary floating point operators.
|
|
|
|
FADD, FSUB, FMUL, FDIV, FREM,
|
2006-03-05 05:06:40 +00:00
|
|
|
|
|
|
|
// FCOPYSIGN(X, Y) - Return the value of X with the sign of Y. NOTE: This
|
|
|
|
// DAG node does not require that X and Y have the same type, just that they
|
|
|
|
// are both floating point. X and the result must have the same type.
|
|
|
|
// FCOPYSIGN(f32, f64) is allowed.
|
|
|
|
FCOPYSIGN,
|
2006-03-17 19:53:41 +00:00
|
|
|
|
2007-07-06 13:27:33 +00:00
|
|
|
/// BUILD_VECTOR(ELT0, ELT1, ELT2, ELT3,...) - Return a vector
|
2006-03-19 00:52:25 +00:00
|
|
|
/// with the specified, possibly variable, elements. The number of elements
|
|
|
|
/// is required to be a power of two.
|
|
|
|
BUILD_VECTOR,
|
|
|
|
|
2007-06-25 16:23:39 +00:00
|
|
|
/// INSERT_VECTOR_ELT(VECTOR, VAL, IDX) - Returns VECTOR with the element
|
|
|
|
/// at IDX replaced with VAL.
|
2006-03-19 00:52:25 +00:00
|
|
|
INSERT_VECTOR_ELT,
|
2006-03-21 20:43:08 +00:00
|
|
|
|
|
|
|
/// EXTRACT_VECTOR_ELT(VECTOR, IDX) - Returns a single element from VECTOR
|
2007-06-25 16:23:39 +00:00
|
|
|
/// identified by the (potentially variable) element number IDX.
|
2006-03-21 20:43:08 +00:00
|
|
|
EXTRACT_VECTOR_ELT,
|
2006-03-19 00:52:25 +00:00
|
|
|
|
2007-06-25 16:23:39 +00:00
|
|
|
/// CONCAT_VECTORS(VECTOR0, VECTOR1, ...) - Given a number of values of
|
|
|
|
/// vector type with the same length and element type, this produces a
|
|
|
|
/// concatenated vector result value, with length equal to the sum of the
|
2007-06-28 23:29:44 +00:00
|
|
|
/// lengths of the input vectors.
|
2007-06-25 16:23:39 +00:00
|
|
|
CONCAT_VECTORS,
|
2007-06-13 15:12:02 +00:00
|
|
|
|
2007-06-25 16:23:39 +00:00
|
|
|
/// EXTRACT_SUBVECTOR(VECTOR, IDX) - Returns a subvector from VECTOR (an
|
|
|
|
/// vector value) starting with the (potentially variable) element number
|
|
|
|
/// IDX, which must be a multiple of the result vector length.
|
|
|
|
EXTRACT_SUBVECTOR,
|
2007-06-13 15:12:02 +00:00
|
|
|
|
2006-03-19 23:42:51 +00:00
|
|
|
/// VECTOR_SHUFFLE(VEC1, VEC2, SHUFFLEVEC) - Returns a vector, of the same
|
|
|
|
/// type as VEC1/VEC2. SHUFFLEVEC is a BUILD_VECTOR of constant int values
|
|
|
|
/// (regardless of whether its datatype is legal or not) that indicate
|
|
|
|
/// which value each result element will get. The elements of VEC1/VEC2 are
|
|
|
|
/// enumerated in order. This is quite similar to the Altivec 'vperm'
|
|
|
|
/// instruction, except that the indices must be constants and are in terms
|
|
|
|
/// of the element size of VEC1/VEC2, not in terms of bytes.
|
|
|
|
VECTOR_SHUFFLE,
|
|
|
|
|
2006-03-19 05:26:45 +00:00
|
|
|
/// SCALAR_TO_VECTOR(VAL) - This represents the operation of loading a
|
|
|
|
/// scalar value into the low element of the resultant vector type. The top
|
|
|
|
/// elements of the vector are undefined.
|
|
|
|
SCALAR_TO_VECTOR,
|
|
|
|
|
2007-07-26 07:34:40 +00:00
|
|
|
// EXTRACT_SUBREG - This node is used to extract a sub-register value.
|
|
|
|
// This node takes a superreg and a constant sub-register index as operands.
|
|
|
|
EXTRACT_SUBREG,
|
|
|
|
|
|
|
|
// INSERT_SUBREG - This node is used to insert a sub-register value.
|
|
|
|
// This node takes a superreg, a subreg value, and a constant sub-register
|
|
|
|
// index as operands.
|
|
|
|
INSERT_SUBREG,
|
|
|
|
|
2005-04-06 04:21:29 +00:00
|
|
|
// MULHU/MULHS - Multiply high - Multiply two integers of type iN, producing
|
|
|
|
// an unsigned/signed value of type i[2*n], then return the top part.
|
|
|
|
MULHU, MULHS,
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2006-01-11 21:21:00 +00:00
|
|
|
// Bitwise operators - logical and, logical or, logical xor, shift left,
|
|
|
|
// shift right algebraic (shift in sign bits), shift right logical (shift in
|
|
|
|
// zeroes), rotate left, rotate right, and byteswap.
|
|
|
|
AND, OR, XOR, SHL, SRA, SRL, ROTL, ROTR, BSWAP,
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2005-05-03 17:19:30 +00:00
|
|
|
// Counting operators
|
|
|
|
CTTZ, CTLZ, CTPOP,
|
|
|
|
|
2006-03-17 19:53:41 +00:00
|
|
|
// Select(COND, TRUEVAL, FALSEVAL)
|
2005-08-10 20:51:12 +00:00
|
|
|
SELECT,
|
|
|
|
|
|
|
|
// Select with condition operator - This selects between a true value and
|
|
|
|
// a false value (ops #2 and #3) based on the boolean result of comparing
|
|
|
|
// the lhs and rhs (ops #0 and #1) of a conditional expression with the
|
|
|
|
// condition code in op #4, a CondCodeSDNode.
|
|
|
|
SELECT_CC,
|
2005-01-07 07:45:27 +00:00
|
|
|
|
|
|
|
// SetCC operator - This evaluates to a boolean (i1) true value if the
|
2005-08-09 20:20:18 +00:00
|
|
|
// condition is true. The operands to this are the left and right operands
|
|
|
|
// to compare (ops #0, and #1) and the condition code to compare them with
|
|
|
|
// (op #2) as a CondCodeSDNode.
|
2005-01-07 07:45:27 +00:00
|
|
|
SETCC,
|
|
|
|
|
2005-04-02 03:30:33 +00:00
|
|
|
// SHL_PARTS/SRA_PARTS/SRL_PARTS - These operators are used for expanded
|
|
|
|
// integer shift operations, just like ADD/SUB_PARTS. The operation
|
|
|
|
// ordering is:
|
2005-04-02 03:59:45 +00:00
|
|
|
// [Lo,Hi] = op [LoLHS,HiLHS], Amt
|
2005-04-02 03:30:33 +00:00
|
|
|
SHL_PARTS, SRA_PARTS, SRL_PARTS,
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
// Conversion operators. These are all single input single output
|
|
|
|
// operations. For all of these, the result type must be strictly
|
|
|
|
// wider or narrower (depending on the operation) than the source
|
|
|
|
// type.
|
|
|
|
|
|
|
|
// SIGN_EXTEND - Used for integer types, replicating the sign bit
|
|
|
|
// into new bits.
|
|
|
|
SIGN_EXTEND,
|
|
|
|
|
|
|
|
// ZERO_EXTEND - Used for integer types, zeroing the new bits.
|
|
|
|
ZERO_EXTEND,
|
|
|
|
|
2005-09-02 00:14:40 +00:00
|
|
|
// ANY_EXTEND - Used for integer types. The high bits are undefined.
|
|
|
|
ANY_EXTEND,
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
// TRUNCATE - Completely drop the high bits.
|
|
|
|
TRUNCATE,
|
|
|
|
|
2005-01-08 08:08:49 +00:00
|
|
|
// [SU]INT_TO_FP - These operators convert integers (whose interpreted sign
|
|
|
|
// depends on the first letter) to floating point.
|
|
|
|
SINT_TO_FP,
|
|
|
|
UINT_TO_FP,
|
|
|
|
|
2005-04-13 02:36:41 +00:00
|
|
|
// SIGN_EXTEND_INREG - This operator atomically performs a SHL/SRA pair to
|
|
|
|
// sign extend a small value in a large integer register (e.g. sign
|
|
|
|
// extending the low 8 bits of a 32-bit register to fill the top 24 bits
|
2005-07-10 00:07:11 +00:00
|
|
|
// with the 7th bit). The size of the smaller type is indicated by the 1th
|
|
|
|
// operand, a ValueType node.
|
2005-01-15 06:17:04 +00:00
|
|
|
SIGN_EXTEND_INREG,
|
|
|
|
|
2005-01-08 08:08:49 +00:00
|
|
|
// FP_TO_[US]INT - Convert a floating point value to a signed or unsigned
|
|
|
|
// integer.
|
|
|
|
FP_TO_SINT,
|
|
|
|
FP_TO_UINT,
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
// FP_ROUND - Perform a rounding operation from the current
|
2005-01-15 06:17:04 +00:00
|
|
|
// precision down to the specified precision (currently always 64->32).
|
2005-01-07 07:45:27 +00:00
|
|
|
FP_ROUND,
|
|
|
|
|
2005-01-15 06:17:04 +00:00
|
|
|
// FP_ROUND_INREG - This operator takes a floating point register, and
|
|
|
|
// rounds it to a floating point value. It then promotes it and returns it
|
|
|
|
// in a register of the same size. This operation effectively just discards
|
2005-07-10 00:07:11 +00:00
|
|
|
// excess precision. The type to round down to is specified by the 1th
|
|
|
|
// operation, a VTSDNode (currently always 64->32->64).
|
2005-01-15 06:17:04 +00:00
|
|
|
FP_ROUND_INREG,
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
// FP_EXTEND - Extend a smaller FP type into a larger FP type.
|
|
|
|
FP_EXTEND,
|
|
|
|
|
2005-12-23 00:15:59 +00:00
|
|
|
// BIT_CONVERT - Theis operator converts between integer and FP values, as
|
|
|
|
// if one was stored to memory as integer and the other was loaded from the
|
2005-12-23 00:46:10 +00:00
|
|
|
// same address (or equivalently for vector format conversions, etc). The
|
|
|
|
// source and result are required to have the same bit size (e.g.
|
|
|
|
// f32 <-> i32). This can also be used for int-to-int or fp-to-fp
|
|
|
|
// conversions, but that is a noop, deleted by getNode().
|
2005-12-23 00:15:59 +00:00
|
|
|
BIT_CONVERT,
|
|
|
|
|
2007-10-11 23:06:37 +00:00
|
|
|
// FNEG, FABS, FSQRT, FSIN, FCOS, FPOWI, FPOW - Perform unary floating point
|
|
|
|
// negation, absolute value, square root, sine and cosine, powi, and pow
|
2006-09-09 05:55:44 +00:00
|
|
|
// operations.
|
2007-10-11 23:06:37 +00:00
|
|
|
FNEG, FABS, FSQRT, FSIN, FCOS, FPOWI, FPOW,
|
2006-03-05 05:06:40 +00:00
|
|
|
|
2006-10-26 21:52:24 +00:00
|
|
|
// LOAD and STORE have token chains as their first operand, then the same
|
|
|
|
// operands as an LLVM load/store instruction, then an offset node that
|
|
|
|
// is added / subtracted from the base pointer to form the address (for
|
|
|
|
// indexed memory ops).
|
2005-01-07 07:45:27 +00:00
|
|
|
LOAD, STORE,
|
2005-11-19 00:36:38 +00:00
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
// DYNAMIC_STACKALLOC - Allocate some number of bytes on the stack aligned
|
2007-04-17 09:20:00 +00:00
|
|
|
// to a specified boundary. This node always has two return values: a new
|
|
|
|
// stack pointer value and a chain. The first operand is the token chain,
|
|
|
|
// the second is the number of bytes to allocate, and the third is the
|
|
|
|
// alignment boundary. The size is guaranteed to be a multiple of the stack
|
|
|
|
// alignment, and the alignment is guaranteed to be bigger than the stack
|
2005-08-29 22:48:32 +00:00
|
|
|
// alignment (if required) or 0 to get standard stack alignment.
|
2005-01-07 07:45:27 +00:00
|
|
|
DYNAMIC_STACKALLOC,
|
|
|
|
|
|
|
|
// Control flow instructions. These all have token chains.
|
2005-04-21 20:39:54 +00:00
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
// BR - Unconditional branch. The first operand is the chain
|
|
|
|
// operand, the second is the MBB to branch to.
|
|
|
|
BR,
|
|
|
|
|
2006-04-22 18:53:45 +00:00
|
|
|
// BRIND - Indirect branch. The first operand is the chain, the second
|
|
|
|
// is the value to branch to, which must be of the same type as the target's
|
|
|
|
// pointer type.
|
|
|
|
BRIND,
|
2006-10-30 07:59:36 +00:00
|
|
|
|
|
|
|
// BR_JT - Jumptable branch. The first operand is the chain, the second
|
|
|
|
// is the jumptable index, the last one is the jumptable entry index.
|
|
|
|
BR_JT,
|
2006-04-22 18:53:45 +00:00
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
// BRCOND - Conditional branch. The first operand is the chain,
|
|
|
|
// the second is the condition, the third is the block to branch
|
|
|
|
// to if the condition is true.
|
|
|
|
BRCOND,
|
|
|
|
|
2005-08-16 19:49:35 +00:00
|
|
|
// BR_CC - Conditional branch. The behavior is like that of SELECT_CC, in
|
|
|
|
// that the condition is represented as condition code, and two nodes to
|
|
|
|
// compare, rather than as a combined SetCC node. The operands in order are
|
|
|
|
// chain, cc, lhs, rhs, block to branch to if condition is true.
|
|
|
|
BR_CC,
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
// RET - Return from function. The first operand is the chain,
|
2006-05-26 23:09:09 +00:00
|
|
|
// and any subsequent operands are pairs of return value and return value
|
|
|
|
// signness for the function. This operation can have variable number of
|
|
|
|
// operands.
|
2005-01-07 07:45:27 +00:00
|
|
|
RET,
|
|
|
|
|
2006-01-26 22:23:45 +00:00
|
|
|
// INLINEASM - Represents an inline asm block. This node always has two
|
|
|
|
// return values: a chain and a flag result. The inputs are as follows:
|
|
|
|
// Operand #0 : Input chain.
|
|
|
|
// Operand #1 : a ExternalSymbolSDNode with a pointer to the asm string.
|
|
|
|
// Operand #2n+2: A RegisterNode.
|
|
|
|
// Operand #2n+3: A TargetConstant, indicating if the reg is a use/def
|
|
|
|
// Operand #last: Optional, an incoming flag.
|
|
|
|
INLINEASM,
|
2007-01-26 14:34:52 +00:00
|
|
|
|
|
|
|
// LABEL - Represents a label in mid basic block used to track
|
|
|
|
// locations needed for debug and exception handling tables. This node
|
|
|
|
// returns a chain.
|
|
|
|
// Operand #0 : input chain.
|
|
|
|
// Operand #1 : module unique number use to identify the label.
|
|
|
|
LABEL,
|
2007-02-21 22:37:22 +00:00
|
|
|
|
2006-01-13 02:39:42 +00:00
|
|
|
// STACKSAVE - STACKSAVE has one operand, an input chain. It produces a
|
|
|
|
// value, the same type as the pointer type for the system, and an output
|
|
|
|
// chain.
|
|
|
|
STACKSAVE,
|
|
|
|
|
|
|
|
// STACKRESTORE has two operands, an input chain and a pointer to restore to
|
|
|
|
// it returns an output chain.
|
|
|
|
STACKRESTORE,
|
|
|
|
|
2005-01-11 05:56:17 +00:00
|
|
|
// MEMSET/MEMCPY/MEMMOVE - The first operand is the chain, and the rest
|
|
|
|
// correspond to the operands of the LLVM intrinsic functions. The only
|
|
|
|
// result is a token chain. The alignment argument is guaranteed to be a
|
|
|
|
// Constant node.
|
|
|
|
MEMSET,
|
|
|
|
MEMMOVE,
|
|
|
|
MEMCPY,
|
2005-04-21 20:39:54 +00:00
|
|
|
|
2005-05-12 23:24:06 +00:00
|
|
|
// CALLSEQ_START/CALLSEQ_END - These operators mark the beginning and end of
|
|
|
|
// a call sequence, and carry arbitrary information that target might want
|
|
|
|
// to know. The first operand is a chain, the rest are specified by the
|
|
|
|
// target and not touched by the DAG optimizers.
|
|
|
|
CALLSEQ_START, // Beginning of a call sequence
|
|
|
|
CALLSEQ_END, // End of a call sequence
|
2006-01-25 18:21:52 +00:00
|
|
|
|
|
|
|
// VAARG - VAARG has three operands: an input chain, a pointer, and a
|
|
|
|
// SRCVALUE. It returns a pair of values: the vaarg value and a new chain.
|
|
|
|
VAARG,
|
|
|
|
|
|
|
|
// VACOPY - VACOPY has five operands: an input chain, a destination pointer,
|
|
|
|
// a source pointer, a SRCVALUE for the destination, and a SRCVALUE for the
|
|
|
|
// source.
|
|
|
|
VACOPY,
|
|
|
|
|
|
|
|
// VAEND, VASTART - VAEND and VASTART have three operands: an input chain, a
|
|
|
|
// pointer, and a SRCVALUE.
|
|
|
|
VAEND, VASTART,
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2005-05-09 20:21:27 +00:00
|
|
|
// SRCVALUE - This corresponds to a Value*, and is used to associate memory
|
|
|
|
// locations with their value. This allows one use alias analysis
|
|
|
|
// information in the backend.
|
|
|
|
SRCVALUE,
|
|
|
|
|
2005-03-31 21:30:35 +00:00
|
|
|
// PCMARKER - This corresponds to the pcmarker intrinsic.
|
2005-03-31 21:24:06 +00:00
|
|
|
PCMARKER,
|
2005-01-07 07:45:27 +00:00
|
|
|
|
Add support for a cycle counter intrinsic. As basically all processors have
this and have it in about the same form, I think this makes sense.
on X86, you do a RDTSC (64bit result, from any ring since the P5MMX)
on Alpha, you do a RDCC
on PPC, there is a sequence which may or may not work depending on how things
are setup by the OS. Or something like that. Maybe someone who knows PPC
can add support. Something about the time base register.
on Sparc, you read %tick, which in some solaris versions (>=8) is readable by
userspace
on IA64 read ar.itc
So I think the ulong is justified since all of those are 64bit.
Support is slighly flaky on old chips (P5 and lower) and sometimes
depends on OS (PPC, Sparc). But for modern OS/Hardware (aka this decade),
we should be ok.
I am still not sure what to do about lowering. I can either see a lower to 0, to
gettimeofday (or the target os equivalent), or loudly complaining and refusing to
continue.
I am commiting an Alpha implementation. I will add the X86 implementation if I
have to (I have use of it in the near future), but if someone who knows that
backend (and the funky multi-register results) better wants to add it, it would
take them a lot less time ;)
TODO: better lowering and legalizing, and support more platforms
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24299 91177308-0d34-0410-b5e6-96231b3b80d8
2005-11-11 16:45:18 +00:00
|
|
|
// READCYCLECOUNTER - This corresponds to the readcyclecounter intrinsic.
|
2005-11-11 22:48:54 +00:00
|
|
|
// The only operand is a chain and a value and a chain are produced. The
|
|
|
|
// value is the contents of the architecture specific cycle counter like
|
|
|
|
// register (or other high accuracy low latency clock source)
|
Add support for a cycle counter intrinsic. As basically all processors have
this and have it in about the same form, I think this makes sense.
on X86, you do a RDTSC (64bit result, from any ring since the P5MMX)
on Alpha, you do a RDCC
on PPC, there is a sequence which may or may not work depending on how things
are setup by the OS. Or something like that. Maybe someone who knows PPC
can add support. Something about the time base register.
on Sparc, you read %tick, which in some solaris versions (>=8) is readable by
userspace
on IA64 read ar.itc
So I think the ulong is justified since all of those are 64bit.
Support is slighly flaky on old chips (P5 and lower) and sometimes
depends on OS (PPC, Sparc). But for modern OS/Hardware (aka this decade),
we should be ok.
I am still not sure what to do about lowering. I can either see a lower to 0, to
gettimeofday (or the target os equivalent), or loudly complaining and refusing to
continue.
I am commiting an Alpha implementation. I will add the X86 implementation if I
have to (I have use of it in the near future), but if someone who knows that
backend (and the funky multi-register results) better wants to add it, it would
take them a lot less time ;)
TODO: better lowering and legalizing, and support more platforms
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24299 91177308-0d34-0410-b5e6-96231b3b80d8
2005-11-11 16:45:18 +00:00
|
|
|
READCYCLECOUNTER,
|
|
|
|
|
2005-10-05 06:34:34 +00:00
|
|
|
// HANDLENODE node - Used as a handle for various purposes.
|
|
|
|
HANDLENODE,
|
2005-04-27 20:10:01 +00:00
|
|
|
|
2005-11-29 06:15:39 +00:00
|
|
|
// LOCATION - This node is used to represent a source location for debug
|
|
|
|
// info. It takes token chain as input, then a line number, then a column
|
|
|
|
// number, then a filename, then a working dir. It produces a token chain
|
|
|
|
// as output.
|
|
|
|
LOCATION,
|
|
|
|
|
2005-12-16 22:45:29 +00:00
|
|
|
// DEBUG_LOC - This node is used to represent source line information
|
2006-01-05 01:25:28 +00:00
|
|
|
// embedded in the code. It takes a token chain as input, then a line
|
2007-01-26 21:22:28 +00:00
|
|
|
// number, then a column then a file id (provided by MachineModuleInfo.) It
|
2006-01-05 01:25:28 +00:00
|
|
|
// produces a token chain as output.
|
2005-12-16 22:45:29 +00:00
|
|
|
DEBUG_LOC,
|
2007-07-27 12:58:54 +00:00
|
|
|
|
|
|
|
// TRAMPOLINE - This corresponds to the init_trampoline intrinsic.
|
|
|
|
// It takes as input a token chain, the pointer to the trampoline,
|
|
|
|
// the pointer to the nested function, the pointer to pass for the
|
|
|
|
// 'nest' parameter, a SRCVALUE for the trampoline and another for
|
|
|
|
// the nested function (allowing targets to access the original
|
2007-09-11 14:10:23 +00:00
|
|
|
// Function*). It produces the result of the intrinsic and a token
|
|
|
|
// chain as output.
|
2007-07-27 12:58:54 +00:00
|
|
|
TRAMPOLINE,
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
// BUILTIN_OP_END - This must be the last enum value in this list.
|
2006-02-22 16:23:43 +00:00
|
|
|
BUILTIN_OP_END
|
2005-01-07 07:45:27 +00:00
|
|
|
};
|
|
|
|
|
2006-03-25 22:56:35 +00:00
|
|
|
/// Node predicates
|
|
|
|
|
2006-03-27 06:58:47 +00:00
|
|
|
/// isBuildVectorAllOnes - Return true if the specified node is a
|
2006-03-25 22:56:35 +00:00
|
|
|
/// BUILD_VECTOR where all of the elements are ~0 or undef.
|
2006-03-27 06:58:47 +00:00
|
|
|
bool isBuildVectorAllOnes(const SDNode *N);
|
2006-03-26 09:50:58 +00:00
|
|
|
|
|
|
|
/// isBuildVectorAllZeros - Return true if the specified node is a
|
|
|
|
/// BUILD_VECTOR where all of the elements are 0 or undef.
|
|
|
|
bool isBuildVectorAllZeros(const SDNode *N);
|
2006-03-25 22:56:35 +00:00
|
|
|
|
2006-10-09 20:55:20 +00:00
|
|
|
//===--------------------------------------------------------------------===//
|
2006-11-09 17:55:04 +00:00
|
|
|
/// MemIndexedMode enum - This enum defines the load / store indexed
|
|
|
|
/// addressing modes.
|
2006-10-09 20:55:20 +00:00
|
|
|
///
|
|
|
|
/// UNINDEXED "Normal" load / store. The effective address is already
|
|
|
|
/// computed and is available in the base pointer. The offset
|
2006-10-10 01:44:58 +00:00
|
|
|
/// operand is always undefined. In addition to producing a
|
|
|
|
/// chain, an unindexed load produces one value (result of the
|
|
|
|
/// load); an unindexed store does not produces a value.
|
2006-10-09 20:55:20 +00:00
|
|
|
///
|
2006-10-17 21:12:56 +00:00
|
|
|
/// PRE_INC Similar to the unindexed mode where the effective address is
|
2006-10-26 21:52:24 +00:00
|
|
|
/// PRE_DEC the value of the base pointer add / subtract the offset.
|
|
|
|
/// It considers the computation as being folded into the load /
|
2006-10-09 20:55:20 +00:00
|
|
|
/// store operation (i.e. the load / store does the address
|
|
|
|
/// computation as well as performing the memory transaction).
|
2006-10-10 01:44:58 +00:00
|
|
|
/// The base operand is always undefined. In addition to
|
|
|
|
/// producing a chain, pre-indexed load produces two values
|
|
|
|
/// (result of the load and the result of the address
|
|
|
|
/// computation); a pre-indexed store produces one value (result
|
|
|
|
/// of the address computation).
|
2006-10-09 20:55:20 +00:00
|
|
|
///
|
2006-10-17 21:12:56 +00:00
|
|
|
/// POST_INC The effective address is the value of the base pointer. The
|
2006-10-26 21:52:24 +00:00
|
|
|
/// POST_DEC value of the offset operand is then added to / subtracted
|
|
|
|
/// from the base after memory transaction. In addition to
|
|
|
|
/// producing a chain, post-indexed load produces two values
|
|
|
|
/// (the result of the load and the result of the base +/- offset
|
|
|
|
/// computation); a post-indexed store produces one value (the
|
|
|
|
/// the result of the base +/- offset computation).
|
2006-10-09 20:55:20 +00:00
|
|
|
///
|
2006-11-09 17:55:04 +00:00
|
|
|
enum MemIndexedMode {
|
2006-10-09 20:55:20 +00:00
|
|
|
UNINDEXED = 0,
|
2006-10-17 21:12:56 +00:00
|
|
|
PRE_INC,
|
|
|
|
PRE_DEC,
|
|
|
|
POST_INC,
|
2006-11-09 17:55:04 +00:00
|
|
|
POST_DEC,
|
|
|
|
LAST_INDEXED_MODE
|
2006-10-09 20:55:20 +00:00
|
|
|
};
|
|
|
|
|
2006-10-04 00:56:09 +00:00
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// LoadExtType enum - This enum defines the three variants of LOADEXT
|
|
|
|
/// (load with extension).
|
|
|
|
///
|
2006-10-09 20:55:20 +00:00
|
|
|
/// SEXTLOAD loads the integer operand and sign extends it to a larger
|
|
|
|
/// integer result type.
|
|
|
|
/// ZEXTLOAD loads the integer operand and zero extends it to a larger
|
|
|
|
/// integer result type.
|
|
|
|
/// EXTLOAD is used for three things: floating point extending loads,
|
|
|
|
/// integer extending loads [the top bits are undefined], and vector
|
|
|
|
/// extending loads [load into low elt].
|
|
|
|
///
|
2006-10-04 00:56:09 +00:00
|
|
|
enum LoadExtType {
|
2006-10-09 20:55:20 +00:00
|
|
|
NON_EXTLOAD = 0,
|
2006-10-04 00:56:09 +00:00
|
|
|
EXTLOAD,
|
|
|
|
SEXTLOAD,
|
|
|
|
ZEXTLOAD,
|
|
|
|
LAST_LOADX_TYPE
|
|
|
|
};
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// ISD::CondCode enum - These are ordered carefully to make the bitfields
|
|
|
|
/// below work out, when considering SETFALSE (something that never exists
|
|
|
|
/// dynamically) as 0. "U" -> Unsigned (for integer operands) or Unordered
|
|
|
|
/// (for floating point), "L" -> Less than, "G" -> Greater than, "E" -> Equal
|
|
|
|
/// to. If the "N" column is 1, the result of the comparison is undefined if
|
|
|
|
/// the input is a NAN.
|
|
|
|
///
|
|
|
|
/// All of these (except for the 'always folded ops') should be handled for
|
|
|
|
/// floating point. For integer, only the SETEQ,SETNE,SETLT,SETLE,SETGT,
|
|
|
|
/// SETGE,SETULT,SETULE,SETUGT, and SETUGE opcodes are used.
|
|
|
|
///
|
|
|
|
/// Note that these are laid out in a specific order to allow bit-twiddling
|
|
|
|
/// to transform conditions.
|
|
|
|
enum CondCode {
|
|
|
|
// Opcode N U L G E Intuitive operation
|
|
|
|
SETFALSE, // 0 0 0 0 Always false (always folded)
|
|
|
|
SETOEQ, // 0 0 0 1 True if ordered and equal
|
|
|
|
SETOGT, // 0 0 1 0 True if ordered and greater than
|
|
|
|
SETOGE, // 0 0 1 1 True if ordered and greater than or equal
|
|
|
|
SETOLT, // 0 1 0 0 True if ordered and less than
|
|
|
|
SETOLE, // 0 1 0 1 True if ordered and less than or equal
|
|
|
|
SETONE, // 0 1 1 0 True if ordered and operands are unequal
|
|
|
|
SETO, // 0 1 1 1 True if ordered (no nans)
|
|
|
|
SETUO, // 1 0 0 0 True if unordered: isnan(X) | isnan(Y)
|
|
|
|
SETUEQ, // 1 0 0 1 True if unordered or equal
|
|
|
|
SETUGT, // 1 0 1 0 True if unordered or greater than
|
|
|
|
SETUGE, // 1 0 1 1 True if unordered, greater than, or equal
|
|
|
|
SETULT, // 1 1 0 0 True if unordered or less than
|
2005-04-21 20:39:54 +00:00
|
|
|
SETULE, // 1 1 0 1 True if unordered, less than, or equal
|
2005-01-07 07:45:27 +00:00
|
|
|
SETUNE, // 1 1 1 0 True if unordered or not equal
|
|
|
|
SETTRUE, // 1 1 1 1 Always true (always folded)
|
|
|
|
// Don't care operations: undefined if the input is a nan.
|
|
|
|
SETFALSE2, // 1 X 0 0 0 Always false (always folded)
|
|
|
|
SETEQ, // 1 X 0 0 1 True if equal
|
|
|
|
SETGT, // 1 X 0 1 0 True if greater than
|
|
|
|
SETGE, // 1 X 0 1 1 True if greater than or equal
|
|
|
|
SETLT, // 1 X 1 0 0 True if less than
|
2005-04-21 20:39:54 +00:00
|
|
|
SETLE, // 1 X 1 0 1 True if less than or equal
|
2005-01-07 07:45:27 +00:00
|
|
|
SETNE, // 1 X 1 1 0 True if not equal
|
|
|
|
SETTRUE2, // 1 X 1 1 1 Always true (always folded)
|
|
|
|
|
2006-02-22 16:23:43 +00:00
|
|
|
SETCC_INVALID // Marker value.
|
2005-01-07 07:45:27 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/// isSignedIntSetCC - Return true if this is a setcc instruction that
|
|
|
|
/// performs a signed comparison when used with integer operands.
|
|
|
|
inline bool isSignedIntSetCC(CondCode Code) {
|
|
|
|
return Code == SETGT || Code == SETGE || Code == SETLT || Code == SETLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// isUnsignedIntSetCC - Return true if this is a setcc instruction that
|
|
|
|
/// performs an unsigned comparison when used with integer operands.
|
|
|
|
inline bool isUnsignedIntSetCC(CondCode Code) {
|
|
|
|
return Code == SETUGT || Code == SETUGE || Code == SETULT || Code == SETULE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// isTrueWhenEqual - Return true if the specified condition returns true if
|
|
|
|
/// the two operands to the condition are equal. Note that if one of the two
|
|
|
|
/// operands is a NaN, this value is meaningless.
|
|
|
|
inline bool isTrueWhenEqual(CondCode Cond) {
|
|
|
|
return ((int)Cond & 1) != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getUnorderedFlavor - This function returns 0 if the condition is always
|
|
|
|
/// false if an operand is a NaN, 1 if the condition is always true if the
|
|
|
|
/// operand is a NaN, and 2 if the condition is undefined if the operand is a
|
|
|
|
/// NaN.
|
|
|
|
inline unsigned getUnorderedFlavor(CondCode Cond) {
|
|
|
|
return ((int)Cond >> 3) & 3;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getSetCCInverse - Return the operation corresponding to !(X op Y), where
|
|
|
|
/// 'op' is a valid SetCC operation.
|
|
|
|
CondCode getSetCCInverse(CondCode Operation, bool isInteger);
|
|
|
|
|
|
|
|
/// getSetCCSwappedOperands - Return the operation corresponding to (Y op X)
|
|
|
|
/// when given the operation for (X op Y).
|
|
|
|
CondCode getSetCCSwappedOperands(CondCode Operation);
|
|
|
|
|
|
|
|
/// getSetCCOrOperation - Return the result of a logical OR between different
|
|
|
|
/// comparisons of identical values: ((X op1 Y) | (X op2 Y)). This
|
|
|
|
/// function returns SETCC_INVALID if it is not possible to represent the
|
|
|
|
/// resultant comparison.
|
|
|
|
CondCode getSetCCOrOperation(CondCode Op1, CondCode Op2, bool isInteger);
|
|
|
|
|
|
|
|
/// getSetCCAndOperation - Return the result of a logical AND between
|
|
|
|
/// different comparisons of identical values: ((X op1 Y) & (X op2 Y)). This
|
|
|
|
/// function returns SETCC_INVALID if it is not possible to represent the
|
|
|
|
/// resultant comparison.
|
|
|
|
CondCode getSetCCAndOperation(CondCode Op1, CondCode Op2, bool isInteger);
|
|
|
|
} // end llvm::ISD namespace
|
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// SDOperand - Unlike LLVM values, Selection DAG nodes may return multiple
|
|
|
|
/// values as the result of a computation. Many nodes return multiple values,
|
|
|
|
/// from loads (which define a token and a return value) to ADDC (which returns
|
|
|
|
/// a result and a carry value), to calls (which may return an arbitrary number
|
|
|
|
/// of values).
|
|
|
|
///
|
|
|
|
/// As such, each use of a SelectionDAG computation must indicate the node that
|
|
|
|
/// computes it as well as which return value to use from that node. This pair
|
|
|
|
/// of information is represented with the SDOperand value type.
|
|
|
|
///
|
2005-01-08 19:52:31 +00:00
|
|
|
class SDOperand {
|
|
|
|
public:
|
2005-01-07 07:45:27 +00:00
|
|
|
SDNode *Val; // The node defining the value we are using.
|
|
|
|
unsigned ResNo; // Which return value of the node we are using.
|
|
|
|
|
2006-04-12 16:44:15 +00:00
|
|
|
SDOperand() : Val(0), ResNo(0) {}
|
2005-01-07 07:45:27 +00:00
|
|
|
SDOperand(SDNode *val, unsigned resno) : Val(val), ResNo(resno) {}
|
|
|
|
|
|
|
|
bool operator==(const SDOperand &O) const {
|
|
|
|
return Val == O.Val && ResNo == O.ResNo;
|
|
|
|
}
|
|
|
|
bool operator!=(const SDOperand &O) const {
|
|
|
|
return !operator==(O);
|
|
|
|
}
|
|
|
|
bool operator<(const SDOperand &O) const {
|
|
|
|
return Val < O.Val || (Val == O.Val && ResNo < O.ResNo);
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand getValue(unsigned R) const {
|
|
|
|
return SDOperand(Val, R);
|
|
|
|
}
|
|
|
|
|
2006-03-03 06:42:32 +00:00
|
|
|
// isOperand - Return true if this node is an operand of N.
|
|
|
|
bool isOperand(SDNode *N) const;
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
/// getValueType - Return the ValueType of the referenced return value.
|
|
|
|
///
|
|
|
|
inline MVT::ValueType getValueType() const;
|
2005-04-21 20:39:54 +00:00
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
// Forwarding methods - These forward to the corresponding methods in SDNode.
|
|
|
|
inline unsigned getOpcode() const;
|
|
|
|
inline unsigned getNumOperands() const;
|
|
|
|
inline const SDOperand &getOperand(unsigned i) const;
|
2006-10-04 00:56:09 +00:00
|
|
|
inline uint64_t getConstantOperandVal(unsigned i) const;
|
2005-08-17 23:44:54 +00:00
|
|
|
inline bool isTargetOpcode() const;
|
|
|
|
inline unsigned getTargetOpcode() const;
|
2005-01-13 22:58:50 +00:00
|
|
|
|
|
|
|
/// hasOneUse - Return true if there is exactly one operation using this
|
|
|
|
/// result value of the defining operator.
|
|
|
|
inline bool hasOneUse() const;
|
2007-09-17 17:44:31 +00:00
|
|
|
|
|
|
|
/// use_empty - Return true if there are no operations using this
|
|
|
|
/// result value of the defining operator.
|
|
|
|
inline bool use_empty() const;
|
2005-01-07 07:45:27 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2007-09-17 18:34:04 +00:00
|
|
|
template<> struct DenseMapInfo<SDOperand> {
|
2007-07-10 06:59:55 +00:00
|
|
|
static inline SDOperand getEmptyKey() { return SDOperand((SDNode*)-1, -1U); }
|
|
|
|
static inline SDOperand getTombstoneKey() { return SDOperand((SDNode*)-1, 0);}
|
|
|
|
static unsigned getHashValue(const SDOperand &Val) {
|
|
|
|
return (unsigned)((uintptr_t)Val.Val >> 4) ^
|
|
|
|
(unsigned)((uintptr_t)Val.Val >> 9) + Val.ResNo;
|
|
|
|
}
|
2007-09-17 18:34:04 +00:00
|
|
|
static bool isEqual(const SDOperand &LHS, const SDOperand &RHS) {
|
|
|
|
return LHS == RHS;
|
|
|
|
}
|
2007-07-10 06:59:55 +00:00
|
|
|
static bool isPod() { return true; }
|
|
|
|
};
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
/// simplify_type specializations - Allow casting operators to work directly on
|
|
|
|
/// SDOperands as if they were SDNode*'s.
|
|
|
|
template<> struct simplify_type<SDOperand> {
|
|
|
|
typedef SDNode* SimpleType;
|
|
|
|
static SimpleType getSimplifiedValue(const SDOperand &Val) {
|
|
|
|
return static_cast<SimpleType>(Val.Val);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
template<> struct simplify_type<const SDOperand> {
|
|
|
|
typedef SDNode* SimpleType;
|
|
|
|
static SimpleType getSimplifiedValue(const SDOperand &Val) {
|
|
|
|
return static_cast<SimpleType>(Val.Val);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/// SDNode - Represents one node in the SelectionDAG.
|
|
|
|
///
|
2006-10-27 23:46:08 +00:00
|
|
|
class SDNode : public FoldingSetNode {
|
2005-01-21 21:39:38 +00:00
|
|
|
/// NodeType - The operation that this node performs.
|
|
|
|
///
|
|
|
|
unsigned short NodeType;
|
2007-02-04 07:28:00 +00:00
|
|
|
|
|
|
|
/// OperandsNeedDelete - This is true if OperandList was new[]'d. If true,
|
|
|
|
/// then they will be delete[]'d when the node is destroyed.
|
|
|
|
bool OperandsNeedDelete : 1;
|
2005-01-21 21:39:38 +00:00
|
|
|
|
2006-07-27 06:38:21 +00:00
|
|
|
/// NodeId - Unique id per SDNode in the DAG.
|
|
|
|
int NodeId;
|
2005-01-21 21:39:38 +00:00
|
|
|
|
2005-11-08 22:06:23 +00:00
|
|
|
/// OperandList - The values that are used by this operation.
|
2005-01-21 21:39:38 +00:00
|
|
|
///
|
2005-11-08 22:06:23 +00:00
|
|
|
SDOperand *OperandList;
|
|
|
|
|
|
|
|
/// ValueList - The types of the values this node defines. SDNode's may
|
|
|
|
/// define multiple values simultaneously.
|
2006-08-14 23:31:51 +00:00
|
|
|
const MVT::ValueType *ValueList;
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2005-11-08 22:06:23 +00:00
|
|
|
/// NumOperands/NumValues - The number of entries in the Operand/Value list.
|
|
|
|
unsigned short NumOperands, NumValues;
|
2005-11-09 23:46:43 +00:00
|
|
|
|
|
|
|
/// Prev/Next pointers - These pointers form the linked list of of the
|
|
|
|
/// AllNodes list in the current DAG.
|
|
|
|
SDNode *Prev, *Next;
|
|
|
|
friend struct ilist_traits<SDNode>;
|
2005-01-07 07:45:27 +00:00
|
|
|
|
|
|
|
/// Uses - These are all of the SDNode's that use a value produced by this
|
|
|
|
/// node.
|
2006-08-16 21:01:10 +00:00
|
|
|
SmallVector<SDNode*,3> Uses;
|
2006-07-19 00:00:37 +00:00
|
|
|
|
|
|
|
// Out-of-line virtual method to give class a home.
|
|
|
|
virtual void ANCHOR();
|
2005-01-07 07:45:27 +00:00
|
|
|
public:
|
2005-11-09 23:46:43 +00:00
|
|
|
virtual ~SDNode() {
|
|
|
|
assert(NumOperands == 0 && "Operand list not cleared before deletion");
|
2006-05-27 00:40:15 +00:00
|
|
|
NodeType = ISD::DELETED_NODE;
|
2005-11-09 23:46:43 +00:00
|
|
|
}
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
// Accessors
|
|
|
|
//
|
|
|
|
unsigned getOpcode() const { return NodeType; }
|
2005-08-17 23:44:54 +00:00
|
|
|
bool isTargetOpcode() const { return NodeType >= ISD::BUILTIN_OP_END; }
|
|
|
|
unsigned getTargetOpcode() const {
|
|
|
|
assert(isTargetOpcode() && "Not a target opcode!");
|
|
|
|
return NodeType - ISD::BUILTIN_OP_END;
|
|
|
|
}
|
2005-01-07 07:45:27 +00:00
|
|
|
|
|
|
|
size_t use_size() const { return Uses.size(); }
|
|
|
|
bool use_empty() const { return Uses.empty(); }
|
|
|
|
bool hasOneUse() const { return Uses.size() == 1; }
|
|
|
|
|
2006-07-27 06:38:21 +00:00
|
|
|
/// getNodeId - Return the unique node id.
|
|
|
|
///
|
|
|
|
int getNodeId() const { return NodeId; }
|
2005-01-21 21:39:38 +00:00
|
|
|
|
2006-08-16 21:01:10 +00:00
|
|
|
typedef SmallVector<SDNode*,3>::const_iterator use_iterator;
|
2005-01-17 02:24:59 +00:00
|
|
|
use_iterator use_begin() const { return Uses.begin(); }
|
|
|
|
use_iterator use_end() const { return Uses.end(); }
|
|
|
|
|
2005-01-12 18:37:33 +00:00
|
|
|
/// hasNUsesOfValue - Return true if there are exactly NUSES uses of the
|
|
|
|
/// indicated value. This method ignores uses of other values defined by this
|
|
|
|
/// operation.
|
2006-02-05 06:29:23 +00:00
|
|
|
bool hasNUsesOfValue(unsigned NUses, unsigned Value) const;
|
|
|
|
|
2007-08-02 05:29:38 +00:00
|
|
|
/// hasAnyUseOfValue - Return true if there are any use of the indicated
|
|
|
|
/// value. This method ignores uses of other values defined by this operation.
|
|
|
|
bool hasAnyUseOfValue(unsigned Value) const;
|
|
|
|
|
2006-11-03 07:31:32 +00:00
|
|
|
/// isOnlyUse - Return true if this node is the only use of N.
|
|
|
|
///
|
2006-02-05 06:29:23 +00:00
|
|
|
bool isOnlyUse(SDNode *N) const;
|
2005-01-12 18:37:33 +00:00
|
|
|
|
2006-11-03 07:31:32 +00:00
|
|
|
/// isOperand - Return true if this node is an operand of N.
|
|
|
|
///
|
2006-03-03 06:24:54 +00:00
|
|
|
bool isOperand(SDNode *N) const;
|
|
|
|
|
2006-11-03 07:31:32 +00:00
|
|
|
/// isPredecessor - Return true if this node is a predecessor of N. This node
|
|
|
|
/// is either an operand of N or it can be reached by recursively traversing
|
|
|
|
/// up the operands.
|
|
|
|
/// NOTE: this is an expensive method. Use it carefully.
|
2006-11-03 03:02:18 +00:00
|
|
|
bool isPredecessor(SDNode *N) const;
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
/// getNumOperands - Return the number of values used by this operation.
|
|
|
|
///
|
2005-11-08 22:06:23 +00:00
|
|
|
unsigned getNumOperands() const { return NumOperands; }
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2006-10-04 00:56:09 +00:00
|
|
|
/// getConstantOperandVal - Helper method returns the integer value of a
|
|
|
|
/// ConstantSDNode operand.
|
|
|
|
uint64_t getConstantOperandVal(unsigned Num) const;
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
const SDOperand &getOperand(unsigned Num) const {
|
2005-11-08 22:06:23 +00:00
|
|
|
assert(Num < NumOperands && "Invalid child # of SDNode!");
|
|
|
|
return OperandList[Num];
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
2006-10-04 00:56:09 +00:00
|
|
|
|
2005-11-08 22:06:23 +00:00
|
|
|
typedef const SDOperand* op_iterator;
|
|
|
|
op_iterator op_begin() const { return OperandList; }
|
|
|
|
op_iterator op_end() const { return OperandList+NumOperands; }
|
2005-05-14 06:19:11 +00:00
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2006-08-15 19:11:05 +00:00
|
|
|
SDVTList getVTList() const {
|
|
|
|
SDVTList X = { ValueList, NumValues };
|
|
|
|
return X;
|
|
|
|
};
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
/// getNumValues - Return the number of values defined/returned by this
|
|
|
|
/// operator.
|
|
|
|
///
|
2005-11-08 22:06:23 +00:00
|
|
|
unsigned getNumValues() const { return NumValues; }
|
2005-01-07 07:45:27 +00:00
|
|
|
|
|
|
|
/// getValueType - Return the type of a specified result.
|
|
|
|
///
|
|
|
|
MVT::ValueType getValueType(unsigned ResNo) const {
|
2005-11-08 22:06:23 +00:00
|
|
|
assert(ResNo < NumValues && "Illegal result number!");
|
|
|
|
return ValueList[ResNo];
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
2005-07-27 05:53:44 +00:00
|
|
|
|
2005-11-08 22:06:23 +00:00
|
|
|
typedef const MVT::ValueType* value_iterator;
|
|
|
|
value_iterator value_begin() const { return ValueList; }
|
|
|
|
value_iterator value_end() const { return ValueList+NumValues; }
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2005-01-10 23:25:04 +00:00
|
|
|
/// getOperationName - Return the opcode of this operation for printing.
|
|
|
|
///
|
2007-04-01 07:28:37 +00:00
|
|
|
std::string getOperationName(const SelectionDAG *G = 0) const;
|
2006-11-09 17:55:04 +00:00
|
|
|
static const char* getIndexedModeName(ISD::MemIndexedMode AM);
|
2005-01-07 07:45:27 +00:00
|
|
|
void dump() const;
|
2005-08-16 18:32:18 +00:00
|
|
|
void dump(const SelectionDAG *G) const;
|
2005-01-07 07:45:27 +00:00
|
|
|
|
|
|
|
static bool classof(const SDNode *) { return true; }
|
|
|
|
|
2006-10-27 23:46:08 +00:00
|
|
|
/// Profile - Gather unique data for the node.
|
|
|
|
///
|
|
|
|
void Profile(FoldingSetNodeID &ID);
|
|
|
|
|
2007-10-15 05:30:55 +00:00
|
|
|
void setNodeId(int Id) {
|
|
|
|
NodeId = Id;
|
|
|
|
}
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
protected:
|
|
|
|
friend class SelectionDAG;
|
2005-11-08 23:30:11 +00:00
|
|
|
|
|
|
|
/// getValueTypeList - Return a pointer to the specified value type.
|
|
|
|
///
|
|
|
|
static MVT::ValueType *getValueTypeList(MVT::ValueType VT);
|
2007-02-04 07:28:00 +00:00
|
|
|
static SDVTList getSDVTList(MVT::ValueType VT) {
|
|
|
|
SDVTList Ret = { getValueTypeList(VT), 1 };
|
|
|
|
return Ret;
|
2005-04-27 20:10:01 +00:00
|
|
|
}
|
2007-02-04 07:28:00 +00:00
|
|
|
|
2007-02-04 07:37:24 +00:00
|
|
|
SDNode(unsigned Opc, SDVTList VTs, const SDOperand *Ops, unsigned NumOps)
|
2006-07-27 06:38:21 +00:00
|
|
|
: NodeType(Opc), NodeId(-1) {
|
2007-02-04 07:28:00 +00:00
|
|
|
OperandsNeedDelete = true;
|
2006-08-08 01:09:31 +00:00
|
|
|
NumOperands = NumOps;
|
2007-02-04 08:13:53 +00:00
|
|
|
OperandList = NumOps ? new SDOperand[NumOperands] : 0;
|
2005-11-08 22:06:23 +00:00
|
|
|
|
2007-02-04 08:13:53 +00:00
|
|
|
for (unsigned i = 0; i != NumOps; ++i) {
|
2006-08-08 01:09:31 +00:00
|
|
|
OperandList[i] = Ops[i];
|
2007-02-04 08:13:53 +00:00
|
|
|
Ops[i].Val->Uses.push_back(this);
|
2005-01-21 21:39:38 +00:00
|
|
|
}
|
2007-02-04 08:13:53 +00:00
|
|
|
|
2007-02-04 07:37:24 +00:00
|
|
|
ValueList = VTs.VTs;
|
|
|
|
NumValues = VTs.NumVTs;
|
2005-11-09 23:46:43 +00:00
|
|
|
Prev = 0; Next = 0;
|
2005-11-08 22:06:23 +00:00
|
|
|
}
|
2007-02-04 08:13:53 +00:00
|
|
|
SDNode(unsigned Opc, SDVTList VTs) : NodeType(Opc), NodeId(-1) {
|
|
|
|
OperandsNeedDelete = false; // Operands set with InitOperands.
|
|
|
|
NumOperands = 0;
|
|
|
|
OperandList = 0;
|
|
|
|
|
|
|
|
ValueList = VTs.VTs;
|
|
|
|
NumValues = VTs.NumVTs;
|
|
|
|
Prev = 0; Next = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// InitOperands - Initialize the operands list of this node with the
|
|
|
|
/// specified values, which are part of the node (thus they don't need to be
|
|
|
|
/// copied in or allocated).
|
|
|
|
void InitOperands(SDOperand *Ops, unsigned NumOps) {
|
|
|
|
assert(OperandList == 0 && "Operands already set!");
|
|
|
|
NumOperands = NumOps;
|
|
|
|
OperandList = Ops;
|
|
|
|
|
|
|
|
for (unsigned i = 0; i != NumOps; ++i)
|
|
|
|
Ops[i].Val->Uses.push_back(this);
|
|
|
|
}
|
|
|
|
|
2007-02-04 02:49:29 +00:00
|
|
|
/// MorphNodeTo - This frees the operands of the current node, resets the
|
|
|
|
/// opcode, types, and operands to the specified value. This should only be
|
|
|
|
/// used by the SelectionDAG class.
|
|
|
|
void MorphNodeTo(unsigned Opc, SDVTList L,
|
|
|
|
const SDOperand *Ops, unsigned NumOps);
|
2005-08-16 18:16:24 +00:00
|
|
|
|
2005-08-17 18:58:38 +00:00
|
|
|
void addUser(SDNode *User) {
|
|
|
|
Uses.push_back(User);
|
2005-08-16 18:16:24 +00:00
|
|
|
}
|
2005-01-07 21:08:55 +00:00
|
|
|
void removeUser(SDNode *User) {
|
|
|
|
// Remove this user from the operand's use list.
|
|
|
|
for (unsigned i = Uses.size(); ; --i) {
|
|
|
|
assert(i != 0 && "Didn't find user!");
|
|
|
|
if (Uses[i-1] == User) {
|
2005-08-17 18:58:38 +00:00
|
|
|
Uses[i-1] = Uses.back();
|
|
|
|
Uses.pop_back();
|
|
|
|
return;
|
2005-01-07 21:08:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-01-07 07:45:27 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
// Define inline functions from the SDOperand class.
|
|
|
|
|
|
|
|
inline unsigned SDOperand::getOpcode() const {
|
|
|
|
return Val->getOpcode();
|
|
|
|
}
|
|
|
|
inline MVT::ValueType SDOperand::getValueType() const {
|
|
|
|
return Val->getValueType(ResNo);
|
|
|
|
}
|
|
|
|
inline unsigned SDOperand::getNumOperands() const {
|
|
|
|
return Val->getNumOperands();
|
|
|
|
}
|
|
|
|
inline const SDOperand &SDOperand::getOperand(unsigned i) const {
|
|
|
|
return Val->getOperand(i);
|
|
|
|
}
|
2006-10-04 00:56:09 +00:00
|
|
|
inline uint64_t SDOperand::getConstantOperandVal(unsigned i) const {
|
|
|
|
return Val->getConstantOperandVal(i);
|
|
|
|
}
|
2005-08-17 23:44:54 +00:00
|
|
|
inline bool SDOperand::isTargetOpcode() const {
|
|
|
|
return Val->isTargetOpcode();
|
|
|
|
}
|
|
|
|
inline unsigned SDOperand::getTargetOpcode() const {
|
|
|
|
return Val->getTargetOpcode();
|
|
|
|
}
|
2005-01-13 22:58:50 +00:00
|
|
|
inline bool SDOperand::hasOneUse() const {
|
|
|
|
return Val->hasNUsesOfValue(1, ResNo);
|
|
|
|
}
|
2007-09-17 17:44:31 +00:00
|
|
|
inline bool SDOperand::use_empty() const {
|
|
|
|
return !Val->hasAnyUseOfValue(ResNo);
|
|
|
|
}
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2007-02-04 08:35:21 +00:00
|
|
|
/// UnarySDNode - This class is used for single-operand SDNodes. This is solely
|
|
|
|
/// to allow co-allocation of node operands with the node itself.
|
|
|
|
class UnarySDNode : public SDNode {
|
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
|
|
|
SDOperand Op;
|
|
|
|
public:
|
|
|
|
UnarySDNode(unsigned Opc, SDVTList VTs, SDOperand X)
|
|
|
|
: SDNode(Opc, VTs), Op(X) {
|
|
|
|
InitOperands(&Op, 1);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/// BinarySDNode - This class is used for two-operand SDNodes. This is solely
|
|
|
|
/// to allow co-allocation of node operands with the node itself.
|
|
|
|
class BinarySDNode : public SDNode {
|
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
|
|
|
SDOperand Ops[2];
|
|
|
|
public:
|
|
|
|
BinarySDNode(unsigned Opc, SDVTList VTs, SDOperand X, SDOperand Y)
|
|
|
|
: SDNode(Opc, VTs) {
|
|
|
|
Ops[0] = X;
|
|
|
|
Ops[1] = Y;
|
|
|
|
InitOperands(Ops, 2);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/// TernarySDNode - This class is used for three-operand SDNodes. This is solely
|
|
|
|
/// to allow co-allocation of node operands with the node itself.
|
|
|
|
class TernarySDNode : public SDNode {
|
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
|
|
|
SDOperand Ops[3];
|
|
|
|
public:
|
|
|
|
TernarySDNode(unsigned Opc, SDVTList VTs, SDOperand X, SDOperand Y,
|
|
|
|
SDOperand Z)
|
|
|
|
: SDNode(Opc, VTs) {
|
|
|
|
Ops[0] = X;
|
|
|
|
Ops[1] = Y;
|
|
|
|
Ops[2] = Z;
|
|
|
|
InitOperands(Ops, 3);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2005-10-05 06:34:34 +00:00
|
|
|
/// HandleSDNode - This class is used to form a handle around another node that
|
|
|
|
/// is persistant and is updated across invocations of replaceAllUsesWith on its
|
|
|
|
/// operand. This node should be directly created by end-users and not added to
|
|
|
|
/// the AllNodes list.
|
|
|
|
class HandleSDNode : public SDNode {
|
2007-02-04 02:23:32 +00:00
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
2007-02-04 08:13:53 +00:00
|
|
|
SDOperand Op;
|
2005-10-05 06:34:34 +00:00
|
|
|
public:
|
2007-03-23 18:44:11 +00:00
|
|
|
explicit HandleSDNode(SDOperand X)
|
2007-02-04 08:13:53 +00:00
|
|
|
: SDNode(ISD::HANDLENODE, getSDVTList(MVT::Other)), Op(X) {
|
|
|
|
InitOperands(&Op, 1);
|
|
|
|
}
|
2007-02-04 02:41:42 +00:00
|
|
|
~HandleSDNode();
|
2007-02-04 08:13:53 +00:00
|
|
|
SDOperand getValue() const { return Op; }
|
2005-10-05 06:34:34 +00:00
|
|
|
};
|
|
|
|
|
2005-11-29 06:15:39 +00:00
|
|
|
class StringSDNode : public SDNode {
|
|
|
|
std::string Value;
|
2007-02-04 02:23:32 +00:00
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
2005-11-29 06:15:39 +00:00
|
|
|
protected:
|
|
|
|
friend class SelectionDAG;
|
2007-03-23 18:44:11 +00:00
|
|
|
explicit StringSDNode(const std::string &val)
|
2007-02-04 08:13:53 +00:00
|
|
|
: SDNode(ISD::STRING, getSDVTList(MVT::Other)), Value(val) {
|
2005-11-29 06:15:39 +00:00
|
|
|
}
|
|
|
|
public:
|
|
|
|
const std::string &getValue() const { return Value; }
|
|
|
|
static bool classof(const StringSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
|
|
|
return N->getOpcode() == ISD::STRING;
|
|
|
|
}
|
|
|
|
};
|
2005-01-07 07:45:27 +00:00
|
|
|
|
|
|
|
class ConstantSDNode : public SDNode {
|
|
|
|
uint64_t Value;
|
2007-02-04 02:23:32 +00:00
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
2005-01-07 07:45:27 +00:00
|
|
|
protected:
|
|
|
|
friend class SelectionDAG;
|
2005-08-17 00:33:30 +00:00
|
|
|
ConstantSDNode(bool isTarget, uint64_t val, MVT::ValueType VT)
|
2007-02-04 08:13:53 +00:00
|
|
|
: SDNode(isTarget ? ISD::TargetConstant : ISD::Constant, getSDVTList(VT)),
|
|
|
|
Value(val) {
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
public:
|
|
|
|
|
|
|
|
uint64_t getValue() const { return Value; }
|
|
|
|
|
|
|
|
int64_t getSignExtended() const {
|
|
|
|
unsigned Bits = MVT::getSizeInBits(getValueType(0));
|
2005-01-08 19:52:31 +00:00
|
|
|
return ((int64_t)Value << (64-Bits)) >> (64-Bits);
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool isNullValue() const { return Value == 0; }
|
|
|
|
bool isAllOnesValue() const {
|
2006-04-02 02:28:52 +00:00
|
|
|
return Value == MVT::getIntVTBitMask(getValueType(0));
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool classof(const ConstantSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
2005-08-17 00:33:30 +00:00
|
|
|
return N->getOpcode() == ISD::Constant ||
|
|
|
|
N->getOpcode() == ISD::TargetConstant;
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class ConstantFPSDNode : public SDNode {
|
2007-08-24 20:59:15 +00:00
|
|
|
APFloat Value;
|
2007-02-04 02:23:32 +00:00
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
2007-08-31 23:34:27 +00:00
|
|
|
// Longterm plan: replace all uses of getValue with getValueAPF, remove
|
|
|
|
// getValue, rename getValueAPF to getValue.
|
2005-01-07 07:45:27 +00:00
|
|
|
protected:
|
|
|
|
friend class SelectionDAG;
|
2007-08-26 01:18:27 +00:00
|
|
|
ConstantFPSDNode(bool isTarget, const APFloat& val, MVT::ValueType VT)
|
2007-08-25 22:10:57 +00:00
|
|
|
: SDNode(isTarget ? ISD::TargetConstantFP : ISD::ConstantFP,
|
|
|
|
getSDVTList(VT)), Value(val) {
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
public:
|
|
|
|
|
2007-08-26 01:18:27 +00:00
|
|
|
const APFloat& getValueAPF() const { return Value; }
|
2005-01-07 07:45:27 +00:00
|
|
|
|
|
|
|
/// isExactlyValue - We don't rely on operator== working on double values, as
|
|
|
|
/// it returns true for things that are clearly not equal, like -0.0 and 0.0.
|
|
|
|
/// As such, this method can be used to do an exact bit-for-bit comparison of
|
|
|
|
/// two floating point values.
|
2007-08-31 23:34:27 +00:00
|
|
|
|
|
|
|
/// We leave the version with the double argument here because it's just so
|
|
|
|
/// convenient to write "2.0" and the like. Without this function we'd
|
|
|
|
/// have to duplicate its logic everywhere it's called.
|
2007-08-25 22:10:57 +00:00
|
|
|
bool isExactlyValue(double V) const {
|
|
|
|
if (getValueType(0)==MVT::f64)
|
|
|
|
return isExactlyValue(APFloat(V));
|
|
|
|
else
|
|
|
|
return isExactlyValue(APFloat((float)V));
|
|
|
|
}
|
2007-08-26 01:18:27 +00:00
|
|
|
bool isExactlyValue(const APFloat& V) const;
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2007-08-30 00:23:21 +00:00
|
|
|
bool isValueValidForType(MVT::ValueType VT, const APFloat& Val);
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
static bool classof(const ConstantFPSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
2006-01-29 06:24:40 +00:00
|
|
|
return N->getOpcode() == ISD::ConstantFP ||
|
|
|
|
N->getOpcode() == ISD::TargetConstantFP;
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class GlobalAddressSDNode : public SDNode {
|
|
|
|
GlobalValue *TheGlobal;
|
2006-02-25 09:54:52 +00:00
|
|
|
int Offset;
|
2007-02-04 02:23:32 +00:00
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
2005-01-07 07:45:27 +00:00
|
|
|
protected:
|
|
|
|
friend class SelectionDAG;
|
2005-11-30 02:04:11 +00:00
|
|
|
GlobalAddressSDNode(bool isTarget, const GlobalValue *GA, MVT::ValueType VT,
|
2007-04-21 20:56:26 +00:00
|
|
|
int o = 0);
|
2005-01-07 07:45:27 +00:00
|
|
|
public:
|
|
|
|
|
|
|
|
GlobalValue *getGlobal() const { return TheGlobal; }
|
2006-02-25 09:54:52 +00:00
|
|
|
int getOffset() const { return Offset; }
|
2005-01-07 07:45:27 +00:00
|
|
|
|
|
|
|
static bool classof(const GlobalAddressSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
2005-08-19 22:31:34 +00:00
|
|
|
return N->getOpcode() == ISD::GlobalAddress ||
|
2007-04-20 21:38:10 +00:00
|
|
|
N->getOpcode() == ISD::TargetGlobalAddress ||
|
|
|
|
N->getOpcode() == ISD::GlobalTLSAddress ||
|
|
|
|
N->getOpcode() == ISD::TargetGlobalTLSAddress;
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class FrameIndexSDNode : public SDNode {
|
|
|
|
int FI;
|
2007-02-04 02:23:32 +00:00
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
2005-01-07 07:45:27 +00:00
|
|
|
protected:
|
|
|
|
friend class SelectionDAG;
|
2005-08-25 00:43:01 +00:00
|
|
|
FrameIndexSDNode(int fi, MVT::ValueType VT, bool isTarg)
|
2007-02-04 08:13:53 +00:00
|
|
|
: SDNode(isTarg ? ISD::TargetFrameIndex : ISD::FrameIndex, getSDVTList(VT)),
|
|
|
|
FI(fi) {
|
2007-02-04 07:28:00 +00:00
|
|
|
}
|
2005-01-07 07:45:27 +00:00
|
|
|
public:
|
|
|
|
|
|
|
|
int getIndex() const { return FI; }
|
|
|
|
|
|
|
|
static bool classof(const FrameIndexSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
2005-08-25 00:43:01 +00:00
|
|
|
return N->getOpcode() == ISD::FrameIndex ||
|
|
|
|
N->getOpcode() == ISD::TargetFrameIndex;
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2006-04-22 18:53:45 +00:00
|
|
|
class JumpTableSDNode : public SDNode {
|
|
|
|
int JTI;
|
2007-02-04 02:23:32 +00:00
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
2006-04-22 18:53:45 +00:00
|
|
|
protected:
|
|
|
|
friend class SelectionDAG;
|
|
|
|
JumpTableSDNode(int jti, MVT::ValueType VT, bool isTarg)
|
2007-02-04 08:13:53 +00:00
|
|
|
: SDNode(isTarg ? ISD::TargetJumpTable : ISD::JumpTable, getSDVTList(VT)),
|
|
|
|
JTI(jti) {
|
2007-02-04 07:28:00 +00:00
|
|
|
}
|
2006-04-22 18:53:45 +00:00
|
|
|
public:
|
|
|
|
|
|
|
|
int getIndex() const { return JTI; }
|
|
|
|
|
|
|
|
static bool classof(const JumpTableSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
|
|
|
return N->getOpcode() == ISD::JumpTable ||
|
|
|
|
N->getOpcode() == ISD::TargetJumpTable;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
class ConstantPoolSDNode : public SDNode {
|
2006-09-12 21:00:35 +00:00
|
|
|
union {
|
|
|
|
Constant *ConstVal;
|
|
|
|
MachineConstantPoolValue *MachineCPVal;
|
|
|
|
} Val;
|
2006-09-14 07:30:48 +00:00
|
|
|
int Offset; // It's a MachineConstantPoolValue if top bit is set.
|
2006-01-31 22:23:14 +00:00
|
|
|
unsigned Alignment;
|
2007-02-04 02:23:32 +00:00
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
2005-01-07 07:45:27 +00:00
|
|
|
protected:
|
|
|
|
friend class SelectionDAG;
|
2006-02-25 09:54:52 +00:00
|
|
|
ConstantPoolSDNode(bool isTarget, Constant *c, MVT::ValueType VT,
|
|
|
|
int o=0)
|
2007-02-04 07:37:24 +00:00
|
|
|
: SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool,
|
2007-02-04 08:13:53 +00:00
|
|
|
getSDVTList(VT)), Offset(o), Alignment(0) {
|
2006-09-12 21:00:35 +00:00
|
|
|
assert((int)Offset >= 0 && "Offset is too large");
|
|
|
|
Val.ConstVal = c;
|
|
|
|
}
|
2006-02-25 09:54:52 +00:00
|
|
|
ConstantPoolSDNode(bool isTarget, Constant *c, MVT::ValueType VT, int o,
|
|
|
|
unsigned Align)
|
2007-02-04 07:37:24 +00:00
|
|
|
: SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool,
|
2007-02-04 08:13:53 +00:00
|
|
|
getSDVTList(VT)), Offset(o), Alignment(Align) {
|
2006-09-12 21:00:35 +00:00
|
|
|
assert((int)Offset >= 0 && "Offset is too large");
|
|
|
|
Val.ConstVal = c;
|
|
|
|
}
|
|
|
|
ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v,
|
|
|
|
MVT::ValueType VT, int o=0)
|
2007-02-04 07:37:24 +00:00
|
|
|
: SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool,
|
2007-02-04 08:13:53 +00:00
|
|
|
getSDVTList(VT)), Offset(o), Alignment(0) {
|
2006-09-12 21:00:35 +00:00
|
|
|
assert((int)Offset >= 0 && "Offset is too large");
|
|
|
|
Val.MachineCPVal = v;
|
|
|
|
Offset |= 1 << (sizeof(unsigned)*8-1);
|
|
|
|
}
|
|
|
|
ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v,
|
|
|
|
MVT::ValueType VT, int o, unsigned Align)
|
2007-02-04 07:37:24 +00:00
|
|
|
: SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool,
|
2007-02-04 08:13:53 +00:00
|
|
|
getSDVTList(VT)), Offset(o), Alignment(Align) {
|
2006-09-12 21:00:35 +00:00
|
|
|
assert((int)Offset >= 0 && "Offset is too large");
|
|
|
|
Val.MachineCPVal = v;
|
|
|
|
Offset |= 1 << (sizeof(unsigned)*8-1);
|
|
|
|
}
|
2005-01-07 07:45:27 +00:00
|
|
|
public:
|
|
|
|
|
2006-09-12 21:00:35 +00:00
|
|
|
bool isMachineConstantPoolEntry() const {
|
|
|
|
return (int)Offset < 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *getConstVal() const {
|
|
|
|
assert(!isMachineConstantPoolEntry() && "Wrong constantpool type");
|
|
|
|
return Val.ConstVal;
|
|
|
|
}
|
|
|
|
|
|
|
|
MachineConstantPoolValue *getMachineCPVal() const {
|
|
|
|
assert(isMachineConstantPoolEntry() && "Wrong constantpool type");
|
|
|
|
return Val.MachineCPVal;
|
|
|
|
}
|
|
|
|
|
2006-09-14 07:30:48 +00:00
|
|
|
int getOffset() const {
|
|
|
|
return Offset & ~(1 << (sizeof(unsigned)*8-1));
|
|
|
|
}
|
2006-02-09 02:10:15 +00:00
|
|
|
|
|
|
|
// Return the alignment of this constant pool object, which is either 0 (for
|
|
|
|
// default alignment) or log2 of the desired value.
|
2006-01-31 22:23:14 +00:00
|
|
|
unsigned getAlignment() const { return Alignment; }
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2006-09-12 21:00:35 +00:00
|
|
|
const Type *getType() const;
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
static bool classof(const ConstantPoolSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
2005-08-25 05:02:41 +00:00
|
|
|
return N->getOpcode() == ISD::ConstantPool ||
|
|
|
|
N->getOpcode() == ISD::TargetConstantPool;
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class BasicBlockSDNode : public SDNode {
|
|
|
|
MachineBasicBlock *MBB;
|
2007-02-04 02:23:32 +00:00
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
2005-01-07 07:45:27 +00:00
|
|
|
protected:
|
|
|
|
friend class SelectionDAG;
|
2007-03-23 18:44:11 +00:00
|
|
|
explicit BasicBlockSDNode(MachineBasicBlock *mbb)
|
2007-02-04 08:13:53 +00:00
|
|
|
: SDNode(ISD::BasicBlock, getSDVTList(MVT::Other)), MBB(mbb) {
|
2007-02-04 07:28:00 +00:00
|
|
|
}
|
2005-01-07 07:45:27 +00:00
|
|
|
public:
|
|
|
|
|
|
|
|
MachineBasicBlock *getBasicBlock() const { return MBB; }
|
|
|
|
|
|
|
|
static bool classof(const BasicBlockSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
|
|
|
return N->getOpcode() == ISD::BasicBlock;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2005-04-27 20:10:01 +00:00
|
|
|
class SrcValueSDNode : public SDNode {
|
|
|
|
const Value *V;
|
2005-05-03 17:19:30 +00:00
|
|
|
int offset;
|
2007-02-04 02:23:32 +00:00
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
2005-04-27 20:10:01 +00:00
|
|
|
protected:
|
|
|
|
friend class SelectionDAG;
|
2005-05-03 17:19:30 +00:00
|
|
|
SrcValueSDNode(const Value* v, int o)
|
2007-02-04 08:13:53 +00:00
|
|
|
: SDNode(ISD::SRCVALUE, getSDVTList(MVT::Other)), V(v), offset(o) {
|
2007-02-04 07:28:00 +00:00
|
|
|
}
|
2005-04-27 20:10:01 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
const Value *getValue() const { return V; }
|
2005-05-03 17:19:30 +00:00
|
|
|
int getOffset() const { return offset; }
|
2005-04-27 20:10:01 +00:00
|
|
|
|
|
|
|
static bool classof(const SrcValueSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
|
|
|
return N->getOpcode() == ISD::SRCVALUE;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2005-08-16 21:55:35 +00:00
|
|
|
class RegisterSDNode : public SDNode {
|
2005-01-07 07:45:27 +00:00
|
|
|
unsigned Reg;
|
2007-02-04 02:23:32 +00:00
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
2005-01-07 07:45:27 +00:00
|
|
|
protected:
|
|
|
|
friend class SelectionDAG;
|
2005-08-16 21:55:35 +00:00
|
|
|
RegisterSDNode(unsigned reg, MVT::ValueType VT)
|
2007-02-04 08:13:53 +00:00
|
|
|
: SDNode(ISD::Register, getSDVTList(VT)), Reg(reg) {
|
2007-02-04 07:28:00 +00:00
|
|
|
}
|
2005-01-07 07:45:27 +00:00
|
|
|
public:
|
|
|
|
|
|
|
|
unsigned getReg() const { return Reg; }
|
|
|
|
|
2005-08-16 21:55:35 +00:00
|
|
|
static bool classof(const RegisterSDNode *) { return true; }
|
2005-01-07 07:45:27 +00:00
|
|
|
static bool classof(const SDNode *N) {
|
2005-08-16 21:55:35 +00:00
|
|
|
return N->getOpcode() == ISD::Register;
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class ExternalSymbolSDNode : public SDNode {
|
|
|
|
const char *Symbol;
|
2007-02-04 02:23:32 +00:00
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
2005-01-07 07:45:27 +00:00
|
|
|
protected:
|
|
|
|
friend class SelectionDAG;
|
2005-10-23 03:40:17 +00:00
|
|
|
ExternalSymbolSDNode(bool isTarget, const char *Sym, MVT::ValueType VT)
|
2007-02-04 07:37:24 +00:00
|
|
|
: SDNode(isTarget ? ISD::TargetExternalSymbol : ISD::ExternalSymbol,
|
2007-02-04 08:13:53 +00:00
|
|
|
getSDVTList(VT)), Symbol(Sym) {
|
2007-02-04 07:28:00 +00:00
|
|
|
}
|
2005-01-07 07:45:27 +00:00
|
|
|
public:
|
|
|
|
|
|
|
|
const char *getSymbol() const { return Symbol; }
|
|
|
|
|
|
|
|
static bool classof(const ExternalSymbolSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
2005-10-23 03:40:17 +00:00
|
|
|
return N->getOpcode() == ISD::ExternalSymbol ||
|
|
|
|
N->getOpcode() == ISD::TargetExternalSymbol;
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2005-08-09 20:20:18 +00:00
|
|
|
class CondCodeSDNode : public SDNode {
|
2005-01-07 07:45:27 +00:00
|
|
|
ISD::CondCode Condition;
|
2007-02-04 02:23:32 +00:00
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
2005-01-07 07:45:27 +00:00
|
|
|
protected:
|
|
|
|
friend class SelectionDAG;
|
2007-03-23 18:44:11 +00:00
|
|
|
explicit CondCodeSDNode(ISD::CondCode Cond)
|
2007-02-04 08:13:53 +00:00
|
|
|
: SDNode(ISD::CONDCODE, getSDVTList(MVT::Other)), Condition(Cond) {
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
public:
|
|
|
|
|
2005-08-09 20:20:18 +00:00
|
|
|
ISD::CondCode get() const { return Condition; }
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2005-08-09 20:20:18 +00:00
|
|
|
static bool classof(const CondCodeSDNode *) { return true; }
|
2005-01-07 07:45:27 +00:00
|
|
|
static bool classof(const SDNode *N) {
|
2005-08-09 20:20:18 +00:00
|
|
|
return N->getOpcode() == ISD::CONDCODE;
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2005-07-10 00:07:11 +00:00
|
|
|
/// VTSDNode - This class is used to represent MVT::ValueType's, which are used
|
|
|
|
/// to parameterize some operations.
|
|
|
|
class VTSDNode : public SDNode {
|
|
|
|
MVT::ValueType ValueType;
|
2007-02-04 02:23:32 +00:00
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
2005-07-10 00:07:11 +00:00
|
|
|
protected:
|
|
|
|
friend class SelectionDAG;
|
2007-03-23 18:44:11 +00:00
|
|
|
explicit VTSDNode(MVT::ValueType VT)
|
2007-02-04 08:13:53 +00:00
|
|
|
: SDNode(ISD::VALUETYPE, getSDVTList(MVT::Other)), ValueType(VT) {
|
2007-02-04 07:28:00 +00:00
|
|
|
}
|
2005-07-10 00:07:11 +00:00
|
|
|
public:
|
|
|
|
|
|
|
|
MVT::ValueType getVT() const { return ValueType; }
|
|
|
|
|
|
|
|
static bool classof(const VTSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
|
|
|
return N->getOpcode() == ISD::VALUETYPE;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2006-10-09 20:55:20 +00:00
|
|
|
/// LoadSDNode - This class is used to represent ISD::LOAD nodes.
|
|
|
|
///
|
|
|
|
class LoadSDNode : public SDNode {
|
2007-02-04 02:23:32 +00:00
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
2007-02-04 08:13:53 +00:00
|
|
|
SDOperand Ops[3];
|
|
|
|
|
2006-10-10 01:44:58 +00:00
|
|
|
// AddrMode - unindexed, pre-indexed, post-indexed.
|
2006-11-09 17:55:04 +00:00
|
|
|
ISD::MemIndexedMode AddrMode;
|
2006-10-10 01:44:58 +00:00
|
|
|
|
|
|
|
// ExtType - non-ext, anyext, sext, zext.
|
|
|
|
ISD::LoadExtType ExtType;
|
|
|
|
|
2006-10-11 07:10:22 +00:00
|
|
|
// LoadedVT - VT of loaded value before extension.
|
|
|
|
MVT::ValueType LoadedVT;
|
2006-10-10 01:44:58 +00:00
|
|
|
|
|
|
|
// SrcValue - Memory location for alias analysis.
|
2006-10-09 20:55:20 +00:00
|
|
|
const Value *SrcValue;
|
2006-10-10 01:44:58 +00:00
|
|
|
|
|
|
|
// SVOffset - Memory location offset.
|
2006-10-09 20:55:20 +00:00
|
|
|
int SVOffset;
|
2006-10-10 01:44:58 +00:00
|
|
|
|
|
|
|
// Alignment - Alignment of memory location in bytes.
|
2006-10-09 20:55:20 +00:00
|
|
|
unsigned Alignment;
|
2006-10-10 01:44:58 +00:00
|
|
|
|
|
|
|
// IsVolatile - True if the load is volatile.
|
2006-10-09 20:55:20 +00:00
|
|
|
bool IsVolatile;
|
|
|
|
protected:
|
|
|
|
friend class SelectionDAG;
|
2007-02-04 07:37:24 +00:00
|
|
|
LoadSDNode(SDOperand *ChainPtrOff, SDVTList VTs,
|
2006-11-09 17:55:04 +00:00
|
|
|
ISD::MemIndexedMode AM, ISD::LoadExtType ETy, MVT::ValueType LVT,
|
2007-04-22 23:15:30 +00:00
|
|
|
const Value *SV, int O=0, unsigned Align=0, bool Vol=false)
|
2007-02-04 08:13:53 +00:00
|
|
|
: SDNode(ISD::LOAD, VTs),
|
2006-10-11 07:10:22 +00:00
|
|
|
AddrMode(AM), ExtType(ETy), LoadedVT(LVT), SrcValue(SV), SVOffset(O),
|
2006-10-09 20:55:20 +00:00
|
|
|
Alignment(Align), IsVolatile(Vol) {
|
2007-02-04 08:13:53 +00:00
|
|
|
Ops[0] = ChainPtrOff[0]; // Chain
|
|
|
|
Ops[1] = ChainPtrOff[1]; // Ptr
|
|
|
|
Ops[2] = ChainPtrOff[2]; // Off
|
|
|
|
InitOperands(Ops, 3);
|
2007-04-22 23:15:30 +00:00
|
|
|
assert(Align != 0 && "Loads should have non-zero aligment");
|
2007-02-04 07:28:00 +00:00
|
|
|
assert((getOffset().getOpcode() == ISD::UNDEF ||
|
|
|
|
AddrMode != ISD::UNINDEXED) &&
|
2006-10-26 21:52:24 +00:00
|
|
|
"Only indexed load has a non-undef offset operand");
|
2006-10-09 20:55:20 +00:00
|
|
|
}
|
|
|
|
public:
|
|
|
|
|
2006-10-10 01:44:58 +00:00
|
|
|
const SDOperand getChain() const { return getOperand(0); }
|
|
|
|
const SDOperand getBasePtr() const { return getOperand(1); }
|
|
|
|
const SDOperand getOffset() const { return getOperand(2); }
|
2006-11-09 17:55:04 +00:00
|
|
|
ISD::MemIndexedMode getAddressingMode() const { return AddrMode; }
|
2006-10-09 20:55:20 +00:00
|
|
|
ISD::LoadExtType getExtensionType() const { return ExtType; }
|
2006-10-11 07:10:22 +00:00
|
|
|
MVT::ValueType getLoadedVT() const { return LoadedVT; }
|
2006-10-09 20:55:20 +00:00
|
|
|
const Value *getSrcValue() const { return SrcValue; }
|
|
|
|
int getSrcValueOffset() const { return SVOffset; }
|
|
|
|
unsigned getAlignment() const { return Alignment; }
|
|
|
|
bool isVolatile() const { return IsVolatile; }
|
|
|
|
|
|
|
|
static bool classof(const LoadSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
|
|
|
return N->getOpcode() == ISD::LOAD;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/// StoreSDNode - This class is used to represent ISD::STORE nodes.
|
|
|
|
///
|
|
|
|
class StoreSDNode : public SDNode {
|
2007-02-04 02:23:32 +00:00
|
|
|
virtual void ANCHOR(); // Out-of-line virtual method to give class a home.
|
2007-02-04 08:13:53 +00:00
|
|
|
SDOperand Ops[4];
|
|
|
|
|
2006-10-10 01:44:58 +00:00
|
|
|
// AddrMode - unindexed, pre-indexed, post-indexed.
|
2006-11-09 17:55:04 +00:00
|
|
|
ISD::MemIndexedMode AddrMode;
|
2006-10-10 01:44:58 +00:00
|
|
|
|
2007-10-05 10:37:00 +00:00
|
|
|
// IsTruncStore - True if the op does a truncation before store.
|
2006-10-10 01:44:58 +00:00
|
|
|
bool IsTruncStore;
|
|
|
|
|
2006-10-11 07:10:22 +00:00
|
|
|
// StoredVT - VT of the value after truncation.
|
2006-10-10 01:44:58 +00:00
|
|
|
MVT::ValueType StoredVT;
|
|
|
|
|
|
|
|
// SrcValue - Memory location for alias analysis.
|
2006-10-09 20:55:20 +00:00
|
|
|
const Value *SrcValue;
|
2006-10-10 01:44:58 +00:00
|
|
|
|
|
|
|
// SVOffset - Memory location offset.
|
2006-10-09 20:55:20 +00:00
|
|
|
int SVOffset;
|
2006-10-10 01:44:58 +00:00
|
|
|
|
|
|
|
// Alignment - Alignment of memory location in bytes.
|
2006-10-09 20:55:20 +00:00
|
|
|
unsigned Alignment;
|
2006-10-10 01:44:58 +00:00
|
|
|
|
|
|
|
// IsVolatile - True if the store is volatile.
|
2006-10-09 20:55:20 +00:00
|
|
|
bool IsVolatile;
|
|
|
|
protected:
|
|
|
|
friend class SelectionDAG;
|
2007-02-04 07:37:24 +00:00
|
|
|
StoreSDNode(SDOperand *ChainValuePtrOff, SDVTList VTs,
|
2006-11-09 17:55:04 +00:00
|
|
|
ISD::MemIndexedMode AM, bool isTrunc, MVT::ValueType SVT,
|
2006-10-09 20:55:20 +00:00
|
|
|
const Value *SV, int O=0, unsigned Align=0, bool Vol=false)
|
2007-02-04 08:13:53 +00:00
|
|
|
: SDNode(ISD::STORE, VTs),
|
2006-10-09 20:55:20 +00:00
|
|
|
AddrMode(AM), IsTruncStore(isTrunc), StoredVT(SVT), SrcValue(SV),
|
|
|
|
SVOffset(O), Alignment(Align), IsVolatile(Vol) {
|
2007-02-04 08:13:53 +00:00
|
|
|
Ops[0] = ChainValuePtrOff[0]; // Chain
|
|
|
|
Ops[1] = ChainValuePtrOff[1]; // Value
|
|
|
|
Ops[2] = ChainValuePtrOff[2]; // Ptr
|
|
|
|
Ops[3] = ChainValuePtrOff[3]; // Off
|
|
|
|
InitOperands(Ops, 4);
|
2007-04-22 23:15:30 +00:00
|
|
|
assert(Align != 0 && "Stores should have non-zero aligment");
|
2007-02-04 07:28:00 +00:00
|
|
|
assert((getOffset().getOpcode() == ISD::UNDEF ||
|
|
|
|
AddrMode != ISD::UNINDEXED) &&
|
2006-10-26 21:52:24 +00:00
|
|
|
"Only indexed store has a non-undef offset operand");
|
2006-10-09 20:55:20 +00:00
|
|
|
}
|
|
|
|
public:
|
|
|
|
|
2006-10-10 01:44:58 +00:00
|
|
|
const SDOperand getChain() const { return getOperand(0); }
|
2006-10-13 21:14:26 +00:00
|
|
|
const SDOperand getValue() const { return getOperand(1); }
|
|
|
|
const SDOperand getBasePtr() const { return getOperand(2); }
|
|
|
|
const SDOperand getOffset() const { return getOperand(3); }
|
2006-11-09 17:55:04 +00:00
|
|
|
ISD::MemIndexedMode getAddressingMode() const { return AddrMode; }
|
2006-10-09 20:55:20 +00:00
|
|
|
bool isTruncatingStore() const { return IsTruncStore; }
|
|
|
|
MVT::ValueType getStoredVT() const { return StoredVT; }
|
|
|
|
const Value *getSrcValue() const { return SrcValue; }
|
|
|
|
int getSrcValueOffset() const { return SVOffset; }
|
|
|
|
unsigned getAlignment() const { return Alignment; }
|
|
|
|
bool isVolatile() const { return IsVolatile; }
|
|
|
|
|
2006-12-16 06:21:55 +00:00
|
|
|
static bool classof(const StoreSDNode *) { return true; }
|
2006-10-09 20:55:20 +00:00
|
|
|
static bool classof(const SDNode *N) {
|
|
|
|
return N->getOpcode() == ISD::STORE;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2005-07-10 00:07:11 +00:00
|
|
|
|
2005-01-10 23:05:53 +00:00
|
|
|
class SDNodeIterator : public forward_iterator<SDNode, ptrdiff_t> {
|
|
|
|
SDNode *Node;
|
|
|
|
unsigned Operand;
|
2005-04-21 20:39:54 +00:00
|
|
|
|
2005-01-10 23:05:53 +00:00
|
|
|
SDNodeIterator(SDNode *N, unsigned Op) : Node(N), Operand(Op) {}
|
|
|
|
public:
|
|
|
|
bool operator==(const SDNodeIterator& x) const {
|
|
|
|
return Operand == x.Operand;
|
|
|
|
}
|
|
|
|
bool operator!=(const SDNodeIterator& x) const { return !operator==(x); }
|
|
|
|
|
|
|
|
const SDNodeIterator &operator=(const SDNodeIterator &I) {
|
|
|
|
assert(I.Node == Node && "Cannot assign iterators to two different nodes!");
|
|
|
|
Operand = I.Operand;
|
|
|
|
return *this;
|
|
|
|
}
|
2005-04-21 20:39:54 +00:00
|
|
|
|
2005-01-10 23:05:53 +00:00
|
|
|
pointer operator*() const {
|
|
|
|
return Node->getOperand(Operand).Val;
|
|
|
|
}
|
|
|
|
pointer operator->() const { return operator*(); }
|
2005-04-21 20:39:54 +00:00
|
|
|
|
2005-01-10 23:05:53 +00:00
|
|
|
SDNodeIterator& operator++() { // Preincrement
|
|
|
|
++Operand;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
SDNodeIterator operator++(int) { // Postincrement
|
2005-04-21 20:39:54 +00:00
|
|
|
SDNodeIterator tmp = *this; ++*this; return tmp;
|
2005-01-10 23:05:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static SDNodeIterator begin(SDNode *N) { return SDNodeIterator(N, 0); }
|
|
|
|
static SDNodeIterator end (SDNode *N) {
|
|
|
|
return SDNodeIterator(N, N->getNumOperands());
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned getOperand() const { return Operand; }
|
|
|
|
const SDNode *getNode() const { return Node; }
|
|
|
|
};
|
|
|
|
|
|
|
|
template <> struct GraphTraits<SDNode*> {
|
|
|
|
typedef SDNode NodeType;
|
|
|
|
typedef SDNodeIterator ChildIteratorType;
|
|
|
|
static inline NodeType *getEntryNode(SDNode *N) { return N; }
|
2005-04-21 20:39:54 +00:00
|
|
|
static inline ChildIteratorType child_begin(NodeType *N) {
|
2005-01-10 23:05:53 +00:00
|
|
|
return SDNodeIterator::begin(N);
|
|
|
|
}
|
2005-04-21 20:39:54 +00:00
|
|
|
static inline ChildIteratorType child_end(NodeType *N) {
|
2005-01-10 23:05:53 +00:00
|
|
|
return SDNodeIterator::end(N);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2005-11-09 23:46:43 +00:00
|
|
|
template<>
|
|
|
|
struct ilist_traits<SDNode> {
|
|
|
|
static SDNode *getPrev(const SDNode *N) { return N->Prev; }
|
|
|
|
static SDNode *getNext(const SDNode *N) { return N->Next; }
|
|
|
|
|
|
|
|
static void setPrev(SDNode *N, SDNode *Prev) { N->Prev = Prev; }
|
|
|
|
static void setNext(SDNode *N, SDNode *Next) { N->Next = Next; }
|
|
|
|
|
|
|
|
static SDNode *createSentinel() {
|
2007-02-04 08:13:53 +00:00
|
|
|
return new SDNode(ISD::EntryToken, SDNode::getSDVTList(MVT::Other));
|
2005-11-09 23:46:43 +00:00
|
|
|
}
|
|
|
|
static void destroySentinel(SDNode *N) { delete N; }
|
|
|
|
//static SDNode *createNode(const SDNode &V) { return new SDNode(V); }
|
|
|
|
|
|
|
|
|
|
|
|
void addNodeToList(SDNode *NTy) {}
|
|
|
|
void removeNodeFromList(SDNode *NTy) {}
|
|
|
|
void transferNodesFromList(iplist<SDNode, ilist_traits> &L2,
|
|
|
|
const ilist_iterator<SDNode> &X,
|
|
|
|
const ilist_iterator<SDNode> &Y) {}
|
|
|
|
};
|
|
|
|
|
2006-10-04 00:56:09 +00:00
|
|
|
namespace ISD {
|
2007-10-06 08:09:29 +00:00
|
|
|
/// isNormalLoad - Returns true if the specified node is a non-extending
|
|
|
|
/// and unindexed load.
|
|
|
|
inline bool isNormalLoad(const SDNode *N) {
|
|
|
|
if (N->getOpcode() != ISD::LOAD)
|
|
|
|
return false;
|
|
|
|
const LoadSDNode *Ld = cast<LoadSDNode>(N);
|
|
|
|
return Ld->getExtensionType() == ISD::NON_EXTLOAD &&
|
|
|
|
Ld->getAddressingMode() == ISD::UNINDEXED;
|
|
|
|
}
|
|
|
|
|
2006-10-09 20:55:20 +00:00
|
|
|
/// isNON_EXTLoad - Returns true if the specified node is a non-extending
|
|
|
|
/// load.
|
|
|
|
inline bool isNON_EXTLoad(const SDNode *N) {
|
|
|
|
return N->getOpcode() == ISD::LOAD &&
|
|
|
|
cast<LoadSDNode>(N)->getExtensionType() == ISD::NON_EXTLOAD;
|
|
|
|
}
|
|
|
|
|
2006-10-04 00:56:09 +00:00
|
|
|
/// isEXTLoad - Returns true if the specified node is a EXTLOAD.
|
|
|
|
///
|
|
|
|
inline bool isEXTLoad(const SDNode *N) {
|
2006-10-09 20:55:20 +00:00
|
|
|
return N->getOpcode() == ISD::LOAD &&
|
|
|
|
cast<LoadSDNode>(N)->getExtensionType() == ISD::EXTLOAD;
|
2006-10-04 00:56:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// isSEXTLoad - Returns true if the specified node is a SEXTLOAD.
|
|
|
|
///
|
|
|
|
inline bool isSEXTLoad(const SDNode *N) {
|
2006-10-09 20:55:20 +00:00
|
|
|
return N->getOpcode() == ISD::LOAD &&
|
|
|
|
cast<LoadSDNode>(N)->getExtensionType() == ISD::SEXTLOAD;
|
2006-10-04 00:56:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// isZEXTLoad - Returns true if the specified node is a ZEXTLOAD.
|
|
|
|
///
|
|
|
|
inline bool isZEXTLoad(const SDNode *N) {
|
2006-10-09 20:55:20 +00:00
|
|
|
return N->getOpcode() == ISD::LOAD &&
|
|
|
|
cast<LoadSDNode>(N)->getExtensionType() == ISD::ZEXTLOAD;
|
2006-10-04 00:56:09 +00:00
|
|
|
}
|
2006-10-13 21:14:26 +00:00
|
|
|
|
2007-03-07 08:04:41 +00:00
|
|
|
/// isUNINDEXEDLoad - Returns true if the specified node is a unindexed load.
|
|
|
|
///
|
|
|
|
inline bool isUNINDEXEDLoad(const SDNode *N) {
|
|
|
|
return N->getOpcode() == ISD::LOAD &&
|
|
|
|
cast<LoadSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
|
|
|
|
}
|
|
|
|
|
2006-10-13 21:14:26 +00:00
|
|
|
/// isNON_TRUNCStore - Returns true if the specified node is a non-truncating
|
|
|
|
/// store.
|
|
|
|
inline bool isNON_TRUNCStore(const SDNode *N) {
|
|
|
|
return N->getOpcode() == ISD::STORE &&
|
|
|
|
!cast<StoreSDNode>(N)->isTruncatingStore();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// isTRUNCStore - Returns true if the specified node is a truncating
|
|
|
|
/// store.
|
|
|
|
inline bool isTRUNCStore(const SDNode *N) {
|
|
|
|
return N->getOpcode() == ISD::STORE &&
|
|
|
|
cast<StoreSDNode>(N)->isTruncatingStore();
|
|
|
|
}
|
2006-10-04 00:56:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
} // end llvm namespace
|
|
|
|
|
|
|
|
#endif
|