https://github.com/nikic updated https://github.com/llvm/llvm-project/pull/80309
>From 1d7578f5b8a5dcd8519344cc6c71ee54447b9923 Mon Sep 17 00:00:00 2001
From: Nikita Popov <npo...@redhat.com>
Date: Tue, 13 Aug 2024 15:11:18 +0200
Subject: [PATCH 1/2] apint only
---
clang/lib/AST/Interp/IntegralAP.h | 6 +-
clang/lib/CodeGen/CGVTT.cpp | 4 +-
clang/lib/CodeGen/ItaniumCXXABI.cpp | 4 +-
clang/lib/Parse/ParseInit.cpp | 4 +-
clang/lib/Sema/SemaExpr.cpp | 7 +-
clang/lib/Sema/SemaOpenMP.cpp | 4 +-
llvm/include/llvm/ADT/APFixedPoint.h | 4 +-
llvm/include/llvm/ADT/APInt.h | 19 +-
llvm/lib/Analysis/ConstantFolding.cpp | 3 +-
llvm/lib/Analysis/MemoryBuiltins.cpp | 2 +
llvm/lib/Analysis/ValueTracking.cpp | 4 +-
llvm/lib/Bitcode/Reader/BitcodeReader.cpp | 3 +-
.../lib/CodeGen/SelectionDAG/SelectionDAG.cpp | 5 +-
.../SelectionDAG/SelectionDAGBuilder.cpp | 3 +-
.../CodeGen/SelectionDAG/SelectionDAGISel.cpp | 4 +-
.../CodeGen/SelectionDAG/TargetLowering.cpp | 8 +-
llvm/lib/IR/ConstantRange.cpp | 6 +-
llvm/lib/IR/Constants.cpp | 4 +-
llvm/lib/Support/APInt.cpp | 14 +-
llvm/lib/Target/X86/X86ISelLowering.cpp | 6 +-
llvm/lib/Transforms/IPO/ArgumentPromotion.cpp | 3 +-
.../InstCombine/InstCombineSelect.cpp | 8 +-
llvm/lib/Transforms/Utils/SimplifyCFG.cpp | 2 +-
llvm/unittests/ADT/APFixedPointTest.cpp | 9 +-
llvm/unittests/ADT/APIntTest.cpp | 185 +++++++-------
llvm/unittests/ADT/APSIntTest.cpp | 8 +-
llvm/unittests/ADT/StringExtrasTest.cpp | 10 +-
.../Analysis/ScalarEvolutionTest.cpp | 2 +-
llvm/unittests/IR/ConstantRangeTest.cpp | 240 +++++++++---------
llvm/unittests/IR/MetadataTest.cpp | 22 +-
llvm/unittests/IR/PatternMatch.cpp | 202 +++++++--------
.../Support/DivisionByConstantTest.cpp | 2 +-
32 files changed, 434 insertions(+), 373 deletions(-)
diff --git a/clang/lib/AST/Interp/IntegralAP.h
b/clang/lib/AST/Interp/IntegralAP.h
index b8aa21038256c7..ed756ab1b537b4 100644
--- a/clang/lib/AST/Interp/IntegralAP.h
+++ b/clang/lib/AST/Interp/IntegralAP.h
@@ -61,7 +61,7 @@ template <bool Signed> class IntegralAP final {
IntegralAP(APInt V) : V(V) {}
/// Arbitrary value for uninitialized variables.
- IntegralAP() : IntegralAP(-1, 3) {}
+ IntegralAP() : IntegralAP(Signed ? -1 : 7, 3) {}
IntegralAP operator-() const { return IntegralAP(-V); }
IntegralAP operator-(const IntegralAP &Other) const {
@@ -112,7 +112,9 @@ template <bool Signed> class IntegralAP final {
template <unsigned Bits, bool InputSigned>
static IntegralAP from(Integral<Bits, InputSigned> I, unsigned BitWidth) {
- APInt Copy = APInt(BitWidth, static_cast<uint64_t>(I), InputSigned);
+ // TODO: Avoid implicit trunc?
+ APInt Copy = APInt(BitWidth, static_cast<uint64_t>(I), InputSigned,
+ /*implicitTrunc=*/true);
return IntegralAP<Signed>(Copy);
}
diff --git a/clang/lib/CodeGen/CGVTT.cpp b/clang/lib/CodeGen/CGVTT.cpp
index 20bd2c2fc2c642..c861e1f9203058 100644
--- a/clang/lib/CodeGen/CGVTT.cpp
+++ b/clang/lib/CodeGen/CGVTT.cpp
@@ -85,8 +85,8 @@ CodeGenVTables::EmitVTTDefinition(llvm::GlobalVariable *VTT,
cast<llvm::StructType>(VTable->getValueType())
->getElementType(AddressPoint.VTableIndex));
unsigned Offset = ComponentSize * AddressPoint.AddressPointIndex;
- llvm::ConstantRange InRange(llvm::APInt(32, -Offset, true),
- llvm::APInt(32, VTableSize - Offset, true));
+ llvm::ConstantRange InRange(llvm::APInt(32, -Offset),
+ llvm::APInt(32, VTableSize - Offset));
llvm::Constant *Init = llvm::ConstantExpr::getGetElementPtr(
VTable->getValueType(), VTable, Idxs, /*InBounds=*/true, InRange);
diff --git a/clang/lib/CodeGen/ItaniumCXXABI.cpp
b/clang/lib/CodeGen/ItaniumCXXABI.cpp
index 0cde8a192eda08..bfab28613f9807 100644
--- a/clang/lib/CodeGen/ItaniumCXXABI.cpp
+++ b/clang/lib/CodeGen/ItaniumCXXABI.cpp
@@ -2094,8 +2094,8 @@ ItaniumCXXABI::getVTableAddressPoint(BaseSubobject Base,
unsigned VTableSize =
ComponentSize * Layout.getVTableSize(AddressPoint.VTableIndex);
unsigned Offset = ComponentSize * AddressPoint.AddressPointIndex;
- llvm::ConstantRange InRange(llvm::APInt(32, -Offset, true),
- llvm::APInt(32, VTableSize - Offset, true));
+ llvm::ConstantRange InRange(llvm::APInt(32, -Offset),
+ llvm::APInt(32, VTableSize - Offset));
return llvm::ConstantExpr::getGetElementPtr(
VTable->getValueType(), VTable, Indices, /*InBounds=*/true, InRange);
}
diff --git a/clang/lib/Parse/ParseInit.cpp b/clang/lib/Parse/ParseInit.cpp
index 0a9a359cdaf979..e7c8d79ccccac3 100644
--- a/clang/lib/Parse/ParseInit.cpp
+++ b/clang/lib/Parse/ParseInit.cpp
@@ -437,7 +437,9 @@ ExprResult Parser::createEmbedExpr() {
SourceLocation StartLoc = ConsumeAnnotationToken();
if (Data->BinaryData.size() == 1) {
Res = IntegerLiteral::Create(Context,
- llvm::APInt(CHAR_BIT,
Data->BinaryData.back()),
+ llvm::APInt(CHAR_BIT, Data->BinaryData.back(),
+ /*isSigned=*/false,
+ /*implicitTrunc=*/true),
Context.UnsignedCharTy, StartLoc);
} else {
auto CreateStringLiteralFromStringRef = [&](StringRef Str, QualType Ty) {
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index 8defc8e1c185c0..f874032707359c 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -3577,8 +3577,11 @@ ExprResult Sema::ActOnCharacterConstant(const Token
&Tok, Scope *UDLScope) {
ExprResult Sema::ActOnIntegerConstant(SourceLocation Loc, uint64_t Val) {
unsigned IntSize = Context.getTargetInfo().getIntWidth();
- return IntegerLiteral::Create(Context, llvm::APInt(IntSize, Val),
- Context.IntTy, Loc);
+ // TODO: Avoid implicit trunc?
+ return IntegerLiteral::Create(
+ Context,
+ llvm::APInt(IntSize, Val, /*isSigned=*/false, /*implicitTrunc=*/true),
+ Context.IntTy, Loc);
}
static Expr *BuildFloatingLiteral(Sema &S, NumericLiteralParser &Literal,
diff --git a/clang/lib/Sema/SemaOpenMP.cpp b/clang/lib/Sema/SemaOpenMP.cpp
index 87d81dfaad601b..297950ff012d56 100644
--- a/clang/lib/Sema/SemaOpenMP.cpp
+++ b/clang/lib/Sema/SemaOpenMP.cpp
@@ -5704,7 +5704,9 @@ StmtResult SemaOpenMP::ActOnOpenMPCanonicalLoop(Stmt
*AStmt) {
llvm_unreachable("unhandled unary increment operator");
}
Step = IntegerLiteral::Create(
- Ctx, llvm::APInt(Ctx.getIntWidth(LogicalTy), Direction), LogicalTy,
{});
+ Ctx,
+ llvm::APInt(Ctx.getIntWidth(LogicalTy), Direction, /*isSigned=*/true),
+ LogicalTy, {});
} else if (auto *IncBin = dyn_cast<BinaryOperator>(Inc)) {
if (IncBin->getOpcode() == BO_AddAssign) {
Step = IncBin->getRHS();
diff --git a/llvm/include/llvm/ADT/APFixedPoint.h
b/llvm/include/llvm/ADT/APFixedPoint.h
index 0c014e76aa7126..9c21b1a055b5ee 100644
--- a/llvm/include/llvm/ADT/APFixedPoint.h
+++ b/llvm/include/llvm/ADT/APFixedPoint.h
@@ -160,7 +160,9 @@ class APFixedPoint {
}
APFixedPoint(uint64_t Val, const FixedPointSemantics &Sema)
- : APFixedPoint(APInt(Sema.getWidth(), Val, Sema.isSigned()), Sema) {}
+ : APFixedPoint(APInt(Sema.getWidth(), Val, Sema.isSigned(),
+ /*implicitTrunc=*/true),
+ Sema) {}
// Zero initialization.
APFixedPoint(const FixedPointSemantics &Sema) : APFixedPoint(0, Sema) {}
diff --git a/llvm/include/llvm/ADT/APInt.h b/llvm/include/llvm/ADT/APInt.h
index 108df7e0eaeaa3..09730d6ea7d800 100644
--- a/llvm/include/llvm/ADT/APInt.h
+++ b/llvm/include/llvm/ADT/APInt.h
@@ -108,11 +108,26 @@ class [[nodiscard]] APInt {
/// \param numBits the bit width of the constructed APInt
/// \param val the initial value of the APInt
/// \param isSigned how to treat signedness of val
- APInt(unsigned numBits, uint64_t val, bool isSigned = false)
+ /// \param implicitTrunc allow implicit truncation of non-zero/sign bits of
+ /// val beyond the range of numBits
+ APInt(unsigned numBits, uint64_t val, bool isSigned = false,
+ bool implicitTrunc = false)
: BitWidth(numBits) {
+ if (!implicitTrunc) {
+ if (BitWidth == 0) {
+ assert(val == 0 && "Value must be zero for 0-bit APInt");
+ } else if (isSigned) {
+ assert(llvm::isIntN(BitWidth, val) &&
+ "Value is not an N-bit signed value");
+ } else {
+ assert(llvm::isUIntN(BitWidth, val) &&
+ "Value is not an N-bit unsigned value");
+ }
+ }
if (isSingleWord()) {
U.VAL = val;
- clearUnusedBits();
+ if (implicitTrunc || isSigned)
+ clearUnusedBits();
} else {
initSlowCase(val, isSigned);
}
diff --git a/llvm/lib/Analysis/ConstantFolding.cpp
b/llvm/lib/Analysis/ConstantFolding.cpp
index defcacdfa8b105..2b4751f9e2595d 100644
--- a/llvm/lib/Analysis/ConstantFolding.cpp
+++ b/llvm/lib/Analysis/ConstantFolding.cpp
@@ -887,7 +887,8 @@ Constant *SymbolicallyEvaluateGEP(const GEPOperator *GEP,
APInt Offset = APInt(
BitWidth,
DL.getIndexedOffsetInType(
- SrcElemTy, ArrayRef((Value *const *)Ops.data() + 1, Ops.size() -
1)));
+ SrcElemTy, ArrayRef((Value *const *)Ops.data() + 1, Ops.size() - 1)),
+ /*isSigned=*/true, /*implicitTrunc=*/true);
std::optional<ConstantRange> InRange = GEP->getInRange();
if (InRange)
diff --git a/llvm/lib/Analysis/MemoryBuiltins.cpp
b/llvm/lib/Analysis/MemoryBuiltins.cpp
index e1abf5e4d885ec..dc2dc4c1733b5e 100644
--- a/llvm/lib/Analysis/MemoryBuiltins.cpp
+++ b/llvm/lib/Analysis/MemoryBuiltins.cpp
@@ -767,6 +767,8 @@ SizeOffsetAPInt
ObjectSizeOffsetVisitor::visitAllocaInst(AllocaInst &I) {
TypeSize ElemSize = DL.getTypeAllocSize(I.getAllocatedType());
if (ElemSize.isScalable() && Options.EvalMode != ObjectSizeOpts::Mode::Min)
return ObjectSizeOffsetVisitor::unknown();
+ if (!isUIntN(IntTyBits, ElemSize.getKnownMinValue()))
+ return ObjectSizeOffsetVisitor::unknown();
APInt Size(IntTyBits, ElemSize.getKnownMinValue());
if (!I.isArrayAllocation())
return SizeOffsetAPInt(align(Size, I.getAlign()), Zero);
diff --git a/llvm/lib/Analysis/ValueTracking.cpp
b/llvm/lib/Analysis/ValueTracking.cpp
index b6414a3e7990b0..c49bd0164e68e3 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -9516,7 +9516,7 @@ static ConstantRange getRangeForIntrinsic(const
IntrinsicInst &II) {
case Intrinsic::cttz:
// Maximum of set/clear bits is the bit width.
return ConstantRange::getNonEmpty(APInt::getZero(Width),
- APInt(Width, Width + 1));
+ APInt(Width, Width) + 1);
case Intrinsic::uadd_sat:
// uadd.sat(x, C) produces [C, UINT_MAX].
if (match(II.getOperand(0), m_APInt(C)) ||
@@ -9671,7 +9671,7 @@ static void setLimitForFPToI(const Instruction *I, APInt
&Lower, APInt &Upper) {
if (!I->getOperand(0)->getType()->getScalarType()->isHalfTy())
return;
if (isa<FPToSIInst>(I) && BitWidth >= 17) {
- Lower = APInt(BitWidth, -65504);
+ Lower = APInt(BitWidth, -65504, true);
Upper = APInt(BitWidth, 65505);
}
diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
index d4dbab04e8ecdb..142ae67dec751f 100644
--- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -858,7 +858,8 @@ class BitcodeReader : public BitcodeReaderBase, public
GVMaterializer {
} else {
int64_t Start = BitcodeReader::decodeSignRotatedValue(Record[OpNum++]);
int64_t End = BitcodeReader::decodeSignRotatedValue(Record[OpNum++]);
- return ConstantRange(APInt(BitWidth, Start), APInt(BitWidth, End));
+ return ConstantRange(APInt(BitWidth, Start, true),
+ APInt(BitWidth, End, true));
}
}
diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
index ab12c3b0e728a8..3bf6d31906cd83 100644
--- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
@@ -1627,7 +1627,10 @@ SDValue SelectionDAG::getConstant(uint64_t Val, const
SDLoc &DL, EVT VT,
assert((EltVT.getSizeInBits() >= 64 ||
(uint64_t)((int64_t)Val >> EltVT.getSizeInBits()) + 1 < 2) &&
"getConstant with a uint64_t value that doesn't fit in the type!");
- return getConstant(APInt(EltVT.getSizeInBits(), Val), DL, VT, isT, isO);
+ // TODO: Avoid implicit trunc?
+ return getConstant(APInt(EltVT.getSizeInBits(), Val, /*isSigned=*/false,
+ /*implicitTrunc=*/true),
+ DL, VT, isT, isO);
}
SDValue SelectionDAG::getConstant(const APInt &Val, const SDLoc &DL, EVT VT,
diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
index 37ba62911ec70b..922199d4db8440 100644
--- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
@@ -4333,7 +4333,8 @@ void SelectionDAGBuilder::visitGetElementPtr(const User
&I) {
GTI.getSequentialElementStride(DAG.getDataLayout());
// We intentionally mask away the high bits here; ElementSize may not
// fit in IdxTy.
- APInt ElementMul(IdxSize, ElementSize.getKnownMinValue());
+ APInt ElementMul(IdxSize, ElementSize.getKnownMinValue(),
+ /*isSigned=*/false, /*implicitTrunc=*/true);
bool ElementScalable = ElementSize.isScalable();
// If this is a scalar constant or a splat vector of constants,
diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
index 3e517a51862de3..02b174cc2ff3cc 100644
--- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
@@ -2142,7 +2142,9 @@ ScheduleDAGSDNodes *SelectionDAGISel::CreateScheduler() {
bool SelectionDAGISel::CheckAndMask(SDValue LHS, ConstantSDNode *RHS,
int64_t DesiredMaskS) const {
const APInt &ActualMask = RHS->getAPIntValue();
- const APInt &DesiredMask = APInt(LHS.getValueSizeInBits(), DesiredMaskS);
+ // TODO: Avoid implicit trunc?
+ const APInt &DesiredMask = APInt(LHS.getValueSizeInBits(), DesiredMaskS,
+ /*isSigned=*/false, /*implicitTrunc=*/true);
// If the actual mask exactly matches, success!
if (ActualMask == DesiredMask)
diff --git a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
index c4f4261a708fda..22759a11531edd 100644
--- a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
@@ -6800,7 +6800,9 @@ TargetLowering::prepareUREMEqFold(EVT SETCCVT, SDValue
REMNode,
PAmts.push_back(DAG.getConstant(P, DL, SVT));
KAmts.push_back(
- DAG.getConstant(APInt(ShSVT.getSizeInBits(), K), DL, ShSVT));
+ DAG.getConstant(APInt(ShSVT.getSizeInBits(), K, /*isSigned=*/false,
+ /*implicitTrunc=*/true),
+ DL, ShSVT));
QAmts.push_back(DAG.getConstant(Q, DL, SVT));
return true;
};
@@ -7071,7 +7073,9 @@ TargetLowering::prepareSREMEqFold(EVT SETCCVT, SDValue
REMNode,
PAmts.push_back(DAG.getConstant(P, DL, SVT));
AAmts.push_back(DAG.getConstant(A, DL, SVT));
KAmts.push_back(
- DAG.getConstant(APInt(ShSVT.getSizeInBits(), K), DL, ShSVT));
+ DAG.getConstant(APInt(ShSVT.getSizeInBits(), K, /*isSigned=*/false,
+ /*implicitTrunc=*/true),
+ DL, ShSVT));
QAmts.push_back(DAG.getConstant(Q, DL, SVT));
return true;
};
diff --git a/llvm/lib/IR/ConstantRange.cpp b/llvm/lib/IR/ConstantRange.cpp
index c389d7214defca..61a051821a5dbf 100644
--- a/llvm/lib/IR/ConstantRange.cpp
+++ b/llvm/lib/IR/ConstantRange.cpp
@@ -1952,7 +1952,7 @@ ConstantRange ConstantRange::ctlz(bool ZeroIsPoison)
const {
// Zero is either safe or not in the range. The output range is composed by
// the result of countLeadingZero of the two extremes.
return getNonEmpty(APInt(getBitWidth(), getUnsignedMax().countl_zero()),
- APInt(getBitWidth(), getUnsignedMin().countl_zero() + 1));
+ APInt(getBitWidth(), getUnsignedMin().countl_zero()) + 1);
}
static ConstantRange getUnsignedCountTrailingZerosRange(const APInt &Lower,
@@ -2011,7 +2011,7 @@ ConstantRange ConstantRange::cttz(bool ZeroIsPoison)
const {
}
if (isFullSet())
- return getNonEmpty(Zero, APInt(BitWidth, BitWidth + 1));
+ return getNonEmpty(Zero, APInt(BitWidth, BitWidth) + 1);
if (!isWrappedSet())
return getUnsignedCountTrailingZerosRange(Lower, Upper);
// The range is wrapped. We decompose it into two ranges, [0, Upper) and
@@ -2056,7 +2056,7 @@ ConstantRange ConstantRange::ctpop() const {
unsigned BitWidth = getBitWidth();
APInt Zero = APInt::getZero(BitWidth);
if (isFullSet())
- return getNonEmpty(Zero, APInt(BitWidth, BitWidth + 1));
+ return getNonEmpty(Zero, APInt(BitWidth, BitWidth) + 1);
if (!isWrappedSet())
return getUnsignedPopCountRange(Lower, Upper);
// The range is wrapped. We decompose it into two ranges, [0, Upper) and
diff --git a/llvm/lib/IR/Constants.cpp b/llvm/lib/IR/Constants.cpp
index a1c9e925a024fe..6c558798146e0b 100644
--- a/llvm/lib/IR/Constants.cpp
+++ b/llvm/lib/IR/Constants.cpp
@@ -933,7 +933,9 @@ Constant *ConstantInt::get(Type *Ty, uint64_t V, bool
isSigned) {
}
ConstantInt *ConstantInt::get(IntegerType *Ty, uint64_t V, bool isSigned) {
- return get(Ty->getContext(), APInt(Ty->getBitWidth(), V, isSigned));
+ // TODO: Avoid implicit trunc?
+ return get(Ty->getContext(),
+ APInt(Ty->getBitWidth(), V, isSigned, /*implicitTrunc=*/true));
}
Constant *ConstantInt::get(Type *Ty, const APInt& V) {
diff --git a/llvm/lib/Support/APInt.cpp b/llvm/lib/Support/APInt.cpp
index fe22e9ba04b6f5..c9d69951e03585 100644
--- a/llvm/lib/Support/APInt.cpp
+++ b/llvm/lib/Support/APInt.cpp
@@ -234,7 +234,8 @@ APInt& APInt::operator-=(uint64_t RHS) {
APInt APInt::operator*(const APInt& RHS) const {
assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
if (isSingleWord())
- return APInt(BitWidth, U.VAL * RHS.U.VAL);
+ return APInt(BitWidth, U.VAL * RHS.U.VAL, /*isSigned=*/false,
+ /*implicitTrunc=*/true);
APInt Result(getMemory(getNumWords()), getBitWidth());
tcMultiply(Result.U.pVal, U.pVal, RHS.U.pVal, getNumWords());
@@ -455,7 +456,8 @@ APInt APInt::extractBits(unsigned numBits, unsigned
bitPosition) const {
"Illegal bit extraction");
if (isSingleWord())
- return APInt(numBits, U.VAL >> bitPosition);
+ return APInt(numBits, U.VAL >> bitPosition, /*isSigned=*/false,
+ /*implicitTrunc=*/true);
unsigned loBit = whichBit(bitPosition);
unsigned loWord = whichWord(bitPosition);
@@ -463,7 +465,8 @@ APInt APInt::extractBits(unsigned numBits, unsigned
bitPosition) const {
// Single word result extracting bits from a single word source.
if (loWord == hiWord)
- return APInt(numBits, U.pVal[loWord] >> loBit);
+ return APInt(numBits, U.pVal[loWord] >> loBit, /*isSigned=*/false,
+ /*implicitTrunc=*/true);
// Extracting bits that start on a source word boundary can be done
// as a fast memory copy.
@@ -907,7 +910,8 @@ APInt APInt::trunc(unsigned width) const {
assert(width <= BitWidth && "Invalid APInt Truncate request");
if (width <= APINT_BITS_PER_WORD)
- return APInt(width, getRawData()[0]);
+ return APInt(width, getRawData()[0], /*isSigned=*/false,
+ /*implicitTrunc=*/true);
if (width == BitWidth)
return *this;
@@ -955,7 +959,7 @@ APInt APInt::sext(unsigned Width) const {
assert(Width >= BitWidth && "Invalid APInt SignExtend request");
if (Width <= APINT_BITS_PER_WORD)
- return APInt(Width, SignExtend64(U.VAL, BitWidth));
+ return APInt(Width, SignExtend64(U.VAL, BitWidth), /*isSigned*/ true);
if (Width == BitWidth)
return *this;
diff --git a/llvm/lib/Target/X86/X86ISelLowering.cpp
b/llvm/lib/Target/X86/X86ISelLowering.cpp
index 2759252693f9f8..bbd3cc57c0a0f6 100644
--- a/llvm/lib/Target/X86/X86ISelLowering.cpp
+++ b/llvm/lib/Target/X86/X86ISelLowering.cpp
@@ -52201,8 +52201,8 @@ static SDValue combineFMulcFCMulc(SDNode *N,
SelectionDAG &DAG,
if (XOR->getOpcode() == ISD::XOR && XOR.hasOneUse()) {
KnownBits XORRHS = DAG.computeKnownBits(XOR.getOperand(1));
if (XORRHS.isConstant()) {
- APInt ConjugationInt32 = APInt(32, 0x80000000, true);
- APInt ConjugationInt64 = APInt(64, 0x8000000080000000ULL, true);
+ APInt ConjugationInt32 = APInt(32, 0x80000000);
+ APInt ConjugationInt64 = APInt(64, 0x8000000080000000ULL);
if ((XORRHS.getBitWidth() == 32 &&
XORRHS.getConstant() == ConjugationInt32) ||
(XORRHS.getBitWidth() == 64 &&
@@ -52241,7 +52241,7 @@ static SDValue combineFaddCFmul(SDNode *N, SelectionDAG
&DAG,
Flags.hasNoSignedZeros();
};
auto IsVectorAllNegativeZero = [&DAG](SDValue Op) {
- APInt AI = APInt(32, 0x80008000, true);
+ APInt AI = APInt(32, 0x80008000);
KnownBits Bits = DAG.computeKnownBits(Op);
return Bits.getBitWidth() == 32 && Bits.isConstant() &&
Bits.getConstant() == AI;
diff --git a/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
b/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
index 452fff7898d0ea..2d6cdda159698f 100644
--- a/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
+++ b/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
@@ -100,7 +100,8 @@ using OffsetAndArgPart = std::pair<int64_t, ArgPart>;
static Value *createByteGEP(IRBuilderBase &IRB, const DataLayout &DL,
Value *Ptr, Type *ResElemTy, int64_t Offset) {
if (Offset != 0) {
- APInt APOffset(DL.getIndexTypeSizeInBits(Ptr->getType()), Offset);
+ APInt APOffset(DL.getIndexTypeSizeInBits(Ptr->getType()), Offset,
+ /*isSigned=*/true);
Ptr = IRB.CreatePtrAdd(Ptr, IRB.getInt(APOffset));
}
return Ptr;
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp
b/llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp
index b86f27168303a1..b8b77bec1b900d 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp
@@ -679,11 +679,11 @@ static Value *foldSelectICmpLshrAshr(const ICmpInst *IC,
Value *TrueVal,
Value *X, *Y;
unsigned Bitwidth = CmpRHS->getType()->getScalarSizeInBits();
if ((Pred != ICmpInst::ICMP_SGT ||
- !match(CmpRHS,
- m_SpecificInt_ICMP(ICmpInst::ICMP_SGE, APInt(Bitwidth, -1)))) &&
+ !match(CmpRHS, m_SpecificInt_ICMP(ICmpInst::ICMP_SGE,
+ APInt::getAllOnes(Bitwidth)))) &&
(Pred != ICmpInst::ICMP_SLT ||
- !match(CmpRHS,
- m_SpecificInt_ICMP(ICmpInst::ICMP_SGE, APInt(Bitwidth, 0)))))
+ !match(CmpRHS, m_SpecificInt_ICMP(ICmpInst::ICMP_SGE,
+ APInt::getZero(Bitwidth)))))
return nullptr;
// Canonicalize so that ashr is in FalseVal.
diff --git a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
index 37c8761ca9383d..961e7ac084e41a 100644
--- a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
+++ b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
@@ -7032,7 +7032,7 @@ static bool reduceSwitchRange(SwitchInst *SI, IRBuilder<>
&Builder,
for (auto Case : SI->cases()) {
auto *Orig = Case.getCaseValue();
- auto Sub = Orig->getValue() - APInt(Ty->getBitWidth(), Base);
+ auto Sub = Orig->getValue() - APInt(Ty->getBitWidth(), Base, true);
Case.setValue(cast<ConstantInt>(ConstantInt::get(Ty, Sub.lshr(Shift))));
}
return true;
diff --git a/llvm/unittests/ADT/APFixedPointTest.cpp
b/llvm/unittests/ADT/APFixedPointTest.cpp
index ecb89fbf76c8bb..a0f43fdfcd7e43 100644
--- a/llvm/unittests/ADT/APFixedPointTest.cpp
+++ b/llvm/unittests/ADT/APFixedPointTest.cpp
@@ -240,19 +240,20 @@ void CheckIntPart(const FixedPointSemantics &Sema,
int64_t IntPart) {
APFixedPoint ValWithFract(
APInt(Sema.getWidth(),
relativeShr(IntPart, Sema.getLsbWeight()) + FullFactPart,
- Sema.isSigned()),
+ Sema.isSigned(), /*implicitTrunc=*/true),
Sema);
ASSERT_EQ(ValWithFract.getIntPart(), IntPart);
// Just fraction
- APFixedPoint JustFract(APInt(Sema.getWidth(), FullFactPart, Sema.isSigned()),
+ APFixedPoint JustFract(APInt(Sema.getWidth(), FullFactPart, Sema.isSigned(),
+ /*implicitTrunc=*/true),
Sema);
ASSERT_EQ(JustFract.getIntPart(), 0);
// Whole number
APFixedPoint WholeNum(APInt(Sema.getWidth(),
relativeShr(IntPart, Sema.getLsbWeight()),
- Sema.isSigned()),
+ Sema.isSigned(), /*implicitTrunc=*/true),
Sema);
ASSERT_EQ(WholeNum.getIntPart(), IntPart);
@@ -260,7 +261,7 @@ void CheckIntPart(const FixedPointSemantics &Sema, int64_t
IntPart) {
if (Sema.isSigned()) {
APFixedPoint Negative(APInt(Sema.getWidth(),
relativeShr(IntPart, Sema.getLsbWeight()),
- Sema.isSigned()),
+ Sema.isSigned(), /*implicitTrunc=*/true),
Sema);
ASSERT_EQ(Negative.getIntPart(), IntPart);
}
diff --git a/llvm/unittests/ADT/APIntTest.cpp b/llvm/unittests/ADT/APIntTest.cpp
index eb4b847185f53b..529b2c30d16df9 100644
--- a/llvm/unittests/ADT/APIntTest.cpp
+++ b/llvm/unittests/ADT/APIntTest.cpp
@@ -220,11 +220,12 @@ TEST(APIntTest, i256) {
}
TEST(APIntTest, i1) {
- const APInt neg_two(1, static_cast<uint64_t>(-2), true);
+ const APInt neg_two(1, static_cast<uint64_t>(-2), true,
+ /*implicitTrunc*/ true);
const APInt neg_one(1, static_cast<uint64_t>(-1), true);
const APInt zero(1, 0);
const APInt one(1, 1);
- const APInt two(1, 2);
+ const APInt two(1, 2, false, /*implicitTrunc*/ true);
EXPECT_EQ(0, neg_two.getSExtValue());
EXPECT_EQ(-1, neg_one.getSExtValue());
@@ -1110,11 +1111,11 @@ TEST(APIntTest, fromString) {
EXPECT_EQ(APInt(32, 3), APInt(32, "+11", 2));
EXPECT_EQ(APInt(32, 4), APInt(32, "+100", 2));
- EXPECT_EQ(APInt(32, uint64_t(-0LL)), APInt(32, "-0", 2));
- EXPECT_EQ(APInt(32, uint64_t(-1LL)), APInt(32, "-1", 2));
- EXPECT_EQ(APInt(32, uint64_t(-2LL)), APInt(32, "-10", 2));
- EXPECT_EQ(APInt(32, uint64_t(-3LL)), APInt(32, "-11", 2));
- EXPECT_EQ(APInt(32, uint64_t(-4LL)), APInt(32, "-100", 2));
+ EXPECT_EQ(APInt(32, uint32_t(-0LL)), APInt(32, "-0", 2));
+ EXPECT_EQ(APInt(32, uint32_t(-1LL)), APInt(32, "-1", 2));
+ EXPECT_EQ(APInt(32, uint32_t(-2LL)), APInt(32, "-10", 2));
+ EXPECT_EQ(APInt(32, uint32_t(-3LL)), APInt(32, "-11", 2));
+ EXPECT_EQ(APInt(32, uint32_t(-4LL)), APInt(32, "-100", 2));
EXPECT_EQ(APInt(32, 0), APInt(32, "0", 8));
EXPECT_EQ(APInt(32, 1), APInt(32, "1", 8));
@@ -1130,12 +1131,12 @@ TEST(APIntTest, fromString) {
EXPECT_EQ(APInt(32, +15), APInt(32, "+17", 8));
EXPECT_EQ(APInt(32, +16), APInt(32, "+20", 8));
- EXPECT_EQ(APInt(32, uint64_t(-0LL)), APInt(32, "-0", 8));
- EXPECT_EQ(APInt(32, uint64_t(-1LL)), APInt(32, "-1", 8));
- EXPECT_EQ(APInt(32, uint64_t(-7LL)), APInt(32, "-7", 8));
- EXPECT_EQ(APInt(32, uint64_t(-8LL)), APInt(32, "-10", 8));
- EXPECT_EQ(APInt(32, uint64_t(-15LL)), APInt(32, "-17", 8));
- EXPECT_EQ(APInt(32, uint64_t(-16LL)), APInt(32, "-20", 8));
+ EXPECT_EQ(APInt(32, uint32_t(-0LL)), APInt(32, "-0", 8));
+ EXPECT_EQ(APInt(32, uint32_t(-1LL)), APInt(32, "-1", 8));
+ EXPECT_EQ(APInt(32, uint32_t(-7LL)), APInt(32, "-7", 8));
+ EXPECT_EQ(APInt(32, uint32_t(-8LL)), APInt(32, "-10", 8));
+ EXPECT_EQ(APInt(32, uint32_t(-15LL)), APInt(32, "-17", 8));
+ EXPECT_EQ(APInt(32, uint32_t(-16LL)), APInt(32, "-20", 8));
EXPECT_EQ(APInt(32, 0), APInt(32, "0", 10));
EXPECT_EQ(APInt(32, 1), APInt(32, "1", 10));
@@ -1144,12 +1145,12 @@ TEST(APIntTest, fromString) {
EXPECT_EQ(APInt(32, 19), APInt(32, "19", 10));
EXPECT_EQ(APInt(32, 20), APInt(32, "20", 10));
- EXPECT_EQ(APInt(32, uint64_t(-0LL)), APInt(32, "-0", 10));
- EXPECT_EQ(APInt(32, uint64_t(-1LL)), APInt(32, "-1", 10));
- EXPECT_EQ(APInt(32, uint64_t(-9LL)), APInt(32, "-9", 10));
- EXPECT_EQ(APInt(32, uint64_t(-10LL)), APInt(32, "-10", 10));
- EXPECT_EQ(APInt(32, uint64_t(-19LL)), APInt(32, "-19", 10));
- EXPECT_EQ(APInt(32, uint64_t(-20LL)), APInt(32, "-20", 10));
+ EXPECT_EQ(APInt(32, uint32_t(-0LL)), APInt(32, "-0", 10));
+ EXPECT_EQ(APInt(32, uint32_t(-1LL)), APInt(32, "-1", 10));
+ EXPECT_EQ(APInt(32, uint32_t(-9LL)), APInt(32, "-9", 10));
+ EXPECT_EQ(APInt(32, uint32_t(-10LL)), APInt(32, "-10", 10));
+ EXPECT_EQ(APInt(32, uint32_t(-19LL)), APInt(32, "-19", 10));
+ EXPECT_EQ(APInt(32, uint32_t(-20LL)), APInt(32, "-20", 10));
EXPECT_EQ(APInt(32, 0), APInt(32, "0", 16));
EXPECT_EQ(APInt(32, 1), APInt(32, "1", 16));
@@ -1158,12 +1159,12 @@ TEST(APIntTest, fromString) {
EXPECT_EQ(APInt(32, 31), APInt(32, "1F", 16));
EXPECT_EQ(APInt(32, 32), APInt(32, "20", 16));
- EXPECT_EQ(APInt(32, uint64_t(-0LL)), APInt(32, "-0", 16));
- EXPECT_EQ(APInt(32, uint64_t(-1LL)), APInt(32, "-1", 16));
- EXPECT_EQ(APInt(32, uint64_t(-15LL)), APInt(32, "-F", 16));
- EXPECT_EQ(APInt(32, uint64_t(-16LL)), APInt(32, "-10", 16));
- EXPECT_EQ(APInt(32, uint64_t(-31LL)), APInt(32, "-1F", 16));
- EXPECT_EQ(APInt(32, uint64_t(-32LL)), APInt(32, "-20", 16));
+ EXPECT_EQ(APInt(32, uint32_t(-0LL)), APInt(32, "-0", 16));
+ EXPECT_EQ(APInt(32, uint32_t(-1LL)), APInt(32, "-1", 16));
+ EXPECT_EQ(APInt(32, uint32_t(-15LL)), APInt(32, "-F", 16));
+ EXPECT_EQ(APInt(32, uint32_t(-16LL)), APInt(32, "-10", 16));
+ EXPECT_EQ(APInt(32, uint32_t(-31LL)), APInt(32, "-1F", 16));
+ EXPECT_EQ(APInt(32, uint32_t(-32LL)), APInt(32, "-20", 16));
EXPECT_EQ(APInt(32, 0), APInt(32, "0", 36));
EXPECT_EQ(APInt(32, 1), APInt(32, "1", 36));
@@ -1172,12 +1173,12 @@ TEST(APIntTest, fromString) {
EXPECT_EQ(APInt(32, 71), APInt(32, "1Z", 36));
EXPECT_EQ(APInt(32, 72), APInt(32, "20", 36));
- EXPECT_EQ(APInt(32, uint64_t(-0LL)), APInt(32, "-0", 36));
- EXPECT_EQ(APInt(32, uint64_t(-1LL)), APInt(32, "-1", 36));
- EXPECT_EQ(APInt(32, uint64_t(-35LL)), APInt(32, "-Z", 36));
- EXPECT_EQ(APInt(32, uint64_t(-36LL)), APInt(32, "-10", 36));
- EXPECT_EQ(APInt(32, uint64_t(-71LL)), APInt(32, "-1Z", 36));
- EXPECT_EQ(APInt(32, uint64_t(-72LL)), APInt(32, "-20", 36));
+ EXPECT_EQ(APInt(32, uint32_t(-0LL)), APInt(32, "-0", 36));
+ EXPECT_EQ(APInt(32, uint32_t(-1LL)), APInt(32, "-1", 36));
+ EXPECT_EQ(APInt(32, uint32_t(-35LL)), APInt(32, "-Z", 36));
+ EXPECT_EQ(APInt(32, uint32_t(-36LL)), APInt(32, "-10", 36));
+ EXPECT_EQ(APInt(32, uint32_t(-71LL)), APInt(32, "-1Z", 36));
+ EXPECT_EQ(APInt(32, uint32_t(-72LL)), APInt(32, "-20", 36));
}
TEST(APIntTest, SaturatingMath) {
@@ -1201,10 +1202,10 @@ TEST(APIntTest, SaturatingMath) {
EXPECT_EQ(APInt(6, 31), AP_42.truncSSat(6));
EXPECT_EQ(APInt(5, 15), AP_42.truncSSat(5));
- EXPECT_EQ(APInt(8, -56), AP_200.truncSSat(8));
- EXPECT_EQ(APInt(7, -56), AP_200.truncSSat(7));
- EXPECT_EQ(APInt(6, -32), AP_200.truncSSat(6));
- EXPECT_EQ(APInt(5, -16), AP_200.truncSSat(5));
+ EXPECT_EQ(APInt(8, -56, true), AP_200.truncSSat(8));
+ EXPECT_EQ(APInt(7, -56, true), AP_200.truncSSat(7));
+ EXPECT_EQ(APInt(6, -32, true), AP_200.truncSSat(6));
+ EXPECT_EQ(APInt(5, -16, true), AP_200.truncSSat(5));
EXPECT_EQ(APInt(8, 200), AP_100.uadd_sat(AP_100));
EXPECT_EQ(APInt(8, 255), AP_100.uadd_sat(AP_200));
@@ -1212,52 +1213,53 @@ TEST(APIntTest, SaturatingMath) {
EXPECT_EQ(APInt(8, 110), AP_10.sadd_sat(AP_100));
EXPECT_EQ(APInt(8, 127), AP_100.sadd_sat(AP_100));
- EXPECT_EQ(APInt(8, -128), (-AP_100).sadd_sat(-AP_100));
- EXPECT_EQ(APInt(8, -128), APInt(8, -128).sadd_sat(APInt(8, -128)));
+ EXPECT_EQ(APInt(8, -128, true), (-AP_100).sadd_sat(-AP_100));
+ EXPECT_EQ(APInt(8, -128, true),
+ APInt(8, -128, true).sadd_sat(APInt(8, -128, true)));
EXPECT_EQ(APInt(8, 90), AP_100.usub_sat(AP_10));
EXPECT_EQ(APInt(8, 0), AP_100.usub_sat(AP_200));
EXPECT_EQ(APInt(8, 0), APInt(8, 0).usub_sat(APInt(8, 255)));
- EXPECT_EQ(APInt(8, -90), AP_10.ssub_sat(AP_100));
+ EXPECT_EQ(APInt(8, -90, true), AP_10.ssub_sat(AP_100));
EXPECT_EQ(APInt(8, 127), AP_100.ssub_sat(-AP_100));
- EXPECT_EQ(APInt(8, -128), (-AP_100).ssub_sat(AP_100));
- EXPECT_EQ(APInt(8, -128), APInt(8, -128).ssub_sat(APInt(8, 127)));
+ EXPECT_EQ(APInt(8, -128, true), (-AP_100).ssub_sat(AP_100));
+ EXPECT_EQ(APInt(8, -128, true), APInt(8, -128, true).ssub_sat(APInt(8,
127)));
EXPECT_EQ(APInt(8, 250), APInt(8, 50).umul_sat(APInt(8, 5)));
EXPECT_EQ(APInt(8, 255), APInt(8, 50).umul_sat(APInt(8, 6)));
- EXPECT_EQ(APInt(8, 255), APInt(8, -128).umul_sat(APInt(8, 3)));
- EXPECT_EQ(APInt(8, 255), APInt(8, 3).umul_sat(APInt(8, -128)));
- EXPECT_EQ(APInt(8, 255), APInt(8, -128).umul_sat(APInt(8, -128)));
+ EXPECT_EQ(APInt(8, 255), APInt(8, -128, true).umul_sat(APInt(8, 3)));
+ EXPECT_EQ(APInt(8, 255), APInt(8, 3).umul_sat(APInt(8, -128, true)));
+ EXPECT_EQ(APInt(8, 255), APInt(8, -128, true).umul_sat(APInt(8, -128,
true)));
EXPECT_EQ(APInt(8, 125), APInt(8, 25).smul_sat(APInt(8, 5)));
EXPECT_EQ(APInt(8, 127), APInt(8, 25).smul_sat(APInt(8, 6)));
EXPECT_EQ(APInt(8, 127), APInt(8, 127).smul_sat(APInt(8, 127)));
- EXPECT_EQ(APInt(8, -125), APInt(8, -25).smul_sat(APInt(8, 5)));
- EXPECT_EQ(APInt(8, -125), APInt(8, 25).smul_sat(APInt(8, -5)));
- EXPECT_EQ(APInt(8, 125), APInt(8, -25).smul_sat(APInt(8, -5)));
+ EXPECT_EQ(APInt(8, -125, true), APInt(8, -25, true).smul_sat(APInt(8, 5)));
+ EXPECT_EQ(APInt(8, -125, true), APInt(8, 25).smul_sat(APInt(8, -5, true)));
+ EXPECT_EQ(APInt(8, 125), APInt(8, -25, true).smul_sat(APInt(8, -5, true)));
EXPECT_EQ(APInt(8, 125), APInt(8, 25).smul_sat(APInt(8, 5)));
- EXPECT_EQ(APInt(8, -128), APInt(8, -25).smul_sat(APInt(8, 6)));
- EXPECT_EQ(APInt(8, -128), APInt(8, 25).smul_sat(APInt(8, -6)));
- EXPECT_EQ(APInt(8, 127), APInt(8, -25).smul_sat(APInt(8, -6)));
+ EXPECT_EQ(APInt(8, -128, true), APInt(8, -25, true).smul_sat(APInt(8, 6)));
+ EXPECT_EQ(APInt(8, -128, true), APInt(8, 25).smul_sat(APInt(8, -6, true)));
+ EXPECT_EQ(APInt(8, 127), APInt(8, -25, true).smul_sat(APInt(8, -6, true)));
EXPECT_EQ(APInt(8, 127), APInt(8, 25).smul_sat(APInt(8, 6)));
EXPECT_EQ(APInt(8, 128), APInt(8, 4).ushl_sat(APInt(8, 5)));
EXPECT_EQ(APInt(8, 255), APInt(8, 4).ushl_sat(APInt(8, 6)));
EXPECT_EQ(APInt(8, 128), APInt(8, 1).ushl_sat(APInt(8, 7)));
EXPECT_EQ(APInt(8, 255), APInt(8, 1).ushl_sat(APInt(8, 8)));
- EXPECT_EQ(APInt(8, 255), APInt(8, -128).ushl_sat(APInt(8, 2)));
+ EXPECT_EQ(APInt(8, 255), APInt(8, -128, true).ushl_sat(APInt(8, 2)));
EXPECT_EQ(APInt(8, 255), APInt(8, 64).ushl_sat(APInt(8, 2)));
- EXPECT_EQ(APInt(8, 255), APInt(8, 64).ushl_sat(APInt(8, -2)));
+ EXPECT_EQ(APInt(8, 255), APInt(8, 64).ushl_sat(APInt(8, -2, true)));
EXPECT_EQ(APInt(8, 64), APInt(8, 4).sshl_sat(APInt(8, 4)));
EXPECT_EQ(APInt(8, 127), APInt(8, 4).sshl_sat(APInt(8, 5)));
EXPECT_EQ(APInt(8, 127), APInt(8, 1).sshl_sat(APInt(8, 8)));
- EXPECT_EQ(APInt(8, -64), APInt(8, -4).sshl_sat(APInt(8, 4)));
- EXPECT_EQ(APInt(8, -128), APInt(8, -4).sshl_sat(APInt(8, 5)));
- EXPECT_EQ(APInt(8, -128), APInt(8, -4).sshl_sat(APInt(8, 6)));
- EXPECT_EQ(APInt(8, -128), APInt(8, -1).sshl_sat(APInt(8, 7)));
- EXPECT_EQ(APInt(8, -128), APInt(8, -1).sshl_sat(APInt(8, 8)));
+ EXPECT_EQ(APInt(8, -64, true), APInt(8, -4, true).sshl_sat(APInt(8, 4)));
+ EXPECT_EQ(APInt(8, -128, true), APInt(8, -4, true).sshl_sat(APInt(8, 5)));
+ EXPECT_EQ(APInt(8, -128, true), APInt(8, -4, true).sshl_sat(APInt(8, 6)));
+ EXPECT_EQ(APInt(8, -128, true), APInt(8, -1, true).sshl_sat(APInt(8, 7)));
+ EXPECT_EQ(APInt(8, -128, true), APInt(8, -1, true).sshl_sat(APInt(8, 8)));
}
TEST(APIntTest, FromArray) {
@@ -1399,39 +1401,39 @@ TEST(APIntTest, toString) {
S.clear();
isSigned = false;
- APInt(8, 255, isSigned).toString(S, 2, isSigned, true);
+ APInt(8, 255).toString(S, 2, isSigned, true);
EXPECT_EQ(std::string(S), "0b11111111");
S.clear();
- APInt(8, 255, isSigned).toString(S, 8, isSigned, true);
+ APInt(8, 255).toString(S, 8, isSigned, true);
EXPECT_EQ(std::string(S), "0377");
S.clear();
- APInt(8, 255, isSigned).toString(S, 10, isSigned, true);
+ APInt(8, 255).toString(S, 10, isSigned, true);
EXPECT_EQ(std::string(S), "255");
S.clear();
- APInt(8, 255, isSigned).toString(S, 16, isSigned, true, /*UpperCase=*/false);
+ APInt(8, 255).toString(S, 16, isSigned, true, /*UpperCase=*/false);
EXPECT_EQ(std::string(S), "0xff");
S.clear();
- APInt(8, 255, isSigned).toString(S, 16, isSigned, true);
+ APInt(8, 255).toString(S, 16, isSigned, true);
EXPECT_EQ(std::string(S), "0xFF");
S.clear();
- APInt(8, 255, isSigned).toString(S, 36, isSigned, false);
+ APInt(8, 255).toString(S, 36, isSigned, false);
EXPECT_EQ(std::string(S), "73");
S.clear();
isSigned = true;
- APInt(8, 255, isSigned).toString(S, 2, isSigned, true);
+ APInt(8, 255).toString(S, 2, isSigned, true);
EXPECT_EQ(std::string(S), "-0b1");
S.clear();
- APInt(8, 255, isSigned).toString(S, 8, isSigned, true);
+ APInt(8, 255).toString(S, 8, isSigned, true);
EXPECT_EQ(std::string(S), "-01");
S.clear();
- APInt(8, 255, isSigned).toString(S, 10, isSigned, true);
+ APInt(8, 255).toString(S, 10, isSigned, true);
EXPECT_EQ(std::string(S), "-1");
S.clear();
- APInt(8, 255, isSigned).toString(S, 16, isSigned, true);
+ APInt(8, 255).toString(S, 16, isSigned, true);
EXPECT_EQ(std::string(S), "-0x1");
S.clear();
- APInt(8, 255, isSigned).toString(S, 36, isSigned, false);
+ APInt(8, 255).toString(S, 36, isSigned, false);
EXPECT_EQ(std::string(S), "-1");
S.clear();
@@ -1514,7 +1516,7 @@ TEST(APIntTest, Rotate) {
EXPECT_EQ(APInt(32, 2), APInt(32, 1).rotl(APInt(33, 33)));
EXPECT_EQ(APInt(32, (1 << 8)), APInt(32, 1).rotl(APInt(32, 40)));
EXPECT_EQ(APInt(32, (1 << 30)), APInt(32, 1).rotl(APInt(31, 30)));
- EXPECT_EQ(APInt(32, (1 << 31)), APInt(32, 1).rotl(APInt(31, 31)));
+ EXPECT_EQ(APInt(32, (1u << 31)), APInt(32, 1).rotl(APInt(31, 31)));
EXPECT_EQ(APInt(32, 1), APInt(32, 1).rotl(APInt(1, 0)));
EXPECT_EQ(APInt(32, 2), APInt(32, 1).rotl(APInt(1, 1)));
@@ -1541,24 +1543,24 @@ TEST(APIntTest, Rotate) {
EXPECT_EQ(APInt(8, 16), APInt(8, 1).rotr(4));
EXPECT_EQ(APInt(8, 1), APInt(8, 1).rotr(8));
- EXPECT_EQ(APInt(32, (1 << 31)), APInt(32, 1).rotr(33));
- EXPECT_EQ(APInt(32, (1 << 31)), APInt(32, 1).rotr(APInt(32, 33)));
+ EXPECT_EQ(APInt(32, (1u << 31)), APInt(32, 1).rotr(33));
+ EXPECT_EQ(APInt(32, (1u << 31)), APInt(32, 1).rotr(APInt(32, 33)));
- EXPECT_EQ(APInt(32, (1 << 31)), APInt(32, 1).rotr(33));
- EXPECT_EQ(APInt(32, (1 << 31)), APInt(32, 1).rotr(APInt(32, 33)));
- EXPECT_EQ(APInt(32, (1 << 31)), APInt(32, 1).rotr(APInt(33, 33)));
+ EXPECT_EQ(APInt(32, (1u << 31)), APInt(32, 1).rotr(33));
+ EXPECT_EQ(APInt(32, (1u << 31)), APInt(32, 1).rotr(APInt(32, 33)));
+ EXPECT_EQ(APInt(32, (1u << 31)), APInt(32, 1).rotr(APInt(33, 33)));
EXPECT_EQ(APInt(32, (1 << 24)), APInt(32, 1).rotr(APInt(32, 40)));
EXPECT_EQ(APInt(32, (1 << 2)), APInt(32, 1).rotr(APInt(31, 30)));
EXPECT_EQ(APInt(32, (1 << 1)), APInt(32, 1).rotr(APInt(31, 31)));
EXPECT_EQ(APInt(32, 1), APInt(32, 1).rotr(APInt(1, 0)));
- EXPECT_EQ(APInt(32, (1 << 31)), APInt(32, 1).rotr(APInt(1, 1)));
+ EXPECT_EQ(APInt(32, (1u << 31)), APInt(32, 1).rotr(APInt(1, 1)));
EXPECT_EQ(APInt(32, (1 << 28)), APInt(32, 1).rotr(APInt(3, 4)));
EXPECT_EQ(APInt(32, 1), APInt(32, 1).rotr(APInt(64, 64)));
- EXPECT_EQ(APInt(32, (1 << 31)), APInt(32, 1).rotr(APInt(64, 65)));
+ EXPECT_EQ(APInt(32, (1u << 31)), APInt(32, 1).rotr(APInt(64, 65)));
EXPECT_EQ(APInt(7, 48), APInt(7, 3).rotr(APInt(7, 3)));
EXPECT_EQ(APInt(7, 48), APInt(7, 3).rotr(APInt(7, 10)));
@@ -1580,7 +1582,7 @@ TEST(APIntTest, Splat) {
APInt ValB(3, 5);
EXPECT_EQ(APInt(4, 0xD), APInt::getSplat(4, ValB));
- EXPECT_EQ(APInt(15, 0xDB6D), APInt::getSplat(15, ValB));
+ EXPECT_EQ(APInt(15, 0x5B6D), APInt::getSplat(15, ValB));
}
TEST(APIntTest, tcDecrement) {
@@ -2857,7 +2859,7 @@ TEST(APIntTest, sext) {
EXPECT_EQ(31U, i32_min.countr_zero());
EXPECT_EQ(32U, i32_min.popcount());
- APInt i32_neg1(APInt(32, ~uint64_t(0)).sext(63));
+ APInt i32_neg1(APInt(32, ~uint32_t(0)).sext(63));
EXPECT_EQ(i32_neg1, i32_neg1.sext(63));
EXPECT_EQ(63U, i32_neg1.countl_one());
EXPECT_EQ(0U, i32_neg1.countr_zero());
@@ -2990,7 +2992,7 @@ TEST(APIntTest, RoundingUDiv) {
TEST(APIntTest, RoundingSDiv) {
for (int64_t Ai = -128; Ai <= 127; Ai++) {
- APInt A(8, Ai);
+ APInt A(8, Ai, true);
if (Ai != 0) {
APInt Zero(8, 0);
@@ -3003,7 +3005,7 @@ TEST(APIntTest, RoundingSDiv) {
if (Bi == 0)
continue;
- APInt B(8, Bi);
+ APInt B(8, Bi, true);
APInt QuoTowardZero = A.sdiv(B);
{
APInt Quo = APIntOps::RoundingSDiv(A, B, APInt::Rounding::UP);
@@ -3062,10 +3064,10 @@ TEST(APIntTest, Average) {
APInt Ap100(32, +100);
APInt Ap101(32, +101);
APInt Ap200(32, +200);
- APInt Am1(32, -1);
- APInt Am100(32, -100);
- APInt Am101(32, -101);
- APInt Am200(32, -200);
+ APInt Am1(32, -1, true);
+ APInt Am100(32, -100, true);
+ APInt Am101(32, -101, true);
+ APInt Am200(32, -200, true);
APInt AmSMin = APInt::getSignedMinValue(32);
APInt ApSMax = APInt::getSignedMaxValue(32);
@@ -3075,7 +3077,7 @@ TEST(APIntTest, Average) {
EXPECT_EQ(APIntOps::RoundingSDiv(Ap100 + Ap200, A2, APInt::Rounding::UP),
APIntOps::avgCeilS(Ap100, Ap200));
- EXPECT_EQ(APInt(32, -150), APIntOps::avgFloorS(Am100, Am200));
+ EXPECT_EQ(APInt(32, -150, true), APIntOps::avgFloorS(Am100, Am200));
EXPECT_EQ(APIntOps::RoundingSDiv(Am100 + Am200, A2, APInt::Rounding::DOWN),
APIntOps::avgFloorS(Am100, Am200));
EXPECT_EQ(APIntOps::RoundingSDiv(Am100 + Am200, A2, APInt::Rounding::UP),
@@ -3088,10 +3090,10 @@ TEST(APIntTest, Average) {
EXPECT_EQ(APIntOps::RoundingSDiv(Ap100 + Ap101, A2, APInt::Rounding::UP),
APIntOps::avgCeilS(Ap100, Ap101));
- EXPECT_EQ(APInt(32, -101), APIntOps::avgFloorS(Am100, Am101));
+ EXPECT_EQ(APInt(32, -101, true), APIntOps::avgFloorS(Am100, Am101));
EXPECT_EQ(APIntOps::RoundingSDiv(Am100 + Am101, A2, APInt::Rounding::DOWN),
APIntOps::avgFloorS(Am100, Am101));
- EXPECT_EQ(APInt(32, -100), APIntOps::avgCeilS(Am100, Am101));
+ EXPECT_EQ(APInt(32, -100, true), APIntOps::avgCeilS(Am100, Am101));
EXPECT_EQ(APIntOps::RoundingSDiv(Am100 + Am101, A2, APInt::Rounding::UP),
APIntOps::avgCeilS(Am100, Am101));
@@ -3303,7 +3305,8 @@ TEST(APIntTest, SolveQuadraticEquationWrap) {
for (int B = Low; B != High; ++B) {
for (int C = Low; C != High; ++C) {
std::optional<APInt> S = APIntOps::SolveQuadraticEquationWrap(
- APInt(Width, A), APInt(Width, B), APInt(Width, C), Width);
+ APInt(Width, A, true), APInt(Width, B, true),
+ APInt(Width, C, true), Width);
if (S)
Validate(A, B, C, Width, S->getSExtValue());
}
@@ -3398,10 +3401,10 @@ TEST(APIntTest,
GetMostSignificantDifferentBitExaustive) {
}
TEST(APIntTest, SignbitZeroChecks) {
- EXPECT_TRUE(APInt(8, -1).isNegative());
- EXPECT_FALSE(APInt(8, -1).isNonNegative());
- EXPECT_FALSE(APInt(8, -1).isStrictlyPositive());
- EXPECT_TRUE(APInt(8, -1).isNonPositive());
+ EXPECT_TRUE(APInt(8, -1, true).isNegative());
+ EXPECT_FALSE(APInt(8, -1, true).isNonNegative());
+ EXPECT_FALSE(APInt(8, -1, true).isStrictlyPositive());
+ EXPECT_TRUE(APInt(8, -1, true).isNonPositive());
EXPECT_FALSE(APInt(8, 0).isNegative());
EXPECT_TRUE(APInt(8, 0).isNonNegative());
diff --git a/llvm/unittests/ADT/APSIntTest.cpp
b/llvm/unittests/ADT/APSIntTest.cpp
index f804eba3ca83eb..2d2a64433da94d 100644
--- a/llvm/unittests/ADT/APSIntTest.cpp
+++ b/llvm/unittests/ADT/APSIntTest.cpp
@@ -74,14 +74,14 @@ TEST(APSIntTest, getExtValue) {
EXPECT_TRUE(APSInt(APInt(3, 7), false).isSigned());
EXPECT_TRUE(APSInt(APInt(4, 7), true).isUnsigned());
EXPECT_TRUE(APSInt(APInt(4, 7), false).isSigned());
- EXPECT_TRUE(APSInt(APInt(4, -7), true).isUnsigned());
- EXPECT_TRUE(APSInt(APInt(4, -7), false).isSigned());
+ EXPECT_TRUE(APSInt(APInt(4, -7, true), true).isUnsigned());
+ EXPECT_TRUE(APSInt(APInt(4, -7, true), false).isSigned());
EXPECT_EQ(7, APSInt(APInt(3, 7), true).getExtValue());
EXPECT_EQ(-1, APSInt(APInt(3, 7), false).getExtValue());
EXPECT_EQ(7, APSInt(APInt(4, 7), true).getExtValue());
EXPECT_EQ(7, APSInt(APInt(4, 7), false).getExtValue());
- EXPECT_EQ(9, APSInt(APInt(4, -7), true).getExtValue());
- EXPECT_EQ(-7, APSInt(APInt(4, -7), false).getExtValue());
+ EXPECT_EQ(9, APSInt(APInt(4, -7, true), true).getExtValue());
+ EXPECT_EQ(-7, APSInt(APInt(4, -7, true), false).getExtValue());
}
TEST(APSIntTest, tryExtValue) {
ASSERT_EQ(-7, APSInt(APInt(64, -7), false).tryExtValue().value_or(42));
diff --git a/llvm/unittests/ADT/StringExtrasTest.cpp
b/llvm/unittests/ADT/StringExtrasTest.cpp
index 1fb1fea6577911..eb202bad865d30 100644
--- a/llvm/unittests/ADT/StringExtrasTest.cpp
+++ b/llvm/unittests/ADT/StringExtrasTest.cpp
@@ -296,11 +296,11 @@ TEST(StringExtrasTest, toStringAPInt) {
EXPECT_EQ(toString(APInt(8, 255, isSigned), 36, isSigned, false), "73");
isSigned = true;
- EXPECT_EQ(toString(APInt(8, 255, isSigned), 2, isSigned, true), "-0b1");
- EXPECT_EQ(toString(APInt(8, 255, isSigned), 8, isSigned, true), "-01");
- EXPECT_EQ(toString(APInt(8, 255, isSigned), 10, isSigned, true), "-1");
- EXPECT_EQ(toString(APInt(8, 255, isSigned), 16, isSigned, true), "-0x1");
- EXPECT_EQ(toString(APInt(8, 255, isSigned), 36, isSigned, false), "-1");
+ EXPECT_EQ(toString(APInt(8, -1, isSigned), 2, isSigned, true), "-0b1");
+ EXPECT_EQ(toString(APInt(8, -1, isSigned), 8, isSigned, true), "-01");
+ EXPECT_EQ(toString(APInt(8, -1, isSigned), 10, isSigned, true), "-1");
+ EXPECT_EQ(toString(APInt(8, -1, isSigned), 16, isSigned, true), "-0x1");
+ EXPECT_EQ(toString(APInt(8, -1, isSigned), 36, isSigned, false), "-1");
}
TEST(StringExtrasTest, toStringAPSInt) {
diff --git a/llvm/unittests/Analysis/ScalarEvolutionTest.cpp
b/llvm/unittests/Analysis/ScalarEvolutionTest.cpp
index d4d90d80f4cea1..37c61e4e4fa714 100644
--- a/llvm/unittests/Analysis/ScalarEvolutionTest.cpp
+++ b/llvm/unittests/Analysis/ScalarEvolutionTest.cpp
@@ -984,7 +984,7 @@ TEST_F(ScalarEvolutionsTest,
SCEVAddRecFromPHIwithLargeConstantAccum) {
// entry:
BranchInst::Create(LoopBB, EntryBB);
// loop:
- auto *MinInt32 = ConstantInt::get(Context, APInt(32, 0x80000000U, true));
+ auto *MinInt32 = ConstantInt::get(Context, APInt(32, 0x80000000U));
auto *Int32_16 = ConstantInt::get(Context, APInt(32, 16));
auto *Br = BranchInst::Create(
LoopBB, ExitBB, UndefValue::get(Type::getInt1Ty(Context)), LoopBB);
diff --git a/llvm/unittests/IR/ConstantRangeTest.cpp
b/llvm/unittests/IR/ConstantRangeTest.cpp
index 4815117458b9af..e1d9b3e387b200 100644
--- a/llvm/unittests/IR/ConstantRangeTest.cpp
+++ b/llvm/unittests/IR/ConstantRangeTest.cpp
@@ -372,10 +372,10 @@ TEST_F(ConstantRangeTest, GetMinsAndMaxes) {
EXPECT_EQ(Some.getSignedMax(), APInt(16, 0xaa9));
EXPECT_EQ(Wrap.getSignedMax(), APInt(16, INT16_MAX));
- EXPECT_EQ(Full.getSignedMin(), APInt(16, (uint64_t)INT16_MIN));
+ EXPECT_EQ(Full.getSignedMin(), APInt(16, (uint16_t)INT16_MIN));
EXPECT_EQ(One.getSignedMin(), APInt(16, 0xa));
EXPECT_EQ(Some.getSignedMin(), APInt(16, 0xa));
- EXPECT_EQ(Wrap.getSignedMin(), APInt(16, (uint64_t)INT16_MIN));
+ EXPECT_EQ(Wrap.getSignedMin(), APInt(16, (uint16_t)INT16_MIN));
// Found by Klee
EXPECT_EQ(ConstantRange(APInt(4, 7), APInt(4, 0)).getSignedMax(),
@@ -487,7 +487,7 @@ TEST_F(ConstantRangeTest, SExt) {
APInt(20, INT16_MAX + 1, true)));
EXPECT_EQ(ConstantRange(APInt(8, 120), APInt(8, 140)).signExtend(16),
- ConstantRange(APInt(16, -128), APInt(16, 128)));
+ ConstantRange(APInt(16, -128, true), APInt(16, 128)));
EXPECT_EQ(ConstantRange(APInt(16, 0x0200), APInt(16, 0x8000)).signExtend(19),
ConstantRange(APInt(19, 0x0200), APInt(19, 0x8000)));
@@ -516,7 +516,7 @@ TEST_F(ConstantRangeTest, IntersectWith) {
EXPECT_TRUE(LHS.intersectWith(RHS) == LHS);
// previous bug: intersection of [min, 3) and [2, max) should be 2
- LHS = ConstantRange(APInt(32, -2147483646), APInt(32, 3));
+ LHS = ConstantRange(APInt(32, (uint32_t)-2147483646), APInt(32, 3));
RHS = ConstantRange(APInt(32, 2), APInt(32, 2147483646));
EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 2)));
@@ -744,45 +744,51 @@ TEST_F(ConstantRangeTest, AddWithNoWrap) {
EXPECT_NE(Some.addWithNoWrap(Full, OBO::NoSignedWrap), Full);
EXPECT_EQ(Full.addWithNoWrap(ConstantRange(APInt(16, 1), APInt(16, 2)),
OBO::NoSignedWrap),
- ConstantRange(APInt(16, INT16_MIN + 1), APInt(16, INT16_MIN)));
+ ConstantRange(APInt(16, INT16_MIN + 1, true),
+ APInt(16, INT16_MIN, true)));
EXPECT_EQ(ConstantRange(APInt(16, 1), APInt(16, 2))
.addWithNoWrap(Full, OBO::NoSignedWrap),
- ConstantRange(APInt(16, INT16_MIN + 1), APInt(16, INT16_MIN)));
- EXPECT_EQ(Full.addWithNoWrap(ConstantRange(APInt(16, -1), APInt(16, 0)),
+ ConstantRange(APInt(16, INT16_MIN + 1, true),
+ APInt(16, INT16_MIN, true)));
+ EXPECT_EQ(Full.addWithNoWrap(ConstantRange(APInt(16, -1, true), APInt(16,
0)),
OBO::NoSignedWrap),
- ConstantRange(APInt(16, INT16_MIN), APInt(16, INT16_MAX)));
+ ConstantRange(APInt(16, INT16_MIN, true), APInt(16, INT16_MAX)));
EXPECT_EQ(ConstantRange(APInt(8, 100), APInt(8, 120))
.addWithNoWrap(ConstantRange(APInt(8, 120), APInt(8, 123)),
OBO::NoSignedWrap),
ConstantRange(8, false));
- EXPECT_EQ(ConstantRange(APInt(8, -120), APInt(8, -100))
- .addWithNoWrap(ConstantRange(APInt(8, -110), APInt(8, -100)),
- OBO::NoSignedWrap),
+ EXPECT_EQ(ConstantRange(APInt(8, -120, true), APInt(8, -100, true))
+ .addWithNoWrap(
+ ConstantRange(APInt(8, -110, true), APInt(8, -100, true)),
+ OBO::NoSignedWrap),
ConstantRange(8, false));
- EXPECT_EQ(ConstantRange(APInt(8, 0), APInt(8, 101))
- .addWithNoWrap(ConstantRange(APInt(8, -128), APInt(8, 28)),
- OBO::NoSignedWrap),
- ConstantRange(8, true));
- EXPECT_EQ(ConstantRange(APInt(8, 0), APInt(8, 101))
- .addWithNoWrap(ConstantRange(APInt(8, -120), APInt(8, 29)),
- OBO::NoSignedWrap),
- ConstantRange(APInt(8, -120), APInt(8, -128)));
- EXPECT_EQ(ConstantRange(APInt(8, -50), APInt(8, 50))
+ EXPECT_EQ(
+ ConstantRange(APInt(8, 0), APInt(8, 101))
+ .addWithNoWrap(ConstantRange(APInt(8, -128, true), APInt(8, 28)),
+ OBO::NoSignedWrap),
+ ConstantRange(8, true));
+ EXPECT_EQ(
+ ConstantRange(APInt(8, 0), APInt(8, 101))
+ .addWithNoWrap(ConstantRange(APInt(8, -120, true), APInt(8, 29)),
+ OBO::NoSignedWrap),
+ ConstantRange(APInt(8, -120, true), APInt(8, -128, true)));
+ EXPECT_EQ(ConstantRange(APInt(8, -50, true), APInt(8, 50))
.addWithNoWrap(ConstantRange(APInt(8, 10), APInt(8, 20)),
OBO::NoSignedWrap),
- ConstantRange(APInt(8, -40), APInt(8, 69)));
+ ConstantRange(APInt(8, -40, true), APInt(8, 69)));
EXPECT_EQ(ConstantRange(APInt(8, 10), APInt(8, 20))
- .addWithNoWrap(ConstantRange(APInt(8, -50), APInt(8, 50)),
+ .addWithNoWrap(ConstantRange(APInt(8, -50, true), APInt(8,
50)),
OBO::NoSignedWrap),
- ConstantRange(APInt(8, -40), APInt(8, 69)));
- EXPECT_EQ(ConstantRange(APInt(8, 120), APInt(8, -10))
+ ConstantRange(APInt(8, -40, true), APInt(8, 69)));
+ EXPECT_EQ(ConstantRange(APInt(8, 120), APInt(8, -10, true))
.addWithNoWrap(ConstantRange(APInt(8, 5), APInt(8, 20)),
OBO::NoSignedWrap),
ConstantRange(APInt(8, 125), APInt(8, 9)));
- EXPECT_EQ(ConstantRange(APInt(8, 5), APInt(8, 20))
- .addWithNoWrap(ConstantRange(APInt(8, 120), APInt(8, -10)),
- OBO::NoSignedWrap),
- ConstantRange(APInt(8, 125), APInt(8, 9)));
+ EXPECT_EQ(
+ ConstantRange(APInt(8, 5), APInt(8, 20))
+ .addWithNoWrap(ConstantRange(APInt(8, 120), APInt(8, -10, true)),
+ OBO::NoSignedWrap),
+ ConstantRange(APInt(8, 125), APInt(8, 9)));
TestBinaryOpExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
@@ -827,15 +833,15 @@ TEST_F(ConstantRangeTest, AddWithNoWrap) {
EXPECT_EQ(ConstantRange(APInt(8, 10), APInt(8, 20))
.addWithNoWrap(ConstantRange(APInt(8, 50), APInt(8, 200)),
OBO::NoUnsignedWrap),
- ConstantRange(APInt(8, 60), APInt(8, -37)));
- EXPECT_EQ(ConstantRange(APInt(8, 20), APInt(8, -30))
+ ConstantRange(APInt(8, 60), APInt(8, -37, true)));
+ EXPECT_EQ(ConstantRange(APInt(8, 20), APInt(8, -30, true))
.addWithNoWrap(ConstantRange(APInt(8, 5), APInt(8, 20)),
OBO::NoUnsignedWrap),
- ConstantRange(APInt(8, 25), APInt(8, -11)));
+ ConstantRange(APInt(8, 25), APInt(8, -11, true)));
EXPECT_EQ(ConstantRange(APInt(8, 5), APInt(8, 20))
- .addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, -30)),
+ .addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, -30,
true)),
OBO::NoUnsignedWrap),
- ConstantRange(APInt(8, 25), APInt(8, -11)));
+ ConstantRange(APInt(8, 25), APInt(8, -11, true)));
TestBinaryOpExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
@@ -853,7 +859,7 @@ TEST_F(ConstantRangeTest, AddWithNoWrap) {
EXPECT_EQ(ConstantRange(APInt(8, 50), APInt(8, 100))
.addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, 70)),
OBO::NoSignedWrap),
- ConstantRange(APInt(8, 70), APInt(8, -128)));
+ ConstantRange(APInt(8, 70), APInt(8, -128, true)));
EXPECT_EQ(ConstantRange(APInt(8, 50), APInt(8, 100))
.addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, 70)),
OBO::NoUnsignedWrap),
@@ -861,17 +867,17 @@ TEST_F(ConstantRangeTest, AddWithNoWrap) {
EXPECT_EQ(ConstantRange(APInt(8, 50), APInt(8, 100))
.addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, 70)),
OBO::NoUnsignedWrap | OBO::NoSignedWrap),
- ConstantRange(APInt(8, 70), APInt(8, -128)));
+ ConstantRange(APInt(8, 70), APInt(8, -128, true)));
- EXPECT_EQ(ConstantRange(APInt(8, -100), APInt(8, -50))
+ EXPECT_EQ(ConstantRange(APInt(8, -100, true), APInt(8, -50, true))
.addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, 30)),
OBO::NoSignedWrap),
- ConstantRange(APInt(8, -80), APInt(8, -21)));
- EXPECT_EQ(ConstantRange(APInt(8, -100), APInt(8, -50))
+ ConstantRange(APInt(8, -80, true), APInt(8, -21, true)));
+ EXPECT_EQ(ConstantRange(APInt(8, -100, true), APInt(8, -50, true))
.addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, 30)),
OBO::NoUnsignedWrap),
ConstantRange(APInt(8, 176), APInt(8, 235)));
- EXPECT_EQ(ConstantRange(APInt(8, -100), APInt(8, -50))
+ EXPECT_EQ(ConstantRange(APInt(8, -100, true), APInt(8, -50, true))
.addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, 30)),
OBO::NoUnsignedWrap | OBO::NoSignedWrap),
ConstantRange(APInt(8, 176), APInt(8, 235)));
@@ -1004,17 +1010,17 @@ TEST_F(ConstantRangeTest, Multiply) {
ConstantRange(APInt(8, 250), APInt(8, 253)));
// TODO: This should be return [-2, 0]
- EXPECT_EQ(ConstantRange(APInt(8, -2)).multiply(
- ConstantRange(APInt(8, 0), APInt(8, 2))),
- ConstantRange(APInt(8, -2), APInt(8, 1)));
+ EXPECT_EQ(ConstantRange(APInt(8, -2, true))
+ .multiply(ConstantRange(APInt(8, 0), APInt(8, 2))),
+ ConstantRange(APInt(8, -2, true), APInt(8, 1)));
// Multiplication by -1 should give precise results.
- EXPECT_EQ(ConstantRange(APInt(8, 3), APInt(8, -11))
- .multiply(ConstantRange(APInt(8, -1))),
- ConstantRange(APInt(8, 12), APInt(8, -2)));
- EXPECT_EQ(ConstantRange(APInt(8, -1))
- .multiply(ConstantRange(APInt(8, 3), APInt(8, -11))),
- ConstantRange(APInt(8, 12), APInt(8, -2)));
+ EXPECT_EQ(ConstantRange(APInt(8, 3), APInt(8, -11, true))
+ .multiply(ConstantRange(APInt(8, -1, true))),
+ ConstantRange(APInt(8, 12), APInt(8, -2, true)));
+ EXPECT_EQ(ConstantRange(APInt(8, -1, true))
+ .multiply(ConstantRange(APInt(8, 3), APInt(8, -11, true))),
+ ConstantRange(APInt(8, 12), APInt(8, -2, true)));
TestBinaryOpExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
@@ -1185,11 +1191,11 @@ TEST_F(ConstantRangeTest, SMax) {
EXPECT_EQ(Empty.smax(Wrap), Empty);
EXPECT_EQ(Empty.smax(One), Empty);
EXPECT_EQ(Some.smax(Some), Some);
- EXPECT_EQ(Some.smax(Wrap), ConstantRange(APInt(16, 0xa),
- APInt(16, (uint64_t)INT16_MIN)));
+ EXPECT_EQ(Some.smax(Wrap),
+ ConstantRange(APInt(16, 0xa), APInt(16, (uint16_t)INT16_MIN)));
EXPECT_EQ(Some.smax(One), Some);
- EXPECT_EQ(Wrap.smax(One), ConstantRange(APInt(16, 0xa),
- APInt(16, (uint64_t)INT16_MIN)));
+ EXPECT_EQ(Wrap.smax(One),
+ ConstantRange(APInt(16, 0xa), APInt(16, (uint16_t)INT16_MIN)));
EXPECT_EQ(One.smax(One), One);
TestBinaryOpExhaustive(
@@ -1231,20 +1237,20 @@ TEST_F(ConstantRangeTest, UMin) {
TEST_F(ConstantRangeTest, SMin) {
EXPECT_EQ(Full.smin(Full), Full);
EXPECT_EQ(Full.smin(Empty), Empty);
- EXPECT_EQ(Full.smin(Some), ConstantRange(APInt(16, (uint64_t)INT16_MIN),
- APInt(16, 0xaaa)));
+ EXPECT_EQ(Full.smin(Some),
+ ConstantRange(APInt(16, (uint16_t)INT16_MIN), APInt(16, 0xaaa)));
EXPECT_EQ(Full.smin(Wrap), Full);
EXPECT_EQ(Empty.smin(Empty), Empty);
EXPECT_EQ(Empty.smin(Some), Empty);
EXPECT_EQ(Empty.smin(Wrap), Empty);
EXPECT_EQ(Empty.smin(One), Empty);
EXPECT_EQ(Some.smin(Some), Some);
- EXPECT_EQ(Some.smin(Wrap), ConstantRange(APInt(16, (uint64_t)INT16_MIN),
- APInt(16, 0xaaa)));
+ EXPECT_EQ(Some.smin(Wrap),
+ ConstantRange(APInt(16, (uint16_t)INT16_MIN), APInt(16, 0xaaa)));
EXPECT_EQ(Some.smin(One), One);
EXPECT_EQ(Wrap.smin(Wrap), Wrap);
- EXPECT_EQ(Wrap.smin(One), ConstantRange(APInt(16, (uint64_t)INT16_MIN),
- APInt(16, 0xb)));
+ EXPECT_EQ(Wrap.smin(One),
+ ConstantRange(APInt(16, (uint16_t)INT16_MIN), APInt(16, 0xb)));
EXPECT_EQ(One.smin(One), One);
TestBinaryOpExhaustive(
@@ -1320,8 +1326,8 @@ TEST_F(ConstantRangeTest, SDiv) {
}
// If there is a non-full signed envelope, that should be the result.
- APInt SMin(Bits, Results.find_first() - Bias);
- APInt SMax(Bits, Results.find_last() - Bias);
+ APInt SMin(Bits, Results.find_first() - Bias, true);
+ APInt SMax(Bits, Results.find_last() - Bias, true);
ConstantRange Envelope = ConstantRange::getNonEmpty(SMin, SMax + 1);
if (!Envelope.isFullSet()) {
EXPECT_EQ(Envelope, CR);
@@ -1340,8 +1346,8 @@ TEST_F(ConstantRangeTest, SDiv) {
--LastPos;
}
- APInt WMax(Bits, LastNeg);
- APInt WMin(Bits, LastPos);
+ APInt WMax(Bits, LastNeg, true);
+ APInt WMin(Bits, LastPos, true);
ConstantRange Wrapped = ConstantRange::getNonEmpty(WMin, WMax + 1);
EXPECT_EQ(Wrapped, CR);
});
@@ -1394,8 +1400,8 @@ TEST_F(ConstantRangeTest, SRem) {
EXPECT_EQ(Full.srem(Full), ConstantRange(APInt::getSignedMinValue(16) + 1,
APInt::getSignedMinValue(16)));
- ConstantRange PosMod(APInt(16, 10), APInt(16, 21)); // [10, 20]
- ConstantRange NegMod(APInt(16, -20), APInt(16, -9)); // [-20, -10]
+ ConstantRange PosMod(APInt(16, 10), APInt(16, 21)); // [10, 20]
+ ConstantRange NegMod(APInt(16, -20, true), APInt(16, -9, true)); // [-20,
-10]
ConstantRange IntMinMod(APInt::getSignedMinValue(16));
ConstantRange Expected(16, true);
@@ -1405,12 +1411,12 @@ TEST_F(ConstantRangeTest, SRem) {
Expected = ConstantRange(APInt(16, 0), APInt(16, 20));
EXPECT_EQ(PosLargeLHS.srem(PosMod), Expected);
EXPECT_EQ(PosLargeLHS.srem(NegMod), Expected);
- ConstantRange NegLargeLHS(APInt(16, -40), APInt(16, 1));
- Expected = ConstantRange(APInt(16, -19), APInt(16, 1));
+ ConstantRange NegLargeLHS(APInt(16, -40, true), APInt(16, 1));
+ Expected = ConstantRange(APInt(16, -19, true), APInt(16, 1));
EXPECT_EQ(NegLargeLHS.srem(PosMod), Expected);
EXPECT_EQ(NegLargeLHS.srem(NegMod), Expected);
- ConstantRange PosNegLargeLHS(APInt(16, -32), APInt(16, 38));
- Expected = ConstantRange(APInt(16, -19), APInt(16, 20));
+ ConstantRange PosNegLargeLHS(APInt(16, -32, true), APInt(16, 38));
+ Expected = ConstantRange(APInt(16, -19, true), APInt(16, 20));
EXPECT_EQ(PosNegLargeLHS.srem(PosMod), Expected);
EXPECT_EQ(PosNegLargeLHS.srem(NegMod), Expected);
@@ -1419,11 +1425,11 @@ TEST_F(ConstantRangeTest, SRem) {
EXPECT_EQ(PosLHS.srem(PosMod), PosLHS);
EXPECT_EQ(PosLHS.srem(NegMod), PosLHS);
EXPECT_EQ(PosLHS.srem(IntMinMod), PosLHS);
- ConstantRange NegLHS(APInt(16, -15), APInt(16, 1));
+ ConstantRange NegLHS(APInt(16, -15, true), APInt(16, 1));
EXPECT_EQ(NegLHS.srem(PosMod), NegLHS);
EXPECT_EQ(NegLHS.srem(NegMod), NegLHS);
EXPECT_EQ(NegLHS.srem(IntMinMod), NegLHS);
- ConstantRange PosNegLHS(APInt(16, -12), APInt(16, 18));
+ ConstantRange PosNegLHS(APInt(16, -12, true), APInt(16, 18));
EXPECT_EQ(PosNegLHS.srem(PosMod), PosNegLHS);
EXPECT_EQ(PosNegLHS.srem(NegMod), PosNegLHS);
EXPECT_EQ(PosNegLHS.srem(IntMinMod), PosNegLHS);
@@ -1433,11 +1439,11 @@ TEST_F(ConstantRangeTest, SRem) {
EXPECT_EQ(PosSmallLHS.srem(PosMod), PosSmallLHS);
EXPECT_EQ(PosSmallLHS.srem(NegMod), PosSmallLHS);
EXPECT_EQ(PosSmallLHS.srem(IntMinMod), PosSmallLHS);
- ConstantRange NegSmallLHS(APInt(16, -7), APInt(16, -2));
+ ConstantRange NegSmallLHS(APInt(16, -7, true), APInt(16, -2, true));
EXPECT_EQ(NegSmallLHS.srem(PosMod), NegSmallLHS);
EXPECT_EQ(NegSmallLHS.srem(NegMod), NegSmallLHS);
EXPECT_EQ(NegSmallLHS.srem(IntMinMod), NegSmallLHS);
- ConstantRange PosNegSmallLHS(APInt(16, -3), APInt(16, 8));
+ ConstantRange PosNegSmallLHS(APInt(16, -3, true), APInt(16, 8));
EXPECT_EQ(PosNegSmallLHS.srem(PosMod), PosNegSmallLHS);
EXPECT_EQ(PosNegSmallLHS.srem(NegMod), PosNegSmallLHS);
EXPECT_EQ(PosNegSmallLHS.srem(IntMinMod), PosNegSmallLHS);
@@ -1554,27 +1560,27 @@ TEST_F(ConstantRangeTest, ShlWithNoWrap) {
EXPECT_EQ(One.shlWithNoWrap(Full, OBO::NoSignedWrap),
ConstantRange(APInt(16, 10), APInt(16, 20481)));
EXPECT_EQ(One.shlWithNoWrap(Full, OBO::NoUnsignedWrap),
- ConstantRange(APInt(16, 10), APInt(16, -24575)));
+ ConstantRange(APInt(16, 10), APInt(16, -24575, true)));
EXPECT_EQ(One.shlWithNoWrap(Full, OBO::NoSignedWrap | OBO::NoUnsignedWrap),
ConstantRange(APInt(16, 10), APInt(16, 20481)));
ConstantRange NegOne(APInt(16, 0xffff));
EXPECT_EQ(NegOne.shlWithNoWrap(Full, OBO::NoSignedWrap),
- ConstantRange(APInt(16, -32768), APInt(16, 0)));
+ ConstantRange(APInt(16, -32768, true), APInt(16, 0)));
EXPECT_EQ(NegOne.shlWithNoWrap(Full, OBO::NoUnsignedWrap), NegOne);
EXPECT_EQ(ConstantRange(APInt(16, 768))
.shlWithNoWrap(Full, OBO::NoSignedWrap | OBO::NoUnsignedWrap),
ConstantRange(APInt(16, 768), APInt(16, 24577)));
EXPECT_EQ(Full.shlWithNoWrap(ConstantRange(APInt(16, 1), APInt(16, 16)),
OBO::NoUnsignedWrap),
- ConstantRange(APInt(16, 0), APInt(16, -1)));
- EXPECT_EQ(ConstantRange(APInt(4, 3), APInt(4, -8))
+ ConstantRange(APInt(16, 0), APInt(16, -1, true)));
+ EXPECT_EQ(ConstantRange(APInt(4, 3), APInt(4, -8, true))
.shlWithNoWrap(ConstantRange(APInt(4, 0), APInt(4, 4)),
OBO::NoSignedWrap),
- ConstantRange(APInt(4, 3), APInt(4, -8)));
- EXPECT_EQ(ConstantRange(APInt(4, -1), APInt(4, 0))
+ ConstantRange(APInt(4, 3), APInt(4, -8, true)));
+ EXPECT_EQ(ConstantRange(APInt(4, -1, true), APInt(4, 0))
.shlWithNoWrap(ConstantRange(APInt(4, 1), APInt(4, 4)),
OBO::NoSignedWrap),
- ConstantRange(APInt(4, -8), APInt(4, -1)));
+ ConstantRange(APInt(4, -8, true), APInt(4, -1, true)));
}
TEST_F(ConstantRangeTest, Lshr) {
@@ -1620,9 +1626,9 @@ TEST_F(ConstantRangeTest, Ashr) {
APInt(16, (0xaaa >> 0xa) + 1)));
EXPECT_EQ(Some.ashr(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
EXPECT_EQ(Wrap.ashr(Wrap), Full);
- ConstantRange Neg(APInt(16, 0xf3f0, true), APInt(16, 0xf7f8, true));
- EXPECT_EQ(Neg.ashr(Small), ConstantRange(APInt(16, 0xfffc, true),
- APInt(16, 0xfffe, true)));
+ ConstantRange Neg(APInt(16, 0xf3f0), APInt(16, 0xf7f8));
+ EXPECT_EQ(Neg.ashr(Small),
+ ConstantRange(APInt(16, 0xfffc), APInt(16, 0xfffe)));
}
TEST(ConstantRange, MakeAllowedICmpRegion) {
@@ -1665,23 +1671,23 @@ TEST(ConstantRange, MakeSatisfyingICmpRegion) {
UnsignedSample),
ConstantRange(APInt(8, 199), APInt(8, 0)));
- ConstantRange SignedSample(APInt(8, -5), APInt(8, 5));
+ ConstantRange SignedSample(APInt(8, -5, true), APInt(8, 5));
EXPECT_EQ(
ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_SLT,
SignedSample),
- ConstantRange(APInt(8, -128), APInt(8, -5)));
+ ConstantRange(APInt(8, -128, true), APInt(8, -5, true)));
EXPECT_EQ(
ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_SLE,
SignedSample),
- ConstantRange(APInt(8, -128), APInt(8, -4)));
+ ConstantRange(APInt(8, -128, true), APInt(8, -4, true)));
EXPECT_EQ(
ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_SGT,
SignedSample),
- ConstantRange(APInt(8, 5), APInt(8, -128)));
+ ConstantRange(APInt(8, 5), APInt(8, -128, true)));
EXPECT_EQ(
ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_SGE,
SignedSample),
- ConstantRange(APInt(8, 4), APInt(8, -128)));
+ ConstantRange(APInt(8, 4), APInt(8, -128, true)));
}
void ICmpTestImpl(CmpInst::Predicate Pred) {
@@ -1703,7 +1709,7 @@ TEST(ConstantRange, ICmp) {
}
TEST(ConstantRange, MakeGuaranteedNoWrapRegion) {
- const int IntMin4Bits = 8;
+ const int IntMin4Bits = -8;
const int IntMax4Bits = 7;
typedef OverflowingBinaryOperator OBO;
@@ -1812,7 +1818,7 @@ TEST(ConstantRange, MakeGuaranteedNoWrapRegion) {
Instruction::Sub, OneToFive, OBO::NoUnsignedWrap),
ConstantRange(APInt::getMinValue(32) + 5, APInt::getMinValue(32)));
- ConstantRange MinusFiveToMinusTwo(APInt(32, -5), APInt(32, -1));
+ ConstantRange MinusFiveToMinusTwo(APInt(32, -5, true), APInt(32, -1, true));
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Add, MinusFiveToMinusTwo, OBO::NoSignedWrap),
ConstantRange(APInt::getSignedMinValue(32) + 5,
@@ -1826,10 +1832,9 @@ TEST(ConstantRange, MakeGuaranteedNoWrapRegion) {
APInt::getSignedMaxValue(32) - 4));
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Sub, MinusFiveToMinusTwo, OBO::NoUnsignedWrap),
- ConstantRange(APInt::getMaxValue(32) - 1,
- APInt::getMinValue(32)));
+ ConstantRange(APInt::getMaxValue(32) - 1, APInt::getMinValue(32)));
- ConstantRange MinusOneToOne(APInt(32, -1), APInt(32, 2));
+ ConstantRange MinusOneToOne(APInt(32, -1, true), APInt(32, 2));
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Add, MinusOneToOne, OBO::NoSignedWrap),
ConstantRange(APInt::getSignedMinValue(32) + 1,
@@ -1877,7 +1882,7 @@ TEST(ConstantRange, MakeGuaranteedNoWrapRegion) {
ConstantRange(APInt(32, 0), APInt(32, 1) + 1));
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl, UpToBitWidth, OBO::NoSignedWrap),
- ConstantRange(APInt(32, -1), APInt(32, 0) + 1));
+ ConstantRange(APInt(32, -1, true), APInt(32, 0) + 1));
EXPECT_EQ(
ConstantRange::makeGuaranteedNoWrapRegion(
@@ -1898,34 +1903,36 @@ TEST(ConstantRange, MakeGuaranteedNoWrapRegion) {
Instruction::Shl, IllegalShAmt, OBO::NoSignedWrap),
ConstantRange::getFull(32));
- EXPECT_EQ(
- ConstantRange::makeGuaranteedNoWrapRegion(
- Instruction::Shl, ConstantRange(APInt(32, -32), APInt(32, 16) + 1),
- OBO::NoUnsignedWrap),
- ConstantRange::makeGuaranteedNoWrapRegion(
- Instruction::Shl, ConstantRange(APInt(32, 0), APInt(32, 16) + 1),
- OBO::NoUnsignedWrap));
- EXPECT_EQ(
- ConstantRange::makeGuaranteedNoWrapRegion(
- Instruction::Shl, ConstantRange(APInt(32, -32), APInt(32, 16) + 1),
- OBO::NoSignedWrap),
- ConstantRange::makeGuaranteedNoWrapRegion(
- Instruction::Shl, ConstantRange(APInt(32, 0), APInt(32, 16) + 1),
- OBO::NoSignedWrap));
+ EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
+ Instruction::Shl,
+ ConstantRange(APInt(32, -32, true), APInt(32, 16) + 1),
+ OBO::NoUnsignedWrap),
+ ConstantRange::makeGuaranteedNoWrapRegion(
+ Instruction::Shl,
+ ConstantRange(APInt(32, 0), APInt(32, 16) + 1),
+ OBO::NoUnsignedWrap));
+ EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
+ Instruction::Shl,
+ ConstantRange(APInt(32, -32, true), APInt(32, 16) + 1),
+ OBO::NoSignedWrap),
+ ConstantRange::makeGuaranteedNoWrapRegion(
+ Instruction::Shl,
+ ConstantRange(APInt(32, 0), APInt(32, 16) + 1),
+ OBO::NoSignedWrap));
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl,
- ConstantRange(APInt(32, -32), APInt(32, 16) + 1),
+ ConstantRange(APInt(32, -32, true), APInt(32, 16) + 1),
OBO::NoUnsignedWrap),
ConstantRange(APInt(32, 0), APInt(32, 65535) + 1));
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl,
- ConstantRange(APInt(32, -32), APInt(32, 16) + 1),
+ ConstantRange(APInt(32, -32, true), APInt(32, 16) + 1),
OBO::NoSignedWrap),
- ConstantRange(APInt(32, -32768), APInt(32, 32767) + 1));
+ ConstantRange(APInt(32, -32768, true), APInt(32, 32767) + 1));
}
-template<typename Fn>
+template <typename Fn>
void TestNoWrapRegionExhaustive(Instruction::BinaryOps BinOp,
unsigned NoWrapKind, Fn OverflowFn) {
for (unsigned Bits : {1, 5}) {
@@ -2090,14 +2097,15 @@ TEST(ConstantRange, GetEquivalentICmp) {
EXPECT_EQ(Pred, CmpInst::ICMP_NE);
EXPECT_EQ(RHS, APInt(32, 0));
- EXPECT_TRUE(ConstantRange(APInt(32, -1)).getEquivalentICmp(Pred, RHS));
+ EXPECT_TRUE(ConstantRange(APInt(32, -1, true)).getEquivalentICmp(Pred, RHS));
EXPECT_EQ(Pred, CmpInst::ICMP_EQ);
- EXPECT_EQ(RHS, APInt(32, -1));
+ EXPECT_EQ(RHS, APInt(32, -1, true));
- EXPECT_TRUE(
- ConstantRange(APInt(32, -1)).inverse().getEquivalentICmp(Pred, RHS));
+ EXPECT_TRUE(ConstantRange(APInt(32, -1, true))
+ .inverse()
+ .getEquivalentICmp(Pred, RHS));
EXPECT_EQ(Pred, CmpInst::ICMP_NE);
- EXPECT_EQ(RHS, APInt(32, -1));
+ EXPECT_EQ(RHS, APInt(32, -1, true));
EnumerateInterestingConstantRanges([](const ConstantRange &CR) {
unsigned Bits = CR.getBitWidth();
diff --git a/llvm/unittests/IR/MetadataTest.cpp
b/llvm/unittests/IR/MetadataTest.cpp
index 17573ca57e0874..821d6f44e521d7 100644
--- a/llvm/unittests/IR/MetadataTest.cpp
+++ b/llvm/unittests/IR/MetadataTest.cpp
@@ -4224,16 +4224,18 @@ TEST_F(DIExpressionTest, foldConstant) {
DIExpression *Expr;
DIExpression *NewExpr;
-#define EXPECT_FOLD_CONST(StartWidth, StartValue, EndWidth, EndValue, NumElts)
\
- Int = ConstantInt::get(Context, APInt(StartWidth, StartValue));
\
- std::tie(NewExpr, NewInt) = Expr->constantFold(Int);
\
- ASSERT_EQ(NewInt->getBitWidth(), EndWidth##u);
\
- EXPECT_EQ(NewInt->getValue(), APInt(EndWidth, EndValue));
\
+#define EXPECT_FOLD_CONST(StartWidth, StartValue, StartIsSigned, EndWidth,
\
+ EndValue, EndIsSigned, NumElts)
\
+ Int =
\
+ ConstantInt::get(Context, APInt(StartWidth, StartValue, StartIsSigned));
\
+ std::tie(NewExpr, NewInt) = Expr->constantFold(Int);
\
+ ASSERT_EQ(NewInt->getBitWidth(), EndWidth##u);
\
+ EXPECT_EQ(NewInt->getValue(), APInt(EndWidth, EndValue, EndIsSigned));
\
EXPECT_EQ(NewExpr->getNumElements(), NumElts##u)
// Unfoldable expression should return the original unmodified Int/Expr.
Expr = DIExpression::get(Context, {dwarf::DW_OP_deref});
- EXPECT_FOLD_CONST(32, 117, 32, 117, 1);
+ EXPECT_FOLD_CONST(32, 117, false, 32, 117, false, 1);
EXPECT_EQ(NewExpr, Expr);
EXPECT_EQ(NewInt, Int);
EXPECT_TRUE(NewExpr->startsWithDeref());
@@ -4241,18 +4243,18 @@ TEST_F(DIExpressionTest, foldConstant) {
// One unsigned bit-width conversion.
Expr = DIExpression::get(
Context, {dwarf::DW_OP_LLVM_convert, 72, dwarf::DW_ATE_unsigned});
- EXPECT_FOLD_CONST(8, 12, 72, 12, 0);
+ EXPECT_FOLD_CONST(8, 12, false, 72, 12, false, 0);
// Two unsigned bit-width conversions (mask truncation).
Expr = DIExpression::get(
Context, {dwarf::DW_OP_LLVM_convert, 8, dwarf::DW_ATE_unsigned,
dwarf::DW_OP_LLVM_convert, 16, dwarf::DW_ATE_unsigned});
- EXPECT_FOLD_CONST(32, -1, 16, 0xff, 0);
+ EXPECT_FOLD_CONST(32, -1, true, 16, 0xff, false, 0);
// Sign extension.
Expr = DIExpression::get(
Context, {dwarf::DW_OP_LLVM_convert, 32, dwarf::DW_ATE_signed});
- EXPECT_FOLD_CONST(16, -1, 32, -1, 0);
+ EXPECT_FOLD_CONST(16, -1, true, 32, -1, true, 0);
// Get non-foldable operations back in the new Expr.
uint64_t Elements[] = {dwarf::DW_OP_deref, dwarf::DW_OP_stack_value};
@@ -4261,7 +4263,7 @@ TEST_F(DIExpressionTest, foldConstant) {
Context, {dwarf::DW_OP_LLVM_convert, 32, dwarf::DW_ATE_signed});
Expr = DIExpression::append(Expr, Expected);
ASSERT_EQ(Expr->getNumElements(), 5u);
- EXPECT_FOLD_CONST(16, -1, 32, -1, 2);
+ EXPECT_FOLD_CONST(16, -1, true, 32, -1, true, 2);
EXPECT_EQ(NewExpr->getElements(), Expected);
#undef EXPECT_FOLD_CONST
diff --git a/llvm/unittests/IR/PatternMatch.cpp
b/llvm/unittests/IR/PatternMatch.cpp
index 379f97fb63139f..13f121a2b9c7dd 100644
--- a/llvm/unittests/IR/PatternMatch.cpp
+++ b/llvm/unittests/IR/PatternMatch.cpp
@@ -71,7 +71,7 @@ TEST_F(PatternMatchTest, SpecificIntEQ) {
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
- Value *NegOne = ConstantInt::get(IntTy, -1);
+ Value *NegOne = Constant::getAllOnesValue(IntTy);
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 0))
@@ -93,15 +93,15 @@ TEST_F(PatternMatchTest, SpecificIntEQ) {
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 1))
.match(NegOne));
- EXPECT_FALSE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, -1))
- .match(Zero));
- EXPECT_FALSE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, -1))
- .match(One));
- EXPECT_TRUE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, -1))
- .match(NegOne));
+ EXPECT_FALSE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ,
+ APInt::getAllOnes(BitWidth))
+ .match(Zero));
+ EXPECT_FALSE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ,
+ APInt::getAllOnes(BitWidth))
+ .match(One));
+ EXPECT_TRUE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ,
+ APInt::getAllOnes(BitWidth))
+ .match(NegOne));
}
TEST_F(PatternMatchTest, SpecificIntNE) {
@@ -110,7 +110,7 @@ TEST_F(PatternMatchTest, SpecificIntNE) {
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
- Value *NegOne = ConstantInt::get(IntTy, -1);
+ Value *NegOne = Constant::getAllOnesValue(IntTy);
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 0))
@@ -132,15 +132,15 @@ TEST_F(PatternMatchTest, SpecificIntNE) {
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 1))
.match(NegOne));
- EXPECT_TRUE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, -1))
- .match(Zero));
- EXPECT_TRUE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, -1))
- .match(One));
- EXPECT_FALSE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, -1))
- .match(NegOne));
+ EXPECT_TRUE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE,
+ APInt::getAllOnes(BitWidth))
+ .match(Zero));
+ EXPECT_TRUE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE,
+ APInt::getAllOnes(BitWidth))
+ .match(One));
+ EXPECT_FALSE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE,
+ APInt::getAllOnes(BitWidth))
+ .match(NegOne));
}
TEST_F(PatternMatchTest, SpecificIntUGT) {
@@ -149,7 +149,7 @@ TEST_F(PatternMatchTest, SpecificIntUGT) {
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
- Value *NegOne = ConstantInt::get(IntTy, -1);
+ Value *NegOne = Constant::getAllOnesValue(IntTy);
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 0))
@@ -171,15 +171,15 @@ TEST_F(PatternMatchTest, SpecificIntUGT) {
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 1))
.match(NegOne));
- EXPECT_FALSE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, -1))
- .match(Zero));
- EXPECT_FALSE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, -1))
- .match(One));
- EXPECT_FALSE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, -1))
- .match(NegOne));
+ EXPECT_FALSE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT,
+ APInt::getAllOnes(BitWidth))
+ .match(Zero));
+ EXPECT_FALSE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT,
+ APInt::getAllOnes(BitWidth))
+ .match(One));
+ EXPECT_FALSE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT,
+ APInt::getAllOnes(BitWidth))
+ .match(NegOne));
}
TEST_F(PatternMatchTest, SignbitZeroChecks) {
@@ -187,7 +187,7 @@ TEST_F(PatternMatchTest, SignbitZeroChecks) {
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
- Value *NegOne = ConstantInt::get(IntTy, -1);
+ Value *NegOne = Constant::getAllOnesValue(IntTy);
EXPECT_TRUE(m_Negative().match(NegOne));
EXPECT_FALSE(m_NonNegative().match(NegOne));
@@ -211,7 +211,7 @@ TEST_F(PatternMatchTest, SpecificIntUGE) {
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
- Value *NegOne = ConstantInt::get(IntTy, -1);
+ Value *NegOne = Constant::getAllOnesValue(IntTy);
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 0))
@@ -233,15 +233,15 @@ TEST_F(PatternMatchTest, SpecificIntUGE) {
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 1))
.match(NegOne));
- EXPECT_FALSE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, -1))
- .match(Zero));
- EXPECT_FALSE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, -1))
- .match(One));
- EXPECT_TRUE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, -1))
- .match(NegOne));
+ EXPECT_FALSE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE,
+ APInt::getAllOnes(BitWidth))
+ .match(Zero));
+ EXPECT_FALSE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE,
+ APInt::getAllOnes(BitWidth))
+ .match(One));
+ EXPECT_TRUE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE,
+ APInt::getAllOnes(BitWidth))
+ .match(NegOne));
}
TEST_F(PatternMatchTest, SpecificIntULT) {
@@ -250,7 +250,7 @@ TEST_F(PatternMatchTest, SpecificIntULT) {
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
- Value *NegOne = ConstantInt::get(IntTy, -1);
+ Value *NegOne = Constant::getAllOnesValue(IntTy);
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 0))
@@ -272,15 +272,15 @@ TEST_F(PatternMatchTest, SpecificIntULT) {
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 1))
.match(NegOne));
- EXPECT_TRUE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, -1))
- .match(Zero));
- EXPECT_TRUE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, -1))
- .match(One));
- EXPECT_FALSE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, -1))
- .match(NegOne));
+ EXPECT_TRUE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT,
+ APInt::getAllOnes(BitWidth))
+ .match(Zero));
+ EXPECT_TRUE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT,
+ APInt::getAllOnes(BitWidth))
+ .match(One));
+ EXPECT_FALSE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT,
+ APInt::getAllOnes(BitWidth))
+ .match(NegOne));
}
TEST_F(PatternMatchTest, SpecificIntULE) {
@@ -289,7 +289,7 @@ TEST_F(PatternMatchTest, SpecificIntULE) {
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
- Value *NegOne = ConstantInt::get(IntTy, -1);
+ Value *NegOne = Constant::getAllOnesValue(IntTy);
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 0))
@@ -311,15 +311,15 @@ TEST_F(PatternMatchTest, SpecificIntULE) {
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 1))
.match(NegOne));
- EXPECT_TRUE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, -1))
- .match(Zero));
- EXPECT_TRUE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, -1))
- .match(One));
- EXPECT_TRUE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, -1))
- .match(NegOne));
+ EXPECT_TRUE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE,
+ APInt::getAllOnes(BitWidth))
+ .match(Zero));
+ EXPECT_TRUE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE,
+ APInt::getAllOnes(BitWidth))
+ .match(One));
+ EXPECT_TRUE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE,
+ APInt::getAllOnes(BitWidth))
+ .match(NegOne));
}
TEST_F(PatternMatchTest, SpecificIntSGT) {
@@ -328,7 +328,7 @@ TEST_F(PatternMatchTest, SpecificIntSGT) {
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
- Value *NegOne = ConstantInt::get(IntTy, -1);
+ Value *NegOne = Constant::getAllOnesValue(IntTy);
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 0))
@@ -350,15 +350,15 @@ TEST_F(PatternMatchTest, SpecificIntSGT) {
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 1))
.match(NegOne));
- EXPECT_TRUE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, -1))
- .match(Zero));
- EXPECT_TRUE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, -1))
- .match(One));
- EXPECT_FALSE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, -1))
- .match(NegOne));
+ EXPECT_TRUE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT,
+ APInt::getAllOnes(BitWidth))
+ .match(Zero));
+ EXPECT_TRUE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT,
+ APInt::getAllOnes(BitWidth))
+ .match(One));
+ EXPECT_FALSE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT,
+ APInt::getAllOnes(BitWidth))
+ .match(NegOne));
}
TEST_F(PatternMatchTest, SpecificIntSGE) {
@@ -367,7 +367,7 @@ TEST_F(PatternMatchTest, SpecificIntSGE) {
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
- Value *NegOne = ConstantInt::get(IntTy, -1);
+ Value *NegOne = Constant::getAllOnesValue(IntTy);
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 0))
@@ -389,15 +389,15 @@ TEST_F(PatternMatchTest, SpecificIntSGE) {
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 1))
.match(NegOne));
- EXPECT_TRUE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, -1))
- .match(Zero));
- EXPECT_TRUE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, -1))
- .match(One));
- EXPECT_TRUE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, -1))
- .match(NegOne));
+ EXPECT_TRUE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE,
+ APInt::getAllOnes(BitWidth))
+ .match(Zero));
+ EXPECT_TRUE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE,
+ APInt::getAllOnes(BitWidth))
+ .match(One));
+ EXPECT_TRUE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE,
+ APInt::getAllOnes(BitWidth))
+ .match(NegOne));
}
TEST_F(PatternMatchTest, SpecificIntSLT) {
@@ -406,7 +406,7 @@ TEST_F(PatternMatchTest, SpecificIntSLT) {
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
- Value *NegOne = ConstantInt::get(IntTy, -1);
+ Value *NegOne = Constant::getAllOnesValue(IntTy);
EXPECT_FALSE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 0))
@@ -428,15 +428,15 @@ TEST_F(PatternMatchTest, SpecificIntSLT) {
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 1))
.match(NegOne));
- EXPECT_FALSE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, -1))
- .match(Zero));
- EXPECT_FALSE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, -1))
- .match(One));
- EXPECT_FALSE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, -1))
- .match(NegOne));
+ EXPECT_FALSE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT,
+ APInt::getAllOnes(BitWidth))
+ .match(Zero));
+ EXPECT_FALSE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT,
+ APInt::getAllOnes(BitWidth))
+ .match(One));
+ EXPECT_FALSE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT,
+ APInt::getAllOnes(BitWidth))
+ .match(NegOne));
}
TEST_F(PatternMatchTest, SpecificIntSLE) {
@@ -445,7 +445,7 @@ TEST_F(PatternMatchTest, SpecificIntSLE) {
Value *Zero = ConstantInt::get(IntTy, 0);
Value *One = ConstantInt::get(IntTy, 1);
- Value *NegOne = ConstantInt::get(IntTy, -1);
+ Value *NegOne = Constant::getAllOnesValue(IntTy);
EXPECT_TRUE(
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 0))
@@ -467,15 +467,15 @@ TEST_F(PatternMatchTest, SpecificIntSLE) {
m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 1))
.match(NegOne));
- EXPECT_FALSE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, -1))
- .match(Zero));
- EXPECT_FALSE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, -1))
- .match(One));
- EXPECT_TRUE(
- m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, -1))
- .match(NegOne));
+ EXPECT_FALSE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE,
+ APInt::getAllOnes(BitWidth))
+ .match(Zero));
+ EXPECT_FALSE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE,
+ APInt::getAllOnes(BitWidth))
+ .match(One));
+ EXPECT_TRUE(m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE,
+ APInt::getAllOnes(BitWidth))
+ .match(NegOne));
}
TEST_F(PatternMatchTest, Unless) {
diff --git a/llvm/unittests/Support/DivisionByConstantTest.cpp
b/llvm/unittests/Support/DivisionByConstantTest.cpp
index 2b17f98bb75b2f..715dded68ff017 100644
--- a/llvm/unittests/Support/DivisionByConstantTest.cpp
+++ b/llvm/unittests/Support/DivisionByConstantTest.cpp
@@ -32,7 +32,7 @@ APInt SignedDivideUsingMagic(APInt Numerator, APInt Divisor,
unsigned Bits = Numerator.getBitWidth();
APInt Factor(Bits, 0);
- APInt ShiftMask(Bits, -1);
+ APInt ShiftMask(Bits, -1, true);
if (Divisor.isOne() || Divisor.isAllOnes()) {
// If d is +1/-1, we just multiply the numerator by +1/-1.
Factor = Divisor.getSExtValue();
>From 65116db675e825618b01a8bd32c6a9ce7b086d59 Mon Sep 17 00:00:00 2001
From: Nikita Popov <npo...@redhat.com>
Date: Wed, 14 Aug 2024 17:08:26 +0200
Subject: [PATCH 2/2] mlir fixes
---
mlir/include/mlir/IR/OpImplementation.h | 3 ++-
mlir/lib/Conversion/TosaToArith/TosaToArith.cpp | 2 +-
.../Dialect/ControlFlow/IR/ControlFlowOps.cpp | 2 +-
mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp | 2 +-
mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp | 2 +-
mlir/lib/IR/Builders.cpp | 16 ++++++++++++----
.../SPIRV/Deserialization/Deserializer.cpp | 6 ++++--
.../Dialect/SPIRV/SerializationTest.cpp | 2 +-
8 files changed, 23 insertions(+), 12 deletions(-)
diff --git a/mlir/include/mlir/IR/OpImplementation.h
b/mlir/include/mlir/IR/OpImplementation.h
index ae412c7227f8ea..cb341ec3dc2bee 100644
--- a/mlir/include/mlir/IR/OpImplementation.h
+++ b/mlir/include/mlir/IR/OpImplementation.h
@@ -743,7 +743,8 @@ class AsmParser {
// zero for non-negated integers.
result =
(IntT)uintResult.sextOrTrunc(sizeof(IntT) *
CHAR_BIT).getLimitedValue();
- if (APInt(uintResult.getBitWidth(), result) != uintResult)
+ if (APInt(uintResult.getBitWidth(), result, /*isSigned=*/true,
+ /*implicitTrunc=*/true) != uintResult)
return emitError(loc, "integer value too large");
return success();
}
diff --git a/mlir/lib/Conversion/TosaToArith/TosaToArith.cpp
b/mlir/lib/Conversion/TosaToArith/TosaToArith.cpp
index 50e57682a2dc8d..593dbaa6c6545a 100644
--- a/mlir/lib/Conversion/TosaToArith/TosaToArith.cpp
+++ b/mlir/lib/Conversion/TosaToArith/TosaToArith.cpp
@@ -43,7 +43,7 @@ Type matchContainerType(Type element, Type container) {
TypedAttr getConstantAttr(Type type, int64_t value, PatternRewriter &rewriter)
{
if (auto shapedTy = dyn_cast<ShapedType>(type)) {
Type eTy = shapedTy.getElementType();
- APInt valueInt(eTy.getIntOrFloatBitWidth(), value);
+ APInt valueInt(eTy.getIntOrFloatBitWidth(), value, /*isSigned=*/true);
return DenseIntElementsAttr::get(shapedTy, valueInt);
}
diff --git a/mlir/lib/Dialect/ControlFlow/IR/ControlFlowOps.cpp
b/mlir/lib/Dialect/ControlFlow/IR/ControlFlowOps.cpp
index 98b429de1fd85c..edd7f607f24f4d 100644
--- a/mlir/lib/Dialect/ControlFlow/IR/ControlFlowOps.cpp
+++ b/mlir/lib/Dialect/ControlFlow/IR/ControlFlowOps.cpp
@@ -528,7 +528,7 @@ static ParseResult parseSwitchOpCases(
int64_t value = 0;
if (failed(parser.parseInteger(value)))
return failure();
- values.push_back(APInt(bitWidth, value));
+ values.push_back(APInt(bitWidth, value, /*isSigned=*/true));
Block *destination;
SmallVector<OpAsmParser::UnresolvedOperand> operands;
diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp
b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp
index 07262bb8e1bacb..ca88fa438c499a 100644
--- a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp
+++ b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp
@@ -514,7 +514,7 @@ static ParseResult parseSwitchOpCases(
int64_t value = 0;
if (failed(parser.parseInteger(value)))
return failure();
- values.push_back(APInt(bitWidth, value));
+ values.push_back(APInt(bitWidth, value, /*isSigned=*/true));
Block *destination;
SmallVector<OpAsmParser::UnresolvedOperand> operands;
diff --git a/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
b/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
index 4c943ebbe3144f..a9628244f7f979 100644
--- a/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
+++ b/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
@@ -1073,7 +1073,7 @@ static ParseResult parseMembersIndex(OpAsmParser &parser,
if (parser.parseInteger(value))
return failure();
shapeTmp++;
- values.push_back(APInt(32, value));
+ values.push_back(APInt(32, value, /*isSigned=*/true));
return success();
};
diff --git a/mlir/lib/IR/Builders.cpp b/mlir/lib/IR/Builders.cpp
index e3d6d71fb61dfb..0c61ab0d1526ec 100644
--- a/mlir/lib/IR/Builders.cpp
+++ b/mlir/lib/IR/Builders.cpp
@@ -222,7 +222,10 @@ DenseIntElementsAttr
Builder::getIndexTensorAttr(ArrayRef<int64_t> values) {
}
IntegerAttr Builder::getI32IntegerAttr(int32_t value) {
- return IntegerAttr::get(getIntegerType(32), APInt(32, value));
+ // The APInt always uses isSigned=true here because we accept the value
+ // as int32_t.
+ return IntegerAttr::get(getIntegerType(32),
+ APInt(32, value, /*isSigned=*/true));
}
IntegerAttr Builder::getSI32IntegerAttr(int32_t value) {
@@ -240,14 +243,19 @@ IntegerAttr Builder::getI16IntegerAttr(int16_t value) {
}
IntegerAttr Builder::getI8IntegerAttr(int8_t value) {
- return IntegerAttr::get(getIntegerType(8), APInt(8, value));
+ // The APInt always uses isSigned=true here because we accept the value
+ // as int8_t.
+ return IntegerAttr::get(getIntegerType(8),
+ APInt(8, value, /*isSigned=*/true));
}
IntegerAttr Builder::getIntegerAttr(Type type, int64_t value) {
if (type.isIndex())
return IntegerAttr::get(type, APInt(64, value));
- return IntegerAttr::get(
- type, APInt(type.getIntOrFloatBitWidth(), value,
type.isSignedInteger()));
+ // TODO: Avoid implicit trunc?
+ return IntegerAttr::get(type, APInt(type.getIntOrFloatBitWidth(), value,
+ type.isSignedInteger(),
+ /*implicitTrunc=*/true));
}
IntegerAttr Builder::getIntegerAttr(Type type, const APInt &value) {
diff --git a/mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp
b/mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp
index 38293f7106a05a..236e0ec100a0de 100644
--- a/mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp
+++ b/mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp
@@ -1284,9 +1284,11 @@ LogicalResult
spirv::Deserializer::processConstant(ArrayRef<uint32_t> operands,
uint32_t word1;
uint32_t word2;
} words = {operands[2], operands[3]};
- value = APInt(64, llvm::bit_cast<uint64_t>(words), /*isSigned=*/true);
+ value = APInt(64, llvm::bit_cast<uint64_t>(words), /*isSigned=*/true,
+ /*implicitTrunc=*/true);
} else if (bitwidth <= 32) {
- value = APInt(bitwidth, operands[2], /*isSigned=*/true);
+ value = APInt(bitwidth, operands[2], /*isSigned=*/true,
+ /*implicitTrunc=*/true);
}
auto attr = opBuilder.getIntegerAttr(intType, value);
diff --git a/mlir/unittests/Dialect/SPIRV/SerializationTest.cpp
b/mlir/unittests/Dialect/SPIRV/SerializationTest.cpp
index 9d2f690ed898af..ef89c1645d373f 100644
--- a/mlir/unittests/Dialect/SPIRV/SerializationTest.cpp
+++ b/mlir/unittests/Dialect/SPIRV/SerializationTest.cpp
@@ -176,7 +176,7 @@ TEST_F(SerializationTest,
SignlessVsSignedIntegerConstantBitExtension) {
IntegerType::get(&context, 16, IntegerType::Signless);
auto signedInt16Type = IntegerType::get(&context, 16, IntegerType::Signed);
// Check the bit extension of same value under different signedness
semantics.
- APInt signlessIntConstVal(signlessInt16Type.getWidth(), -1,
+ APInt signlessIntConstVal(signlessInt16Type.getWidth(), 0xffff,
signlessInt16Type.getSignedness());
APInt signedIntConstVal(signedInt16Type.getWidth(), -1,
signedInt16Type.getSignedness());
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
