llvm::StoreSDNode

This class is used to represent ISD::STORE nodes.

Synopsis

Declared in <llvm/CodeGen/SelectionDAGNodes.h>

class StoreSDNode
    : public LSBaseSDNode

Base Classes

Name

Description

LSBaseSDNode

Base class for LoadSDNode and StoreSDNode

Types

Name

Description

use_iterator

This class provides iterator support for SDUse operands that use a specific SDNode.

user_iterator

value_op_iterator

Iterator for directly iterating over the operand SDValue's.

Type Aliases

Name

op_iterator

value_iterator

Member Functions

Name

Description

Profile

Gather unique data for the node.

addUse

This method should only be used by the SDUse class.

dump overloads

dumpr overloads

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.

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.

getAAInfo

Returns the AA info that describes the dereference.

getAddressSpace

Return the address space for the associated pointer

getAddressingMode

Return the addressing mode for this load or store: unindexed, pre‐inc, pre‐dec, post‐inc, or post‐dec.

getAlign

getAsAPIntVal

Helper method returns the APInt value of a ConstantSDNode.

getAsZExtVal

Helper method returns the zero‐extended integer value of a ConstantSDNode.

getBaseAlign

Returns alignment and volatility of the memory access

getBasePtr

getCFIType

getChain

getCombinerWorklistIndex

Get worklist index for DAGCombiner

getConstantOperandAPInt

Helper method returns the APInt of a ConstantSDNode operand.

getConstantOperandVal

Helper method returns the integer value of a ConstantSDNode operand.

getDebugLoc

Return the source location info.

getFlags

getGluedNode

If this node has a glue operand, return the node to which the glue operand points. Otherwise return NULL.

getGluedUser

If this node has a glue value with a user, return the user (there is at most one). Otherwise return NULL.

getHasDebugValue

getIROrder

Return the node ordering.

getMachineOpcode

This may only be called if isMachineOpcode returns true. It returns the MachineInstr opcode value that the node's opcode corresponds to.

getMemCacheHint

Returns the cache hint metadata for this memory access.

getMemOperand

Return the unique MachineMemOperand object describing the memory reference performed by operation. Asserts if multiple MMOs are present ‐ use memoperands() instead.

getMemoryVT

Return the type of the in‐memory value.

getMergedOrdering

Return a single atomic ordering that is at least as strong as both the success and failure orderings for an atomic operation. (For operations other than cmpxchg, this is equivalent to getSuccessOrdering().)

getNodeId

Return the unique node id.

getNumMemOperands

Return the number of memory operands.

getNumOperands

Return the number of values used by this operation.

getNumValues

Return the number of values defined/returned by this operator.

getOffset

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.

getOperand

getOperationName

Return the opcode of this operation for printing.

getPointerInfo

getRanges

Returns the Ranges that describes the dereference.

getRawSubclassData

Return the SubclassData value, without HasDebugValue. This contains an encoding of the volatile flag, as well as bits used by subclasses. This function should only be used to compute a FoldingSetNodeID value. The HasDebugValue bit is masked out because CSE map needs to match nodes with debug info with nodes without debug info. Same is about isDivergent bit.

getSchedulerWorklistVisited

Get visited state for ScheduleDAGSDNodes::BuildSchedUnits.

getSimpleValueType

Return the type of a specified result as a simple type.

getSrcValueOffset

getSuccessOrdering

Return the atomic ordering requirements for this memory operation. For cmpxchg atomic operations, return the atomic ordering requirements when store occurs.

getSyncScopeID

Returns the synchronization scope ID for this memory operation.

getVTList

getValue

getValueSizeInBits

Returns MVT::getSizeInBits(getValueType(ResNo)).

getValueType

Return the type of a specified result.

hasAnyUseOfValue

Return true if there are any use of the indicated value. This method ignores uses of other values defined by this operation.

hasNUsesOfValue

Return true if there are exactly NUSES uses of the indicated value. This method ignores uses of other values defined by this operation.

hasOneUse

Return true if there is exactly one use of this node.

hasPoisonGeneratingFlags

hasPredecessor

Return true if N is a predecessor of this node. N is either an operand of this node, or can be reached by recursively traversing up the operands. NOTE: This is an expensive method. Use it carefully.

hasUniqueMemOperand

Return true if this node has exactly one memory operand.

intersectFlagsWith

Clear any flags in this node that aren't also set in Flags. If Flags is not in a defined state then this has no effect.

isAnyAdd

Returns true if the node type is ADD or PTRADD.

isAssert

Test if this node is an assert operation.

isAtomic

Return true if the memory operation ordering is Unordered or higher.

isDereferenceable

isDivergent

isIndexed

Return true if this is a pre/post inc/dec load/store.

isInvariant

isMachineOpcode

Test if this node has a post‐isel opcode, directly corresponding to a MachineInstr opcode.

isMemIntrinsic

Test if this node is a memory intrinsic (with valid pointer information).

isNonTemporal

isOnlyUserOf

Return true if this node is the only use of N.

isOperandOf

Return true if this node is an operand of N.

isPredecessorOf

Return true if this node is a predecessor of N. NOTE: Implemented on top of hasPredecessor and every bit as expensive. Use carefully.

isSimple

Returns true if the memory operation is neither atomic or volatile.

isStrictFPOpcode

Test if this node is a strict floating point pseudo‐op.

isTargetOpcode

Test if this node has a target‐specific opcode (in the <target>ISD namespace).

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.

isUndef

Returns true if the node type is UNDEF or POISON.

isUnindexed

Return true if this is NOT a pre/post inc/dec load/store.

isUnordered

Returns true if the memory operation doesn't imply any ordering constraints on surrounding memory operations beyond the normal memory aliasing rules.

isVPOpcode

Test if this node is a vector predication operation.

isVolatile

memoperands

Return the memory operands for this node.

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.

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.

readMem

refineAlignment

Update this MemSDNode's MachineMemOperand information to reflect the alignment of NewMMOs, if they have greater alignment. This must only be used when the new alignment applies to all users of these MachineMemOperands. The NewMMOs array must parallel memoperands().

refineMMOMetadata

Refine LLVM IR metadata for all MMOs. The NewMMOs array must parallel memoperands(). For each pair, if metadata differs, the stored metadata is cleared conservatively.

setCFIType

setCombinerWorklistIndex

Set worklist index for DAGCombiner

setDebugLoc

Set source location info. Try to avoid this, putting it in the constructor is preferable.

setFlags

setHasDebugValue

setIROrder

Set the node ordering.

setNodeId

Set unique node id.

setSchedulerWorklistVisited

Set visited state for ScheduleDAGSDNodes::BuildSchedUnits.

use_begin

Provide iteration support to walk over all uses of an SDNode.

use_empty

Return true if there are no uses of this node.

use_size

Return the number of uses of this node. This method takes time proportional to the number of uses.

user_begin

Provide iteration support to walk over all users of an SDNode.

Static Member Functions

Name

Description

areOnlyUsersOf

Return true if all the users of N are contained in Nodes. NOTE: Requires at least one match, but doesn't require them all.

classof

getIndexedModeName

getMaxNumOperands

Return the maximum number of operands that a SDNode can hold.

hasPredecessorHelper

Returns true if N is a predecessor of any node in Worklist. This helper keeps Visited and Worklist sets externally to allow unions searches to be performed in parallel, caching of results across queries and incremental addition to Worklist. Stops early if N is found but will resume. Remember to clear Visited and Worklists if DAG changes. MaxSteps gives a maximum number of nodes to visit before giving up. The TopologicalPrune flag signals that positive NodeIds are topologically ordered (Operands have strictly smaller node id) and search can be pruned leveraging this.

use_end

user_end

Data Members

Name

Description

CombinerWorklistIndex [variant member]

Index in worklist of DAGCombiner, or negative if the node is not in the worklist. ‐1 = not in worklist; ‐2 = not in worklist, but has already been combined at least once.

ConstantSDNodeBits [variant member]

LSBaseSDNodeBits [variant member]

LoadSDNodeBits [variant member]

MemSDNodeBits [variant member]

PersistentId

Unique and persistent id per SDNode in the DAG. Used for debug printing. We do not place that under #if LLVM_ENABLE_ABI_BREAKING_CHECKS intentionally because it adds unneeded complexity without noticeable benefits (see discussion with thakis in D120714). Currently, there are two padding bytes after this field.

RawSDNodeBits [variant member]

SDNodeBits [variant member]

SchedulerWorklistVisited [variant member]

Visited state in ScheduleDAGSDNodes::BuildSchedUnits.

StoreSDNodeBits [variant member]

Protected Types

Name

Unnamed union

ConstantSDNodeBitfields

LSBaseSDNodeBitfields

LoadSDNodeBitfields

MemSDNodeBitfields

SDNodeBitfields

StoreSDNodeBitfields

Protected Enums

Name

Unnamed enum

Protected Member Functions

Name

Description

DropOperands

Release the operands and set this node to have zero operands.

Protected Static Member Functions

Name

getSDVTList

Protected Data Members

Name

Description

MemRefs

Memory reference information. Must always have at least one MMO. ‐ MachineMemOperand*: exactly 1 MMO (common case) ‐ MachineMemOperand**: pointer to array, size at offset ‐1

Friends

Name

Description

llvm::SelectionDAG

This is used to represent a portion of an LLVM function in a low‐level Data Dependence DAG representation suitable for instruction selection. This DAG is constructed as the first step of instruction selection in order to allow implementation of machine specific optimizations and code simplifications.

Non-Member Functions

Name

Description

ISD::allOperandsUndef

Return true if the node has at least one operand and all operands of the specified node are ISD::UNDEF.

ISD::isBuildVectorAllOnes

Return true if the specified node is a BUILD_VECTOR where all of the elements are ~0 or undef.

ISD::isBuildVectorAllZeros

Return true if the specified node is a BUILD_VECTOR where all of the elements are 0 or undef.

ISD::isBuildVectorOfConstantFPSDNodes

Return true if the specified node is a BUILD_VECTOR node of all ConstantFPSDNode or undef.

ISD::isBuildVectorOfConstantSDNodes

Return true if the specified node is a BUILD_VECTOR node of all ConstantSDNode or undef.

ISD::isConstantSplatVector

If N is a BUILD_VECTOR or SPLAT_VECTOR node whose elements are all the same constant or undefined, return true and return the constant value in SplatValue.

ISD::isConstantSplatVectorAllOnes

Return true if the specified node is a BUILD_VECTOR or SPLAT_VECTOR where all of the elements are ~0 or undef. If BuildVectorOnly is set to true, it only checks BUILD_VECTOR.

ISD::isConstantSplatVectorAllZeros

Return true if the specified node is a BUILD_VECTOR or SPLAT_VECTOR where all of the elements are 0 or undef. If BuildVectorOnly is set to true, it only checks BUILD_VECTOR.

ISD::isEXTLoad

Returns true if the specified node is a EXTLOAD.

ISD::isFreezeUndef

Return true if the specified node is FREEZE(UNDEF).

ISD::isNON_EXTLoad

Returns true if the specified node is a non‐extending load.

ISD::isNormalLoad

Returns true if the specified node is a non‐extending and unindexed load.

ISD::isNormalMaskedLoad

Returns true if the specified node is a non‐extending and unindexed masked load.

ISD::isNormalMaskedStore

Returns true if the specified node is a non‐extending and unindexed masked store.