31#include "llvm/Config/config.h"
45#include "llvm/IR/IntrinsicsAArch64.h"
46#include "llvm/IR/IntrinsicsAMDGPU.h"
47#include "llvm/IR/IntrinsicsARM.h"
48#include "llvm/IR/IntrinsicsNVPTX.h"
49#include "llvm/IR/IntrinsicsWebAssembly.h"
50#include "llvm/IR/IntrinsicsX86.h"
79 unsigned BitShift =
DL.getTypeSizeInBits(SrcEltTy);
80 for (
unsigned i = 0; i != NumSrcElts; ++i) {
82 if (
DL.isLittleEndian())
83 Element =
C->getAggregateElement(NumSrcElts - i - 1);
85 Element =
C->getAggregateElement(i);
87 if (isa_and_nonnull<UndefValue>(Element)) {
92 auto *ElementCI = dyn_cast_or_null<ConstantInt>(Element);
97 Result |= ElementCI->getValue().zext(
Result.getBitWidth());
108 "Invalid constantexpr bitcast!");
114 if (
auto *VTy = dyn_cast<VectorType>(
C->getType())) {
117 unsigned NumSrcElts = cast<FixedVectorType>(VTy)->getNumElements();
118 Type *SrcEltTy = VTy->getElementType();
131 if (
Constant *CE = foldConstVectorToAPInt(Result, DestTy,
C,
132 SrcEltTy, NumSrcElts,
DL))
135 if (isa<IntegerType>(DestTy))
136 return ConstantInt::get(DestTy, Result);
144 auto *DestVTy = dyn_cast<VectorType>(DestTy);
150 if (!isa<VectorType>(
C->getType()) &&
151 (isa<ConstantFP>(
C) || isa<ConstantInt>(
C))) {
158 if (!isa<FixedVectorType>(
C->getType()))
162 if (!isa<ConstantDataVector>(
C) && !isa<ConstantVector>(
C) &&
163 !isa<ConstantInt>(
C) && !isa<ConstantFP>(
C))
167 unsigned NumDstElt = cast<FixedVectorType>(DestVTy)->getNumElements();
168 unsigned NumSrcElt = cast<FixedVectorType>(
C->getType())->getNumElements();
169 if (NumDstElt == NumSrcElt)
172 Type *SrcEltTy = cast<VectorType>(
C->getType())->getElementType();
173 Type *DstEltTy = DestVTy->getElementType();
205 assert((isa<ConstantVector>(
C) ||
206 isa<ConstantDataVector>(
C) || isa<ConstantInt>(
C)) &&
207 "Constant folding cannot fail for plain fp->int bitcast!");
214 bool isLittleEndian =
DL.isLittleEndian();
217 if (NumDstElt < NumSrcElt) {
220 unsigned Ratio = NumSrcElt/NumDstElt;
223 for (
unsigned i = 0; i != NumDstElt; ++i) {
226 unsigned ShiftAmt = isLittleEndian ? 0 : SrcBitSize*(Ratio-1);
227 for (
unsigned j = 0;
j != Ratio; ++
j) {
228 Constant *Src =
C->getAggregateElement(SrcElt++);
229 if (isa_and_nonnull<UndefValue>(Src))
231 cast<VectorType>(
C->getType())->getElementType());
233 Src = dyn_cast_or_null<ConstantInt>(Src);
240 assert(Src &&
"Constant folding cannot fail on plain integers");
244 Instruction::Shl, Src, ConstantInt::get(Src->getType(), ShiftAmt),
246 assert(Src &&
"Constant folding cannot fail on plain integers");
248 ShiftAmt += isLittleEndian ? SrcBitSize : -SrcBitSize;
252 assert(Elt &&
"Constant folding cannot fail on plain integers");
260 unsigned Ratio = NumDstElt/NumSrcElt;
261 unsigned DstBitSize =
DL.getTypeSizeInBits(DstEltTy);
264 for (
unsigned i = 0; i != NumSrcElt; ++i) {
265 auto *Element =
C->getAggregateElement(i);
270 if (isa<UndefValue>(Element)) {
276 auto *Src = dyn_cast<ConstantInt>(Element);
280 unsigned ShiftAmt = isLittleEndian ? 0 : DstBitSize*(Ratio-1);
281 for (
unsigned j = 0;
j != Ratio; ++
j) {
284 APInt Elt = Src->getValue().lshr(ShiftAmt);
285 ShiftAmt += isLittleEndian ? DstBitSize : -DstBitSize;
288 Result.push_back(ConstantInt::get(DstEltTy, Elt.
trunc(DstBitSize)));
306 if ((GV = dyn_cast<GlobalValue>(
C))) {
312 if (
auto *FoundDSOEquiv = dyn_cast<DSOLocalEquivalent>(
C)) {
314 *DSOEquiv = FoundDSOEquiv;
315 GV = FoundDSOEquiv->getGlobalValue();
322 auto *CE = dyn_cast<ConstantExpr>(
C);
323 if (!CE)
return false;
326 if (CE->getOpcode() == Instruction::PtrToInt ||
327 CE->getOpcode() == Instruction::BitCast)
332 auto *
GEP = dyn_cast<GEPOperator>(CE);
336 unsigned BitWidth =
DL.getIndexTypeSizeInBits(
GEP->getType());
345 if (!
GEP->accumulateConstantOffset(
DL, TmpOffset))
355 Type *SrcTy =
C->getType();
359 TypeSize DestSize =
DL.getTypeSizeInBits(DestTy);
360 TypeSize SrcSize =
DL.getTypeSizeInBits(SrcTy);
361 if (!TypeSize::isKnownGE(SrcSize, DestSize))
372 if (SrcSize == DestSize &&
379 Cast = Instruction::IntToPtr;
381 Cast = Instruction::PtrToInt;
402 ElemC =
C->getAggregateElement(Elem++);
403 }
while (ElemC &&
DL.getTypeSizeInBits(ElemC->
getType()).isZero());
408 if (
auto *VT = dyn_cast<VectorType>(SrcTy))
409 if (!
DL.typeSizeEqualsStoreSize(VT->getElementType()))
412 C =
C->getAggregateElement(0u);
427 assert(ByteOffset <=
DL.getTypeAllocSize(
C->getType()) &&
428 "Out of range access");
432 if (isa<ConstantAggregateZero>(
C) || isa<UndefValue>(
C))
435 if (
auto *CI = dyn_cast<ConstantInt>(
C)) {
436 if ((CI->getBitWidth() & 7) != 0)
438 const APInt &Val = CI->getValue();
439 unsigned IntBytes =
unsigned(CI->getBitWidth()/8);
441 for (
unsigned i = 0; i != BytesLeft && ByteOffset != IntBytes; ++i) {
442 unsigned n = ByteOffset;
443 if (!
DL.isLittleEndian())
444 n = IntBytes - n - 1;
451 if (
auto *CFP = dyn_cast<ConstantFP>(
C)) {
452 if (CFP->getType()->isDoubleTy()) {
454 return ReadDataFromGlobal(
C, ByteOffset, CurPtr, BytesLeft,
DL);
456 if (CFP->getType()->isFloatTy()){
458 return ReadDataFromGlobal(
C, ByteOffset, CurPtr, BytesLeft,
DL);
460 if (CFP->getType()->isHalfTy()){
462 return ReadDataFromGlobal(
C, ByteOffset, CurPtr, BytesLeft,
DL);
467 if (
auto *CS = dyn_cast<ConstantStruct>(
C)) {
471 ByteOffset -= CurEltOffset;
476 uint64_t EltSize =
DL.getTypeAllocSize(CS->getOperand(Index)->getType());
478 if (ByteOffset < EltSize &&
479 !ReadDataFromGlobal(CS->getOperand(Index), ByteOffset, CurPtr,
486 if (Index == CS->getType()->getNumElements())
492 if (BytesLeft <= NextEltOffset - CurEltOffset - ByteOffset)
496 CurPtr += NextEltOffset - CurEltOffset - ByteOffset;
497 BytesLeft -= NextEltOffset - CurEltOffset - ByteOffset;
499 CurEltOffset = NextEltOffset;
504 if (isa<ConstantArray>(
C) || isa<ConstantVector>(
C) ||
505 isa<ConstantDataSequential>(
C)) {
508 if (
auto *AT = dyn_cast<ArrayType>(
C->getType())) {
509 NumElts = AT->getNumElements();
510 EltTy = AT->getElementType();
511 EltSize =
DL.getTypeAllocSize(EltTy);
513 NumElts = cast<FixedVectorType>(
C->getType())->getNumElements();
514 EltTy = cast<FixedVectorType>(
C->getType())->getElementType();
517 if (!
DL.typeSizeEqualsStoreSize(EltTy))
520 EltSize =
DL.getTypeStoreSize(EltTy);
526 if (!ReadDataFromGlobal(
C->getAggregateElement(Index),
Offset, CurPtr,
531 assert(BytesWritten <= EltSize &&
"Not indexing into this element?");
532 if (BytesWritten >= BytesLeft)
536 BytesLeft -= BytesWritten;
537 CurPtr += BytesWritten;
542 if (
auto *CE = dyn_cast<ConstantExpr>(
C)) {
543 if (
CE->getOpcode() == Instruction::IntToPtr &&
544 CE->getOperand(0)->getType() ==
DL.getIntPtrType(
CE->getType())) {
545 return ReadDataFromGlobal(
CE->getOperand(0), ByteOffset, CurPtr,
557 if (isa<ScalableVectorType>(LoadTy))
560 auto *IntType = dyn_cast<IntegerType>(LoadTy);
573 DL.getTypeSizeInBits(LoadTy).getFixedValue());
594 unsigned BytesLoaded = (IntType->getBitWidth() + 7) / 8;
595 if (BytesLoaded > 32 || BytesLoaded == 0)
599 if (
Offset <= -1 *
static_cast<int64_t
>(BytesLoaded))
603 TypeSize InitializerSize =
DL.getTypeAllocSize(
C->getType());
611 unsigned char RawBytes[32] = {0};
612 unsigned char *CurPtr = RawBytes;
613 unsigned BytesLeft = BytesLoaded;
622 if (!ReadDataFromGlobal(
C,
Offset, CurPtr, BytesLeft,
DL))
625 APInt ResultVal =
APInt(IntType->getBitWidth(), 0);
626 if (
DL.isLittleEndian()) {
627 ResultVal = RawBytes[BytesLoaded - 1];
628 for (
unsigned i = 1; i != BytesLoaded; ++i) {
630 ResultVal |= RawBytes[BytesLoaded - 1 - i];
633 ResultVal = RawBytes[0];
634 for (
unsigned i = 1; i != BytesLoaded; ++i) {
636 ResultVal |= RawBytes[i];
640 return ConstantInt::get(IntType->getContext(), ResultVal);
660 if (NBytes > UINT16_MAX)
668 unsigned char *CurPtr = RawBytes.
data();
670 if (!ReadDataFromGlobal(
Init,
Offset, CurPtr, NBytes,
DL))
683 if (!isa<ConstantAggregate>(
Base) && !isa<ConstantDataSequential>(
Base))
688 if (!
Offset.isZero() || !Indices[0].isZero())
693 if (Index.isNegative() || Index.getActiveBits() >= 32)
696 C =
C->getAggregateElement(Index.getZExtValue());
722 if (
Offset.getSignificantBits() <= 64)
724 FoldReinterpretLoadFromConst(
C, Ty,
Offset.getSExtValue(),
DL))
741 if (!GV || !GV->isConstant() || !GV->hasDefinitiveInitializer())
744 C = cast<Constant>(
C->stripAndAccumulateConstantOffsets(
765 if (isa<PoisonValue>(
C))
767 if (isa<UndefValue>(
C))
771 if (!
DL.typeSizeEqualsStoreSize(
C->getType()))
775 if (
C->isAllOnesValue() &&
795 if (Opc == Instruction::And) {
798 if ((Known1.
One | Known0.
Zero).isAllOnes()) {
802 if ((Known0.
One | Known1.
Zero).isAllOnes()) {
814 if (Opc == Instruction::Sub) {
820 unsigned OpSize =
DL.getTypeSizeInBits(Op0->
getType());
837 std::optional<ConstantRange>
InRange,
839 Type *IntIdxTy =
DL.getIndexType(ResultTy);
844 for (
unsigned i = 1, e = Ops.
size(); i != e; ++i) {
847 SrcElemTy, Ops.
slice(1, i - 1)))) &&
848 Ops[i]->getType()->getScalarType() != IntIdxScalarTy) {
851 Ops[i]->getType()->isVectorTy() ? IntIdxTy : IntIdxScalarTy;
875 Type *SrcElemTy =
GEP->getSourceElementType();
877 if (!SrcElemTy->
isSized() || isa<ScalableVectorType>(SrcElemTy))
880 if (
Constant *
C = CastGEPIndices(SrcElemTy, Ops, ResTy,
GEP->getNoWrapFlags(),
881 GEP->getInRange(),
DL, TLI))
885 if (!
Ptr->getType()->isPointerTy())
888 Type *IntIdxTy =
DL.getIndexType(
Ptr->getType());
890 for (
unsigned i = 1, e = Ops.
size(); i != e; ++i)
891 if (!isa<ConstantInt>(Ops[i]) || !Ops[i]->
getType()->isIntegerTy())
894 unsigned BitWidth =
DL.getTypeSizeInBits(IntIdxTy);
897 DL.getIndexedOffsetInType(
901 std::optional<ConstantRange>
InRange =
GEP->getInRange();
907 bool Overflow =
false;
908 while (
auto *
GEP = dyn_cast<GEPOperator>(
Ptr)) {
909 NW &=
GEP->getNoWrapFlags();
914 bool AllConstantInt =
true;
915 for (
Value *NestedOp : NestedOps)
916 if (!isa<ConstantInt>(NestedOp)) {
917 AllConstantInt =
false;
931 Ptr = cast<Constant>(
GEP->getOperand(0));
932 SrcElemTy =
GEP->getSourceElementType();
947 if (
auto *CE = dyn_cast<ConstantExpr>(
Ptr)) {
948 if (
CE->getOpcode() == Instruction::IntToPtr) {
949 if (
auto *
Base = dyn_cast<ConstantInt>(
CE->getOperand(0)))
954 auto *PTy = cast<PointerType>(
Ptr->getType());
955 if ((
Ptr->isNullValue() || BasePtr != 0) &&
956 !
DL.isNonIntegralPointerType(PTy)) {
963 bool CanBeNull, CanBeFreed;
965 Ptr->getPointerDereferenceableBytes(
DL, CanBeNull, CanBeFreed);
966 if (DerefBytes != 0 && !CanBeNull &&
Offset.sle(DerefBytes))
977 ConstantInt::get(Ctx,
Offset), NW,
986Constant *ConstantFoldInstOperandsImpl(
const Value *InstOrCE,
unsigned Opcode,
990 bool AllowNonDeterministic) {
1000 case Instruction::FAdd:
1001 case Instruction::FSub:
1002 case Instruction::FMul:
1003 case Instruction::FDiv:
1004 case Instruction::FRem:
1008 if (
const auto *
I = dyn_cast<Instruction>(InstOrCE)) {
1010 AllowNonDeterministic);
1019 if (
auto *
GEP = dyn_cast<GEPOperator>(InstOrCE)) {
1020 Type *SrcElemTy =
GEP->getSourceElementType();
1028 GEP->getNoWrapFlags(),
1032 if (
auto *CE = dyn_cast<ConstantExpr>(InstOrCE))
1033 return CE->getWithOperands(Ops);
1036 default:
return nullptr;
1037 case Instruction::ICmp:
1038 case Instruction::FCmp: {
1039 auto *
C = cast<CmpInst>(InstOrCE);
1043 case Instruction::Freeze:
1045 case Instruction::Call:
1046 if (
auto *
F = dyn_cast<Function>(Ops.
back())) {
1047 const auto *
Call = cast<CallBase>(InstOrCE);
1050 AllowNonDeterministic);
1053 case Instruction::Select:
1055 case Instruction::ExtractElement:
1057 case Instruction::ExtractValue:
1059 Ops[0], cast<ExtractValueInst>(InstOrCE)->getIndices());
1060 case Instruction::InsertElement:
1062 case Instruction::InsertValue:
1064 Ops[0], Ops[1], cast<InsertValueInst>(InstOrCE)->getIndices());
1065 case Instruction::ShuffleVector:
1067 Ops[0], Ops[1], cast<ShuffleVectorInst>(InstOrCE)->getShuffleMask());
1068 case Instruction::Load: {
1069 const auto *LI = dyn_cast<LoadInst>(InstOrCE);
1070 if (LI->isVolatile())
1089 if (!isa<ConstantVector>(
C) && !isa<ConstantExpr>(
C))
1093 for (
const Use &OldU :
C->operands()) {
1094 Constant *OldC = cast<Constant>(&OldU);
1098 if (isa<ConstantVector>(OldC) || isa<ConstantExpr>(OldC)) {
1099 auto It = FoldedOps.
find(OldC);
1100 if (It == FoldedOps.
end()) {
1101 NewC = ConstantFoldConstantImpl(OldC,
DL, TLI, FoldedOps);
1102 FoldedOps.
insert({OldC, NewC});
1110 if (
auto *CE = dyn_cast<ConstantExpr>(
C)) {
1111 if (
Constant *Res = ConstantFoldInstOperandsImpl(
1112 CE,
CE->getOpcode(), Ops,
DL, TLI,
true))
1117 assert(isa<ConstantVector>(
C));
1126 if (
auto *PN = dyn_cast<PHINode>(
I)) {
1142 C = ConstantFoldConstantImpl(
C,
DL, TLI, FoldedOps);
1145 if (CommonValue &&
C != CommonValue)
1156 if (!
all_of(
I->operands(), [](
Use &U) { return isa<Constant>(U); }))
1161 for (
const Use &OpU :
I->operands()) {
1162 auto *
Op = cast<Constant>(&OpU);
1164 Op = ConstantFoldConstantImpl(
Op,
DL, TLI, FoldedOps);
1174 return ConstantFoldConstantImpl(
C,
DL, TLI, FoldedOps);
1181 bool AllowNonDeterministic) {
1182 return ConstantFoldInstOperandsImpl(
I,
I->getOpcode(), Ops,
DL, TLI,
1183 AllowNonDeterministic);
1200 if (
auto *CE0 = dyn_cast<ConstantExpr>(Ops0)) {
1202 if (CE0->getOpcode() == Instruction::IntToPtr) {
1203 Type *IntPtrTy =
DL.getIntPtrType(CE0->getType());
1215 if (CE0->getOpcode() == Instruction::PtrToInt) {
1216 Type *IntPtrTy =
DL.getIntPtrType(CE0->getOperand(0)->getType());
1217 if (CE0->getType() == IntPtrTy) {
1225 if (
auto *CE1 = dyn_cast<ConstantExpr>(Ops1)) {
1226 if (CE0->getOpcode() == CE1->getOpcode()) {
1227 if (CE0->getOpcode() == Instruction::IntToPtr) {
1228 Type *IntPtrTy =
DL.getIntPtrType(CE0->getType());
1242 if (CE0->getOpcode() == Instruction::PtrToInt) {
1243 Type *IntPtrTy =
DL.getIntPtrType(CE0->getOperand(0)->getType());
1244 if (CE0->getType() == IntPtrTy &&
1245 CE0->getOperand(0)->getType() == CE1->getOperand(0)->getType()) {
1247 Predicate, CE0->getOperand(0), CE1->getOperand(0),
DL, TLI);
1259 unsigned IndexWidth =
DL.getIndexTypeSizeInBits(Ops0->
getType());
1260 APInt Offset0(IndexWidth, 0);
1263 APInt Offset1(IndexWidth, 0);
1266 if (Stripped0 == Stripped1)
1272 }
else if (isa<ConstantExpr>(Ops1)) {
1275 Predicate = ICmpInst::getSwappedPredicate(Predicate);
1304 if (isa<ConstantExpr>(
LHS) || isa<ConstantExpr>(
RHS))
1319 return ConstantFP::get(Ty->
getContext(), APF);
1321 return ConstantFP::get(
1351 IsOutput ? Mode.Output : Mode.Input);
1356 if (
ConstantFP *CFP = dyn_cast<ConstantFP>(Operand))
1359 if (isa<ConstantAggregateZero, UndefValue, ConstantExpr>(Operand))
1363 VectorType *VecTy = dyn_cast<VectorType>(Ty);
1375 if (
const auto *CV = dyn_cast<ConstantVector>(Operand)) {
1377 for (
unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {
1379 if (isa<UndefValue>(Element)) {
1384 ConstantFP *CFP = dyn_cast<ConstantFP>(Element);
1397 if (
const auto *CDV = dyn_cast<ConstantDataVector>(Operand)) {
1399 for (
unsigned I = 0, E = CDV->getNumElements();
I < E; ++
I) {
1400 const APFloat &Elt = CDV->getElementAsAPFloat(
I);
1402 NewElts.
push_back(ConstantFP::get(Ty, Elt));
1422 bool AllowNonDeterministic) {
1435 if (!AllowNonDeterministic)
1436 if (
auto *
FP = dyn_cast_or_null<FPMathOperator>(
I))
1437 if (
FP->hasNoSignedZeros() ||
FP->hasAllowReassoc() ||
1438 FP->hasAllowContract() ||
FP->hasAllowReciprocal())
1452 if (!AllowNonDeterministic &&
C->isNaN())
1468 case Instruction::PtrToInt:
1469 if (
auto *CE = dyn_cast<ConstantExpr>(
C)) {
1473 if (CE->getOpcode() == Instruction::IntToPtr) {
1476 DL.getIntPtrType(CE->getType()),
1478 }
else if (
auto *
GEP = dyn_cast<GEPOperator>(CE)) {
1482 unsigned BitWidth =
DL.getIndexTypeSizeInBits(
GEP->getType());
1484 auto *
Base = cast<Constant>(
GEP->stripAndAccumulateConstantOffsets(
1485 DL, BaseOffset,
true));
1486 if (
Base->isNullValue()) {
1487 FoldedValue = ConstantInt::get(CE->getContext(), BaseOffset);
1490 if (
GEP->getNumIndices() == 1 &&
1491 GEP->getSourceElementType()->isIntegerTy(8)) {
1492 auto *
Ptr = cast<Constant>(
GEP->getPointerOperand());
1493 auto *Sub = dyn_cast<ConstantExpr>(
GEP->getOperand(1));
1494 Type *IntIdxTy =
DL.getIndexType(
Ptr->getType());
1495 if (Sub && Sub->getType() == IntIdxTy &&
1496 Sub->getOpcode() == Instruction::Sub &&
1497 Sub->getOperand(0)->isNullValue())
1510 case Instruction::IntToPtr:
1515 if (
auto *CE = dyn_cast<ConstantExpr>(
C)) {
1516 if (CE->getOpcode() == Instruction::PtrToInt) {
1517 Constant *SrcPtr = CE->getOperand(0);
1518 unsigned SrcPtrSize =
DL.getPointerTypeSizeInBits(SrcPtr->
getType());
1519 unsigned MidIntSize = CE->getType()->getScalarSizeInBits();
1521 if (MidIntSize >= SrcPtrSize) {
1529 case Instruction::Trunc:
1530 case Instruction::ZExt:
1531 case Instruction::SExt:
1532 case Instruction::FPTrunc:
1533 case Instruction::FPExt:
1534 case Instruction::UIToFP:
1535 case Instruction::SIToFP:
1536 case Instruction::FPToUI:
1537 case Instruction::FPToSI:
1538 case Instruction::AddrSpaceCast:
1540 case Instruction::BitCast:
1551 Type *SrcTy =
C->getType();
1552 if (SrcTy == DestTy)
1566 if (Call->isNoBuiltin())
1568 if (Call->getFunctionType() !=
F->getFunctionType())
1570 switch (
F->getIntrinsicID()) {
1573 case Intrinsic::bswap:
1574 case Intrinsic::ctpop:
1575 case Intrinsic::ctlz:
1576 case Intrinsic::cttz:
1577 case Intrinsic::fshl:
1578 case Intrinsic::fshr:
1579 case Intrinsic::launder_invariant_group:
1580 case Intrinsic::strip_invariant_group:
1581 case Intrinsic::masked_load:
1582 case Intrinsic::get_active_lane_mask:
1583 case Intrinsic::abs:
1584 case Intrinsic::smax:
1585 case Intrinsic::smin:
1586 case Intrinsic::umax:
1587 case Intrinsic::umin:
1588 case Intrinsic::scmp:
1589 case Intrinsic::ucmp:
1590 case Intrinsic::sadd_with_overflow:
1591 case Intrinsic::uadd_with_overflow:
1592 case Intrinsic::ssub_with_overflow:
1593 case Intrinsic::usub_with_overflow:
1594 case Intrinsic::smul_with_overflow:
1595 case Intrinsic::umul_with_overflow:
1596 case Intrinsic::sadd_sat:
1597 case Intrinsic::uadd_sat:
1598 case Intrinsic::ssub_sat:
1599 case Intrinsic::usub_sat:
1600 case Intrinsic::smul_fix:
1601 case Intrinsic::smul_fix_sat:
1602 case Intrinsic::bitreverse:
1603 case Intrinsic::is_constant:
1604 case Intrinsic::vector_reduce_add:
1605 case Intrinsic::vector_reduce_mul:
1606 case Intrinsic::vector_reduce_and:
1607 case Intrinsic::vector_reduce_or:
1608 case Intrinsic::vector_reduce_xor:
1609 case Intrinsic::vector_reduce_smin:
1610 case Intrinsic::vector_reduce_smax:
1611 case Intrinsic::vector_reduce_umin:
1612 case Intrinsic::vector_reduce_umax:
1614 case Intrinsic::amdgcn_perm:
1615 case Intrinsic::amdgcn_wave_reduce_umin:
1616 case Intrinsic::amdgcn_wave_reduce_umax:
1617 case Intrinsic::amdgcn_s_wqm:
1618 case Intrinsic::amdgcn_s_quadmask:
1619 case Intrinsic::amdgcn_s_bitreplicate:
1620 case Intrinsic::arm_mve_vctp8:
1621 case Intrinsic::arm_mve_vctp16:
1622 case Intrinsic::arm_mve_vctp32:
1623 case Intrinsic::arm_mve_vctp64:
1624 case Intrinsic::aarch64_sve_convert_from_svbool:
1626 case Intrinsic::wasm_trunc_signed:
1627 case Intrinsic::wasm_trunc_unsigned:
1632 case Intrinsic::minnum:
1633 case Intrinsic::maxnum:
1634 case Intrinsic::minimum:
1635 case Intrinsic::maximum:
1636 case Intrinsic::log:
1637 case Intrinsic::log2:
1638 case Intrinsic::log10:
1639 case Intrinsic::exp:
1640 case Intrinsic::exp2:
1641 case Intrinsic::exp10:
1642 case Intrinsic::sqrt:
1643 case Intrinsic::sin:
1644 case Intrinsic::cos:
1645 case Intrinsic::sincos:
1646 case Intrinsic::pow:
1647 case Intrinsic::powi:
1648 case Intrinsic::ldexp:
1649 case Intrinsic::fma:
1650 case Intrinsic::fmuladd:
1651 case Intrinsic::frexp:
1652 case Intrinsic::fptoui_sat:
1653 case Intrinsic::fptosi_sat:
1654 case Intrinsic::convert_from_fp16:
1655 case Intrinsic::convert_to_fp16:
1656 case Intrinsic::amdgcn_cos:
1657 case Intrinsic::amdgcn_cubeid:
1658 case Intrinsic::amdgcn_cubema:
1659 case Intrinsic::amdgcn_cubesc:
1660 case Intrinsic::amdgcn_cubetc:
1661 case Intrinsic::amdgcn_fmul_legacy:
1662 case Intrinsic::amdgcn_fma_legacy:
1663 case Intrinsic::amdgcn_fract:
1664 case Intrinsic::amdgcn_sin:
1666 case Intrinsic::x86_sse_cvtss2si:
1667 case Intrinsic::x86_sse_cvtss2si64:
1668 case Intrinsic::x86_sse_cvttss2si:
1669 case Intrinsic::x86_sse_cvttss2si64:
1670 case Intrinsic::x86_sse2_cvtsd2si:
1671 case Intrinsic::x86_sse2_cvtsd2si64:
1672 case Intrinsic::x86_sse2_cvttsd2si:
1673 case Intrinsic::x86_sse2_cvttsd2si64:
1674 case Intrinsic::x86_avx512_vcvtss2si32:
1675 case Intrinsic::x86_avx512_vcvtss2si64:
1676 case Intrinsic::x86_avx512_cvttss2si:
1677 case Intrinsic::x86_avx512_cvttss2si64:
1678 case Intrinsic::x86_avx512_vcvtsd2si32:
1679 case Intrinsic::x86_avx512_vcvtsd2si64:
1680 case Intrinsic::x86_avx512_cvttsd2si:
1681 case Intrinsic::x86_avx512_cvttsd2si64:
1682 case Intrinsic::x86_avx512_vcvtss2usi32:
1683 case Intrinsic::x86_avx512_vcvtss2usi64:
1684 case Intrinsic::x86_avx512_cvttss2usi:
1685 case Intrinsic::x86_avx512_cvttss2usi64:
1686 case Intrinsic::x86_avx512_vcvtsd2usi32:
1687 case Intrinsic::x86_avx512_vcvtsd2usi64:
1688 case Intrinsic::x86_avx512_cvttsd2usi:
1689 case Intrinsic::x86_avx512_cvttsd2usi64:
1690 return !Call->isStrictFP();
1693 case Intrinsic::nvvm_fmax_d:
1694 case Intrinsic::nvvm_fmax_f:
1695 case Intrinsic::nvvm_fmax_ftz_f:
1696 case Intrinsic::nvvm_fmax_ftz_nan_f:
1697 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:
1698 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:
1699 case Intrinsic::nvvm_fmax_nan_f:
1700 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:
1701 case Intrinsic::nvvm_fmax_xorsign_abs_f:
1704 case Intrinsic::nvvm_fmin_d:
1705 case Intrinsic::nvvm_fmin_f:
1706 case Intrinsic::nvvm_fmin_ftz_f:
1707 case Intrinsic::nvvm_fmin_ftz_nan_f:
1708 case Intrinsic::nvvm_fmin_ftz_nan_xorsign_abs_f:
1709 case Intrinsic::nvvm_fmin_ftz_xorsign_abs_f:
1710 case Intrinsic::nvvm_fmin_nan_f:
1711 case Intrinsic::nvvm_fmin_nan_xorsign_abs_f:
1712 case Intrinsic::nvvm_fmin_xorsign_abs_f:
1715 case Intrinsic::nvvm_f2i_rm:
1716 case Intrinsic::nvvm_f2i_rn:
1717 case Intrinsic::nvvm_f2i_rp:
1718 case Intrinsic::nvvm_f2i_rz:
1719 case Intrinsic::nvvm_f2i_rm_ftz:
1720 case Intrinsic::nvvm_f2i_rn_ftz:
1721 case Intrinsic::nvvm_f2i_rp_ftz:
1722 case Intrinsic::nvvm_f2i_rz_ftz:
1723 case Intrinsic::nvvm_f2ui_rm:
1724 case Intrinsic::nvvm_f2ui_rn:
1725 case Intrinsic::nvvm_f2ui_rp:
1726 case Intrinsic::nvvm_f2ui_rz:
1727 case Intrinsic::nvvm_f2ui_rm_ftz:
1728 case Intrinsic::nvvm_f2ui_rn_ftz:
1729 case Intrinsic::nvvm_f2ui_rp_ftz:
1730 case Intrinsic::nvvm_f2ui_rz_ftz:
1731 case Intrinsic::nvvm_d2i_rm:
1732 case Intrinsic::nvvm_d2i_rn:
1733 case Intrinsic::nvvm_d2i_rp:
1734 case Intrinsic::nvvm_d2i_rz:
1735 case Intrinsic::nvvm_d2ui_rm:
1736 case Intrinsic::nvvm_d2ui_rn:
1737 case Intrinsic::nvvm_d2ui_rp:
1738 case Intrinsic::nvvm_d2ui_rz:
1741 case Intrinsic::nvvm_f2ll_rm:
1742 case Intrinsic::nvvm_f2ll_rn:
1743 case Intrinsic::nvvm_f2ll_rp:
1744 case Intrinsic::nvvm_f2ll_rz:
1745 case Intrinsic::nvvm_f2ll_rm_ftz:
1746 case Intrinsic::nvvm_f2ll_rn_ftz:
1747 case Intrinsic::nvvm_f2ll_rp_ftz:
1748 case Intrinsic::nvvm_f2ll_rz_ftz:
1749 case Intrinsic::nvvm_f2ull_rm:
1750 case Intrinsic::nvvm_f2ull_rn:
1751 case Intrinsic::nvvm_f2ull_rp:
1752 case Intrinsic::nvvm_f2ull_rz:
1753 case Intrinsic::nvvm_f2ull_rm_ftz:
1754 case Intrinsic::nvvm_f2ull_rn_ftz:
1755 case Intrinsic::nvvm_f2ull_rp_ftz:
1756 case Intrinsic::nvvm_f2ull_rz_ftz:
1757 case Intrinsic::nvvm_d2ll_rm:
1758 case Intrinsic::nvvm_d2ll_rn:
1759 case Intrinsic::nvvm_d2ll_rp:
1760 case Intrinsic::nvvm_d2ll_rz:
1761 case Intrinsic::nvvm_d2ull_rm:
1762 case Intrinsic::nvvm_d2ull_rn:
1763 case Intrinsic::nvvm_d2ull_rp:
1764 case Intrinsic::nvvm_d2ull_rz:
1768 case Intrinsic::fabs:
1769 case Intrinsic::copysign:
1770 case Intrinsic::is_fpclass:
1773 case Intrinsic::ceil:
1774 case Intrinsic::floor:
1775 case Intrinsic::round:
1776 case Intrinsic::roundeven:
1777 case Intrinsic::trunc:
1778 case Intrinsic::nearbyint:
1779 case Intrinsic::rint:
1780 case Intrinsic::canonicalize:
1783 case Intrinsic::experimental_constrained_fma:
1784 case Intrinsic::experimental_constrained_fmuladd:
1785 case Intrinsic::experimental_constrained_fadd:
1786 case Intrinsic::experimental_constrained_fsub:
1787 case Intrinsic::experimental_constrained_fmul:
1788 case Intrinsic::experimental_constrained_fdiv:
1789 case Intrinsic::experimental_constrained_frem:
1790 case Intrinsic::experimental_constrained_ceil:
1791 case Intrinsic::experimental_constrained_floor:
1792 case Intrinsic::experimental_constrained_round:
1793 case Intrinsic::experimental_constrained_roundeven:
1794 case Intrinsic::experimental_constrained_trunc:
1795 case Intrinsic::experimental_constrained_nearbyint:
1796 case Intrinsic::experimental_constrained_rint:
1797 case Intrinsic::experimental_constrained_fcmp:
1798 case Intrinsic::experimental_constrained_fcmps:
1805 if (!
F->hasName() || Call->isStrictFP())
1816 return Name ==
"acos" ||
Name ==
"acosf" ||
1817 Name ==
"asin" ||
Name ==
"asinf" ||
1818 Name ==
"atan" ||
Name ==
"atanf" ||
1819 Name ==
"atan2" ||
Name ==
"atan2f";
1821 return Name ==
"ceil" ||
Name ==
"ceilf" ||
1825 return Name ==
"exp" ||
Name ==
"expf" ||
Name ==
"exp2" ||
1828 return Name ==
"fabs" ||
Name ==
"fabsf" ||
1829 Name ==
"floor" ||
Name ==
"floorf" ||
1832 return Name ==
"ilogb" ||
Name ==
"ilogbf";
1834 return Name ==
"log" ||
Name ==
"logf" ||
Name ==
"logl" ||
1835 Name ==
"log2" ||
Name ==
"log2f" ||
Name ==
"log10" ||
1836 Name ==
"log10f" ||
Name ==
"logb" ||
Name ==
"logbf" ||
1837 Name ==
"log1p" ||
Name ==
"log1pf";
1839 return Name ==
"nearbyint" ||
Name ==
"nearbyintf";
1841 return Name ==
"pow" ||
Name ==
"powf";
1843 return Name ==
"remainder" ||
Name ==
"remainderf" ||
1844 Name ==
"rint" ||
Name ==
"rintf" ||
1845 Name ==
"round" ||
Name ==
"roundf";
1847 return Name ==
"sin" ||
Name ==
"sinf" ||
1848 Name ==
"sinh" ||
Name ==
"sinhf" ||
1851 return Name ==
"tan" ||
Name ==
"tanf" ||
1852 Name ==
"tanh" ||
Name ==
"tanhf" ||
1853 Name ==
"trunc" ||
Name ==
"truncf";
1861 if (
Name.size() < 12 ||
Name[1] !=
'_')
1867 return Name ==
"__acos_finite" ||
Name ==
"__acosf_finite" ||
1868 Name ==
"__asin_finite" ||
Name ==
"__asinf_finite" ||
1869 Name ==
"__atan2_finite" ||
Name ==
"__atan2f_finite";
1871 return Name ==
"__cosh_finite" ||
Name ==
"__coshf_finite";
1873 return Name ==
"__exp_finite" ||
Name ==
"__expf_finite" ||
1874 Name ==
"__exp2_finite" ||
Name ==
"__exp2f_finite";
1876 return Name ==
"__log_finite" ||
Name ==
"__logf_finite" ||
1877 Name ==
"__log10_finite" ||
Name ==
"__log10f_finite";
1879 return Name ==
"__pow_finite" ||
Name ==
"__powf_finite";
1881 return Name ==
"__sinh_finite" ||
Name ==
"__sinhf_finite";
1892 APF.convert(Ty->
getFltSemantics(), APFloat::rmNearestTiesToEven, &unused);
1893 return ConstantFP::get(Ty->
getContext(), APF);
1900#if defined(HAS_IEE754_FLOAT128) && defined(HAS_LOGF128)
1901Constant *GetConstantFoldFPValue128(float128 V,
Type *Ty) {
1903 return ConstantFP::get(Ty, V);
1909inline void llvm_fenv_clearexcept() {
1910#if HAVE_DECL_FE_ALL_EXCEPT
1911 feclearexcept(FE_ALL_EXCEPT);
1917inline bool llvm_fenv_testexcept() {
1918 int errno_val = errno;
1919 if (errno_val == ERANGE || errno_val == EDOM)
1921#if HAVE_DECL_FE_ALL_EXCEPT && HAVE_DECL_FE_INEXACT
1922 if (fetestexcept(FE_ALL_EXCEPT & ~FE_INEXACT))
1936 llvm_fenv_clearexcept();
1937 double Result = NativeFP(
V.convertToDouble());
1938 if (llvm_fenv_testexcept()) {
1939 llvm_fenv_clearexcept();
1943 return GetConstantFoldFPValue(Result, Ty);
1946#if defined(HAS_IEE754_FLOAT128) && defined(HAS_LOGF128)
1947Constant *ConstantFoldFP128(float128 (*NativeFP)(float128),
const APFloat &V,
1949 llvm_fenv_clearexcept();
1950 float128
Result = NativeFP(
V.convertToQuad());
1951 if (llvm_fenv_testexcept()) {
1952 llvm_fenv_clearexcept();
1956 return GetConstantFoldFPValue128(Result, Ty);
1960Constant *ConstantFoldBinaryFP(
double (*NativeFP)(
double,
double),
1962 llvm_fenv_clearexcept();
1963 double Result = NativeFP(
V.convertToDouble(),
W.convertToDouble());
1964 if (llvm_fenv_testexcept()) {
1965 llvm_fenv_clearexcept();
1969 return GetConstantFoldFPValue(Result, Ty);
1979 if (isa<ConstantAggregateZero>(
Op))
1983 if (isa<PoisonValue>(
Op) ||
Op->containsPoisonElement())
1987 if (!isa<ConstantVector>(
Op) && !isa<ConstantDataVector>(
Op))
1990 auto *EltC = dyn_cast<ConstantInt>(
Op->getAggregateElement(0U));
1994 APInt Acc = EltC->getValue();
1996 if (!(EltC = dyn_cast<ConstantInt>(
Op->getAggregateElement(
I))))
1998 const APInt &
X = EltC->getValue();
2000 case Intrinsic::vector_reduce_add:
2003 case Intrinsic::vector_reduce_mul:
2006 case Intrinsic::vector_reduce_and:
2009 case Intrinsic::vector_reduce_or:
2012 case Intrinsic::vector_reduce_xor:
2015 case Intrinsic::vector_reduce_smin:
2018 case Intrinsic::vector_reduce_smax:
2021 case Intrinsic::vector_reduce_umin:
2024 case Intrinsic::vector_reduce_umax:
2030 return ConstantInt::get(
Op->getContext(), Acc);
2040Constant *ConstantFoldSSEConvertToInt(
const APFloat &Val,
bool roundTowardZero,
2041 Type *Ty,
bool IsSigned) {
2044 assert(ResultWidth <= 64 &&
2045 "Can only constant fold conversions to 64 and 32 bit ints");
2048 bool isExact =
false;
2050 : APFloat::rmNearestTiesToEven;
2053 IsSigned,
mode, &isExact);
2054 if (status != APFloat::opOK &&
2055 (!roundTowardZero || status != APFloat::opInexact))
2057 return ConstantInt::get(Ty, UIntVal, IsSigned);
2061 Type *Ty =
Op->getType();
2064 return Op->getValueAPF().convertToDouble();
2068 APF.
convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &unused);
2073 if (
auto *CI = dyn_cast<ConstantInt>(
Op)) {
2074 C = &CI->getValue();
2077 if (isa<UndefValue>(
Op)) {
2096 if (St == APFloat::opStatus::opOK)
2101 if (ORM && *ORM == RoundingMode::Dynamic)
2106 if (EB && *EB != fp::ExceptionBehavior::ebStrict)
2118 if (!ORM || *ORM == RoundingMode::Dynamic)
2123 return RoundingMode::NearestTiesToEven;
2133 return ConstantFP::get(
2145 if (Src.isNormal() || Src.isInfinity())
2146 return ConstantFP::get(CI->
getContext(), Src);
2153 return ConstantFP::get(CI->
getContext(), Src);
2185 if (IntrinsicID == Intrinsic::is_constant) {
2189 if (
Operands[0]->isManifestConstant())
2194 if (isa<PoisonValue>(
Operands[0])) {
2196 if (IntrinsicID == Intrinsic::canonicalize)
2200 if (isa<UndefValue>(
Operands[0])) {
2204 if (IntrinsicID == Intrinsic::cos ||
2205 IntrinsicID == Intrinsic::ctpop ||
2206 IntrinsicID == Intrinsic::fptoui_sat ||
2207 IntrinsicID == Intrinsic::fptosi_sat ||
2208 IntrinsicID == Intrinsic::canonicalize)
2210 if (IntrinsicID == Intrinsic::bswap ||
2211 IntrinsicID == Intrinsic::bitreverse ||
2212 IntrinsicID == Intrinsic::launder_invariant_group ||
2213 IntrinsicID == Intrinsic::strip_invariant_group)
2217 if (isa<ConstantPointerNull>(
Operands[0])) {
2219 if (IntrinsicID == Intrinsic::launder_invariant_group ||
2220 IntrinsicID == Intrinsic::strip_invariant_group) {
2225 Call->getParent() ?
Call->getCaller() :
nullptr;
2235 if (
auto *
Op = dyn_cast<ConstantFP>(
Operands[0])) {
2236 if (IntrinsicID == Intrinsic::convert_to_fp16) {
2240 Val.
convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &lost);
2247 if (IntrinsicID == Intrinsic::wasm_trunc_signed ||
2248 IntrinsicID == Intrinsic::wasm_trunc_unsigned) {
2249 bool Signed = IntrinsicID == Intrinsic::wasm_trunc_signed;
2256 bool IsExact =
false;
2258 U.convertToInteger(
Int, APFloat::rmTowardZero, &IsExact);
2260 if (
Status == APFloat::opOK ||
Status == APFloat::opInexact)
2261 return ConstantInt::get(Ty,
Int);
2266 if (IntrinsicID == Intrinsic::fptoui_sat ||
2267 IntrinsicID == Intrinsic::fptosi_sat) {
2270 IntrinsicID == Intrinsic::fptoui_sat);
2272 U.convertToInteger(
Int, APFloat::rmTowardZero, &IsExact);
2273 return ConstantInt::get(Ty,
Int);
2276 if (IntrinsicID == Intrinsic::canonicalize)
2277 return constantFoldCanonicalize(Ty, Call, U);
2279#if defined(HAS_IEE754_FLOAT128) && defined(HAS_LOGF128)
2281 if (IntrinsicID == Intrinsic::log) {
2282 float128
Result = logf128(
Op->getValueAPF().convertToQuad());
2283 return GetConstantFoldFPValue128(Result, Ty);
2288 Fp128Func == LibFunc_logl)
2289 return ConstantFoldFP128(logf128,
Op->getValueAPF(), Ty);
2299 if (IntrinsicID == Intrinsic::nearbyint || IntrinsicID == Intrinsic::rint) {
2300 U.roundToIntegral(APFloat::rmNearestTiesToEven);
2304 if (IntrinsicID == Intrinsic::round) {
2305 U.roundToIntegral(APFloat::rmNearestTiesToAway);
2309 if (IntrinsicID == Intrinsic::roundeven) {
2310 U.roundToIntegral(APFloat::rmNearestTiesToEven);
2314 if (IntrinsicID == Intrinsic::ceil) {
2315 U.roundToIntegral(APFloat::rmTowardPositive);
2319 if (IntrinsicID == Intrinsic::floor) {
2320 U.roundToIntegral(APFloat::rmTowardNegative);
2324 if (IntrinsicID == Intrinsic::trunc) {
2325 U.roundToIntegral(APFloat::rmTowardZero);
2329 if (IntrinsicID == Intrinsic::fabs) {
2334 if (IntrinsicID == Intrinsic::amdgcn_fract) {
2340 FloorU.roundToIntegral(APFloat::rmTowardNegative);
2342 APFloat AlmostOne(
U.getSemantics(), 1);
2343 AlmostOne.next(
true);
2350 std::optional<APFloat::roundingMode>
RM;
2351 switch (IntrinsicID) {
2354 case Intrinsic::experimental_constrained_nearbyint:
2355 case Intrinsic::experimental_constrained_rint: {
2356 auto CI = cast<ConstrainedFPIntrinsic>(Call);
2357 RM = CI->getRoundingMode();
2358 if (!RM || *RM == RoundingMode::Dynamic)
2362 case Intrinsic::experimental_constrained_round:
2363 RM = APFloat::rmNearestTiesToAway;
2365 case Intrinsic::experimental_constrained_ceil:
2366 RM = APFloat::rmTowardPositive;
2368 case Intrinsic::experimental_constrained_floor:
2369 RM = APFloat::rmTowardNegative;
2371 case Intrinsic::experimental_constrained_trunc:
2372 RM = APFloat::rmTowardZero;
2376 auto CI = cast<ConstrainedFPIntrinsic>(Call);
2379 if (IntrinsicID == Intrinsic::experimental_constrained_rint &&
2380 St == APFloat::opInexact) {
2381 std::optional<fp::ExceptionBehavior> EB = CI->getExceptionBehavior();
2385 }
else if (
U.isSignaling()) {
2386 std::optional<fp::ExceptionBehavior> EB = CI->getExceptionBehavior();
2395 switch (IntrinsicID) {
2397 case Intrinsic::nvvm_f2i_rm:
2398 case Intrinsic::nvvm_f2i_rn:
2399 case Intrinsic::nvvm_f2i_rp:
2400 case Intrinsic::nvvm_f2i_rz:
2401 case Intrinsic::nvvm_f2i_rm_ftz:
2402 case Intrinsic::nvvm_f2i_rn_ftz:
2403 case Intrinsic::nvvm_f2i_rp_ftz:
2404 case Intrinsic::nvvm_f2i_rz_ftz:
2406 case Intrinsic::nvvm_f2ui_rm:
2407 case Intrinsic::nvvm_f2ui_rn:
2408 case Intrinsic::nvvm_f2ui_rp:
2409 case Intrinsic::nvvm_f2ui_rz:
2410 case Intrinsic::nvvm_f2ui_rm_ftz:
2411 case Intrinsic::nvvm_f2ui_rn_ftz:
2412 case Intrinsic::nvvm_f2ui_rp_ftz:
2413 case Intrinsic::nvvm_f2ui_rz_ftz:
2415 case Intrinsic::nvvm_d2i_rm:
2416 case Intrinsic::nvvm_d2i_rn:
2417 case Intrinsic::nvvm_d2i_rp:
2418 case Intrinsic::nvvm_d2i_rz:
2420 case Intrinsic::nvvm_d2ui_rm:
2421 case Intrinsic::nvvm_d2ui_rn:
2422 case Intrinsic::nvvm_d2ui_rp:
2423 case Intrinsic::nvvm_d2ui_rz:
2425 case Intrinsic::nvvm_f2ll_rm:
2426 case Intrinsic::nvvm_f2ll_rn:
2427 case Intrinsic::nvvm_f2ll_rp:
2428 case Intrinsic::nvvm_f2ll_rz:
2429 case Intrinsic::nvvm_f2ll_rm_ftz:
2430 case Intrinsic::nvvm_f2ll_rn_ftz:
2431 case Intrinsic::nvvm_f2ll_rp_ftz:
2432 case Intrinsic::nvvm_f2ll_rz_ftz:
2434 case Intrinsic::nvvm_f2ull_rm:
2435 case Intrinsic::nvvm_f2ull_rn:
2436 case Intrinsic::nvvm_f2ull_rp:
2437 case Intrinsic::nvvm_f2ull_rz:
2438 case Intrinsic::nvvm_f2ull_rm_ftz:
2439 case Intrinsic::nvvm_f2ull_rn_ftz:
2440 case Intrinsic::nvvm_f2ull_rp_ftz:
2441 case Intrinsic::nvvm_f2ull_rz_ftz:
2443 case Intrinsic::nvvm_d2ll_rm:
2444 case Intrinsic::nvvm_d2ll_rn:
2445 case Intrinsic::nvvm_d2ll_rp:
2446 case Intrinsic::nvvm_d2ll_rz:
2448 case Intrinsic::nvvm_d2ull_rm:
2449 case Intrinsic::nvvm_d2ull_rn:
2450 case Intrinsic::nvvm_d2ull_rp:
2451 case Intrinsic::nvvm_d2ull_rz: {
2454 return ConstantInt::get(Ty, 0);
2462 auto FloatToRound = IsFTZ ? FTZPreserveSign(U) :
U;
2464 bool IsExact =
false;
2466 FloatToRound.convertToInteger(ResInt, RMode, &IsExact);
2468 if (
Status != APFloat::opInvalidOp)
2469 return ConstantInt::get(Ty, ResInt);
2486 switch (IntrinsicID) {
2488 case Intrinsic::log:
2489 return ConstantFoldFP(log, APF, Ty);
2490 case Intrinsic::log2:
2492 return ConstantFoldFP(
log2, APF, Ty);
2493 case Intrinsic::log10:
2495 return ConstantFoldFP(log10, APF, Ty);
2496 case Intrinsic::exp:
2497 return ConstantFoldFP(exp, APF, Ty);
2498 case Intrinsic::exp2:
2500 return ConstantFoldBinaryFP(pow,
APFloat(2.0), APF, Ty);
2501 case Intrinsic::exp10:
2503 return ConstantFoldBinaryFP(pow,
APFloat(10.0), APF, Ty);
2504 case Intrinsic::sin:
2505 return ConstantFoldFP(sin, APF, Ty);
2506 case Intrinsic::cos:
2507 return ConstantFoldFP(cos, APF, Ty);
2508 case Intrinsic::sqrt:
2509 return ConstantFoldFP(sqrt, APF, Ty);
2510 case Intrinsic::amdgcn_cos:
2511 case Intrinsic::amdgcn_sin: {
2512 double V = getValueAsDouble(
Op);
2513 if (V < -256.0 || V > 256.0)
2518 bool IsCos = IntrinsicID == Intrinsic::amdgcn_cos;
2519 double V4 =
V * 4.0;
2520 if (V4 == floor(V4)) {
2522 const double SinVals[4] = { 0.0, 1.0, 0.0, -1.0 };
2523 V = SinVals[((int)V4 + (IsCos ? 1 : 0)) & 3];
2530 return GetConstantFoldFPValue(V, Ty);
2546 case LibFunc_acos_finite:
2547 case LibFunc_acosf_finite:
2549 return ConstantFoldFP(acos, APF, Ty);
2553 case LibFunc_asin_finite:
2554 case LibFunc_asinf_finite:
2556 return ConstantFoldFP(asin, APF, Ty);
2561 return ConstantFoldFP(atan, APF, Ty);
2565 if (TLI->
has(Func)) {
2566 U.roundToIntegral(APFloat::rmTowardPositive);
2573 return ConstantFoldFP(cos, APF, Ty);
2577 case LibFunc_cosh_finite:
2578 case LibFunc_coshf_finite:
2580 return ConstantFoldFP(cosh, APF, Ty);
2584 case LibFunc_exp_finite:
2585 case LibFunc_expf_finite:
2587 return ConstantFoldFP(exp, APF, Ty);
2591 case LibFunc_exp2_finite:
2592 case LibFunc_exp2f_finite:
2595 return ConstantFoldBinaryFP(pow,
APFloat(2.0), APF, Ty);
2599 if (TLI->
has(Func)) {
2605 case LibFunc_floorf:
2606 if (TLI->
has(Func)) {
2607 U.roundToIntegral(APFloat::rmTowardNegative);
2613 case LibFunc_log_finite:
2614 case LibFunc_logf_finite:
2616 return ConstantFoldFP(log, APF, Ty);
2620 case LibFunc_log2_finite:
2621 case LibFunc_log2f_finite:
2624 return ConstantFoldFP(
log2, APF, Ty);
2627 case LibFunc_log10f:
2628 case LibFunc_log10_finite:
2629 case LibFunc_log10f_finite:
2632 return ConstantFoldFP(log10, APF, Ty);
2635 case LibFunc_ilogbf:
2637 return ConstantInt::get(Ty,
ilogb(APF),
true);
2642 return ConstantFoldFP(logb, APF, Ty);
2645 case LibFunc_log1pf:
2650 return ConstantFoldFP(log1p, APF, Ty);
2657 return ConstantFoldFP(erf, APF, Ty);
2659 case LibFunc_nearbyint:
2660 case LibFunc_nearbyintf:
2663 if (TLI->
has(Func)) {
2664 U.roundToIntegral(APFloat::rmNearestTiesToEven);
2669 case LibFunc_roundf:
2670 if (TLI->
has(Func)) {
2671 U.roundToIntegral(APFloat::rmNearestTiesToAway);
2678 return ConstantFoldFP(sin, APF, Ty);
2682 case LibFunc_sinh_finite:
2683 case LibFunc_sinhf_finite:
2685 return ConstantFoldFP(sinh, APF, Ty);
2690 return ConstantFoldFP(sqrt, APF, Ty);
2695 return ConstantFoldFP(tan, APF, Ty);
2700 return ConstantFoldFP(tanh, APF, Ty);
2703 case LibFunc_truncf:
2704 if (TLI->
has(Func)) {
2705 U.roundToIntegral(APFloat::rmTowardZero);
2713 if (
auto *
Op = dyn_cast<ConstantInt>(
Operands[0])) {
2714 switch (IntrinsicID) {
2715 case Intrinsic::bswap:
2716 return ConstantInt::get(Ty->
getContext(),
Op->getValue().byteSwap());
2717 case Intrinsic::ctpop:
2718 return ConstantInt::get(Ty,
Op->getValue().popcount());
2719 case Intrinsic::bitreverse:
2720 return ConstantInt::get(Ty->
getContext(),
Op->getValue().reverseBits());
2721 case Intrinsic::convert_from_fp16: {
2722 APFloat Val(APFloat::IEEEhalf(),
Op->getValue());
2730 assert(status != APFloat::opInexact && !lost &&
2731 "Precision lost during fp16 constfolding");
2733 return ConstantFP::get(Ty->
getContext(), Val);
2736 case Intrinsic::amdgcn_s_wqm: {
2738 Val |= (Val & 0x5555555555555555ULL) << 1 |
2739 ((Val >> 1) & 0x5555555555555555ULL);
2740 Val |= (Val & 0x3333333333333333ULL) << 2 |
2741 ((Val >> 2) & 0x3333333333333333ULL);
2742 return ConstantInt::get(Ty, Val);
2745 case Intrinsic::amdgcn_s_quadmask: {
2748 for (
unsigned I = 0;
I <
Op->getBitWidth() / 4; ++
I, Val >>= 4) {
2752 QuadMask |= (1ULL <<
I);
2754 return ConstantInt::get(Ty, QuadMask);
2757 case Intrinsic::amdgcn_s_bitreplicate: {
2759 Val = (Val & 0x000000000000FFFFULL) | (Val & 0x00000000FFFF0000ULL) << 16;
2760 Val = (Val & 0x000000FF000000FFULL) | (Val & 0x0000FF000000FF00ULL) << 8;
2761 Val = (Val & 0x000F000F000F000FULL) | (Val & 0x00F000F000F000F0ULL) << 4;
2762 Val = (Val & 0x0303030303030303ULL) | (Val & 0x0C0C0C0C0C0C0C0CULL) << 2;
2763 Val = (Val & 0x1111111111111111ULL) | (Val & 0x2222222222222222ULL) << 1;
2764 Val = Val | Val << 1;
2765 return ConstantInt::get(Ty, Val);
2773 switch (IntrinsicID) {
2775 case Intrinsic::vector_reduce_add:
2776 case Intrinsic::vector_reduce_mul:
2777 case Intrinsic::vector_reduce_and:
2778 case Intrinsic::vector_reduce_or:
2779 case Intrinsic::vector_reduce_xor:
2780 case Intrinsic::vector_reduce_smin:
2781 case Intrinsic::vector_reduce_smax:
2782 case Intrinsic::vector_reduce_umin:
2783 case Intrinsic::vector_reduce_umax:
2790 if (isa<ConstantVector>(
Operands[0]) ||
2791 isa<ConstantDataVector>(
Operands[0])) {
2793 switch (IntrinsicID) {
2795 case Intrinsic::x86_sse_cvtss2si:
2796 case Intrinsic::x86_sse_cvtss2si64:
2797 case Intrinsic::x86_sse2_cvtsd2si:
2798 case Intrinsic::x86_sse2_cvtsd2si64:
2800 dyn_cast_or_null<ConstantFP>(
Op->getAggregateElement(0U)))
2801 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
2805 case Intrinsic::x86_sse_cvttss2si:
2806 case Intrinsic::x86_sse_cvttss2si64:
2807 case Intrinsic::x86_sse2_cvttsd2si:
2808 case Intrinsic::x86_sse2_cvttsd2si64:
2810 dyn_cast_or_null<ConstantFP>(
Op->getAggregateElement(0U)))
2811 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
2824 auto *FCmp = cast<ConstrainedFPCmpIntrinsic>(Call);
2826 if (FCmp->isSignaling()) {
2828 St = APFloat::opInvalidOp;
2831 St = APFloat::opInvalidOp;
2835 return ConstantInt::get(
Call->getType()->getScalarType(), Result);
2849 const auto *Op1 = dyn_cast<ConstantFP>(
Operands[0]);
2853 const auto *Op2 = dyn_cast<ConstantFP>(
Operands[1]);
2857 const APFloat &Op1V = Op1->getValueAPF();
2858 const APFloat &Op2V = Op2->getValueAPF();
2865 case LibFunc_pow_finite:
2866 case LibFunc_powf_finite:
2868 return ConstantFoldBinaryFP(pow, Op1V, Op2V, Ty);
2872 if (TLI->
has(Func)) {
2874 if (APFloat::opStatus::opOK ==
V.mod(Op2->getValueAPF()))
2878 case LibFunc_remainder:
2879 case LibFunc_remainderf:
2880 if (TLI->
has(Func)) {
2882 if (APFloat::opStatus::opOK ==
V.remainder(Op2->getValueAPF()))
2887 case LibFunc_atan2f:
2893 case LibFunc_atan2_finite:
2894 case LibFunc_atan2f_finite:
2896 return ConstantFoldBinaryFP(atan2, Op1V, Op2V, Ty);
2911 bool IsOp0Undef = isa<UndefValue>(
Operands[0]);
2912 bool IsOp1Undef = isa<UndefValue>(
Operands[1]);
2913 switch (IntrinsicID) {
2914 case Intrinsic::maxnum:
2915 case Intrinsic::minnum:
2916 case Intrinsic::maximum:
2917 case Intrinsic::minimum:
2918 case Intrinsic::nvvm_fmax_d:
2919 case Intrinsic::nvvm_fmin_d:
2927 case Intrinsic::nvvm_fmax_f:
2928 case Intrinsic::nvvm_fmax_ftz_f:
2929 case Intrinsic::nvvm_fmax_ftz_nan_f:
2930 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:
2931 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:
2932 case Intrinsic::nvvm_fmax_nan_f:
2933 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:
2934 case Intrinsic::nvvm_fmax_xorsign_abs_f:
2936 case Intrinsic::nvvm_fmin_f:
2937 case Intrinsic::nvvm_fmin_ftz_f:
2938 case Intrinsic::nvvm_fmin_ftz_nan_f:
2939 case Intrinsic::nvvm_fmin_ftz_nan_xorsign_abs_f:
2940 case Intrinsic::nvvm_fmin_ftz_xorsign_abs_f:
2941 case Intrinsic::nvvm_fmin_nan_f:
2942 case Intrinsic::nvvm_fmin_nan_xorsign_abs_f:
2943 case Intrinsic::nvvm_fmin_xorsign_abs_f:
2947 if (!IsOp0Undef && !IsOp1Undef)
2949 if (
auto *
Op = dyn_cast<ConstantFP>(
Operands[IsOp0Undef ? 1 : 0])) {
2951 APInt NVCanonicalNaN(32, 0x7fffffff);
2952 return ConstantFP::get(
2956 return ConstantFP::get(Ty, FTZPreserveSign(
Op->getValueAPF()));
2964 if (
const auto *Op1 = dyn_cast<ConstantFP>(
Operands[0])) {
2965 const APFloat &Op1V = Op1->getValueAPF();
2967 if (
const auto *Op2 = dyn_cast<ConstantFP>(
Operands[1])) {
2968 if (Op2->getType() != Op1->getType())
2970 const APFloat &Op2V = Op2->getValueAPF();
2972 if (
const auto *ConstrIntr =
2973 dyn_cast_if_present<ConstrainedFPIntrinsic>(Call)) {
2977 switch (IntrinsicID) {
2980 case Intrinsic::experimental_constrained_fadd:
2981 St = Res.
add(Op2V, RM);
2983 case Intrinsic::experimental_constrained_fsub:
2986 case Intrinsic::experimental_constrained_fmul:
2989 case Intrinsic::experimental_constrained_fdiv:
2990 St = Res.
divide(Op2V, RM);
2992 case Intrinsic::experimental_constrained_frem:
2995 case Intrinsic::experimental_constrained_fcmp:
2996 case Intrinsic::experimental_constrained_fcmps:
2997 return evaluateCompare(Op1V, Op2V, ConstrIntr);
3001 return ConstantFP::get(Ty->
getContext(), Res);
3005 switch (IntrinsicID) {
3008 case Intrinsic::copysign:
3010 case Intrinsic::minnum:
3012 case Intrinsic::maxnum:
3014 case Intrinsic::minimum:
3016 case Intrinsic::maximum:
3019 case Intrinsic::nvvm_fmax_d:
3020 case Intrinsic::nvvm_fmax_f:
3021 case Intrinsic::nvvm_fmax_ftz_f:
3022 case Intrinsic::nvvm_fmax_ftz_nan_f:
3023 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:
3024 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:
3025 case Intrinsic::nvvm_fmax_nan_f:
3026 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:
3027 case Intrinsic::nvvm_fmax_xorsign_abs_f:
3029 case Intrinsic::nvvm_fmin_d:
3030 case Intrinsic::nvvm_fmin_f:
3031 case Intrinsic::nvvm_fmin_ftz_f:
3032 case Intrinsic::nvvm_fmin_ftz_nan_f:
3033 case Intrinsic::nvvm_fmin_ftz_nan_xorsign_abs_f:
3034 case Intrinsic::nvvm_fmin_ftz_xorsign_abs_f:
3035 case Intrinsic::nvvm_fmin_nan_f:
3036 case Intrinsic::nvvm_fmin_nan_xorsign_abs_f:
3037 case Intrinsic::nvvm_fmin_xorsign_abs_f: {
3039 bool ShouldCanonicalizeNaNs = !(IntrinsicID == Intrinsic::nvvm_fmax_d ||
3040 IntrinsicID == Intrinsic::nvvm_fmin_d);
3045 APFloat A = IsFTZ ? FTZPreserveSign(Op1V) : Op1V;
3046 APFloat B = IsFTZ ? FTZPreserveSign(Op2V) : Op2V;
3048 bool XorSign =
false;
3050 XorSign =
A.isNegative() ^
B.isNegative();
3055 bool IsFMax =
false;
3056 switch (IntrinsicID) {
3057 case Intrinsic::nvvm_fmax_d:
3058 case Intrinsic::nvvm_fmax_f:
3059 case Intrinsic::nvvm_fmax_ftz_f:
3060 case Intrinsic::nvvm_fmax_ftz_nan_f:
3061 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:
3062 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:
3063 case Intrinsic::nvvm_fmax_nan_f:
3064 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:
3065 case Intrinsic::nvvm_fmax_xorsign_abs_f:
3071 if (ShouldCanonicalizeNaNs) {
3073 if (
A.isNaN() &&
B.isNaN())
3074 return ConstantFP::get(Ty, NVCanonicalNaN);
3075 else if (IsNaNPropagating && (
A.isNaN() ||
B.isNaN()))
3076 return ConstantFP::get(Ty, NVCanonicalNaN);
3079 if (
A.isNaN() &&
B.isNaN())
3086 if (IsXorSignAbs && XorSign != Res.
isNegative())
3089 return ConstantFP::get(Ty->
getContext(), Res);
3096 switch (IntrinsicID) {
3099 case Intrinsic::pow:
3100 return ConstantFoldBinaryFP(pow, Op1V, Op2V, Ty);
3101 case Intrinsic::amdgcn_fmul_legacy:
3106 return ConstantFP::get(Ty->
getContext(), Op1V * Op2V);
3109 }
else if (
auto *Op2C = dyn_cast<ConstantInt>(
Operands[1])) {
3110 switch (IntrinsicID) {
3111 case Intrinsic::ldexp: {
3112 return ConstantFP::get(
3114 scalbn(Op1V, Op2C->getSExtValue(), APFloat::rmNearestTiesToEven));
3116 case Intrinsic::is_fpclass: {
3129 return ConstantInt::get(Ty, Result);
3131 case Intrinsic::powi: {
3132 int Exp =
static_cast<int>(Op2C->getSExtValue());
3139 Res.
convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
3142 return ConstantFP::get(Ty->
getContext(), Res);
3159 const APInt *C0, *C1;
3160 if (!getConstIntOrUndef(
Operands[0], C0) ||
3161 !getConstIntOrUndef(
Operands[1], C1))
3164 switch (IntrinsicID) {
3166 case Intrinsic::smax:
3167 case Intrinsic::smin:
3168 case Intrinsic::umax:
3169 case Intrinsic::umin:
3179 return ConstantInt::get(
3185 case Intrinsic::scmp:
3186 case Intrinsic::ucmp:
3191 return ConstantInt::get(Ty, 0);
3194 if (IntrinsicID == Intrinsic::scmp)
3195 Res = C0->
sgt(*C1) ? 1 : C0->
slt(*C1) ? -1 : 0;
3197 Res = C0->
ugt(*C1) ? 1 : C0->
ult(*C1) ? -1 : 0;
3198 return ConstantInt::get(Ty, Res,
true);
3200 case Intrinsic::usub_with_overflow:
3201 case Intrinsic::ssub_with_overflow:
3207 case Intrinsic::uadd_with_overflow:
3208 case Intrinsic::sadd_with_overflow:
3213 cast<StructType>(Ty),
3218 case Intrinsic::smul_with_overflow:
3219 case Intrinsic::umul_with_overflow: {
3227 switch (IntrinsicID) {
3229 case Intrinsic::sadd_with_overflow:
3230 Res = C0->
sadd_ov(*C1, Overflow);
3232 case Intrinsic::uadd_with_overflow:
3233 Res = C0->
uadd_ov(*C1, Overflow);
3235 case Intrinsic::ssub_with_overflow:
3236 Res = C0->
ssub_ov(*C1, Overflow);
3238 case Intrinsic::usub_with_overflow:
3239 Res = C0->
usub_ov(*C1, Overflow);
3241 case Intrinsic::smul_with_overflow:
3242 Res = C0->
smul_ov(*C1, Overflow);
3244 case Intrinsic::umul_with_overflow:
3245 Res = C0->
umul_ov(*C1, Overflow);
3254 case Intrinsic::uadd_sat:
3255 case Intrinsic::sadd_sat:
3265 if (IntrinsicID == Intrinsic::uadd_sat)
3266 return ConstantInt::get(Ty, C0->
uadd_sat(*C1));
3268 return ConstantInt::get(Ty, C0->
sadd_sat(*C1));
3269 case Intrinsic::usub_sat:
3270 case Intrinsic::ssub_sat:
3280 if (IntrinsicID == Intrinsic::usub_sat)
3281 return ConstantInt::get(Ty, C0->
usub_sat(*C1));
3283 return ConstantInt::get(Ty, C0->
ssub_sat(*C1));
3284 case Intrinsic::cttz:
3285 case Intrinsic::ctlz:
3286 assert(C1 &&
"Must be constant int");
3293 if (IntrinsicID == Intrinsic::cttz)
3298 case Intrinsic::abs:
3299 assert(C1 &&
"Must be constant int");
3310 return ConstantInt::get(Ty, C0->
abs());
3311 case Intrinsic::amdgcn_wave_reduce_umin:
3312 case Intrinsic::amdgcn_wave_reduce_umax:
3313 return dyn_cast<Constant>(
Operands[0]);
3320 if ((isa<ConstantVector>(
Operands[0]) ||
3321 isa<ConstantDataVector>(
Operands[0])) &&
3325 cast<ConstantInt>(
Operands[1])->getValue() == 4) {
3327 switch (IntrinsicID) {
3329 case Intrinsic::x86_avx512_vcvtss2si32:
3330 case Intrinsic::x86_avx512_vcvtss2si64:
3331 case Intrinsic::x86_avx512_vcvtsd2si32:
3332 case Intrinsic::x86_avx512_vcvtsd2si64:
3334 dyn_cast_or_null<ConstantFP>(
Op->getAggregateElement(0U)))
3335 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
3339 case Intrinsic::x86_avx512_vcvtss2usi32:
3340 case Intrinsic::x86_avx512_vcvtss2usi64:
3341 case Intrinsic::x86_avx512_vcvtsd2usi32:
3342 case Intrinsic::x86_avx512_vcvtsd2usi64:
3344 dyn_cast_or_null<ConstantFP>(
Op->getAggregateElement(0U)))
3345 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
3349 case Intrinsic::x86_avx512_cvttss2si:
3350 case Intrinsic::x86_avx512_cvttss2si64:
3351 case Intrinsic::x86_avx512_cvttsd2si:
3352 case Intrinsic::x86_avx512_cvttsd2si64:
3354 dyn_cast_or_null<ConstantFP>(
Op->getAggregateElement(0U)))
3355 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
3359 case Intrinsic::x86_avx512_cvttss2usi:
3360 case Intrinsic::x86_avx512_cvttss2usi64:
3361 case Intrinsic::x86_avx512_cvttsd2usi:
3362 case Intrinsic::x86_avx512_cvttsd2usi64:
3364 dyn_cast_or_null<ConstantFP>(
Op->getAggregateElement(0U)))
3365 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
3393 if (
S1.isNegative() &&
S1.isNonZero() && !
S1.isNaN()) {
3415 switch (IntrinsicID) {
3418 case Intrinsic::amdgcn_cubeid:
3420 case Intrinsic::amdgcn_cubema:
3422 case Intrinsic::amdgcn_cubesc:
3424 case Intrinsic::amdgcn_cubetc:
3431 const APInt *C0, *C1, *C2;
3432 if (!getConstIntOrUndef(
Operands[0], C0) ||
3433 !getConstIntOrUndef(
Operands[1], C1) ||
3434 !getConstIntOrUndef(
Operands[2], C2))
3441 unsigned NumUndefBytes = 0;
3442 for (
unsigned I = 0;
I < 32;
I += 8) {
3451 const APInt *Src = ((Sel & 10) == 10 || (Sel & 12) == 4) ? C0 : C1;
3455 B = Src->extractBitsAsZExtValue(8, (Sel & 3) * 8);
3457 B = Src->extractBitsAsZExtValue(1, (Sel & 1) ? 31 : 15) * 0xff;
3460 Val.insertBits(
B,
I, 8);
3463 if (NumUndefBytes == 4)
3466 return ConstantInt::get(Ty, Val);
3477 if (
const auto *Op1 = dyn_cast<ConstantFP>(
Operands[0])) {
3478 if (
const auto *Op2 = dyn_cast<ConstantFP>(
Operands[1])) {
3479 if (
const auto *Op3 = dyn_cast<ConstantFP>(
Operands[2])) {
3480 const APFloat &C1 = Op1->getValueAPF();
3481 const APFloat &C2 = Op2->getValueAPF();
3482 const APFloat &C3 = Op3->getValueAPF();
3484 if (
const auto *ConstrIntr = dyn_cast<ConstrainedFPIntrinsic>(Call)) {
3488 switch (IntrinsicID) {
3491 case Intrinsic::experimental_constrained_fma:
3492 case Intrinsic::experimental_constrained_fmuladd:
3496 if (mayFoldConstrained(
3498 return ConstantFP::get(Ty->
getContext(), Res);
3502 switch (IntrinsicID) {
3504 case Intrinsic::amdgcn_fma_legacy: {
3514 case Intrinsic::fma:
3515 case Intrinsic::fmuladd: {
3517 V.fusedMultiplyAdd(C2, C3, APFloat::rmNearestTiesToEven);
3520 case Intrinsic::amdgcn_cubeid:
3521 case Intrinsic::amdgcn_cubema:
3522 case Intrinsic::amdgcn_cubesc:
3523 case Intrinsic::amdgcn_cubetc: {
3524 APFloat V = ConstantFoldAMDGCNCubeIntrinsic(IntrinsicID, C1, C2, C3);
3532 if (IntrinsicID == Intrinsic::smul_fix ||
3533 IntrinsicID == Intrinsic::smul_fix_sat) {
3539 const APInt *C0, *C1;
3540 if (!getConstIntOrUndef(
Operands[0], C0) ||
3541 !getConstIntOrUndef(
Operands[1], C1))
3555 unsigned Scale = cast<ConstantInt>(
Operands[2])->getZExtValue();
3557 assert(Scale < Width &&
"Illegal scale.");
3558 unsigned ExtendedWidth = Width * 2;
3560 (C0->
sext(ExtendedWidth) * C1->
sext(ExtendedWidth)).ashr(Scale);
3561 if (IntrinsicID == Intrinsic::smul_fix_sat) {
3570 if (IntrinsicID == Intrinsic::fshl || IntrinsicID == Intrinsic::fshr) {
3571 const APInt *C0, *C1, *C2;
3572 if (!getConstIntOrUndef(
Operands[0], C0) ||
3573 !getConstIntOrUndef(
Operands[1], C1) ||
3574 !getConstIntOrUndef(
Operands[2], C2))
3577 bool IsRight = IntrinsicID == Intrinsic::fshr;
3591 unsigned LshrAmt = IsRight ? ShAmt :
BitWidth - ShAmt;
3592 unsigned ShlAmt = !IsRight ? ShAmt :
BitWidth - ShAmt;
3594 return ConstantInt::get(Ty, C1->
lshr(LshrAmt));
3596 return ConstantInt::get(Ty, C0->
shl(ShlAmt));
3597 return ConstantInt::get(Ty, C0->
shl(ShlAmt) | C1->
lshr(LshrAmt));
3600 if (IntrinsicID == Intrinsic::amdgcn_perm)
3601 return ConstantFoldAMDGCNPermIntrinsic(
Operands, Ty);
3613 return ConstantFoldScalarCall1(
Name, IntrinsicID, Ty,
Operands, TLI, Call);
3618 return FoldedLibCall;
3620 return ConstantFoldIntrinsicCall2(IntrinsicID, Ty,
Operands, Call);
3624 return ConstantFoldScalarCall3(
Name, IntrinsicID, Ty,
Operands, TLI, Call);
3629static Constant *ConstantFoldFixedVectorCall(
3637 switch (IntrinsicID) {
3638 case Intrinsic::masked_load: {
3647 auto *MaskElt =
Mask->getAggregateElement(
I);
3650 auto *PassthruElt = Passthru->getAggregateElement(
I);
3652 if (isa<UndefValue>(MaskElt)) {
3660 if (MaskElt->isNullValue()) {
3664 }
else if (MaskElt->isOneValue()) {
3676 case Intrinsic::arm_mve_vctp8:
3677 case Intrinsic::arm_mve_vctp16:
3678 case Intrinsic::arm_mve_vctp32:
3679 case Intrinsic::arm_mve_vctp64: {
3680 if (
auto *
Op = dyn_cast<ConstantInt>(
Operands[0])) {
3685 for (
unsigned i = 0; i < Lanes; i++) {
3695 case Intrinsic::get_active_lane_mask: {
3696 auto *Op0 = dyn_cast<ConstantInt>(
Operands[0]);
3697 auto *Op1 = dyn_cast<ConstantInt>(
Operands[1]);
3701 uint64_t Limit = Op1->getZExtValue();
3704 for (
unsigned i = 0; i < Lanes; i++) {
3705 if (
Base + i < Limit)
3720 for (
unsigned J = 0, JE =
Operands.size(); J != JE; ++J) {
3736 ConstantFoldScalarCall(
Name, IntrinsicID, Ty, Lane, TLI, Call);
3745static Constant *ConstantFoldScalableVectorCall(
3749 switch (IntrinsicID) {
3750 case Intrinsic::aarch64_sve_convert_from_svbool: {
3751 auto *Src = dyn_cast<Constant>(
Operands[0]);
3752 if (!Src || !Src->isNullValue())
3763static std::pair<Constant *, Constant *>
3765 if (isa<PoisonValue>(
Op))
3768 auto *ConstFP = dyn_cast<ConstantFP>(
Op);
3772 const APFloat &
U = ConstFP->getValueAPF();
3774 APFloat FrexpMant =
frexp(U, FrexpExp, APFloat::rmNearestTiesToEven);
3775 Constant *Result0 = ConstantFP::get(ConstFP->getType(), FrexpMant);
3782 return {Result0, Result1};
3792 switch (IntrinsicID) {
3793 case Intrinsic::frexp: {
3797 if (
auto *FVTy0 = dyn_cast<FixedVectorType>(Ty0)) {
3801 for (
unsigned I = 0, E = FVTy0->getNumElements();
I != E; ++
I) {
3803 std::tie(Results0[
I], Results1[
I]) =
3804 ConstantFoldScalarFrexpCall(Lane, Ty1);
3813 auto [Result0, Result1] = ConstantFoldScalarFrexpCall(
Operands[0], Ty1);
3818 case Intrinsic::sincos: {
3822 auto ConstantFoldScalarSincosCall =
3823 [&](
Constant *
Op) -> std::pair<Constant *, Constant *> {
3825 ConstantFoldScalarCall(
Name, Intrinsic::sin, TyScalar,
Op, TLI, Call);
3827 ConstantFoldScalarCall(
Name, Intrinsic::cos, TyScalar,
Op, TLI, Call);
3828 return std::make_pair(SinResult, CosResult);
3831 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
3837 std::tie(SinResults[
I], CosResults[
I]) =
3838 ConstantFoldScalarSincosCall(Lane);
3839 if (!SinResults[
I] || !CosResults[
I])
3847 auto [SinResult, CosResult] = ConstantFoldScalarSincosCall(
Operands[0]);
3848 if (!SinResult || !CosResult)
3855 return ConstantFoldScalarCall(
Name, IntrinsicID, StTy,
Operands, TLI, Call);
3866 return ConstantFoldIntrinsicCall2(
ID, Ty, {
LHS,
RHS},
3867 dyn_cast_if_present<CallBase>(
FMFSource));
3873 bool AllowNonDeterministic) {
3874 if (Call->isNoBuiltin())
3891 Type *Ty =
F->getReturnType();
3896 if (
auto *FVTy = dyn_cast<FixedVectorType>(Ty))
3897 return ConstantFoldFixedVectorCall(
3900 if (
auto *SVTy = dyn_cast<ScalableVectorType>(Ty))
3901 return ConstantFoldScalableVectorCall(
3904 if (
auto *StTy = dyn_cast<StructType>(Ty))
3905 return ConstantFoldStructCall(
Name, IID, StTy,
Operands,
3906 F->getDataLayout(), TLI, Call);
3911 return ConstantFoldScalarCall(
Name, IID, Ty,
Operands, TLI, Call);
3918 if (Call->isNoBuiltin() || Call->isStrictFP())
3920 Function *
F = Call->getCalledFunction();
3928 if (Call->arg_size() == 1) {
3929 if (
ConstantFP *OpC = dyn_cast<ConstantFP>(Call->getArgOperand(0))) {
3938 case LibFunc_log10l:
3940 case LibFunc_log10f:
3941 return Op.isNaN() || (!
Op.isZero() && !
Op.isNegative());
3947 if (OpC->getType()->isDoubleTy())
3949 if (OpC->getType()->isFloatTy())
3957 if (OpC->getType()->isDoubleTy())
3959 if (OpC->getType()->isFloatTy())
3969 return !
Op.isInfinity();
3973 case LibFunc_tanf: {
3976 Type *Ty = OpC->getType();
3978 return ConstantFoldFP(tan, OpC->getValueAPF(), Ty) !=
nullptr;
4004 if (OpC->getType()->isDoubleTy())
4006 if (OpC->getType()->isFloatTy())
4013 return Op.isNaN() ||
Op.isZero() || !
Op.isNegative();
4023 if (Call->arg_size() == 2) {
4024 ConstantFP *Op0C = dyn_cast<ConstantFP>(Call->getArgOperand(0));
4025 ConstantFP *Op1C = dyn_cast<ConstantFP>(Call->getArgOperand(1));
4033 case LibFunc_powf: {
4039 return ConstantFoldBinaryFP(pow, Op0, Op1, Ty) !=
nullptr;
4047 case LibFunc_remainderl:
4048 case LibFunc_remainder:
4049 case LibFunc_remainderf:
4054 case LibFunc_atan2f:
4055 case LibFunc_atan2l:
4071void TargetFolder::anchor() {}
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
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
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 ConstantFP * flushDenormalConstantFP(ConstantFP *CFP, const Instruction *Inst, bool IsOutput)
static DenormalMode getInstrDenormalMode(const Instruction *CtxI, 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.
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
amode Optimize addressing mode
mir Rename Register Operands
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,...
const SmallVectorImpl< MachineOperand > & Cond
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
static SymbolRef::Type getType(const Symbol *Sym)
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)
opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
opStatus subtract(const APFloat &RHS, roundingMode RM)
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)
float convertToFloat() const
Converts this APFloat to host float value.
opStatus fusedMultiplyAdd(const APFloat &Multiplicand, const APFloat &Addend, roundingMode RM)
APInt bitcastToAPInt() const
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.
APInt umul_ov(const APInt &RHS, bool &Overflow) const
APInt usub_sat(const APInt &RHS) const
bool isMinSignedValue() const
Determine if this is the smallest signed value.
uint64_t getZExtValue() const
Get zero extended value.
uint64_t extractBitsAsZExtValue(unsigned numBits, unsigned bitPosition) const
APInt zextOrTrunc(unsigned width) const
Zero extend or truncate to width.
APInt trunc(unsigned width) const
Truncate to new width.
APInt abs() const
Get the absolute value.
APInt sadd_sat(const APInt &RHS) const
bool sgt(const APInt &RHS) const
Signed greater than comparison.
APInt usub_ov(const APInt &RHS, bool &Overflow) const
bool ugt(const APInt &RHS) const
Unsigned greater than comparison.
bool isZero() const
Determine if this value is zero, i.e. all bits are clear.
APInt urem(const APInt &RHS) const
Unsigned remainder operation.
unsigned getBitWidth() const
Return the number of bits in the APInt.
bool ult(const APInt &RHS) const
Unsigned less than comparison.
static APInt getSignedMaxValue(unsigned numBits)
Gets maximum signed value of APInt for a specific bit width.
APInt sadd_ov(const APInt &RHS, bool &Overflow) const
APInt uadd_ov(const APInt &RHS, bool &Overflow) const
unsigned countr_zero() const
Count the number of trailing zero bits.
unsigned countl_zero() const
The APInt version of std::countl_zero.
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
APInt sextOrTrunc(unsigned width) const
Sign extend or truncate to width.
APInt uadd_sat(const APInt &RHS) const
APInt smul_ov(const APInt &RHS, bool &Overflow) const
APInt sext(unsigned width) const
Sign extend to a new width.
APInt shl(unsigned shiftAmt) const
Left-shift function.
bool slt(const APInt &RHS) const
Signed less than comparison.
APInt extractBits(unsigned numBits, unsigned bitPosition) const
Return an APInt with the extracted bits [bitPosition,bitPosition+numBits).
APInt ssub_ov(const APInt &RHS, bool &Overflow) const
bool isOne() const
Determine if this is a value of 1.
APInt lshr(unsigned shiftAmt) const
Logical right-shift function.
APInt ssub_sat(const APInt &RHS) const
An arbitrary precision integer that knows its signedness.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
const T & back() const
back - Get the last element.
size_t size() const
size - Get the array size.
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
static 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 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.
bool isFPPredicate() const
static Constant * get(LLVMContext &Context, ArrayRef< ElementTy > Elts)
get() constructor - Return a constant with array type with an element count and element type matching...
static Constant * getIntToPtr(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static Constant * getExtractElement(Constant *Vec, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
static bool isDesirableCastOp(unsigned Opcode)
Whether creating a constant expression for this cast is desirable.
static Constant * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)
Convenience function for getting a Cast operation.
static Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
static Constant * getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
static Constant * getPtrToInt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static 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 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 bool isDesirableBinOp(unsigned Opcode)
Whether creating a constant expression for this binary operator is desirable.
static 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 Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
ConstantFP - Floating Point Values [float, double].
const APFloat & getValueAPF() const
static Constant * getZero(Type *Ty, bool Negative=false)
This is the shared class of boolean and integer constants.
static ConstantInt * getTrue(LLVMContext &Context)
static ConstantInt * getSigned(IntegerType *Ty, int64_t V)
Return a ConstantInt with the specified value for the specified type.
static ConstantInt * getFalse(LLVMContext &Context)
static ConstantInt * getBool(LLVMContext &Context, bool V)
static Constant * get(StructType *T, ArrayRef< Constant * > V)
static Constant * getSplat(ElementCount EC, Constant *Elt)
Return a ConstantVector with the specified constant in each element.
static Constant * get(ArrayRef< Constant * > V)
This is an important base class in LLVM.
Constant * getSplatValue(bool AllowPoison=false) const
If all elements of the vector constant have the same value, return that value.
static Constant * getAllOnesValue(Type *Ty)
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
Constrained floating point compare intrinsics.
This is the common base class for constrained floating point intrinsics.
std::optional< fp::ExceptionBehavior > getExceptionBehavior() const
std::optional< RoundingMode > getRoundingMode() const
Wrapper for a function that represents a value that functionally represents the original function.
This class represents an Operation in the Expression.
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 bool compare(const APFloat &LHS, const APFloat &RHS, FCmpInst::Predicate Pred)
Return result of LHS Pred RHS comparison.
This provides a helper for copying FMF from an instruction or setting specified flags.
Class to represent fixed width SIMD vectors.
unsigned getNumElements() const
static 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.
Represents flags for the getelementptr instruction/expression.
static GEPNoWrapFlags inBounds()
GEPNoWrapFlags withoutNoUnsignedSignedWrap() const
static GEPNoWrapFlags noUnsignedWrap()
bool hasNoUnsignedSignedWrap() const
static 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.
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 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.
const Function * getFunction() const
Return the function this instruction belongs to.
static 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...
ICmpInst::Predicate getPredicate() const
Returns the comparison predicate underlying the intrinsic.
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Class to represent scalable SIMD vectors.
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.
StringRef - 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...
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.
Provides information about what library functions are available for the current target.
bool has(LibFunc F) const
Tests whether a library function is available.
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
The instances of the Type class are immutable: once they are created, they are never changed.
unsigned getIntegerBitWidth() const
Type * getStructElementType(unsigned N) const
const fltSemantics & getFltSemantics() const
bool isVectorTy() const
True if this is an instance of VectorType.
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
bool isPointerTy() const
True if this is an instance of PointerType.
static IntegerType * getInt1Ty(LLVMContext &C)
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
bool isBFloatTy() const
Return true if this is 'bfloat', a 16-bit bfloat type.
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
@ HalfTyID
16-bit floating point type
@ FloatTyID
32-bit floating point type
@ DoubleTyID
64-bit floating point type
static IntegerType * getIntNTy(LLVMContext &C, unsigned N)
bool isFP128Ty() const
Return true if this is 'fp128'.
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
bool isStructTy() const
True if this is an instance of StructType.
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
static IntegerType * getInt16Ty(LLVMContext &C)
bool isAggregateType() const
Return true if the type is an aggregate type.
bool isHalfTy() const
Return true if this is 'half', a 16-bit IEEE fp type.
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
static IntegerType * getInt8Ty(LLVMContext &C)
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
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.
static IntegerType * getInt32Ty(LLVMContext &C)
static IntegerType * getInt64Ty(LLVMContext &C)
bool isIntegerTy() const
True if this is an instance of IntegerType.
TypeID getTypeID() const
Return the type id for the type.
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
Type * getContainedType(unsigned i) const
This method is used to implement the type iterator (defined at the end of the file).
bool isIEEELikeFPTy() const
Return true if this is a well-behaved IEEE-like type, which has a IEEE compatible layout as defined b...
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
static 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.
Value * getOperand(unsigned i) const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
const Value * stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL, APInt &Offset) const
This is a wrapper around stripAndAccumulateConstantOffsets with the in-bounds requirement set to fals...
LLVMContext & getContext() const
All values hold a context through their type.
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).
const ParentTy * getParent() const
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
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.
const APInt & umin(const APInt &A, const APInt &B)
Determine the smaller of two APInts considered to be unsigned.
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.
@ C
The default llvm calling convention, compatible with C.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
@ SC
CHAIN = SC CHAIN, Imm128 - System call.
@ CE
Windows NT (Windows on ARM)
int ilogb(const IEEEFloat &Arg)
@ ebStrict
This corresponds to "fpexcept.strict".
@ ebIgnore
This corresponds to "fpexcept.ignore".
bool FPToIntegerIntrinsicResultIsSigned(Intrinsic::ID IntrinsicID)
APFloat::roundingMode GetFPToIntegerRoundingMode(Intrinsic::ID IntrinsicID)
bool FPToIntegerIntrinsicShouldFTZ(Intrinsic::ID IntrinsicID)
bool FMinFMaxIsXorSignAbs(Intrinsic::ID IntrinsicID)
bool FMinFMaxShouldFTZ(Intrinsic::ID IntrinsicID)
bool FMinFMaxPropagatesNaNs(Intrinsic::ID IntrinsicID)
NodeAddr< FuncNode * > Func
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.
Constant * ConstantFoldBinaryIntrinsic(Intrinsic::ID ID, Constant *LHS, Constant *RHS, Type *Ty, Instruction *FMFSource)
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
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)
Constant * ConstantFoldSelectInstruction(Constant *Cond, Constant *V1, Constant *V2)
Attempt to constant fold a select instruction with the specified operands.
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,...
bool canConstantFoldCallTo(const CallBase *Call, const Function *F)
canConstantFoldCallTo - Return true if its even possible to fold a call to the specified function.
unsigned getPointerAddressSpace(const Type *T)
APFloat abs(APFloat X)
Returns the absolute value of the argument.
Constant * ConstantFoldCompareInstruction(CmpInst::Predicate Predicate, Constant *C1, Constant *C2)
Constant * ConstantFoldUnaryInstruction(unsigned Opcode, Constant *V)
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.
bool isMathLibCallNoop(const CallBase *Call, const TargetLibraryInfo *TLI)
Check whether the given call has no side-effects.
Constant * ReadByteArrayFromGlobal(const GlobalVariable *GV, uint64_t Offset)
LLVM_READONLY APFloat maximum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2019 maximum semantics.
const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=6)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
Constant * ConstantFoldCompareInstOperands(unsigned Predicate, Constant *LHS, Constant *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const Instruction *I=nullptr)
Attempt to constant fold a compare instruction (icmp/fcmp) with the specified operands.
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...
APFloat frexp(const APFloat &X, int &Exp, APFloat::roundingMode RM)
Equivalent of C standard library function.
Constant * ConstantFoldExtractValueInstruction(Constant *Agg, ArrayRef< unsigned > Idxs)
Attempt to constant fold an extractvalue instruction with the specified operands and indices.
Constant * ConstantFoldConstant(const Constant *C, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldConstant - Fold the constant using the specified DataLayout.
LLVM_READONLY APFloat maxnum(const APFloat &A, const APFloat &B)
Implements IEEE-754 2019 maximumNumber semantics.
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...
Constant * ConstantFoldUnaryOpOperand(unsigned Opcode, Constant *Op, const DataLayout &DL)
Attempt to constant fold a unary operation with the specified operand.
Constant * FlushFPConstant(Constant *Operand, const Instruction *I, bool IsOutput)
Attempt to flush float point constant according to denormal mode set in the instruction's parent func...
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM)
bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
Constant * ConstantFoldInstOperands(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.
Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)
Attempt to constant fold a cast with the specified operand.
Constant * ConstantFoldLoadFromConst(Constant *C, Type *Ty, const APInt &Offset, const DataLayout &DL)
Extract value of C at the given Offset reinterpreted as Ty.
Constant * ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS, Constant *RHS, const DataLayout &DL)
Attempt to constant fold a binary operation with the specified operands.
LLVM_READONLY APFloat minnum(const APFloat &A, const APFloat &B)
Implements IEEE-754 2019 minimumNumber semantics.
bool isVectorIntrinsicWithScalarOpAtArg(Intrinsic::ID ID, unsigned ScalarOpdIdx, const TargetTransformInfo *TTI)
Identifies if the vector form of the intrinsic has a scalar operand.
void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
DWARFExpression::Operation Op
Constant * ConstantFoldInstruction(Instruction *I, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldInstruction - Try to constant fold the specified instruction.
RoundingMode
Rounding mode.
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
Constant * ConstantFoldCastInstruction(unsigned opcode, Constant *V, Type *DestTy)
Constant * ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val, ArrayRef< unsigned > Idxs)
ConstantFoldInsertValueInstruction - Attempt to constant fold an insertvalue instruction with the spe...
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...
LLVM_READONLY APFloat minimum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2019 minimum semantics.
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...
Constant * ConstantFoldBinaryInstruction(unsigned Opcode, Constant *V1, Constant *V2)
opStatus
IEEE-754R 7: Default exception handling.
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.
DenormalModeKind Output
Denormal flushing mode for floating point instruction results in the default floating point environme...
static constexpr DenormalMode getDynamic()
static constexpr DenormalMode getIEEE()
Incoming for lane maks phi as machine instruction, incoming register Reg and incoming block Block are...
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.