[clang] 36036aa - Reapply "Rename/refactor isIntegerConstantExpression to getIntegerConstantExpression"
David Blaikie via cfe-commits
cfe-commits at lists.llvm.org
Tue Jul 21 20:57:33 PDT 2020
Author: David Blaikie
Date: 2020-07-21T20:57:12-07:00
New Revision: 36036aa70ec1df7b51b5d30b2dd8090ad2b6e783
URL: https://github.com/llvm/llvm-project/commit/36036aa70ec1df7b51b5d30b2dd8090ad2b6e783
DIFF: https://github.com/llvm/llvm-project/commit/36036aa70ec1df7b51b5d30b2dd8090ad2b6e783.diff
LOG: Reapply "Rename/refactor isIntegerConstantExpression to getIntegerConstantExpression"
Reapply 49e5f603d40083dce9c05796e3cde3a185c3beba
which had been reverted in c94332919bd922032e979b3ae3ced5ca5bdf9650.
Originally reverted because I hadn't updated it in quite a while when I
got around to committing it, so there were a bunch of missing changes to
new code since I'd written the patch.
Reviewers: aaron.ballman
Differential Revision: https://reviews.llvm.org/D76646
Added:
Modified:
clang/include/clang/AST/Expr.h
clang/lib/AST/ASTContext.cpp
clang/lib/AST/ExprConstant.cpp
clang/lib/AST/MicrosoftMangle.cpp
clang/lib/AST/OpenMPClause.cpp
clang/lib/CodeGen/CGBuiltin.cpp
clang/lib/CodeGen/CGExpr.cpp
clang/lib/Sema/SemaAttr.cpp
clang/lib/Sema/SemaChecking.cpp
clang/lib/Sema/SemaDecl.cpp
clang/lib/Sema/SemaDeclAttr.cpp
clang/lib/Sema/SemaExpr.cpp
clang/lib/Sema/SemaExprCXX.cpp
clang/lib/Sema/SemaOpenMP.cpp
clang/lib/Sema/SemaOverload.cpp
clang/lib/Sema/SemaStmtAttr.cpp
clang/lib/Sema/SemaTemplateDeduction.cpp
clang/lib/Sema/SemaType.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h
index ea8f688452eb..24bface15d3e 100644
--- a/clang/include/clang/AST/Expr.h
+++ b/clang/include/clang/AST/Expr.h
@@ -522,16 +522,15 @@ class Expr : public ValueStmt {
/// semantically correspond to a bool.
bool isKnownToHaveBooleanValue(bool Semantic = true) const;
- /// isIntegerConstantExpr - Return true if this expression is a valid integer
- /// constant expression, and, if so, return its value in Result. If not a
- /// valid i-c-e, return false and fill in Loc (if specified) with the location
- /// of the invalid expression.
+ /// isIntegerConstantExpr - Return the value if this expression is a valid
+ /// integer constant expression. If not a valid i-c-e, return None and fill
+ /// in Loc (if specified) with the location of the invalid expression.
///
/// Note: This does not perform the implicit conversions required by C++11
/// [expr.const]p5.
- bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx,
- SourceLocation *Loc = nullptr,
- bool isEvaluated = true) const;
+ Optional<llvm::APSInt> getIntegerConstantExpr(const ASTContext &Ctx,
+ SourceLocation *Loc = nullptr,
+ bool isEvaluated = true) const;
bool isIntegerConstantExpr(const ASTContext &Ctx,
SourceLocation *Loc = nullptr) const;
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index 2ba643f12a82..807028885652 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -9471,17 +9471,15 @@ QualType ASTContext::mergeTypes(QualType LHS, QualType RHS,
const ConstantArrayType* CAT)
-> std::pair<bool,llvm::APInt> {
if (VAT) {
- llvm::APSInt TheInt;
+ Optional<llvm::APSInt> TheInt;
Expr *E = VAT->getSizeExpr();
- if (E && E->isIntegerConstantExpr(TheInt, *this))
- return std::make_pair(true, TheInt);
- else
- return std::make_pair(false, TheInt);
- } else if (CAT) {
- return std::make_pair(true, CAT->getSize());
- } else {
- return std::make_pair(false, llvm::APInt());
+ if (E && (TheInt = E->getIntegerConstantExpr(*this)))
+ return std::make_pair(true, *TheInt);
+ return std::make_pair(false, llvm::APSInt());
}
+ if (CAT)
+ return std::make_pair(true, CAT->getSize());
+ return std::make_pair(false, llvm::APInt());
};
bool HaveLSize, HaveRSize;
diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp
index 41a4ae4b91c8..5f8ad18c0ed2 100644
--- a/clang/lib/AST/ExprConstant.cpp
+++ b/clang/lib/AST/ExprConstant.cpp
@@ -14892,16 +14892,22 @@ bool Expr::isIntegerConstantExpr(const ASTContext &Ctx,
return true;
}
-bool Expr::isIntegerConstantExpr(llvm::APSInt &Value, const ASTContext &Ctx,
- SourceLocation *Loc, bool isEvaluated) const {
+Optional<llvm::APSInt> Expr::getIntegerConstantExpr(const ASTContext &Ctx,
+ SourceLocation *Loc,
+ bool isEvaluated) const {
assert(!isValueDependent() &&
"Expression evaluator can't be called on a dependent expression.");
- if (Ctx.getLangOpts().CPlusPlus11)
- return EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, &Value, Loc);
+ APSInt Value;
+
+ if (Ctx.getLangOpts().CPlusPlus11) {
+ if (EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, &Value, Loc))
+ return Value;
+ return None;
+ }
if (!isIntegerConstantExpr(Ctx, Loc))
- return false;
+ return None;
// The only possible side-effects here are due to UB discovered in the
// evaluation (for instance, INT_MAX + 1). In such a case, we are still
@@ -14915,8 +14921,7 @@ bool Expr::isIntegerConstantExpr(llvm::APSInt &Value, const ASTContext &Ctx,
if (!::EvaluateAsInt(this, ExprResult, Ctx, SE_AllowSideEffects, Info))
llvm_unreachable("ICE cannot be evaluated!");
- Value = ExprResult.Val.getInt();
- return true;
+ return ExprResult.Val.getInt();
}
bool Expr::isCXX98IntegralConstantExpr(const ASTContext &Ctx) const {
diff --git a/clang/lib/AST/MicrosoftMangle.cpp b/clang/lib/AST/MicrosoftMangle.cpp
index 529f301e4696..09579c28061a 100644
--- a/clang/lib/AST/MicrosoftMangle.cpp
+++ b/clang/lib/AST/MicrosoftMangle.cpp
@@ -1372,9 +1372,9 @@ void MicrosoftCXXNameMangler::mangleIntegerLiteral(const llvm::APSInt &Value,
void MicrosoftCXXNameMangler::mangleExpression(const Expr *E) {
// See if this is a constant expression.
- llvm::APSInt Value;
- if (E->isIntegerConstantExpr(Value, Context.getASTContext())) {
- mangleIntegerLiteral(Value, E->getType()->isBooleanType());
+ if (Optional<llvm::APSInt> Value =
+ E->getIntegerConstantExpr(Context.getASTContext())) {
+ mangleIntegerLiteral(*Value, E->getType()->isBooleanType());
return;
}
diff --git a/clang/lib/AST/OpenMPClause.cpp b/clang/lib/AST/OpenMPClause.cpp
index a0b0dca55390..6933c5742552 100644
--- a/clang/lib/AST/OpenMPClause.cpp
+++ b/clang/lib/AST/OpenMPClause.cpp
@@ -2127,21 +2127,21 @@ void OMPTraitInfo::getAsVariantMatchInfo(ASTContext &ASTCtx,
TraitProperty::user_condition_unknown &&
"Ill-formed user condition, expected unknown trait property!");
- llvm::APSInt CondVal;
- if (Selector.ScoreOrCondition->isIntegerConstantExpr(CondVal, ASTCtx))
- VMI.addTrait(CondVal.isNullValue()
- ? TraitProperty::user_condition_false
- : TraitProperty::user_condition_true);
+ if (Optional<APSInt> CondVal =
+ Selector.ScoreOrCondition->getIntegerConstantExpr(ASTCtx))
+ VMI.addTrait(CondVal->isNullValue()
+ ? TraitProperty::user_condition_false
+ : TraitProperty::user_condition_true);
else
VMI.addTrait(TraitProperty::user_condition_false);
continue;
}
- llvm::APSInt Score;
+ Optional<llvm::APSInt> Score;
llvm::APInt *ScorePtr = nullptr;
if (Selector.ScoreOrCondition) {
- if (Selector.ScoreOrCondition->isIntegerConstantExpr(Score, ASTCtx))
- ScorePtr = &Score;
+ if ((Score = Selector.ScoreOrCondition->getIntegerConstantExpr(ASTCtx)))
+ ScorePtr = &*Score;
else
VMI.addTrait(TraitProperty::user_condition_false);
}
diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp
index 8994b939093e..f0191112074b 100644
--- a/clang/lib/CodeGen/CGBuiltin.cpp
+++ b/clang/lib/CodeGen/CGBuiltin.cpp
@@ -4419,11 +4419,9 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
} else {
// If this is required to be a constant, constant fold it so that we
// know that the generated intrinsic gets a ConstantInt.
- llvm::APSInt Result;
- bool IsConst = E->getArg(i)->isIntegerConstantExpr(Result,getContext());
- assert(IsConst && "Constant arg isn't actually constant?");
- (void)IsConst;
- ArgValue = llvm::ConstantInt::get(getLLVMContext(), Result);
+ ArgValue = llvm::ConstantInt::get(
+ getLLVMContext(),
+ *E->getArg(i)->getIntegerConstantExpr(getContext()));
}
// If the intrinsic arg type is
diff erent from the builtin arg type
@@ -5596,13 +5594,14 @@ Value *CodeGenFunction::EmitCommonNeonBuiltinExpr(
SmallVectorImpl<llvm::Value *> &Ops, Address PtrOp0, Address PtrOp1,
llvm::Triple::ArchType Arch) {
// Get the last argument, which specifies the vector type.
- llvm::APSInt NeonTypeConst;
const Expr *Arg = E->getArg(E->getNumArgs() - 1);
- if (!Arg->isIntegerConstantExpr(NeonTypeConst, getContext()))
+ Optional<llvm::APSInt> NeonTypeConst =
+ Arg->getIntegerConstantExpr(getContext());
+ if (!NeonTypeConst)
return nullptr;
// Determine the type of this overloaded NEON intrinsic.
- NeonTypeFlags Type(NeonTypeConst.getZExtValue());
+ NeonTypeFlags Type(NeonTypeConst->getZExtValue());
bool Usgn = Type.isUnsigned();
bool Quad = Type.isQuad();
const bool HasLegalHalfType = getTarget().hasLegalHalfType();
@@ -6898,10 +6897,9 @@ Value *CodeGenFunction::EmitARMBuiltinExpr(unsigned BuiltinID,
} else {
// If this is required to be a constant, constant fold it so that we know
// that the generated intrinsic gets a ConstantInt.
- llvm::APSInt Result;
- bool IsConst = E->getArg(i)->isIntegerConstantExpr(Result, getContext());
- assert(IsConst && "Constant arg isn't actually constant?"); (void)IsConst;
- Ops.push_back(llvm::ConstantInt::get(getLLVMContext(), Result));
+ Ops.push_back(llvm::ConstantInt::get(
+ getLLVMContext(),
+ *E->getArg(i)->getIntegerConstantExpr(getContext())));
}
}
@@ -7112,9 +7110,9 @@ Value *CodeGenFunction::EmitARMBuiltinExpr(unsigned BuiltinID,
// Get the last argument, which specifies the vector type.
assert(HasExtraArg);
- llvm::APSInt Result;
const Expr *Arg = E->getArg(E->getNumArgs()-1);
- if (!Arg->isIntegerConstantExpr(Result, getContext()))
+ Optional<llvm::APSInt> Result = Arg->getIntegerConstantExpr(getContext());
+ if (!Result)
return nullptr;
if (BuiltinID == ARM::BI__builtin_arm_vcvtr_f ||
@@ -7127,7 +7125,7 @@ Value *CodeGenFunction::EmitARMBuiltinExpr(unsigned BuiltinID,
Ty = DoubleTy;
// Determine whether this is an unsigned conversion or not.
- bool usgn = Result.getZExtValue() == 1;
+ bool usgn = Result->getZExtValue() == 1;
unsigned Int = usgn ? Intrinsic::arm_vcvtru : Intrinsic::arm_vcvtr;
// Call the appropriate intrinsic.
@@ -7136,7 +7134,7 @@ Value *CodeGenFunction::EmitARMBuiltinExpr(unsigned BuiltinID,
}
// Determine the type of this overloaded NEON intrinsic.
- NeonTypeFlags Type(Result.getZExtValue());
+ NeonTypeFlags Type = Result->getZExtValue();
bool usgn = Type.isUnsigned();
bool rightShift = false;
@@ -7280,11 +7278,7 @@ Value *CodeGenFunction::EmitARMBuiltinExpr(unsigned BuiltinID,
template<typename Integer>
static Integer GetIntegerConstantValue(const Expr *E, ASTContext &Context) {
- llvm::APSInt IntVal;
- bool IsConst = E->isIntegerConstantExpr(IntVal, Context);
- assert(IsConst && "Sema should have checked this was a constant");
- (void)IsConst;
- return IntVal.getExtValue();
+ return E->getIntegerConstantExpr(Context)->getExtValue();
}
static llvm::Value *SignOrZeroExtend(CGBuilderTy &Builder, llvm::Value *V,
@@ -7557,13 +7551,13 @@ static Value *EmitAArch64TblBuiltinExpr(CodeGenFunction &CGF, unsigned BuiltinID
assert(E->getNumArgs() >= 3);
// Get the last argument, which specifies the vector type.
- llvm::APSInt Result;
const Expr *Arg = E->getArg(E->getNumArgs() - 1);
- if (!Arg->isIntegerConstantExpr(Result, CGF.getContext()))
+ Optional<llvm::APSInt> Result = Arg->getIntegerConstantExpr(CGF.getContext());
+ if (!Result)
return nullptr;
// Determine the type of this overloaded NEON intrinsic.
- NeonTypeFlags Type(Result.getZExtValue());
+ NeonTypeFlags Type = Result->getZExtValue();
llvm::VectorType *Ty = GetNeonType(&CGF, Type);
if (!Ty)
return nullptr;
@@ -8240,15 +8234,15 @@ Value *CodeGenFunction::EmitAArch64SVEBuiltinExpr(unsigned BuiltinID,
else {
// If this is required to be a constant, constant fold it so that we know
// that the generated intrinsic gets a ConstantInt.
- llvm::APSInt Result;
- if (!E->getArg(i)->isIntegerConstantExpr(Result, getContext()))
- llvm_unreachable("Expected argument to be a constant");
+ Optional<llvm::APSInt> Result =
+ E->getArg(i)->getIntegerConstantExpr(getContext());
+ assert(Result && "Expected argument to be a constant");
// Immediates for SVE llvm intrinsics are always 32bit. We can safely
// truncate because the immediate has been range checked and no valid
// immediate requires more than a handful of bits.
- Result = Result.extOrTrunc(32);
- Ops.push_back(llvm::ConstantInt::get(getLLVMContext(), Result));
+ *Result = Result->extOrTrunc(32);
+ Ops.push_back(llvm::ConstantInt::get(getLLVMContext(), *Result));
}
}
@@ -8952,11 +8946,9 @@ Value *CodeGenFunction::EmitAArch64BuiltinExpr(unsigned BuiltinID,
} else {
// If this is required to be a constant, constant fold it so that we know
// that the generated intrinsic gets a ConstantInt.
- llvm::APSInt Result;
- bool IsConst = E->getArg(i)->isIntegerConstantExpr(Result, getContext());
- assert(IsConst && "Constant arg isn't actually constant?");
- (void)IsConst;
- Ops.push_back(llvm::ConstantInt::get(getLLVMContext(), Result));
+ Ops.push_back(llvm::ConstantInt::get(
+ getLLVMContext(),
+ *E->getArg(i)->getIntegerConstantExpr(getContext())));
}
}
@@ -8971,12 +8963,11 @@ Value *CodeGenFunction::EmitAArch64BuiltinExpr(unsigned BuiltinID,
return Result;
}
- llvm::APSInt Result;
const Expr *Arg = E->getArg(E->getNumArgs()-1);
NeonTypeFlags Type(0);
- if (Arg->isIntegerConstantExpr(Result, getContext()))
+ if (Optional<llvm::APSInt> Result = Arg->getIntegerConstantExpr(getContext()))
// Determine the type of this overloaded NEON intrinsic.
- Type = NeonTypeFlags(Result.getZExtValue());
+ Type = NeonTypeFlags(Result->getZExtValue());
bool usgn = Type.isUnsigned();
bool quad = Type.isQuad();
@@ -11807,10 +11798,8 @@ Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
// If this is required to be a constant, constant fold it so that we know
// that the generated intrinsic gets a ConstantInt.
- llvm::APSInt Result;
- bool IsConst = E->getArg(i)->isIntegerConstantExpr(Result, getContext());
- assert(IsConst && "Constant arg isn't actually constant?"); (void)IsConst;
- Ops.push_back(llvm::ConstantInt::get(getLLVMContext(), Result));
+ Ops.push_back(llvm::ConstantInt::get(
+ getLLVMContext(), *E->getArg(i)->getIntegerConstantExpr(getContext())));
}
// These exist so that the builtin that takes an immediate can be bounds
@@ -15089,11 +15078,8 @@ Value *CodeGenFunction::EmitSystemZBuiltinExpr(unsigned BuiltinID,
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
// Constant-fold the M4 and M5 mask arguments.
- llvm::APSInt M4, M5;
- bool IsConstM4 = E->getArg(1)->isIntegerConstantExpr(M4, getContext());
- bool IsConstM5 = E->getArg(2)->isIntegerConstantExpr(M5, getContext());
- assert(IsConstM4 && IsConstM5 && "Constant arg isn't actually constant?");
- (void)IsConstM4; (void)IsConstM5;
+ llvm::APSInt M4 = *E->getArg(1)->getIntegerConstantExpr(getContext());
+ llvm::APSInt M5 = *E->getArg(2)->getIntegerConstantExpr(getContext());
// Check whether this instance can be represented via a LLVM standard
// intrinsic. We only support some combinations of M4 and M5.
Intrinsic::ID ID = Intrinsic::not_intrinsic;
@@ -15148,10 +15134,7 @@ Value *CodeGenFunction::EmitSystemZBuiltinExpr(unsigned BuiltinID,
Value *X = EmitScalarExpr(E->getArg(0));
Value *Y = EmitScalarExpr(E->getArg(1));
// Constant-fold the M4 mask argument.
- llvm::APSInt M4;
- bool IsConstM4 = E->getArg(2)->isIntegerConstantExpr(M4, getContext());
- assert(IsConstM4 && "Constant arg isn't actually constant?");
- (void)IsConstM4;
+ llvm::APSInt M4 = *E->getArg(2)->getIntegerConstantExpr(getContext());
// Check whether this instance can be represented via a LLVM standard
// intrinsic. We only support some values of M4.
Intrinsic::ID ID = Intrinsic::not_intrinsic;
@@ -15185,10 +15168,7 @@ Value *CodeGenFunction::EmitSystemZBuiltinExpr(unsigned BuiltinID,
Value *X = EmitScalarExpr(E->getArg(0));
Value *Y = EmitScalarExpr(E->getArg(1));
// Constant-fold the M4 mask argument.
- llvm::APSInt M4;
- bool IsConstM4 = E->getArg(2)->isIntegerConstantExpr(M4, getContext());
- assert(IsConstM4 && "Constant arg isn't actually constant?");
- (void)IsConstM4;
+ llvm::APSInt M4 = *E->getArg(2)->getIntegerConstantExpr(getContext());
// Check whether this instance can be represented via a LLVM standard
// intrinsic. We only support some values of M4.
Intrinsic::ID ID = Intrinsic::not_intrinsic;
@@ -15855,10 +15835,11 @@ CodeGenFunction::EmitNVPTXBuiltinExpr(unsigned BuiltinID, const CallExpr *E) {
Address Dst = EmitPointerWithAlignment(E->getArg(0));
Value *Src = EmitScalarExpr(E->getArg(1));
Value *Ldm = EmitScalarExpr(E->getArg(2));
- llvm::APSInt isColMajorArg;
- if (!E->getArg(3)->isIntegerConstantExpr(isColMajorArg, getContext()))
+ Optional<llvm::APSInt> isColMajorArg =
+ E->getArg(3)->getIntegerConstantExpr(getContext());
+ if (!isColMajorArg)
return nullptr;
- bool isColMajor = isColMajorArg.getSExtValue();
+ bool isColMajor = isColMajorArg->getSExtValue();
NVPTXMmaLdstInfo II = getNVPTXMmaLdstInfo(BuiltinID);
unsigned IID = isColMajor ? II.IID_col : II.IID_row;
if (IID == 0)
@@ -15899,10 +15880,11 @@ CodeGenFunction::EmitNVPTXBuiltinExpr(unsigned BuiltinID, const CallExpr *E) {
Value *Dst = EmitScalarExpr(E->getArg(0));
Address Src = EmitPointerWithAlignment(E->getArg(1));
Value *Ldm = EmitScalarExpr(E->getArg(2));
- llvm::APSInt isColMajorArg;
- if (!E->getArg(3)->isIntegerConstantExpr(isColMajorArg, getContext()))
+ Optional<llvm::APSInt> isColMajorArg =
+ E->getArg(3)->getIntegerConstantExpr(getContext());
+ if (!isColMajorArg)
return nullptr;
- bool isColMajor = isColMajorArg.getSExtValue();
+ bool isColMajor = isColMajorArg->getSExtValue();
NVPTXMmaLdstInfo II = getNVPTXMmaLdstInfo(BuiltinID);
unsigned IID = isColMajor ? II.IID_col : II.IID_row;
if (IID == 0)
@@ -15949,16 +15931,20 @@ CodeGenFunction::EmitNVPTXBuiltinExpr(unsigned BuiltinID, const CallExpr *E) {
Address SrcA = EmitPointerWithAlignment(E->getArg(1));
Address SrcB = EmitPointerWithAlignment(E->getArg(2));
Address SrcC = EmitPointerWithAlignment(E->getArg(3));
- llvm::APSInt LayoutArg;
- if (!E->getArg(4)->isIntegerConstantExpr(LayoutArg, getContext()))
+ Optional<llvm::APSInt> LayoutArg =
+ E->getArg(4)->getIntegerConstantExpr(getContext());
+ if (!LayoutArg)
return nullptr;
- int Layout = LayoutArg.getSExtValue();
+ int Layout = LayoutArg->getSExtValue();
if (Layout < 0 || Layout > 3)
return nullptr;
llvm::APSInt SatfArg;
if (BuiltinID == NVPTX::BI__bmma_m8n8k128_mma_xor_popc_b1)
SatfArg = 0; // .b1 does not have satf argument.
- else if (!E->getArg(5)->isIntegerConstantExpr(SatfArg, getContext()))
+ else if (Optional<llvm::APSInt> OptSatfArg =
+ E->getArg(5)->getIntegerConstantExpr(getContext()))
+ SatfArg = *OptSatfArg;
+ else
return nullptr;
bool Satf = SatfArg.getSExtValue();
NVPTXMmaInfo MI = getNVPTXMmaInfo(BuiltinID);
@@ -16287,9 +16273,8 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID,
case WebAssembly::BI__builtin_wasm_extract_lane_i64x2:
case WebAssembly::BI__builtin_wasm_extract_lane_f32x4:
case WebAssembly::BI__builtin_wasm_extract_lane_f64x2: {
- llvm::APSInt LaneConst;
- if (!E->getArg(1)->isIntegerConstantExpr(LaneConst, getContext()))
- llvm_unreachable("Constant arg isn't actually constant?");
+ llvm::APSInt LaneConst =
+ *E->getArg(1)->getIntegerConstantExpr(getContext());
Value *Vec = EmitScalarExpr(E->getArg(0));
Value *Lane = llvm::ConstantInt::get(getLLVMContext(), LaneConst);
Value *Extract = Builder.CreateExtractElement(Vec, Lane);
@@ -16315,9 +16300,8 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID,
case WebAssembly::BI__builtin_wasm_replace_lane_i64x2:
case WebAssembly::BI__builtin_wasm_replace_lane_f32x4:
case WebAssembly::BI__builtin_wasm_replace_lane_f64x2: {
- llvm::APSInt LaneConst;
- if (!E->getArg(1)->isIntegerConstantExpr(LaneConst, getContext()))
- llvm_unreachable("Constant arg isn't actually constant?");
+ llvm::APSInt LaneConst =
+ *E->getArg(1)->getIntegerConstantExpr(getContext());
Value *Vec = EmitScalarExpr(E->getArg(0));
Value *Lane = llvm::ConstantInt::get(getLLVMContext(), LaneConst);
Value *Val = EmitScalarExpr(E->getArg(2));
@@ -16579,10 +16563,10 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID,
Ops[OpIdx++] = EmitScalarExpr(E->getArg(0));
Ops[OpIdx++] = EmitScalarExpr(E->getArg(1));
while (OpIdx < 18) {
- llvm::APSInt LaneConst;
- if (!E->getArg(OpIdx)->isIntegerConstantExpr(LaneConst, getContext()))
- llvm_unreachable("Constant arg isn't actually constant?");
- Ops[OpIdx++] = llvm::ConstantInt::get(getLLVMContext(), LaneConst);
+ Optional<llvm::APSInt> LaneConst =
+ E->getArg(OpIdx)->getIntegerConstantExpr(getContext());
+ assert(LaneConst && "Constant arg isn't actually constant?");
+ Ops[OpIdx++] = llvm::ConstantInt::get(getLLVMContext(), *LaneConst);
}
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_shuffle);
return Builder.CreateCall(Callee, Ops);
diff --git a/clang/lib/CodeGen/CGExpr.cpp b/clang/lib/CodeGen/CGExpr.cpp
index 9e8770573d70..ab29e32929ce 100644
--- a/clang/lib/CodeGen/CGExpr.cpp
+++ b/clang/lib/CodeGen/CGExpr.cpp
@@ -3868,15 +3868,17 @@ LValue CodeGenFunction::EmitOMPArraySectionExpr(const OMPArraySectionExpr *E,
llvm::APSInt ConstLength;
if (Length) {
// Idx = LowerBound + Length - 1;
- if (Length->isIntegerConstantExpr(ConstLength, C)) {
- ConstLength = ConstLength.zextOrTrunc(PointerWidthInBits);
+ if (Optional<llvm::APSInt> CL = Length->getIntegerConstantExpr(C)) {
+ ConstLength = CL->zextOrTrunc(PointerWidthInBits);
Length = nullptr;
}
auto *LowerBound = E->getLowerBound();
llvm::APSInt ConstLowerBound(PointerWidthInBits, /*isUnsigned=*/false);
- if (LowerBound && LowerBound->isIntegerConstantExpr(ConstLowerBound, C)) {
- ConstLowerBound = ConstLowerBound.zextOrTrunc(PointerWidthInBits);
- LowerBound = nullptr;
+ if (LowerBound) {
+ if (Optional<llvm::APSInt> LB = LowerBound->getIntegerConstantExpr(C)) {
+ ConstLowerBound = LB->zextOrTrunc(PointerWidthInBits);
+ LowerBound = nullptr;
+ }
}
if (!Length)
--ConstLength;
@@ -3913,8 +3915,10 @@ LValue CodeGenFunction::EmitOMPArraySectionExpr(const OMPArraySectionExpr *E,
: BaseTy;
if (auto *VAT = C.getAsVariableArrayType(ArrayTy)) {
Length = VAT->getSizeExpr();
- if (Length->isIntegerConstantExpr(ConstLength, C))
+ if (Optional<llvm::APSInt> L = Length->getIntegerConstantExpr(C)) {
+ ConstLength = *L;
Length = nullptr;
+ }
} else {
auto *CAT = C.getAsConstantArrayType(ArrayTy);
ConstLength = CAT->getSize();
diff --git a/clang/lib/Sema/SemaAttr.cpp b/clang/lib/Sema/SemaAttr.cpp
index b354e810974c..f9785e4bea5e 100644
--- a/clang/lib/Sema/SemaAttr.cpp
+++ b/clang/lib/Sema/SemaAttr.cpp
@@ -300,20 +300,18 @@ void Sema::ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action,
// If specified then alignment must be a "small" power of two.
unsigned AlignmentVal = 0;
if (Alignment) {
- llvm::APSInt Val;
+ Optional<llvm::APSInt> Val;
// pack(0) is like pack(), which just works out since that is what
// we use 0 for in PackAttr.
- if (Alignment->isTypeDependent() ||
- Alignment->isValueDependent() ||
- !Alignment->isIntegerConstantExpr(Val, Context) ||
- !(Val == 0 || Val.isPowerOf2()) ||
- Val.getZExtValue() > 16) {
+ if (Alignment->isTypeDependent() || Alignment->isValueDependent() ||
+ !(Val = Alignment->getIntegerConstantExpr(Context)) ||
+ !(*Val == 0 || Val->isPowerOf2()) || Val->getZExtValue() > 16) {
Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment);
return; // Ignore
}
- AlignmentVal = (unsigned) Val.getZExtValue();
+ AlignmentVal = (unsigned)Val->getZExtValue();
}
if (Action == Sema::PSK_Show) {
// Show the current alignment, making sure to show the right value
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index 509d88e25000..252690b436e3 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -2284,10 +2284,7 @@ bool Sema::CheckARMCoprocessorImmediate(const TargetInfo &TI,
if (CoprocArg->isTypeDependent() || CoprocArg->isValueDependent())
return false;
- llvm::APSInt CoprocNoAP;
- bool IsICE = CoprocArg->isIntegerConstantExpr(CoprocNoAP, Context);
- (void)IsICE;
- assert(IsICE && "Coprocossor immediate is not a constant expression");
+ llvm::APSInt CoprocNoAP = *CoprocArg->getIntegerConstantExpr(Context);
int64_t CoprocNo = CoprocNoAP.getExtValue();
assert(CoprocNo >= 0 && "Coprocessor immediate must be non-negative");
@@ -2571,9 +2568,8 @@ bool Sema::CheckBPFBuiltinFunctionCall(unsigned BuiltinID,
Expr *Arg;
if (BuiltinID == BPF::BI__builtin_btf_type_id) {
// The second argument needs to be a constant int
- llvm::APSInt Value;
Arg = TheCall->getArg(1);
- if (!Arg->isIntegerConstantExpr(Value, Context)) {
+ if (!Arg->isIntegerConstantExpr(Context)) {
Diag(Arg->getBeginLoc(), diag::err_btf_type_id_not_const)
<< 2 << Arg->getSourceRange();
return true;
@@ -2599,8 +2595,7 @@ bool Sema::CheckBPFBuiltinFunctionCall(unsigned BuiltinID,
// The second argument needs to be a constant int
Arg = TheCall->getArg(1);
- llvm::APSInt Value;
- if (!Arg->isIntegerConstantExpr(Value, Context)) {
+ if (!Arg->isIntegerConstantExpr(Context)) {
Diag(Arg->getBeginLoc(), diag::err_preserve_field_info_not_const)
<< 2 << Arg->getSourceRange();
return true;
@@ -3198,11 +3193,10 @@ bool Sema::CheckSystemZBuiltinFunctionCall(unsigned BuiltinID,
CallExpr *TheCall) {
if (BuiltinID == SystemZ::BI__builtin_tabort) {
Expr *Arg = TheCall->getArg(0);
- llvm::APSInt AbortCode(32);
- if (Arg->isIntegerConstantExpr(AbortCode, Context) &&
- AbortCode.getSExtValue() >= 0 && AbortCode.getSExtValue() < 256)
- return Diag(Arg->getBeginLoc(), diag::err_systemz_invalid_tabort_code)
- << Arg->getSourceRange();
+ if (Optional<llvm::APSInt> AbortCode = Arg->getIntegerConstantExpr(Context))
+ if (AbortCode->getSExtValue() >= 0 && AbortCode->getSExtValue() < 256)
+ return Diag(Arg->getBeginLoc(), diag::err_systemz_invalid_tabort_code)
+ << Arg->getSourceRange();
}
// For intrinsics which take an immediate value as part of the instruction,
@@ -4923,21 +4917,21 @@ ExprResult Sema::BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,
}
if (SubExprs.size() >= 2 && Form != Init) {
- llvm::APSInt Result(32);
- if (SubExprs[1]->isIntegerConstantExpr(Result, Context) &&
- !isValidOrderingForOp(Result.getSExtValue(), Op))
- Diag(SubExprs[1]->getBeginLoc(),
- diag::warn_atomic_op_has_invalid_memory_order)
- << SubExprs[1]->getSourceRange();
+ if (Optional<llvm::APSInt> Result =
+ SubExprs[1]->getIntegerConstantExpr(Context))
+ if (!isValidOrderingForOp(Result->getSExtValue(), Op))
+ Diag(SubExprs[1]->getBeginLoc(),
+ diag::warn_atomic_op_has_invalid_memory_order)
+ << SubExprs[1]->getSourceRange();
}
if (auto ScopeModel = AtomicExpr::getScopeModel(Op)) {
auto *Scope = Args[Args.size() - 1];
- llvm::APSInt Result(32);
- if (Scope->isIntegerConstantExpr(Result, Context) &&
- !ScopeModel->isValid(Result.getZExtValue())) {
- Diag(Scope->getBeginLoc(), diag::err_atomic_op_has_invalid_synch_scope)
- << Scope->getSourceRange();
+ if (Optional<llvm::APSInt> Result =
+ Scope->getIntegerConstantExpr(Context)) {
+ if (!ScopeModel->isValid(Result->getZExtValue()))
+ Diag(Scope->getBeginLoc(), diag::err_atomic_op_has_invalid_synch_scope)
+ << Scope->getSourceRange();
}
SubExprs.push_back(Scope);
}
@@ -5814,8 +5808,7 @@ bool Sema::SemaBuiltinVSX(CallExpr *TheCall) {
<< TheCall->getSourceRange();
// Check the third argument is a compile time constant
- llvm::APSInt Value;
- if(!TheCall->getArg(2)->isIntegerConstantExpr(Value, Context))
+ if (!TheCall->getArg(2)->isIntegerConstantExpr(Context))
return Diag(TheCall->getBeginLoc(),
diag::err_vsx_builtin_nonconstant_argument)
<< 3 /* argument index */ << TheCall->getDirectCallee()
@@ -5910,17 +5903,18 @@ ExprResult Sema::SemaBuiltinShuffleVector(CallExpr *TheCall) {
TheCall->getArg(i)->isValueDependent())
continue;
- llvm::APSInt Result(32);
- if (!TheCall->getArg(i)->isIntegerConstantExpr(Result, Context))
+ Optional<llvm::APSInt> Result;
+ if (!(Result = TheCall->getArg(i)->getIntegerConstantExpr(Context)))
return ExprError(Diag(TheCall->getBeginLoc(),
diag::err_shufflevector_nonconstant_argument)
<< TheCall->getArg(i)->getSourceRange());
// Allow -1 which will be translated to undef in the IR.
- if (Result.isSigned() && Result.isAllOnesValue())
+ if (Result->isSigned() && Result->isAllOnesValue())
continue;
- if (Result.getActiveBits() > 64 || Result.getZExtValue() >= numElements*2)
+ if (Result->getActiveBits() > 64 ||
+ Result->getZExtValue() >= numElements * 2)
return ExprError(Diag(TheCall->getBeginLoc(),
diag::err_shufflevector_argument_too_large)
<< TheCall->getArg(i)->getSourceRange());
@@ -6167,10 +6161,11 @@ bool Sema::SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum,
if (Arg->isTypeDependent() || Arg->isValueDependent()) return false;
- if (!Arg->isIntegerConstantExpr(Result, Context))
+ Optional<llvm::APSInt> R;
+ if (!(R = Arg->getIntegerConstantExpr(Context)))
return Diag(TheCall->getBeginLoc(), diag::err_constant_integer_arg_type)
<< FDecl->getDeclName() << Arg->getSourceRange();
-
+ Result = *R;
return false;
}
@@ -10330,14 +10325,15 @@ static IntRange GetExprRange(ASTContext &C, const Expr *E, unsigned MaxWidth,
// If the shift amount is a positive constant, drop the width by
// that much.
- llvm::APSInt shift;
- if (BO->getRHS()->isIntegerConstantExpr(shift, C) &&
- shift.isNonNegative()) {
- unsigned zext = shift.getZExtValue();
- if (zext >= L.Width)
- L.Width = (L.NonNegative ? 0 : 1);
- else
- L.Width -= zext;
+ if (Optional<llvm::APSInt> shift =
+ BO->getRHS()->getIntegerConstantExpr(C)) {
+ if (shift->isNonNegative()) {
+ unsigned zext = shift->getZExtValue();
+ if (zext >= L.Width)
+ L.Width = (L.NonNegative ? 0 : 1);
+ else
+ L.Width -= zext;
+ }
}
return L;
@@ -10361,9 +10357,9 @@ static IntRange GetExprRange(ASTContext &C, const Expr *E, unsigned MaxWidth,
IntRange L = GetExprRange(C, BO->getLHS(), opWidth, InConstantContext);
// If the divisor is constant, use that.
- llvm::APSInt divisor;
- if (BO->getRHS()->isIntegerConstantExpr(divisor, C)) {
- unsigned log2 = divisor.logBase2(); // floor(log_2(divisor))
+ if (Optional<llvm::APSInt> divisor =
+ BO->getRHS()->getIntegerConstantExpr(C)) {
+ unsigned log2 = divisor->logBase2(); // floor(log_2(divisor))
if (log2 >= L.Width)
L.Width = (L.NonNegative ? 0 : 1);
else
@@ -10795,23 +10791,20 @@ static void AnalyzeComparison(Sema &S, BinaryOperator *E) {
Expr *RHS = E->getRHS();
if (T->isIntegralType(S.Context)) {
- llvm::APSInt RHSValue;
- llvm::APSInt LHSValue;
-
- bool IsRHSIntegralLiteral = RHS->isIntegerConstantExpr(RHSValue, S.Context);
- bool IsLHSIntegralLiteral = LHS->isIntegerConstantExpr(LHSValue, S.Context);
+ Optional<llvm::APSInt> RHSValue = RHS->getIntegerConstantExpr(S.Context);
+ Optional<llvm::APSInt> LHSValue = LHS->getIntegerConstantExpr(S.Context);
// We don't care about expressions whose result is a constant.
- if (IsRHSIntegralLiteral && IsLHSIntegralLiteral)
+ if (RHSValue && LHSValue)
return AnalyzeImpConvsInComparison(S, E);
// We only care about expressions where just one side is literal
- if (IsRHSIntegralLiteral ^ IsLHSIntegralLiteral) {
+ if ((bool)RHSValue ^ (bool)LHSValue) {
// Is the constant on the RHS or LHS?
- const bool RhsConstant = IsRHSIntegralLiteral;
+ const bool RhsConstant = (bool)RHSValue;
Expr *Const = RhsConstant ? RHS : LHS;
Expr *Other = RhsConstant ? LHS : RHS;
- const llvm::APSInt &Value = RhsConstant ? RHSValue : LHSValue;
+ const llvm::APSInt &Value = RhsConstant ? *RHSValue : *LHSValue;
// Check whether an integer constant comparison results in a value
// of 'true' or 'false'.
@@ -11769,8 +11762,8 @@ static void CheckImplicitConversion(Sema &S, Expr *E, QualType T,
if (SourcePrecision > 0 && TargetPrecision > 0 &&
SourcePrecision > TargetPrecision) {
- llvm::APSInt SourceInt;
- if (E->isIntegerConstantExpr(SourceInt, S.Context)) {
+ if (Optional<llvm::APSInt> SourceInt =
+ E->getIntegerConstantExpr(S.Context)) {
// If the source integer is a constant, convert it to the target
// floating point type. Issue a warning if the value changes
// during the whole conversion.
@@ -11778,11 +11771,11 @@ static void CheckImplicitConversion(Sema &S, Expr *E, QualType T,
S.Context.getFloatTypeSemantics(QualType(TargetBT, 0)));
llvm::APFloat::opStatus ConversionStatus =
TargetFloatValue.convertFromAPInt(
- SourceInt, SourceBT->isSignedInteger(),
+ *SourceInt, SourceBT->isSignedInteger(),
llvm::APFloat::rmNearestTiesToEven);
if (ConversionStatus != llvm::APFloat::opOK) {
- std::string PrettySourceValue = SourceInt.toString(10);
+ std::string PrettySourceValue = SourceInt->toString(10);
SmallString<32> PrettyTargetValue;
TargetFloatValue.toString(PrettyTargetValue, TargetPrecision);
@@ -13505,10 +13498,9 @@ getAlignmentAndOffsetFromBinAddOrSub(const Expr *PtrE, const Expr *IntE,
if (!P)
return llvm::None;
- llvm::APSInt IdxRes;
CharUnits EltSize = Ctx.getTypeSizeInChars(PointeeType);
- if (IntE->isIntegerConstantExpr(IdxRes, Ctx)) {
- CharUnits Offset = EltSize * IdxRes.getExtValue();
+ if (Optional<llvm::APSInt> IdxRes = IntE->getIntegerConstantExpr(Ctx)) {
+ CharUnits Offset = EltSize * IdxRes->getExtValue();
if (IsSub)
Offset = -Offset;
return std::make_pair(P->first, P->second + Offset);
@@ -14133,9 +14125,10 @@ namespace {
return;
if (Expr *RHS = BinOp->getRHS()) {
RHS = RHS->IgnoreParenCasts();
- llvm::APSInt Value;
+ Optional<llvm::APSInt> Value;
VarWillBeReased =
- (RHS && RHS->isIntegerConstantExpr(Value, Context) && Value == 0);
+ (RHS && (Value = RHS->getIntegerConstantExpr(Context)) &&
+ *Value == 0);
}
}
}
@@ -15362,14 +15355,15 @@ ExprResult Sema::SemaBuiltinMatrixTranspose(CallExpr *TheCall,
// Get and verify the matrix dimensions.
static llvm::Optional<unsigned>
getAndVerifyMatrixDimension(Expr *Expr, StringRef Name, Sema &S) {
- llvm::APSInt Value(64);
SourceLocation ErrorPos;
- if (!Expr->isIntegerConstantExpr(Value, S.Context, &ErrorPos)) {
+ Optional<llvm::APSInt> Value =
+ Expr->getIntegerConstantExpr(S.Context, &ErrorPos);
+ if (!Value) {
S.Diag(Expr->getBeginLoc(), diag::err_builtin_matrix_scalar_unsigned_arg)
<< Name;
return {};
}
- uint64_t Dim = Value.getZExtValue();
+ uint64_t Dim = Value->getZExtValue();
if (!ConstantMatrixType::isDimensionValid(Dim)) {
S.Diag(Expr->getBeginLoc(), diag::err_builtin_matrix_invalid_dimension)
<< Name << ConstantMatrixType::getMaxElementsPerDimension();
@@ -15473,13 +15467,15 @@ ExprResult Sema::SemaBuiltinMatrixColumnMajorLoad(CallExpr *TheCall,
StrideExpr = StrideConv.get();
TheCall->setArg(3, StrideExpr);
- llvm::APSInt Value(64);
- if (MaybeRows && StrideExpr->isIntegerConstantExpr(Value, Context)) {
- uint64_t Stride = Value.getZExtValue();
- if (Stride < *MaybeRows) {
- Diag(StrideExpr->getBeginLoc(),
- diag::err_builtin_matrix_stride_too_small);
- ArgError = true;
+ if (MaybeRows) {
+ if (Optional<llvm::APSInt> Value =
+ StrideExpr->getIntegerConstantExpr(Context)) {
+ uint64_t Stride = Value->getZExtValue();
+ if (Stride < *MaybeRows) {
+ Diag(StrideExpr->getBeginLoc(),
+ diag::err_builtin_matrix_stride_too_small);
+ ArgError = true;
+ }
}
}
@@ -15570,13 +15566,15 @@ ExprResult Sema::SemaBuiltinMatrixColumnMajorStore(CallExpr *TheCall,
}
// Check stride argument.
- llvm::APSInt Value(64);
- if (MatrixTy && StrideExpr->isIntegerConstantExpr(Value, Context)) {
- uint64_t Stride = Value.getZExtValue();
- if (Stride < MatrixTy->getNumRows()) {
- Diag(StrideExpr->getBeginLoc(),
- diag::err_builtin_matrix_stride_too_small);
- ArgError = true;
+ if (MatrixTy) {
+ if (Optional<llvm::APSInt> Value =
+ StrideExpr->getIntegerConstantExpr(Context)) {
+ uint64_t Stride = Value->getZExtValue();
+ if (Stride < MatrixTy->getNumRows()) {
+ Diag(StrideExpr->getBeginLoc(),
+ diag::err_builtin_matrix_stride_too_small);
+ ArgError = true;
+ }
}
}
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 406c9c712564..e37384e874e2 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -13150,20 +13150,20 @@ void Sema::FinalizeDeclaration(Decl *ThisDecl) {
if (!MagicValueExpr) {
continue;
}
- llvm::APSInt MagicValueInt;
- if (!MagicValueExpr->isIntegerConstantExpr(MagicValueInt, Context)) {
+ Optional<llvm::APSInt> MagicValueInt;
+ if (!(MagicValueInt = MagicValueExpr->getIntegerConstantExpr(Context))) {
Diag(I->getRange().getBegin(),
diag::err_type_tag_for_datatype_not_ice)
<< LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
continue;
}
- if (MagicValueInt.getActiveBits() > 64) {
+ if (MagicValueInt->getActiveBits() > 64) {
Diag(I->getRange().getBegin(),
diag::err_type_tag_for_datatype_too_large)
<< LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
continue;
}
- uint64_t MagicValue = MagicValueInt.getZExtValue();
+ uint64_t MagicValue = MagicValueInt->getZExtValue();
RegisterTypeTagForDatatype(I->getArgumentKind(),
MagicValue,
I->getMatchingCType(),
diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp
index 1a0594512a60..ece93cbd6a9b 100644
--- a/clang/lib/Sema/SemaDeclAttr.cpp
+++ b/clang/lib/Sema/SemaDeclAttr.cpp
@@ -240,9 +240,9 @@ template <typename AttrInfo>
static bool checkUInt32Argument(Sema &S, const AttrInfo &AI, const Expr *Expr,
uint32_t &Val, unsigned Idx = UINT_MAX,
bool StrictlyUnsigned = false) {
- llvm::APSInt I(32);
+ Optional<llvm::APSInt> I = llvm::APSInt(32);
if (Expr->isTypeDependent() || Expr->isValueDependent() ||
- !Expr->isIntegerConstantExpr(I, S.Context)) {
+ !(I = Expr->getIntegerConstantExpr(S.Context))) {
if (Idx != UINT_MAX)
S.Diag(getAttrLoc(AI), diag::err_attribute_argument_n_type)
<< &AI << Idx << AANT_ArgumentIntegerConstant
@@ -253,19 +253,19 @@ static bool checkUInt32Argument(Sema &S, const AttrInfo &AI, const Expr *Expr,
return false;
}
- if (!I.isIntN(32)) {
+ if (!I->isIntN(32)) {
S.Diag(Expr->getExprLoc(), diag::err_ice_too_large)
- << I.toString(10, false) << 32 << /* Unsigned */ 1;
+ << I->toString(10, false) << 32 << /* Unsigned */ 1;
return false;
}
- if (StrictlyUnsigned && I.isSigned() && I.isNegative()) {
+ if (StrictlyUnsigned && I->isSigned() && I->isNegative()) {
S.Diag(getAttrLoc(AI), diag::err_attribute_requires_positive_integer)
<< &AI << /*non-negative*/ 1;
return false;
}
- Val = (uint32_t)I.getZExtValue();
+ Val = (uint32_t)I->getZExtValue();
return true;
}
@@ -332,16 +332,16 @@ static bool checkFunctionOrMethodParameterIndex(
unsigned NumParams =
(HP ? getFunctionOrMethodNumParams(D) : 0) + HasImplicitThisParam;
- llvm::APSInt IdxInt;
+ Optional<llvm::APSInt> IdxInt;
if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
- !IdxExpr->isIntegerConstantExpr(IdxInt, S.Context)) {
+ !(IdxInt = IdxExpr->getIntegerConstantExpr(S.Context))) {
S.Diag(getAttrLoc(AI), diag::err_attribute_argument_n_type)
<< &AI << AttrArgNum << AANT_ArgumentIntegerConstant
<< IdxExpr->getSourceRange();
return false;
}
- unsigned IdxSource = IdxInt.getLimitedValue(UINT_MAX);
+ unsigned IdxSource = IdxInt->getLimitedValue(UINT_MAX);
if (IdxSource < 1 || (!IV && IdxSource > NumParams)) {
S.Diag(getAttrLoc(AI), diag::err_attribute_argument_out_of_bounds)
<< &AI << AttrArgNum << IdxExpr->getSourceRange();
@@ -1605,8 +1605,8 @@ void Sema::AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,
}
if (!E->isValueDependent()) {
- llvm::APSInt I(64);
- if (!E->isIntegerConstantExpr(I, Context)) {
+ Optional<llvm::APSInt> I = llvm::APSInt(64);
+ if (!(I = E->getIntegerConstantExpr(Context))) {
if (OE)
Diag(AttrLoc, diag::err_attribute_argument_n_type)
<< &TmpAttr << 1 << AANT_ArgumentIntegerConstant
@@ -1618,27 +1618,22 @@ void Sema::AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,
return;
}
- if (!I.isPowerOf2()) {
+ if (!I->isPowerOf2()) {
Diag(AttrLoc, diag::err_alignment_not_power_of_two)
<< E->getSourceRange();
return;
}
- if (I > Sema::MaximumAlignment)
+ if (*I > Sema::MaximumAlignment)
Diag(CI.getLoc(), diag::warn_assume_aligned_too_great)
<< CI.getRange() << Sema::MaximumAlignment;
}
- if (OE) {
- if (!OE->isValueDependent()) {
- llvm::APSInt I(64);
- if (!OE->isIntegerConstantExpr(I, Context)) {
- Diag(AttrLoc, diag::err_attribute_argument_n_type)
- << &TmpAttr << 2 << AANT_ArgumentIntegerConstant
- << OE->getSourceRange();
- return;
- }
- }
+ if (OE && !OE->isValueDependent() && !OE->isIntegerConstantExpr(Context)) {
+ Diag(AttrLoc, diag::err_attribute_argument_n_type)
+ << &TmpAttr << 2 << AANT_ArgumentIntegerConstant
+ << OE->getSourceRange();
+ return;
}
D->addAttr(::new (Context) AssumeAlignedAttr(Context, CI, E, OE));
@@ -2729,36 +2724,36 @@ static void handleSentinelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
unsigned sentinel = (unsigned)SentinelAttr::DefaultSentinel;
if (AL.getNumArgs() > 0) {
Expr *E = AL.getArgAsExpr(0);
- llvm::APSInt Idx(32);
+ Optional<llvm::APSInt> Idx = llvm::APSInt(32);
if (E->isTypeDependent() || E->isValueDependent() ||
- !E->isIntegerConstantExpr(Idx, S.Context)) {
+ !(Idx = E->getIntegerConstantExpr(S.Context))) {
S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
<< AL << 1 << AANT_ArgumentIntegerConstant << E->getSourceRange();
return;
}
- if (Idx.isSigned() && Idx.isNegative()) {
+ if (Idx->isSigned() && Idx->isNegative()) {
S.Diag(AL.getLoc(), diag::err_attribute_sentinel_less_than_zero)
<< E->getSourceRange();
return;
}
- sentinel = Idx.getZExtValue();
+ sentinel = Idx->getZExtValue();
}
unsigned nullPos = (unsigned)SentinelAttr::DefaultNullPos;
if (AL.getNumArgs() > 1) {
Expr *E = AL.getArgAsExpr(1);
- llvm::APSInt Idx(32);
+ Optional<llvm::APSInt> Idx = llvm::APSInt(32);
if (E->isTypeDependent() || E->isValueDependent() ||
- !E->isIntegerConstantExpr(Idx, S.Context)) {
+ !(Idx = E->getIntegerConstantExpr(S.Context))) {
S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
<< AL << 2 << AANT_ArgumentIntegerConstant << E->getSourceRange();
return;
}
- nullPos = Idx.getZExtValue();
+ nullPos = Idx->getZExtValue();
- if ((Idx.isSigned() && Idx.isNegative()) || nullPos > 1) {
+ if ((Idx->isSigned() && Idx->isNegative()) || nullPos > 1) {
// FIXME: This error message could be improved, it would be nice
// to say what the bounds actually are.
S.Diag(AL.getLoc(), diag::err_attribute_sentinel_not_zero_or_one)
@@ -4833,19 +4828,19 @@ static Expr *makeLaunchBoundsArgExpr(Sema &S, Expr *E,
if (E->isValueDependent())
return E;
- llvm::APSInt I(64);
- if (!E->isIntegerConstantExpr(I, S.Context)) {
+ Optional<llvm::APSInt> I = llvm::APSInt(64);
+ if (!(I = E->getIntegerConstantExpr(S.Context))) {
S.Diag(E->getExprLoc(), diag::err_attribute_argument_n_type)
<< &AL << Idx << AANT_ArgumentIntegerConstant << E->getSourceRange();
return nullptr;
}
// Make sure we can fit it in 32 bits.
- if (!I.isIntN(32)) {
- S.Diag(E->getExprLoc(), diag::err_ice_too_large) << I.toString(10, false)
- << 32 << /* Unsigned */ 1;
+ if (!I->isIntN(32)) {
+ S.Diag(E->getExprLoc(), diag::err_ice_too_large)
+ << I->toString(10, false) << 32 << /* Unsigned */ 1;
return nullptr;
}
- if (I < 0)
+ if (*I < 0)
S.Diag(E->getExprLoc(), diag::warn_attribute_argument_n_negative)
<< &AL << Idx << E->getSourceRange();
@@ -5686,18 +5681,18 @@ static void handleMSP430InterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
}
Expr *NumParamsExpr = static_cast<Expr *>(AL.getArgAsExpr(0));
- llvm::APSInt NumParams(32);
- if (!NumParamsExpr->isIntegerConstantExpr(NumParams, S.Context)) {
+ Optional<llvm::APSInt> NumParams = llvm::APSInt(32);
+ if (!(NumParams = NumParamsExpr->getIntegerConstantExpr(S.Context))) {
S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
<< AL << AANT_ArgumentIntegerConstant
<< NumParamsExpr->getSourceRange();
return;
}
// The argument should be in range 0..63.
- unsigned Num = NumParams.getLimitedValue(255);
+ unsigned Num = NumParams->getLimitedValue(255);
if (Num > 63) {
S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
- << AL << (int)NumParams.getSExtValue()
+ << AL << (int)NumParams->getSExtValue()
<< NumParamsExpr->getSourceRange();
return;
}
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index 0bed0ddf539b..ad44302cea45 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -4741,12 +4741,13 @@ ExprResult Sema::CreateBuiltinMatrixSubscriptExpr(Expr *Base, Expr *RowIdx,
return nullptr;
}
- llvm::APSInt Idx;
- if (IndexExpr->isIntegerConstantExpr(Idx, Context) &&
- (Idx < 0 || Idx >= Dim)) {
- Diag(IndexExpr->getBeginLoc(), diag::err_matrix_index_outside_range)
- << IsColumnIdx << Dim;
- return nullptr;
+ if (Optional<llvm::APSInt> Idx =
+ IndexExpr->getIntegerConstantExpr(Context)) {
+ if ((*Idx < 0 || *Idx >= Dim)) {
+ Diag(IndexExpr->getBeginLoc(), diag::err_matrix_index_outside_range)
+ << IsColumnIdx << Dim;
+ return nullptr;
+ }
}
ExprResult ConvExpr =
@@ -5162,12 +5163,11 @@ ExprResult Sema::ActOnOMPIteratorExpr(Scope *S, SourceLocation IteratorKwLoc,
IsCorrect = false;
continue;
}
- llvm::APSInt Result;
- bool IsConstant = Step->isIntegerConstantExpr(Result, Context);
+ Optional<llvm::APSInt> Result = Step->getIntegerConstantExpr(Context);
// OpenMP 5.0, 2.1.6 Iterators, Restrictions
// If the step expression of a range-specification equals zero, the
// behavior is unspecified.
- if (IsConstant && Result.isNullValue()) {
+ if (Result && Result->isNullValue()) {
Diag(Step->getExprLoc(), diag::err_omp_iterator_step_constant_zero)
<< Step << Step->getSourceRange();
IsCorrect = false;
diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp
index 10da9595c658..3d5cd965980d 100644
--- a/clang/lib/Sema/SemaExprCXX.cpp
+++ b/clang/lib/Sema/SemaExprCXX.cpp
@@ -2076,29 +2076,29 @@ Sema::BuildCXXNew(SourceRange Range, bool UseGlobal,
// per CWG1464. Otherwise, if it's not a constant, we must have an
// unparenthesized array type.
if (!(*ArraySize)->isValueDependent()) {
- llvm::APSInt Value;
// We've already performed any required implicit conversion to integer or
// unscoped enumeration type.
// FIXME: Per CWG1464, we are required to check the value prior to
// converting to size_t. This will never find a negative array size in
// C++14 onwards, because Value is always unsigned here!
- if ((*ArraySize)->isIntegerConstantExpr(Value, Context)) {
- if (Value.isSigned() && Value.isNegative()) {
+ if (Optional<llvm::APSInt> Value =
+ (*ArraySize)->getIntegerConstantExpr(Context)) {
+ if (Value->isSigned() && Value->isNegative()) {
return ExprError(Diag((*ArraySize)->getBeginLoc(),
diag::err_typecheck_negative_array_size)
<< (*ArraySize)->getSourceRange());
}
if (!AllocType->isDependentType()) {
- unsigned ActiveSizeBits =
- ConstantArrayType::getNumAddressingBits(Context, AllocType, Value);
+ unsigned ActiveSizeBits = ConstantArrayType::getNumAddressingBits(
+ Context, AllocType, *Value);
if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context))
return ExprError(
Diag((*ArraySize)->getBeginLoc(), diag::err_array_too_large)
- << Value.toString(10) << (*ArraySize)->getSourceRange());
+ << Value->toString(10) << (*ArraySize)->getSourceRange());
}
- KnownArraySize = Value.getZExtValue();
+ KnownArraySize = Value->getZExtValue();
} else if (TypeIdParens.isValid()) {
// Can't have dynamic array size when the type-id is in parentheses.
Diag((*ArraySize)->getBeginLoc(), diag::ext_new_paren_array_nonconst)
diff --git a/clang/lib/Sema/SemaOpenMP.cpp b/clang/lib/Sema/SemaOpenMP.cpp
index 3c9fdbddfa75..452c4d526b7a 100644
--- a/clang/lib/Sema/SemaOpenMP.cpp
+++ b/clang/lib/Sema/SemaOpenMP.cpp
@@ -6027,8 +6027,7 @@ Sema::checkOpenMPDeclareVariantFunction(Sema::DeclGroupPtrTy DG,
// Deal with non-constant score and user condition expressions.
auto HandleNonConstantScoresAndConditions = [this](Expr *&E,
bool IsScore) -> bool {
- llvm::APSInt Result;
- if (!E || E->isIntegerConstantExpr(Result, Context))
+ if (!E || E->isIntegerConstantExpr(Context))
return false;
if (IsScore) {
@@ -6514,14 +6513,14 @@ bool OpenMPIterationSpaceChecker::setStep(Expr *NewStep, bool Subtract) {
// loop. If test-expr is of form b relational-op var and relational-op is
// > or >= then incr-expr must cause var to increase on each iteration of
// the loop.
- llvm::APSInt Result;
- bool IsConstant = NewStep->isIntegerConstantExpr(Result, SemaRef.Context);
+ Optional<llvm::APSInt> Result =
+ NewStep->getIntegerConstantExpr(SemaRef.Context);
bool IsUnsigned = !NewStep->getType()->hasSignedIntegerRepresentation();
bool IsConstNeg =
- IsConstant && Result.isSigned() && (Subtract != Result.isNegative());
+ Result && Result->isSigned() && (Subtract != Result->isNegative());
bool IsConstPos =
- IsConstant && Result.isSigned() && (Subtract == Result.isNegative());
- bool IsConstZero = IsConstant && !Result.getBoolValue();
+ Result && Result->isSigned() && (Subtract == Result->isNegative());
+ bool IsConstZero = Result && !Result->getBoolValue();
// != with increment is treated as <; != with decrement is treated as >
if (!TestIsLessOp.hasValue())
@@ -6969,9 +6968,16 @@ calculateNumIters(Sema &SemaRef, Scope *S, SourceLocation DefaultLoc,
ExprResult NewStep = tryBuildCapture(SemaRef, Step, Captures);
if (!NewStep.isUsable())
return nullptr;
- llvm::APSInt LRes, URes, SRes;
- bool IsLowerConst = Lower->isIntegerConstantExpr(LRes, SemaRef.Context);
- bool IsStepConst = Step->isIntegerConstantExpr(SRes, SemaRef.Context);
+ llvm::APSInt LRes, SRes;
+ bool IsLowerConst = false, IsStepConst = false;
+ if (Optional<llvm::APSInt> Res = Lower->getIntegerConstantExpr(SemaRef.Context)) {
+ LRes = *Res;
+ IsLowerConst = true;
+ }
+ if (Optional<llvm::APSInt> Res = Step->getIntegerConstantExpr(SemaRef.Context)) {
+ SRes = *Res;
+ IsStepConst = true;
+ }
bool NoNeedToConvert = IsLowerConst && !RoundToStep &&
((!TestIsStrictOp && LRes.isNonNegative()) ||
(TestIsStrictOp && LRes.isStrictlyPositive()));
@@ -7004,7 +7010,12 @@ calculateNumIters(Sema &SemaRef, Scope *S, SourceLocation DefaultLoc,
}
NeedToReorganize = NoNeedToConvert;
}
- bool IsUpperConst = Upper->isIntegerConstantExpr(URes, SemaRef.Context);
+ llvm::APSInt URes;
+ bool IsUpperConst = false;
+ if (Optional<llvm::APSInt> Res = Upper->getIntegerConstantExpr(SemaRef.Context)) {
+ URes = *Res;
+ IsUpperConst = true;
+ }
if (NoNeedToConvert && IsLowerConst && IsUpperConst &&
(!RoundToStep || IsStepConst)) {
unsigned BW = LRes.getBitWidth() > URes.getBitWidth() ? LRes.getBitWidth()
@@ -7952,9 +7963,9 @@ static ExprResult widenIterationCount(unsigned Bits, Expr *E, Sema &SemaRef) {
static bool fitsInto(unsigned Bits, bool Signed, const Expr *E, Sema &SemaRef) {
if (E == nullptr)
return false;
- llvm::APSInt Result;
- if (E->isIntegerConstantExpr(Result, SemaRef.Context))
- return Signed ? Result.isSignedIntN(Bits) : Result.isIntN(Bits);
+ if (Optional<llvm::APSInt> Result =
+ E->getIntegerConstantExpr(SemaRef.Context))
+ return Signed ? Result->isSignedIntN(Bits) : Result->isIntN(Bits);
return false;
}
@@ -8227,9 +8238,7 @@ checkOpenMPLoop(OpenMPDirectiveKind DKind, Expr *CollapseLoopCountExpr,
// Calculate the last iteration number beforehand instead of doing this on
// each iteration. Do not do this if the number of iterations may be kfold-ed.
- llvm::APSInt Result;
- bool IsConstant =
- LastIteration.get()->isIntegerConstantExpr(Result, SemaRef.Context);
+ bool IsConstant = LastIteration.get()->isIntegerConstantExpr(SemaRef.Context);
ExprResult CalcLastIteration;
if (!IsConstant) {
ExprResult SaveRef =
@@ -12620,15 +12629,16 @@ isNonNegativeIntegerValue(Expr *&ValExpr, Sema &SemaRef, OpenMPClauseKind CKind,
ValExpr = Value.get();
// The expression must evaluate to a non-negative integer value.
- llvm::APSInt Result;
- if (ValExpr->isIntegerConstantExpr(Result, SemaRef.Context) &&
- Result.isSigned() &&
- !((!StrictlyPositive && Result.isNonNegative()) ||
- (StrictlyPositive && Result.isStrictlyPositive()))) {
- SemaRef.Diag(Loc, diag::err_omp_negative_expression_in_clause)
- << getOpenMPClauseName(CKind) << (StrictlyPositive ? 1 : 0)
- << ValExpr->getSourceRange();
- return false;
+ if (Optional<llvm::APSInt> Result =
+ ValExpr->getIntegerConstantExpr(SemaRef.Context)) {
+ if (Result->isSigned() &&
+ !((!StrictlyPositive && Result->isNonNegative()) ||
+ (StrictlyPositive && Result->isStrictlyPositive()))) {
+ SemaRef.Diag(Loc, diag::err_omp_negative_expression_in_clause)
+ << getOpenMPClauseName(CKind) << (StrictlyPositive ? 1 : 0)
+ << ValExpr->getSourceRange();
+ return false;
+ }
}
if (!BuildCapture)
return true;
@@ -13263,9 +13273,9 @@ OMPClause *Sema::ActOnOpenMPScheduleClause(
// OpenMP [2.7.1, Restrictions]
// chunk_size must be a loop invariant integer expression with a positive
// value.
- llvm::APSInt Result;
- if (ValExpr->isIntegerConstantExpr(Result, Context)) {
- if (Result.isSigned() && !Result.isStrictlyPositive()) {
+ if (Optional<llvm::APSInt> Result =
+ ValExpr->getIntegerConstantExpr(Context)) {
+ if (Result->isSigned() && !Result->isStrictlyPositive()) {
Diag(ChunkSizeLoc, diag::err_omp_negative_expression_in_clause)
<< "schedule" << 1 << ChunkSize->getSourceRange();
return nullptr;
@@ -15742,12 +15752,12 @@ OMPClause *Sema::ActOnOpenMPLinearClause(
// Warn about zero linear step (it would be probably better specified as
// making corresponding variables 'const').
- llvm::APSInt Result;
- bool IsConstant = StepExpr->isIntegerConstantExpr(Result, Context);
- if (IsConstant && !Result.isNegative() && !Result.isStrictlyPositive())
- Diag(StepLoc, diag::warn_omp_linear_step_zero) << Vars[0]
- << (Vars.size() > 1);
- if (!IsConstant && CalcStep.isUsable()) {
+ if (Optional<llvm::APSInt> Result =
+ StepExpr->getIntegerConstantExpr(Context)) {
+ if (!Result->isNegative() && !Result->isStrictlyPositive())
+ Diag(StepLoc, diag::warn_omp_linear_step_zero)
+ << Vars[0] << (Vars.size() > 1);
+ } else if (CalcStep.isUsable()) {
// Calculate the step beforehand instead of doing this on each iteration.
// (This is not used if the number of iterations may be kfold-ed).
CalcStepExpr = CalcStep.get();
@@ -18280,9 +18290,9 @@ OMPClause *Sema::ActOnOpenMPDistScheduleClause(
// OpenMP [2.7.1, Restrictions]
// chunk_size must be a loop invariant integer expression with a positive
// value.
- llvm::APSInt Result;
- if (ValExpr->isIntegerConstantExpr(Result, Context)) {
- if (Result.isSigned() && !Result.isStrictlyPositive()) {
+ if (Optional<llvm::APSInt> Result =
+ ValExpr->getIntegerConstantExpr(Context)) {
+ if (Result->isSigned() && !Result->isStrictlyPositive()) {
Diag(ChunkSizeLoc, diag::err_omp_negative_expression_in_clause)
<< "dist_schedule" << ChunkSize->getSourceRange();
return nullptr;
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index 8635397f4806..7c6acf011d57 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -346,7 +346,6 @@ NarrowingKind StandardConversionSequence::getNarrowingKind(
ToType->isRealFloatingType()) {
if (IgnoreFloatToIntegralConversion)
return NK_Not_Narrowing;
- llvm::APSInt IntConstantValue;
const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
assert(Initializer && "Unknown conversion expression");
@@ -354,19 +353,20 @@ NarrowingKind StandardConversionSequence::getNarrowingKind(
if (Initializer->isValueDependent())
return NK_Dependent_Narrowing;
- if (Initializer->isIntegerConstantExpr(IntConstantValue, Ctx)) {
+ if (Optional<llvm::APSInt> IntConstantValue =
+ Initializer->getIntegerConstantExpr(Ctx)) {
// Convert the integer to the floating type.
llvm::APFloat Result(Ctx.getFloatTypeSemantics(ToType));
- Result.convertFromAPInt(IntConstantValue, IntConstantValue.isSigned(),
+ Result.convertFromAPInt(*IntConstantValue, IntConstantValue->isSigned(),
llvm::APFloat::rmNearestTiesToEven);
// And back.
- llvm::APSInt ConvertedValue = IntConstantValue;
+ llvm::APSInt ConvertedValue = *IntConstantValue;
bool ignored;
Result.convertToInteger(ConvertedValue,
llvm::APFloat::rmTowardZero, &ignored);
// If the resulting value is
diff erent, this was a narrowing conversion.
- if (IntConstantValue != ConvertedValue) {
- ConstantValue = APValue(IntConstantValue);
+ if (*IntConstantValue != ConvertedValue) {
+ ConstantValue = APValue(*IntConstantValue);
ConstantType = Initializer->getType();
return NK_Constant_Narrowing;
}
@@ -430,17 +430,18 @@ NarrowingKind StandardConversionSequence::getNarrowingKind(
(FromWidth == ToWidth && FromSigned != ToSigned) ||
(FromSigned && !ToSigned)) {
// Not all values of FromType can be represented in ToType.
- llvm::APSInt InitializerValue;
const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
// If it's value-dependent, we can't tell whether it's narrowing.
if (Initializer->isValueDependent())
return NK_Dependent_Narrowing;
- if (!Initializer->isIntegerConstantExpr(InitializerValue, Ctx)) {
+ Optional<llvm::APSInt> OptInitializerValue;
+ if (!(OptInitializerValue = Initializer->getIntegerConstantExpr(Ctx))) {
// Such conversions on variables are always narrowing.
return NK_Variable_Narrowing;
}
+ llvm::APSInt &InitializerValue = *OptInitializerValue;
bool Narrowing = false;
if (FromWidth < ToWidth) {
// Negative -> unsigned is narrowing. Otherwise, more bits is never
@@ -2183,21 +2184,22 @@ bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
// compatibility.
if (From) {
if (FieldDecl *MemberDecl = From->getSourceBitField()) {
- llvm::APSInt BitWidth;
+ Optional<llvm::APSInt> BitWidth;
if (FromType->isIntegralType(Context) &&
- MemberDecl->getBitWidth()->isIntegerConstantExpr(BitWidth, Context)) {
- llvm::APSInt ToSize(BitWidth.getBitWidth(), BitWidth.isUnsigned());
+ (BitWidth =
+ MemberDecl->getBitWidth()->getIntegerConstantExpr(Context))) {
+ llvm::APSInt ToSize(BitWidth->getBitWidth(), BitWidth->isUnsigned());
ToSize = Context.getTypeSize(ToType);
// Are we promoting to an int from a bitfield that fits in an int?
- if (BitWidth < ToSize ||
- (FromType->isSignedIntegerType() && BitWidth <= ToSize)) {
+ if (*BitWidth < ToSize ||
+ (FromType->isSignedIntegerType() && *BitWidth <= ToSize)) {
return To->getKind() == BuiltinType::Int;
}
// Are we promoting to an unsigned int from an unsigned bitfield
// that fits into an unsigned int?
- if (FromType->isUnsignedIntegerType() && BitWidth <= ToSize) {
+ if (FromType->isUnsignedIntegerType() && *BitWidth <= ToSize) {
return To->getKind() == BuiltinType::UInt;
}
diff --git a/clang/lib/Sema/SemaStmtAttr.cpp b/clang/lib/Sema/SemaStmtAttr.cpp
index eb56245e1954..0910ca88c6b7 100644
--- a/clang/lib/Sema/SemaStmtAttr.cpp
+++ b/clang/lib/Sema/SemaStmtAttr.cpp
@@ -336,15 +336,15 @@ static Attr *handleOpenCLUnrollHint(Sema &S, Stmt *St, const ParsedAttr &A,
if (NumArgs == 1) {
Expr *E = A.getArgAsExpr(0);
- llvm::APSInt ArgVal(32);
+ Optional<llvm::APSInt> ArgVal;
- if (!E->isIntegerConstantExpr(ArgVal, S.Context)) {
+ if (!(ArgVal = E->getIntegerConstantExpr(S.Context))) {
S.Diag(A.getLoc(), diag::err_attribute_argument_type)
<< A << AANT_ArgumentIntegerConstant << E->getSourceRange();
return nullptr;
}
- int Val = ArgVal.getSExtValue();
+ int Val = ArgVal->getSExtValue();
if (Val <= 0) {
S.Diag(A.getRange().getBegin(),
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index 5392be57a3aa..52062e9a5039 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -2100,24 +2100,23 @@ DeduceTemplateArgumentsByTypeMatch(Sema &S,
const auto *ArgConstMatrix = dyn_cast<ConstantMatrixType>(Arg);
const auto *ArgDepMatrix = dyn_cast<DependentSizedMatrixType>(Arg);
if (!ParamExpr->isValueDependent()) {
- llvm::APSInt ParamConst(
- S.Context.getTypeSize(S.Context.getSizeType()));
- if (!ParamExpr->isIntegerConstantExpr(ParamConst, S.Context))
+ Optional<llvm::APSInt> ParamConst =
+ ParamExpr->getIntegerConstantExpr(S.Context);
+ if (!ParamConst)
return Sema::TDK_NonDeducedMismatch;
if (ArgConstMatrix) {
- if ((ArgConstMatrix->*GetArgDimension)() == ParamConst)
+ if ((ArgConstMatrix->*GetArgDimension)() == *ParamConst)
return Sema::TDK_Success;
return Sema::TDK_NonDeducedMismatch;
}
Expr *ArgExpr = (ArgDepMatrix->*GetArgDimensionExpr)();
- llvm::APSInt ArgConst(
- S.Context.getTypeSize(S.Context.getSizeType()));
- if (!ArgExpr->isValueDependent() &&
- ArgExpr->isIntegerConstantExpr(ArgConst, S.Context) &&
- ArgConst == ParamConst)
- return Sema::TDK_Success;
+ if (!ArgExpr->isValueDependent())
+ if (Optional<llvm::APSInt> ArgConst =
+ ArgExpr->getIntegerConstantExpr(S.Context))
+ if (*ArgConst == *ParamConst)
+ return Sema::TDK_Success;
return Sema::TDK_NonDeducedMismatch;
}
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index 38cb83938ad2..09def48a158e 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -2477,8 +2477,8 @@ QualType Sema::BuildVectorType(QualType CurType, Expr *SizeExpr,
return Context.getDependentVectorType(CurType, SizeExpr, AttrLoc,
VectorType::GenericVector);
- llvm::APSInt VecSize(32);
- if (!SizeExpr->isIntegerConstantExpr(VecSize, Context)) {
+ Optional<llvm::APSInt> VecSize = SizeExpr->getIntegerConstantExpr(Context);
+ if (!VecSize) {
Diag(AttrLoc, diag::err_attribute_argument_type)
<< "vector_size" << AANT_ArgumentIntegerConstant
<< SizeExpr->getSourceRange();
@@ -2490,13 +2490,13 @@ QualType Sema::BuildVectorType(QualType CurType, Expr *SizeExpr,
VectorType::GenericVector);
// vecSize is specified in bytes - convert to bits.
- if (!VecSize.isIntN(61)) {
+ if (!VecSize->isIntN(61)) {
// Bit size will overflow uint64.
Diag(AttrLoc, diag::err_attribute_size_too_large)
<< SizeExpr->getSourceRange() << "vector";
return QualType();
}
- uint64_t VectorSizeBits = VecSize.getZExtValue() * 8;
+ uint64_t VectorSizeBits = VecSize->getZExtValue() * 8;
unsigned TypeSize = static_cast<unsigned>(Context.getTypeSize(CurType));
if (VectorSizeBits == 0) {
@@ -2541,22 +2541,22 @@ QualType Sema::BuildExtVectorType(QualType T, Expr *ArraySize,
}
if (!ArraySize->isTypeDependent() && !ArraySize->isValueDependent()) {
- llvm::APSInt vecSize(32);
- if (!ArraySize->isIntegerConstantExpr(vecSize, Context)) {
+ Optional<llvm::APSInt> vecSize = ArraySize->getIntegerConstantExpr(Context);
+ if (!vecSize) {
Diag(AttrLoc, diag::err_attribute_argument_type)
<< "ext_vector_type" << AANT_ArgumentIntegerConstant
<< ArraySize->getSourceRange();
return QualType();
}
- if (!vecSize.isIntN(32)) {
+ if (!vecSize->isIntN(32)) {
Diag(AttrLoc, diag::err_attribute_size_too_large)
<< ArraySize->getSourceRange() << "vector";
return QualType();
}
// Unlike gcc's vector_size attribute, the size is specified as the
// number of elements, not the number of bytes.
- unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue());
+ unsigned vectorSize = static_cast<unsigned>(vecSize->getZExtValue());
if (vectorSize == 0) {
Diag(AttrLoc, diag::err_attribute_zero_size)
@@ -2587,18 +2587,15 @@ QualType Sema::BuildMatrixType(QualType ElementTy, Expr *NumRows, Expr *NumCols,
return Context.getDependentSizedMatrixType(ElementTy, NumRows, NumCols,
AttrLoc);
- // Both row and column values can only be 20 bit wide currently.
- llvm::APSInt ValueRows(32), ValueColumns(32);
-
- bool const RowsIsInteger = NumRows->isIntegerConstantExpr(ValueRows, Context);
- bool const ColumnsIsInteger =
- NumCols->isIntegerConstantExpr(ValueColumns, Context);
+ Optional<llvm::APSInt> ValueRows = NumRows->getIntegerConstantExpr(Context);
+ Optional<llvm::APSInt> ValueColumns =
+ NumCols->getIntegerConstantExpr(Context);
auto const RowRange = NumRows->getSourceRange();
auto const ColRange = NumCols->getSourceRange();
// Both are row and column expressions are invalid.
- if (!RowsIsInteger && !ColumnsIsInteger) {
+ if (!ValueRows && !ValueColumns) {
Diag(AttrLoc, diag::err_attribute_argument_type)
<< "matrix_type" << AANT_ArgumentIntegerConstant << RowRange
<< ColRange;
@@ -2606,22 +2603,22 @@ QualType Sema::BuildMatrixType(QualType ElementTy, Expr *NumRows, Expr *NumCols,
}
// Only the row expression is invalid.
- if (!RowsIsInteger) {
+ if (!ValueRows) {
Diag(AttrLoc, diag::err_attribute_argument_type)
<< "matrix_type" << AANT_ArgumentIntegerConstant << RowRange;
return QualType();
}
// Only the column expression is invalid.
- if (!ColumnsIsInteger) {
+ if (!ValueColumns) {
Diag(AttrLoc, diag::err_attribute_argument_type)
<< "matrix_type" << AANT_ArgumentIntegerConstant << ColRange;
return QualType();
}
// Check the matrix dimensions.
- unsigned MatrixRows = static_cast<unsigned>(ValueRows.getZExtValue());
- unsigned MatrixColumns = static_cast<unsigned>(ValueColumns.getZExtValue());
+ unsigned MatrixRows = static_cast<unsigned>(ValueRows->getZExtValue());
+ unsigned MatrixColumns = static_cast<unsigned>(ValueColumns->getZExtValue());
if (MatrixRows == 0 && MatrixColumns == 0) {
Diag(AttrLoc, diag::err_attribute_zero_size)
<< "matrix" << RowRange << ColRange;
@@ -6255,13 +6252,15 @@ static bool BuildAddressSpaceIndex(Sema &S, LangAS &ASIdx,
const Expr *AddrSpace,
SourceLocation AttrLoc) {
if (!AddrSpace->isValueDependent()) {
- llvm::APSInt addrSpace(32);
- if (!AddrSpace->isIntegerConstantExpr(addrSpace, S.Context)) {
+ Optional<llvm::APSInt> OptAddrSpace =
+ AddrSpace->getIntegerConstantExpr(S.Context);
+ if (!OptAddrSpace) {
S.Diag(AttrLoc, diag::err_attribute_argument_type)
<< "'address_space'" << AANT_ArgumentIntegerConstant
<< AddrSpace->getSourceRange();
return false;
}
+ llvm::APSInt &addrSpace = *OptAddrSpace;
// Bounds checking.
if (addrSpace.isSigned()) {
@@ -7738,7 +7737,7 @@ static void HandleNeonVectorTypeAttr(QualType &CurType, const ParsedAttr &Attr,
// The total size of the vector must be 64 or 128 bits.
unsigned typeSize = static_cast<unsigned>(S.Context.getTypeSize(CurType));
- unsigned numElts = static_cast<unsigned>(numEltsInt.getZExtValue());
+ unsigned numElts = static_cast<unsigned>(numEltsInt->getZExtValue());
unsigned vecSize = typeSize * numElts;
if (vecSize != 64 && vecSize != 128) {
S.Diag(Attr.getLoc(), diag::err_attribute_bad_neon_vector_size) << CurType;
More information about the cfe-commits
mailing list