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

SCEV expression wrapping a constant integer value.

== Synopsis

Declared in `<llvm/Analysis/ScalarEvolutionExpressions.h>`

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

== Base Classes

[cols="1,4"]
|===
| Name| Description
| `xref:llvm/SCEV.adoc[SCEV]`
| This class represents an analyzed expression in the program. These are opaque objects that the client is not allowed to do much with directly.
|===

== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:llvm/SCEV/NoWrapFlags.adoc[`NoWrapFlags`] 
| SCEV no‐wrap flags; alias of SCEVNoWrapFlags.
|===


== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/SCEV/operator_assign.adoc[`operator=`]  [.small]#[deleted]#
| Deleted copy assignment.
| xref:llvm/SCEV/computeAndSetCanonical.adoc[`computeAndSetCanonical`] 
| Compute and set the canonical SCEV, by constructing a SCEV with the same operands, but all SCEVUse flags dropped.
| xref:llvm/SCEV/dump.adoc[`dump`] 
| This method is used for debugging.
| xref:llvm/SCEVConstant/getAPInt.adoc[`getAPInt`] 
| Return the APInt underlying this constant.
| xref:llvm/SCEV/getCanonical.adoc[`getCanonical`] 
| Return the canonical SCEV.
| xref:llvm/SCEV/getExpressionSize.adoc[`getExpressionSize`] 
| Return the estimated size of this SCEV's expression tree.
| xref:llvm/SCEV/getSCEVType.adoc[`getSCEVType`] 
| Return the SCEV opcode of this expression.
| xref:llvm/SCEV/getType.adoc[`getType`] 
| Return the LLVM type of this SCEV expression.
| xref:llvm/SCEVConstant/getValue.adoc[`getValue`] 
| Return the constant integer value.
| xref:llvm/SCEV/isAllOnesValue.adoc[`isAllOnesValue`] 
| Return true if the expression is a constant all‐ones value.
| xref:llvm/SCEV/isNonConstantNegative.adoc[`isNonConstantNegative`] 
| Return true if the specified scev is negated, but not a constant.
| xref:llvm/SCEV/isOne.adoc[`isOne`] 
| Return true if the expression is a constant one.
| xref:llvm/SCEV/isZero.adoc[`isZero`] 
| Return true if the expression is a constant zero.
| xref:llvm/SCEV/operands.adoc[`operands`] 
| Return operands of this SCEV expression.
| xref:llvm/SCEV/print.adoc[`print`] 
| Print this SCEV to `OS.`
|===


== Static Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/SCEVConstant/classof.adoc[`classof`] 
| Methods for support type inquiry through isa, cast, and dyn_cast.
|===


== Static Data Members

[cols="1,4"]
|===
| Name| Description
| xref:llvm/SCEV/FlagAnyWrap.adoc[`FlagAnyWrap`] 
| No wrap guarantee.
| xref:llvm/SCEV/FlagNSW.adoc[`FlagNSW`] 
| No signed wrap.
| xref:llvm/SCEV/FlagNUW.adoc[`FlagNUW`] 
| No unsigned wrap.
| xref:llvm/SCEV/FlagNW.adoc[`FlagNW`] 
| No self‐wrap.
| xref:llvm/SCEV/NoWrapMask.adoc[`NoWrapMask`] 
| Mask of all no‐wrap flag bits.
|===


== Protected Data Members

[cols="1,4"]
|===
| Name| Description
| xref:llvm/SCEV/CanonicalSCEV.adoc[`CanonicalSCEV`] 
| Pointer to the canonical version of the SCEV, i.e. one where all operands have no SCEVUse flags.
| xref:llvm/SCEV/ExpressionSize.adoc[`ExpressionSize`] 
| Estimated complexity of this node's expression tree size.
| xref:llvm/SCEV/SubclassData.adoc[`SubclassData`] 
| This field is initialized to zero and may be used in subclasses to store miscellaneous information.
| xref:llvm/SCEV/Ty.adoc[`Ty`] 
| Immutable type of the SCEV.
|===


== Friends

[cols="1,4"]
|===
| Name| Description
| `xref:llvm/ScalarEvolution.adoc[llvm::ScalarEvolution]`
| The main scalar evolution driver. Because client code (intentionally) can't do much with the SCEV objects directly, they must ask this class for services.
|===

== Non-Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/SCEVExprContains.adoc[`SCEVExprContains`]
| Return true if any node in `Root` satisfies the predicate `Pred.`
| xref:llvm/cannotBeMaxInLoop.adoc[`cannotBeMaxInLoop`]
| Returns true if `S` is defined and never is equal to signed/unsigned max.
| xref:llvm/cannotBeMinInLoop.adoc[`cannotBeMinInLoop`]
| Returns true if `S` is defined and never is equal to signed/unsigned min.
| xref:llvm/denormalizeForPostIncUse.adoc[`denormalizeForPostIncUse`]
| Denormalize `S` to be post‐increment for all loops present in `Loops.`
| xref:llvm/isDereferenceableAndAlignedInLoop-062.adoc[`isDereferenceableAndAlignedInLoop`]
| Overload for isDereferenceableAndAlignedInLoop taking the pointer and access size directly as SCEVs.
| xref:llvm/isKnownNegativeInLoop.adoc[`isKnownNegativeInLoop`]
| Returns true if we can prove that `S` is defined and always negative in loop `L.`
| xref:llvm/isKnownNonNegativeInLoop.adoc[`isKnownNonNegativeInLoop`]
| Returns true if we can prove that `S` is defined and always non‐negative in loop `L.`
| xref:llvm/isKnownNonPositiveInLoop.adoc[`isKnownNonPositiveInLoop`]
| Returns true if we can prove that `S` is defined and always non‐positive in loop `L.`
| xref:llvm/isKnownPositiveInLoop.adoc[`isKnownPositiveInLoop`]
| Returns true if we can prove that `S` is defined and always positive in loop `L.`
| xref:llvm/normalizeForPostIncUse.adoc[`normalizeForPostIncUse`]
| Normalize `S` to be post‐increment for all loops present in `Loops.`
| xref:llvm/normalizeForPostIncUseIf.adoc[`normalizeForPostIncUseIf`]
| Normalize `S` for all add recurrence sub‐expressions for which `Pred` returns true.
| xref:llvm/visitAll.adoc[`visitAll`]
| Use SCEVTraversal to visit all nodes in the given expression tree.
| xref:llvm/SCEVPatternMatch/m_SCEV-00.adoc[`SCEVPatternMatch::m_SCEV`]
| Match a SCEV, capturing it if we match.
| xref:llvm/SCEVPatternMatch/m_SCEVConstant-02.adoc[`SCEVPatternMatch::m_SCEVConstant`]
| Match a SCEVConstant, capturing it if we match.
| xref:llvm/SCEVPatternMatch/m_scev_Specific.adoc[`SCEVPatternMatch::m_scev_Specific`]
| Match if we have a specific specified SCEV.
| xref:llvm/SCEVPatternMatch/match-04.adoc[`SCEVPatternMatch::match`]
| Match SCEV `S` against pattern `P.`
|===


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