49 assert(
Op &&
Op->isCast() &&
"Can't fold cast of cast without a cast!");
54 Type *SrcTy =
Op->getOperand(0)->getType();
55 Type *MidTy =
Op->getType();
63 Type *SrcTy = V->getType();
67 if (V->isAllOnesValue())
84 return ConstantFP::get(
103 if (SrcTy->isPPC_FP128Ty())
111 return ConstantInt::get(DestTy,
FP->getValueAPF().bitcastToAPInt());
133 if (opc == Instruction::ZExt || opc == Instruction::SExt ||
134 opc == Instruction::UIToFP || opc == Instruction::SIToFP)
140 opc != Instruction::AddrSpaceCast)
156 if (DestTy->
isVectorTy() && V->getType()->isVectorTy() &&
190 case Instruction::FPTrunc:
191 case Instruction::FPExt:
194 APFloat Val = FPC->getValueAPF();
197 return ConstantFP::get(DestTy, Val);
200 case Instruction::FPToUI:
201 case Instruction::FPToSI:
203 const APFloat &V = FPC->getValueAPF();
212 return ConstantInt::get(DestTy, IntVal);
215 case Instruction::UIToFP:
216 case Instruction::SIToFP:
218 const APInt &api = CI->getValue();
223 return ConstantFP::get(DestTy, apf);
226 case Instruction::ZExt:
229 return ConstantInt::get(DestTy, CI->getValue().zext(
BitWidth));
232 case Instruction::SExt:
235 return ConstantInt::get(DestTy, CI->getValue().sext(
BitWidth));
238 case Instruction::Trunc: {
241 return ConstantInt::get(DestTy, CI->getValue().trunc(
BitWidth));
246 case Instruction::BitCast:
248 case Instruction::AddrSpaceCast:
249 case Instruction::IntToPtr:
250 case Instruction::PtrToAddr:
251 case Instruction::PtrToInt:
259 if (
Cond->isNullValue())
return V2;
260 if (
Cond->isAllOnesValue())
return V1;
264 auto *V1VTy = CondV->getType();
267 for (
unsigned i = 0, e = V1VTy->getNumElements(); i != e; ++i) {
270 ConstantInt::get(Ty, i));
272 ConstantInt::get(Ty, i));
276 }
else if (V1Element == V2Element) {
282 V =
Cond->isNullValue() ? V2Element : V1Element;
288 if (Result.size() == V1VTy->getNumElements())
300 if (V1 == V2)
return V1;
322 if (
C->getType()->isVectorTy())
323 return !
C->containsPoisonElement() && !
C->containsConstantExpression();
353 if (CIdx->uge(ValFVTy->getNumElements()))
361 Ops.reserve(CE->getNumOperands());
362 for (
unsigned i = 0, e = CE->getNumOperands(); i != e; ++i) {
364 if (
Op->getType()->isVectorTy()) {
368 Ops.push_back(ScalarOp);
372 return CE->getWithOperands(
Ops, ValVTy->getElementType(),
false,
373 GEP->getSourceElementType());
374 }
else if (CE->getOpcode() == Instruction::InsertElement) {
377 APSInt(CIdx->getValue()))) {
378 return CE->getOperand(1);
390 if (CIdx->getValue().ult(ValVTy->getElementCount().getKnownMinValue())) {
410 if (!CIdx)
return nullptr;
419 unsigned NumElts = ValTy->getNumElements();
420 if (CIdx->
uge(NumElts))
424 Result.reserve(NumElts);
427 for (
unsigned i = 0; i != NumElts; ++i) {
429 Result.push_back(Elt);
443 unsigned MaskNumElts = Mask.size();
446 Type *EltTy = V1VTy->getElementType();
455 if (
all_of(Mask, [](
int Elt) {
return Elt == 0; })) {
471 unsigned SrcNumElts = V1VTy->getElementCount().getKnownMinValue();
475 for (
unsigned i = 0; i != MaskNumElts; ++i) {
482 if (
unsigned(Elt) >= SrcNumElts*2)
484 else if (
unsigned(Elt) >= SrcNumElts) {
488 ConstantInt::get(Ty, Elt - SrcNumElts));
493 Result.push_back(InElt);
520 NumElts = ST->getNumElements();
525 for (
unsigned i = 0; i != NumElts; ++i) {
527 if (!
C)
return nullptr;
546 bool HasScalarUndefOrScalableVectorUndef =
549 if (HasScalarUndefOrScalableVectorUndef) {
551 case Instruction::FNeg:
553 case Instruction::UnaryOpsEnd:
559 assert(!HasScalarUndefOrScalableVectorUndef &&
"Unexpected UndefValue");
564 const APFloat &CV = CFP->getValueAPF();
568 case Instruction::FNeg:
569 return ConstantFP::get(
C->getType(),
neg(CV));
581 for (
unsigned i = 0, e = FVTy->getNumElements(); i != e; ++i) {
582 Constant *ExtractIdx = ConstantInt::get(Ty, i);
587 Result.push_back(Res);
605 Opcode, C1->
getType(),
false)) {
611 Opcode, C1->
getType(),
true)) {
623 bool HasScalarUndefOrScalableVectorUndef =
624 (!C1->
getType()->isVectorTy() || IsScalableVector) &&
626 if (HasScalarUndefOrScalableVectorUndef) {
628 case Instruction::Xor:
634 case Instruction::Add:
635 case Instruction::Sub:
637 case Instruction::And:
641 case Instruction::Mul: {
654 case Instruction::SDiv:
655 case Instruction::UDiv:
662 case Instruction::URem:
663 case Instruction::SRem:
670 case Instruction::Or:
674 case Instruction::LShr:
680 case Instruction::AShr:
687 case Instruction::Shl:
693 case Instruction::FSub:
698 case Instruction::FAdd:
699 case Instruction::FMul:
700 case Instruction::FDiv:
701 case Instruction::FRem:
713 case Instruction::BinaryOpsEnd:
719 assert((!HasScalarUndefOrScalableVectorUndef) &&
"Unexpected UndefValue");
728 case Instruction::UDiv:
729 case Instruction::SDiv:
733 case Instruction::URem:
734 case Instruction::SRem:
740 case Instruction::And:
741 assert(!CI2->isZero() &&
"And zero handled above");
744 if (CE1->getOpcode() == Instruction::PtrToInt &&
770 unsigned DstWidth = CI2->getBitWidth();
771 unsigned SrcWidth = std::min(DstWidth,
Log2(GVAlign));
775 if ((CI2->getValue() & BitsNotSet) == CI2->getValue())
792 const APInt &C1V = CI1->getValue();
793 const APInt &C2V = CI2->getValue();
797 case Instruction::Add:
798 return ConstantInt::get(C1->
getType(), C1V + C2V);
799 case Instruction::Sub:
800 return ConstantInt::get(C1->
getType(), C1V - C2V);
801 case Instruction::Mul:
802 return ConstantInt::get(C1->
getType(), C1V * C2V);
803 case Instruction::UDiv:
804 assert(!CI2->isZero() &&
"Div by zero handled above");
805 return ConstantInt::get(CI1->getType(), C1V.
udiv(C2V));
806 case Instruction::SDiv:
807 assert(!CI2->isZero() &&
"Div by zero handled above");
810 return ConstantInt::get(CI1->getType(), C1V.
sdiv(C2V));
811 case Instruction::URem:
812 assert(!CI2->isZero() &&
"Div by zero handled above");
813 return ConstantInt::get(C1->
getType(), C1V.
urem(C2V));
814 case Instruction::SRem:
815 assert(!CI2->isZero() &&
"Div by zero handled above");
818 return ConstantInt::get(C1->
getType(), C1V.
srem(C2V));
819 case Instruction::And:
820 return ConstantInt::get(C1->
getType(), C1V & C2V);
821 case Instruction::Or:
822 return ConstantInt::get(C1->
getType(), C1V | C2V);
823 case Instruction::Xor:
824 return ConstantInt::get(C1->
getType(), C1V ^ C2V);
825 case Instruction::Shl:
827 return ConstantInt::get(C1->
getType(), C1V.
shl(C2V));
829 case Instruction::LShr:
831 return ConstantInt::get(C1->
getType(), C1V.
lshr(C2V));
833 case Instruction::AShr:
835 return ConstantInt::get(C1->
getType(), C1V.
ashr(C2V));
845 const APFloat &C1V = CFP1->getValueAPF();
846 const APFloat &C2V = CFP2->getValueAPF();
851 case Instruction::FAdd:
853 return ConstantFP::get(C1->
getType(), C3V);
854 case Instruction::FSub:
856 return ConstantFP::get(C1->
getType(), C3V);
857 case Instruction::FMul:
859 return ConstantFP::get(C1->
getType(), C3V);
860 case Instruction::FDiv:
862 return ConstantFP::get(C1->
getType(), C3V);
863 case Instruction::FRem:
865 return ConstantFP::get(C1->
getType(), C3V);
890 for (
unsigned i = 0, e = FVTy->getNumElements(); i != e; ++i) {
891 Constant *ExtractIdx = ConstantInt::get(Ty, i);
899 Result.push_back(Res);
928 case Instruction::Add:
929 case Instruction::Sub:
931 case Instruction::Shl:
932 case Instruction::LShr:
933 case Instruction::AShr:
937 case Instruction::SDiv:
938 case Instruction::UDiv:
942 case Instruction::URem:
943 case Instruction::SRem:
958 auto isGlobalUnsafeForEquality = [](
const GlobalValue *GV) {
959 if (GV->isInterposable() || GV->hasGlobalUnnamedAddr())
962 Type *Ty = GVar->getValueType();
975 if (!isGlobalUnsafeForEquality(GV1) && !isGlobalUnsafeForEquality(GV2))
988 "Cannot compare different types of values!");
999 auto GetComplexity = [](
Constant *V) {
1008 if (GetComplexity(V1) < GetComplexity(V2)) {
1021 if (BA2->getFunction() != BA->getFunction())
1041 GV->getType()->getAddressSpace()))
1049 switch (CE1->getOpcode()) {
1050 case Instruction::GetElementPtr: {
1060 if (!GV->hasExternalWeakLinkage() && CE1GEP->
isInBounds())
1077 if (CE1Op0 != CE2Op0) {
1100 VT->getElementCount());
1125 if (isIntegerPredicate)
1146 switch (Predicate) {
1185 for (
unsigned I = 0, E = C1VTy->getElementCount().getKnownMinValue();
1222 switch (Predicate) {
1232 switch (Predicate) {
1242 switch (Predicate) {
1252 switch (Predicate) {
1295 return ConstantInt::get(ResultTy, Result);
1310 std::optional<ConstantRange>
InRange,
1312 if (Idxs.
empty())
return C;
1323 auto IsNoOp = [&]() {
1334 return GEPTy->
isVectorTy() && !
C->getType()->isVectorTy()
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file implements the APSInt class, which is a simple class that represents an arbitrary sized int...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static unsigned foldConstantCastPair(unsigned opc, ConstantExpr *Op, Type *DstTy)
This function determines which opcode to use to fold two constant cast expressions together.
static Constant * foldMaybeUndesirableCast(unsigned opc, Constant *V, Type *DestTy)
static ICmpInst::Predicate areGlobalsPotentiallyEqual(const GlobalValue *GV1, const GlobalValue *GV2)
static Constant * FoldBitCast(Constant *V, Type *DestTy)
static ICmpInst::Predicate evaluateICmpRelation(Constant *V1, Constant *V2)
This function determines if there is anything we can decide about the two constants provided.
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Module.h This file contains the declarations for the Module class.
const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]
static bool InRange(int64_t Value, unsigned short Shift, int LBound, int HBound)
const SmallVectorImpl< MachineOperand > & Cond
This file defines the SmallVector class.
static std::optional< unsigned > getOpcode(ArrayRef< VPValue * > Values)
Returns the opcode of Values or ~0 if they do not all agree.
opStatus divide(const APFloat &RHS, roundingMode RM)
LLVM_ABI opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
opStatus subtract(const APFloat &RHS, roundingMode RM)
opStatus add(const APFloat &RHS, roundingMode RM)
opStatus convertFromAPInt(const APInt &Input, bool IsSigned, roundingMode RM)
opStatus multiply(const APFloat &RHS, roundingMode RM)
opStatus mod(const APFloat &RHS)
Class for arbitrary precision integers.
LLVM_ABI APInt udiv(const APInt &RHS) const
Unsigned division operation.
bool isMinSignedValue() const
Determine if this is the smallest signed value.
LLVM_ABI APInt urem(const APInt &RHS) const
Unsigned remainder operation.
unsigned getBitWidth() const
Return the number of bits in the APInt.
LLVM_ABI APInt sdiv(const APInt &RHS) const
Signed division function for APInt.
APInt ashr(unsigned ShiftAmt) const
Arithmetic right-shift function.
LLVM_ABI APInt srem(const APInt &RHS) const
Function for signed remainder operation.
APInt shl(unsigned shiftAmt) const
Left-shift function.
static APInt getLowBitsSet(unsigned numBits, unsigned loBitsSet)
Constructs an APInt value that has the bottom loBitsSet bits set.
static APInt getZero(unsigned numBits)
Get the '0' value for the specified bit-width.
APInt lshr(unsigned shiftAmt) const
Logical right-shift function.
An arbitrary precision integer that knows its signedness.
static bool isSameValue(const APSInt &I1, const APSInt &I2)
Determine if two APSInts have the same value, zero- or sign-extending as needed.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
size - Get the array size.
bool empty() const
empty - Check if the array is empty.
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array.
The address of a basic block.
static LLVM_ABI unsigned isEliminableCastPair(Instruction::CastOps firstOpcode, Instruction::CastOps secondOpcode, Type *SrcTy, Type *MidTy, Type *DstTy, const DataLayout *DL)
Determine how a pair of casts can be eliminated, if they can be at all.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
@ FCMP_TRUE
1 1 1 1 Always true (always folded)
@ ICMP_SLT
signed less than
@ ICMP_SLE
signed less or equal
@ ICMP_UGE
unsigned greater or equal
@ ICMP_UGT
unsigned greater than
@ ICMP_SGT
signed greater than
@ FCMP_ONE
0 1 1 0 True if ordered and operands are unequal
@ FCMP_UEQ
1 0 0 1 True if unordered or equal
@ ICMP_ULT
unsigned less than
@ ICMP_SGE
signed greater or equal
@ ICMP_ULE
unsigned less or equal
@ FCMP_FALSE
0 0 0 0 Always false (always folded)
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
bool isTrueWhenEqual() const
This is just a convenience.
static LLVM_ABI bool isUnordered(Predicate predicate)
Determine if the predicate is an unordered operation.
static bool isIntPredicate(Predicate P)
static LLVM_ABI Constant * get(ArrayType *T, ArrayRef< Constant * > V)
A constant value that is initialized with an expression using other constant values.
static LLVM_ABI Constant * getExtractElement(Constant *Vec, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
static LLVM_ABI bool isDesirableCastOp(unsigned Opcode)
Whether creating a constant expression for this cast is desirable.
static LLVM_ABI Constant * getBinOpAbsorber(unsigned Opcode, Type *Ty, bool AllowLHSConstant=false)
Return the absorbing element for the given binary operation, i.e.
static LLVM_ABI Constant * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)
Convenience function for getting a Cast operation.
static LLVM_ABI Constant * getNot(Constant *C)
static LLVM_ABI Constant * getXor(Constant *C1, Constant *C2)
static LLVM_ABI Constant * get(unsigned Opcode, Constant *C1, Constant *C2, unsigned Flags=0, Type *OnlyIfReducedTy=nullptr)
get - Return a binary or shift operator constant expression, folding if possible.
static LLVM_ABI bool isDesirableBinOp(unsigned Opcode)
Whether creating a constant expression for this binary operator is desirable.
static LLVM_ABI Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static LLVM_ABI Constant * getBinOpIdentity(unsigned Opcode, Type *Ty, bool AllowRHSConstant=false, bool NSZ=false)
Return the identity constant for a binary opcode.
ConstantFP - Floating Point Values [float, double].
static LLVM_ABI Constant * getNaN(Type *Ty, bool Negative=false, uint64_t Payload=0)
This is the shared class of boolean and integer constants.
static LLVM_ABI ConstantInt * getTrue(LLVMContext &Context)
static LLVM_ABI ConstantInt * getFalse(LLVMContext &Context)
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
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 LLVM_ABI Constant * get(StructType *T, ArrayRef< Constant * > V)
Constant Vector Declarations.
static LLVM_ABI Constant * getSplat(ElementCount EC, Constant *Elt)
Return a ConstantVector with the specified constant in each element.
static LLVM_ABI Constant * get(ArrayRef< Constant * > V)
This is an important base class in LLVM.
LLVM_ABI Constant * getSplatValue(bool AllowPoison=false) const
If all elements of the vector constant have the same value, return that value.
static LLVM_ABI Constant * getAllOnesValue(Type *Ty)
static LLVM_ABI Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
LLVM_ABI Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
LLVM_ABI bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
A parsed version of the target data layout string in and methods for querying it.
static constexpr ElementCount get(ScalarTy MinVal, bool Scalable)
static LLVM_ABI bool compare(const APFloat &LHS, const APFloat &RHS, FCmpInst::Predicate Pred)
Return result of LHS Pred RHS comparison.
bool isInBounds() const
Test whether this is an inbounds GEP, as defined by LangRef.html.
bool hasAllZeroIndices() const
Return true if all of the indices of this GEP are zeros.
static Type * getGEPReturnType(Value *Ptr, ArrayRef< Value * > IdxList)
Returns the pointer type returned by the GEP instruction, which may be a vector of pointers.
Module * getParent()
Get the module that this global value is contained inside of...
static LLVM_ABI bool compare(const APInt &LHS, const APInt &RHS, ICmpInst::Predicate Pred)
Return result of LHS Pred RHS comparison.
static bool isEquality(Predicate P)
Return true if this predicate is either EQ or NE.
LLVM_ABI bool isAssociative() const LLVM_READONLY
Return true if the instruction is associative:
LLVM_ABI bool isCommutative() const LLVM_READONLY
Return true if the instruction is commutative:
static LLVM_ABI IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
A Module instance is used to store all the information related to an LLVM module.
static LLVM_ABI PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Class to represent struct types.
The instances of the Type class are immutable: once they are created, they are never changed.
bool isVectorTy() const
True if this is an instance of VectorType.
static LLVM_ABI IntegerType * getInt32Ty(LLVMContext &C)
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
bool isPointerTy() const
True if this is an instance of PointerType.
bool isPPC_FP128Ty() const
Return true if this is powerpc long double.
LLVM_ABI bool isFirstClassType() const
Return true if the type is "first class", meaning it is a valid type for a Value.
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
LLVM_ABI unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
static LLVM_ABI IntegerType * getInt1Ty(LLVMContext &C)
bool isX86_AMXTy() const
Return true if this is X86 AMX.
bool isIntegerTy() const
True if this is an instance of IntegerType.
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
LLVM_ABI const fltSemantics & getFltSemantics() const
static LLVM_ABI UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Value * getOperand(unsigned i) const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
LLVM_ABI Align getPointerAlignment(const DataLayout &DL) const
Returns an alignment of the pointer value.
LLVM_ABI LLVMContext & getContext() const
All values hold a context through their type.
Base class of all SIMD vector types.
static LLVM_ABI VectorType * get(Type *ElementType, ElementCount EC)
This static method is the primary way to construct an VectorType.
Type * getElementType() const
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
ap_match< APInt > m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
bool match(Val *V, const Pattern &P)
cstfp_pred_ty< is_neg_zero_fp > m_NegZeroFP()
Match a floating-point negative zero.
auto m_Undef()
Match an arbitrary undef constant.
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
This is an optimization pass for GlobalISel generic memory operations.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
LLVM_ABI Constant * ConstantFoldSelectInstruction(Constant *Cond, Constant *V1, Constant *V2)
Attempt to constant fold a select instruction with the specified operands.
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
LLVM_ABI Constant * ConstantFoldCompareInstruction(CmpInst::Predicate Predicate, Constant *C1, Constant *C2)
LLVM_ABI Constant * ConstantFoldUnaryInstruction(unsigned Opcode, Constant *V)
LLVM_ABI Constant * ConstantFoldGetElementPtr(Type *Ty, Constant *C, std::optional< ConstantRange > InRange, ArrayRef< Value * > Idxs)
LLVM_ABI Constant * ConstantFoldExtractValueInstruction(Constant *Agg, ArrayRef< unsigned > Idxs)
Attempt to constant fold an extractvalue instruction with the specified operands and indices.
LLVM_ABI bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
LLVM_ABI Constant * ConstantFoldInsertElementInstruction(Constant *Val, Constant *Elt, Constant *Idx)
Attempt to constant fold an insertelement instruction with the specified operands and indices.
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
constexpr int PoisonMaskElem
LLVM_ABI Constant * ConstantFoldExtractElementInstruction(Constant *Val, Constant *Idx)
Attempt to constant fold an extractelement instruction with the specified operands and indices.
DWARFExpression::Operation Op
ArrayRef(const T &OneElt) -> ArrayRef< T >
constexpr unsigned BitWidth
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
APFloat neg(APFloat X)
Returns the negated value of the argument.
LLVM_ABI Constant * ConstantFoldCastInstruction(unsigned opcode, Constant *V, Type *DestTy)
LLVM_ABI Constant * ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val, ArrayRef< unsigned > Idxs)
ConstantFoldInsertValueInstruction - Attempt to constant fold an insertvalue instruction with the spe...
unsigned Log2(Align A)
Returns the log2 of the alignment.
LLVM_ABI Constant * ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2, ArrayRef< int > Mask)
Attempt to constant fold a shufflevector instruction with the specified operands and mask.
LLVM_ABI Constant * ConstantFoldBinaryInstruction(unsigned Opcode, Constant *V1, Constant *V2)
static constexpr roundingMode rmNearestTiesToEven
static constexpr roundingMode rmTowardZero
This struct is a compact representation of a valid (non-zero power of two) alignment.