[#llvm-FPStateAccessSDNode]
= xref:llvm.adoc[llvm]::FPStateAccessSDNode
:relfileprefix: ../
:mrdocs:

SDNode for get/set FP environment memory accesses.

== Synopsis

Declared in `<llvm/CodeGen/SelectionDAGNodes.h>`

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
class FPStateAccessSDNode
    : public xref:llvm/MemSDNode.adoc[MemSDNode]
----

== Base Classes

[cols="1,4"]
|===
| Name| Description
| `xref:llvm/MemSDNode.adoc[MemSDNode]`
| This is an abstract virtual class for memory operations.
|===

== Types

[cols="1,4"]
|===
| Name| Description
| xref:llvm/SDNode/use_iterator.adoc[`use_iterator`] 
| Iterator over SDUse operands that use a specific SDNode.
| xref:llvm/SDNode/user_iterator.adoc[`user_iterator`] 
| Iterator over SDNodes that use a specific SDNode.
| xref:llvm/SDNode/value_op_iterator.adoc[`value_op_iterator`] 
| Iterator for directly iterating over the operand SDValue's.
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:llvm/SDNode/op_iterator.adoc[`op_iterator`] 
| Iterator type over this node's SDUse operands.
| xref:llvm/SDNode/value_iterator.adoc[`value_iterator`] 
| Iterator type over this node's result value types.
|===


== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/FPStateAccessSDNode/2constructor.adoc[`FPStateAccessSDNode`]         [.small]#[constructor]#
| Construct an FP environment memory access node.
| xref:llvm/SDNode/Profile.adoc[`Profile`] 
| Gather unique data for the node into folding‐set id `ID.`
| xref:llvm/SDNode/addUse.adoc[`addUse`] 
| Add use `U` to this node's use list (SDUse only).
| xref:llvm/SDNode/bitcastToAPInt.adoc[`bitcastToAPInt`] 
| Bitcast a constant integer or FP node to an APInt when possible.
| xref:llvm/SDNode/dropFlags.adoc[`dropFlags`] 
| Clear flag bits set in `Mask.`
| xref:llvm/MemSDNode/dump.adoc[`dump`] 
| `dump` overloads
| xref:llvm/MemSDNode/dumpr.adoc[`dumpr`] 
| `dumpr` overloads
| xref:llvm/SDNode/dumprFull.adoc[`dumprFull`] 
| Dump the full recursive print of this node to dbgs().
| xref:llvm/SDNode/dumprWithDepth.adoc[`dumprWithDepth`] 
| Dump a depth‐limited recursive print of this node to dbgs().
| xref:llvm/MemSDNode/getAAInfo.adoc[`getAAInfo`] 
| Returns the AA info that describes the dereference.
| xref:llvm/MemSDNode/getAddressSpace.adoc[`getAddressSpace`] 
| Return the address space for the associated pointer
| xref:llvm/MemSDNode/getAlign.adoc[`getAlign`] 
| Return the alignment of the memory access.
| xref:llvm/SDNode/getAsAPIntVal.adoc[`getAsAPIntVal`] 
| Helper method returns the APInt value of a ConstantSDNode.
| xref:llvm/SDNode/getAsZExtVal.adoc[`getAsZExtVal`] 
| Helper method returns the zero‐extended integer value of a ConstantSDNode.
| xref:llvm/MemSDNode/getBaseAlign.adoc[`getBaseAlign`] 
| Return the base alignment of the memory access.
| xref:llvm/MemSDNode/getBasePtr.adoc[`getBasePtr`] 
| Return the base pointer operand.
| xref:llvm/SDNode/getCFIType.adoc[`getCFIType`] 
| Return the CFI type identifier for this node.
| xref:llvm/MemSDNode/getChain.adoc[`getChain`] 
| Return the chain operand.
| xref:llvm/SDNode/getCombinerWorklistIndex.adoc[`getCombinerWorklistIndex`] 
| Get worklist index for DAGCombiner
| xref:llvm/SDNode/getConstantOperandAPInt.adoc[`getConstantOperandAPInt`] 
| Helper method returns the APInt of a ConstantSDNode operand.
| xref:llvm/SDNode/getConstantOperandVal.adoc[`getConstantOperandVal`] 
| Helper method returns the integer value of a ConstantSDNode operand.
| xref:llvm/SDNode/getDebugLoc.adoc[`getDebugLoc`] 
| Return the source location info.
| xref:llvm/SDNode/getFlags.adoc[`getFlags`] 
| Return the optimization flags attached to this node.
| xref:llvm/SDNode/getGluedNode.adoc[`getGluedNode`] 
| If this node has a glue operand, return the node to which the glue operand points. Otherwise return NULL.
| xref:llvm/SDNode/getGluedUser.adoc[`getGluedUser`] 
| If this node has a glue value with a user, return the user (there is at most one). Otherwise return NULL.
| xref:llvm/SDNode/getHasDebugValue.adoc[`getHasDebugValue`] 
| Return true if this node has an associated debug value.
| xref:llvm/SDNode/getIROrder.adoc[`getIROrder`] 
| Return the node ordering.
| xref:llvm/SDNode/getMachineOpcode.adoc[`getMachineOpcode`] 
| This may only be called if isMachineOpcode returns true. It returns the MachineInstr opcode value that the node's opcode corresponds to.
| xref:llvm/MemSDNode/getMemCacheHint.adoc[`getMemCacheHint`] 
| Returns the cache hint metadata for this memory access.
| xref:llvm/MemSDNode/getMemOperand.adoc[`getMemOperand`] 
| Return the unique MachineMemOperand for this memory operation.
| xref:llvm/MemSDNode/getMemoryVT.adoc[`getMemoryVT`] 
| Return the type of the in‐memory value.
| xref:llvm/MemSDNode/getMergedOrdering.adoc[`getMergedOrdering`] 
| Return a single atomic ordering at least as strong as success and failure.
| xref:llvm/SDNode/getNodeId.adoc[`getNodeId`] 
| Return the unique node id.
| xref:llvm/MemSDNode/getNumMemOperands.adoc[`getNumMemOperands`] 
| Return the number of memory operands.
| xref:llvm/SDNode/getNumOperands.adoc[`getNumOperands`] 
| Return the number of values used by this operation.
| xref:llvm/SDNode/getNumValues.adoc[`getNumValues`] 
| Return the number of values defined/returned by this operator.
| xref:llvm/SDNode/getOpcode.adoc[`getOpcode`] 
| Return the SelectionDAG opcode value for this node.
| xref:llvm/SDNode/getOperand.adoc[`getOperand`] 
| Return operand `Num` of this node.
| xref:llvm/SDNode/getOperationName.adoc[`getOperationName`] 
| Return the opcode of this operation for printing.
| xref:llvm/MemSDNode/getPointerInfo.adoc[`getPointerInfo`] 
| Return pointer info for the memory operand.
| xref:llvm/MemSDNode/getRanges.adoc[`getRanges`] 
| Returns the Ranges that describes the dereference.
| xref:llvm/MemSDNode/getRawSubclassData.adoc[`getRawSubclassData`] 
| Return SubclassData bits with HasDebugValue cleared.
| xref:llvm/SDNode/getSchedulerWorklistVisited.adoc[`getSchedulerWorklistVisited`] 
| Get visited state for ScheduleDAGSDNodes::BuildSchedUnits.
| xref:llvm/SDNode/getSimpleValueType.adoc[`getSimpleValueType`] 
| Return the type of a specified result as a simple type.
| xref:llvm/MemSDNode/getSrcValueOffset.adoc[`getSrcValueOffset`] 
| Return the offset from the location of the access.
| xref:llvm/MemSDNode/getSuccessOrdering.adoc[`getSuccessOrdering`] 
| Return the atomic ordering requirements for this memory operation. For cmpxchg atomic operations, return the atomic ordering requirements when store occurs.
| xref:llvm/MemSDNode/getSyncScopeID.adoc[`getSyncScopeID`] 
| Returns the synchronization scope ID for this memory operation.
| xref:llvm/SDNode/getVTList.adoc[`getVTList`] 
| Return the SDVTList describing this node's result types.
| xref:llvm/SDNode/getValueSizeInBits.adoc[`getValueSizeInBits`] 
| Return the size in bits of result `ResNo.`
| xref:llvm/SDNode/getValueType.adoc[`getValueType`] 
| Return the type of a specified result.
| xref:llvm/SDNode/hasAnyUseOfValue.adoc[`hasAnyUseOfValue`] 
| Return true if there are any use of the indicated value. This method ignores uses of other values defined by this operation.
| xref:llvm/SDNode/hasNUsesOfValue.adoc[`hasNUsesOfValue`] 
| Return true if there are exactly NUSES uses of the indicated value. This method ignores uses of other values defined by this operation.
| xref:llvm/SDNode/hasOneUse.adoc[`hasOneUse`] 
| Return true if there is exactly one use of this node.
| xref:llvm/SDNode/hasPoisonGeneratingFlags.adoc[`hasPoisonGeneratingFlags`] 
| Return true if any poison‐generating flag is set.
| xref:llvm/SDNode/hasPredecessor.adoc[`hasPredecessor`] 
| Return true if N is a predecessor of this node.
| xref:llvm/MemSDNode/hasUniqueMemOperand.adoc[`hasUniqueMemOperand`] 
| Return true if this node has exactly one memory operand.
| xref:llvm/SDNode/intersectFlagsWith.adoc[`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.
| xref:llvm/SDNode/isAnyAdd.adoc[`isAnyAdd`] 
| Returns true if the node type is ADD or PTRADD.
| xref:llvm/SDNode/isAssert.adoc[`isAssert`] 
| Test if this node is an assert operation.
| xref:llvm/MemSDNode/isAtomic.adoc[`isAtomic`] 
| Return true if the memory operation ordering is Unordered or higher.
| xref:llvm/MemSDNode/isDereferenceable.adoc[`isDereferenceable`] 
| Return true if the memory access is dereferenceable.
| xref:llvm/SDNode/isDivergent.adoc[`isDivergent`] 
| Return true if this node is divergent.
| xref:llvm/MemSDNode/isInvariant.adoc[`isInvariant`] 
| Return true if the memory access is invariant.
| xref:llvm/SDNode/isMachineOpcode.adoc[`isMachineOpcode`] 
| Test if this node has a post‐isel opcode, directly corresponding to a MachineInstr opcode.
| xref:llvm/SDNode/isMemIntrinsic.adoc[`isMemIntrinsic`] 
| Test if this node is a memory intrinsic (with valid pointer information).
| xref:llvm/MemSDNode/isNonTemporal.adoc[`isNonTemporal`] 
| Return true if the memory access is non‐temporal.
| xref:llvm/SDNode/isOnlyUserOf.adoc[`isOnlyUserOf`] 
| Return true if this node is the only use of N.
| xref:llvm/SDNode/isOperandOf.adoc[`isOperandOf`] 
| Return true if this node is an operand of N.
| xref:llvm/SDNode/isPredecessorOf.adoc[`isPredecessorOf`] 
| Return true if this node is a predecessor of N. NOTE: Implemented on top of hasPredecessor and every bit as expensive. Use carefully.
| xref:llvm/MemSDNode/isSimple.adoc[`isSimple`] 
| Returns true if the memory operation is neither atomic or volatile.
| xref:llvm/SDNode/isStrictFPOpcode.adoc[`isStrictFPOpcode`] 
| Test if this node is a strict floating point pseudo‐op.
| xref:llvm/SDNode/isTargetOpcode.adoc[`isTargetOpcode`] 
| Test if this node has a target‐specific opcode (in the <target>ISD namespace).
| xref:llvm/SDNode/isUndef.adoc[`isUndef`] 
| Returns true if the node type is UNDEF or POISON.
| xref:llvm/MemSDNode/isUnordered.adoc[`isUnordered`] 
| Returns true if the memory operation doesn't imply any ordering constraints on surrounding memory operations beyond the normal memory aliasing rules.
| xref:llvm/SDNode/isVPOpcode.adoc[`isVPOpcode`] 
| Test if this node is a vector predication operation.
| xref:llvm/MemSDNode/isVolatile.adoc[`isVolatile`] 
| Return true if the memory access is volatile.
| xref:llvm/MemSDNode/memoperands.adoc[`memoperands`] 
| Return the memory operands for this node.
| xref:llvm/SDNode/op_begin.adoc[`op_begin`] 
| Return an iterator to the first operand.
| xref:llvm/SDNode/op_end.adoc[`op_end`] 
| Return an iterator past the last operand.
| xref:llvm/SDNode/op_values.adoc[`op_values`] 
| Return a range over operand SDValues.
| xref:llvm/SDNode/ops.adoc[`ops`] 
| Return this node's operands as an ArrayRef of SDUse.
| xref:llvm/SDNode/print.adoc[`print`] 
| Print this node to `OS.`
| xref:llvm/SDNode/print_details.adoc[`print_details`] 
| Print this node's details to `OS.`
| xref:llvm/SDNode/print_types.adoc[`print_types`] 
| Print this node's result types to `OS.`
| xref:llvm/SDNode/printr.adoc[`printr`] 
| Print this node recursively to `OS.`
| xref:llvm/SDNode/printrFull.adoc[`printrFull`] 
| Print this node and all children down to the leaves.
| xref:llvm/SDNode/printrWithDepth.adoc[`printrWithDepth`] 
| Print this node and children up to depth `depth.`
| xref:llvm/MemSDNode/readMem.adoc[`readMem`] 
| Return true if this memory operation reads memory.
| xref:llvm/MemSDNode/refineAlignment-00.adoc[`refineAlignment`] 
| `refineAlignment` overloads
| xref:llvm/MemSDNode/refineMMOMetadata-08.adoc[`refineMMOMetadata`] 
| `refineMMOMetadata` overloads
| xref:llvm/SDNode/setCFIType.adoc[`setCFIType`] 
| Set the CFI type identifier for this node.
| xref:llvm/SDNode/setCombinerWorklistIndex.adoc[`setCombinerWorklistIndex`] 
| Set worklist index for DAGCombiner.
| xref:llvm/SDNode/setDebugLoc.adoc[`setDebugLoc`] 
| Set source location info. Try to avoid this, putting it in the constructor is preferable.
| xref:llvm/SDNode/setFlags.adoc[`setFlags`] 
| Replace this node's optimization flags.
| xref:llvm/SDNode/setHasDebugValue.adoc[`setHasDebugValue`] 
| Set whether this node has an associated debug value.
| xref:llvm/SDNode/setIROrder.adoc[`setIROrder`] 
| Set the node ordering.
| xref:llvm/SDNode/setNodeId.adoc[`setNodeId`] 
| Set unique node id.
| xref:llvm/SDNode/setSchedulerWorklistVisited.adoc[`setSchedulerWorklistVisited`] 
| Set visited state for ScheduleDAGSDNodes::BuildSchedUnits.
| xref:llvm/SDNode/use_begin.adoc[`use_begin`] 
| Provide iteration support to walk over all uses of an SDNode.
| xref:llvm/SDNode/use_empty.adoc[`use_empty`] 
| Return true if there are no uses of this node.
| xref:llvm/SDNode/use_size.adoc[`use_size`] 
| Return the number of uses of this node. This method takes time proportional to the number of uses.
| xref:llvm/SDNode/user_begin.adoc[`user_begin`] 
| Provide iteration support to walk over all users of an SDNode.
| xref:llvm/MemSDNode/users.adoc[`users`] 
| `users` overloads
| xref:llvm/MemSDNode/uses.adoc[`uses`] 
| `uses` overloads
| xref:llvm/SDNode/value_begin.adoc[`value_begin`] 
| Return an iterator to the first result value type.
| xref:llvm/SDNode/value_end.adoc[`value_end`] 
| Return an iterator past the last result value type.
| xref:llvm/SDNode/values.adoc[`values`] 
| Return a range over this node's result value types.
| xref:llvm/MemSDNode/writeMem.adoc[`writeMem`] 
| Return true if this memory operation writes memory.
|===


== Static Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/SDNode/areOnlyUsersOf.adoc[`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.
| xref:llvm/FPStateAccessSDNode/classof.adoc[`classof`] 
| Methods for support type inquiry through isa, cast, and dyn_cast.
| xref:llvm/SDNode/getIndexedModeName.adoc[`getIndexedModeName`] 
| Return a printable name for indexed mode `AM.`
| xref:llvm/SDNode/getMaxNumOperands.adoc[`getMaxNumOperands`] 
| Return the maximum number of operands that a SDNode can hold.
| xref:llvm/SDNode/hasPredecessorHelper.adoc[`hasPredecessorHelper`] 
| Return true if `N` is a predecessor of any node in `Worklist.`
| xref:llvm/SDNode/use_end.adoc[`use_end`] 
| Return the end iterator for the use list.
| xref:llvm/SDNode/user_end.adoc[`user_end`] 
| Return the end iterator for the user list.
|===


== Data Members

[cols="1,4"]
|===
| Name| Description
| xref:llvm/SDNode/CombinerWorklistIndex.adoc[`CombinerWorklistIndex`] [.small]#[variant member]#
| DAGCombiner worklist index, or a negative sentinel.
| xref:llvm/SDNode/ConstantSDNodeBits.adoc[`ConstantSDNodeBits`] [.small]#[variant member]#
| ConstantSDNode bitfields.
| xref:llvm/SDNode/LSBaseSDNodeBits.adoc[`LSBaseSDNodeBits`] [.small]#[variant member]#
| LSBaseSDNode bitfields.
| xref:llvm/SDNode/LoadSDNodeBits.adoc[`LoadSDNodeBits`] [.small]#[variant member]#
| LoadSDNode bitfields.
| xref:llvm/SDNode/MemSDNodeBits.adoc[`MemSDNodeBits`] [.small]#[variant member]#
| MemSDNode bitfields.
| xref:llvm/SDNode/PersistentId.adoc[`PersistentId`] 
| Unique persistent id per SDNode used for debug printing.
| xref:llvm/SDNode/RawSDNodeBits.adoc[`RawSDNodeBits`] [.small]#[variant member]#
| Raw bytes overlaying subclass bitfields.
| xref:llvm/SDNode/SDNodeBits.adoc[`SDNodeBits`] [.small]#[variant member]#
| Base SDNode bitfields.
| xref:llvm/SDNode/SchedulerWorklistVisited.adoc[`SchedulerWorklistVisited`] [.small]#[variant member]#
| Visited state in ScheduleDAGSDNodes::BuildSchedUnits.
| xref:llvm/SDNode/StoreSDNodeBits.adoc[`StoreSDNodeBits`] [.small]#[variant member]#
| StoreSDNode bitfields.
|===


== Protected Types

[cols="1,4"]
|===
| Name| Description
| xref:llvm/MemSDNode/_01record.adoc[`Unnamed union`] 
| 
| xref:llvm/SDNode/ConstantSDNodeBitfields.adoc[`ConstantSDNodeBitfields`] 
| Bitfields specific to ConstantSDNode.
| xref:llvm/SDNode/LSBaseSDNodeBitfields.adoc[`LSBaseSDNodeBitfields`] 
| Bitfields for load/store addressing mode and related hierarchies.
| xref:llvm/SDNode/LoadSDNodeBitfields.adoc[`LoadSDNodeBitfields`] 
| Bitfields specific to load‐like SDNode subclasses.
| xref:llvm/SDNode/MemSDNodeBitfields.adoc[`MemSDNodeBitfields`] 
| Bitfields shared by memory‐accessing SDNode subclasses.
| xref:llvm/SDNode/SDNodeBitfields.adoc[`SDNodeBitfields`] 
| Bitfields shared by all SDNode subclasses in SubclassData.
| xref:llvm/SDNode/StoreSDNodeBitfields.adoc[`StoreSDNodeBitfields`] 
| Bitfields specific to store‐like SDNode subclasses.
|===


== Protected Enums

[cols="1,4"]
|===
| Name| Description
| xref:llvm/SDNode/_04enum-03.adoc[`Unnamed enum`] 
| Width of SDNodeBitfields in SubclassData.
|===


== Protected Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/SDNode/DropOperands.adoc[`DropOperands`] 
| Release the operands and set this node to have zero operands.
|===


== Protected Static Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/SDNode/getSDVTList.adoc[`getSDVTList`] 
| Return an SDVTList for single simple type `VT.`
|===


== Protected Data Members

[cols="1,4"]
|===
| Name| Description
| xref:llvm/MemSDNode/MemRefs.adoc[`MemRefs`] 
| Memory reference information (always at least one MMO).
|===


== Friends

[cols="1,4"]
|===
| Name| Description
| `xref:llvm/SelectionDAG.adoc[llvm::SelectionDAG]`
| This is used to represent a portion of an LLVM function as a DAG.
|===

== Non-Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/checkForCycles-06.adoc[`checkForCycles`]
| Check the subgraph rooted at `N` for cycles.
| xref:llvm/ISD/allOperandsUndef.adoc[`ISD::allOperandsUndef`]
| Return true if all operands of `N` are ISD::UNDEF.
| xref:llvm/ISD/isBuildVectorAllOnes.adoc[`ISD::isBuildVectorAllOnes`]
| Return true if `N` is a BUILD_VECTOR of all ones or undef.
| xref:llvm/ISD/isBuildVectorAllZeros.adoc[`ISD::isBuildVectorAllZeros`]
| Return true if `N` is a BUILD_VECTOR of all zeros or undef.
| xref:llvm/ISD/isBuildVectorOfConstantFPSDNodes.adoc[`ISD::isBuildVectorOfConstantFPSDNodes`]
| Return true if `N` is a BUILD_VECTOR of ConstantFPSDNode or undef.
| xref:llvm/ISD/isBuildVectorOfConstantSDNodes.adoc[`ISD::isBuildVectorOfConstantSDNodes`]
| Return true if `N` is a BUILD_VECTOR of ConstantSDNode or undef.
| xref:llvm/ISD/isConstantSplatVector.adoc[`ISD::isConstantSplatVector`]
| Return true if `N` is a constant splat BUILD_VECTOR or SPLAT_VECTOR.
| xref:llvm/ISD/isConstantSplatVectorAllOnes.adoc[`ISD::isConstantSplatVectorAllOnes`]
| Return true if `N` is an all‐ones constant splat vector.
| xref:llvm/ISD/isConstantSplatVectorAllZeros.adoc[`ISD::isConstantSplatVectorAllZeros`]
| Return true if `N` is an all‐zeros constant splat vector.
| xref:llvm/ISD/isEXTLoad.adoc[`ISD::isEXTLoad`]
| Returns true if the specified node is a EXTLOAD.
| xref:llvm/ISD/isFreezeUndef.adoc[`ISD::isFreezeUndef`]
| Return true if `N` is FREEZE(UNDEF).
| xref:llvm/ISD/isNON_EXTLoad.adoc[`ISD::isNON_EXTLoad`]
| Returns true if the specified node is a non‐extending load.
| xref:llvm/ISD/isNormalLoad.adoc[`ISD::isNormalLoad`]
| Returns true if the specified node is a non‐extending and unindexed load.
| xref:llvm/ISD/isNormalMaskedLoad.adoc[`ISD::isNormalMaskedLoad`]
| Returns true if `N` is a non‐extending unindexed masked load.
| xref:llvm/ISD/isNormalMaskedStore.adoc[`ISD::isNormalMaskedStore`]
| Returns true if `N` is a non‐truncating unindexed masked store.
| xref:llvm/ISD/isNormalStore.adoc[`ISD::isNormalStore`]
| Returns true if the specified node is a non‐truncating unindexed store.
| xref:llvm/ISD/isSEXTLoad.adoc[`ISD::isSEXTLoad`]
| Returns true if the specified node is a SEXTLOAD.
| xref:llvm/ISD/isUNINDEXEDLoad.adoc[`ISD::isUNINDEXEDLoad`]
| Returns true if the specified node is an unindexed load.
| xref:llvm/ISD/isUNINDEXEDStore.adoc[`ISD::isUNINDEXEDStore`]
| Returns true if the specified node is an unindexed store.
| xref:llvm/ISD/isVectorShrinkable.adoc[`ISD::isVectorShrinkable`]
| Return true if vector elements of `N` shrink to `NewEltSize.`
| xref:llvm/ISD/isZEXTLoad.adoc[`ISD::isZEXTLoad`]
| Returns true if the specified node is a ZEXTLOAD.
| xref:llvm/SDPatternMatch/sd_context_match-007.adoc[`SDPatternMatch::sd_context_match`]
| Match SDNode `N` (result 0) against pattern `P` under context `Ctx.`
| xref:llvm/SDPatternMatch/sd_match-007.adoc[`SDPatternMatch::sd_match`]
| Match SDNode `N` against pattern `P` without a SelectionDAG.
| xref:llvm/SDPatternMatch/sd_match-09.adoc[`SDPatternMatch::sd_match`]
| Match SDNode `N` against pattern `P` using a BasicMatchContext for `DAG.`
|===


[.small]#Created with https://www.mrdocs.com[MrDocs]#