20#ifndef LLVM_IR_CONSTANTS_H
21#define LLVM_IR_CONSTANTS_H
45template <
class ConstantClass>
struct ConstantAggrKeyType;
62 void *
operator new(
size_t S) {
return User::operator
new(S, 0); }
65 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
71 return V->getValueID() >= ConstantDataFirstVal &&
72 V->getValueID() <= ConstantDataLastVal;
88 void destroyConstantImpl();
124 return get(Ty, V,
true);
127 return get(Ty, V,
true);
261 return V->getValueID() == ConstantIntVal;
276 void destroyConstantImpl();
302 APInt *Payload =
nullptr);
304 APInt *Payload =
nullptr);
343 return V->getValueID() == ConstantFPVal;
356 void destroyConstantImpl();
384 return V->getValueID() == ConstantAggregateZeroVal;
409 return V->getValueID() >= ConstantAggregateFirstVal &&
410 V->getValueID() <= ConstantAggregateLastVal;
429 void destroyConstantImpl();
448 return V->getValueID() == ConstantArrayVal;
461 void destroyConstantImpl();
468 template <
typename... Csts>
480 bool Packed =
false) {
487 bool Packed =
false);
491 bool Packed =
false);
500 return V->getValueID() == ConstantStructVal;
513 void destroyConstantImpl();
541 return V->getValueID() == ConstantVectorVal;
554 void destroyConstantImpl();
570 return V->getValueID() == ConstantPointerNullVal;
589 const char *DataElements;
595 std::unique_ptr<ConstantDataSequential> Next;
597 void destroyConstantImpl();
650 bool isString(
unsigned CharSize = 8)
const;
668 return Str.substr(0, Str.size() - 1);
678 return V->getValueID() == ConstantDataArrayVal ||
679 V->getValueID() == ConstantDataVectorVal;
683 const char *getElementPointer(
unsigned Elt)
const;
704 template <
typename ElementTy>
706 const char *
Data =
reinterpret_cast<const char *
>(Elts.
data());
708 Type::getScalarTy<ElementTy>(
Context));
713 template <
typename ArrayTy>
746 bool AddNull =
true);
756 return V->getValueID() == ConstantDataArrayVal;
773 mutable bool IsSplatSet : 1;
774 mutable bool IsSplat : 1;
775 bool isSplatData()
const;
833 return V->getValueID() == ConstantDataVectorVal;
846 void destroyConstantImpl();
856 return V->getValueID() == ConstantTokenNoneVal;
867 void destroyConstantImpl();
883 return V->getValueID() == ConstantTargetNoneVal;
894 void *
operator new(
size_t S) {
return User::operator
new(S, 2); }
896 void destroyConstantImpl();
900 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
922 return V->getValueID() == BlockAddressVal;
940 void *
operator new(
size_t S) {
return User::operator
new(S, 1); }
942 void destroyConstantImpl();
946 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
955 return cast<GlobalValue>(
Op<0>().
get());
960 return V->getValueID() == DSOLocalEquivalentVal;
977 void *
operator new(
size_t S) {
return User::operator
new(S, 1); }
979 void destroyConstantImpl();
990 return cast<GlobalValue>(
Op<0>().
get());
1000 return V->getValueID() == NoCFIValueVal;
1021 void destroyConstantImpl();
1026 :
Constant(ty, ConstantExprVal, Ops, NumOps) {
1028 setValueSubclassData(Opcode);
1052 bool HasNSW =
false);
1054 bool HasNSW =
false);
1056 bool HasNSW =
false);
1059 bool HasNSW =
false);
1062 bool OnlyIfReduced =
false);
1064 bool OnlyIfReduced =
false);
1066 bool OnlyIfReduced =
false);
1068 bool OnlyIfReduced =
false);
1073 return getAdd(C1, C2,
false,
true);
1077 return getAdd(C1, C2,
true,
false);
1081 return getSub(C1, C2,
false,
true);
1085 return getSub(C1, C2,
true,
false);
1089 return getMul(C1, C2,
false,
true);
1093 return getMul(C1, C2,
true,
false);
1097 return getShl(C1, C2,
false,
true);
1101 return getShl(C1, C2,
true,
false);
1117 static Constant *getBinOpIdentity(
unsigned Opcode,
Type *Ty,
1118 bool AllowRHSConstant =
false,
1127 bool AllowRHSConstant =
false,
bool NSZ =
false);
1133 static Constant *getBinOpAbsorber(
unsigned Opcode,
Type *Ty);
1145 bool OnlyIfReduced =
false);
1162 static Constant *getPointerBitCastOrAddrSpaceCast(
1168 bool isCast()
const;
1171 bool isCompare()
const;
1178 unsigned Flags = 0,
Type *OnlyIfReducedTy =
nullptr);
1184 bool OnlyIfReduced =
false);
1190 bool OnlyIfReduced =
false);
1192 bool OnlyIfReduced =
false);
1201 bool InBounds =
false,
1202 std::optional<ConstantRange>
InRange = std::nullopt,
1203 Type *OnlyIfReducedTy =
nullptr) {
1204 return getGetElementPtr(
1206 InBounds,
InRange, OnlyIfReducedTy);
1210 std::optional<ConstantRange>
InRange = std::nullopt,
1211 Type *OnlyIfReducedTy =
nullptr) {
1215 return getGetElementPtr(Ty,
C, cast<Value>(
Idx), InBounds,
InRange,
1220 bool InBounds =
false,
1221 std::optional<ConstantRange>
InRange = std::nullopt,
1222 Type *OnlyIfReducedTy =
nullptr);
1228 return getGetElementPtr(Ty,
C, IdxList,
true);
1235 return getGetElementPtr(Ty,
C,
Idx,
true);
1239 return getGetElementPtr(Ty,
C, IdxList,
true);
1243 Type *OnlyIfReducedTy =
nullptr);
1245 Type *OnlyIfReducedTy =
nullptr);
1248 Type *OnlyIfReducedTy =
nullptr);
1251 unsigned getOpcode()
const {
return getSubclassDataFromValue(); }
1255 unsigned getPredicate()
const;
1265 Constant *getShuffleMaskForBitcode()
const;
1274 return getWithOperands(Ops,
getType());
1287 bool OnlyIfReduced =
false,
1288 Type *SrcTy =
nullptr)
const;
1301 static bool isDesirableBinOp(
unsigned Opcode);
1305 static bool isSupportedBinOp(
unsigned Opcode);
1308 static bool isDesirableCastOp(
unsigned Opcode);
1311 static bool isSupportedCastOp(
unsigned Opcode);
1321 return V->getValueID() == ConstantExprVal;
1327 void setValueSubclassData(
unsigned short D) {
1353 void destroyConstantImpl();
1370 UndefValue *getStructElement(
unsigned Elt)
const;
1380 unsigned getNumElements()
const;
1384 return V->getValueID() == UndefValueVal ||
1385 V->getValueID() == PoisonValueVal;
1401 void destroyConstantImpl();
1426 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 bool InRange(int64_t Value, unsigned short Shift, int LBound, int HBound)
#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, ArrayRef< Constant * > IdxList, bool InBounds=false, std::optional< ConstantRange > InRange=std::nullopt, Type *OnlyIfReducedTy=nullptr)
Getelementptr form.
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, Constant *Idx, bool InBounds=false, std::optional< ConstantRange > InRange=std::nullopt, Type *OnlyIfReducedTy=nullptr)
static Constant * getInBoundsGetElementPtr(Type *Ty, Constant *C, ArrayRef< Value * > IdxList)
static Constant * getNSWNeg(Constant *C)
static Constant * getNSWSub(Constant *C1, Constant *C2)
static Constant * getInBoundsGetElementPtr(Type *Ty, Constant *C, Constant *Idx)
static Constant * getNUWAdd(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.
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 * getIntegerType() const
Variant of the getType() method to always return an IntegerType, which reduces the amount of casting ...
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.
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 scalar 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.
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...
Constant * getSplatValue(bool AllowPoison=false) const
If all elements of the vector constant have the same value, return that value.
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.
This class represents an Operation in the Expression.
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:
PointerType * getType() const
NoCFIValue is always a pointer.
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 type whose size is a known multiple of vscale.
'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...