llvm::LSBaseSDNode

Synopsis

Declared in <llvm/CodeGen/SelectionDAGNodes.h>

class LSBaseSDNode
    : public MemSDNode

Base Classes

Name	Description
`MemSDNode`	This is an abstract virtual class for memory operations.

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
`LSBaseSDNode` [constructor]
`Profile`	Gather unique data for the node.
`addUse`	This method should only be used by the SDUse class.
`bitcastToAPInt`
`dropFlags`
`dump`	`dump` overloads
`dumpr`	`dumpr` overloads
`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.
`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`
`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).
`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.
`op_begin`
`op_end`
`op_values`
`ops`
`print`
`print_details`
`print_types`
`printr`
`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.
`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.
`users`
`uses`
`value_begin`
`value_end`
`values`
`writeMem`

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

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.
`ISD::isNormalStore`	Returns true if the specified node is a non-truncating and unindexed store.
`ISD::isSEXTLoad`	Returns true if the specified node is a SEXTLOAD.
`ISD::isUNINDEXEDLoad`	Returns true if the specified node is an unindexed load.
`ISD::isUNINDEXEDStore`	Returns true if the specified node is an unindexed store.
`ISD::isVectorShrinkable`	Returns true if the specified node is a vector where all elements can be truncated to the specified element size without a loss in meaning.
`ISD::isZEXTLoad`	Returns true if the specified node is a ZEXTLOAD.

Derived Classes

Name	Description
`LoadSDNode`	This class is used to represent ISD::LOAD nodes.
`StoreSDNode`	This class is used to represent ISD::STORE nodes.