20#ifndef LLVM_IR_CONSTANTS_H
21#define LLVM_IR_CONSTANTS_H
44template <
class ConstantClass>
struct ConstantAggrKeyType;
61 void *
operator new(
size_t S) {
return User::operator
new(S, 0); }
64 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
70 return V->getValueID() >= ConstantDataFirstVal &&
71 V->getValueID() <= ConstantDataLastVal;
87 void destroyConstantImpl();
123 return get(Ty, V,
true);
126 return get(Ty, V,
true);
260 return V->getValueID() == ConstantIntVal;
275 void destroyConstantImpl();
301 APInt *Payload =
nullptr);
303 APInt *Payload =
nullptr);
342 return V->getValueID() == ConstantFPVal;
355 void destroyConstantImpl();
383 return V->getValueID() == ConstantAggregateZeroVal;
408 return V->getValueID() >= ConstantAggregateFirstVal &&
409 V->getValueID() <= ConstantAggregateLastVal;
428 void destroyConstantImpl();
447 return V->getValueID() == ConstantArrayVal;
460 void destroyConstantImpl();
467 template <
typename... Csts>
479 bool Packed =
false) {
486 bool Packed =
false);
490 bool Packed =
false);
499 return V->getValueID() == ConstantStructVal;
512 void destroyConstantImpl();
540 return V->getValueID() == ConstantVectorVal;
553 void destroyConstantImpl();
569 return V->getValueID() == ConstantPointerNullVal;
588 const char *DataElements;
594 std::unique_ptr<ConstantDataSequential> Next;
596 void destroyConstantImpl();
649 bool isString(
unsigned CharSize = 8)
const;
667 return Str.substr(0, Str.size() - 1);
677 return V->getValueID() == ConstantDataArrayVal ||
678 V->getValueID() == ConstantDataVectorVal;
682 const char *getElementPointer(
unsigned Elt)
const;
703 template <
typename ElementTy>
705 const char *
Data =
reinterpret_cast<const char *
>(Elts.
data());
707 Type::getScalarTy<ElementTy>(
Context));
712 template <
typename ArrayTy>
745 bool AddNull =
true);
755 return V->getValueID() == ConstantDataArrayVal;
772 mutable bool IsSplatSet : 1;
773 mutable bool IsSplat : 1;
774 bool isSplatData()
const;
832 return V->getValueID() == ConstantDataVectorVal;
845 void destroyConstantImpl();
855 return V->getValueID() == ConstantTokenNoneVal;
866 void destroyConstantImpl();
882 return V->getValueID() == ConstantTargetNoneVal;
893 void *
operator new(
size_t S) {
return User::operator
new(S, 2); }
895 void destroyConstantImpl();
899 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
921 return V->getValueID() == BlockAddressVal;
939 void *
operator new(
size_t S) {
return User::operator
new(S, 1); }
941 void destroyConstantImpl();
945 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
954 return cast<GlobalValue>(
Op<0>().
get());
959 return V->getValueID() == DSOLocalEquivalentVal;
976 void *
operator new(
size_t S) {
return User::operator
new(S, 1); }
978 void destroyConstantImpl();
989 return cast<GlobalValue>(
Op<0>().
get());
999 return V->getValueID() == NoCFIValueVal;
1020 void destroyConstantImpl();
1025 :
Constant(ty, ConstantExprVal, Ops, NumOps) {
1027 setValueSubclassData(Opcode);
1049 bool HasNSW =
false);
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);
1074 return getAdd(C1, C2,
false,
true);
1078 return getAdd(C1, C2,
true,
false);
1082 return getSub(C1, C2,
false,
true);
1086 return getSub(C1, C2,
true,
false);
1090 return getMul(C1, C2,
false,
true);
1094 return getMul(C1, C2,
true,
false);
1098 return getShl(C1, C2,
false,
true);
1102 return getShl(C1, C2,
true,
false);
1118 static Constant *getBinOpIdentity(
unsigned Opcode,
Type *Ty,
1119 bool AllowRHSConstant =
false,
1128 bool AllowRHSConstant =
false,
bool NSZ =
false);
1134 static Constant *getBinOpAbsorber(
unsigned Opcode,
Type *Ty);
1146 bool OnlyIfReduced =
false);
1163 static Constant *getPointerBitCastOrAddrSpaceCast(
1169 bool isCast()
const;
1172 bool isCompare()
const;
1179 unsigned Flags = 0,
Type *OnlyIfReducedTy =
nullptr);
1185 bool OnlyIfReduced =
false);
1191 bool OnlyIfReduced =
false);
1193 bool OnlyIfReduced =
false);
1202 bool InBounds =
false,
1203 std::optional<unsigned> InRangeIndex = std::nullopt,
1204 Type *OnlyIfReducedTy =
nullptr) {
1205 return getGetElementPtr(
1207 InBounds, InRangeIndex, OnlyIfReducedTy);
1211 std::optional<unsigned> InRangeIndex = std::nullopt,
1212 Type *OnlyIfReducedTy =
nullptr) {
1216 return getGetElementPtr(Ty,
C, cast<Value>(
Idx), InBounds, InRangeIndex,
1221 bool InBounds =
false,
1222 std::optional<unsigned> InRangeIndex = std::nullopt,
1223 Type *OnlyIfReducedTy =
nullptr);
1229 return getGetElementPtr(Ty,
C, IdxList,
true);
1236 return getGetElementPtr(Ty,
C,
Idx,
true);
1240 return getGetElementPtr(Ty,
C, IdxList,
true);
1244 Type *OnlyIfReducedTy =
nullptr);
1246 Type *OnlyIfReducedTy =
nullptr);
1249 Type *OnlyIfReducedTy =
nullptr);
1252 unsigned getOpcode()
const {
return getSubclassDataFromValue(); }
1256 unsigned getPredicate()
const;
1266 Constant *getShuffleMaskForBitcode()
const;
1275 return getWithOperands(Ops,
getType());
1288 bool OnlyIfReduced =
false,
1289 Type *SrcTy =
nullptr)
const;
1303 static bool isDesirableBinOp(
unsigned Opcode);
1307 static bool isSupportedBinOp(
unsigned Opcode);
1310 static bool isDesirableCastOp(
unsigned Opcode);
1313 static bool isSupportedCastOp(
unsigned Opcode);
1323 return V->getValueID() == ConstantExprVal;
1329 void setValueSubclassData(
unsigned short D) {
1355 void destroyConstantImpl();
1372 UndefValue *getStructElement(
unsigned Elt)
const;
1382 unsigned getNumElements()
const;
1386 return V->getValueID() == UndefValueVal ||
1387 V->getValueID() == PoisonValueVal;
1403 void destroyConstantImpl();
1428 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
#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 * getInBoundsGetElementPtr(Type *Ty, Constant *C, Constant *Idx)
static Constant * getNUWAdd(Constant *C1, Constant *C2)
static Constant * getNUWNeg(Constant *C)
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.
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.
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...