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();
115 return get(Ty, V,
true);
118 return get(Ty, V,
true);
253 return V->getValueID() == ConstantIntVal;
267 void destroyConstantImpl();
287 APInt *Payload =
nullptr);
289 APInt *Payload =
nullptr);
328 return V->getValueID() == ConstantFPVal;
341 void destroyConstantImpl();
369 return V->getValueID() == ConstantAggregateZeroVal;
394 return V->getValueID() >= ConstantAggregateFirstVal &&
395 V->getValueID() <= ConstantAggregateLastVal;
414 void destroyConstantImpl();
433 return V->getValueID() == ConstantArrayVal;
446 void destroyConstantImpl();
453 template <
typename... Csts>
465 bool Packed =
false) {
472 bool Packed =
false);
476 bool Packed =
false);
485 return V->getValueID() == ConstantStructVal;
498 void destroyConstantImpl();
526 return V->getValueID() == ConstantVectorVal;
539 void destroyConstantImpl();
555 return V->getValueID() == ConstantPointerNullVal;
574 const char *DataElements;
580 std::unique_ptr<ConstantDataSequential> Next;
582 void destroyConstantImpl();
635 bool isString(
unsigned CharSize = 8)
const;
653 return Str.substr(0, Str.size() - 1);
663 return V->getValueID() == ConstantDataArrayVal ||
664 V->getValueID() == ConstantDataVectorVal;
668 const char *getElementPointer(
unsigned Elt)
const;
689 template <
typename ElementTy>
691 const char *
Data =
reinterpret_cast<const char *
>(Elts.
data());
693 Type::getScalarTy<ElementTy>(
Context));
698 template <
typename ArrayTy>
731 bool AddNull =
true);
741 return V->getValueID() == ConstantDataArrayVal;
758 mutable bool IsSplatSet : 1;
759 mutable bool IsSplat : 1;
760 bool isSplatData()
const;
818 return V->getValueID() == ConstantDataVectorVal;
831 void destroyConstantImpl();
841 return V->getValueID() == ConstantTokenNoneVal;
852 void destroyConstantImpl();
868 return V->getValueID() == ConstantTargetNoneVal;
879 void *
operator new(
size_t S) {
return User::operator
new(S, 2); }
881 void destroyConstantImpl();
885 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
907 return V->getValueID() == BlockAddressVal;
925 void *
operator new(
size_t S) {
return User::operator
new(S, 1); }
927 void destroyConstantImpl();
931 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
940 return cast<GlobalValue>(Op<0>().
get());
945 return V->getValueID() == DSOLocalEquivalentVal;
962 void *
operator new(
size_t S) {
return User::operator
new(S, 1); }
964 void destroyConstantImpl();
975 return cast<GlobalValue>(Op<0>().
get());
980 return V->getValueID() == NoCFIValueVal;
1001 void destroyConstantImpl();
1006 :
Constant(ty, ConstantExprVal, Ops, NumOps) {
1008 setValueSubclassData(Opcode);
1030 bool HasNSW =
false);
1033 bool HasNSW =
false);
1035 bool HasNSW =
false);
1037 bool HasNSW =
false);
1042 bool HasNSW =
false);
1049 bool OnlyIfReduced =
false);
1051 bool OnlyIfReduced =
false);
1057 bool OnlyIfReduced =
false);
1059 bool OnlyIfReduced =
false);
1061 bool OnlyIfReduced =
false);
1063 bool OnlyIfReduced =
false);
1069 return getAdd(C1, C2,
false,
true);
1073 return getAdd(C1, C2,
true,
false);
1077 return getSub(C1, C2,
false,
true);
1081 return getSub(C1, C2,
true,
false);
1085 return getMul(C1, C2,
false,
true);
1089 return getMul(C1, C2,
true,
false);
1093 return getShl(C1, C2,
false,
true);
1097 return getShl(C1, C2,
true,
false);
1101 return getAShr(C1, C2,
true);
1105 return getLShr(C1, C2,
true);
1123 static Constant *getBinOpIdentity(
unsigned Opcode,
Type *Ty,
1124 bool AllowRHSConstant =
false,
1131 static Constant *getBinOpAbsorber(
unsigned Opcode,
Type *Ty);
1143 bool OnlyIfReduced =
false);
1177 static Constant *getPointerBitCastOrAddrSpaceCast(
1195 bool isCast()
const;
1198 bool isCompare()
const;
1205 unsigned Flags = 0,
Type *OnlyIfReducedTy =
nullptr);
1211 bool OnlyIfReduced =
false);
1217 bool OnlyIfReduced =
false);
1219 bool OnlyIfReduced =
false);
1228 bool InBounds =
false,
1229 std::optional<unsigned> InRangeIndex = std::nullopt,
1230 Type *OnlyIfReducedTy =
nullptr) {
1231 return getGetElementPtr(
1233 InBounds, InRangeIndex, OnlyIfReducedTy);
1237 std::optional<unsigned> InRangeIndex = std::nullopt,
1238 Type *OnlyIfReducedTy =
nullptr) {
1242 return getGetElementPtr(Ty,
C, cast<Value>(
Idx), InBounds, InRangeIndex,
1247 bool InBounds =
false,
1248 std::optional<unsigned> InRangeIndex = std::nullopt,
1249 Type *OnlyIfReducedTy =
nullptr);
1255 return getGetElementPtr(Ty,
C, IdxList,
true);
1262 return getGetElementPtr(Ty,
C,
Idx,
true);
1266 return getGetElementPtr(Ty,
C, IdxList,
true);
1270 Type *OnlyIfReducedTy =
nullptr);
1272 Type *OnlyIfReducedTy =
nullptr);
1275 Type *OnlyIfReducedTy =
nullptr);
1278 unsigned getOpcode()
const {
return getSubclassDataFromValue(); }
1282 unsigned getPredicate()
const;
1292 Constant *getShuffleMaskForBitcode()
const;
1301 return getWithOperands(Ops,
getType());
1314 bool OnlyIfReduced =
false,
1315 Type *SrcTy =
nullptr)
const;
1329 static bool isDesirableBinOp(
unsigned Opcode);
1333 static bool isSupportedBinOp(
unsigned Opcode);
1343 return V->getValueID() == ConstantExprVal;
1349 void setValueSubclassData(
unsigned short D) {
1375 void destroyConstantImpl();
1392 UndefValue *getStructElement(
unsigned Elt)
const;
1402 unsigned getNumElements()
const;
1406 return V->getValueID() == UndefValueVal ||
1407 V->getValueID() == PoisonValueVal;
1423 void destroyConstantImpl();
1448 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.
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.
static Constant * getSigned(Type *Ty, int64_t V)
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.
static ConstantInt * getSigned(IntegerType *Ty, int64_t V)
Return a ConstantInt with the specified value for the specified type.
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...
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...