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
|
|
|
|
//
|
2007-12-29 19:59:42 +00:00
|
|
|
// This file 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
|
|
|
|
|
2008-09-12 18:08:03 +00:00
|
|
|
#include "llvm/Constants.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"
|
2008-07-28 21:51:04 +00:00
|
|
|
#include "llvm/ADT/ilist_node.h"
|
2009-04-27 18:41:29 +00:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2008-07-28 21:51:04 +00:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2006-09-12 21:00:35 +00:00
|
|
|
#include "llvm/CodeGen/ValueTypes.h"
|
2008-04-07 19:35:22 +00:00
|
|
|
#include "llvm/CodeGen/MachineMemOperand.h"
|
2009-09-15 19:05:41 +00:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2009-10-26 01:35:46 +00:00
|
|
|
#include "llvm/System/DataTypes.h"
|
2009-06-19 22:08:58 +00:00
|
|
|
#include "llvm/Support/DebugLoc.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;
|
2009-01-13 00:35:13 +00:00
|
|
|
class Value;
|
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;
|
2008-09-20 18:02:18 +00:00
|
|
|
template <typename T> struct ilist_traits;
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2010-01-20 20:13:31 +00:00
|
|
|
void checkForCycles(const SDNode *N);
|
|
|
|
|
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 {
|
2009-08-10 22:56:29 +00:00
|
|
|
const EVT *VTs;
|
2009-04-09 23:53:31 +00:00
|
|
|
unsigned int NumVTs;
|
2006-08-15 19:11:05 +00:00
|
|
|
};
|
|
|
|
|
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
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
//===--------------------------------------------------------------------===//
|
2009-01-28 21:34:36 +00:00
|
|
|
/// ISD::NodeType enum - This enum defines the target-independent operators
|
|
|
|
/// for a SelectionDAG.
|
2005-01-07 07:45:27 +00:00
|
|
|
///
|
2009-01-28 21:34:36 +00:00
|
|
|
/// Targets may also define target-dependent operator codes for SDNodes. For
|
|
|
|
/// example, on x86, these are the enum values in the X86ISD namespace.
|
|
|
|
/// Targets should aim to use target-independent operators to model their
|
|
|
|
/// instruction sets as much as possible, and only use target-dependent
|
|
|
|
/// operators when they have special requirements.
|
|
|
|
///
|
|
|
|
/// Finally, during and after selection proper, SNodes may use special
|
|
|
|
/// operator codes that correspond directly with MachineInstr opcodes. These
|
|
|
|
/// are used to represent selected instructions. See the isMachineOpcode()
|
|
|
|
/// and getMachineOpcode() member functions of SDNode.
|
2009-01-28 21:13:08 +00:00
|
|
|
///
|
2005-01-07 07:45:27 +00:00
|
|
|
enum NodeType {
|
2009-03-23 15:54:02 +00:00
|
|
|
// DELETED_NODE - This is an illegal value that is used to catch
|
2006-05-27 00:40:15 +00:00
|
|
|
// errors. This opcode is not a legal opcode for any node.
|
|
|
|
DELETED_NODE,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2005-01-13 17:58:35 +00:00
|
|
|
// EntryToken - This is the marker used to indicate the start of the region.
|
|
|
|
EntryToken,
|
|
|
|
|
2008-10-21 23:57:52 +00:00
|
|
|
// TokenFactor - 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,
|
2009-02-17 22:15:04 +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
|
2005-08-30 02:39:32 +00:00
|
|
|
// 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.
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@78142 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-05 01:29:28 +00:00
|
|
|
BasicBlock, VALUETYPE, CONDCODE, Register,
|
2006-03-01 00:51:13 +00:00
|
|
|
Constant, ConstantFP,
|
2007-04-20 21:38:10 +00:00
|
|
|
GlobalAddress, GlobalTLSAddress, FrameIndex,
|
2009-10-30 01:27:03 +00:00
|
|
|
JumpTable, ConstantPool, ExternalSymbol, BlockAddress,
|
2006-03-01 00:51:13 +00:00
|
|
|
|
2006-10-11 04:29:42 +00:00
|
|
|
// The address of the GOT
|
|
|
|
GLOBAL_OFFSET_TABLE,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
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,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
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,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2009-08-11 00:09:57 +00:00
|
|
|
// RESULT, OUTCHAIN = LSDAADDR(INCHAIN) - This node represents the
|
|
|
|
// address of the Language Specific Data Area for the enclosing function.
|
|
|
|
LSDAADDR,
|
|
|
|
|
2007-02-21 22:37:22 +00:00
|
|
|
// 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,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
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,
|
2008-09-16 21:48:12 +00:00
|
|
|
TargetExternalSymbol,
|
2009-10-30 01:27:03 +00:00
|
|
|
TargetBlockAddress,
|
2009-02-17 22:15:04 +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,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2006-03-28 00:39:06 +00:00
|
|
|
/// 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,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2005-08-16 21:55:35 +00:00
|
|
|
// CopyToReg - This node has three operands: a chain, a register number to
|
2009-02-17 22:15:04 +00:00
|
|
|
// 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
|
2007-11-19 15:36:19 +00:00
|
|
|
// SelectionDAG. The register is available from the RegisterSDNode object.
|
2005-01-07 07:45:27 +00:00
|
|
|
CopyFromReg,
|
|
|
|
|
2005-04-01 22:34:39 +00:00
|
|
|
// UNDEF - An undefined node
|
|
|
|
UNDEF,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2008-03-12 20:30:08 +00:00
|
|
|
// EXTRACT_ELEMENT - This is used to get the lower or upper (determined by
|
2008-06-25 20:24:48 +00:00
|
|
|
// a Constant, which is required to be operand #1) half of the integer or
|
|
|
|
// float value specified as operand #0. This is only for use before
|
|
|
|
// legalization, for values that will be broken into multiple registers.
|
2005-01-07 07:45:27 +00:00
|
|
|
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,
|
2008-06-25 20:24:48 +00:00
|
|
|
|
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
|
2009-07-30 08:44:08 +00:00
|
|
|
// number of inputs and outputs. 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.
|
2005-11-20 22:55:57 +00:00
|
|
|
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
|
2007-10-25 12:28:12 +00:00
|
|
|
// a signed/unsigned value of type i[2*N], and return the full value as
|
2007-10-05 14:07:56 +00:00
|
|
|
// 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,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2009-06-02 03:12:52 +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
|
2009-06-02 03:12:52 +00:00
|
|
|
// result is the carry flag result.
|
2006-02-17 05:43:56 +00:00
|
|
|
ADDC, SUBC,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2006-02-17 05:43:56 +00:00
|
|
|
// 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
|
2009-06-02 03:12:52 +00:00
|
|
|
// values.
|
2006-02-17 05:43:56 +00:00
|
|
|
ADDE, SUBE,
|
2008-11-21 00:11:16 +00:00
|
|
|
|
2008-11-22 07:24:01 +00:00
|
|
|
// RESULT, BOOL = [SU]ADDO(LHS, RHS) - Overflow-aware nodes for addition.
|
|
|
|
// These nodes take two operands: the normal LHS and RHS to the add. They
|
|
|
|
// produce two results: the normal result of the add, and a boolean that
|
|
|
|
// indicates if an overflow occured (*not* a flag, because it may be stored
|
|
|
|
// to memory, etc.). If the type of the boolean is not i1 then the high
|
2008-11-23 15:47:28 +00:00
|
|
|
// bits conform to getBooleanContents.
|
2008-11-22 07:24:01 +00:00
|
|
|
// These nodes are generated from the llvm.[su]add.with.overflow intrinsics.
|
2008-11-21 02:12:42 +00:00
|
|
|
SADDO, UADDO,
|
2008-11-21 00:11:16 +00:00
|
|
|
|
2008-12-09 22:08:41 +00:00
|
|
|
// Same for subtraction
|
|
|
|
SSUBO, USUBO,
|
|
|
|
|
|
|
|
// Same for multiplication
|
|
|
|
SMULO, UMULO,
|
|
|
|
|
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-12-22 20:47:56 +00:00
|
|
|
// INT = FGETSIGN(FP) - Return the sign bit of the specified floating point
|
|
|
|
// value as an integer 0/1 value.
|
|
|
|
FGETSIGN,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2009-04-20 17:27:09 +00:00
|
|
|
/// BUILD_VECTOR(ELT0, ELT1, ELT2, ELT3,...) - Return a vector with the
|
|
|
|
/// specified, possibly variable, elements. The number of elements is
|
|
|
|
/// required to be a power of two. The types of the operands must all be
|
|
|
|
/// the same and must match the vector element type, except that integer
|
|
|
|
/// types are allowed to be larger than the element type, in which case
|
|
|
|
/// the operands are implicitly truncated.
|
2006-03-19 00:52:25 +00:00
|
|
|
BUILD_VECTOR,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2007-06-25 16:23:39 +00:00
|
|
|
/// INSERT_VECTOR_ELT(VECTOR, VAL, IDX) - Returns VECTOR with the element
|
2008-02-27 10:18:23 +00:00
|
|
|
/// at IDX replaced with VAL. If the type of VAL is larger than the vector
|
|
|
|
/// element type then VAL is truncated before replacement.
|
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
|
2009-07-09 22:01:03 +00:00
|
|
|
/// identified by the (potentially variable) element number IDX. If the
|
|
|
|
/// return type is an integer type larger than the element type of the
|
|
|
|
/// vector, the result is extended to the width of the return type.
|
2006-03-21 20:43:08 +00:00
|
|
|
EXTRACT_VECTOR_ELT,
|
2009-02-17 22:15:04 +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,
|
2009-02-17 22:15:04 +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,
|
2008-02-28 17:12:11 +00:00
|
|
|
|
2009-04-29 18:13:31 +00:00
|
|
|
/// VECTOR_SHUFFLE(VEC1, VEC2) - Returns a vector, of the same type as
|
2009-08-27 23:44:33 +00:00
|
|
|
/// VEC1/VEC2. A VECTOR_SHUFFLE node also contains an array of constant int
|
2009-04-29 18:13:31 +00:00
|
|
|
/// values that indicate which value (or undef) each result element will
|
|
|
|
/// get. These constant ints are accessible through the
|
|
|
|
/// ShuffleVectorSDNode class. 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.
|
2006-03-19 23:42:51 +00:00
|
|
|
VECTOR_SHUFFLE,
|
2008-02-28 17:12:11 +00:00
|
|
|
|
2006-03-19 05:26:45 +00:00
|
|
|
/// SCALAR_TO_VECTOR(VAL) - This represents the operation of loading a
|
2008-01-07 17:52:24 +00:00
|
|
|
/// scalar value into element 0 of the resultant vector type. The top
|
2009-04-18 20:16:54 +00:00
|
|
|
/// elements 1 to N-1 of the N-element vector are undefined. The type
|
|
|
|
/// of the operand must match the vector element type, except when they
|
|
|
|
/// are integer types. In this case the operand is allowed to be wider
|
|
|
|
/// than the vector element type, and is implicitly truncated to it.
|
2006-03-19 05:26:45 +00:00
|
|
|
SCALAR_TO_VECTOR,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2005-04-06 04:21:29 +00:00
|
|
|
// MULHU/MULHS - Multiply high - Multiply two integers of type iN, producing
|
2007-10-25 12:28:12 +00:00
|
|
|
// an unsigned/signed value of type i[2*N], then return the top part.
|
2005-04-06 04:21:29 +00:00
|
|
|
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,
|
|
|
|
|
2008-10-22 09:06:24 +00:00
|
|
|
// Select(COND, TRUEVAL, FALSEVAL). If the type of the boolean COND is not
|
2008-11-23 15:47:28 +00:00
|
|
|
// i1 then the high bits must conform to getBooleanContents.
|
2008-10-22 09:06:24 +00:00
|
|
|
SELECT,
|
|
|
|
|
2009-02-17 22:15:04 +00:00
|
|
|
// Select with condition operator - This selects between a true value and
|
2005-08-10 20:51:12 +00:00
|
|
|
// a false value (ops #2 and #3) based on the boolean result of comparing
|
2009-02-17 22:15:04 +00:00
|
|
|
// the lhs and rhs (ops #0 and #1) of a conditional expression with the
|
2005-08-10 20:51:12 +00:00
|
|
|
// condition code in op #4, a CondCodeSDNode.
|
|
|
|
SELECT_CC,
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2008-10-22 09:06:24 +00:00
|
|
|
// SetCC operator - This evaluates to a true value iff the condition is
|
|
|
|
// true. If the result value type is not i1 then the high bits conform
|
2008-11-23 15:47:28 +00:00
|
|
|
// to getBooleanContents. The operands to this are the left and right
|
2008-10-22 09:06:24 +00:00
|
|
|
// 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,
|
|
|
|
|
2009-07-08 00:31:33 +00:00
|
|
|
// RESULT = VSETCC(LHS, RHS, COND) operator - This evaluates to a vector of
|
|
|
|
// integer elements with all bits of the result elements set to true if the
|
|
|
|
// comparison is true or all cleared if the comparison is false. The
|
|
|
|
// operands to this are the left and right operands to compare (LHS/RHS) and
|
|
|
|
// the condition code to compare them with (COND) as a CondCodeSDNode.
|
2008-05-12 19:40:03 +00:00
|
|
|
VSETCC,
|
|
|
|
|
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,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
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,
|
|
|
|
|
2008-01-17 07:00:52 +00:00
|
|
|
/// FP_TO_[US]INT - Convert a floating point value to a signed or unsigned
|
|
|
|
/// integer.
|
2005-01-08 08:08:49 +00:00
|
|
|
FP_TO_SINT,
|
|
|
|
FP_TO_UINT,
|
|
|
|
|
2008-01-17 07:00:52 +00:00
|
|
|
/// X = FP_ROUND(Y, TRUNC) - Rounding 'Y' from a larger floating point type
|
|
|
|
/// down to the precision of the destination VT. TRUNC is a flag, which is
|
|
|
|
/// always an integer that is zero or one. If TRUNC is 0, this is a
|
|
|
|
/// normal rounding, if it is 1, this FP_ROUND is known to not change the
|
|
|
|
/// value of Y.
|
|
|
|
///
|
|
|
|
/// The TRUNC = 1 case is used in cases where we know that the value will
|
|
|
|
/// not be modified by the node, because Y is not using any of the extra
|
|
|
|
/// precision of source type. This allows certain transformations like
|
2009-02-17 22:15:04 +00:00
|
|
|
/// FP_EXTEND(FP_ROUND(X,1)) -> X which are not safe for
|
2008-01-17 07:00:52 +00:00
|
|
|
/// FP_EXTEND(FP_ROUND(X,0)) because the extra bits aren't removed.
|
2005-01-07 07:45:27 +00:00
|
|
|
FP_ROUND,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2008-01-31 00:41:03 +00:00
|
|
|
// FLT_ROUNDS_ - Returns current rounding mode:
|
2007-11-15 23:25:33 +00:00
|
|
|
// -1 Undefined
|
|
|
|
// 0 Round to 0
|
|
|
|
// 1 Round to nearest
|
|
|
|
// 2 Round to +inf
|
|
|
|
// 3 Round to -inf
|
2008-01-31 00:41:03 +00:00
|
|
|
FLT_ROUNDS_,
|
2007-11-15 23:25:33 +00:00
|
|
|
|
2008-01-17 07:00:52 +00:00
|
|
|
/// X = FP_ROUND_INREG(Y, VT) - This operator takes an FP 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 excess precision. The type to round down to is specified by
|
|
|
|
/// the VT operand, a VTSDNode.
|
2005-01-15 06:17:04 +00:00
|
|
|
FP_ROUND_INREG,
|
|
|
|
|
2008-01-17 07:00:52 +00:00
|
|
|
/// X = FP_EXTEND(Y) - Extend a smaller FP type into a larger FP type.
|
2005-01-07 07:45:27 +00:00
|
|
|
FP_EXTEND,
|
|
|
|
|
2009-12-17 05:05:36 +00:00
|
|
|
// BIT_CONVERT - This operator converts between integer, vector and FP
|
|
|
|
// values, as if the value was stored to memory with one type and loaded
|
|
|
|
// from the same address with the other type (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,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2008-11-10 20:54:11 +00:00
|
|
|
// CONVERT_RNDSAT - This operator is used to support various conversions
|
2008-11-11 05:40:06 +00:00
|
|
|
// between various types (float, signed, unsigned and vectors of those
|
|
|
|
// types) with rounding and saturation. NOTE: Avoid using this operator as
|
|
|
|
// most target don't support it and the operator might be removed in the
|
|
|
|
// future. It takes the following arguments:
|
2008-11-10 20:54:11 +00:00
|
|
|
// 0) value
|
|
|
|
// 1) dest type (type to convert to)
|
|
|
|
// 2) src type (type to convert from)
|
|
|
|
// 3) rounding imm
|
|
|
|
// 4) saturation imm
|
|
|
|
// 5) ISD::CvtCode indicating the type of conversion to do
|
|
|
|
CONVERT_RNDSAT,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2008-08-21 17:55:02 +00:00
|
|
|
// FNEG, FABS, FSQRT, FSIN, FCOS, FPOWI, FPOW,
|
2008-09-04 00:47:13 +00:00
|
|
|
// FLOG, FLOG2, FLOG10, FEXP, FEXP2,
|
2008-08-21 18:13:12 +00:00
|
|
|
// FCEIL, FTRUNC, FRINT, FNEARBYINT, FFLOOR - Perform various unary floating
|
2008-08-21 17:55:02 +00:00
|
|
|
// point operations. These are inspired by libm.
|
2007-10-11 23:06:37 +00:00
|
|
|
FNEG, FABS, FSQRT, FSIN, FCOS, FPOWI, FPOW,
|
2008-09-04 00:47:13 +00:00
|
|
|
FLOG, FLOG2, FLOG10, FEXP, FEXP2,
|
2008-08-21 17:55:02 +00:00
|
|
|
FCEIL, FTRUNC, FRINT, FNEARBYINT, FFLOOR,
|
2009-02-17 22:15:04 +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,
|
2008-02-21 06:45:13 +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,
|
2008-11-07 20:13:04 +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. If the type of the condition is not i1, then the
|
2008-11-23 15:47:28 +00:00
|
|
|
// high bits must conform to getBooleanContents.
|
2005-01-07 07:45:27 +00:00
|
|
|
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,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
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.
|
2008-09-16 21:48:12 +00:00
|
|
|
// Operand #1 : a ExternalSymbolSDNode with a pointer to the asm string.
|
2006-01-26 22:23:45 +00:00
|
|
|
// 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,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2009-11-23 23:20:51 +00:00
|
|
|
// EH_LABEL - Represents a label in mid basic block used to track
|
2008-07-01 00:05:16 +00:00
|
|
|
// locations needed for debug and exception handling tables. These nodes
|
|
|
|
// take a chain as input and return a chain.
|
|
|
|
EH_LABEL,
|
2008-02-02 04:07:54 +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,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2006-01-13 02:39:42 +00:00
|
|
|
// STACKRESTORE has two operands, an input chain and a pointer to restore to
|
|
|
|
// it returns an output chain.
|
|
|
|
STACKRESTORE,
|
2009-02-17 22:15:04 +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.
|
2008-03-05 19:14:03 +00:00
|
|
|
// CALLSEQ_START..CALLSEQ_END pairs may not be nested.
|
2005-05-12 23:24:06 +00:00
|
|
|
CALLSEQ_START, // Beginning of a call sequence
|
|
|
|
CALLSEQ_END, // End of a call sequence
|
2009-02-17 22:15:04 +00:00
|
|
|
|
|
|
|
// VAARG - VAARG has three operands: an input chain, a pointer, and a
|
2006-01-25 18:21:52 +00:00
|
|
|
// SRCVALUE. It returns a pair of values: the vaarg value and a new chain.
|
|
|
|
VAARG,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2006-01-25 18:21:52 +00:00
|
|
|
// 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,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2006-01-25 18:21:52 +00:00
|
|
|
// 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
|
|
|
|
2008-02-06 22:27:42 +00:00
|
|
|
// SRCVALUE - This is a node type that holds a Value* that is used to
|
|
|
|
// make reference to a value in the LLVM IR.
|
2005-05-09 20:21:27 +00:00
|
|
|
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
|
2009-02-17 22:15:04 +00:00
|
|
|
// value is the contents of the architecture specific cycle counter like
|
2005-11-11 22:48:54 +00:00
|
|
|
// 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
|
|
|
|
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,
|
|
|
|
|
2008-01-15 07:02:33 +00:00
|
|
|
// TRAP - Trapping instruction
|
|
|
|
TRAP,
|
|
|
|
|
2008-03-08 00:58:38 +00:00
|
|
|
// PREFETCH - This corresponds to a prefetch intrinsic. It takes chains are
|
|
|
|
// their first operand. The other operands are the address to prefetch,
|
|
|
|
// read / write specifier, and locality specifier.
|
|
|
|
PREFETCH,
|
|
|
|
|
2009-02-17 22:15:04 +00:00
|
|
|
// OUTCHAIN = MEMBARRIER(INCHAIN, load-load, load-store, store-load,
|
2008-02-16 01:24:58 +00:00
|
|
|
// store-store, device)
|
2008-02-21 06:45:13 +00:00
|
|
|
// This corresponds to the memory.barrier intrinsic.
|
2008-02-16 01:24:58 +00:00
|
|
|
// it takes an input chain, 4 operands to specify the type of barrier, an
|
|
|
|
// operand specifying if the barrier applies to device and uncached memory
|
|
|
|
// and produces an output chain.
|
|
|
|
MEMBARRIER,
|
|
|
|
|
2008-06-25 08:15:39 +00:00
|
|
|
// Val, OUTCHAIN = ATOMIC_CMP_SWAP(INCHAIN, ptr, cmp, swap)
|
2008-02-21 06:45:13 +00:00
|
|
|
// this corresponds to the atomic.lcs intrinsic.
|
|
|
|
// cmp is compared to *ptr, and if equal, swap is stored in *ptr.
|
|
|
|
// the return is always the original value in *ptr
|
2008-12-23 21:37:04 +00:00
|
|
|
ATOMIC_CMP_SWAP,
|
2008-02-21 06:45:13 +00:00
|
|
|
|
|
|
|
// Val, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amt)
|
|
|
|
// this corresponds to the atomic.swap intrinsic.
|
|
|
|
// amt is stored to *ptr atomically.
|
|
|
|
// the return is always the original value in *ptr
|
2008-12-23 21:37:04 +00:00
|
|
|
ATOMIC_SWAP,
|
2008-02-21 06:45:13 +00:00
|
|
|
|
2009-01-08 22:14:50 +00:00
|
|
|
// Val, OUTCHAIN = ATOMIC_LOAD_[OpName](INCHAIN, ptr, amt)
|
|
|
|
// this corresponds to the atomic.load.[OpName] intrinsic.
|
2008-05-05 19:05:59 +00:00
|
|
|
// op(*ptr, amt) is stored to *ptr atomically.
|
|
|
|
// the return is always the original value in *ptr
|
2008-12-23 21:37:04 +00:00
|
|
|
ATOMIC_LOAD_ADD,
|
|
|
|
ATOMIC_LOAD_SUB,
|
|
|
|
ATOMIC_LOAD_AND,
|
|
|
|
ATOMIC_LOAD_OR,
|
|
|
|
ATOMIC_LOAD_XOR,
|
|
|
|
ATOMIC_LOAD_NAND,
|
|
|
|
ATOMIC_LOAD_MIN,
|
|
|
|
ATOMIC_LOAD_MAX,
|
|
|
|
ATOMIC_LOAD_UMIN,
|
|
|
|
ATOMIC_LOAD_UMAX,
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2009-09-25 20:36:54 +00:00
|
|
|
/// BUILTIN_OP_END - This must be the last enum value in this list.
|
|
|
|
/// The target-specific pre-isel opcode values start here.
|
2006-02-22 16:23:43 +00:00
|
|
|
BUILTIN_OP_END
|
2005-01-07 07:45:27 +00:00
|
|
|
};
|
|
|
|
|
2009-09-25 20:36:54 +00:00
|
|
|
/// FIRST_TARGET_MEMORY_OPCODE - Target-specific pre-isel operations
|
|
|
|
/// which do not reference a specific memory location should be less than
|
|
|
|
/// this value. Those that do must not be less than this value, and can
|
|
|
|
/// be used with SelectionDAG::getMemIntrinsicNode.
|
2010-02-15 06:39:31 +00:00
|
|
|
static const int FIRST_TARGET_MEMORY_OPCODE = BUILTIN_OP_END+80;
|
2009-09-25 20:36:54 +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);
|
2008-01-31 09:59:15 +00:00
|
|
|
|
- When DAG combiner is folding a bit convert into a BUILD_VECTOR, it should check if it's essentially a SCALAR_TO_VECTOR. Avoid turning (v8i16) <10, u, u, u> to <10, 0, u, u, u, u, u, u>. Instead, simply convert it to a SCALAR_TO_VECTOR of the proper type.
- X86 now normalize SCALAR_TO_VECTOR to (BIT_CONVERT (v4i32 SCALAR_TO_VECTOR)). Get rid of X86ISD::S2VEC.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@47290 91177308-0d34-0410-b5e6-96231b3b80d8
2008-02-18 23:04:32 +00:00
|
|
|
/// isScalarToVector - Return true if the specified node is a
|
|
|
|
/// ISD::SCALAR_TO_VECTOR node or a BUILD_VECTOR node where only the low
|
|
|
|
/// element is not an undef.
|
|
|
|
bool isScalarToVector(const SDNode *N);
|
|
|
|
|
2006-10-09 20:55:20 +00:00
|
|
|
//===--------------------------------------------------------------------===//
|
2009-02-17 22:15:04 +00:00
|
|
|
/// MemIndexedMode enum - This enum defines the load / store indexed
|
2006-11-09 17:55:04 +00:00
|
|
|
/// 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
|
2008-03-21 09:14:45 +00:00
|
|
|
/// load); an unindexed store does not produce 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.
|
2009-02-17 22:15:04 +00:00
|
|
|
/// EXTLOAD is used for three things: floating point extending loads,
|
2006-10-09 20:55:20 +00:00
|
|
|
/// 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,
|
2008-10-14 21:26:46 +00:00
|
|
|
LAST_LOADEXT_TYPE
|
2006-10-04 00:56:09 +00:00
|
|
|
};
|
|
|
|
|
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);
|
2008-11-10 20:54:11 +00:00
|
|
|
|
|
|
|
//===--------------------------------------------------------------------===//
|
2009-02-17 22:15:04 +00:00
|
|
|
/// CvtCode enum - This enum defines the various converts CONVERT_RNDSAT
|
2008-11-10 20:54:11 +00:00
|
|
|
/// supports.
|
|
|
|
enum CvtCode {
|
|
|
|
CVT_FF, // Float from Float
|
|
|
|
CVT_FS, // Float from Signed
|
|
|
|
CVT_FU, // Float from Unsigned
|
|
|
|
CVT_SF, // Signed from Float
|
|
|
|
CVT_UF, // Unsigned from Float
|
|
|
|
CVT_SS, // Signed from Signed
|
|
|
|
CVT_SU, // Signed from Unsigned
|
|
|
|
CVT_US, // Unsigned from Signed
|
|
|
|
CVT_UU, // Unsigned from Unsigned
|
|
|
|
CVT_INVALID // Marker - Invalid opcode
|
|
|
|
};
|
2005-01-07 07:45:27 +00:00
|
|
|
} // end llvm::ISD namespace
|
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
2008-07-27 21:46:04 +00:00
|
|
|
/// SDValue - Unlike LLVM values, Selection DAG nodes may return multiple
|
2005-01-07 07:45:27 +00:00
|
|
|
/// 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
|
2008-07-27 21:46:04 +00:00
|
|
|
/// of information is represented with the SDValue value type.
|
2005-01-07 07:45:27 +00:00
|
|
|
///
|
2008-07-27 21:46:04 +00:00
|
|
|
class SDValue {
|
2008-08-28 21:40:38 +00:00
|
|
|
SDNode *Node; // The node defining the value we are using.
|
2005-01-07 07:45:27 +00:00
|
|
|
unsigned ResNo; // Which return value of the node we are using.
|
2008-08-26 22:36:50 +00:00
|
|
|
public:
|
2008-08-28 21:40:38 +00:00
|
|
|
SDValue() : Node(0), ResNo(0) {}
|
|
|
|
SDValue(SDNode *node, unsigned resno) : Node(node), ResNo(resno) {}
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2008-08-26 22:36:50 +00:00
|
|
|
/// get the index which selects a specific result in the SDNode
|
|
|
|
unsigned getResNo() const { return ResNo; }
|
|
|
|
|
2008-08-28 21:40:38 +00:00
|
|
|
/// get the SDNode which holds the desired result
|
|
|
|
SDNode *getNode() const { return Node; }
|
|
|
|
|
|
|
|
/// set the SDNode
|
|
|
|
void setNode(SDNode *N) { Node = N; }
|
|
|
|
|
2010-02-15 07:11:34 +00:00
|
|
|
inline SDNode *operator->() const { return Node; }
|
|
|
|
|
2008-07-27 21:46:04 +00:00
|
|
|
bool operator==(const SDValue &O) const {
|
2008-08-28 21:40:38 +00:00
|
|
|
return Node == O.Node && ResNo == O.ResNo;
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
2008-07-27 21:46:04 +00:00
|
|
|
bool operator!=(const SDValue &O) const {
|
2005-01-07 07:45:27 +00:00
|
|
|
return !operator==(O);
|
|
|
|
}
|
2008-07-27 21:46:04 +00:00
|
|
|
bool operator<(const SDValue &O) const {
|
2008-08-28 21:40:38 +00:00
|
|
|
return Node < O.Node || (Node == O.Node && ResNo < O.ResNo);
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
|
2008-07-27 21:46:04 +00:00
|
|
|
SDValue getValue(unsigned R) const {
|
2008-08-28 21:40:38 +00:00
|
|
|
return SDValue(Node, R);
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
|
2008-03-04 00:41:45 +00:00
|
|
|
// isOperandOf - Return true if this node is an operand of N.
|
|
|
|
bool isOperandOf(SDNode *N) const;
|
2006-03-03 06:42:32 +00:00
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
/// getValueType - Return the ValueType of the referenced return value.
|
|
|
|
///
|
2009-08-10 22:56:29 +00:00
|
|
|
inline EVT getValueType() const;
|
2005-04-21 20:39:54 +00:00
|
|
|
|
2008-06-06 12:08:01 +00:00
|
|
|
/// getValueSizeInBits - Returns the size of the value in bits.
|
2008-02-25 19:08:02 +00:00
|
|
|
///
|
|
|
|
unsigned getValueSizeInBits() const {
|
2008-06-06 12:08:01 +00:00
|
|
|
return getValueType().getSizeInBits();
|
2008-02-25 19:08:02 +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;
|
2008-07-27 21:46:04 +00:00
|
|
|
inline const SDValue &getOperand(unsigned i) const;
|
2006-10-04 00:56:09 +00:00
|
|
|
inline uint64_t getConstantOperandVal(unsigned i) const;
|
2009-09-25 20:36:54 +00:00
|
|
|
inline bool isTargetMemoryOpcode() const;
|
2005-08-17 23:44:54 +00:00
|
|
|
inline bool isTargetOpcode() const;
|
2008-07-17 19:10:17 +00:00
|
|
|
inline bool isMachineOpcode() const;
|
|
|
|
inline unsigned getMachineOpcode() const;
|
2009-01-27 23:19:41 +00:00
|
|
|
inline const DebugLoc getDebugLoc() const;
|
2005-01-13 22:58:50 +00:00
|
|
|
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2008-01-16 05:49:24 +00:00
|
|
|
/// reachesChainWithoutSideEffects - Return true if this operand (which must
|
2009-02-17 22:15:04 +00:00
|
|
|
/// be a chain) reaches the specified operand without crossing any
|
2008-01-16 05:49:24 +00:00
|
|
|
/// side-effecting instructions. In practice, this looks through token
|
|
|
|
/// factors and non-volatile loads. In order to remain efficient, this only
|
|
|
|
/// looks a couple of nodes in, it does not do an exhaustive search.
|
2009-02-17 22:15:04 +00:00
|
|
|
bool reachesChainWithoutSideEffects(SDValue Dest,
|
2008-04-07 10:06:32 +00:00
|
|
|
unsigned Depth = 2) const;
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2008-07-27 17:44:52 +00:00
|
|
|
/// use_empty - Return true if there are no nodes using value ResNo
|
2008-08-28 21:40:38 +00:00
|
|
|
/// of Node.
|
2008-07-27 17:44:52 +00:00
|
|
|
///
|
2007-09-17 17:44:31 +00:00
|
|
|
inline bool use_empty() const;
|
2008-07-27 17:44:52 +00:00
|
|
|
|
2008-08-26 17:44:40 +00:00
|
|
|
/// hasOneUse - Return true if there is exactly one node using value
|
2008-08-28 21:40:38 +00:00
|
|
|
/// ResNo of Node.
|
2008-07-27 17:44:52 +00:00
|
|
|
///
|
|
|
|
inline bool hasOneUse() const;
|
2005-01-07 07:45:27 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2008-07-27 21:46:04 +00:00
|
|
|
template<> struct DenseMapInfo<SDValue> {
|
2009-02-17 22:15:04 +00:00
|
|
|
static inline SDValue getEmptyKey() {
|
|
|
|
return SDValue((SDNode*)-1, -1U);
|
2008-04-07 10:06:32 +00:00
|
|
|
}
|
2009-02-17 22:15:04 +00:00
|
|
|
static inline SDValue getTombstoneKey() {
|
2008-07-27 21:46:04 +00:00
|
|
|
return SDValue((SDNode*)-1, 0);
|
2008-04-07 10:06:32 +00:00
|
|
|
}
|
2008-07-27 21:46:04 +00:00
|
|
|
static unsigned getHashValue(const SDValue &Val) {
|
2008-08-28 21:40:38 +00:00
|
|
|
return ((unsigned)((uintptr_t)Val.getNode() >> 4) ^
|
|
|
|
(unsigned)((uintptr_t)Val.getNode() >> 9)) + Val.getResNo();
|
2007-07-10 06:59:55 +00:00
|
|
|
}
|
2008-07-27 21:46:04 +00:00
|
|
|
static bool isEqual(const SDValue &LHS, const SDValue &RHS) {
|
2007-09-17 18:34:04 +00:00
|
|
|
return LHS == RHS;
|
|
|
|
}
|
2007-07-10 06:59:55 +00:00
|
|
|
};
|
2009-12-15 07:26:43 +00:00
|
|
|
template <> struct isPodLike<SDValue> { static const bool value = true; };
|
|
|
|
|
2007-07-10 06:59:55 +00:00
|
|
|
|
2008-04-07 10:06:32 +00:00
|
|
|
/// simplify_type specializations - Allow casting operators to work directly on
|
2008-07-27 21:46:04 +00:00
|
|
|
/// SDValues as if they were SDNode*'s.
|
|
|
|
template<> struct simplify_type<SDValue> {
|
2008-04-07 10:06:32 +00:00
|
|
|
typedef SDNode* SimpleType;
|
2008-07-27 21:46:04 +00:00
|
|
|
static SimpleType getSimplifiedValue(const SDValue &Val) {
|
2008-08-28 21:40:38 +00:00
|
|
|
return static_cast<SimpleType>(Val.getNode());
|
2008-04-07 10:06:32 +00:00
|
|
|
}
|
|
|
|
};
|
2008-07-27 21:46:04 +00:00
|
|
|
template<> struct simplify_type<const SDValue> {
|
2008-04-07 10:06:32 +00:00
|
|
|
typedef SDNode* SimpleType;
|
2008-07-27 21:46:04 +00:00
|
|
|
static SimpleType getSimplifiedValue(const SDValue &Val) {
|
2008-08-28 21:40:38 +00:00
|
|
|
return static_cast<SimpleType>(Val.getNode());
|
2008-04-07 10:06:32 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2009-01-26 04:35:06 +00:00
|
|
|
/// SDUse - Represents a use of a SDNode. This class holds an SDValue,
|
|
|
|
/// which records the SDNode being used and the result number, a
|
|
|
|
/// pointer to the SDNode using the value, and Next and Prev pointers,
|
|
|
|
/// which link together all the uses of an SDNode.
|
|
|
|
///
|
2008-04-16 16:15:27 +00:00
|
|
|
class SDUse {
|
2009-01-26 04:35:06 +00:00
|
|
|
/// Val - The value being used.
|
|
|
|
SDValue Val;
|
|
|
|
/// User - The user of this value.
|
|
|
|
SDNode *User;
|
2009-02-17 22:15:04 +00:00
|
|
|
/// Prev, Next - Pointers to the uses list of the SDNode referred by
|
2008-04-07 10:06:32 +00:00
|
|
|
/// this operand.
|
2008-04-16 16:15:27 +00:00
|
|
|
SDUse **Prev, *Next;
|
2008-04-07 10:06:32 +00:00
|
|
|
|
2009-01-26 04:35:06 +00:00
|
|
|
SDUse(const SDUse &U); // Do not implement
|
|
|
|
void operator=(const SDUse &U); // Do not implement
|
2008-04-07 10:06:32 +00:00
|
|
|
|
2009-01-26 04:35:06 +00:00
|
|
|
public:
|
|
|
|
SDUse() : Val(), User(NULL), Prev(NULL), Next(NULL) {}
|
2008-04-07 10:06:32 +00:00
|
|
|
|
2009-01-26 04:35:06 +00:00
|
|
|
/// Normally SDUse will just implicitly convert to an SDValue that it holds.
|
|
|
|
operator const SDValue&() const { return Val; }
|
2008-04-07 10:06:32 +00:00
|
|
|
|
2009-01-26 04:35:06 +00:00
|
|
|
/// If implicit conversion to SDValue doesn't work, the get() method returns
|
|
|
|
/// the SDValue.
|
|
|
|
const SDValue &get() const { return Val; }
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2009-01-26 04:35:06 +00:00
|
|
|
/// getUser - This returns the SDNode that contains this Use.
|
2008-04-17 09:29:48 +00:00
|
|
|
SDNode *getUser() { return User; }
|
2008-04-16 16:15:27 +00:00
|
|
|
|
2009-01-26 04:35:06 +00:00
|
|
|
/// getNext - Get the next SDUse in the use list.
|
|
|
|
SDUse *getNext() const { return Next; }
|
2008-04-16 16:15:27 +00:00
|
|
|
|
2009-01-26 04:35:06 +00:00
|
|
|
/// getNode - Convenience function for get().getNode().
|
|
|
|
SDNode *getNode() const { return Val.getNode(); }
|
|
|
|
/// getResNo - Convenience function for get().getResNo().
|
|
|
|
unsigned getResNo() const { return Val.getResNo(); }
|
|
|
|
/// getValueType - Convenience function for get().getValueType().
|
2009-08-10 22:56:29 +00:00
|
|
|
EVT getValueType() const { return Val.getValueType(); }
|
2008-04-16 16:15:27 +00:00
|
|
|
|
2009-01-26 04:35:06 +00:00
|
|
|
/// operator== - Convenience function for get().operator==
|
|
|
|
bool operator==(const SDValue &V) const {
|
|
|
|
return Val == V;
|
2008-04-16 16:15:27 +00:00
|
|
|
}
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2009-01-26 04:35:06 +00:00
|
|
|
/// operator!= - Convenience function for get().operator!=
|
|
|
|
bool operator!=(const SDValue &V) const {
|
|
|
|
return Val != V;
|
2008-04-16 16:15:27 +00:00
|
|
|
}
|
|
|
|
|
2009-01-26 04:35:06 +00:00
|
|
|
/// operator< - Convenience function for get().operator<
|
|
|
|
bool operator<(const SDValue &V) const {
|
|
|
|
return Val < V;
|
2008-04-16 16:15:27 +00:00
|
|
|
}
|
|
|
|
|
2009-01-26 04:35:06 +00:00
|
|
|
private:
|
|
|
|
friend class SelectionDAG;
|
|
|
|
friend class SDNode;
|
|
|
|
|
|
|
|
void setUser(SDNode *p) { User = p; }
|
|
|
|
|
|
|
|
/// set - Remove this use from its existing use list, assign it the
|
|
|
|
/// given value, and add it to the new value's node's use list.
|
|
|
|
inline void set(const SDValue &V);
|
|
|
|
/// setInitial - like set, but only supports initializing a newly-allocated
|
|
|
|
/// SDUse with a non-null value.
|
|
|
|
inline void setInitial(const SDValue &V);
|
|
|
|
/// setNode - like set, but only sets the Node portion of the value,
|
|
|
|
/// leaving the ResNo portion unmodified.
|
|
|
|
inline void setNode(SDNode *N);
|
|
|
|
|
2008-04-16 16:15:27 +00:00
|
|
|
void addToList(SDUse **List) {
|
2008-04-07 10:06:32 +00:00
|
|
|
Next = *List;
|
|
|
|
if (Next) Next->Prev = &Next;
|
|
|
|
Prev = List;
|
|
|
|
*List = this;
|
|
|
|
}
|
|
|
|
|
|
|
|
void removeFromList() {
|
|
|
|
*Prev = Next;
|
|
|
|
if (Next) Next->Prev = Prev;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
/// simplify_type specializations - Allow casting operators to work directly on
|
2008-07-27 21:46:04 +00:00
|
|
|
/// SDValues as if they were SDNode*'s.
|
2008-04-16 16:15:27 +00:00
|
|
|
template<> struct simplify_type<SDUse> {
|
2005-01-07 07:45:27 +00:00
|
|
|
typedef SDNode* SimpleType;
|
2008-04-16 16:15:27 +00:00
|
|
|
static SimpleType getSimplifiedValue(const SDUse &Val) {
|
2009-01-26 04:35:06 +00:00
|
|
|
return static_cast<SimpleType>(Val.getNode());
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
};
|
2008-04-16 16:15:27 +00:00
|
|
|
template<> struct simplify_type<const SDUse> {
|
2005-01-07 07:45:27 +00:00
|
|
|
typedef SDNode* SimpleType;
|
2008-04-16 16:15:27 +00:00
|
|
|
static SimpleType getSimplifiedValue(const SDUse &Val) {
|
2009-01-26 04:35:06 +00:00
|
|
|
return static_cast<SimpleType>(Val.getNode());
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/// SDNode - Represents one node in the SelectionDAG.
|
|
|
|
///
|
2008-07-28 21:51:04 +00:00
|
|
|
class SDNode : public FoldingSetNode, public ilist_node<SDNode> {
|
2008-04-07 10:06:32 +00:00
|
|
|
private:
|
2005-01-21 21:39:38 +00:00
|
|
|
/// NodeType - The operation that this node performs.
|
|
|
|
///
|
2009-09-25 20:36:54 +00:00
|
|
|
int16_t NodeType;
|
2009-02-17 22:15:04 +00:00
|
|
|
|
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.
|
2009-09-25 20:36:54 +00:00
|
|
|
uint16_t OperandsNeedDelete : 1;
|
2005-01-21 21:39:38 +00:00
|
|
|
|
2008-07-10 21:44:59 +00:00
|
|
|
protected:
|
|
|
|
/// SubclassData - This member is defined by this class, but is not used for
|
|
|
|
/// anything. Subclasses can use it to hold whatever state they find useful.
|
|
|
|
/// This field is initialized to zero by the ctor.
|
2009-09-25 20:36:54 +00:00
|
|
|
uint16_t SubclassData : 15;
|
2008-07-10 21:44:59 +00:00
|
|
|
|
|
|
|
private:
|
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
|
|
|
///
|
2008-04-16 16:15:27 +00:00
|
|
|
SDUse *OperandList;
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2005-11-08 22:06:23 +00:00
|
|
|
/// ValueList - The types of the values this node defines. SDNode's may
|
|
|
|
/// define multiple values simultaneously.
|
2009-08-10 22:56:29 +00:00
|
|
|
const EVT *ValueList;
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2009-01-26 04:35:06 +00:00
|
|
|
/// UseList - List of uses for this SDNode.
|
|
|
|
SDUse *UseList;
|
2008-04-07 10:06:32 +00:00
|
|
|
|
2009-02-02 18:04:24 +00:00
|
|
|
/// NumOperands/NumValues - The number of entries in the Operand/Value list.
|
|
|
|
unsigned short NumOperands, NumValues;
|
|
|
|
|
|
|
|
/// debugLoc - source line information.
|
|
|
|
DebugLoc debugLoc;
|
|
|
|
|
2009-01-26 04:35:06 +00:00
|
|
|
/// getValueTypeList - Return a pointer to the specified value type.
|
2009-08-10 22:56:29 +00:00
|
|
|
static const EVT *getValueTypeList(EVT VT);
|
2009-01-26 04:35:06 +00:00
|
|
|
|
|
|
|
friend class SelectionDAG;
|
|
|
|
friend struct ilist_traits<SDNode>;
|
2008-04-07 10:06:32 +00:00
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
public:
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
// Accessors
|
|
|
|
//
|
2008-07-17 19:10:17 +00:00
|
|
|
|
|
|
|
/// getOpcode - Return the SelectionDAG opcode value for this node. For
|
|
|
|
/// pre-isel nodes (those for which isMachineOpcode returns false), these
|
|
|
|
/// are the opcode values in the ISD and <target>ISD namespaces. For
|
|
|
|
/// post-isel opcodes, see getMachineOpcode.
|
|
|
|
unsigned getOpcode() const { return (unsigned short)NodeType; }
|
|
|
|
|
|
|
|
/// isTargetOpcode - Test if this node has a target-specific opcode (in the
|
2009-03-03 02:55:14 +00:00
|
|
|
/// \<target\>ISD namespace).
|
2005-08-17 23:44:54 +00:00
|
|
|
bool isTargetOpcode() const { return NodeType >= ISD::BUILTIN_OP_END; }
|
2008-07-17 19:10:17 +00:00
|
|
|
|
2009-09-25 20:36:54 +00:00
|
|
|
/// isTargetMemoryOpcode - Test if this node has a target-specific
|
|
|
|
/// memory-referencing opcode (in the \<target\>ISD namespace and
|
|
|
|
/// greater than FIRST_TARGET_MEMORY_OPCODE).
|
|
|
|
bool isTargetMemoryOpcode() const {
|
|
|
|
return NodeType >= ISD::FIRST_TARGET_MEMORY_OPCODE;
|
|
|
|
}
|
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
/// isMachineOpcode - Test if this node has a post-isel opcode, directly
|
|
|
|
/// corresponding to a MachineInstr opcode.
|
|
|
|
bool isMachineOpcode() const { return NodeType < 0; }
|
|
|
|
|
|
|
|
/// getMachineOpcode - This may only be called if isMachineOpcode returns
|
|
|
|
/// true. It returns the MachineInstr opcode value that the node's opcode
|
|
|
|
/// corresponds to.
|
|
|
|
unsigned getMachineOpcode() const {
|
2008-08-05 14:42:28 +00:00
|
|
|
assert(isMachineOpcode() && "Not a MachineInstr opcode!");
|
2008-07-17 19:10:17 +00:00
|
|
|
return ~NodeType;
|
2005-08-17 23:44:54 +00:00
|
|
|
}
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2008-08-06 15:18:10 +00:00
|
|
|
/// use_empty - Return true if there are no uses of this node.
|
2008-07-27 17:44:52 +00:00
|
|
|
///
|
2009-01-26 04:35:06 +00:00
|
|
|
bool use_empty() const { return UseList == NULL; }
|
2008-07-27 17:44:52 +00:00
|
|
|
|
2008-08-06 15:18:10 +00:00
|
|
|
/// hasOneUse - Return true if there is exactly one use of this node.
|
2008-07-27 17:44:52 +00:00
|
|
|
///
|
2008-07-09 23:03:14 +00:00
|
|
|
bool hasOneUse() const {
|
2009-12-03 00:50:42 +00:00
|
|
|
return !use_empty() && llvm::next(use_begin()) == use_end();
|
2008-07-09 23:03:14 +00:00
|
|
|
}
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2008-08-06 15:18:10 +00:00
|
|
|
/// use_size - Return the number of uses of this node. This method takes
|
2008-07-27 17:44:52 +00:00
|
|
|
/// time proportional to the number of uses.
|
|
|
|
///
|
|
|
|
size_t use_size() const { return std::distance(use_begin(), use_end()); }
|
|
|
|
|
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
|
|
|
|
2007-12-12 23:15:59 +00:00
|
|
|
/// setNodeId - Set unique node id.
|
|
|
|
void setNodeId(int Id) { NodeId = Id; }
|
|
|
|
|
2009-01-27 21:41:04 +00:00
|
|
|
/// getDebugLoc - Return the source location info.
|
2009-01-27 23:19:41 +00:00
|
|
|
const DebugLoc getDebugLoc() const { return debugLoc; }
|
2009-01-27 21:41:04 +00:00
|
|
|
|
2009-01-27 23:32:10 +00:00
|
|
|
/// setDebugLoc - Set source location info. Try to avoid this, putting
|
|
|
|
/// it in the constructor is preferable.
|
2009-01-27 23:19:41 +00:00
|
|
|
void setDebugLoc(const DebugLoc dl) { debugLoc = dl; }
|
2009-01-27 21:41:04 +00:00
|
|
|
|
2008-04-16 16:15:27 +00:00
|
|
|
/// use_iterator - This class provides iterator support for SDUse
|
2009-02-17 22:15:04 +00:00
|
|
|
/// operands that use a specific SDNode.
|
2008-04-07 10:06:32 +00:00
|
|
|
class use_iterator
|
2009-08-27 06:41:46 +00:00
|
|
|
: public std::iterator<std::forward_iterator_tag, SDUse, ptrdiff_t> {
|
2008-04-16 16:15:27 +00:00
|
|
|
SDUse *Op;
|
|
|
|
explicit use_iterator(SDUse *op) : Op(op) {
|
2008-04-07 10:06:32 +00:00
|
|
|
}
|
|
|
|
friend class SDNode;
|
|
|
|
public:
|
2009-08-27 23:44:33 +00:00
|
|
|
typedef std::iterator<std::forward_iterator_tag,
|
|
|
|
SDUse, ptrdiff_t>::reference reference;
|
|
|
|
typedef std::iterator<std::forward_iterator_tag,
|
|
|
|
SDUse, ptrdiff_t>::pointer pointer;
|
2008-04-07 10:06:32 +00:00
|
|
|
|
|
|
|
use_iterator(const use_iterator &I) : Op(I.Op) {}
|
|
|
|
use_iterator() : Op(0) {}
|
|
|
|
|
|
|
|
bool operator==(const use_iterator &x) const {
|
|
|
|
return Op == x.Op;
|
|
|
|
}
|
|
|
|
bool operator!=(const use_iterator &x) const {
|
|
|
|
return !operator==(x);
|
|
|
|
}
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2008-04-07 10:06:32 +00:00
|
|
|
/// atEnd - return true if this iterator is at the end of uses list.
|
|
|
|
bool atEnd() const { return Op == 0; }
|
|
|
|
|
|
|
|
// Iterator traversal: forward iteration only.
|
|
|
|
use_iterator &operator++() { // Preincrement
|
|
|
|
assert(Op && "Cannot increment end iterator!");
|
|
|
|
Op = Op->getNext();
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
use_iterator operator++(int) { // Postincrement
|
|
|
|
use_iterator tmp = *this; ++*this; return tmp;
|
|
|
|
}
|
|
|
|
|
2008-07-27 20:43:25 +00:00
|
|
|
/// Retrieve a pointer to the current user node.
|
|
|
|
SDNode *operator*() const {
|
2008-04-07 10:06:32 +00:00
|
|
|
assert(Op && "Cannot dereference end iterator!");
|
2008-07-27 20:43:25 +00:00
|
|
|
return Op->getUser();
|
2008-04-07 10:06:32 +00:00
|
|
|
}
|
|
|
|
|
2008-07-27 20:43:25 +00:00
|
|
|
SDNode *operator->() const { return operator*(); }
|
|
|
|
|
|
|
|
SDUse &getUse() const { return *Op; }
|
2008-04-07 10:06:32 +00:00
|
|
|
|
2008-12-08 14:10:36 +00:00
|
|
|
/// getOperandNo - Retrieve the operand # of this use in its user.
|
2008-07-27 20:43:25 +00:00
|
|
|
///
|
|
|
|
unsigned getOperandNo() const {
|
2008-04-07 10:06:32 +00:00
|
|
|
assert(Op && "Cannot dereference end iterator!");
|
2008-07-27 20:43:25 +00:00
|
|
|
return (unsigned)(Op - Op->getUser()->OperandList);
|
2008-04-07 10:06:32 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/// use_begin/use_end - Provide iteration support to walk over all uses
|
|
|
|
/// of an SDNode.
|
|
|
|
|
|
|
|
use_iterator use_begin() const {
|
2009-01-26 04:35:06 +00:00
|
|
|
return use_iterator(UseList);
|
2008-04-07 10:06:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static use_iterator use_end() { return use_iterator(0); }
|
|
|
|
|
2005-01-17 02:24:59 +00:00
|
|
|
|
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;
|
|
|
|
|
2008-07-27 18:06:42 +00:00
|
|
|
/// isOnlyUserOf - Return true if this node is the only use of N.
|
2006-11-03 07:31:32 +00:00
|
|
|
///
|
2008-07-27 18:06:42 +00:00
|
|
|
bool isOnlyUserOf(SDNode *N) const;
|
2005-01-12 18:37:33 +00:00
|
|
|
|
2008-03-04 00:41:45 +00:00
|
|
|
/// isOperandOf - Return true if this node is an operand of N.
|
2006-11-03 07:31:32 +00:00
|
|
|
///
|
2008-03-04 00:41:45 +00:00
|
|
|
bool isOperandOf(SDNode *N) const;
|
2006-03-03 06:24:54 +00:00
|
|
|
|
2008-03-04 00:41:45 +00:00
|
|
|
/// isPredecessorOf - 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.
|
2006-11-03 07:31:32 +00:00
|
|
|
/// NOTE: this is an expensive method. Use it carefully.
|
2008-03-04 00:41:45 +00:00
|
|
|
bool isPredecessorOf(SDNode *N) const;
|
2006-11-03 03:02:18 +00:00
|
|
|
|
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
|
|
|
|
2009-02-17 22:15:04 +00:00
|
|
|
/// getConstantOperandVal - Helper method returns the integer value of a
|
2006-10-04 00:56:09 +00:00
|
|
|
/// ConstantSDNode operand.
|
|
|
|
uint64_t getConstantOperandVal(unsigned Num) const;
|
|
|
|
|
2008-07-27 21:46:04 +00:00
|
|
|
const SDValue &getOperand(unsigned Num) const {
|
2005-11-08 22:06:23 +00:00
|
|
|
assert(Num < NumOperands && "Invalid child # of SDNode!");
|
2009-01-26 04:35:06 +00:00
|
|
|
return OperandList[Num];
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
2006-10-04 00:56:09 +00:00
|
|
|
|
2008-04-16 16:15:27 +00:00
|
|
|
typedef SDUse* op_iterator;
|
2005-11-08 22:06:23 +00:00
|
|
|
op_iterator op_begin() const { return OperandList; }
|
|
|
|
op_iterator op_end() const { return OperandList+NumOperands; }
|
2005-05-14 06:19:11 +00:00
|
|
|
|
2006-08-15 19:11:05 +00:00
|
|
|
SDVTList getVTList() const {
|
|
|
|
SDVTList X = { ValueList, NumValues };
|
|
|
|
return X;
|
2009-12-19 03:21:36 +00:00
|
|
|
}
|
2008-11-13 23:24:17 +00:00
|
|
|
|
|
|
|
/// getFlaggedNode - If this node has a flag operand, return the node
|
|
|
|
/// to which the flag operand points. Otherwise return NULL.
|
|
|
|
SDNode *getFlaggedNode() const {
|
|
|
|
if (getNumOperands() != 0 &&
|
2009-08-11 20:47:22 +00:00
|
|
|
getOperand(getNumOperands()-1).getValueType().getSimpleVT() == MVT::Flag)
|
2008-11-13 23:24:17 +00:00
|
|
|
return getOperand(getNumOperands()-1).getNode();
|
|
|
|
return 0;
|
|
|
|
}
|
2009-01-15 22:18:12 +00:00
|
|
|
|
|
|
|
// If this is a pseudo op, like copyfromreg, look to see if there is a
|
|
|
|
// real target node flagged to it. If so, return the target node.
|
|
|
|
const SDNode *getFlaggedMachineNode() const {
|
|
|
|
const SDNode *FoundNode = this;
|
|
|
|
|
|
|
|
// Climb up flag edges until a machine-opcode node is found, or the
|
|
|
|
// end of the chain is reached.
|
|
|
|
while (!FoundNode->isMachineOpcode()) {
|
|
|
|
const SDNode *N = FoundNode->getFlaggedNode();
|
|
|
|
if (!N) break;
|
|
|
|
FoundNode = N;
|
|
|
|
}
|
|
|
|
|
|
|
|
return FoundNode;
|
|
|
|
}
|
|
|
|
|
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.
|
|
|
|
///
|
2009-08-10 22:56:29 +00:00
|
|
|
EVT 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
|
|
|
|
2009-08-11 20:47:22 +00:00
|
|
|
/// getValueSizeInBits - Returns MVT::getSizeInBits(getValueType(ResNo)).
|
2008-02-25 19:08:02 +00:00
|
|
|
///
|
|
|
|
unsigned getValueSizeInBits(unsigned ResNo) const {
|
2008-06-06 12:08:01 +00:00
|
|
|
return getValueType(ResNo).getSizeInBits();
|
2008-02-25 19:08:02 +00:00
|
|
|
}
|
|
|
|
|
2009-08-10 22:56:29 +00:00
|
|
|
typedef const EVT* value_iterator;
|
2005-11-08 22:06:23 +00:00
|
|
|
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);
|
2009-02-04 16:46:19 +00:00
|
|
|
void print_types(raw_ostream &OS, const SelectionDAG *G) const;
|
|
|
|
void print_details(raw_ostream &OS, const SelectionDAG *G) const;
|
2008-08-23 22:23:09 +00:00
|
|
|
void print(raw_ostream &OS, const SelectionDAG *G = 0) const;
|
2009-02-04 16:46:19 +00:00
|
|
|
void printr(raw_ostream &OS, const SelectionDAG *G = 0) const;
|
2010-01-19 20:37:34 +00:00
|
|
|
|
|
|
|
/// printrFull - Print a SelectionDAG node and all children down to
|
|
|
|
/// the leaves. The given SelectionDAG allows target-specific nodes
|
|
|
|
/// to be printed in human-readable form. Unlike printr, this will
|
|
|
|
/// print the whole DAG, including children that appear multiple
|
|
|
|
/// times.
|
2010-01-15 19:43:23 +00:00
|
|
|
///
|
2010-01-19 20:37:34 +00:00
|
|
|
void printrFull(raw_ostream &O, const SelectionDAG *G = 0) const;
|
|
|
|
|
|
|
|
/// printrWithDepth - Print a SelectionDAG node and children up to
|
|
|
|
/// depth "depth." The given SelectionDAG allows target-specific
|
|
|
|
/// nodes to be printed in human-readable form. Unlike printr, this
|
|
|
|
/// will print children that appear multiple times wherever they are
|
|
|
|
/// used.
|
2010-01-15 19:43:23 +00:00
|
|
|
///
|
2010-01-19 20:37:34 +00:00
|
|
|
void printrWithDepth(raw_ostream &O, const SelectionDAG *G = 0,
|
|
|
|
unsigned depth = 100) const;
|
|
|
|
|
|
|
|
|
2010-01-15 22:22:58 +00:00
|
|
|
/// dump - Dump this node, for debugging.
|
2005-01-07 07:45:27 +00:00
|
|
|
void dump() const;
|
2010-01-19 20:37:34 +00:00
|
|
|
|
2010-01-15 22:22:58 +00:00
|
|
|
/// dumpr - Dump (recursively) this node and its use-def subgraph.
|
2009-02-04 16:46:19 +00:00
|
|
|
void dumpr() const;
|
2010-01-19 20:37:34 +00:00
|
|
|
|
2010-01-15 22:22:58 +00:00
|
|
|
/// dump - Dump this node, for debugging.
|
|
|
|
/// The given SelectionDAG allows target-specific nodes to be printed
|
|
|
|
/// in human-readable form.
|
2005-08-16 18:32:18 +00:00
|
|
|
void dump(const SelectionDAG *G) const;
|
2010-01-19 20:37:34 +00:00
|
|
|
|
2010-01-15 22:22:58 +00:00
|
|
|
/// dumpr - Dump (recursively) this node and its use-def subgraph.
|
|
|
|
/// The given SelectionDAG allows target-specific nodes to be printed
|
|
|
|
/// in human-readable form.
|
2009-09-25 00:34:34 +00:00
|
|
|
void dumpr(const SelectionDAG *G) const;
|
2010-01-19 20:37:34 +00:00
|
|
|
|
|
|
|
/// dumprFull - printrFull to dbgs(). The given SelectionDAG allows
|
|
|
|
/// target-specific nodes to be printed in human-readable form.
|
|
|
|
/// Unlike dumpr, this will print the whole DAG, including children
|
|
|
|
/// that appear multiple times.
|
2010-01-15 19:43:23 +00:00
|
|
|
///
|
2010-01-19 20:37:34 +00:00
|
|
|
void dumprFull(const SelectionDAG *G = 0) const;
|
|
|
|
|
|
|
|
/// dumprWithDepth - printrWithDepth to dbgs(). The given
|
|
|
|
/// SelectionDAG allows target-specific nodes to be printed in
|
|
|
|
/// human-readable form. Unlike dumpr, this will print children
|
|
|
|
/// that appear multiple times wherever they are used.
|
2010-01-15 19:43:23 +00:00
|
|
|
///
|
2010-01-19 20:37:34 +00:00
|
|
|
void dumprWithDepth(const SelectionDAG *G = 0, unsigned depth = 100) 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.
|
|
|
|
///
|
2008-08-20 15:58:01 +00:00
|
|
|
void Profile(FoldingSetNodeID &ID) const;
|
2006-10-27 23:46:08 +00:00
|
|
|
|
2009-01-26 04:35:06 +00:00
|
|
|
/// addUse - This method should only be used by the SDUse class.
|
2005-11-08 23:30:11 +00:00
|
|
|
///
|
2009-01-26 04:35:06 +00:00
|
|
|
void addUse(SDUse &U) { U.addToList(&UseList); }
|
|
|
|
|
|
|
|
protected:
|
2009-08-10 22:56:29 +00:00
|
|
|
static SDVTList getSDVTList(EVT VT) {
|
2007-02-04 07:28:00 +00:00
|
|
|
SDVTList Ret = { getValueTypeList(VT), 1 };
|
|
|
|
return Ret;
|
2005-04-27 20:10:01 +00:00
|
|
|
}
|
2007-02-04 07:28:00 +00:00
|
|
|
|
2009-02-17 22:15:04 +00:00
|
|
|
SDNode(unsigned Opc, const DebugLoc dl, SDVTList VTs, const SDValue *Ops,
|
2009-01-27 23:19:41 +00:00
|
|
|
unsigned NumOps)
|
2009-01-27 21:41:04 +00:00
|
|
|
: NodeType(Opc), OperandsNeedDelete(true), SubclassData(0),
|
2009-02-02 18:04:24 +00:00
|
|
|
NodeId(-1),
|
2009-01-27 21:41:04 +00:00
|
|
|
OperandList(NumOps ? new SDUse[NumOps] : 0),
|
2009-02-02 18:04:24 +00:00
|
|
|
ValueList(VTs.VTs), UseList(NULL),
|
2009-01-27 21:41:04 +00:00
|
|
|
NumOperands(NumOps), NumValues(VTs.NumVTs),
|
2009-02-02 18:04:24 +00:00
|
|
|
debugLoc(dl) {
|
2009-01-27 21:41:04 +00:00
|
|
|
for (unsigned i = 0; i != NumOps; ++i) {
|
|
|
|
OperandList[i].setUser(this);
|
|
|
|
OperandList[i].setInitial(Ops[i]);
|
|
|
|
}
|
2010-01-20 20:13:31 +00:00
|
|
|
checkForCycles(this);
|
2009-01-27 21:41:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// This constructor adds no operands itself; operands can be
|
|
|
|
/// set later with InitOperands.
|
2009-01-27 23:19:41 +00:00
|
|
|
SDNode(unsigned Opc, const DebugLoc dl, SDVTList VTs)
|
2009-01-27 21:41:04 +00:00
|
|
|
: NodeType(Opc), OperandsNeedDelete(false), SubclassData(0),
|
2009-02-02 18:04:24 +00:00
|
|
|
NodeId(-1), OperandList(0), ValueList(VTs.VTs), UseList(NULL),
|
|
|
|
NumOperands(0), NumValues(VTs.NumVTs),
|
|
|
|
debugLoc(dl) {}
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2009-01-26 04:35:06 +00:00
|
|
|
/// InitOperands - Initialize the operands list of this with 1 operand.
|
|
|
|
void InitOperands(SDUse *Ops, const SDValue &Op0) {
|
|
|
|
Ops[0].setUser(this);
|
|
|
|
Ops[0].setInitial(Op0);
|
|
|
|
NumOperands = 1;
|
2007-02-04 08:13:53 +00:00
|
|
|
OperandList = Ops;
|
2010-01-20 20:13:31 +00:00
|
|
|
checkForCycles(this);
|
2009-01-26 04:35:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// InitOperands - Initialize the operands list of this with 2 operands.
|
|
|
|
void InitOperands(SDUse *Ops, const SDValue &Op0, const SDValue &Op1) {
|
|
|
|
Ops[0].setUser(this);
|
|
|
|
Ops[0].setInitial(Op0);
|
|
|
|
Ops[1].setUser(this);
|
|
|
|
Ops[1].setInitial(Op1);
|
|
|
|
NumOperands = 2;
|
|
|
|
OperandList = Ops;
|
2010-01-20 20:13:31 +00:00
|
|
|
checkForCycles(this);
|
2009-01-26 04:35:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// InitOperands - Initialize the operands list of this with 3 operands.
|
|
|
|
void InitOperands(SDUse *Ops, const SDValue &Op0, const SDValue &Op1,
|
|
|
|
const SDValue &Op2) {
|
|
|
|
Ops[0].setUser(this);
|
|
|
|
Ops[0].setInitial(Op0);
|
|
|
|
Ops[1].setUser(this);
|
|
|
|
Ops[1].setInitial(Op1);
|
|
|
|
Ops[2].setUser(this);
|
|
|
|
Ops[2].setInitial(Op2);
|
|
|
|
NumOperands = 3;
|
|
|
|
OperandList = Ops;
|
2010-01-20 20:13:31 +00:00
|
|
|
checkForCycles(this);
|
2009-01-26 04:35:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// InitOperands - Initialize the operands list of this with 4 operands.
|
|
|
|
void InitOperands(SDUse *Ops, const SDValue &Op0, const SDValue &Op1,
|
|
|
|
const SDValue &Op2, const SDValue &Op3) {
|
|
|
|
Ops[0].setUser(this);
|
|
|
|
Ops[0].setInitial(Op0);
|
|
|
|
Ops[1].setUser(this);
|
|
|
|
Ops[1].setInitial(Op1);
|
|
|
|
Ops[2].setUser(this);
|
|
|
|
Ops[2].setInitial(Op2);
|
|
|
|
Ops[3].setUser(this);
|
|
|
|
Ops[3].setInitial(Op3);
|
|
|
|
NumOperands = 4;
|
|
|
|
OperandList = Ops;
|
2010-01-20 20:13:31 +00:00
|
|
|
checkForCycles(this);
|
2009-01-26 04:35:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// InitOperands - Initialize the operands list of this with N operands.
|
|
|
|
void InitOperands(SDUse *Ops, const SDValue *Vals, unsigned N) {
|
|
|
|
for (unsigned i = 0; i != N; ++i) {
|
|
|
|
Ops[i].setUser(this);
|
|
|
|
Ops[i].setInitial(Vals[i]);
|
2008-04-07 10:06:32 +00:00
|
|
|
}
|
2009-01-26 04:35:06 +00:00
|
|
|
NumOperands = N;
|
|
|
|
OperandList = Ops;
|
2010-01-20 20:13:31 +00:00
|
|
|
checkForCycles(this);
|
2007-02-04 08:13:53 +00:00
|
|
|
}
|
2008-07-07 20:57:48 +00:00
|
|
|
|
|
|
|
/// DropOperands - Release the operands and set this node to have
|
2008-07-17 19:10:17 +00:00
|
|
|
/// zero operands.
|
2008-07-07 20:57:48 +00:00
|
|
|
void DropOperands();
|
2005-01-07 07:45:27 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2008-07-27 21:46:04 +00:00
|
|
|
// Define inline functions from the SDValue class.
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2008-07-27 21:46:04 +00:00
|
|
|
inline unsigned SDValue::getOpcode() const {
|
2008-08-28 21:40:38 +00:00
|
|
|
return Node->getOpcode();
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
2009-08-10 22:56:29 +00:00
|
|
|
inline EVT SDValue::getValueType() const {
|
2008-08-28 21:40:38 +00:00
|
|
|
return Node->getValueType(ResNo);
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
2008-07-27 21:46:04 +00:00
|
|
|
inline unsigned SDValue::getNumOperands() const {
|
2008-08-28 21:40:38 +00:00
|
|
|
return Node->getNumOperands();
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
2008-07-27 21:46:04 +00:00
|
|
|
inline const SDValue &SDValue::getOperand(unsigned i) const {
|
2008-08-28 21:40:38 +00:00
|
|
|
return Node->getOperand(i);
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
2008-07-27 21:46:04 +00:00
|
|
|
inline uint64_t SDValue::getConstantOperandVal(unsigned i) const {
|
2008-08-28 21:40:38 +00:00
|
|
|
return Node->getConstantOperandVal(i);
|
2006-10-04 00:56:09 +00:00
|
|
|
}
|
2008-07-27 21:46:04 +00:00
|
|
|
inline bool SDValue::isTargetOpcode() const {
|
2008-08-28 21:40:38 +00:00
|
|
|
return Node->isTargetOpcode();
|
2005-08-17 23:44:54 +00:00
|
|
|
}
|
2009-09-25 20:36:54 +00:00
|
|
|
inline bool SDValue::isTargetMemoryOpcode() const {
|
|
|
|
return Node->isTargetMemoryOpcode();
|
|
|
|
}
|
2008-07-27 21:46:04 +00:00
|
|
|
inline bool SDValue::isMachineOpcode() const {
|
2008-08-28 21:40:38 +00:00
|
|
|
return Node->isMachineOpcode();
|
2008-07-17 19:10:17 +00:00
|
|
|
}
|
2008-07-27 21:46:04 +00:00
|
|
|
inline unsigned SDValue::getMachineOpcode() const {
|
2008-08-28 21:40:38 +00:00
|
|
|
return Node->getMachineOpcode();
|
2005-08-17 23:44:54 +00:00
|
|
|
}
|
2008-07-27 21:46:04 +00:00
|
|
|
inline bool SDValue::use_empty() const {
|
2008-08-28 21:40:38 +00:00
|
|
|
return !Node->hasAnyUseOfValue(ResNo);
|
2007-09-17 17:44:31 +00:00
|
|
|
}
|
2008-07-27 21:46:04 +00:00
|
|
|
inline bool SDValue::hasOneUse() const {
|
2008-08-28 21:40:38 +00:00
|
|
|
return Node->hasNUsesOfValue(1, ResNo);
|
2008-07-27 17:44:52 +00:00
|
|
|
}
|
2009-01-27 23:19:41 +00:00
|
|
|
inline const DebugLoc SDValue::getDebugLoc() const {
|
2009-01-27 21:41:04 +00:00
|
|
|
return Node->getDebugLoc();
|
|
|
|
}
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2009-01-26 04:35:06 +00:00
|
|
|
// Define inline functions from the SDUse class.
|
|
|
|
|
|
|
|
inline void SDUse::set(const SDValue &V) {
|
|
|
|
if (Val.getNode()) removeFromList();
|
|
|
|
Val = V;
|
|
|
|
if (V.getNode()) V.getNode()->addUse(*this);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void SDUse::setInitial(const SDValue &V) {
|
|
|
|
Val = V;
|
|
|
|
V.getNode()->addUse(*this);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void SDUse::setNode(SDNode *N) {
|
|
|
|
if (Val.getNode()) removeFromList();
|
|
|
|
Val.setNode(N);
|
|
|
|
if (N) N->addUse(*this);
|
|
|
|
}
|
|
|
|
|
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 {
|
2008-04-16 16:15:27 +00:00
|
|
|
SDUse Op;
|
2007-02-04 08:35:21 +00:00
|
|
|
public:
|
2009-01-28 21:18:29 +00:00
|
|
|
UnarySDNode(unsigned Opc, DebugLoc dl, SDVTList VTs, SDValue X)
|
|
|
|
: SDNode(Opc, dl, VTs) {
|
|
|
|
InitOperands(&Op, X);
|
|
|
|
}
|
2007-02-04 08:35:21 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/// 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 {
|
2008-04-16 16:15:27 +00:00
|
|
|
SDUse Ops[2];
|
2007-02-04 08:35:21 +00:00
|
|
|
public:
|
2009-01-28 21:18:29 +00:00
|
|
|
BinarySDNode(unsigned Opc, DebugLoc dl, SDVTList VTs, SDValue X, SDValue Y)
|
|
|
|
: SDNode(Opc, dl, VTs) {
|
|
|
|
InitOperands(Ops, X, Y);
|
|
|
|
}
|
2007-02-04 08:35:21 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/// 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 {
|
2008-04-16 16:15:27 +00:00
|
|
|
SDUse Ops[3];
|
2007-02-04 08:35:21 +00:00
|
|
|
public:
|
2009-01-28 21:18:29 +00:00
|
|
|
TernarySDNode(unsigned Opc, DebugLoc dl, SDVTList VTs, SDValue X, SDValue Y,
|
|
|
|
SDValue Z)
|
|
|
|
: SDNode(Opc, dl, VTs) {
|
|
|
|
InitOperands(Ops, X, Y, Z);
|
|
|
|
}
|
2007-02-04 08:35:21 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
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 {
|
2008-04-16 16:15:27 +00:00
|
|
|
SDUse Op;
|
2005-10-05 06:34:34 +00:00
|
|
|
public:
|
2008-05-06 23:30:02 +00:00
|
|
|
// FIXME: Remove the "noinline" attribute once <rdar://problem/5852746> is
|
|
|
|
// fixed.
|
2008-05-07 00:00:34 +00:00
|
|
|
#ifdef __GNUC__
|
2008-07-27 21:46:04 +00:00
|
|
|
explicit __attribute__((__noinline__)) HandleSDNode(SDValue X)
|
2008-05-07 00:00:34 +00:00
|
|
|
#else
|
2008-07-27 21:46:04 +00:00
|
|
|
explicit HandleSDNode(SDValue X)
|
2008-05-07 00:00:34 +00:00
|
|
|
#endif
|
2009-02-07 02:15:05 +00:00
|
|
|
: SDNode(ISD::HANDLENODE, DebugLoc::getUnknownLoc(),
|
2009-08-11 20:47:22 +00:00
|
|
|
getSDVTList(MVT::Other)) {
|
2009-01-26 04:35:06 +00:00
|
|
|
InitOperands(&Op, X);
|
2007-02-04 08:13:53 +00:00
|
|
|
}
|
2009-02-17 22:15:04 +00:00
|
|
|
~HandleSDNode();
|
2009-01-26 04:35:06 +00:00
|
|
|
const SDValue &getValue() const { return Op; }
|
2005-10-05 06:34:34 +00:00
|
|
|
};
|
|
|
|
|
2008-06-25 08:15:39 +00:00
|
|
|
/// Abstact virtual class for operations for memory operations
|
|
|
|
class MemSDNode : public SDNode {
|
|
|
|
private:
|
2008-07-09 22:08:04 +00:00
|
|
|
// MemoryVT - VT of in-memory value.
|
2009-08-10 22:56:29 +00:00
|
|
|
EVT MemoryVT;
|
2008-07-09 22:08:04 +00:00
|
|
|
|
2009-09-25 20:36:54 +00:00
|
|
|
protected:
|
|
|
|
/// MMO - Memory reference information.
|
|
|
|
MachineMemOperand *MMO;
|
2008-06-25 08:15:39 +00:00
|
|
|
|
|
|
|
public:
|
2009-08-10 22:56:29 +00:00
|
|
|
MemSDNode(unsigned Opc, DebugLoc dl, SDVTList VTs, EVT MemoryVT,
|
2009-09-25 20:36:54 +00:00
|
|
|
MachineMemOperand *MMO);
|
2009-01-28 21:18:29 +00:00
|
|
|
|
2009-02-05 21:34:56 +00:00
|
|
|
MemSDNode(unsigned Opc, DebugLoc dl, SDVTList VTs, const SDValue *Ops,
|
2009-09-25 20:36:54 +00:00
|
|
|
unsigned NumOps, EVT MemoryVT, MachineMemOperand *MMO);
|
|
|
|
|
|
|
|
bool readMem() const { return MMO->isLoad(); }
|
|
|
|
bool writeMem() const { return MMO->isStore(); }
|
2009-01-28 21:18:29 +00:00
|
|
|
|
2008-06-25 08:15:39 +00:00
|
|
|
/// Returns alignment and volatility of the memory access
|
2009-09-15 19:05:41 +00:00
|
|
|
unsigned getOriginalAlignment() const {
|
2009-09-25 20:36:54 +00:00
|
|
|
return MMO->getBaseAlignment();
|
2009-09-15 19:05:41 +00:00
|
|
|
}
|
|
|
|
unsigned getAlignment() const {
|
2009-09-25 20:36:54 +00:00
|
|
|
return MMO->getAlignment();
|
2009-09-15 19:05:41 +00:00
|
|
|
}
|
2009-02-05 21:34:56 +00:00
|
|
|
|
2009-02-03 00:08:45 +00:00
|
|
|
/// getRawSubclassData - Return the SubclassData value, which contains an
|
2009-09-25 20:36:54 +00:00
|
|
|
/// encoding of the volatile flag, as well as bits used by subclasses. This
|
|
|
|
/// function should only be used to compute a FoldingSetNodeID value.
|
2009-02-03 00:08:45 +00:00
|
|
|
unsigned getRawSubclassData() const {
|
|
|
|
return SubclassData;
|
|
|
|
}
|
|
|
|
|
2010-02-17 20:21:42 +00:00
|
|
|
// We access subclass data here so that we can check consistency
|
|
|
|
// with MachineMemOperand information.
|
2009-09-25 20:36:54 +00:00
|
|
|
bool isVolatile() const { return (SubclassData >> 5) & 1; }
|
2010-02-17 20:21:42 +00:00
|
|
|
bool isNonTemporal() const { return (SubclassData >> 6) & 1; }
|
2009-09-25 20:36:54 +00:00
|
|
|
|
2008-06-25 08:15:39 +00:00
|
|
|
/// Returns the SrcValue and offset that describes the location of the access
|
2009-09-25 20:36:54 +00:00
|
|
|
const Value *getSrcValue() const { return MMO->getValue(); }
|
|
|
|
int64_t getSrcValueOffset() const { return MMO->getOffset(); }
|
2009-02-05 21:34:56 +00:00
|
|
|
|
2008-07-09 22:08:04 +00:00
|
|
|
/// getMemoryVT - Return the type of the in-memory value.
|
2009-08-10 22:56:29 +00:00
|
|
|
EVT getMemoryVT() const { return MemoryVT; }
|
2009-02-05 21:34:56 +00:00
|
|
|
|
2008-06-25 08:15:39 +00:00
|
|
|
/// getMemOperand - Return a MachineMemOperand object describing the memory
|
|
|
|
/// reference performed by operation.
|
2009-09-25 20:36:54 +00:00
|
|
|
MachineMemOperand *getMemOperand() const { return MMO; }
|
|
|
|
|
|
|
|
/// refineAlignment - Update this MemSDNode's MachineMemOperand information
|
|
|
|
/// to reflect the alignment of NewMMO, if it has a greater alignment.
|
|
|
|
/// This must only be used when the new alignment applies to all users of
|
|
|
|
/// this MachineMemOperand.
|
|
|
|
void refineAlignment(const MachineMemOperand *NewMMO) {
|
|
|
|
MMO->refineAlignment(NewMMO);
|
|
|
|
}
|
2008-07-09 22:08:04 +00:00
|
|
|
|
2008-07-27 21:46:04 +00:00
|
|
|
const SDValue &getChain() const { return getOperand(0); }
|
|
|
|
const SDValue &getBasePtr() const {
|
2008-07-09 22:08:04 +00:00
|
|
|
return getOperand(getOpcode() == ISD::STORE ? 2 : 1);
|
|
|
|
}
|
2008-06-25 08:15:39 +00:00
|
|
|
|
|
|
|
// Methods to support isa and dyn_cast
|
|
|
|
static bool classof(const MemSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
2008-10-17 18:22:58 +00:00
|
|
|
// For some targets, we lower some target intrinsics to a MemIntrinsicNode
|
|
|
|
// with either an intrinsic or a target opcode.
|
2008-08-28 02:44:49 +00:00
|
|
|
return N->getOpcode() == ISD::LOAD ||
|
|
|
|
N->getOpcode() == ISD::STORE ||
|
2008-12-23 21:37:04 +00:00
|
|
|
N->getOpcode() == ISD::ATOMIC_CMP_SWAP ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_SWAP ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_ADD ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_SUB ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_AND ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_OR ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_XOR ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_NAND ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_MIN ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_MAX ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_UMIN ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_UMAX ||
|
2009-09-25 20:36:54 +00:00
|
|
|
N->isTargetMemoryOpcode();
|
2009-02-05 21:34:56 +00:00
|
|
|
}
|
2008-06-25 08:15:39 +00:00
|
|
|
};
|
|
|
|
|
2008-10-17 18:22:58 +00:00
|
|
|
/// AtomicSDNode - A SDNode reprenting atomic operations.
|
|
|
|
///
|
2008-06-25 08:15:39 +00:00
|
|
|
class AtomicSDNode : public MemSDNode {
|
2008-04-16 16:15:27 +00:00
|
|
|
SDUse Ops[4];
|
2009-02-05 21:34:56 +00:00
|
|
|
|
2009-01-19 22:39:36 +00:00
|
|
|
public:
|
2008-06-25 08:15:39 +00:00
|
|
|
// Opc: opcode for atomic
|
|
|
|
// VTL: value type list
|
|
|
|
// Chain: memory chain for operaand
|
2008-07-27 21:46:04 +00:00
|
|
|
// Ptr: address to update as a SDValue
|
2008-06-25 08:15:39 +00:00
|
|
|
// Cmp: compare value
|
|
|
|
// Swp: swap value
|
|
|
|
// SrcVal: address to update as a Value (used for MemOperand)
|
|
|
|
// Align: alignment of memory
|
2009-08-10 22:56:29 +00:00
|
|
|
AtomicSDNode(unsigned Opc, DebugLoc dl, SDVTList VTL, EVT MemVT,
|
2009-01-28 21:18:29 +00:00
|
|
|
SDValue Chain, SDValue Ptr,
|
2009-09-25 20:36:54 +00:00
|
|
|
SDValue Cmp, SDValue Swp, MachineMemOperand *MMO)
|
|
|
|
: MemSDNode(Opc, dl, VTL, MemVT, MMO) {
|
|
|
|
assert(readMem() && "Atomic MachineMemOperand is not a load!");
|
|
|
|
assert(writeMem() && "Atomic MachineMemOperand is not a store!");
|
2009-01-28 21:18:29 +00:00
|
|
|
InitOperands(Ops, Chain, Ptr, Cmp, Swp);
|
|
|
|
}
|
2009-08-10 22:56:29 +00:00
|
|
|
AtomicSDNode(unsigned Opc, DebugLoc dl, SDVTList VTL, EVT MemVT,
|
2009-02-05 21:34:56 +00:00
|
|
|
SDValue Chain, SDValue Ptr,
|
2009-09-25 20:36:54 +00:00
|
|
|
SDValue Val, MachineMemOperand *MMO)
|
|
|
|
: MemSDNode(Opc, dl, VTL, MemVT, MMO) {
|
|
|
|
assert(readMem() && "Atomic MachineMemOperand is not a load!");
|
|
|
|
assert(writeMem() && "Atomic MachineMemOperand is not a store!");
|
2009-01-28 21:18:29 +00:00
|
|
|
InitOperands(Ops, Chain, Ptr, Val);
|
|
|
|
}
|
2009-02-05 21:34:56 +00:00
|
|
|
|
2008-07-27 21:46:04 +00:00
|
|
|
const SDValue &getBasePtr() const { return getOperand(1); }
|
|
|
|
const SDValue &getVal() const { return getOperand(2); }
|
2008-06-25 08:15:39 +00:00
|
|
|
|
2009-02-05 21:34:56 +00:00
|
|
|
bool isCompareAndSwap() const {
|
|
|
|
unsigned Op = getOpcode();
|
2008-12-23 21:37:04 +00:00
|
|
|
return Op == ISD::ATOMIC_CMP_SWAP;
|
2008-08-28 02:44:49 +00:00
|
|
|
}
|
2008-06-25 08:15:39 +00:00
|
|
|
|
|
|
|
// Methods to support isa and dyn_cast
|
|
|
|
static bool classof(const AtomicSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
2008-12-23 21:37:04 +00:00
|
|
|
return N->getOpcode() == ISD::ATOMIC_CMP_SWAP ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_SWAP ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_ADD ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_SUB ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_AND ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_OR ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_XOR ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_NAND ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_MIN ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_MAX ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_UMIN ||
|
|
|
|
N->getOpcode() == ISD::ATOMIC_LOAD_UMAX;
|
2008-06-25 08:15:39 +00:00
|
|
|
}
|
2008-02-21 06:45:13 +00:00
|
|
|
};
|
|
|
|
|
2009-09-25 20:36:54 +00:00
|
|
|
/// MemIntrinsicSDNode - This SDNode is used for target intrinsics that touch
|
|
|
|
/// memory and need an associated MachineMemOperand. Its opcode may be
|
|
|
|
/// INTRINSIC_VOID, INTRINSIC_W_CHAIN, or a target-specific opcode with a
|
|
|
|
/// value not less than FIRST_TARGET_MEMORY_OPCODE.
|
2008-10-17 18:22:58 +00:00
|
|
|
class MemIntrinsicSDNode : public MemSDNode {
|
2008-11-18 17:05:42 +00:00
|
|
|
public:
|
2009-01-28 21:18:29 +00:00
|
|
|
MemIntrinsicSDNode(unsigned Opc, DebugLoc dl, SDVTList VTs,
|
|
|
|
const SDValue *Ops, unsigned NumOps,
|
2009-09-25 20:36:54 +00:00
|
|
|
EVT MemoryVT, MachineMemOperand *MMO)
|
|
|
|
: MemSDNode(Opc, dl, VTs, Ops, NumOps, MemoryVT, MMO) {
|
2009-01-28 21:18:29 +00:00
|
|
|
}
|
2008-10-17 18:22:58 +00:00
|
|
|
|
|
|
|
// Methods to support isa and dyn_cast
|
|
|
|
static bool classof(const MemIntrinsicSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
|
|
|
// We lower some target intrinsics to their target opcode
|
|
|
|
// early a node with a target opcode can be of this class
|
|
|
|
return N->getOpcode() == ISD::INTRINSIC_W_CHAIN ||
|
|
|
|
N->getOpcode() == ISD::INTRINSIC_VOID ||
|
2009-09-25 20:36:54 +00:00
|
|
|
N->isTargetMemoryOpcode();
|
2008-10-17 18:22:58 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2009-04-29 05:20:52 +00:00
|
|
|
/// ShuffleVectorSDNode - This SDNode is used to implement the code generator
|
|
|
|
/// support for the llvm IR shufflevector instruction. It combines elements
|
|
|
|
/// from two input vectors into a new input vector, with the selection and
|
|
|
|
/// ordering of elements determined by an array of integers, referred to as
|
|
|
|
/// the shuffle mask. For input vectors of width N, mask indices of 0..N-1
|
|
|
|
/// refer to elements from the LHS input, and indices from N to 2N-1 the RHS.
|
|
|
|
/// An index of -1 is treated as undef, such that the code generator may put
|
|
|
|
/// any value in the corresponding element of the result.
|
2009-04-27 18:41:29 +00:00
|
|
|
class ShuffleVectorSDNode : public SDNode {
|
|
|
|
SDUse Ops[2];
|
2009-04-29 05:20:52 +00:00
|
|
|
|
|
|
|
// The memory for Mask is owned by the SelectionDAG's OperandAllocator, and
|
|
|
|
// is freed when the SelectionDAG object is destroyed.
|
|
|
|
const int *Mask;
|
2009-04-27 18:41:29 +00:00
|
|
|
protected:
|
|
|
|
friend class SelectionDAG;
|
2009-08-10 22:56:29 +00:00
|
|
|
ShuffleVectorSDNode(EVT VT, DebugLoc dl, SDValue N1, SDValue N2,
|
2009-04-29 05:20:52 +00:00
|
|
|
const int *M)
|
2009-04-27 18:41:29 +00:00
|
|
|
: SDNode(ISD::VECTOR_SHUFFLE, dl, getSDVTList(VT)), Mask(M) {
|
|
|
|
InitOperands(Ops, N1, N2);
|
|
|
|
}
|
|
|
|
public:
|
|
|
|
|
|
|
|
void getMask(SmallVectorImpl<int> &M) const {
|
2009-08-10 22:56:29 +00:00
|
|
|
EVT VT = getValueType(0);
|
2009-04-27 18:41:29 +00:00
|
|
|
M.clear();
|
|
|
|
for (unsigned i = 0, e = VT.getVectorNumElements(); i != e; ++i)
|
|
|
|
M.push_back(Mask[i]);
|
|
|
|
}
|
|
|
|
int getMaskElt(unsigned Idx) const {
|
|
|
|
assert(Idx < getValueType(0).getVectorNumElements() && "Idx out of range!");
|
|
|
|
return Mask[Idx];
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isSplat() const { return isSplatMask(Mask, getValueType(0)); }
|
|
|
|
int getSplatIndex() const {
|
|
|
|
assert(isSplat() && "Cannot get splat index for non-splat!");
|
2010-02-18 22:33:18 +00:00
|
|
|
EVT VT = getValueType(0);
|
|
|
|
for (unsigned i = 0, e = VT.getVectorNumElements(); i != e; ++i) {
|
|
|
|
if (Mask[i] != -1)
|
|
|
|
return Mask[i];
|
|
|
|
}
|
|
|
|
return -1;
|
2009-04-27 18:41:29 +00:00
|
|
|
}
|
2009-08-10 22:56:29 +00:00
|
|
|
static bool isSplatMask(const int *Mask, EVT VT);
|
2009-04-27 18:41:29 +00:00
|
|
|
|
|
|
|
static bool classof(const ShuffleVectorSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
|
|
|
return N->getOpcode() == ISD::VECTOR_SHUFFLE;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
class ConstantSDNode : public SDNode {
|
2008-09-12 18:08:03 +00:00
|
|
|
const ConstantInt *Value;
|
2005-01-07 07:45:27 +00:00
|
|
|
friend class SelectionDAG;
|
2009-08-10 22:56:29 +00:00
|
|
|
ConstantSDNode(bool isTarget, const ConstantInt *val, EVT VT)
|
2009-02-17 22:15:04 +00:00
|
|
|
: SDNode(isTarget ? ISD::TargetConstant : ISD::Constant,
|
2009-02-07 02:15:05 +00:00
|
|
|
DebugLoc::getUnknownLoc(), getSDVTList(VT)), Value(val) {
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
public:
|
|
|
|
|
2008-09-12 18:08:03 +00:00
|
|
|
const ConstantInt *getConstantIntValue() const { return Value; }
|
|
|
|
const APInt &getAPIntValue() const { return Value->getValue(); }
|
|
|
|
uint64_t getZExtValue() const { return Value->getZExtValue(); }
|
2008-09-26 21:54:37 +00:00
|
|
|
int64_t getSExtValue() const { return Value->getSExtValue(); }
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2008-09-12 18:08:03 +00:00
|
|
|
bool isNullValue() const { return Value->isNullValue(); }
|
|
|
|
bool isAllOnesValue() const { return Value->isAllOnesValue(); }
|
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 {
|
2008-09-12 18:08:03 +00:00
|
|
|
const ConstantFP *Value;
|
2005-01-07 07:45:27 +00:00
|
|
|
friend class SelectionDAG;
|
2009-08-10 22:56:29 +00:00
|
|
|
ConstantFPSDNode(bool isTarget, const ConstantFP *val, EVT VT)
|
2007-08-25 22:10:57 +00:00
|
|
|
: SDNode(isTarget ? ISD::TargetConstantFP : ISD::ConstantFP,
|
2009-02-07 02:15:05 +00:00
|
|
|
DebugLoc::getUnknownLoc(), getSDVTList(VT)), Value(val) {
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
public:
|
|
|
|
|
2008-09-12 18:08:03 +00:00
|
|
|
const APFloat& getValueAPF() const { return Value->getValueAPF(); }
|
|
|
|
const ConstantFP *getConstantFPValue() 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
|
2009-02-17 22:15:04 +00:00
|
|
|
/// convenient to write "2.0" and the like. Without this function we'd
|
2007-08-31 23:34:27 +00:00
|
|
|
/// have to duplicate its logic everywhere it's called.
|
2008-04-20 18:23:46 +00:00
|
|
|
bool isExactlyValue(double V) const {
|
2008-10-09 23:00:39 +00:00
|
|
|
bool ignored;
|
2008-04-20 18:23:46 +00:00
|
|
|
// convert is not supported on this type
|
2008-09-12 18:08:03 +00:00
|
|
|
if (&Value->getValueAPF().getSemantics() == &APFloat::PPCDoubleDouble)
|
2008-04-20 18:23:46 +00:00
|
|
|
return false;
|
2008-01-27 06:19:08 +00:00
|
|
|
APFloat Tmp(V);
|
2008-09-12 18:08:03 +00:00
|
|
|
Tmp.convert(Value->getValueAPF().getSemantics(),
|
2008-10-09 23:00:39 +00:00
|
|
|
APFloat::rmNearestTiesToEven, &ignored);
|
2008-01-27 06:19:08 +00:00
|
|
|
return isExactlyValue(Tmp);
|
2007-08-25 22:10:57 +00:00
|
|
|
}
|
2007-08-26 01:18:27 +00:00
|
|
|
bool isExactlyValue(const APFloat& V) const;
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2009-08-10 22:56:29 +00:00
|
|
|
bool isValueValidForType(EVT VT, const APFloat& Val);
|
2007-08-30 00:23:21 +00:00
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
static bool classof(const ConstantFPSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
2009-02-17 22:15:04 +00:00
|
|
|
return N->getOpcode() == ISD::ConstantFP ||
|
2006-01-29 06:24:40 +00:00
|
|
|
N->getOpcode() == ISD::TargetConstantFP;
|
2005-01-07 07:45:27 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class GlobalAddressSDNode : public SDNode {
|
|
|
|
GlobalValue *TheGlobal;
|
Teach DAGCombine to fold constant offsets into GlobalAddress nodes,
and add a TargetLowering hook for it to use to determine when this
is legal (i.e. not in PIC mode, etc.)
This allows instruction selection to emit folded constant offsets
in more cases, such as the included testcase, eliminating the need
for explicit arithmetic instructions.
This eliminates the need for the C++ code in X86ISelDAGToDAG.cpp
that attempted to achieve the same effect, but wasn't as effective.
Also, fix handling of offsets in GlobalAddressSDNodes in several
places, including changing GlobalAddressSDNode's offset from
int to int64_t.
The Mips, Alpha, Sparc, and CellSPU targets appear to be
unaware of GlobalAddress offsets currently, so set the hook to
false on those targets.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@57748 91177308-0d34-0410-b5e6-96231b3b80d8
2008-10-18 02:06:02 +00:00
|
|
|
int64_t Offset;
|
2009-06-25 21:21:14 +00:00
|
|
|
unsigned char TargetFlags;
|
2005-01-07 07:45:27 +00:00
|
|
|
friend class SelectionDAG;
|
2009-08-10 22:56:29 +00:00
|
|
|
GlobalAddressSDNode(unsigned Opc, const GlobalValue *GA, EVT VT,
|
2009-06-25 21:21:14 +00:00
|
|
|
int64_t o, unsigned char TargetFlags);
|
2005-01-07 07:45:27 +00:00
|
|
|
public:
|
|
|
|
|
|
|
|
GlobalValue *getGlobal() const { return TheGlobal; }
|
Teach DAGCombine to fold constant offsets into GlobalAddress nodes,
and add a TargetLowering hook for it to use to determine when this
is legal (i.e. not in PIC mode, etc.)
This allows instruction selection to emit folded constant offsets
in more cases, such as the included testcase, eliminating the need
for explicit arithmetic instructions.
This eliminates the need for the C++ code in X86ISelDAGToDAG.cpp
that attempted to achieve the same effect, but wasn't as effective.
Also, fix handling of offsets in GlobalAddressSDNodes in several
places, including changing GlobalAddressSDNode's offset from
int to int64_t.
The Mips, Alpha, Sparc, and CellSPU targets appear to be
unaware of GlobalAddress offsets currently, so set the hook to
false on those targets.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@57748 91177308-0d34-0410-b5e6-96231b3b80d8
2008-10-18 02:06:02 +00:00
|
|
|
int64_t getOffset() const { return Offset; }
|
2009-06-25 21:21:14 +00:00
|
|
|
unsigned char getTargetFlags() const { return TargetFlags; }
|
2009-04-29 04:43:24 +00:00
|
|
|
// Return the address space this GlobalAddress belongs to.
|
|
|
|
unsigned getAddressSpace() const;
|
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;
|
|
|
|
friend class SelectionDAG;
|
2009-08-10 22:56:29 +00:00
|
|
|
FrameIndexSDNode(int fi, EVT VT, bool isTarg)
|
2009-02-17 22:15:04 +00:00
|
|
|
: SDNode(isTarg ? ISD::TargetFrameIndex : ISD::FrameIndex,
|
2009-02-07 02:15:05 +00:00
|
|
|
DebugLoc::getUnknownLoc(), 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;
|
2009-06-25 21:35:31 +00:00
|
|
|
unsigned char TargetFlags;
|
2006-04-22 18:53:45 +00:00
|
|
|
friend class SelectionDAG;
|
2009-08-10 22:56:29 +00:00
|
|
|
JumpTableSDNode(int jti, EVT VT, bool isTarg, unsigned char TF)
|
2009-02-07 02:15:05 +00:00
|
|
|
: SDNode(isTarg ? ISD::TargetJumpTable : ISD::JumpTable,
|
2009-06-25 21:35:31 +00:00
|
|
|
DebugLoc::getUnknownLoc(), getSDVTList(VT)), JTI(jti), TargetFlags(TF) {
|
2007-02-04 07:28:00 +00:00
|
|
|
}
|
2006-04-22 18:53:45 +00:00
|
|
|
public:
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2008-02-22 01:54:35 +00:00
|
|
|
int getIndex() const { return JTI; }
|
2009-06-25 21:35:31 +00:00
|
|
|
unsigned char getTargetFlags() const { return TargetFlags; }
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2006-04-22 18:53:45 +00:00
|
|
|
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.
|
2009-03-13 07:51:59 +00:00
|
|
|
unsigned Alignment; // Minimum alignment requirement of CP (not log2 value).
|
2009-06-25 21:35:31 +00:00
|
|
|
unsigned char TargetFlags;
|
2005-01-07 07:45:27 +00:00
|
|
|
friend class SelectionDAG;
|
2009-08-10 22:56:29 +00:00
|
|
|
ConstantPoolSDNode(bool isTarget, Constant *c, EVT VT, int o, unsigned Align,
|
2009-06-25 21:35:31 +00:00
|
|
|
unsigned char TF)
|
2007-02-04 07:37:24 +00:00
|
|
|
: SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool,
|
2009-02-07 02:15:05 +00:00
|
|
|
DebugLoc::getUnknownLoc(),
|
2009-06-25 21:35:31 +00:00
|
|
|
getSDVTList(VT)), Offset(o), Alignment(Align), TargetFlags(TF) {
|
2006-09-12 21:00:35 +00:00
|
|
|
assert((int)Offset >= 0 && "Offset is too large");
|
|
|
|
Val.ConstVal = c;
|
|
|
|
}
|
|
|
|
ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v,
|
2009-08-10 22:56:29 +00:00
|
|
|
EVT VT, int o, unsigned Align, unsigned char TF)
|
2009-02-17 22:15:04 +00:00
|
|
|
: SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool,
|
2009-02-07 02:15:05 +00:00
|
|
|
DebugLoc::getUnknownLoc(),
|
2009-06-25 21:35:31 +00:00
|
|
|
getSDVTList(VT)), Offset(o), Alignment(Align), TargetFlags(TF) {
|
2006-09-12 21:00:35 +00:00
|
|
|
assert((int)Offset >= 0 && "Offset is too large");
|
|
|
|
Val.MachineCPVal = v;
|
2009-04-01 18:45:54 +00:00
|
|
|
Offset |= 1 << (sizeof(unsigned)*CHAR_BIT-1);
|
2006-09-12 21:00:35 +00:00
|
|
|
}
|
2005-01-07 07:45:27 +00:00
|
|
|
public:
|
2009-06-25 21:35:31 +00:00
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
|
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 {
|
2009-04-01 18:45:54 +00:00
|
|
|
return Offset & ~(1 << (sizeof(unsigned)*CHAR_BIT-1));
|
2006-09-14 07:30:48 +00:00
|
|
|
}
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2006-02-09 02:10:15 +00:00
|
|
|
// Return the alignment of this constant pool object, which is either 0 (for
|
2009-03-13 07:51:59 +00:00
|
|
|
// default alignment) or the desired value.
|
2006-01-31 22:23:14 +00:00
|
|
|
unsigned getAlignment() const { return Alignment; }
|
2009-06-25 21:35:31 +00:00
|
|
|
unsigned char getTargetFlags() const { return TargetFlags; }
|
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;
|
|
|
|
friend class SelectionDAG;
|
2009-02-07 02:15:05 +00:00
|
|
|
/// Debug info is meaningful and potentially useful here, but we create
|
|
|
|
/// blocks out of order when they're jumped to, which makes it a bit
|
|
|
|
/// harder. Let's see if we need it first.
|
2007-03-23 18:44:11 +00:00
|
|
|
explicit BasicBlockSDNode(MachineBasicBlock *mbb)
|
2009-02-07 02:15:05 +00:00
|
|
|
: SDNode(ISD::BasicBlock, DebugLoc::getUnknownLoc(),
|
2009-08-11 20:47:22 +00:00
|
|
|
getSDVTList(MVT::Other)), MBB(mbb) {
|
2009-01-28 21:18:29 +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;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2009-03-01 01:13:55 +00:00
|
|
|
/// BuildVectorSDNode - A "pseudo-class" with methods for operating on
|
|
|
|
/// BUILD_VECTORs.
|
|
|
|
class BuildVectorSDNode : public SDNode {
|
2009-03-09 17:07:15 +00:00
|
|
|
// These are constructed as SDNodes and then cast to BuildVectorSDNodes.
|
|
|
|
explicit BuildVectorSDNode(); // Do not implement
|
2009-03-01 01:13:55 +00:00
|
|
|
public:
|
2009-03-02 23:24:16 +00:00
|
|
|
/// isConstantSplat - Check if this is a constant splat, and if so, find the
|
|
|
|
/// smallest element size that splats the vector. If MinSplatBits is
|
|
|
|
/// nonzero, the element size must be at least that large. Note that the
|
|
|
|
/// splat element may be the entire vector (i.e., a one element vector).
|
|
|
|
/// Returns the splat element value in SplatValue. Any undefined bits in
|
|
|
|
/// that value are zero, and the corresponding bits in the SplatUndef mask
|
|
|
|
/// are set. The SplatBitSize value is set to the splat element size in
|
|
|
|
/// bits. HasAnyUndefs is set to true if any bits in the vector are
|
2009-11-13 01:45:18 +00:00
|
|
|
/// undefined. isBigEndian describes the endianness of the target.
|
2009-03-02 23:24:16 +00:00
|
|
|
bool isConstantSplat(APInt &SplatValue, APInt &SplatUndef,
|
|
|
|
unsigned &SplatBitSize, bool &HasAnyUndefs,
|
2009-11-13 01:45:18 +00:00
|
|
|
unsigned MinSplatBits = 0, bool isBigEndian = false);
|
2009-03-01 01:13:55 +00:00
|
|
|
|
|
|
|
static inline bool classof(const BuildVectorSDNode *) { return true; }
|
|
|
|
static inline bool classof(const SDNode *N) {
|
|
|
|
return N->getOpcode() == ISD::BUILD_VECTOR;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2008-02-12 18:52:52 +00:00
|
|
|
/// SrcValueSDNode - An SDNode that holds an arbitrary LLVM IR Value. This is
|
|
|
|
/// used when the SelectionDAG needs to make a simple reference to something
|
|
|
|
/// in the LLVM IR representation.
|
|
|
|
///
|
2005-04-27 20:10:01 +00:00
|
|
|
class SrcValueSDNode : public SDNode {
|
|
|
|
const Value *V;
|
|
|
|
friend class SelectionDAG;
|
2008-02-06 22:27:42 +00:00
|
|
|
/// Create a SrcValue for a general value.
|
|
|
|
explicit SrcValueSDNode(const Value *v)
|
2009-02-07 02:15:05 +00:00
|
|
|
: SDNode(ISD::SRCVALUE, DebugLoc::getUnknownLoc(),
|
2009-08-11 20:47:22 +00:00
|
|
|
getSDVTList(MVT::Other)), V(v) {}
|
2005-04-27 20:10:01 +00:00
|
|
|
|
|
|
|
public:
|
2008-02-06 22:27:42 +00:00
|
|
|
/// getValue - return the contained Value.
|
2005-04-27 20:10:01 +00:00
|
|
|
const Value *getValue() const { return V; }
|
|
|
|
|
|
|
|
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;
|
|
|
|
friend class SelectionDAG;
|
2009-08-10 22:56:29 +00:00
|
|
|
RegisterSDNode(unsigned reg, EVT VT)
|
2009-02-07 02:15:05 +00:00
|
|
|
: SDNode(ISD::Register, DebugLoc::getUnknownLoc(),
|
|
|
|
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
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2009-10-30 01:27:03 +00:00
|
|
|
class BlockAddressSDNode : public SDNode {
|
|
|
|
BlockAddress *BA;
|
2009-11-20 23:18:13 +00:00
|
|
|
unsigned char TargetFlags;
|
2009-10-30 01:27:03 +00:00
|
|
|
friend class SelectionDAG;
|
2009-11-20 23:18:13 +00:00
|
|
|
BlockAddressSDNode(unsigned NodeTy, EVT VT, BlockAddress *ba,
|
|
|
|
unsigned char Flags)
|
|
|
|
: SDNode(NodeTy, DebugLoc::getUnknownLoc(), getSDVTList(VT)),
|
|
|
|
BA(ba), TargetFlags(Flags) {
|
2009-10-30 01:27:03 +00:00
|
|
|
}
|
|
|
|
public:
|
|
|
|
BlockAddress *getBlockAddress() const { return BA; }
|
2009-11-20 23:18:13 +00:00
|
|
|
unsigned char getTargetFlags() const { return TargetFlags; }
|
2009-10-30 01:27:03 +00:00
|
|
|
|
|
|
|
static bool classof(const BlockAddressSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
|
|
|
return N->getOpcode() == ISD::BlockAddress ||
|
|
|
|
N->getOpcode() == ISD::TargetBlockAddress;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2008-07-01 00:05:16 +00:00
|
|
|
class LabelSDNode : public SDNode {
|
|
|
|
SDUse Chain;
|
|
|
|
unsigned LabelID;
|
|
|
|
friend class SelectionDAG;
|
2009-10-30 01:27:03 +00:00
|
|
|
LabelSDNode(unsigned NodeTy, DebugLoc dl, SDValue ch, unsigned id)
|
2009-08-11 20:47:22 +00:00
|
|
|
: SDNode(NodeTy, dl, getSDVTList(MVT::Other)), LabelID(id) {
|
2009-01-28 21:18:29 +00:00
|
|
|
InitOperands(&Chain, ch);
|
|
|
|
}
|
2008-07-01 00:05:16 +00:00
|
|
|
public:
|
|
|
|
unsigned getLabelID() const { return LabelID; }
|
|
|
|
|
|
|
|
static bool classof(const LabelSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
2009-11-23 23:20:51 +00:00
|
|
|
return N->getOpcode() == ISD::EH_LABEL;
|
2008-07-01 00:05:16 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2008-09-16 21:48:12 +00:00
|
|
|
class ExternalSymbolSDNode : public SDNode {
|
2005-01-07 07:45:27 +00:00
|
|
|
const char *Symbol;
|
2009-06-25 18:45:50 +00:00
|
|
|
unsigned char TargetFlags;
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
friend class SelectionDAG;
|
2009-08-10 22:56:29 +00:00
|
|
|
ExternalSymbolSDNode(bool isTarget, const char *Sym, unsigned char TF, EVT VT)
|
2008-09-16 21:48:12 +00:00
|
|
|
: SDNode(isTarget ? ISD::TargetExternalSymbol : ISD::ExternalSymbol,
|
2009-02-07 02:15:05 +00:00
|
|
|
DebugLoc::getUnknownLoc(),
|
2009-06-25 18:45:50 +00:00
|
|
|
getSDVTList(VT)), Symbol(Sym), TargetFlags(TF) {
|
2009-01-28 21:18:29 +00:00
|
|
|
}
|
2005-01-07 07:45:27 +00:00
|
|
|
public:
|
2008-09-16 21:48:12 +00:00
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
const char *getSymbol() const { return Symbol; }
|
2009-06-25 18:45:50 +00:00
|
|
|
unsigned char getTargetFlags() const { return TargetFlags; }
|
2005-01-07 07:45:27 +00:00
|
|
|
|
2008-09-16 21:48:12 +00:00
|
|
|
static bool classof(const ExternalSymbolSDNode *) { return true; }
|
2005-01-07 07:45:27 +00:00
|
|
|
static bool classof(const SDNode *N) {
|
2008-09-16 21:48:12 +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;
|
|
|
|
friend class SelectionDAG;
|
2007-03-23 18:44:11 +00:00
|
|
|
explicit CondCodeSDNode(ISD::CondCode Cond)
|
2009-02-07 02:15:05 +00:00
|
|
|
: SDNode(ISD::CONDCODE, DebugLoc::getUnknownLoc(),
|
2009-08-11 20:47:22 +00:00
|
|
|
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
|
|
|
}
|
|
|
|
};
|
2009-04-27 18:41:29 +00:00
|
|
|
|
2008-11-10 20:54:11 +00:00
|
|
|
/// CvtRndSatSDNode - NOTE: avoid using this node as this may disappear in the
|
|
|
|
/// future and most targets don't support it.
|
|
|
|
class CvtRndSatSDNode : public SDNode {
|
|
|
|
ISD::CvtCode CvtCode;
|
|
|
|
friend class SelectionDAG;
|
2009-08-10 22:56:29 +00:00
|
|
|
explicit CvtRndSatSDNode(EVT VT, DebugLoc dl, const SDValue *Ops,
|
2009-02-03 23:04:43 +00:00
|
|
|
unsigned NumOps, ISD::CvtCode Code)
|
2009-02-17 22:15:04 +00:00
|
|
|
: SDNode(ISD::CONVERT_RNDSAT, dl, getSDVTList(VT), Ops, NumOps),
|
2009-02-03 23:04:43 +00:00
|
|
|
CvtCode(Code) {
|
|
|
|
assert(NumOps == 5 && "wrong number of operations");
|
|
|
|
}
|
2008-11-10 20:54:11 +00:00
|
|
|
public:
|
|
|
|
ISD::CvtCode getCvtCode() const { return CvtCode; }
|
|
|
|
|
|
|
|
static bool classof(const CvtRndSatSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
|
|
|
return N->getOpcode() == ISD::CONVERT_RNDSAT;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2008-03-21 09:14:45 +00:00
|
|
|
namespace ISD {
|
|
|
|
struct ArgFlagsTy {
|
|
|
|
private:
|
|
|
|
static const uint64_t NoFlagSet = 0ULL;
|
|
|
|
static const uint64_t ZExt = 1ULL<<0; ///< Zero extended
|
|
|
|
static const uint64_t ZExtOffs = 0;
|
|
|
|
static const uint64_t SExt = 1ULL<<1; ///< Sign extended
|
|
|
|
static const uint64_t SExtOffs = 1;
|
|
|
|
static const uint64_t InReg = 1ULL<<2; ///< Passed in register
|
|
|
|
static const uint64_t InRegOffs = 2;
|
|
|
|
static const uint64_t SRet = 1ULL<<3; ///< Hidden struct-ret ptr
|
|
|
|
static const uint64_t SRetOffs = 3;
|
|
|
|
static const uint64_t ByVal = 1ULL<<4; ///< Struct passed by value
|
|
|
|
static const uint64_t ByValOffs = 4;
|
|
|
|
static const uint64_t Nest = 1ULL<<5; ///< Nested fn static chain
|
|
|
|
static const uint64_t NestOffs = 5;
|
|
|
|
static const uint64_t ByValAlign = 0xFULL << 6; //< Struct alignment
|
|
|
|
static const uint64_t ByValAlignOffs = 6;
|
2008-04-15 08:08:50 +00:00
|
|
|
static const uint64_t Split = 1ULL << 10;
|
|
|
|
static const uint64_t SplitOffs = 10;
|
2008-03-21 09:14:45 +00:00
|
|
|
static const uint64_t OrigAlign = 0x1FULL<<27;
|
|
|
|
static const uint64_t OrigAlignOffs = 27;
|
|
|
|
static const uint64_t ByValSize = 0xffffffffULL << 32; //< Struct size
|
|
|
|
static const uint64_t ByValSizeOffs = 32;
|
|
|
|
|
|
|
|
static const uint64_t One = 1ULL; //< 1 of this type, for shifts
|
|
|
|
|
|
|
|
uint64_t Flags;
|
|
|
|
public:
|
|
|
|
ArgFlagsTy() : Flags(0) { }
|
|
|
|
|
|
|
|
bool isZExt() const { return Flags & ZExt; }
|
|
|
|
void setZExt() { Flags |= One << ZExtOffs; }
|
|
|
|
|
|
|
|
bool isSExt() const { return Flags & SExt; }
|
|
|
|
void setSExt() { Flags |= One << SExtOffs; }
|
|
|
|
|
|
|
|
bool isInReg() const { return Flags & InReg; }
|
|
|
|
void setInReg() { Flags |= One << InRegOffs; }
|
|
|
|
|
|
|
|
bool isSRet() const { return Flags & SRet; }
|
|
|
|
void setSRet() { Flags |= One << SRetOffs; }
|
|
|
|
|
|
|
|
bool isByVal() const { return Flags & ByVal; }
|
|
|
|
void setByVal() { Flags |= One << ByValOffs; }
|
|
|
|
|
|
|
|
bool isNest() const { return Flags & Nest; }
|
|
|
|
void setNest() { Flags |= One << NestOffs; }
|
|
|
|
|
|
|
|
unsigned getByValAlign() const {
|
2009-02-17 22:15:04 +00:00
|
|
|
return (unsigned)
|
2008-04-15 18:44:59 +00:00
|
|
|
((One << ((Flags & ByValAlign) >> ByValAlignOffs)) / 2);
|
2008-03-21 09:14:45 +00:00
|
|
|
}
|
|
|
|
void setByValAlign(unsigned A) {
|
|
|
|
Flags = (Flags & ~ByValAlign) |
|
|
|
|
(uint64_t(Log2_32(A) + 1) << ByValAlignOffs);
|
|
|
|
}
|
2009-02-17 22:15:04 +00:00
|
|
|
|
2008-04-15 08:08:50 +00:00
|
|
|
bool isSplit() const { return Flags & Split; }
|
|
|
|
void setSplit() { Flags |= One << SplitOffs; }
|
2008-03-21 09:14:45 +00:00
|
|
|
|
|
|
|
unsigned getOrigAlign() const {
|
2008-04-15 18:44:59 +00:00
|
|
|
return (unsigned)
|
|
|
|
((One << ((Flags & OrigAlign) >> OrigAlignOffs)) / 2);
|
2008-03-21 09:14:45 +00:00
|
|
|
}
|
|
|
|
void setOrigAlign(unsigned A) {
|
|
|
|
Flags = (Flags & ~OrigAlign) |
|
|
|
|
(uint64_t(Log2_32(A) + 1) << OrigAlignOffs);
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned getByValSize() const {
|
2008-04-15 18:44:59 +00:00
|
|
|
return (unsigned)((Flags & ByValSize) >> ByValSizeOffs);
|
2008-03-21 09:14:45 +00:00
|
|
|
}
|
|
|
|
void setByValSize(unsigned S) {
|
|
|
|
Flags = (Flags & ~ByValSize) | (uint64_t(S) << ByValSizeOffs);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getArgFlagsString - Returns the flags as a string, eg: "zext align:4".
|
|
|
|
std::string getArgFlagsString();
|
|
|
|
|
|
|
|
/// getRawBits - Represent the flags as a bunch of bits.
|
|
|
|
uint64_t getRawBits() const { return Flags; }
|
|
|
|
};
|
2008-09-13 01:54:27 +00:00
|
|
|
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@78142 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-05 01:29:28 +00:00
|
|
|
/// InputArg - This struct carries flags and type information about a
|
|
|
|
/// single incoming (formal) argument or incoming (from the perspective
|
|
|
|
/// of the caller) return value virtual register.
|
|
|
|
///
|
|
|
|
struct InputArg {
|
|
|
|
ArgFlagsTy Flags;
|
2009-08-10 22:56:29 +00:00
|
|
|
EVT VT;
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@78142 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-05 01:29:28 +00:00
|
|
|
bool Used;
|
|
|
|
|
2009-08-11 20:47:22 +00:00
|
|
|
InputArg() : VT(MVT::Other), Used(false) {}
|
2009-08-10 22:56:29 +00:00
|
|
|
InputArg(ISD::ArgFlagsTy flags, EVT vt, bool used)
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@78142 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-05 01:29:28 +00:00
|
|
|
: Flags(flags), VT(vt), Used(used) {
|
|
|
|
assert(VT.isSimple() &&
|
|
|
|
"InputArg value type must be Simple!");
|
|
|
|
}
|
|
|
|
};
|
2008-09-13 01:54:27 +00:00
|
|
|
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@78142 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-05 01:29:28 +00:00
|
|
|
/// OutputArg - This struct carries flags and a value for a
|
|
|
|
/// single outgoing (actual) argument or outgoing (from the perspective
|
|
|
|
/// of the caller) return value virtual register.
|
|
|
|
///
|
|
|
|
struct OutputArg {
|
|
|
|
ArgFlagsTy Flags;
|
|
|
|
SDValue Val;
|
|
|
|
bool IsFixed;
|
|
|
|
|
|
|
|
OutputArg() : IsFixed(false) {}
|
|
|
|
OutputArg(ISD::ArgFlagsTy flags, SDValue val, bool isfixed)
|
|
|
|
: Flags(flags), Val(val), IsFixed(isfixed) {
|
|
|
|
assert(Val.getValueType().isSimple() &&
|
|
|
|
"OutputArg value type must be Simple!");
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
2008-09-13 01:54:27 +00:00
|
|
|
|
2009-08-10 22:56:29 +00:00
|
|
|
/// VTSDNode - This class is used to represent EVT's, which are used
|
2005-07-10 00:07:11 +00:00
|
|
|
/// to parameterize some operations.
|
|
|
|
class VTSDNode : public SDNode {
|
2009-08-10 22:56:29 +00:00
|
|
|
EVT ValueType;
|
2005-07-10 00:07:11 +00:00
|
|
|
friend class SelectionDAG;
|
2009-08-10 22:56:29 +00:00
|
|
|
explicit VTSDNode(EVT VT)
|
2009-02-07 02:15:05 +00:00
|
|
|
: SDNode(ISD::VALUETYPE, DebugLoc::getUnknownLoc(),
|
2009-08-11 20:47:22 +00:00
|
|
|
getSDVTList(MVT::Other)), ValueType(VT) {
|
2007-02-04 07:28:00 +00:00
|
|
|
}
|
2005-07-10 00:07:11 +00:00
|
|
|
public:
|
|
|
|
|
2009-08-10 22:56:29 +00:00
|
|
|
EVT getVT() const { return ValueType; }
|
2005-07-10 00:07:11 +00:00
|
|
|
|
|
|
|
static bool classof(const VTSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
|
|
|
return N->getOpcode() == ISD::VALUETYPE;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2008-01-11 02:53:15 +00:00
|
|
|
/// LSBaseSDNode - Base class for LoadSDNode and StoreSDNode
|
|
|
|
///
|
2008-06-25 08:15:39 +00:00
|
|
|
class LSBaseSDNode : public MemSDNode {
|
2008-01-11 02:53:15 +00:00
|
|
|
//! Operand array for load and store
|
|
|
|
/*!
|
|
|
|
\note Moving this array to the base class captures more
|
|
|
|
common functionality shared between LoadSDNode and
|
|
|
|
StoreSDNode
|
|
|
|
*/
|
2008-04-16 16:15:27 +00:00
|
|
|
SDUse Ops[4];
|
2008-01-11 02:53:15 +00:00
|
|
|
public:
|
2009-02-05 21:34:56 +00:00
|
|
|
LSBaseSDNode(ISD::NodeType NodeTy, DebugLoc dl, SDValue *Operands,
|
|
|
|
unsigned numOperands, SDVTList VTs, ISD::MemIndexedMode AM,
|
2009-09-25 20:36:54 +00:00
|
|
|
EVT MemVT, MachineMemOperand *MMO)
|
|
|
|
: MemSDNode(NodeTy, dl, VTs, MemVT, MMO) {
|
2009-02-03 00:08:45 +00:00
|
|
|
SubclassData |= AM << 2;
|
|
|
|
assert(getAddressingMode() == AM && "MemIndexedMode encoding error!");
|
|
|
|
InitOperands(Ops, Operands, numOperands);
|
2009-01-28 21:18:29 +00:00
|
|
|
assert((getOffset().getOpcode() == ISD::UNDEF || isIndexed()) &&
|
|
|
|
"Only indexed loads and stores have a non-undef offset operand");
|
|
|
|
}
|
2008-01-11 02:53:15 +00:00
|
|
|
|
2008-07-27 21:46:04 +00:00
|
|
|
const SDValue &getOffset() const {
|
2008-02-25 19:31:21 +00:00
|
|
|
return getOperand(getOpcode() == ISD::LOAD ? 2 : 3);
|
|
|
|
}
|
2008-01-11 02:53:15 +00:00
|
|
|
|
2008-07-10 21:44:59 +00:00
|
|
|
/// getAddressingMode - Return the addressing mode for this load or store:
|
|
|
|
/// unindexed, pre-inc, pre-dec, post-inc, or post-dec.
|
|
|
|
ISD::MemIndexedMode getAddressingMode() const {
|
2009-02-03 00:08:45 +00:00
|
|
|
return ISD::MemIndexedMode((SubclassData >> 2) & 7);
|
2008-07-10 21:44:59 +00:00
|
|
|
}
|
2008-01-30 00:15:11 +00:00
|
|
|
|
|
|
|
/// isIndexed - Return true if this is a pre/post inc/dec load/store.
|
2008-07-10 21:44:59 +00:00
|
|
|
bool isIndexed() const { return getAddressingMode() != ISD::UNINDEXED; }
|
2008-01-30 00:15:11 +00:00
|
|
|
|
|
|
|
/// isUnindexed - Return true if this is NOT a pre/post inc/dec load/store.
|
2008-07-10 21:44:59 +00:00
|
|
|
bool isUnindexed() const { return getAddressingMode() == ISD::UNINDEXED; }
|
2008-01-30 00:15:11 +00:00
|
|
|
|
2008-05-19 20:15:12 +00:00
|
|
|
static bool classof(const LSBaseSDNode *) { return true; }
|
2008-01-30 00:15:11 +00:00
|
|
|
static bool classof(const SDNode *N) {
|
|
|
|
return N->getOpcode() == ISD::LOAD ||
|
|
|
|
N->getOpcode() == ISD::STORE;
|
|
|
|
}
|
2008-01-11 02:53:15 +00:00
|
|
|
};
|
|
|
|
|
2006-10-09 20:55:20 +00:00
|
|
|
/// LoadSDNode - This class is used to represent ISD::LOAD nodes.
|
|
|
|
///
|
2008-01-11 02:53:15 +00:00
|
|
|
class LoadSDNode : public LSBaseSDNode {
|
2006-10-09 20:55:20 +00:00
|
|
|
friend class SelectionDAG;
|
2009-01-28 21:18:29 +00:00
|
|
|
LoadSDNode(SDValue *ChainPtrOff, DebugLoc dl, SDVTList VTs,
|
2009-09-25 20:36:54 +00:00
|
|
|
ISD::MemIndexedMode AM, ISD::LoadExtType ETy, EVT MemVT,
|
|
|
|
MachineMemOperand *MMO)
|
2009-01-28 21:18:29 +00:00
|
|
|
: LSBaseSDNode(ISD::LOAD, dl, ChainPtrOff, 3,
|
2009-09-25 20:36:54 +00:00
|
|
|
VTs, AM, MemVT, MMO) {
|
2009-02-03 00:08:45 +00:00
|
|
|
SubclassData |= (unsigned short)ETy;
|
|
|
|
assert(getExtensionType() == ETy && "LoadExtType encoding error!");
|
2009-09-25 20:36:54 +00:00
|
|
|
assert(readMem() && "Load MachineMemOperand is not a load!");
|
|
|
|
assert(!writeMem() && "Load MachineMemOperand is a store!");
|
2009-01-28 21:18:29 +00:00
|
|
|
}
|
2006-10-09 20:55:20 +00:00
|
|
|
public:
|
|
|
|
|
2008-07-10 21:44:59 +00:00
|
|
|
/// getExtensionType - Return whether this is a plain node,
|
|
|
|
/// or one of the varieties of value-extending loads.
|
|
|
|
ISD::LoadExtType getExtensionType() const {
|
2009-02-03 00:08:45 +00:00
|
|
|
return ISD::LoadExtType(SubclassData & 3);
|
2008-07-10 21:44:59 +00:00
|
|
|
}
|
|
|
|
|
2008-07-27 21:46:04 +00:00
|
|
|
const SDValue &getBasePtr() const { return getOperand(1); }
|
|
|
|
const SDValue &getOffset() const { return getOperand(2); }
|
2009-02-05 21:34:56 +00:00
|
|
|
|
2006-10-09 20:55:20 +00:00
|
|
|
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.
|
|
|
|
///
|
2008-01-11 02:53:15 +00:00
|
|
|
class StoreSDNode : public LSBaseSDNode {
|
2006-10-09 20:55:20 +00:00
|
|
|
friend class SelectionDAG;
|
2009-01-28 21:18:29 +00:00
|
|
|
StoreSDNode(SDValue *ChainValuePtrOff, DebugLoc dl, SDVTList VTs,
|
2009-09-25 20:36:54 +00:00
|
|
|
ISD::MemIndexedMode AM, bool isTrunc, EVT MemVT,
|
|
|
|
MachineMemOperand *MMO)
|
2009-01-28 21:18:29 +00:00
|
|
|
: LSBaseSDNode(ISD::STORE, dl, ChainValuePtrOff, 4,
|
2009-09-25 20:36:54 +00:00
|
|
|
VTs, AM, MemVT, MMO) {
|
2009-02-03 00:08:45 +00:00
|
|
|
SubclassData |= (unsigned short)isTrunc;
|
|
|
|
assert(isTruncatingStore() == isTrunc && "isTrunc encoding error!");
|
2009-09-25 20:36:54 +00:00
|
|
|
assert(!readMem() && "Store MachineMemOperand is a load!");
|
|
|
|
assert(writeMem() && "Store MachineMemOperand is not a store!");
|
2009-01-28 21:18:29 +00:00
|
|
|
}
|
2006-10-09 20:55:20 +00:00
|
|
|
public:
|
|
|
|
|
2008-07-10 21:44:59 +00:00
|
|
|
/// isTruncatingStore - Return true if the op does a truncation before store.
|
|
|
|
/// For integers this is the same as doing a TRUNCATE and storing the result.
|
|
|
|
/// For floats, it is the same as doing an FP_ROUND and storing the result.
|
2009-02-03 00:08:45 +00:00
|
|
|
bool isTruncatingStore() const { return SubclassData & 1; }
|
2008-07-10 21:44:59 +00:00
|
|
|
|
2008-07-27 21:46:04 +00:00
|
|
|
const SDValue &getValue() const { return getOperand(1); }
|
|
|
|
const SDValue &getBasePtr() const { return getOperand(2); }
|
|
|
|
const SDValue &getOffset() const { return getOperand(3); }
|
2009-02-05 21:34:56 +00:00
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2009-09-25 20:36:54 +00:00
|
|
|
/// MachineSDNode - An SDNode that represents everything that will be needed
|
|
|
|
/// to construct a MachineInstr. These nodes are created during the
|
|
|
|
/// instruction selection proper phase.
|
|
|
|
///
|
|
|
|
class MachineSDNode : public SDNode {
|
|
|
|
public:
|
|
|
|
typedef MachineMemOperand **mmo_iterator;
|
|
|
|
|
|
|
|
private:
|
|
|
|
friend class SelectionDAG;
|
|
|
|
MachineSDNode(unsigned Opc, const DebugLoc DL, SDVTList VTs)
|
|
|
|
: SDNode(Opc, DL, VTs), MemRefs(0), MemRefsEnd(0) {}
|
|
|
|
|
|
|
|
/// LocalOperands - Operands for this instruction, if they fit here. If
|
|
|
|
/// they don't, this field is unused.
|
|
|
|
SDUse LocalOperands[4];
|
|
|
|
|
|
|
|
/// MemRefs - Memory reference descriptions for this instruction.
|
|
|
|
mmo_iterator MemRefs;
|
|
|
|
mmo_iterator MemRefsEnd;
|
|
|
|
|
|
|
|
public:
|
|
|
|
mmo_iterator memoperands_begin() const { return MemRefs; }
|
|
|
|
mmo_iterator memoperands_end() const { return MemRefsEnd; }
|
|
|
|
bool memoperands_empty() const { return MemRefsEnd == MemRefs; }
|
|
|
|
|
|
|
|
/// setMemRefs - Assign this MachineSDNodes's memory reference descriptor
|
|
|
|
/// list. This does not transfer ownership.
|
|
|
|
void setMemRefs(mmo_iterator NewMemRefs, mmo_iterator NewMemRefsEnd) {
|
|
|
|
MemRefs = NewMemRefs;
|
|
|
|
MemRefsEnd = NewMemRefsEnd;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool classof(const MachineSDNode *) { return true; }
|
|
|
|
static bool classof(const SDNode *N) {
|
|
|
|
return N->isMachineOpcode();
|
|
|
|
}
|
|
|
|
};
|
2005-07-10 00:07:11 +00:00
|
|
|
|
2009-08-27 23:44:33 +00:00
|
|
|
class SDNodeIterator : public std::iterator<std::forward_iterator_tag,
|
|
|
|
SDNode, ptrdiff_t> {
|
2005-01-10 23:05:53 +00:00
|
|
|
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 {
|
2008-08-28 21:40:38 +00:00
|
|
|
return Node->getOperand(Operand).getNode();
|
2005-01-10 23:05:53 +00:00
|
|
|
}
|
|
|
|
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
|
|
|
}
|
2009-12-01 19:20:00 +00:00
|
|
|
size_t operator-(SDNodeIterator Other) const {
|
|
|
|
assert(Node == Other.Node &&
|
|
|
|
"Cannot compare iterators of two different nodes!");
|
|
|
|
return Operand - Other.Operand;
|
|
|
|
}
|
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);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2008-07-07 23:02:41 +00:00
|
|
|
/// LargestSDNode - The largest SDNode class.
|
|
|
|
///
|
|
|
|
typedef LoadSDNode LargestSDNode;
|
|
|
|
|
2008-07-28 21:51:04 +00:00
|
|
|
/// MostAlignedSDNode - The SDNode class with the greatest alignment
|
|
|
|
/// requirement.
|
|
|
|
///
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@78142 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-05 01:29:28 +00:00
|
|
|
typedef GlobalAddressSDNode MostAlignedSDNode;
|
2005-11-09 23:46:43 +00:00
|
|
|
|
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) {
|
2008-06-20 18:34:30 +00:00
|
|
|
const LoadSDNode *Ld = dyn_cast<LoadSDNode>(N);
|
|
|
|
return Ld && Ld->getExtensionType() == ISD::NON_EXTLOAD &&
|
2007-10-06 08:09:29 +00:00
|
|
|
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) {
|
2008-06-20 18:34:30 +00:00
|
|
|
return isa<LoadSDNode>(N) &&
|
2006-10-09 20:55:20 +00:00
|
|
|
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) {
|
2008-06-20 18:34:30 +00:00
|
|
|
return isa<LoadSDNode>(N) &&
|
2006-10-09 20:55:20 +00:00
|
|
|
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) {
|
2008-06-20 18:34:30 +00:00
|
|
|
return isa<LoadSDNode>(N) &&
|
2006-10-09 20:55:20 +00:00
|
|
|
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) {
|
2008-06-20 18:34:30 +00:00
|
|
|
return isa<LoadSDNode>(N) &&
|
2006-10-09 20:55:20 +00:00
|
|
|
cast<LoadSDNode>(N)->getExtensionType() == ISD::ZEXTLOAD;
|
2006-10-04 00:56:09 +00:00
|
|
|
}
|
2006-10-13 21:14:26 +00:00
|
|
|
|
2008-06-20 18:34:30 +00:00
|
|
|
/// isUNINDEXEDLoad - Returns true if the specified node is an unindexed load.
|
2007-03-07 08:04:41 +00:00
|
|
|
///
|
|
|
|
inline bool isUNINDEXEDLoad(const SDNode *N) {
|
2008-06-20 18:34:30 +00:00
|
|
|
return isa<LoadSDNode>(N) &&
|
2007-03-07 08:04:41 +00:00
|
|
|
cast<LoadSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
|
|
|
|
}
|
|
|
|
|
2008-06-20 18:34:30 +00:00
|
|
|
/// isNormalStore - Returns true if the specified node is a non-truncating
|
|
|
|
/// and unindexed store.
|
|
|
|
inline bool isNormalStore(const SDNode *N) {
|
|
|
|
const StoreSDNode *St = dyn_cast<StoreSDNode>(N);
|
|
|
|
return St && !St->isTruncatingStore() &&
|
|
|
|
St->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) {
|
2008-06-20 18:34:30 +00:00
|
|
|
return isa<StoreSDNode>(N) && !cast<StoreSDNode>(N)->isTruncatingStore();
|
2006-10-13 21:14:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// isTRUNCStore - Returns true if the specified node is a truncating
|
|
|
|
/// store.
|
|
|
|
inline bool isTRUNCStore(const SDNode *N) {
|
2008-06-20 18:34:30 +00:00
|
|
|
return isa<StoreSDNode>(N) && cast<StoreSDNode>(N)->isTruncatingStore();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// isUNINDEXEDStore - Returns true if the specified node is an
|
|
|
|
/// unindexed store.
|
|
|
|
inline bool isUNINDEXEDStore(const SDNode *N) {
|
|
|
|
return isa<StoreSDNode>(N) &&
|
|
|
|
cast<StoreSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
|
2006-10-13 21:14:26 +00:00
|
|
|
}
|
2006-10-04 00:56:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-01-07 07:45:27 +00:00
|
|
|
} // end llvm namespace
|
|
|
|
|
|
|
|
#endif
|