20#ifndef LLVM_IR_CONSTANTS_H
21#define LLVM_IR_CONSTANTS_H
43template <
class ConstantClass>
struct ConstantAggrKeyType;
60 void *
operator new(
size_t S) {
return User::operator
new(S, 0); }
63 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
69 return V->getValueID() >= ConstantDataFirstVal &&
70 V->getValueID() <= ConstantDataLastVal;
85 void destroyConstantImpl();
249 return V->getValueID() == ConstantIntVal;
263 void destroyConstantImpl();
288 APInt *Payload =
nullptr);
290 APInt *Payload =
nullptr);
329 return V->getValueID() == ConstantFPVal;
342 void destroyConstantImpl();
370 return V->getValueID() == ConstantAggregateZeroVal;
395 return V->getValueID() >= ConstantAggregateFirstVal &&
396 V->getValueID() <= ConstantAggregateLastVal;
415 void destroyConstantImpl();
434 return V->getValueID() == ConstantArrayVal;
447 void destroyConstantImpl();
454 template <
typename... Csts>
466 bool Packed =
false) {
473 bool Packed =
false);
477 bool Packed =
false);
486 return V->getValueID() == ConstantStructVal;
499 void destroyConstantImpl();
527 return V->getValueID() == ConstantVectorVal;
540 void destroyConstantImpl();
556 return V->getValueID() == ConstantPointerNullVal;
575 const char *DataElements;
581 std::unique_ptr<ConstantDataSequential> Next;
583 void destroyConstantImpl();
636 bool isString(
unsigned CharSize = 8)
const;
654 return Str.substr(0, Str.size() - 1);
664 return V->getValueID() == ConstantDataArrayVal ||
665 V->getValueID() == ConstantDataVectorVal;
669 const char *getElementPointer(
unsigned Elt)
const;
690 template <
typename ElementTy>
692 const char *
Data =
reinterpret_cast<const char *
>(Elts.
data());
694 Type::getScalarTy<ElementTy>(
Context));
699 template <
typename ArrayTy>
732 bool AddNull =
true);
742 return V->getValueID() == ConstantDataArrayVal;
759 mutable bool IsSplatSet : 1;
760 mutable bool IsSplat : 1;
761 bool isSplatData()
const;
819 return V->getValueID() == ConstantDataVectorVal;
832 void destroyConstantImpl();
842 return V->getValueID() == ConstantTokenNoneVal;
853 void destroyConstantImpl();
869 return V->getValueID() == ConstantTargetNoneVal;
880 void *
operator new(
size_t S) {
return User::operator
new(S, 2); }
882 void destroyConstantImpl();
886 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
908 return V->getValueID() == BlockAddressVal;
926 void *
operator new(
size_t S) {
return User::operator
new(S, 1); }
928 void destroyConstantImpl();
932 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
941 return cast<GlobalValue>(Op<0>().
get());
946 return V->getValueID() == DSOLocalEquivalentVal;
963 void *
operator new(
size_t S) {
return User::operator
new(S, 1); }
965 void destroyConstantImpl();
976 return cast<GlobalValue>(Op<0>().
get());
981 return V->getValueID() == NoCFIValueVal;
1002 void destroyConstantImpl();
1007 :
Constant(ty, ConstantExprVal, Ops, NumOps) {
1009 setValueSubclassData(Opcode);
1031 bool HasNSW =
false);
1034 bool HasNSW =
false);
1036 bool HasNSW =
false);
1038 bool HasNSW =
false);
1043 bool HasNSW =
false);
1050 bool OnlyIfReduced =
false);
1052 bool OnlyIfReduced =
false);
1058 bool OnlyIfReduced =
false);
1060 bool OnlyIfReduced =
false);
1062 bool OnlyIfReduced =
false);
1064 bool OnlyIfReduced =
false);
1070 return getAdd(C1, C2,
false,
true);
1074 return getAdd(C1, C2,
true,
false);
1078 return getSub(C1, C2,
false,
true);
1082 return getSub(C1, C2,
true,
false);
1086 return getMul(C1, C2,
false,
true);
1090 return getMul(C1, C2,
true,
false);
1094 return getShl(C1, C2,
false,
true);
1098 return getShl(C1, C2,
true,
false);
1102 return getAShr(C1, C2,
true);
1106 return getLShr(C1, C2,
true);
1124 static Constant *getBinOpIdentity(
unsigned Opcode,
Type *Ty,
1125 bool AllowRHSConstant =
false,
1132 static Constant *getBinOpAbsorber(
unsigned Opcode,
Type *Ty);
1144 bool OnlyIfReduced =
false);
1178 static Constant *getPointerBitCastOrAddrSpaceCast(
1196 bool isCast()
const;
1199 bool isCompare()
const;
1206 unsigned Flags = 0,
Type *OnlyIfReducedTy =
nullptr);
1212 bool OnlyIfReduced =
false);
1218 bool OnlyIfReduced =
false);
1220 bool OnlyIfReduced =
false);
1229 bool InBounds =
false,
1230 std::optional<unsigned> InRangeIndex = std::nullopt,
1231 Type *OnlyIfReducedTy =
nullptr) {
1232 return getGetElementPtr(
1234 InBounds, InRangeIndex, OnlyIfReducedTy);
1238 std::optional<unsigned> InRangeIndex = std::nullopt,
1239 Type *OnlyIfReducedTy =
nullptr) {
1243 return getGetElementPtr(Ty,
C, cast<Value>(
Idx), InBounds, InRangeIndex,
1248 bool InBounds =
false,
1249 std::optional<unsigned> InRangeIndex = std::nullopt,
1250 Type *OnlyIfReducedTy =
nullptr);
1256 return getGetElementPtr(Ty,
C, IdxList,
true);
1263 return getGetElementPtr(Ty,
C,
Idx,
true);
1267 return getGetElementPtr(Ty,
C, IdxList,
true);
1271 Type *OnlyIfReducedTy =
nullptr);
1273 Type *OnlyIfReducedTy =
nullptr);
1276 Type *OnlyIfReducedTy =
nullptr);
1279 unsigned getOpcode()
const {
return getSubclassDataFromValue(); }
1283 unsigned getPredicate()
const;
1293 Constant *getShuffleMaskForBitcode()
const;
1302 return getWithOperands(Ops,
getType());
1315 bool OnlyIfReduced =
false,
1316 Type *SrcTy =
nullptr)
const;
1330 static bool isDesirableBinOp(
unsigned Opcode);
1334 static bool isSupportedBinOp(
unsigned Opcode);
1344 return V->getValueID() == ConstantExprVal;
1350 void setValueSubclassData(
unsigned short D) {
1376 void destroyConstantImpl();
1393 UndefValue *getStructElement(
unsigned Elt)
const;
1403 unsigned getNumElements()
const;
1407 return V->getValueID() == UndefValueVal ||
1408 V->getValueID() == PoisonValueVal;
1424 void destroyConstantImpl();
1449 return V->getValueID() == PoisonValueVal;
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
BlockVerifier::State From
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static StringRef getOpcodeName(uint8_t Opcode, uint8_t OpcodeBase)
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
Looks at all the uses of the given value Returns the Liveness deduced from the uses of this value Adds all uses that cause the result to be MaybeLive to MaybeLiveRetUses If the result is MaybeLiveUses might be modified but its content should be ignored(since it might not be complete). DeadArgumentEliminationPass
Given that RA is a live value
static LazyValueInfoImpl & getImpl(void *&PImpl, AssumptionCache *AC, const Module *M)
This lazily constructs the LazyValueInfoImpl.
#define DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CLASS, VALUECLASS)
Macro for generating out-of-class operand accessor definitions.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static SymbolRef::Type getType(const Symbol *Sym)
opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
const fltSemantics & getSemantics() const
Class for arbitrary precision integers.
bool isMinSignedValue() const
Determine if this is the smallest signed value.
uint64_t getZExtValue() const
Get zero extended value.
bool isAllOnes() const
Determine if all bits are set. This is true for zero-width values.
bool isZero() const
Determine if this value is zero, i.e. all bits are clear.
unsigned getBitWidth() const
Return the number of bits in the APInt.
bool isMinValue() const
Determine if this is the smallest unsigned value.
bool isNegative() const
Determine sign of this APInt.
uint64_t getLimitedValue(uint64_t Limit=UINT64_MAX) const
If this value is smaller than the specified limit, return it, otherwise return the limit value.
bool isMaxSignedValue() const
Determine if this is the largest signed value.
bool isOne() const
Determine if this is a value of 1.
int64_t getSExtValue() const
Get sign extended value.
bool uge(const APInt &RHS) const
Unsigned greater or equal comparison.
bool isMaxValue() const
Determine if this is the largest unsigned value.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
size - Get the array size.
Class to represent array types.
static ArrayType * get(Type *ElementType, uint64_t NumElements)
This static method is the primary way to construct an ArrayType.
LLVM Basic Block Representation.
The address of a basic block.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
static BlockAddress * lookup(const BasicBlock *BB)
Lookup an existing BlockAddress constant for the given BasicBlock.
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Function * getFunction() const
BasicBlock * getBasicBlock() const
static BlockAddress * get(Function *F, BasicBlock *BB)
Return a BlockAddress for the specified function and basic block.
All zero aggregate value.
ElementCount getElementCount() const
Return the number of elements in the array, vector, or struct.
ConstantAggregateZero(const ConstantAggregateZero &)=delete
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Constant * getSequentialElement() const
If this CAZ has array or vector type, return a zero with the right element type.
Constant * getElementValue(Constant *C) const
Return a zero of the right value for the specified GEP index if we can, otherwise return null (e....
Constant * getStructElement(unsigned Elt) const
If this CAZ has struct type, return a zero with the right element type for the specified element.
static ConstantAggregateZero * get(Type *Ty)
Base class for aggregate constants (with operands).
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant)
Transparently provide more efficient getOperand methods.
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
ConstantArray - Constant Array Declarations.
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
ArrayType * getType() const
Specialize the getType() method to always return an ArrayType, which reduces the amount of casting ne...
An array constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
static Constant * getString(LLVMContext &Context, StringRef Initializer, bool AddNull=true)
This method constructs a CDS and initializes it with a text string.
static Constant * get(LLVMContext &Context, ArrayRef< ElementTy > Elts)
get() constructor - Return a constant with array type with an element count and element type matching...
static Constant * getFP(Type *ElementType, ArrayRef< uint16_t > Elts)
getFP() constructors - Return a constant of array type with a float element type taken from argument ...
static Constant * get(LLVMContext &Context, ArrayTy &Elts)
get() constructor - ArrayTy needs to be compatible with ArrayRef<ElementTy>.
ConstantDataArray(const ConstantDataArray &)=delete
static Constant * getRaw(StringRef Data, uint64_t NumElements, Type *ElementTy)
getRaw() constructor - Return a constant with array type with an element count and element type match...
ArrayType * getType() const
Specialize the getType() method to always return an ArrayType, which reduces the amount of casting ne...
ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...
APInt getElementAsAPInt(unsigned i) const
If this is a sequential container of integers (of any size), return the specified element as an APInt...
double getElementAsDouble(unsigned i) const
If this is an sequential container of doubles, return the specified element as a double.
StringRef getAsString() const
If this array is isString(), then this method returns the array as a StringRef.
uint64_t getElementByteSize() const
Return the size (in bytes) of each element in the array/vector.
ConstantDataSequential(const ConstantDataSequential &)=delete
float getElementAsFloat(unsigned i) const
If this is an sequential container of floats, return the specified element as a float.
bool isString(unsigned CharSize=8) const
This method returns true if this is an array of CharSize integers.
StringRef getAsCString() const
If this array is isCString(), then this method returns the array (without the trailing null byte) as ...
uint64_t getElementAsInteger(unsigned i) const
If this is a sequential container of integers (of any size), return the specified element in the low ...
static Constant * getImpl(StringRef Bytes, Type *Ty)
This is the underlying implementation of all of the ConstantDataSequential::get methods.
unsigned getNumElements() const
Return the number of elements in the array or vector.
Constant * getElementAsConstant(unsigned i) const
Return a Constant for a specified index's element.
Type * getElementType() const
Return the element type of the array/vector.
bool isCString() const
This method returns true if the array "isString", ends with a null byte, and does not contains any ot...
APFloat getElementAsAPFloat(unsigned i) const
If this is a sequential container of floating point type, return the specified element as an APFloat.
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
StringRef getRawDataValues() const
Return the raw, underlying, bytes of this data.
static bool isElementTypeCompatible(Type *Ty)
Return true if a ConstantDataSequential can be formed with a vector or array of the specified element...
ConstantDataSequential(Type *ty, ValueTy VT, const char *Data)
A vector constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
static Constant * getRaw(StringRef Data, uint64_t NumElements, Type *ElementTy)
getRaw() constructor - Return a constant with vector type with an element count and element type matc...
Constant * getSplatValue() const
If this is a splat constant, meaning that all of the elements have the same value,...
static Constant * getSplat(unsigned NumElts, Constant *Elt)
Return a ConstantVector with the specified constant in each element.
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
bool isSplat() const
Returns true if this is a splat constant, meaning that all elements have the same value.
FixedVectorType * getType() const
Specialize the getType() method to always return a FixedVectorType, which reduces the amount of casti...
ConstantDataVector(const ConstantDataVector &)=delete
static Constant * get(LLVMContext &Context, ArrayRef< uint8_t > Elts)
get() constructors - Return a constant with vector type with an element count and element type matchi...
static Constant * getFP(Type *ElementType, ArrayRef< uint16_t > Elts)
getFP() constructors - Return a constant of vector type with a float element type taken from argument...
Base class for constants with no operands.
static bool classof(const Value *V)
Methods to support type inquiry through isa, cast, and dyn_cast.
ConstantData(const ConstantData &)=delete
ConstantData(Type *Ty, ValueTy VT)
A constant value that is initialized with an expression using other constant values.
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
static Constant * getNUWSub(Constant *C1, Constant *C2)
static Constant * getInBoundsGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList)
Create an "inbounds" getelementptr.
static Constant * getNSWAdd(Constant *C1, Constant *C2)
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant)
Transparently provide more efficient getOperand methods.
static Constant * getNUWShl(Constant *C1, Constant *C2)
ConstantExpr(Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps)
static Constant * getGetElementPtr(Type *Ty, Constant *C, Constant *Idx, bool InBounds=false, std::optional< unsigned > InRangeIndex=std::nullopt, Type *OnlyIfReducedTy=nullptr)
static bool isSupportedGetElementPtr(const Type *SrcElemTy)
Whether creating a constant expression for this getelementptr type is supported.
static Constant * getNSWShl(Constant *C1, Constant *C2)
static Constant * getGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList, bool InBounds=false, std::optional< unsigned > InRangeIndex=std::nullopt, Type *OnlyIfReducedTy=nullptr)
Getelementptr form.
static Constant * getInBoundsGetElementPtr(Type *Ty, Constant *C, ArrayRef< Value * > IdxList)
static Constant * getNSWNeg(Constant *C)
static Constant * getNSWSub(Constant *C1, Constant *C2)
static Constant * getExactLShr(Constant *C1, Constant *C2)
static Constant * getInBoundsGetElementPtr(Type *Ty, Constant *C, Constant *Idx)
static Constant * getNUWAdd(Constant *C1, Constant *C2)
static Constant * getNUWNeg(Constant *C)
static Constant * getExactAShr(Constant *C1, Constant *C2)
unsigned getOpcode() const
Return the opcode at the root of this constant expression.
static Constant * getNSWMul(Constant *C1, Constant *C2)
static Constant * getNUWMul(Constant *C1, Constant *C2)
Constant * getWithOperands(ArrayRef< Constant * > Ops) const
This returns the current constant expression with the operands replaced with the specified values.
ConstantFP - Floating Point Values [float, double].
ConstantFP(const ConstantFP &)=delete
const APFloat & getValue() const
static Constant * getSNaN(Type *Ty, bool Negative=false, APInt *Payload=nullptr)
const APFloat & getValueAPF() const
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
bool isInfinity() const
Return true if the value is infinity.
static Constant * get(Type *Ty, double V)
This returns a ConstantFP, or a vector containing a splat of a ConstantFP, for the specified value in...
bool isNegative() const
Return true if the sign bit is set.
bool isExactlyValue(double V) const
static Constant * getInfinity(Type *Ty, bool Negative=false)
static Constant * getZero(Type *Ty, bool Negative=false)
static Constant * getNegativeZero(Type *Ty)
static Constant * getNaN(Type *Ty, bool Negative=false, uint64_t Payload=0)
bool isNaN() const
Return true if the value is a NaN.
static Constant * getZeroValueForNegation(Type *Ty)
Floating point negation must be implemented with f(x) = -0.0 - x.
bool isExactlyValue(const APFloat &V) const
We don't rely on operator== working on double values, as it returns true for things that are clearly ...
static bool isValueValidForType(Type *Ty, const APFloat &V)
Return true if Ty is big enough to represent V.
static Constant * getQNaN(Type *Ty, bool Negative=false, APInt *Payload=nullptr)
bool isZero() const
Return true if the value is positive or negative zero.
This is the shared class of boolean and integer constants.
bool isMinusOne() const
This function will return true iff every bit in this constant is set to true.
bool isOne() const
This is just a convenience method to make client code smaller for a common case.
uint64_t getLimitedValue(uint64_t Limit=~0ULL) const
getLimitedValue - If the value is smaller than the specified limit, return it, otherwise return the l...
IntegerType * getType() const
getType - Specialize the getType() method to always return an IntegerType, which reduces the amount o...
static bool isValueValidForType(Type *Ty, uint64_t V)
This static method returns true if the type Ty is big enough to represent the value V.
static bool classof(const Value *V)
Methods to support type inquiry through isa, cast, and dyn_cast.
static ConstantInt * getTrue(LLVMContext &Context)
ConstantInt(const ConstantInt &)=delete
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
MaybeAlign getMaybeAlignValue() const
Return the constant as an llvm::MaybeAlign.
bool isMinValue(bool IsSigned) const
This function will return true iff this constant represents the smallest value that may be represente...
static ConstantInt * getFalse(LLVMContext &Context)
int64_t getSExtValue() const
Return the constant as a 64-bit integer value after it has been sign extended as appropriate for the ...
bool isMaxValue(bool IsSigned) const
This function will return true iff this constant represents the largest value that may be represented...
unsigned getBitWidth() const
getBitWidth - Return the bitwidth of this constant.
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
static ConstantInt * getSigned(IntegerType *Ty, int64_t V)
Return a ConstantInt with the specified value for the specified type.
Align getAlignValue() const
Return the constant as an llvm::Align, interpreting 0 as Align(1).
bool equalsInt(uint64_t V) const
A helper method that can be used to determine if the constant contained within is equal to a constant...
const APInt & getValue() const
Return the constant as an APInt value reference.
bool uge(uint64_t Num) const
This function will return true iff this constant represents a value with active bits bigger than 64 b...
static ConstantInt * getBool(LLVMContext &Context, bool V)
A constant pointer value that points to null.
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
PointerType * getType() const
Specialize the getType() method to always return an PointerType, which reduces the amount of casting ...
ConstantPointerNull(const ConstantPointerNull &)=delete
static Constant * getAnon(LLVMContext &Ctx, ArrayRef< Constant * > V, bool Packed=false)
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
static Constant * get(StructType *T, ArrayRef< Constant * > V)
static StructType * getTypeForElements(ArrayRef< Constant * > V, bool Packed=false)
Return an anonymous struct type to use for a constant with the specified set of elements.
static std::enable_if_t< are_base_of< Constant, Csts... >::value, Constant * > get(StructType *T, Csts *...Vs)
StructType * getType() const
Specialization - reduce amount of casting.
static Constant * getAnon(ArrayRef< Constant * > V, bool Packed=false)
Return an anonymous struct that has the specified elements.
A constant target extension type default initializer.
static ConstantTargetNone * get(TargetExtType *T)
Static factory methods - Return objects of the specified value.
TargetExtType * getType() const
Specialize the getType() method to always return an TargetExtType, which reduces the amount of castin...
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast.
ConstantTargetNone(const ConstantTargetNone &)=delete
A constant token which is empty.
ConstantTokenNone(const ConstantTokenNone &)=delete
static ConstantTokenNone * get(LLVMContext &Context)
Return the ConstantTokenNone.
static bool classof(const Value *V)
Methods to support type inquiry through isa, cast, and dyn_cast.
Constant Vector Declarations.
Constant * getSplatValue(bool AllowUndefs=false) const
If all elements of the vector constant have the same value, return that value.
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
FixedVectorType * getType() const
Specialize the getType() method to always return a FixedVectorType, which reduces the amount of casti...
static Constant * getSplat(ElementCount EC, Constant *Elt)
Return a ConstantVector with the specified constant in each element.
static Constant * get(ArrayRef< Constant * > V)
This is an important base class in LLVM.
Wrapper for a function that represents a value that functionally represents the original function.
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
GlobalValue * getGlobalValue() const
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
static constexpr ElementCount getFixed(ScalarTy MinVal)
Class to represent fixed width SIMD vectors.
Class to represent integer types.
This is an important class for using LLVM in a threaded context.
Wrapper for a value that won't be replaced with a CFI jump table pointer in LowerTypeTestsModule.
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
GlobalValue * getGlobalValue() const
Class to represent pointers.
In order to facilitate speculative execution, many instructions do not invoke immediate undefined beh...
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
PoisonValue(const PoisonValue &)=delete
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
PoisonValue * getStructElement(unsigned Elt) const
If this poison has struct type, return a poison with the right element type for the specified element...
PoisonValue * getSequentialElement() const
If this poison has array or vector type, return a poison with the right element type.
PoisonValue * getElementValue(Constant *C) const
Return an poison of the right value for the specified GEP index if we can, otherwise return null (e....
StringRef - Represent a constant reference to a string, i.e.
Class to represent struct types.
Class to represent target extensions types, which are generally unintrospectable from target-independ...
The instances of the Type class are immutable: once they are created, they are never changed.
bool isScalableTy() const
Return true if this is a scalable vector type or a target extension type with a scalable layout.
'undef' values are things that do not have specified contents.
UndefValue(const UndefValue &)=delete
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
UndefValue(Type *T, ValueTy vty)
A Use represents the edge between a Value definition and its users.
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
void setValueSubclassData(unsigned short D)
ValueTy
Concrete subclass of this.
Base class of all SIMD vector types.
static VectorType * get(Type *ElementType, ElementCount EC)
This static method is the primary way to construct an VectorType.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
This is an optimization pass for GlobalISel generic memory operations.
std::conjunction< std::is_base_of< T, Ts >... > are_base_of
traits class for checking whether type T is a base class for all the given types in the variadic list...
decltype(auto) get(const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)
static constexpr roundingMode rmNearestTiesToEven
This struct is a compact representation of a valid (non-zero power of two) alignment.
FixedNumOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Align valueOrOne() const
For convenience, returns a valid alignment or 1 if undefined.
Compile-time customization of User operands.
VariadicOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...