32#include "llvm/Config/config.h"
46#include "llvm/IR/IntrinsicsAArch64.h"
47#include "llvm/IR/IntrinsicsAMDGPU.h"
48#include "llvm/IR/IntrinsicsARM.h"
49#include "llvm/IR/IntrinsicsNVPTX.h"
50#include "llvm/IR/IntrinsicsWebAssembly.h"
51#include "llvm/IR/IntrinsicsX86.h"
69 "disable-fp-call-folding",
70 cl::desc(
"Disable constant-folding of FP intrinsics and libcalls."),
85 unsigned BitShift =
DL.getTypeSizeInBits(SrcEltTy);
86 for (
unsigned i = 0; i != NumSrcElts; ++i) {
88 if (
DL.isLittleEndian())
89 Element =
C->getAggregateElement(NumSrcElts - i - 1);
91 Element =
C->getAggregateElement(i);
103 Result |= ElementCI->getValue().zext(
Result.getBitWidth());
116static bool foldMixesPoisonBits(
Constant *
C,
unsigned NumSrcElt,
117 unsigned NumDstElt) {
120 if (NumSrcElt % NumDstElt != 0)
121 return C->containsPoisonElement();
122 unsigned Ratio = NumSrcElt / NumDstElt;
123 for (
unsigned i = 0; i != NumSrcElt; i += Ratio) {
124 bool HasPoison =
false;
125 bool HasNonPoison =
false;
126 for (
unsigned j = 0;
j != Ratio; ++
j) {
127 Constant *Src =
C->getAggregateElement(i + j);
136 if (HasPoison && HasNonPoison)
146static bool computePoisonDstLanes(
Constant *
C,
unsigned NumSrcElt,
151 if ((NumDstElt < NumSrcElt ? NumSrcElt % NumDstElt : NumDstElt % NumSrcElt))
152 return !
C->containsPoisonElement();
153 if (NumDstElt < NumSrcElt) {
154 unsigned Ratio = NumSrcElt / NumDstElt;
155 for (
unsigned i = 0; i != NumDstElt; ++i) {
156 for (
unsigned j = 0;
j != Ratio; ++
j) {
157 Constant *Src =
C->getAggregateElement(i * Ratio + j);
161 PoisonDstElts[i] =
true;
167 unsigned Ratio = NumDstElt / NumSrcElt;
168 for (
unsigned i = 0; i != NumSrcElt; ++i) {
169 Constant *Src =
C->getAggregateElement(i);
173 PoisonDstElts.
set(i * Ratio, (i + 1) * Ratio);
184 "Invalid constantexpr bitcast!");
195 Type *SrcEltTy = VTy->getElementType();
199 (
C->containsPoisonElement() || SrcEltTy->
isPointerTy()))
204 if (SrcEltTy->
isByteTy() &&
C->containsPoisonElement())
222 if (
Constant *CE = foldConstVectorToAPInt(Result, DestTy,
C, SrcEltTy,
228 return ConstantInt::get(DestTy, Result);
231 return ConstantByte::get(DestTy->
getContext(), Result);
264 if (NumDstElt == NumSrcElt)
268 Type *DstEltTy = DestVTy->getElementType();
297 if (NumDstElt < NumSrcElt && foldMixesPoisonBits(
C, NumSrcElt, NumDstElt))
318 "Constant folding cannot fail for plain fp->int bitcast!");
327 if (!computePoisonDstLanes(
C, NumSrcElt, NumDstElt, PoisonDstElts))
337 "Constant folding cannot fail for plain byte->int bitcast!");
344 bool isLittleEndian =
DL.isLittleEndian();
350 APInt Buffer(2 * std::max(SrcBitSize, DstBitSize), 0);
351 APInt UndefMask(Buffer.getBitWidth(), 0);
352 APInt PoisonMask(Buffer.getBitWidth(), 0);
353 unsigned BufferBitSize = 0;
355 while (
Result.size() != NumDstElt) {
357 while (BufferBitSize < DstBitSize) {
358 Constant *Element =
C->getAggregateElement(SrcElt++);
363 if (!isLittleEndian) {
364 Buffer <<= SrcBitSize;
365 UndefMask <<= SrcBitSize;
366 PoisonMask <<= SrcBitSize;
370 unsigned BitPosition = isLittleEndian ? BufferBitSize : 0;
373 UndefMask.setBits(BitPosition, BitPosition + SrcBitSize);
375 PoisonMask.setBits(BitPosition, BitPosition + SrcBitSize);
381 SrcValue = Src->getValue();
385 Buffer.insertBits(SrcValue, BitPosition);
386 BufferBitSize += SrcBitSize;
390 while (BufferBitSize >= DstBitSize) {
391 unsigned ShiftAmt = isLittleEndian ? 0 : BufferBitSize - DstBitSize;
393 if (UndefMask.extractBits(DstBitSize, ShiftAmt).isAllOnes()) {
395 if (!PoisonMask.extractBits(DstBitSize, ShiftAmt).isZero()) {
403 Result.push_back(ConstantInt::get(DstEltTy, Elt));
407 if (isLittleEndian) {
408 Buffer.lshrInPlace(DstBitSize);
409 UndefMask.lshrInPlace(DstBitSize);
410 PoisonMask.lshrInPlace(DstBitSize);
412 BufferBitSize -= DstBitSize;
417 for (
unsigned I : PoisonDstElts.
set_bits())
442 *DSOEquiv = FoundDSOEquiv;
443 GV = FoundDSOEquiv->getGlobalValue();
451 if (!CE)
return false;
454 if (CE->getOpcode() == Instruction::PtrToInt ||
455 CE->getOpcode() == Instruction::PtrToAddr)
464 unsigned BitWidth =
DL.getIndexTypeSizeInBits(
GEP->getType());
473 if (!
GEP->accumulateConstantOffset(
DL, TmpOffset))
483 Type *SrcTy =
C->getType();
487 TypeSize DestSize =
DL.getTypeSizeInBits(DestTy);
488 TypeSize SrcSize =
DL.getTypeSizeInBits(SrcTy);
500 if (SrcSize == DestSize &&
501 DL.isNonIntegralPointerType(SrcTy->getScalarType()) ==
507 Cast = Instruction::IntToPtr;
508 else if (SrcTy->isPointerTy() && DestTy->
isIntegerTy())
509 Cast = Instruction::PtrToInt;
517 if (!SrcTy->isAggregateType() && !SrcTy->isVectorTy())
524 if (SrcTy->isStructTy()) {
530 ElemC =
C->getAggregateElement(Elem++);
531 }
while (ElemC &&
DL.getTypeSizeInBits(ElemC->
getType()).isZero());
537 if (!
DL.typeSizeEqualsStoreSize(VT->getElementType()))
540 C =
C->getAggregateElement(0u);
553 return Ty->isByteOrByteVectorTy();
566 bool IsByteLoad =
false) {
567 assert(ByteOffset <=
DL.getTypeAllocSize(
C->getType()) &&
568 "Out of range access");
571 if (ByteOffset >=
DL.getTypeStoreSize(
C->getType()))
580 if (CI && CI->getType()->isIntegerTy()) {
581 if ((CI->getBitWidth() & 7) != 0)
583 const APInt &Val = CI->getValue();
584 unsigned IntBytes =
unsigned(CI->getBitWidth()/8);
586 for (
unsigned i = 0; i != BytesLeft && ByteOffset != IntBytes; ++i) {
587 unsigned n = ByteOffset;
588 if (!
DL.isLittleEndian())
589 n = IntBytes - n - 1;
598 if (CB && CB->getType()->isByteTy())
599 return ReadDataFromGlobal(ConstantInt::get(
C->getContext(), CB->getValue()),
600 ByteOffset, CurPtr, BytesLeft,
DL, IsByteLoad);
603 if (CFP && CFP->getType()->isFloatingPointTy()) {
604 if (CFP->getType()->isDoubleTy()) {
606 return ReadDataFromGlobal(
C, ByteOffset, CurPtr, BytesLeft,
DL,
609 if (CFP->getType()->isFloatTy()){
611 return ReadDataFromGlobal(
C, ByteOffset, CurPtr, BytesLeft,
DL,
614 if (CFP->getType()->isHalfTy()){
616 return ReadDataFromGlobal(
C, ByteOffset, CurPtr, BytesLeft,
DL,
626 ByteOffset -= CurEltOffset;
631 uint64_t EltSize =
DL.getTypeAllocSize(CS->getOperand(Index)->getType());
633 if (ByteOffset < EltSize &&
634 !ReadDataFromGlobal(CS->getOperand(Index), ByteOffset, CurPtr,
635 BytesLeft,
DL, IsByteLoad))
641 if (Index == CS->getType()->getNumElements())
647 if (BytesLeft <= NextEltOffset - CurEltOffset - ByteOffset)
651 CurPtr += NextEltOffset - CurEltOffset - ByteOffset;
652 BytesLeft -= NextEltOffset - CurEltOffset - ByteOffset;
654 CurEltOffset = NextEltOffset;
665 NumElts = AT->getNumElements();
666 EltTy = AT->getElementType();
667 EltSize =
DL.getTypeAllocSize(EltTy);
673 if (!
DL.typeSizeEqualsStoreSize(EltTy))
676 EltSize =
DL.getTypeStoreSize(EltTy);
678 uint64_t Index = ByteOffset / EltSize;
681 for (; Index != NumElts; ++Index) {
682 if (!ReadDataFromGlobal(
C->getAggregateElement(Index),
Offset, CurPtr,
683 BytesLeft,
DL, IsByteLoad))
687 assert(BytesWritten <= EltSize &&
"Not indexing into this element?");
688 if (BytesWritten >= BytesLeft)
692 BytesLeft -= BytesWritten;
693 CurPtr += BytesWritten;
699 if (
CE->getOpcode() == Instruction::IntToPtr &&
700 CE->getOperand(0)->getType() ==
DL.getIntPtrType(
CE->getType())) {
705 return ReadDataFromGlobal(
CE->getOperand(0), ByteOffset, CurPtr,
706 BytesLeft,
DL, IsByteLoad);
740 Type *ByteTy =
DL.getBytePtrType(LoadTy);
742 FoldReinterpretLoadFromConst(
C, ByteTy, ByteTy,
Offset,
DL))
747 DL.getTypeSizeInBits(LoadTy).getFixedValue());
749 FoldReinterpretLoadFromConst(
C, MapTy, OrigLoadTy,
Offset,
DL)) {
769 unsigned BytesLoaded = (IntType->getBitWidth() + 7) / 8;
771 if (BytesLoaded > 128 || BytesLoaded == 0)
780 if (
Offset <= -1 *
static_cast<int64_t
>(BytesLoaded))
784 TypeSize InitializerSize =
DL.getTypeAllocSize(
C->getType());
793 unsigned char *CurPtr = RawBytes.data();
794 unsigned BytesLeft = BytesLoaded;
803 if (!ReadDataFromGlobal(
C,
Offset, CurPtr, BytesLeft,
DL,
807 APInt ResultVal =
APInt(IntType->getBitWidth(), 0);
808 if (
DL.isLittleEndian()) {
809 ResultVal = RawBytes[BytesLoaded - 1];
810 for (
unsigned i = 1; i != BytesLoaded; ++i) {
812 ResultVal |= RawBytes[BytesLoaded - 1 - i];
815 ResultVal = RawBytes[0];
816 for (
unsigned i = 1; i != BytesLoaded; ++i) {
818 ResultVal |= RawBytes[i];
822 return ConstantInt::get(IntType->getContext(), ResultVal);
841 uint64_t NBytes = InitSize -
Offset;
842 if (NBytes > UINT16_MAX)
850 unsigned char *CurPtr = RawBytes.
data();
852 if (!ReadDataFromGlobal(
Init,
Offset, CurPtr, NBytes,
DL))
870 if (!
Offset.isZero() || !Indices[0].isZero())
875 if (Index.isNegative() || Index.getActiveBits() >= 32)
878 C =
C->getAggregateElement(Index.getZExtValue());
904 if (
Offset.getSignificantBits() <= 64)
906 FoldReinterpretLoadFromConst(
C, Ty, Ty,
Offset.getSExtValue(),
DL))
923 if (!GV || !GV->isConstant() || !GV->hasDefinitiveInitializer())
953 if (!
DL.typeSizeEqualsStoreSize(
C->getType()))
955 if (
C->isNullValue() && !Ty->isX86_AMXTy())
957 if (
C->isAllOnesValue() &&
958 (Ty->isIntOrIntVectorTy() || Ty->isByteOrByteVectorTy() ||
959 Ty->isFPOrFPVectorTy()))
978 if (
Opc == Instruction::And) {
981 if ((Known1.
One | Known0.
Zero).isAllOnes()) {
985 if ((Known0.
One | Known1.
Zero).isAllOnes()) {
997 if (
Opc == Instruction::Sub) {
1003 unsigned OpSize =
DL.getTypeSizeInBits(Op0->
getType());
1020 std::optional<ConstantRange>
InRange,
1022 Type *IntIdxTy =
DL.getIndexType(ResultTy);
1027 for (
unsigned i = 1, e =
Ops.size(); i != e; ++i) {
1030 SrcElemTy,
Ops.slice(1, i - 1)))) &&
1031 Ops[i]->getType()->getScalarType() != IntIdxScalarTy) {
1034 Ops[i]->getType()->isVectorTy() ? IntIdxTy : IntIdxScalarTy;
1060 Type *SrcElemTy =
GEP->getSourceElementType();
1065 if (
Constant *
C = CastGEPIndices(SrcElemTy,
Ops, ResTy,
GEP->getNoWrapFlags(),
1075 for (
unsigned i = 1, e =
Ops.size(); i != e; ++i)
1079 unsigned BitWidth =
DL.getTypeSizeInBits(IntIdxTy);
1082 reinterpret_cast<const Value *
const *
>(
Ops.data()) + 1,
Ops.size() - 1);
1086 std::optional<ConstantRange>
InRange =
GEP->getInRange();
1092 bool Overflow =
false;
1094 NW &=
GEP->getNoWrapFlags();
1098 if (!
GEP->accumulateConstantOffset(
DL, NestedOffset))
1102 if (
auto GEPRange =
GEP->getInRange()) {
1103 auto AdjustedGEPRange = GEPRange->sextOrTrunc(
BitWidth).subtract(
Offset);
1105 InRange ?
InRange->intersectWith(AdjustedGEPRange) : AdjustedGEPRange;
1109 SrcElemTy =
GEP->getSourceElementType();
1120 APInt BaseIntVal(
DL.getPointerTypeSizeInBits(Ptr->
getType()), 0);
1122 if (
CE->getOpcode() == Instruction::IntToPtr) {
1124 BaseIntVal =
Base->getValue().zextOrTrunc(BaseIntVal.getBitWidth());
1129 !
DL.mustNotIntroduceIntToPtr(Ptr->
getType())) {
1142 DL, CanBeNull,
nullptr);
1143 if (DerefBytes != 0 && !CanBeNull &&
Offset.sle(DerefBytes))
1162Constant *ConstantFoldInstOperandsImpl(
const Value *InstOrCE,
unsigned Opcode,
1166 bool AllowNonDeterministic) {
1176 case Instruction::FAdd:
1177 case Instruction::FSub:
1178 case Instruction::FMul:
1179 case Instruction::FDiv:
1180 case Instruction::FRem:
1186 AllowNonDeterministic);
1196 Type *SrcElemTy =
GEP->getSourceElementType();
1204 GEP->getNoWrapFlags(),
1209 return CE->getWithOperands(
Ops);
1212 default:
return nullptr;
1213 case Instruction::ICmp:
1214 case Instruction::FCmp: {
1217 DL,
TLI,
C->getFunction());
1219 case Instruction::Freeze:
1221 case Instruction::Call:
1226 AllowNonDeterministic);
1229 case Instruction::Select:
1231 case Instruction::ExtractElement:
1233 case Instruction::ExtractValue:
1236 case Instruction::InsertElement:
1238 case Instruction::InsertValue:
1241 case Instruction::ShuffleVector:
1244 case Instruction::BitInsert:
1246 case Instruction::BitExtract:
1249 case Instruction::Load: {
1251 if (LI->isVolatile())
1274 for (
const Use &OldU :
C->operands()) {
1280 auto It = FoldedOps.
find(OldC);
1281 if (It == FoldedOps.
end()) {
1282 NewC = ConstantFoldConstantImpl(OldC,
DL,
TLI, FoldedOps);
1283 FoldedOps.
insert({OldC, NewC});
1288 Ops.push_back(NewC);
1292 if (
Constant *Res = ConstantFoldInstOperandsImpl(
1312 for (
Value *Incoming : PN->incoming_values()) {
1324 C = ConstantFoldConstantImpl(
C,
DL,
TLI, FoldedOps);
1327 if (CommonValue &&
C != CommonValue)
1338 if (!
all_of(
I->operands(), [](
const Use &U) { return isa<Constant>(U); }))
1343 for (
const Use &OpU :
I->operands()) {
1346 Op = ConstantFoldConstantImpl(
Op,
DL,
TLI, FoldedOps);
1356 return ConstantFoldConstantImpl(
C,
DL,
TLI, FoldedOps);
1363 bool AllowNonDeterministic) {
1364 return ConstantFoldInstOperandsImpl(
I,
I->getOpcode(),
Ops,
DL,
TLI,
1365 AllowNonDeterministic);
1386 if (CE0->getOpcode() == Instruction::IntToPtr) {
1399 if (CE0->getOpcode() == Instruction::PtrToInt ||
1400 CE0->getOpcode() == Instruction::PtrToAddr) {
1401 Type *AddrTy =
DL.getAddressType(CE0->getOperand(0)->getType());
1402 if (CE0->getType() == AddrTy) {
1411 if (CE0->getOpcode() == CE1->getOpcode()) {
1412 if (CE0->getOpcode() == Instruction::IntToPtr) {
1427 if (CE0->getOpcode() == Instruction::PtrToInt ||
1428 CE0->getOpcode() == Instruction::PtrToAddr) {
1429 Type *AddrTy =
DL.getAddressType(CE0->getOperand(0)->getType());
1430 if (CE0->getType() == AddrTy &&
1431 CE0->getOperand(0)->getType() == CE1->getOperand(0)->getType()) {
1433 Predicate, CE0->getOperand(0), CE1->getOperand(0),
DL,
TLI);
1445 unsigned IndexWidth =
DL.getIndexTypeSizeInBits(Ops0->
getType());
1446 APInt Offset0(IndexWidth, 0);
1449 DL, Offset0, IsEqPred,
1452 APInt Offset1(IndexWidth, 0);
1454 DL, Offset1, IsEqPred,
1457 if (Stripped0 == Stripped1)
1496 if (
Constant *
C = SymbolicallyEvaluateBinop(Opcode, LHS, RHS,
DL))
1510 return ConstantFP::get(Ty, APF);
1512 return ConstantFP::get(
1539 IsOutput ?
Mode.Output :
Mode.Input);
1568 for (
unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {
1590 for (
unsigned I = 0, E = CDV->getNumElements();
I < E; ++
I) {
1591 const APFloat &Elt = CDV->getElementAsAPFloat(
I);
1593 NewElts.
push_back(ConstantFP::get(Ty, Elt));
1613 bool AllowNonDeterministic) {
1628 if (!AllowNonDeterministic)
1630 if (
FP->hasNoSignedZeros() ||
FP->hasAllowReassoc() ||
1631 FP->hasAllowContract() ||
FP->hasAllowReciprocal())
1645 if (!AllowNonDeterministic &&
C->isNaN())
1664 C->getType(), DestTy, &
DL))
1670 case Instruction::PtrToAddr:
1671 case Instruction::PtrToInt:
1676 if (CE->getOpcode() == Instruction::IntToPtr) {
1680 DL.getIntPtrType(CE->getType()),
1686 unsigned BitWidth =
DL.getIndexTypeSizeInBits(
GEP->getType());
1689 DL, BaseOffset,
true));
1690 if (
Base->isNullValue()) {
1691 FoldedValue = ConstantInt::get(CE->getContext(), BaseOffset);
1695 if (
GEP->getNumIndices() == 1 &&
1696 GEP->getSourceElementType()->isIntegerTy(8)) {
1700 if (
Sub &&
Sub->getType() == IntIdxTy &&
1701 Sub->getOpcode() == Instruction::Sub &&
1702 Sub->getOperand(0)->isNullValue())
1705 Sub->getOperand(1));
1716 case Instruction::IntToPtr:
1717 case Instruction::Trunc:
1718 case Instruction::ZExt:
1719 case Instruction::SExt:
1720 case Instruction::FPTrunc:
1721 case Instruction::FPExt:
1722 case Instruction::UIToFP:
1723 case Instruction::SIToFP:
1724 case Instruction::FPToUI:
1725 case Instruction::FPToSI:
1726 case Instruction::AddrSpaceCast:
1728 case Instruction::BitCast:
1739 Type *SrcTy =
C->getType();
1740 if (SrcTy == DestTy)
1765 if (BaseSplat && ValSplat && OffsetSplat) {
1779 for (
unsigned I = 0, E = FVTy->getNumElements();
I != E; ++
I) {
1783 if (!BaseElt || !ValElt || !OffsetElt)
1789 Result.push_back(Res);
1800 unsigned BaseBits =
DL.getTypeSizeInBits(
Base->getType());
1801 unsigned Bits =
DL.getTypeSizeInBits(Val->
getType());
1802 uint64_t
Off = COffset->getZExtValue();
1803 if (
Off + Bits > BaseBits)
1807 if (Bits == BaseBits)
1828 APInt Res = CB->getValue();
1830 return ConstantByte::get(
Base->getType(), Res);
1842 Type *EltTy = VTy->getElementType();
1846 if (SrcSplat && OffsetSplat) {
1860 for (
unsigned I = 0, E = FVTy->getNumElements();
I != E; ++
I) {
1861 Constant *SrcElt = Src->getAggregateElement(
I);
1863 if (!SrcElt || !OffsetElt)
1869 Result.push_back(Res);
1880 unsigned Bits =
DL.getTypeSizeInBits(Ty);
1881 uint64_t
Off = COffset->getZExtValue();
1882 if (
Off + Bits >
DL.getTypeSizeInBits(Src->getType()))
1891 if (!CB || Ty->isPointerTy())
1896 Instruction::BitCast, ConstantInt::get(Src->getContext(), Res), Ty,
DL);
1908 case Intrinsic::bswap:
1909 case Intrinsic::ctpop:
1910 case Intrinsic::ctlz:
1911 case Intrinsic::cttz:
1912 case Intrinsic::fshl:
1913 case Intrinsic::fshr:
1914 case Intrinsic::clmul:
1915 case Intrinsic::pdep:
1916 case Intrinsic::pext:
1917 case Intrinsic::launder_invariant_group:
1918 case Intrinsic::masked_load:
1919 case Intrinsic::get_active_lane_mask:
1920 case Intrinsic::mask_beforefirst:
1921 case Intrinsic::abs:
1922 case Intrinsic::smax:
1923 case Intrinsic::smin:
1924 case Intrinsic::umax:
1925 case Intrinsic::umin:
1926 case Intrinsic::scmp:
1927 case Intrinsic::ucmp:
1928 case Intrinsic::sadd_with_overflow:
1929 case Intrinsic::uadd_with_overflow:
1930 case Intrinsic::ssub_with_overflow:
1931 case Intrinsic::usub_with_overflow:
1932 case Intrinsic::smul_with_overflow:
1933 case Intrinsic::umul_with_overflow:
1934 case Intrinsic::smulh:
1935 case Intrinsic::umulh:
1936 case Intrinsic::sadd_sat:
1937 case Intrinsic::uadd_sat:
1938 case Intrinsic::ssub_sat:
1939 case Intrinsic::usub_sat:
1940 case Intrinsic::sshl_sat:
1941 case Intrinsic::ushl_sat:
1942 case Intrinsic::smul_fix:
1943 case Intrinsic::smul_fix_sat:
1944 case Intrinsic::bitreverse:
1945 case Intrinsic::is_constant:
1946 case Intrinsic::vector_reduce_add:
1947 case Intrinsic::vector_reduce_mul:
1948 case Intrinsic::vector_reduce_and:
1949 case Intrinsic::vector_reduce_or:
1950 case Intrinsic::vector_reduce_xor:
1951 case Intrinsic::vector_reduce_smin:
1952 case Intrinsic::vector_reduce_smax:
1953 case Intrinsic::vector_reduce_umin:
1954 case Intrinsic::vector_reduce_umax:
1955 case Intrinsic::vector_partial_reduce_add:
1956 case Intrinsic::vector_extract:
1957 case Intrinsic::vector_insert:
1958 case Intrinsic::vector_interleave2:
1959 case Intrinsic::vector_interleave3:
1960 case Intrinsic::vector_interleave4:
1961 case Intrinsic::vector_interleave5:
1962 case Intrinsic::vector_interleave6:
1963 case Intrinsic::vector_interleave7:
1964 case Intrinsic::vector_interleave8:
1965 case Intrinsic::vector_deinterleave2:
1966 case Intrinsic::vector_deinterleave3:
1967 case Intrinsic::vector_deinterleave4:
1968 case Intrinsic::vector_deinterleave5:
1969 case Intrinsic::vector_deinterleave6:
1970 case Intrinsic::vector_deinterleave7:
1971 case Intrinsic::vector_deinterleave8:
1973 case Intrinsic::amdgcn_perm:
1974 case Intrinsic::amdgcn_wave_reduce_umin:
1975 case Intrinsic::amdgcn_wave_reduce_umax:
1976 case Intrinsic::amdgcn_wave_reduce_max:
1977 case Intrinsic::amdgcn_wave_reduce_min:
1978 case Intrinsic::amdgcn_wave_reduce_and:
1979 case Intrinsic::amdgcn_wave_reduce_or:
1980 case Intrinsic::amdgcn_wave_reduce_xor:
1981 case Intrinsic::amdgcn_wave_reduce_add:
1982 case Intrinsic::amdgcn_wave_reduce_sub:
1983 case Intrinsic::amdgcn_s_wqm:
1984 case Intrinsic::amdgcn_s_quadmask:
1985 case Intrinsic::amdgcn_s_bitreplicate:
1986 case Intrinsic::arm_crc32b:
1987 case Intrinsic::arm_crc32h:
1988 case Intrinsic::arm_crc32w:
1989 case Intrinsic::arm_crc32cb:
1990 case Intrinsic::arm_crc32ch:
1991 case Intrinsic::arm_crc32cw:
1992 case Intrinsic::arm_mve_vctp8:
1993 case Intrinsic::arm_mve_vctp16:
1994 case Intrinsic::arm_mve_vctp32:
1995 case Intrinsic::arm_mve_vctp64:
1996 case Intrinsic::aarch64_crc32b:
1997 case Intrinsic::aarch64_crc32h:
1998 case Intrinsic::aarch64_crc32w:
1999 case Intrinsic::aarch64_crc32x:
2000 case Intrinsic::aarch64_crc32cb:
2001 case Intrinsic::aarch64_crc32ch:
2002 case Intrinsic::aarch64_crc32cw:
2003 case Intrinsic::aarch64_crc32cx:
2004 case Intrinsic::aarch64_sve_convert_from_svbool:
2005 case Intrinsic::wasm_alltrue:
2006 case Intrinsic::wasm_anytrue:
2007 case Intrinsic::wasm_dot:
2009 case Intrinsic::wasm_trunc_signed:
2010 case Intrinsic::wasm_trunc_unsigned:
2011 case Intrinsic::x86_sse42_crc32_32_8:
2012 case Intrinsic::x86_sse42_crc32_32_16:
2013 case Intrinsic::x86_sse42_crc32_32_32:
2014 case Intrinsic::x86_sse42_crc32_64_64:
2019 case Intrinsic::minnum:
2020 case Intrinsic::maxnum:
2021 case Intrinsic::minimum:
2022 case Intrinsic::maximum:
2023 case Intrinsic::minimumnum:
2024 case Intrinsic::maximumnum:
2025 case Intrinsic::log:
2026 case Intrinsic::log2:
2027 case Intrinsic::log10:
2028 case Intrinsic::exp:
2029 case Intrinsic::exp2:
2030 case Intrinsic::exp10:
2031 case Intrinsic::sqrt:
2032 case Intrinsic::sin:
2033 case Intrinsic::cos:
2034 case Intrinsic::sincos:
2035 case Intrinsic::sinh:
2036 case Intrinsic::cosh:
2037 case Intrinsic::atan:
2038 case Intrinsic::pow:
2039 case Intrinsic::powi:
2040 case Intrinsic::ldexp:
2041 case Intrinsic::fma:
2042 case Intrinsic::fmuladd:
2043 case Intrinsic::frexp:
2044 case Intrinsic::fptoui_sat:
2045 case Intrinsic::fptosi_sat:
2046 case Intrinsic::amdgcn_cos:
2047 case Intrinsic::amdgcn_cubeid:
2048 case Intrinsic::amdgcn_cubema:
2049 case Intrinsic::amdgcn_cubesc:
2050 case Intrinsic::amdgcn_cubetc:
2051 case Intrinsic::amdgcn_fmul_legacy:
2052 case Intrinsic::amdgcn_fma_legacy:
2053 case Intrinsic::amdgcn_fract:
2054 case Intrinsic::amdgcn_sin:
2056 case Intrinsic::x86_sse_cvtss2si:
2057 case Intrinsic::x86_sse_cvtss2si64:
2058 case Intrinsic::x86_sse_cvttss2si:
2059 case Intrinsic::x86_sse_cvttss2si64:
2060 case Intrinsic::x86_sse2_cvtsd2si:
2061 case Intrinsic::x86_sse2_cvtsd2si64:
2062 case Intrinsic::x86_sse2_cvttsd2si:
2063 case Intrinsic::x86_sse2_cvttsd2si64:
2064 case Intrinsic::x86_avx512_vcvtss2si32:
2065 case Intrinsic::x86_avx512_vcvtss2si64:
2066 case Intrinsic::x86_avx512_cvttss2si:
2067 case Intrinsic::x86_avx512_cvttss2si64:
2068 case Intrinsic::x86_avx512_vcvtsd2si32:
2069 case Intrinsic::x86_avx512_vcvtsd2si64:
2070 case Intrinsic::x86_avx512_cvttsd2si:
2071 case Intrinsic::x86_avx512_cvttsd2si64:
2072 case Intrinsic::x86_avx512_vcvtss2usi32:
2073 case Intrinsic::x86_avx512_vcvtss2usi64:
2074 case Intrinsic::x86_avx512_cvttss2usi:
2075 case Intrinsic::x86_avx512_cvttss2usi64:
2076 case Intrinsic::x86_avx512_vcvtsd2usi32:
2077 case Intrinsic::x86_avx512_vcvtsd2usi64:
2078 case Intrinsic::x86_avx512_cvttsd2usi:
2079 case Intrinsic::x86_avx512_cvttsd2usi64:
2082 case Intrinsic::nvvm_fmax_d:
2083 case Intrinsic::nvvm_fmax_f:
2084 case Intrinsic::nvvm_fmax_ftz_f:
2085 case Intrinsic::nvvm_fmax_ftz_nan_f:
2086 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:
2087 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:
2088 case Intrinsic::nvvm_fmax_nan_f:
2089 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:
2090 case Intrinsic::nvvm_fmax_xorsign_abs_f:
2093 case Intrinsic::nvvm_fmin_d:
2094 case Intrinsic::nvvm_fmin_f:
2095 case Intrinsic::nvvm_fmin_ftz_f:
2096 case Intrinsic::nvvm_fmin_ftz_nan_f:
2097 case Intrinsic::nvvm_fmin_ftz_nan_xorsign_abs_f:
2098 case Intrinsic::nvvm_fmin_ftz_xorsign_abs_f:
2099 case Intrinsic::nvvm_fmin_nan_f:
2100 case Intrinsic::nvvm_fmin_nan_xorsign_abs_f:
2101 case Intrinsic::nvvm_fmin_xorsign_abs_f:
2104 case Intrinsic::nvvm_f2i_rm:
2105 case Intrinsic::nvvm_f2i_rn:
2106 case Intrinsic::nvvm_f2i_rp:
2107 case Intrinsic::nvvm_f2i_rz:
2108 case Intrinsic::nvvm_f2i_rm_ftz:
2109 case Intrinsic::nvvm_f2i_rn_ftz:
2110 case Intrinsic::nvvm_f2i_rp_ftz:
2111 case Intrinsic::nvvm_f2i_rz_ftz:
2112 case Intrinsic::nvvm_f2ui_rm:
2113 case Intrinsic::nvvm_f2ui_rn:
2114 case Intrinsic::nvvm_f2ui_rp:
2115 case Intrinsic::nvvm_f2ui_rz:
2116 case Intrinsic::nvvm_f2ui_rm_ftz:
2117 case Intrinsic::nvvm_f2ui_rn_ftz:
2118 case Intrinsic::nvvm_f2ui_rp_ftz:
2119 case Intrinsic::nvvm_f2ui_rz_ftz:
2120 case Intrinsic::nvvm_d2i_rm:
2121 case Intrinsic::nvvm_d2i_rn:
2122 case Intrinsic::nvvm_d2i_rp:
2123 case Intrinsic::nvvm_d2i_rz:
2124 case Intrinsic::nvvm_d2ui_rm:
2125 case Intrinsic::nvvm_d2ui_rn:
2126 case Intrinsic::nvvm_d2ui_rp:
2127 case Intrinsic::nvvm_d2ui_rz:
2130 case Intrinsic::nvvm_f2ll_rm:
2131 case Intrinsic::nvvm_f2ll_rn:
2132 case Intrinsic::nvvm_f2ll_rp:
2133 case Intrinsic::nvvm_f2ll_rz:
2134 case Intrinsic::nvvm_f2ll_rm_ftz:
2135 case Intrinsic::nvvm_f2ll_rn_ftz:
2136 case Intrinsic::nvvm_f2ll_rp_ftz:
2137 case Intrinsic::nvvm_f2ll_rz_ftz:
2138 case Intrinsic::nvvm_f2ull_rm:
2139 case Intrinsic::nvvm_f2ull_rn:
2140 case Intrinsic::nvvm_f2ull_rp:
2141 case Intrinsic::nvvm_f2ull_rz:
2142 case Intrinsic::nvvm_f2ull_rm_ftz:
2143 case Intrinsic::nvvm_f2ull_rn_ftz:
2144 case Intrinsic::nvvm_f2ull_rp_ftz:
2145 case Intrinsic::nvvm_f2ull_rz_ftz:
2146 case Intrinsic::nvvm_d2ll_rm:
2147 case Intrinsic::nvvm_d2ll_rn:
2148 case Intrinsic::nvvm_d2ll_rp:
2149 case Intrinsic::nvvm_d2ll_rz:
2150 case Intrinsic::nvvm_d2ull_rm:
2151 case Intrinsic::nvvm_d2ull_rn:
2152 case Intrinsic::nvvm_d2ull_rp:
2153 case Intrinsic::nvvm_d2ull_rz:
2156 case Intrinsic::nvvm_ceil_d:
2157 case Intrinsic::nvvm_ceil_f:
2158 case Intrinsic::nvvm_ceil_ftz_f:
2160 case Intrinsic::nvvm_fabs:
2161 case Intrinsic::nvvm_fabs_ftz:
2163 case Intrinsic::nvvm_floor_d:
2164 case Intrinsic::nvvm_floor_f:
2165 case Intrinsic::nvvm_floor_ftz_f:
2167 case Intrinsic::nvvm_rcp_rm_d:
2168 case Intrinsic::nvvm_rcp_rm_f:
2169 case Intrinsic::nvvm_rcp_rm_ftz_f:
2170 case Intrinsic::nvvm_rcp_rn_d:
2171 case Intrinsic::nvvm_rcp_rn_f:
2172 case Intrinsic::nvvm_rcp_rn_ftz_f:
2173 case Intrinsic::nvvm_rcp_rp_d:
2174 case Intrinsic::nvvm_rcp_rp_f:
2175 case Intrinsic::nvvm_rcp_rp_ftz_f:
2176 case Intrinsic::nvvm_rcp_rz_d:
2177 case Intrinsic::nvvm_rcp_rz_f:
2178 case Intrinsic::nvvm_rcp_rz_ftz_f:
2180 case Intrinsic::nvvm_round_d:
2181 case Intrinsic::nvvm_round_f:
2182 case Intrinsic::nvvm_round_ftz_f:
2184 case Intrinsic::nvvm_saturate_d:
2185 case Intrinsic::nvvm_saturate_f:
2186 case Intrinsic::nvvm_saturate_ftz_f:
2188 case Intrinsic::nvvm_sqrt_f:
2189 case Intrinsic::nvvm_sqrt_rn_d:
2190 case Intrinsic::nvvm_sqrt_rn_f:
2191 case Intrinsic::nvvm_sqrt_rn_ftz_f:
2195 case Intrinsic::nvvm_fadd:
2196 case Intrinsic::nvvm_fadd_ftz:
2197 case Intrinsic::nvvm_fma:
2198 case Intrinsic::nvvm_fma_ftz:
2199 case Intrinsic::nvvm_fmul:
2200 case Intrinsic::nvvm_fmul_ftz:
2203 case Intrinsic::nvvm_div_rm_d:
2204 case Intrinsic::nvvm_div_rn_d:
2205 case Intrinsic::nvvm_div_rp_d:
2206 case Intrinsic::nvvm_div_rz_d:
2207 case Intrinsic::nvvm_div_rm_f:
2208 case Intrinsic::nvvm_div_rn_f:
2209 case Intrinsic::nvvm_div_rp_f:
2210 case Intrinsic::nvvm_div_rz_f:
2211 case Intrinsic::nvvm_div_rm_ftz_f:
2212 case Intrinsic::nvvm_div_rn_ftz_f:
2213 case Intrinsic::nvvm_div_rp_ftz_f:
2214 case Intrinsic::nvvm_div_rz_ftz_f:
2218 case Intrinsic::fabs:
2219 case Intrinsic::copysign:
2220 case Intrinsic::is_fpclass:
2223 case Intrinsic::ceil:
2224 case Intrinsic::floor:
2225 case Intrinsic::round:
2226 case Intrinsic::roundeven:
2227 case Intrinsic::trunc:
2228 case Intrinsic::nearbyint:
2229 case Intrinsic::rint:
2230 case Intrinsic::canonicalize:
2234 case Intrinsic::experimental_constrained_fma:
2235 case Intrinsic::experimental_constrained_fmuladd:
2236 case Intrinsic::experimental_constrained_fadd:
2237 case Intrinsic::experimental_constrained_fsub:
2238 case Intrinsic::experimental_constrained_fmul:
2239 case Intrinsic::experimental_constrained_fdiv:
2240 case Intrinsic::experimental_constrained_frem:
2241 case Intrinsic::experimental_constrained_ceil:
2242 case Intrinsic::experimental_constrained_floor:
2243 case Intrinsic::experimental_constrained_round:
2244 case Intrinsic::experimental_constrained_roundeven:
2245 case Intrinsic::experimental_constrained_trunc:
2246 case Intrinsic::experimental_constrained_nearbyint:
2247 case Intrinsic::experimental_constrained_rint:
2248 case Intrinsic::experimental_constrained_fcmp:
2249 case Intrinsic::experimental_constrained_fcmps:
2251 case Intrinsic::experimental_cttz_elts:
2262 return V->getType()->isFloatingPointTy();
2268 if (
Call->isNoBuiltin())
2270 if (
Call->getFunctionType() !=
F->getFunctionType())
2286 if (!
TLI ||
Call->isStrictFP())
2289 LibFunc Func =
TLI->getLibFunc(*
F);
2290 if (Func == NotLibFunc)
2296 case LibFunc_acos_finite:
2297 case LibFunc_acosf_finite:
2300 case LibFunc_asin_finite:
2301 case LibFunc_asinf_finite:
2305 case LibFunc_atan2f:
2306 case LibFunc_atan2_finite:
2307 case LibFunc_atan2f_finite:
2312 case LibFunc_cosh_finite:
2313 case LibFunc_coshf_finite:
2320 case LibFunc_exp_finite:
2321 case LibFunc_expf_finite:
2324 case LibFunc_exp2_finite:
2325 case LibFunc_exp2f_finite:
2329 case LibFunc_floorf:
2333 case LibFunc_ilogbf:
2336 case LibFunc_log_finite:
2337 case LibFunc_logf_finite:
2343 case LibFunc_log2_finite:
2344 case LibFunc_log2f_finite:
2346 case LibFunc_log10f:
2347 case LibFunc_log10_finite:
2348 case LibFunc_log10f_finite:
2350 case LibFunc_log1pf:
2351 case LibFunc_nearbyint:
2352 case LibFunc_nearbyintf:
2353 case LibFunc_nextafter:
2354 case LibFunc_nextafterf:
2355 case LibFunc_nexttoward:
2356 case LibFunc_nexttowardf:
2359 case LibFunc_pow_finite:
2360 case LibFunc_powf_finite:
2361 case LibFunc_remainder:
2362 case LibFunc_remainderf:
2366 case LibFunc_roundf:
2367 case LibFunc_roundeven:
2368 case LibFunc_roundevenf:
2373 case LibFunc_sinh_finite:
2374 case LibFunc_sinhf_finite:
2382 case LibFunc_truncf:
2392 if (Ty->isHalfTy() || Ty->isFloatTy() || Ty->isBFloatTy()) {
2396 return ConstantFP::get(Ty->getContext(), APF);
2398 if (Ty->isDoubleTy())
2399 return ConstantFP::get(Ty->getContext(),
APFloat(
V));
2403#if defined(HAS_IEE754_FLOAT128) && defined(HAS_LOGF128)
2405 if (Ty->isFP128Ty())
2406 return ConstantFP::get(Ty,
V);
2412inline void llvm_fenv_clearexcept() {
2413#if defined(FE_ALL_EXCEPT)
2414 feclearexcept(FE_ALL_EXCEPT);
2420inline bool llvm_fenv_testexcept() {
2421 int errno_val = errno;
2422 if (errno_val == ERANGE || errno_val == EDOM)
2424#if defined(FE_ALL_EXCEPT) && defined(FE_INEXACT)
2425 if (fetestexcept(FE_ALL_EXCEPT & ~FE_INEXACT))
2447 switch (DenormKind) {
2451 return FTZPreserveSign(
V);
2453 return FlushToPositiveZero(
V);
2459#if defined(HAS_IEE754_FLOAT128) && defined(HAS_LOGF128)
2460Constant *ConstantFoldFP128(float128 (*NativeFP)(float128),
const APFloat &
V,
2462 llvm_fenv_clearexcept();
2463 float128
Result = NativeFP(
V.convertToQuad());
2464 if (llvm_fenv_testexcept()) {
2465 llvm_fenv_clearexcept();
2469 return GetConstantFoldFPValue128(Result, Ty);
2473Constant *ConstantFoldBinaryFP(
double (*NativeFP)(
double,
double),
2475 llvm_fenv_clearexcept();
2476 double Result = NativeFP(
V.convertToDouble(),
W.convertToDouble());
2477 if (llvm_fenv_testexcept()) {
2478 llvm_fenv_clearexcept();
2482 return GetConstantFoldFPValue(Result, Ty);
2489 if (
Op->containsPoisonElement())
2493 if (
Constant *SplatVal =
Op->getSplatValue()) {
2495 case Intrinsic::vector_reduce_and:
2496 case Intrinsic::vector_reduce_or:
2497 case Intrinsic::vector_reduce_smin:
2498 case Intrinsic::vector_reduce_smax:
2499 case Intrinsic::vector_reduce_umin:
2500 case Intrinsic::vector_reduce_umax:
2502 case Intrinsic::vector_reduce_add:
2503 if (SplatVal->isNullValue())
2506 case Intrinsic::vector_reduce_mul:
2507 if (SplatVal->isNullValue() || SplatVal->isOneValue())
2510 case Intrinsic::vector_reduce_xor:
2511 if (SplatVal->isNullValue())
2513 if (OpVT->getElementCount().isKnownMultipleOf(2))
2527 APInt Acc = EltC->getValue();
2531 const APInt &
X = EltC->getValue();
2533 case Intrinsic::vector_reduce_add:
2536 case Intrinsic::vector_reduce_mul:
2539 case Intrinsic::vector_reduce_and:
2542 case Intrinsic::vector_reduce_or:
2545 case Intrinsic::vector_reduce_xor:
2548 case Intrinsic::vector_reduce_smin:
2551 case Intrinsic::vector_reduce_smax:
2554 case Intrinsic::vector_reduce_umin:
2557 case Intrinsic::vector_reduce_umax:
2563 return ConstantInt::get(
Op->getContext(), Acc);
2581 unsigned NumAccElts = AccTy->getNumElements();
2582 unsigned NumInputElts = InputTy->getNumElements();
2585 for (
unsigned I = 0;
I < NumAccElts; ++
I) {
2591 for (
unsigned I = 0;
I < NumInputElts; ++
I) {
2596 unsigned ResultIdx =
I % NumAccElts;
2598 Instruction::Add, ResultElts[ResultIdx], InputElt,
DL);
2602 ResultElts[ResultIdx] =
Folded;
2615Constant *ConstantFoldSSEConvertToInt(
const APFloat &Val,
bool roundTowardZero,
2616 Type *Ty,
bool IsSigned) {
2618 unsigned ResultWidth = Ty->getIntegerBitWidth();
2619 assert(ResultWidth <= 64 &&
2620 "Can only constant fold conversions to 64 and 32 bit ints");
2623 bool isExact =
false;
2628 IsSigned,
mode, &isExact);
2632 return ConstantInt::get(Ty, UIntVal, IsSigned);
2636 Type *Ty =
Op->getType();
2638 if (Ty->isBFloatTy() || Ty->isHalfTy() || Ty->isFloatTy() || Ty->isDoubleTy())
2639 return Op->getValueAPF().convertToDouble();
2649 C = &CI->getValue();
2708 return ConstantFP::get(
2713 if (!Ty->isIEEELikeFPTy())
2720 if (Src.isNormal() || Src.isInfinity())
2721 return ConstantFP::get(Ty->getContext(), Src);
2723 if (Src.isDenormal() && CtxF) {
2724 DenormalMode DenormMode = CtxF->getDenormalMode(Src.getSemantics());
2727 return ConstantFP::get(Ty->getContext(), Src);
2744 return ConstantFP::get(Ty->getContext(),
2758 if (IntrinsicID == Intrinsic::is_constant) {
2762 if (
Operands[0]->isManifestConstant())
2771 if (IntrinsicID == Intrinsic::cos ||
2772 IntrinsicID == Intrinsic::ctpop ||
2773 IntrinsicID == Intrinsic::fptoui_sat ||
2774 IntrinsicID == Intrinsic::fptosi_sat ||
2775 IntrinsicID == Intrinsic::canonicalize)
2777 if (IntrinsicID == Intrinsic::bswap ||
2778 IntrinsicID == Intrinsic::bitreverse ||
2779 IntrinsicID == Intrinsic::launder_invariant_group)
2785 if (IntrinsicID == Intrinsic::launder_invariant_group) {
2790 Call &&
Call->getParent() ?
Call->getCaller() :
nullptr;
2803 if (IntrinsicID == Intrinsic::wasm_trunc_signed ||
2804 IntrinsicID == Intrinsic::wasm_trunc_unsigned) {
2805 bool Signed = IntrinsicID == Intrinsic::wasm_trunc_signed;
2810 unsigned Width = Ty->getIntegerBitWidth();
2812 bool IsExact =
false;
2817 return ConstantInt::get(Ty,
Int);
2822 if (IntrinsicID == Intrinsic::fptoui_sat ||
2823 IntrinsicID == Intrinsic::fptosi_sat) {
2826 IntrinsicID == Intrinsic::fptoui_sat);
2829 return ConstantInt::get(Ty,
Int);
2832 if (IntrinsicID == Intrinsic::canonicalize) {
2834 Call &&
Call->getParent() ?
Call->getFunction() :
nullptr;
2835 return constantFoldCanonicalize(Ty, U, CtxF);
2838#if defined(HAS_IEE754_FLOAT128) && defined(HAS_LOGF128)
2839 if (Ty->isFP128Ty()) {
2840 if (IntrinsicID == Intrinsic::log) {
2841 float128
Result = logf128(
Op->getValueAPF().convertToQuad());
2842 return GetConstantFoldFPValue128(Result, Ty);
2845 if (
TLI &&
TLI->getLibFunc(Name) == LibFunc_logl &&
2846 TLI->has(LibFunc_logl))
2847 return ConstantFoldFP128(logf128,
Op->getValueAPF(), Ty);
2851 if (!Ty->isHalfTy() && !Ty->isFloatTy() && !Ty->isDoubleTy() &&
2852 !Ty->isIntegerTy() && !Ty->isBFloatTy())
2857 if (IntrinsicID == Intrinsic::nearbyint || IntrinsicID == Intrinsic::rint ||
2858 IntrinsicID == Intrinsic::roundeven) {
2860 return ConstantFP::get(Ty, U);
2863 if (IntrinsicID == Intrinsic::round) {
2865 return ConstantFP::get(Ty, U);
2868 if (IntrinsicID == Intrinsic::roundeven) {
2870 return ConstantFP::get(Ty, U);
2873 if (IntrinsicID == Intrinsic::ceil) {
2875 return ConstantFP::get(Ty, U);
2878 if (IntrinsicID == Intrinsic::floor) {
2880 return ConstantFP::get(Ty, U);
2883 if (IntrinsicID == Intrinsic::trunc) {
2885 return ConstantFP::get(Ty, U);
2888 if (IntrinsicID == Intrinsic::fabs) {
2890 return ConstantFP::get(Ty, U);
2893 if (IntrinsicID == Intrinsic::amdgcn_fract) {
2901 APFloat AlmostOne(U.getSemantics(), 1);
2902 AlmostOne.next(
true);
2903 return ConstantFP::get(Ty,
minimum(FractU, AlmostOne));
2910 std::optional<APFloat::roundingMode>
RM;
2911 switch (IntrinsicID) {
2914 case Intrinsic::experimental_constrained_nearbyint:
2915 case Intrinsic::experimental_constrained_rint: {
2921 case Intrinsic::experimental_constrained_round:
2924 case Intrinsic::experimental_constrained_ceil:
2927 case Intrinsic::experimental_constrained_floor:
2930 case Intrinsic::experimental_constrained_trunc:
2937 if (IntrinsicID == Intrinsic::experimental_constrained_rint &&
2939 std::optional<fp::ExceptionBehavior> EB =
2944 }
else if (U.isSignaling()) {
2950 return ConstantFP::get(Ty, U);
2955 switch (IntrinsicID) {
2957 case Intrinsic::nvvm_f2i_rm:
2958 case Intrinsic::nvvm_f2i_rn:
2959 case Intrinsic::nvvm_f2i_rp:
2960 case Intrinsic::nvvm_f2i_rz:
2961 case Intrinsic::nvvm_f2i_rm_ftz:
2962 case Intrinsic::nvvm_f2i_rn_ftz:
2963 case Intrinsic::nvvm_f2i_rp_ftz:
2964 case Intrinsic::nvvm_f2i_rz_ftz:
2966 case Intrinsic::nvvm_f2ui_rm:
2967 case Intrinsic::nvvm_f2ui_rn:
2968 case Intrinsic::nvvm_f2ui_rp:
2969 case Intrinsic::nvvm_f2ui_rz:
2970 case Intrinsic::nvvm_f2ui_rm_ftz:
2971 case Intrinsic::nvvm_f2ui_rn_ftz:
2972 case Intrinsic::nvvm_f2ui_rp_ftz:
2973 case Intrinsic::nvvm_f2ui_rz_ftz:
2975 case Intrinsic::nvvm_d2i_rm:
2976 case Intrinsic::nvvm_d2i_rn:
2977 case Intrinsic::nvvm_d2i_rp:
2978 case Intrinsic::nvvm_d2i_rz:
2980 case Intrinsic::nvvm_d2ui_rm:
2981 case Intrinsic::nvvm_d2ui_rn:
2982 case Intrinsic::nvvm_d2ui_rp:
2983 case Intrinsic::nvvm_d2ui_rz:
2985 case Intrinsic::nvvm_f2ll_rm:
2986 case Intrinsic::nvvm_f2ll_rn:
2987 case Intrinsic::nvvm_f2ll_rp:
2988 case Intrinsic::nvvm_f2ll_rz:
2989 case Intrinsic::nvvm_f2ll_rm_ftz:
2990 case Intrinsic::nvvm_f2ll_rn_ftz:
2991 case Intrinsic::nvvm_f2ll_rp_ftz:
2992 case Intrinsic::nvvm_f2ll_rz_ftz:
2994 case Intrinsic::nvvm_f2ull_rm:
2995 case Intrinsic::nvvm_f2ull_rn:
2996 case Intrinsic::nvvm_f2ull_rp:
2997 case Intrinsic::nvvm_f2ull_rz:
2998 case Intrinsic::nvvm_f2ull_rm_ftz:
2999 case Intrinsic::nvvm_f2ull_rn_ftz:
3000 case Intrinsic::nvvm_f2ull_rp_ftz:
3001 case Intrinsic::nvvm_f2ull_rz_ftz:
3003 case Intrinsic::nvvm_d2ll_rm:
3004 case Intrinsic::nvvm_d2ll_rn:
3005 case Intrinsic::nvvm_d2ll_rp:
3006 case Intrinsic::nvvm_d2ll_rz:
3008 case Intrinsic::nvvm_d2ull_rm:
3009 case Intrinsic::nvvm_d2ull_rn:
3010 case Intrinsic::nvvm_d2ull_rp:
3011 case Intrinsic::nvvm_d2ull_rz: {
3017 return ConstantInt::get(Ty, 0);
3020 unsigned BitWidth = Ty->getIntegerBitWidth();
3030 APSInt ResInt(Ty->getIntegerBitWidth(), !IsSigned);
3031 auto FloatToRound = IsFTZ ? FTZPreserveSign(U) : U;
3035 bool IsExact =
false;
3036 FloatToRound.convertToInteger(ResInt, RMode, &IsExact);
3037 return ConstantInt::get(Ty, ResInt);
3053 switch (IntrinsicID) {
3055 case Intrinsic::log:
3063 case Intrinsic::log2:
3072 case Intrinsic::log10:
3081 case Intrinsic::exp:
3083 case Intrinsic::exp2:
3085 return ConstantFoldBinaryFP(pow,
APFloat(2.0), APF, Ty);
3086 case Intrinsic::exp10:
3088 return ConstantFoldBinaryFP(pow,
APFloat(10.0), APF, Ty);
3089 case Intrinsic::sin:
3091 case Intrinsic::cos:
3093 case Intrinsic::sinh:
3095 case Intrinsic::cosh:
3097 case Intrinsic::atan:
3100 return ConstantFP::get(Ty, U);
3102 case Intrinsic::sqrt:
3106 case Intrinsic::nvvm_ceil_ftz_f:
3107 case Intrinsic::nvvm_ceil_f:
3108 case Intrinsic::nvvm_ceil_d:
3114 case Intrinsic::nvvm_fabs_ftz:
3115 case Intrinsic::nvvm_fabs:
3121 case Intrinsic::nvvm_floor_ftz_f:
3122 case Intrinsic::nvvm_floor_f:
3123 case Intrinsic::nvvm_floor_d:
3129 case Intrinsic::nvvm_rcp_rm_ftz_f:
3130 case Intrinsic::nvvm_rcp_rn_ftz_f:
3131 case Intrinsic::nvvm_rcp_rp_ftz_f:
3132 case Intrinsic::nvvm_rcp_rz_ftz_f:
3133 case Intrinsic::nvvm_rcp_rm_d:
3134 case Intrinsic::nvvm_rcp_rm_f:
3135 case Intrinsic::nvvm_rcp_rn_d:
3136 case Intrinsic::nvvm_rcp_rn_f:
3137 case Intrinsic::nvvm_rcp_rp_d:
3138 case Intrinsic::nvvm_rcp_rp_f:
3139 case Intrinsic::nvvm_rcp_rz_d:
3140 case Intrinsic::nvvm_rcp_rz_f: {
3144 auto Denominator = IsFTZ ? FTZPreserveSign(APF) : APF;
3150 Res = FTZPreserveSign(Res);
3151 return ConstantFP::get(Ty, Res);
3156 case Intrinsic::nvvm_round_ftz_f:
3157 case Intrinsic::nvvm_round_f:
3158 case Intrinsic::nvvm_round_d: {
3163 auto V = IsFTZ ? FTZPreserveSign(APF) : APF;
3165 return ConstantFP::get(Ty,
V);
3168 case Intrinsic::nvvm_saturate_ftz_f:
3169 case Intrinsic::nvvm_saturate_d:
3170 case Intrinsic::nvvm_saturate_f: {
3172 auto V = IsFTZ ? FTZPreserveSign(APF) : APF;
3173 if (
V.isNegative() ||
V.isZero() ||
V.isNaN())
3177 return ConstantFP::get(Ty, One);
3178 return ConstantFP::get(Ty, APF);
3181 case Intrinsic::nvvm_sqrt_rn_ftz_f:
3182 case Intrinsic::nvvm_sqrt_f:
3183 case Intrinsic::nvvm_sqrt_rn_d:
3184 case Intrinsic::nvvm_sqrt_rn_f:
3193 case Intrinsic::amdgcn_cos:
3194 case Intrinsic::amdgcn_sin: {
3195 double V = getValueAsDouble(
Op);
3201 bool IsCos = IntrinsicID == Intrinsic::amdgcn_cos;
3202 double V4 =
V * 4.0;
3203 if (V4 == floor(V4)) {
3205 const double SinVals[4] = { 0.0, 1.0, 0.0, -1.0 };
3206 V = SinVals[((int)V4 + (IsCos ? 1 : 0)) & 3];
3213 return GetConstantFoldFPValue(
V, Ty);
3220 LibFunc
Func =
TLI->getLibFunc(Name);
3221 if (Func == NotLibFunc)
3229 case LibFunc_acos_finite:
3230 case LibFunc_acosf_finite:
3236 case LibFunc_asin_finite:
3237 case LibFunc_asinf_finite:
3245 return ConstantFP::get(Ty, U);
3251 if (
TLI->has(Func)) {
3253 return ConstantFP::get(Ty, U);
3263 case LibFunc_cosh_finite:
3264 case LibFunc_coshf_finite:
3270 case LibFunc_exp_finite:
3271 case LibFunc_expf_finite:
3277 case LibFunc_exp2_finite:
3278 case LibFunc_exp2f_finite:
3281 return ConstantFoldBinaryFP(pow,
APFloat(2.0), APF, Ty);
3285 if (
TLI->has(Func)) {
3287 return ConstantFP::get(Ty, U);
3291 case LibFunc_floorf:
3292 if (
TLI->has(Func)) {
3294 return ConstantFP::get(Ty, U);
3299 case LibFunc_log_finite:
3300 case LibFunc_logf_finite:
3306 case LibFunc_log2_finite:
3307 case LibFunc_log2f_finite:
3313 case LibFunc_log10f:
3314 case LibFunc_log10_finite:
3315 case LibFunc_log10f_finite:
3321 case LibFunc_ilogbf:
3323 return ConstantInt::get(Ty,
ilogb(APF),
true);
3331 case LibFunc_log1pf:
3334 return ConstantFP::get(Ty, U);
3345 case LibFunc_nearbyint:
3346 case LibFunc_nearbyintf:
3349 case LibFunc_roundeven:
3350 case LibFunc_roundevenf:
3351 if (
TLI->has(Func)) {
3353 return ConstantFP::get(Ty, U);
3357 case LibFunc_roundf:
3358 if (
TLI->has(Func)) {
3360 return ConstantFP::get(Ty, U);
3370 case LibFunc_sinh_finite:
3371 case LibFunc_sinhf_finite:
3391 case LibFunc_truncf:
3392 if (
TLI->has(Func)) {
3394 return ConstantFP::get(Ty, U);
3402 switch (IntrinsicID) {
3403 case Intrinsic::bswap:
3404 return ConstantInt::get(Ty->getContext(),
Op->getValue().byteSwap());
3405 case Intrinsic::ctpop:
3406 return ConstantInt::get(Ty,
Op->getValue().popcount());
3407 case Intrinsic::bitreverse:
3408 return ConstantInt::get(Ty->getContext(),
Op->getValue().reverseBits());
3409 case Intrinsic::amdgcn_s_wqm: {
3411 Val |= (Val & 0x5555555555555555ULL) << 1 |
3412 ((Val >> 1) & 0x5555555555555555ULL);
3413 Val |= (Val & 0x3333333333333333ULL) << 2 |
3414 ((Val >> 2) & 0x3333333333333333ULL);
3415 return ConstantInt::get(Ty, Val);
3418 case Intrinsic::amdgcn_s_quadmask: {
3421 for (
unsigned I = 0;
I <
Op->getBitWidth() / 4; ++
I, Val >>= 4) {
3425 QuadMask |= (1ULL <<
I);
3427 return ConstantInt::get(Ty, QuadMask);
3430 case Intrinsic::amdgcn_s_bitreplicate: {
3432 Val = (Val & 0x000000000000FFFFULL) | (Val & 0x00000000FFFF0000ULL) << 16;
3433 Val = (Val & 0x000000FF000000FFULL) | (Val & 0x0000FF000000FF00ULL) << 8;
3434 Val = (Val & 0x000F000F000F000FULL) | (Val & 0x00F000F000F000F0ULL) << 4;
3435 Val = (Val & 0x0303030303030303ULL) | (Val & 0x0C0C0C0C0C0C0C0CULL) << 2;
3436 Val = (Val & 0x1111111111111111ULL) | (Val & 0x2222222222222222ULL) << 1;
3437 Val = Val | Val << 1;
3438 return ConstantInt::get(Ty, Val);
3445 switch (IntrinsicID) {
3447 case Intrinsic::vector_reduce_add:
3448 case Intrinsic::vector_reduce_mul:
3449 case Intrinsic::vector_reduce_and:
3450 case Intrinsic::vector_reduce_or:
3451 case Intrinsic::vector_reduce_xor:
3452 case Intrinsic::vector_reduce_smin:
3453 case Intrinsic::vector_reduce_smax:
3454 case Intrinsic::vector_reduce_umin:
3455 case Intrinsic::vector_reduce_umax:
3459 case Intrinsic::x86_sse_cvtss2si:
3460 case Intrinsic::x86_sse_cvtss2si64:
3461 case Intrinsic::x86_sse2_cvtsd2si:
3462 case Intrinsic::x86_sse2_cvtsd2si64:
3465 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
3469 case Intrinsic::x86_sse_cvttss2si:
3470 case Intrinsic::x86_sse_cvttss2si64:
3471 case Intrinsic::x86_sse2_cvttsd2si:
3472 case Intrinsic::x86_sse2_cvttsd2si64:
3475 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
3480 case Intrinsic::wasm_anytrue:
3481 return Op->isNullValue() ? ConstantInt::get(Ty, 0)
3484 case Intrinsic::wasm_alltrue:
3487 for (
unsigned I = 0;
I !=
E; ++
I) {
3491 return ConstantInt::get(Ty, 0);
3497 return ConstantInt::get(Ty, 1);
3509 if (FCmp->isSignaling()) {
3518 return ConstantInt::get(
Call->getType()->getScalarType(), Result);
3523 const Type *RetTy) {
3524 assert(RetTy !=
nullptr);
3533 return ConstantFP::get(RetTy->
getContext(), Ret);
3541 assert(!LosesInfo &&
"Unexpected lossy promotion");
3551 return ConstantFP::get(RetTy->
getContext(), Ret);
3556 if (
Next.isZero() ||
Next.isDenormal() ||
Next.isSignaling())
3567 LibFunc
Func =
TLI->getLibFunc(Name);
3568 if (Func == NotLibFunc)
3579 const APFloat &Op1V = Op1->getValueAPF();
3580 const APFloat &Op2V = Op2->getValueAPF();
3587 case LibFunc_pow_finite:
3588 case LibFunc_powf_finite:
3590 return ConstantFoldBinaryFP(pow, Op1V, Op2V, Ty);
3594 if (
TLI->has(Func)) {
3597 return ConstantFP::get(Ty,
V);
3600 case LibFunc_remainder:
3601 case LibFunc_remainderf:
3602 if (
TLI->has(Func)) {
3605 return ConstantFP::get(Ty,
V);
3609 case LibFunc_atan2f:
3615 case LibFunc_atan2_finite:
3616 case LibFunc_atan2f_finite:
3618 return ConstantFoldBinaryFP(atan2, Op1V, Op2V, Ty);
3620 case LibFunc_nextafter:
3621 case LibFunc_nextafterf:
3622 case LibFunc_nexttoward:
3623 case LibFunc_nexttowardf:
3625 return ConstantFoldNextToward(Op1V, Op2V, Ty);
3633 const APInt *DataArg,
unsigned DataBytes,
3635 if (!CrcArg || !DataArg)
3640 return ConstantInt::get(Ty, Result);
3648 if (Ty->isFloatingPointTy()) {
3653 switch (IntrinsicID) {
3654 case Intrinsic::maxnum:
3655 case Intrinsic::minnum:
3656 case Intrinsic::maximum:
3657 case Intrinsic::minimum:
3658 case Intrinsic::maximumnum:
3659 case Intrinsic::minimumnum:
3660 case Intrinsic::nvvm_fmax_d:
3661 case Intrinsic::nvvm_fmin_d:
3669 case Intrinsic::nvvm_fmax_f:
3670 case Intrinsic::nvvm_fmax_ftz_f:
3671 case Intrinsic::nvvm_fmax_ftz_nan_f:
3672 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:
3673 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:
3674 case Intrinsic::nvvm_fmax_nan_f:
3675 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:
3676 case Intrinsic::nvvm_fmax_xorsign_abs_f:
3678 case Intrinsic::nvvm_fmin_f:
3679 case Intrinsic::nvvm_fmin_ftz_f:
3680 case Intrinsic::nvvm_fmin_ftz_nan_f:
3681 case Intrinsic::nvvm_fmin_ftz_nan_xorsign_abs_f:
3682 case Intrinsic::nvvm_fmin_ftz_xorsign_abs_f:
3683 case Intrinsic::nvvm_fmin_nan_f:
3684 case Intrinsic::nvvm_fmin_nan_xorsign_abs_f:
3685 case Intrinsic::nvvm_fmin_xorsign_abs_f:
3689 if (!IsOp0Undef && !IsOp1Undef)
3693 APInt NVCanonicalNaN(32, 0x7fffffff);
3694 return ConstantFP::get(
3695 Ty,
APFloat(Ty->getFltSemantics(), NVCanonicalNaN));
3698 return ConstantFP::get(Ty, FTZPreserveSign(
Op->getValueAPF()));
3707 const APFloat &Op1V = Op1->getValueAPF();
3710 if (Op2->getType() != Op1->getType())
3712 const APFloat &Op2V = Op2->getValueAPF();
3714 if (
const auto *ConstrIntr =
3719 switch (IntrinsicID) {
3722 case Intrinsic::experimental_constrained_fadd:
3723 St = Res.
add(Op2V, RM);
3725 case Intrinsic::experimental_constrained_fsub:
3728 case Intrinsic::experimental_constrained_fmul:
3731 case Intrinsic::experimental_constrained_fdiv:
3732 St = Res.
divide(Op2V, RM);
3734 case Intrinsic::experimental_constrained_frem:
3737 case Intrinsic::experimental_constrained_fcmp:
3738 case Intrinsic::experimental_constrained_fcmps:
3739 return evaluateCompare(Op1V, Op2V, ConstrIntr);
3743 return ConstantFP::get(Ty, Res);
3747 switch (IntrinsicID) {
3750 case Intrinsic::copysign:
3752 case Intrinsic::minnum:
3753 return ConstantFP::get(Ty,
minnum(Op1V, Op2V));
3754 case Intrinsic::maxnum:
3755 return ConstantFP::get(Ty,
maxnum(Op1V, Op2V));
3756 case Intrinsic::minimum:
3757 return ConstantFP::get(Ty,
minimum(Op1V, Op2V));
3758 case Intrinsic::maximum:
3759 return ConstantFP::get(Ty,
maximum(Op1V, Op2V));
3760 case Intrinsic::minimumnum:
3761 return ConstantFP::get(Ty,
minimumnum(Op1V, Op2V));
3762 case Intrinsic::maximumnum:
3763 return ConstantFP::get(Ty,
maximumnum(Op1V, Op2V));
3765 case Intrinsic::nvvm_fmax_d:
3766 case Intrinsic::nvvm_fmax_f:
3767 case Intrinsic::nvvm_fmax_ftz_f:
3768 case Intrinsic::nvvm_fmax_ftz_nan_f:
3769 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:
3770 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:
3771 case Intrinsic::nvvm_fmax_nan_f:
3772 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:
3773 case Intrinsic::nvvm_fmax_xorsign_abs_f:
3775 case Intrinsic::nvvm_fmin_d:
3776 case Intrinsic::nvvm_fmin_f:
3777 case Intrinsic::nvvm_fmin_ftz_f:
3778 case Intrinsic::nvvm_fmin_ftz_nan_f:
3779 case Intrinsic::nvvm_fmin_ftz_nan_xorsign_abs_f:
3780 case Intrinsic::nvvm_fmin_ftz_xorsign_abs_f:
3781 case Intrinsic::nvvm_fmin_nan_f:
3782 case Intrinsic::nvvm_fmin_nan_xorsign_abs_f:
3783 case Intrinsic::nvvm_fmin_xorsign_abs_f: {
3785 bool ShouldCanonicalizeNaNs = !(IntrinsicID == Intrinsic::nvvm_fmax_d ||
3786 IntrinsicID == Intrinsic::nvvm_fmin_d);
3791 APFloat A = IsFTZ ? FTZPreserveSign(Op1V) : Op1V;
3792 APFloat B = IsFTZ ? FTZPreserveSign(Op2V) : Op2V;
3794 bool XorSign =
false;
3796 XorSign =
A.isNegative() ^
B.isNegative();
3801 bool IsFMax =
false;
3802 switch (IntrinsicID) {
3803 case Intrinsic::nvvm_fmax_d:
3804 case Intrinsic::nvvm_fmax_f:
3805 case Intrinsic::nvvm_fmax_ftz_f:
3806 case Intrinsic::nvvm_fmax_ftz_nan_f:
3807 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:
3808 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:
3809 case Intrinsic::nvvm_fmax_nan_f:
3810 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:
3811 case Intrinsic::nvvm_fmax_xorsign_abs_f:
3819 if (ShouldCanonicalizeNaNs && Res.
isNaN()) {
3820 APFloat NVCanonicalNaN(Res.getSemantics(), APInt(32, 0x7fffffff));
3821 return ConstantFP::get(Ty, NVCanonicalNaN);
3827 return ConstantFP::get(Ty, Res);
3830 case Intrinsic::nvvm_div_rm_f:
3831 case Intrinsic::nvvm_div_rn_f:
3832 case Intrinsic::nvvm_div_rp_f:
3833 case Intrinsic::nvvm_div_rz_f:
3834 case Intrinsic::nvvm_div_rm_d:
3835 case Intrinsic::nvvm_div_rn_d:
3836 case Intrinsic::nvvm_div_rp_d:
3837 case Intrinsic::nvvm_div_rz_d:
3838 case Intrinsic::nvvm_div_rm_ftz_f:
3839 case Intrinsic::nvvm_div_rn_ftz_f:
3840 case Intrinsic::nvvm_div_rp_ftz_f:
3841 case Intrinsic::nvvm_div_rz_ftz_f: {
3843 APFloat A = IsFTZ ? FTZPreserveSign(Op1V) : Op1V;
3844 APFloat B = IsFTZ ? FTZPreserveSign(Op2V) : Op2V;
3852 Res = IsFTZ ? FTZPreserveSign(Res) : Res;
3853 return ConstantFP::get(Ty, Res);
3859 if (!Ty->isHalfTy() && !Ty->isFloatTy() && !Ty->isDoubleTy())
3862 switch (IntrinsicID) {
3865 case Intrinsic::pow:
3866 return ConstantFoldBinaryFP(pow, Op1V, Op2V, Ty);
3867 case Intrinsic::amdgcn_fmul_legacy:
3872 return ConstantFP::get(Ty, Op1V * Op2V);
3876 switch (IntrinsicID) {
3877 case Intrinsic::ldexp: {
3882 Exp =
Exp.getBitWidth() < 32 ?
Exp.sext(32) :
Exp.truncSSat(32);
3883 return ConstantFP::get(
3887 case Intrinsic::is_fpclass: {
3900 return ConstantInt::get(Ty, Result);
3902 case Intrinsic::powi: {
3905 int Exp =
static_cast<int>(Op2C->getSExtValue());
3906 unsigned UExp =
static_cast<unsigned>(
Exp);
3914 Res = Res * CurSquare;
3915 CurSquare = CurSquare * CurSquare;
3920 return ConstantFP::get(Ty, Res);
3936 switch (IntrinsicID) {
3938 case Intrinsic::smax:
3939 case Intrinsic::smin:
3940 case Intrinsic::umax:
3941 case Intrinsic::umin:
3944 return ConstantInt::get(
3950 case Intrinsic::scmp:
3951 case Intrinsic::ucmp:
3953 return ConstantInt::get(Ty, 0);
3956 if (IntrinsicID == Intrinsic::scmp)
3957 Res =
C0->sgt(*
C1) ? 1 :
C0->slt(*
C1) ? -1 : 0;
3959 Res =
C0->ugt(*
C1) ? 1 :
C0->ult(*
C1) ? -1 : 0;
3960 return ConstantInt::get(Ty, Res,
true);
3962 case Intrinsic::usub_with_overflow:
3963 case Intrinsic::ssub_with_overflow:
3969 case Intrinsic::uadd_with_overflow:
3970 case Intrinsic::sadd_with_overflow:
3980 case Intrinsic::smul_with_overflow:
3981 case Intrinsic::umul_with_overflow: {
3989 switch (IntrinsicID) {
3991 case Intrinsic::sadd_with_overflow:
3992 Res =
C0->sadd_ov(*
C1, Overflow);
3994 case Intrinsic::uadd_with_overflow:
3995 Res =
C0->uadd_ov(*
C1, Overflow);
3997 case Intrinsic::ssub_with_overflow:
3998 Res =
C0->ssub_ov(*
C1, Overflow);
4000 case Intrinsic::usub_with_overflow:
4001 Res =
C0->usub_ov(*
C1, Overflow);
4003 case Intrinsic::smul_with_overflow:
4004 Res =
C0->smul_ov(*
C1, Overflow);
4006 case Intrinsic::umul_with_overflow:
4007 Res =
C0->umul_ov(*
C1, Overflow);
4011 ConstantInt::get(Ty->getContext(), Res),
4016 case Intrinsic::uadd_sat:
4017 case Intrinsic::sadd_sat:
4020 if (IntrinsicID == Intrinsic::uadd_sat)
4021 return ConstantInt::get(Ty,
C0->uadd_sat(*
C1));
4023 return ConstantInt::get(Ty,
C0->sadd_sat(*
C1));
4024 case Intrinsic::usub_sat:
4025 case Intrinsic::ssub_sat:
4028 if (IntrinsicID == Intrinsic::usub_sat)
4029 return ConstantInt::get(Ty,
C0->usub_sat(*
C1));
4031 return ConstantInt::get(Ty,
C0->ssub_sat(*
C1));
4032 case Intrinsic::ushl_sat:
4033 case Intrinsic::sshl_sat:
4036 if (
C1->uge(
C1->getBitWidth()))
4038 if (IntrinsicID == Intrinsic::ushl_sat)
4039 return ConstantInt::get(Ty,
C0->ushl_sat(*
C1));
4040 return ConstantInt::get(Ty,
C0->sshl_sat(*
C1));
4041 case Intrinsic::cttz:
4042 case Intrinsic::ctlz:
4043 assert(
C1 &&
"Must be constant int");
4046 if (
C1->isOne() && (!
C0 ||
C0->isZero()))
4050 if (IntrinsicID == Intrinsic::cttz)
4051 return ConstantInt::get(Ty,
C0->countr_zero());
4053 return ConstantInt::get(Ty,
C0->countl_zero());
4055 case Intrinsic::abs:
4056 assert(
C1 &&
"Must be constant int");
4057 assert((
C1->isOne() ||
C1->isZero()) &&
"Must be 0 or 1");
4060 if (
C1->isOne() && (!
C0 ||
C0->isMinSignedValue()))
4067 return ConstantInt::get(Ty,
C0->abs());
4068 case Intrinsic::clmul:
4072 case Intrinsic::pdep:
4076 case Intrinsic::pext:
4080 case Intrinsic::smulh:
4084 case Intrinsic::umulh:
4088 case Intrinsic::amdgcn_wave_reduce_add:
4089 case Intrinsic::amdgcn_wave_reduce_sub:
4090 case Intrinsic::amdgcn_wave_reduce_xor: {
4091 if (
C0 &&
C0->isZero())
4095 case Intrinsic::amdgcn_wave_reduce_umin:
4096 case Intrinsic::amdgcn_wave_reduce_umax:
4097 case Intrinsic::amdgcn_wave_reduce_max:
4098 case Intrinsic::amdgcn_wave_reduce_min:
4099 case Intrinsic::amdgcn_wave_reduce_and:
4100 case Intrinsic::amdgcn_wave_reduce_or:
4102 case Intrinsic::aarch64_crc32b:
4103 case Intrinsic::arm_crc32b:
4104 return ConstantFoldCRC32(Ty,
C0,
C1, 1, 0xEDB88320);
4105 case Intrinsic::aarch64_crc32h:
4106 case Intrinsic::arm_crc32h:
4107 return ConstantFoldCRC32(Ty,
C0,
C1, 2, 0xEDB88320);
4108 case Intrinsic::aarch64_crc32w:
4109 case Intrinsic::arm_crc32w:
4110 return ConstantFoldCRC32(Ty,
C0,
C1, 4, 0xEDB88320);
4111 case Intrinsic::aarch64_crc32x:
4112 return ConstantFoldCRC32(Ty,
C0,
C1, 8, 0xEDB88320);
4113 case Intrinsic::aarch64_crc32cb:
4114 case Intrinsic::arm_crc32cb:
4115 case Intrinsic::x86_sse42_crc32_32_8:
4116 return ConstantFoldCRC32(Ty,
C0,
C1, 1, 0x82F63B78);
4117 case Intrinsic::aarch64_crc32ch:
4118 case Intrinsic::arm_crc32ch:
4119 case Intrinsic::x86_sse42_crc32_32_16:
4120 return ConstantFoldCRC32(Ty,
C0,
C1, 2, 0x82F63B78);
4121 case Intrinsic::aarch64_crc32cw:
4122 case Intrinsic::arm_crc32cw:
4123 case Intrinsic::x86_sse42_crc32_32_32:
4124 return ConstantFoldCRC32(Ty,
C0,
C1, 4, 0x82F63B78);
4125 case Intrinsic::aarch64_crc32cx:
4126 case Intrinsic::x86_sse42_crc32_64_64:
4127 return ConstantFoldCRC32(Ty,
C0,
C1, 8, 0x82F63B78);
4141 switch (IntrinsicID) {
4143 case Intrinsic::x86_avx512_vcvtss2si32:
4144 case Intrinsic::x86_avx512_vcvtss2si64:
4145 case Intrinsic::x86_avx512_vcvtsd2si32:
4146 case Intrinsic::x86_avx512_vcvtsd2si64:
4149 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
4153 case Intrinsic::x86_avx512_vcvtss2usi32:
4154 case Intrinsic::x86_avx512_vcvtss2usi64:
4155 case Intrinsic::x86_avx512_vcvtsd2usi32:
4156 case Intrinsic::x86_avx512_vcvtsd2usi64:
4159 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
4163 case Intrinsic::x86_avx512_cvttss2si:
4164 case Intrinsic::x86_avx512_cvttss2si64:
4165 case Intrinsic::x86_avx512_cvttsd2si:
4166 case Intrinsic::x86_avx512_cvttsd2si64:
4169 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
4173 case Intrinsic::x86_avx512_cvttss2usi:
4174 case Intrinsic::x86_avx512_cvttss2usi64:
4175 case Intrinsic::x86_avx512_cvttsd2usi:
4176 case Intrinsic::x86_avx512_cvttsd2usi64:
4179 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
4186 if (IntrinsicID == Intrinsic::experimental_cttz_elts) {
4191 unsigned Width = Ty->getIntegerBitWidth();
4193 Operands[0]->containsPoisonElement())
4195 for (
unsigned I = 0;
I < FVTy->getNumElements(); ++
I) {
4201 return ConstantInt::get(Ty,
I);
4205 return ConstantInt::get(Ty, FVTy->getNumElements());
4216 APFloat MA(Sem), SC(Sem), TC(Sem);
4229 if (
S1.isNegative() &&
S1.isNonZero() && !
S1.isNaN()) {
4251 switch (IntrinsicID) {
4254 case Intrinsic::amdgcn_cubeid:
4256 case Intrinsic::amdgcn_cubema:
4258 case Intrinsic::amdgcn_cubesc:
4260 case Intrinsic::amdgcn_cubetc:
4270 !getConstIntOrUndef(
Operands[2], C2))
4277 unsigned NumUndefBytes = 0;
4278 for (
unsigned I = 0;
I < 32;
I += 8) {
4287 const APInt *Src = ((Sel & 10) == 10 || (Sel & 12) == 4) ?
C0 :
C1;
4291 B = Src->extractBitsAsZExtValue(8, (Sel & 3) * 8);
4293 B = Src->extractBitsAsZExtValue(1, (Sel & 1) ? 31 : 15) * 0xff;
4296 Val.insertBits(
B,
I, 8);
4299 if (NumUndefBytes == 4)
4302 return ConstantInt::get(Ty, Val);
4316 const APFloat &C2 = Op2->getValueAPF();
4317 const APFloat &C3 = Op3->getValueAPF();
4319 if (
const auto *ConstrIntr =
4324 switch (IntrinsicID) {
4327 case Intrinsic::experimental_constrained_fma:
4328 case Intrinsic::experimental_constrained_fmuladd:
4332 if (mayFoldConstrained(
4334 return ConstantFP::get(Ty, Res);
4338 switch (IntrinsicID) {
4340 case Intrinsic::amdgcn_fma_legacy: {
4346 return ConstantFP::get(Ty,
APFloat(0.0f) + C3);
4350 case Intrinsic::fma:
4351 case Intrinsic::fmuladd: {
4354 return ConstantFP::get(Ty,
V);
4357 case Intrinsic::amdgcn_cubeid:
4358 case Intrinsic::amdgcn_cubema:
4359 case Intrinsic::amdgcn_cubesc:
4360 case Intrinsic::amdgcn_cubetc: {
4361 APFloat V = ConstantFoldAMDGCNCubeIntrinsic(IntrinsicID,
C1, C2, C3);
4362 return ConstantFP::get(Ty,
V);
4368 const bool IsFAdd = IntrinsicID == Intrinsic::nvvm_fadd ||
4369 IntrinsicID == Intrinsic::nvvm_fadd_ftz;
4370 const bool IsFMul = IntrinsicID == Intrinsic::nvvm_fmul ||
4371 IntrinsicID == Intrinsic::nvvm_fmul_ftz;
4372 if (IsFAdd || IsFMul) {
4373 bool IsFTZ = IntrinsicID == Intrinsic::nvvm_fadd_ftz ||
4374 IntrinsicID == Intrinsic::nvvm_fmul_ftz;
4376 IsFTZ ? FTZPreserveSign(Op1->getValueAPF()) : Op1->getValueAPF();
4378 IsFTZ ? FTZPreserveSign(Op2->getValueAPF()) : Op2->getValueAPF();
4385 IsFAdd ? Res.
add(
B, RoundMode) : Res.
multiply(
B, RoundMode);
4389 Res = IsFTZ ? FTZPreserveSign(Res) : Res;
4390 return ConstantFP::get(Ty, Res);
4397 if (IntrinsicID == Intrinsic::smul_fix ||
4398 IntrinsicID == Intrinsic::smul_fix_sat) {
4416 unsigned Width =
C0->getBitWidth();
4417 assert(Scale < Width &&
"Illegal scale.");
4418 unsigned ExtendedWidth = Width * 2;
4420 (
C0->sext(ExtendedWidth) *
C1->sext(ExtendedWidth)).
ashr(Scale);
4421 if (IntrinsicID == Intrinsic::smul_fix_sat) {
4427 return ConstantInt::get(Ty->getContext(), Product.
sextOrTrunc(Width));
4430 if (IntrinsicID == Intrinsic::fshl || IntrinsicID == Intrinsic::fshr) {
4434 !getConstIntOrUndef(
Operands[2], C2))
4437 bool IsRight = IntrinsicID == Intrinsic::fshr;
4451 unsigned LshrAmt = IsRight ? ShAmt :
BitWidth - ShAmt;
4452 unsigned ShlAmt = !IsRight ? ShAmt :
BitWidth - ShAmt;
4454 return ConstantInt::get(Ty,
C1->lshr(LshrAmt));
4456 return ConstantInt::get(Ty,
C0->shl(ShlAmt));
4457 return ConstantInt::get(Ty,
C0->shl(ShlAmt) |
C1->lshr(LshrAmt));
4460 if (IntrinsicID == Intrinsic::amdgcn_perm)
4461 return ConstantFoldAMDGCNPermIntrinsic(
Operands, Ty);
4474 if (IntrinsicID == Intrinsic::nvvm_fma ||
4475 IntrinsicID == Intrinsic::nvvm_fma_ftz) {
4479 if (!Op1 || !Op2 || !Op3)
4484 IsFTZ ? FTZPreserveSign(Op1->getValueAPF()) : Op1->getValueAPF();
4486 IsFTZ ? FTZPreserveSign(Op2->getValueAPF()) : Op2->getValueAPF();
4488 IsFTZ ? FTZPreserveSign(Op3->getValueAPF()) : Op3->getValueAPF();
4498 Res = IsFTZ ? FTZPreserveSign(Res) : Res;
4499 return ConstantFP::get(Ty, Res);
4518 return ConstantFoldScalarCall1(Name, IntrinsicID, Ty,
Operands,
TLI,
Call);
4523 return FoldedLibCall;
4525 return ConstantFoldIntrinsicCall2(IntrinsicID, Ty,
Operands,
Call);
4529 return ConstantFoldScalarCall3(Name, IntrinsicID, Ty,
Operands,
TLI,
Call);
4532 return ConstantFoldScalarCall4(Name, IntrinsicID, Ty,
Operands,
TLI,
Call);
4537static Constant *ConstantFoldFixedVectorCall(
4545 switch (IntrinsicID) {
4546 case Intrinsic::masked_load: {
4555 auto *MaskElt =
Mask->getAggregateElement(
I);
4558 auto *PassthruElt = Passthru->getAggregateElement(
I);
4568 if (MaskElt->isNullValue()) {
4572 }
else if (MaskElt->isOneValue()) {
4584 case Intrinsic::arm_mve_vctp8:
4585 case Intrinsic::arm_mve_vctp16:
4586 case Intrinsic::arm_mve_vctp32:
4587 case Intrinsic::arm_mve_vctp64: {
4593 for (
unsigned i = 0; i < Lanes; i++) {
4603 case Intrinsic::get_active_lane_mask: {
4609 APInt Limit = Op1->getValue();
4612 for (
unsigned I = 0;
I < Lanes;
I++) {
4614 if (
Base.uadd_ov(
APInt(
Base.getBitWidth(),
I), Overflow).ult(Limit) &&
4624 case Intrinsic::mask_beforefirst: {
4641 case Intrinsic::vector_extract: {
4648 unsigned VecNumElements =
4650 unsigned StartingIndex =
Idx->getZExtValue();
4653 if (NumElements == VecNumElements && StartingIndex == 0)
4656 for (
unsigned I = StartingIndex,
E = StartingIndex + NumElements;
I <
E;
4661 Result[
I - StartingIndex] = Elt;
4666 case Intrinsic::vector_insert: {
4673 unsigned SubVecNumElements =
4675 unsigned VecNumElements =
4677 unsigned IdxN =
Idx->getZExtValue();
4679 if (SubVecNumElements == VecNumElements && IdxN == 0)
4682 for (
unsigned I = 0;
I < VecNumElements; ++
I) {
4684 if (
I < IdxN + SubVecNumElements)
4694 case Intrinsic::vector_interleave2:
4695 case Intrinsic::vector_interleave3:
4696 case Intrinsic::vector_interleave4:
4697 case Intrinsic::vector_interleave5:
4698 case Intrinsic::vector_interleave6:
4699 case Intrinsic::vector_interleave7:
4700 case Intrinsic::vector_interleave8: {
4701 unsigned NumElements =
4703 unsigned NumOperands =
Operands.size();
4704 for (
unsigned I = 0;
I < NumElements; ++
I) {
4705 for (
unsigned J = 0; J < NumOperands; ++J) {
4709 Result[NumOperands *
I + J] = Elt;
4714 case Intrinsic::vector_partial_reduce_add:
4716 case Intrinsic::wasm_dot: {
4717 unsigned NumElements =
4721 "wasm dot takes i16x8 and produces i32x4");
4722 assert(Ty->isIntegerTy());
4723 int32_t MulVector[8];
4725 for (
unsigned I = 0;
I < NumElements; ++
I) {
4736 for (
unsigned I = 0;
I <
Result.size();
I++) {
4737 int64_t IAdd = (int64_t)MulVector[
I * 2] + (int64_t)MulVector[
I * 2 + 1];
4743 case Intrinsic::nvvm_fadd:
4744 case Intrinsic::nvvm_fadd_ftz:
4745 case Intrinsic::nvvm_fma:
4746 case Intrinsic::nvvm_fma_ftz:
4747 case Intrinsic::nvvm_fmul:
4748 case Intrinsic::nvvm_fmul_ftz:
4759 for (
unsigned J = 0, JE =
Operands.size(); J != JE; ++J) {
4775 ConstantFoldScalarCall(Name, IntrinsicID, Ty, Lane,
TLI,
Call);
4784static Constant *ConstantFoldScalableVectorCall(
4788 switch (IntrinsicID) {
4789 case Intrinsic::aarch64_sve_convert_from_svbool: {
4791 if (!Src->isNullValue())
4796 case Intrinsic::get_active_lane_mask: {
4799 if (Op0 && Op1 && Op0->getValue().uge(Op1->getValue()))
4803 case Intrinsic::mask_beforefirst: {
4811 case Intrinsic::vector_interleave2:
4812 case Intrinsic::vector_interleave3:
4813 case Intrinsic::vector_interleave4:
4814 case Intrinsic::vector_interleave5:
4815 case Intrinsic::vector_interleave6:
4816 case Intrinsic::vector_interleave7:
4817 case Intrinsic::vector_interleave8: {
4856static std::pair<Constant *, Constant *>
4862 const APFloat &U = ConstFP->getValueAPF();
4865 Constant *Result0 = ConstantFP::get(ConstFP->getType(), FrexpMant);
4872 return {Result0, Result1};
4882 switch (IntrinsicID) {
4883 case Intrinsic::frexp: {
4891 for (
unsigned I = 0,
E = FVTy0->getNumElements();
I !=
E; ++
I) {
4893 std::tie(Results0[
I], Results1[
I]) =
4894 ConstantFoldScalarFrexpCall(Lane, Ty1);
4903 auto [Result0, Result1] = ConstantFoldScalarFrexpCall(
Operands[0], Ty1);
4908 case Intrinsic::sincos: {
4912 auto ConstantFoldScalarSincosCall =
4913 [&](
Constant *
Op) -> std::pair<Constant *, Constant *> {
4915 ConstantFoldScalarCall(Name, Intrinsic::sin, TyScalar,
Op,
TLI,
Call);
4917 ConstantFoldScalarCall(Name, Intrinsic::cos, TyScalar,
Op,
TLI,
Call);
4918 return std::make_pair(SinResult, CosResult);
4927 std::tie(SinResults[
I], CosResults[
I]) =
4928 ConstantFoldScalarSincosCall(Lane);
4929 if (!SinResults[
I] || !CosResults[
I])
4937 if (!Ty->isFloatingPointTy())
4940 auto [SinResult, CosResult] = ConstantFoldScalarSincosCall(
Operands[0]);
4941 if (!SinResult || !CosResult)
4945 case Intrinsic::vector_deinterleave2:
4946 case Intrinsic::vector_deinterleave3:
4947 case Intrinsic::vector_deinterleave4:
4948 case Intrinsic::vector_deinterleave5:
4949 case Intrinsic::vector_deinterleave6:
4950 case Intrinsic::vector_deinterleave7:
4951 case Intrinsic::vector_deinterleave8: {
4971 for (
unsigned I = 0;
I != NumResults; ++
I) {
4972 for (
unsigned J = 0; J != NumElements; ++J) {
4985 return ConstantFoldScalarCall(Name, IntrinsicID, StTy,
Operands,
TLI,
Call);
5000 llvm_fenv_clearexcept();
5002 double Result = NativeFP(
Input.convertToDouble());
5003 if (llvm_fenv_testexcept()) {
5004 llvm_fenv_clearexcept();
5008 Constant *Output = GetConstantFoldFPValue(Result, Ty);
5012 APFloat Res = FlushWithDenormKind(CFP->getValueAPF(), DenormMode.
Output);
5013 return ConstantFP::get(Ty->getContext(), Res);
5027 return ConstantFoldFixedVectorCall(
"", ID, FVTy,
Ops,
DL);
5028 return ConstantFoldScalarCall(
"", ID, Ty,
Ops);
5034 bool AllowNonDeterministic) {
5035 if (
Call->isNoBuiltin())
5045 if (
TLI->getLibFunc(*
F) == NotLibFunc)
5051 Type *Ty =
F->getReturnType();
5052 if (!AllowNonDeterministic && Ty->isFPOrFPVectorTy())
5057 return ConstantFoldFixedVectorCall(
5061 return ConstantFoldScalableVectorCall(
5065 return ConstantFoldStructCall(Name, IID, StTy,
Operands,
5078 if (
Call->isNoBuiltin() ||
Call->isStrictFP())
5087 LibFunc Func =
TLI->getLibFunc(*
F);
5088 if (Func == NotLibFunc)
5091 if (
Call->arg_size() == 1) {
5101 case LibFunc_log10l:
5103 case LibFunc_log10f:
5104 return Op.isNaN() || (!
Op.isZero() && !
Op.isNegative());
5107 return !
Op.isNaN() && !
Op.isZero() && !
Op.isInfinity();
5113 if (OpC->getType()->isDoubleTy())
5115 if (OpC->getType()->isFloatTy())
5123 if (OpC->getType()->isDoubleTy())
5125 if (OpC->getType()->isFloatTy())
5135 return !
Op.isInfinity();
5139 case LibFunc_tanf: {
5142 Type *Ty = OpC->getType();
5143 if (Ty->isDoubleTy() || Ty->isFloatTy() || Ty->isHalfTy())
5170 if (OpC->getType()->isDoubleTy())
5172 if (OpC->getType()->isFloatTy())
5179 return Op.isNaN() ||
Op.isZero() || !
Op.isNegative();
5189 if (
Call->arg_size() == 2) {
5199 case LibFunc_powf: {
5203 if (Ty->isDoubleTy() || Ty->isFloatTy() || Ty->isHalfTy()) {
5205 return ConstantFoldBinaryFP(pow, Op0, Op1, Ty) !=
nullptr;
5213 case LibFunc_remainderl:
5214 case LibFunc_remainder:
5215 case LibFunc_remainderf:
5220 case LibFunc_atan2f:
5221 case LibFunc_atan2l:
5228 case LibFunc_nextafter:
5229 case LibFunc_nextafterf:
5230 case LibFunc_nextafterl:
5231 case LibFunc_nexttoward:
5232 case LibFunc_nexttowardf:
5233 case LibFunc_nexttowardl: {
5234 return ConstantFoldNextToward(Op0, Op1,
F->getReturnType()) !=
nullptr;
5249 case Instruction::BitCast:
5252 case Instruction::Trunc: {
5260 Flags->NSW = ZExtC == SExtC;
5264 case Instruction::SExt:
5265 case Instruction::ZExt: {
5269 if (!CastInvC || CastInvC !=
C)
5271 if (Flags && CastOp == Instruction::ZExt) {
5275 Flags->NNeg = CastInvC == SExtInvC;
5279 case Instruction::FPExt: {
5307void TargetFolder::anchor() {}
const TargetLowering & TLI
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
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...
This file implements the APSInt class, which is a simple class that represents an arbitrary sized int...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Function Alias Analysis Results
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static Constant * FoldBitCast(Constant *V, Type *DestTy)
static ConstantFP * flushDenormalConstant(Type *Ty, const APFloat &APF, DenormalMode::DenormalModeKind Mode)
Constant * getConstantAtOffset(Constant *Base, APInt Offset, const DataLayout &DL)
If this Offset points exactly to the start of an aggregate element, return that element,...
static cl::opt< bool > DisableFPCallFolding("disable-fp-call-folding", cl::desc("Disable constant-folding of FP intrinsics and libcalls."), cl::init(false), cl::Hidden)
static bool canConstantFoldIntrinsic(Intrinsic::ID ID, bool IsStrictFP)
Returns true if the intrinsic can be constant folded, given IsStrictFP.
static bool containsByteType(Type *Ty)
Return true if Ty is or contains a byte type.
static ConstantFP * flushDenormalConstantFP(ConstantFP *CFP, const Function *CtxF, bool IsOutput)
static bool anyTypeContainsFP(Type *RetTy, ArrayRef< Value * > Ops)
Given a function's return type and its operands, determine if any of them of of floating-point type.
static DenormalMode getInstrDenormalMode(const Function *CtxF, Type *Ty)
Return the denormal mode that can be assumed when executing a floating point operation at CtxI.
This file contains the declarations for the subclasses of Constant, which represent the different fla...
This file defines the DenseMap class.
amode Optimize addressing mode
static constexpr Value * getValue(Ty &ValueOrUse)
const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]
static bool InRange(int64_t Value, unsigned short Shift, int LBound, int HBound)
This file contains the definitions of the enumerations and flags associated with NVVM Intrinsics,...
MachineBasicBlock * Folded
SmallVector< MachineOperand, 4 > Cond
static cl::opt< RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode > Mode("regalloc-enable-advisor", cl::Hidden, cl::init(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default), cl::desc("Enable regalloc advisor mode"), cl::values(clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default, "default", "Default"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Release, "release", "precompiled"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Development, "development", "for training")))
This file implements the SmallBitVector class.
This file defines the SmallVector class.
static SymbolRef::Type getType(const Symbol *Sym)
cmpResult
IEEE-754R 5.11: Floating Point Comparison Relations.
static constexpr roundingMode rmTowardZero
llvm::RoundingMode roundingMode
IEEE-754R 4.3: Rounding-direction attributes.
static const fltSemantics & IEEEdouble()
static constexpr roundingMode rmTowardNegative
static constexpr roundingMode rmNearestTiesToEven
static constexpr roundingMode rmTowardPositive
static constexpr roundingMode rmNearestTiesToAway
opStatus
IEEE-754R 7: Default exception handling.
static APFloat getQNaN(const fltSemantics &Sem, bool Negative=false, const APInt *payload=nullptr)
Factory for QNaN values.
opStatus divide(const APFloat &RHS, roundingMode RM)
void copySign(const APFloat &RHS)
LLVM_ABI opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
opStatus subtract(const APFloat &RHS, roundingMode RM)
LLVM_ABI double convertToDouble() const
Converts this APFloat to host double value.
bool isPosInfinity() const
opStatus add(const APFloat &RHS, roundingMode RM)
const fltSemantics & getSemantics() const
static APFloat getOne(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative One.
opStatus multiply(const APFloat &RHS, roundingMode RM)
opStatus fusedMultiplyAdd(const APFloat &Multiplicand, const APFloat &Addend, roundingMode RM)
opStatus convertToInteger(MutableArrayRef< integerPart > Input, unsigned int Width, bool IsSigned, roundingMode RM, bool *IsExact) const
opStatus mod(const APFloat &RHS)
bool isNegInfinity() const
static APFloat getZero(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative Zero.
Class for arbitrary precision integers.
uint64_t getZExtValue() const
Get zero extended value.
LLVM_ABI uint64_t extractBitsAsZExtValue(unsigned numBits, unsigned bitPosition) const
LLVM_ABI APInt zextOrTrunc(unsigned width) const
Zero extend or truncate to width.
static APInt getMaxValue(unsigned numBits)
Gets maximum unsigned value of APInt for specific bit width.
LLVM_ABI APInt urem(const APInt &RHS) const
Unsigned remainder operation.
unsigned getBitWidth() const
Return the number of bits in the APInt.
static APInt getSignedMaxValue(unsigned numBits)
Gets maximum signed value of APInt for a specific bit width.
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
LLVM_ABI APInt sextOrTrunc(unsigned width) const
Sign extend or truncate to width.
LLVM_ABI void insertBits(const APInt &SubBits, unsigned bitPosition)
Insert the bits from a smaller APInt starting at bitPosition.
APInt ashr(unsigned ShiftAmt) const
Arithmetic right-shift function.
LLVM_ABI APInt sext(unsigned width) const
Sign extend to a new width.
static APInt getZero(unsigned numBits)
Get the '0' value for the specified bit-width.
LLVM_ABI APInt extractBits(unsigned numBits, unsigned bitPosition) const
Return an APInt with the extracted bits [bitPosition,bitPosition+numBits).
An arbitrary precision integer that knows its signedness.
Represent a constant reference to an array (0 or more elements consecutively in memory),...
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
static LLVM_ABI Instruction::CastOps getCastOpcode(const Value *Val, bool SrcIsSigned, Type *Ty, bool DstIsSigned)
Returns the opcode necessary to cast Val into Ty using usual casting rules.
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.
static LLVM_ABI bool castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy)
This method can be used to determine if a cast from SrcTy to DstTy using Opcode op is valid or not.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
static bool isFPPredicate(Predicate P)
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 LLVM_ABI Constant * getIntToPtr(Constant *C, Type *Ty, bool OnlyIfReduced=false)
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 * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)
Convenience function for getting a Cast operation.
static LLVM_ABI Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
static Constant * getPtrAdd(Constant *Ptr, Constant *Offset, GEPNoWrapFlags NW=GEPNoWrapFlags::none(), std::optional< ConstantRange > InRange=std::nullopt, Type *OnlyIfReduced=nullptr)
Create a getelementptr i8, ptr, offset constant expression.
static LLVM_ABI Constant * getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
static LLVM_SUPPRESS_DEPRECATED_DECLARATIONS_PUSH Constant * getGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList, GEPNoWrapFlags NW=GEPNoWrapFlags::none(), std::optional< ConstantRange > InRange=std::nullopt, Type *OnlyIfReducedTy=nullptr)
Getelementptr form.
static LLVM_ABI Constant * getShuffleVector(Constant *V1, Constant *V2, ArrayRef< int > Mask, Type *OnlyIfReducedTy=nullptr)
static bool isSupportedGetElementPtr(const Type *SrcElemTy)
Whether creating a constant expression for this getelementptr type is supported.
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 * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
ConstantFP - Floating Point Values [float, double].
const APFloat & getValueAPF() const
static LLVM_ABI ConstantFP * getZero(Type *Ty, bool Negative=false)
static LLVM_ABI ConstantFP * getNaN(Type *Ty, bool Negative=false, uint64_t Payload=0)
static LLVM_ABI ConstantFP * getInfinity(Type *Ty, bool Negative=false)
This is the shared class of boolean and integer constants.
static LLVM_ABI ConstantInt * getTrue(LLVMContext &Context)
static ConstantInt * getSigned(IntegerType *Ty, int64_t V, bool ImplicitTrunc=false)
Return a ConstantInt with the specified value for the specified type.
static LLVM_ABI 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 ...
static LLVM_ABI ConstantInt * getBool(LLVMContext &Context, bool V)
static LLVM_ABI Constant * get(StructType *T, ArrayRef< Constant * > V)
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.
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
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...
Constrained floating point compare intrinsics.
This is the common base class for constrained floating point intrinsics.
LLVM_ABI std::optional< fp::ExceptionBehavior > getExceptionBehavior() const
LLVM_ABI std::optional< RoundingMode > getRoundingMode() const
Wrapper for a function that represents a value that functionally represents the original function.
A parsed version of the target data layout string in and methods for querying it.
iterator find(const_arg_type_t< KeyT > Val)
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
static LLVM_ABI bool compare(const APFloat &LHS, const APFloat &RHS, FCmpInst::Predicate Pred)
Return result of LHS Pred RHS comparison.
Class to represent fixed width SIMD vectors.
unsigned getNumElements() const
static LLVM_ABI FixedVectorType * get(Type *ElementType, unsigned NumElts)
DenormalMode getDenormalMode(const fltSemantics &FPType) const
Returns the denormal handling type for the default rounding mode of the function.
bool isStrictFP() const
Determine if the function has strict floating point sematics.
Represents flags for the getelementptr instruction/expression.
static GEPNoWrapFlags inBounds()
GEPNoWrapFlags withoutNoUnsignedSignedWrap() const
static GEPNoWrapFlags noUnsignedWrap()
bool hasNoUnsignedSignedWrap() const
LLVM_ABI bool accumulateConstantOffset(const DataLayout &DL, APInt &Offset, function_ref< bool(Value &, APInt &)> ExternalAnalysis=nullptr) const
Accumulate the constant address offset of this GEP if possible.
static LLVM_ABI Type * getIndexedType(Type *Ty, ArrayRef< Value * > IdxList)
Returns the result type of a getelementptr with the given source element type and indexes.
PointerType * getType() const
Global values are always pointers.
LLVM_ABI const DataLayout & getDataLayout() const
Get the data layout of the module this global belongs to.
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
bool hasDefinitiveInitializer() const
hasDefinitiveInitializer - Whether the global variable has an initializer, and any other instances of...
static LLVM_ABI bool compare(const APInt &LHS, const APInt &RHS, ICmpInst::Predicate Pred)
Return result of LHS Pred RHS comparison.
Predicate getSignedPredicate() const
For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
bool isEquality() const
Return true if this predicate is either EQ or NE.
static LLVM_ABI IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
This is an important class for using LLVM in a threaded context.
static APInt getSaturationPoint(Intrinsic::ID ID, unsigned numBits)
Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values, so there is a certain thre...
static ICmpInst::Predicate getPredicate(Intrinsic::ID ID)
Returns the comparison predicate underlying the intrinsic.
static LLVM_ABI PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Class to represent scalable SIMD vectors.
This is a 'bitvector' (really, a variable-sized bit array), optimized for the case when the array is ...
iterator_range< const_set_bits_iterator > set_bits() const
void push_back(const T &Elt)
pointer data()
Return a pointer to the vector's buffer, even if empty().
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Represent a constant reference to a string, i.e.
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
LLVM_ABI unsigned getElementContainingOffset(uint64_t FixedOffset) const
Given a valid byte offset into the structure, returns the structure index that contains it.
TypeSize getElementOffset(unsigned Idx) const
Class to represent struct types.
unsigned getNumElements() const
Random access to the elements.
Provides information about what library functions are available for the current target.
The instances of the Type class are immutable: once they are created, they are never changed.
static LLVM_ABI IntegerType * getInt64Ty(LLVMContext &C)
bool isByteTy() const
True if this is an instance of ByteType.
bool isVectorTy() const
True if this is an instance of VectorType.
static LLVM_ABI IntegerType * getInt32Ty(LLVMContext &C)
bool isPointerTy() const
True if this is an instance of PointerType.
bool isSized() const
Return true if it makes sense to take the size of this type.
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
LLVM_ABI TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
bool isByteOrByteVectorTy() const
Return true if this is a byte type or a vector of byte types.
static LLVM_ABI IntegerType * getInt16Ty(LLVMContext &C)
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
static LLVM_ABI IntegerType * getInt1Ty(LLVMContext &C)
bool isFloatingPointTy() const
Return true if this is one of the floating-point types.
bool isPtrOrPtrVectorTy() const
Return true if this is a pointer type or a vector of pointer types.
bool isX86_AMXTy() const
Return true if this is X86 AMX.
bool isIntegerTy() const
True if this is an instance of IntegerType.
static LLVM_ABI IntegerType * getIntNTy(LLVMContext &C, unsigned N)
Type * getContainedType(unsigned i) const
This method is used to implement the type iterator (defined at the end of the file).
LLVM_ABI const fltSemantics & getFltSemantics() const
static LLVM_ABI UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
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.
LLVMContext & getContext() const
All values hold a context through their type.
LLVM_ABI const Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds, bool AllowInvariantGroup=false, function_ref< bool(Value &Value, APInt &Offset)> ExternalAnalysis=nullptr, bool LookThroughIntToPtr=false) const
Accumulate the constant offset this value has compared to a base pointer.
LLVM_ABI uint64_t getPointerDereferenceableBytes(const DataLayout &DL, bool &CanBeNull, bool *CanBeFreed) const
Returns the number of bytes known to be dereferenceable for the pointer value.
Base class of all SIMD vector types.
ElementCount getElementCount() const
Return an ElementCount instance to represent the (possibly scalable) number of elements in the vector...
Type * getElementType() const
constexpr ScalarTy getFixedValue() const
constexpr bool isScalable() const
Returns whether the quantity is scaled by a runtime quantity (vscale).
constexpr bool isFixed() const
Returns true if the quantity is not scaled by vscale.
constexpr LeafTy divideCoefficientBy(ScalarTy RHS) const
We do not provide the '/' operator here because division for polynomial types does not work in the sa...
static constexpr bool isKnownGE(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
LLVM_ABI APInt mulhu(const APInt &C1, const APInt &C2)
Performs (2*N)-bit multiplication on zero-extended operands.
LLVM_ABI APInt pext(const APInt &Val, const APInt &Mask)
Perform a "compress" operation, also known as pext or bext.
LLVM_ABI APInt mulhs(const APInt &C1, const APInt &C2)
Performs (2*N)-bit multiplication on sign-extended operands.
const APInt & smin(const APInt &A, const APInt &B)
Determine the smaller of two APInts considered to be signed.
const APInt & smax(const APInt &A, const APInt &B)
Determine the larger of two APInts considered to be signed.
LLVM_ABI APInt clmul(const APInt &LHS, const APInt &RHS)
Perform a carry-less multiply, also known as XOR multiplication, and return low-bits.
const APInt & umin(const APInt &A, const APInt &B)
Determine the smaller of two APInts considered to be unsigned.
LLVM_ABI APInt pdep(const APInt &Val, const APInt &Mask)
Perform an "expand" operation, also known as pdep or bdep.
const APInt & umax(const APInt &A, const APInt &B)
Determine the larger of two APInts considered to be unsigned.
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
@ CE
Windows NT (Windows on ARM)
initializer< Ty > init(const Ty &Val)
static constexpr roundingMode rmNearestTiesToEven
static constexpr cmpResult cmpEqual
@ ebStrict
This corresponds to "fpexcept.strict".
@ ebIgnore
This corresponds to "fpexcept.ignore".
APFloat::roundingMode GetRoundingModeFromImmArg(const Value *ImmArgVal)
DenormalMode GetNVVMDenormMode(bool ShouldFTZ)
bool FPToIntegerIntrinsicNaNZero(Intrinsic::ID IntrinsicID)
APFloat::roundingMode GetFDivRoundingMode(Intrinsic::ID IntrinsicID)
bool FPToIntegerIntrinsicResultIsSigned(Intrinsic::ID IntrinsicID)
APFloat::roundingMode GetFPToIntegerRoundingMode(Intrinsic::ID IntrinsicID)
bool RCPShouldFTZ(Intrinsic::ID IntrinsicID)
bool FPToIntegerIntrinsicShouldFTZ(Intrinsic::ID IntrinsicID)
bool FDivShouldFTZ(Intrinsic::ID IntrinsicID)
bool FMinFMaxIsXorSignAbs(Intrinsic::ID IntrinsicID)
bool FPArithShouldFTZ(Intrinsic::ID IntrinsicID)
bool UnaryMathIntrinsicShouldFTZ(Intrinsic::ID IntrinsicID)
bool FMinFMaxShouldFTZ(Intrinsic::ID IntrinsicID)
APFloat::roundingMode GetRCPRoundingMode(Intrinsic::ID IntrinsicID)
bool FMinFMaxPropagatesNaNs(Intrinsic::ID IntrinsicID)
NodeAddr< FuncNode * > Func
LLVM_ABI std::error_code status(const Twine &path, file_status &result, bool follow=true)
Get file status as if by POSIX stat().
This is an optimization pass for GlobalISel generic memory operations.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
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 * ConstantFoldLoadThroughBitcast(Constant *C, Type *DestTy, const DataLayout &DL)
ConstantFoldLoadThroughBitcast - try to cast constant to destination type returning null if unsuccess...
static double log2(double V)
LLVM_ABI Constant * ConstantFoldSelectInstruction(Constant *Cond, Constant *V1, Constant *V2)
Attempt to constant fold a select instruction with the specified operands.
LLVM_ABI Constant * ConstantFoldFPInstOperands(unsigned Opcode, Constant *LHS, Constant *RHS, const DataLayout &DL, const Instruction *I, bool AllowNonDeterministic=true)
Attempt to constant fold a floating point binary operation with the specified operands,...
auto enumerate(FirstRange &&First, RestRanges &&...Rest)
Given two or more input ranges, returns a new range whose values are tuples (A, B,...
unsigned getPointerAddressSpace(const Type *T)
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
LLVM_ABI Constant * ConstantFoldInstruction(const Instruction *I, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldInstruction - Try to constant fold the specified instruction.
APFloat abs(APFloat X)
Returns the absolute value of the argument.
LLVM_ABI Constant * ConstantFoldCompareInstruction(CmpInst::Predicate Predicate, Constant *C1, Constant *C2)
LLVM_ABI Constant * ConstantFoldUnaryInstruction(unsigned Opcode, Constant *V)
LLVM_ABI bool IsConstantOffsetFromGlobal(Constant *C, GlobalValue *&GV, APInt &Offset, const DataLayout &DL, DSOLocalEquivalent **DSOEquiv=nullptr)
If this constant is a constant offset from a global, return the global and the constant.
LLVM_ABI bool isMathLibCallNoop(const CallBase *Call, const TargetLibraryInfo *TLI)
Check whether the given call has no side-effects.
LLVM_ABI Constant * ReadByteArrayFromGlobal(const GlobalVariable *GV, uint64_t Offset)
auto dyn_cast_if_present(const Y &Val)
dyn_cast_if_present<X> - Functionally identical to dyn_cast, except that a null (or none in the case ...
LLVM_READONLY APFloat maximum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2019 maximum semantics.
LLVM_ABI void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true, unsigned Depth=0)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
LLVM_ABI Constant * ConstantFoldBitInsertOperands(Constant *Base, Constant *Val, Constant *Offset, const DataLayout &DL)
Attempt to constant fold a bitinsert instruction with the specified operands.
int ilogb(const APFloat &Arg)
Returns the exponent of the internal representation of the APFloat.
bool isa_and_nonnull(const Y &Val)
LLVM_ABI Constant * ConstantFoldCall(const CallBase *Call, Function *F, ArrayRef< Constant * > Operands, const TargetLibraryInfo *TLI=nullptr, bool AllowNonDeterministic=true)
ConstantFoldCall - Attempt to constant fold a call to the specified function with the specified argum...
LLVM_ABI bool canConstantFoldCallTo(const CallBase *Call, const Function *F, const TargetLibraryInfo *TLI=nullptr)
canConstantFoldCallTo - Return true if its even possible to fold a call to the specified function.
APFloat frexp(const APFloat &X, int &Exp, APFloat::roundingMode RM)
Equivalent of C standard library function.
LLVM_ABI Constant * ConstantFoldIntrinsic(Intrinsic::ID ID, ArrayRef< Constant * > Ops, Type *Ty, const DataLayout &DL, const Function *CtxF=nullptr)
LLVM_ABI Constant * ConstantFoldExtractValueInstruction(Constant *Agg, ArrayRef< unsigned > Idxs)
Attempt to constant fold an extractvalue instruction with the specified operands and indices.
LLVM_ABI Constant * ConstantFoldCompareInstOperands(unsigned Predicate, Constant *LHS, Constant *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const Function *CtxF=nullptr)
Attempt to constant fold a compare instruction (icmp/fcmp) with the specified operands.
LLVM_ABI Constant * ConstantFoldConstant(const Constant *C, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldConstant - Fold the constant using the specified DataLayout.
auto dyn_cast_or_null(const Y &Val)
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
LLVM_READONLY APFloat maxnum(const APFloat &A, const APFloat &B)
Implements IEEE-754 2008 maxNum semantics.
LLVM_ABI Constant * ConstantFoldLoadFromUniformValue(Constant *C, Type *Ty, const DataLayout &DL)
If C is a uniform value where all bits are the same (either all zero, all ones, all undef or all pois...
LLVM_ABI Constant * ConstantFoldUnaryOpOperand(unsigned Opcode, Constant *Op, const DataLayout &DL)
Attempt to constant fold a unary operation with the specified operand.
LLVM_ABI Constant * getLosslessUnsignedTrunc(Constant *C, Type *DestTy, const DataLayout &DL, PreservedCastFlags *Flags=nullptr)
LLVM_READONLY LLVM_ABI std::optional< APFloat > exp(const APFloat &X, RoundingMode RM=APFloat::rmNearestTiesToEven, APFloat::opStatus *Status=nullptr)
Implement IEEE 754-2019 exp functions.
decltype(auto) get(const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)
LLVM_READONLY APFloat minimumnum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2019 minimumNumber semantics.
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM)
Returns: X * 2^Exp for integral exponents.
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 * getLosslessSignedTrunc(Constant *C, Type *DestTy, const DataLayout &DL, PreservedCastFlags *Flags=nullptr)
LLVM_ABI Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)
Attempt to constant fold a cast with the specified operand.
LLVM_ABI Constant * ConstantFoldLoadFromConst(Constant *C, Type *Ty, const APInt &Offset, const DataLayout &DL)
Extract value of C at the given Offset reinterpreted as Ty.
LLVM_ABI const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=MaxLookupSearchDepth, bool MustPreserveProvenance=false)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
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...
LLVM_ABI bool intrinsicPropagatesPoison(Intrinsic::ID IID)
Return whether this intrinsic propagates poison for all operands.
LLVM_ABI Constant * ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS, Constant *RHS, const DataLayout &DL)
Attempt to constant fold a binary operation with the specified operands.
LLVM_ABI Constant * FlushFPConstant(Constant *Operand, const Function *CtxF, bool IsOutput)
Attempt to flush float point constant according to denormal mode set in the instruction's parent func...
MutableArrayRef(T &OneElt) -> MutableArrayRef< T >
LLVM_ABI Constant * ConstantFoldBitExtractOperands(Type *Ty, Constant *Src, Constant *Offset, const DataLayout &DL)
Attempt to constant fold a bitextract instruction with the specified result type and operands.
LLVM_READONLY APFloat minnum(const APFloat &A, const APFloat &B)
Implements IEEE-754 2008 minNum semantics.
@ Sub
Subtraction of integers.
LLVM_ABI bool isVectorIntrinsicWithScalarOpAtArg(Intrinsic::ID ID, unsigned ScalarOpdIdx, const TargetTransformInfo *TTI)
Identifies if the vector form of the intrinsic has a scalar operand.
DWARFExpression::Operation Op
RoundingMode
Rounding mode.
@ NearestTiesToEven
roundTiesToEven.
@ Dynamic
Denotes mode unknown at compile time.
LLVM_ABI bool isGuaranteedNotToBeUndefOrPoison(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Return true if this function can prove that V does not have undef bits and is never poison.
constexpr unsigned BitWidth
LLVM_ABI Constant * getLosslessInvCast(Constant *C, Type *InvCastTo, unsigned CastOp, const DataLayout &DL, PreservedCastFlags *Flags=nullptr)
Try to cast C to InvC losslessly, satisfying CastOp(InvC) equals C, or CastOp(InvC) is a refined valu...
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Next
bool all_equal(std::initializer_list< T > Values)
Returns true if all Values in the initializer lists are equal or the list.
LLVM_ABI Constant * ConstantFoldCastInstruction(unsigned opcode, Constant *V, Type *DestTy)
LLVM_ABI Constant * ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val, ArrayRef< unsigned > Idxs)
Attempt to constant fold an insertvalue instruction with the specified operands and indices.
LLVM_ABI Constant * ConstantFoldLoadFromConstPtr(Constant *C, Type *Ty, APInt Offset, const DataLayout &DL)
Return the value that a load from C with offset Offset would produce if it is constant and determinab...
constexpr uint32_t calculateReflectedCRC32(uint32_t Crc, uint64_t Data, unsigned DataBytes, uint32_t Poly)
LLVM_ABI Constant * ConstantFoldInstOperands(const Instruction *I, ArrayRef< Constant * > Ops, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, bool AllowNonDeterministic=true)
ConstantFoldInstOperands - Attempt to constant fold an instruction with the specified operands.
LLVM_READONLY APFloat minimum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2019 minimum semantics.
LLVM_READONLY APFloat maximumnum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2019 maximumNumber semantics.
LLVM_ABI Constant * ConstantFoldIntegerCast(Constant *C, Type *DestTy, bool IsSigned, const DataLayout &DL)
Constant fold a zext, sext or trunc, depending on IsSigned and whether the DestTy is wider or narrowe...
LLVM_ABI bool isTriviallyVectorizable(Intrinsic::ID ID)
Identify if the intrinsic is trivially vectorizable.
constexpr detail::IsaCheckPredicate< Types... > IsaPred
Function object wrapper for the llvm::isa type check.
LLVM_ABI Constant * ConstantFoldBinaryInstruction(unsigned Opcode, Constant *V1, Constant *V2)
LLVM_ABI Constant * ConstantFoldFP(double(*NativeFP)(double), const APFloat &V, Type *Ty, DenormalMode DenormMode=DenormalMode::getIEEE())
Evaluate NativeFP on V using the host libm, then convert the result to Ty.
Represent subnormal handling kind for floating point instruction inputs and outputs.
DenormalModeKind Input
Denormal treatment kind for floating point instruction inputs in the default floating-point environme...
DenormalModeKind
Represent handled modes for denormal (aka subnormal) modes in the floating point environment.
@ PreserveSign
The sign of a flushed-to-zero number is preserved in the sign of 0.
@ PositiveZero
Denormals are flushed to positive zero.
@ Dynamic
Denormals have unknown treatment.
@ IEEE
IEEE-754 denormal numbers preserved.
constexpr bool isValid() const
DenormalModeKind Output
Denormal flushing mode for floating point instruction results in the default floating point environme...
static constexpr DenormalMode getDynamic()
static constexpr DenormalMode getIEEE()
bool isConstant() const
Returns true if we know the value of all bits.
const APInt & getConstant() const
Returns the value when all bits have a known value.