4e7cf1b1ed
Add an `EvaluationResult` class. This contains the result either as a `Pointer` or as a `APValue`. This way, we can inspect the result of the evaluation and diagnose problems with it (e.g. uninitialized fields in global initializers or pointers pointing to things they shouldn't point to).
616 lines
18 KiB
C++
616 lines
18 KiB
C++
//===------- Interp.cpp - Interpreter for the constexpr VM ------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "Interp.h"
|
|
#include <limits>
|
|
#include <vector>
|
|
#include "Function.h"
|
|
#include "InterpFrame.h"
|
|
#include "InterpStack.h"
|
|
#include "Opcode.h"
|
|
#include "PrimType.h"
|
|
#include "Program.h"
|
|
#include "State.h"
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/AST/ASTDiagnostic.h"
|
|
#include "clang/AST/CXXInheritance.h"
|
|
#include "clang/AST/Expr.h"
|
|
#include "clang/AST/ExprCXX.h"
|
|
#include "llvm/ADT/APSInt.h"
|
|
|
|
using namespace clang;
|
|
using namespace clang::interp;
|
|
|
|
static bool RetValue(InterpState &S, CodePtr &Pt, APValue &Result) {
|
|
llvm::report_fatal_error("Interpreter cannot return values");
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Jmp, Jt, Jf
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
static bool Jmp(InterpState &S, CodePtr &PC, int32_t Offset) {
|
|
PC += Offset;
|
|
return true;
|
|
}
|
|
|
|
static bool Jt(InterpState &S, CodePtr &PC, int32_t Offset) {
|
|
if (S.Stk.pop<bool>()) {
|
|
PC += Offset;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool Jf(InterpState &S, CodePtr &PC, int32_t Offset) {
|
|
if (!S.Stk.pop<bool>()) {
|
|
PC += Offset;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static void diagnoseNonConstVariable(InterpState &S, CodePtr OpPC,
|
|
const ValueDecl *VD) {
|
|
if (!S.getLangOpts().CPlusPlus)
|
|
return;
|
|
|
|
const SourceInfo &Loc = S.Current->getSource(OpPC);
|
|
|
|
if (VD->getType()->isIntegralOrEnumerationType())
|
|
S.FFDiag(Loc, diag::note_constexpr_ltor_non_const_int, 1) << VD;
|
|
else
|
|
S.FFDiag(Loc,
|
|
S.getLangOpts().CPlusPlus11
|
|
? diag::note_constexpr_ltor_non_constexpr
|
|
: diag::note_constexpr_ltor_non_integral,
|
|
1)
|
|
<< VD << VD->getType();
|
|
S.Note(VD->getLocation(), diag::note_declared_at);
|
|
}
|
|
|
|
static bool CheckActive(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
|
|
AccessKinds AK) {
|
|
if (Ptr.isActive())
|
|
return true;
|
|
|
|
// Get the inactive field descriptor.
|
|
const FieldDecl *InactiveField = Ptr.getField();
|
|
|
|
// Walk up the pointer chain to find the union which is not active.
|
|
Pointer U = Ptr.getBase();
|
|
while (!U.isActive()) {
|
|
U = U.getBase();
|
|
}
|
|
|
|
// Find the active field of the union.
|
|
const Record *R = U.getRecord();
|
|
assert(R && R->isUnion() && "Not a union");
|
|
const FieldDecl *ActiveField = nullptr;
|
|
for (unsigned I = 0, N = R->getNumFields(); I < N; ++I) {
|
|
const Pointer &Field = U.atField(R->getField(I)->Offset);
|
|
if (Field.isActive()) {
|
|
ActiveField = Field.getField();
|
|
break;
|
|
}
|
|
}
|
|
|
|
const SourceInfo &Loc = S.Current->getSource(OpPC);
|
|
S.FFDiag(Loc, diag::note_constexpr_access_inactive_union_member)
|
|
<< AK << InactiveField << !ActiveField << ActiveField;
|
|
return false;
|
|
}
|
|
|
|
static bool CheckTemporary(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
|
|
AccessKinds AK) {
|
|
if (auto ID = Ptr.getDeclID()) {
|
|
if (!Ptr.isStaticTemporary())
|
|
return true;
|
|
|
|
if (Ptr.getDeclDesc()->getType().isConstQualified())
|
|
return true;
|
|
|
|
if (S.P.getCurrentDecl() == ID)
|
|
return true;
|
|
|
|
const SourceInfo &E = S.Current->getSource(OpPC);
|
|
S.FFDiag(E, diag::note_constexpr_access_static_temporary, 1) << AK;
|
|
S.Note(Ptr.getDeclLoc(), diag::note_constexpr_temporary_here);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool CheckGlobal(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
|
|
if (auto ID = Ptr.getDeclID()) {
|
|
if (!Ptr.isStatic())
|
|
return true;
|
|
|
|
if (S.P.getCurrentDecl() == ID)
|
|
return true;
|
|
|
|
S.FFDiag(S.Current->getLocation(OpPC), diag::note_constexpr_modify_global);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
namespace clang {
|
|
namespace interp {
|
|
static void popArg(InterpState &S, const Expr *Arg) {
|
|
PrimType Ty = S.getContext().classify(Arg->getType()).value_or(PT_Ptr);
|
|
TYPE_SWITCH(Ty, S.Stk.discard<T>());
|
|
}
|
|
|
|
void cleanupAfterFunctionCall(InterpState &S, CodePtr OpPC) {
|
|
assert(S.Current);
|
|
const Function *CurFunc = S.Current->getFunction();
|
|
assert(CurFunc);
|
|
|
|
if (CurFunc->isUnevaluatedBuiltin())
|
|
return;
|
|
|
|
// Some builtin functions require us to only look at the call site, since
|
|
// the classified parameter types do not match.
|
|
if (CurFunc->isBuiltin()) {
|
|
const auto *CE =
|
|
cast<CallExpr>(S.Current->Caller->getExpr(S.Current->getRetPC()));
|
|
for (int32_t I = CE->getNumArgs() - 1; I >= 0; --I) {
|
|
const Expr *A = CE->getArg(I);
|
|
popArg(S, A);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (S.Current->Caller && CurFunc->isVariadic()) {
|
|
// CallExpr we're look for is at the return PC of the current function, i.e.
|
|
// in the caller.
|
|
// This code path should be executed very rarely.
|
|
const auto *CE =
|
|
cast<CallExpr>(S.Current->Caller->getExpr(S.Current->getRetPC()));
|
|
unsigned FixedParams = CurFunc->getNumParams();
|
|
int32_t ArgsToPop = CE->getNumArgs() - FixedParams;
|
|
assert(ArgsToPop >= 0);
|
|
for (int32_t I = ArgsToPop - 1; I >= 0; --I) {
|
|
const Expr *A = CE->getArg(FixedParams + I);
|
|
popArg(S, A);
|
|
}
|
|
}
|
|
// And in any case, remove the fixed parameters (the non-variadic ones)
|
|
// at the end.
|
|
S.Current->popArgs();
|
|
}
|
|
|
|
bool CheckExtern(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
|
|
if (!Ptr.isExtern())
|
|
return true;
|
|
|
|
if (!S.checkingPotentialConstantExpression() && S.getLangOpts().CPlusPlus) {
|
|
const auto *VD = Ptr.getDeclDesc()->asValueDecl();
|
|
diagnoseNonConstVariable(S, OpPC, VD);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CheckArray(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
|
|
if (!Ptr.isUnknownSizeArray())
|
|
return true;
|
|
const SourceInfo &E = S.Current->getSource(OpPC);
|
|
S.FFDiag(E, diag::note_constexpr_unsized_array_indexed);
|
|
return false;
|
|
}
|
|
|
|
bool CheckLive(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
|
|
AccessKinds AK) {
|
|
if (Ptr.isZero()) {
|
|
const auto &Src = S.Current->getSource(OpPC);
|
|
|
|
if (Ptr.isField())
|
|
S.FFDiag(Src, diag::note_constexpr_null_subobject) << CSK_Field;
|
|
else
|
|
S.FFDiag(Src, diag::note_constexpr_access_null) << AK;
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!Ptr.isLive()) {
|
|
const auto &Src = S.Current->getSource(OpPC);
|
|
bool IsTemp = Ptr.isTemporary();
|
|
|
|
S.FFDiag(Src, diag::note_constexpr_lifetime_ended, 1) << AK << !IsTemp;
|
|
|
|
if (IsTemp)
|
|
S.Note(Ptr.getDeclLoc(), diag::note_constexpr_temporary_here);
|
|
else
|
|
S.Note(Ptr.getDeclLoc(), diag::note_declared_at);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CheckConstant(InterpState &S, CodePtr OpPC, const Descriptor *Desc) {
|
|
assert(Desc);
|
|
|
|
auto IsConstType = [&S](const VarDecl *VD) -> bool {
|
|
if (VD->isConstexpr())
|
|
return true;
|
|
|
|
if (S.getLangOpts().CPlusPlus && !S.getLangOpts().CPlusPlus11)
|
|
return false;
|
|
|
|
QualType T = VD->getType();
|
|
if (T.isConstQualified())
|
|
return true;
|
|
|
|
if (const auto *RT = T->getAs<ReferenceType>())
|
|
return RT->getPointeeType().isConstQualified();
|
|
|
|
if (const auto *PT = T->getAs<PointerType>())
|
|
return PT->getPointeeType().isConstQualified();
|
|
|
|
return false;
|
|
};
|
|
|
|
if (const auto *D = Desc->asValueDecl()) {
|
|
if (const auto *VD = dyn_cast<VarDecl>(D);
|
|
VD && VD->hasGlobalStorage() && !IsConstType(VD)) {
|
|
diagnoseNonConstVariable(S, OpPC, VD);
|
|
return S.inConstantContext();
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool CheckConstant(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
|
|
return CheckConstant(S, OpPC, Ptr.getDeclDesc());
|
|
}
|
|
|
|
bool CheckDummy(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
|
|
return !Ptr.isZero() && !Ptr.isDummy();
|
|
}
|
|
|
|
bool CheckNull(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
|
|
CheckSubobjectKind CSK) {
|
|
if (!Ptr.isZero())
|
|
return true;
|
|
const SourceInfo &Loc = S.Current->getSource(OpPC);
|
|
S.FFDiag(Loc, diag::note_constexpr_null_subobject) << CSK;
|
|
return false;
|
|
}
|
|
|
|
bool CheckRange(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
|
|
AccessKinds AK) {
|
|
if (!Ptr.isOnePastEnd())
|
|
return true;
|
|
const SourceInfo &Loc = S.Current->getSource(OpPC);
|
|
S.FFDiag(Loc, diag::note_constexpr_access_past_end) << AK;
|
|
return false;
|
|
}
|
|
|
|
bool CheckRange(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
|
|
CheckSubobjectKind CSK) {
|
|
if (!Ptr.isElementPastEnd())
|
|
return true;
|
|
const SourceInfo &Loc = S.Current->getSource(OpPC);
|
|
S.FFDiag(Loc, diag::note_constexpr_past_end_subobject) << CSK;
|
|
return false;
|
|
}
|
|
|
|
bool CheckSubobject(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
|
|
CheckSubobjectKind CSK) {
|
|
if (!Ptr.isOnePastEnd())
|
|
return true;
|
|
|
|
const SourceInfo &Loc = S.Current->getSource(OpPC);
|
|
S.FFDiag(Loc, diag::note_constexpr_past_end_subobject) << CSK;
|
|
return false;
|
|
}
|
|
|
|
bool CheckConst(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
|
|
assert(Ptr.isLive() && "Pointer is not live");
|
|
if (!Ptr.isConst())
|
|
return true;
|
|
|
|
// The This pointer is writable in constructors and destructors,
|
|
// even if isConst() returns true.
|
|
if (const Function *Func = S.Current->getFunction();
|
|
Func && (Func->isConstructor() || Func->isDestructor()) &&
|
|
Ptr.block() == S.Current->getThis().block()) {
|
|
return true;
|
|
}
|
|
|
|
const QualType Ty = Ptr.getType();
|
|
const SourceInfo &Loc = S.Current->getSource(OpPC);
|
|
S.FFDiag(Loc, diag::note_constexpr_modify_const_type) << Ty;
|
|
return false;
|
|
}
|
|
|
|
bool CheckMutable(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
|
|
assert(Ptr.isLive() && "Pointer is not live");
|
|
if (!Ptr.isMutable()) {
|
|
return true;
|
|
}
|
|
|
|
const SourceInfo &Loc = S.Current->getSource(OpPC);
|
|
const FieldDecl *Field = Ptr.getField();
|
|
S.FFDiag(Loc, diag::note_constexpr_access_mutable, 1) << AK_Read << Field;
|
|
S.Note(Field->getLocation(), diag::note_declared_at);
|
|
return false;
|
|
}
|
|
|
|
bool CheckInitialized(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
|
|
AccessKinds AK) {
|
|
if (Ptr.isInitialized())
|
|
return true;
|
|
|
|
if (!S.checkingPotentialConstantExpression()) {
|
|
S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_access_uninit)
|
|
<< AK << /*uninitialized=*/true << S.Current->getRange(OpPC);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CheckLoad(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
|
|
if (!CheckLive(S, OpPC, Ptr, AK_Read))
|
|
return false;
|
|
if (!CheckConstant(S, OpPC, Ptr))
|
|
return false;
|
|
|
|
if (!CheckDummy(S, OpPC, Ptr))
|
|
return false;
|
|
if (!CheckExtern(S, OpPC, Ptr))
|
|
return false;
|
|
if (!CheckRange(S, OpPC, Ptr, AK_Read))
|
|
return false;
|
|
if (!CheckInitialized(S, OpPC, Ptr, AK_Read))
|
|
return false;
|
|
if (!CheckActive(S, OpPC, Ptr, AK_Read))
|
|
return false;
|
|
if (!CheckTemporary(S, OpPC, Ptr, AK_Read))
|
|
return false;
|
|
if (!CheckMutable(S, OpPC, Ptr))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool CheckStore(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
|
|
if (!CheckLive(S, OpPC, Ptr, AK_Assign))
|
|
return false;
|
|
if (!CheckExtern(S, OpPC, Ptr))
|
|
return false;
|
|
if (!CheckRange(S, OpPC, Ptr, AK_Assign))
|
|
return false;
|
|
if (!CheckGlobal(S, OpPC, Ptr))
|
|
return false;
|
|
if (!CheckConst(S, OpPC, Ptr))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool CheckInvoke(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
|
|
if (!CheckLive(S, OpPC, Ptr, AK_MemberCall))
|
|
return false;
|
|
if (!CheckExtern(S, OpPC, Ptr))
|
|
return false;
|
|
if (!CheckRange(S, OpPC, Ptr, AK_MemberCall))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool CheckInit(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
|
|
if (!CheckLive(S, OpPC, Ptr, AK_Assign))
|
|
return false;
|
|
if (!CheckRange(S, OpPC, Ptr, AK_Assign))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool CheckCallable(InterpState &S, CodePtr OpPC, const Function *F) {
|
|
|
|
if (F->isVirtual() && !S.getLangOpts().CPlusPlus20) {
|
|
const SourceLocation &Loc = S.Current->getLocation(OpPC);
|
|
S.CCEDiag(Loc, diag::note_constexpr_virtual_call);
|
|
return false;
|
|
}
|
|
|
|
if (!F->isConstexpr()) {
|
|
const SourceLocation &Loc = S.Current->getLocation(OpPC);
|
|
if (S.getLangOpts().CPlusPlus11) {
|
|
const FunctionDecl *DiagDecl = F->getDecl();
|
|
|
|
// If this function is not constexpr because it is an inherited
|
|
// non-constexpr constructor, diagnose that directly.
|
|
const auto *CD = dyn_cast<CXXConstructorDecl>(DiagDecl);
|
|
if (CD && CD->isInheritingConstructor()) {
|
|
const auto *Inherited = CD->getInheritedConstructor().getConstructor();
|
|
if (!Inherited->isConstexpr())
|
|
DiagDecl = CD = Inherited;
|
|
}
|
|
|
|
// FIXME: If DiagDecl is an implicitly-declared special member function
|
|
// or an inheriting constructor, we should be much more explicit about why
|
|
// it's not constexpr.
|
|
if (CD && CD->isInheritingConstructor()) {
|
|
S.FFDiag(Loc, diag::note_constexpr_invalid_inhctor, 1)
|
|
<< CD->getInheritedConstructor().getConstructor()->getParent();
|
|
S.Note(DiagDecl->getLocation(), diag::note_declared_at);
|
|
} else {
|
|
// Don't emit anything if the function isn't defined and we're checking
|
|
// for a constant expression. It might be defined at the point we're
|
|
// actually calling it.
|
|
if (!DiagDecl->isDefined() && S.checkingPotentialConstantExpression())
|
|
return false;
|
|
|
|
S.FFDiag(Loc, diag::note_constexpr_invalid_function, 1)
|
|
<< DiagDecl->isConstexpr() << (bool)CD << DiagDecl;
|
|
S.Note(DiagDecl->getLocation(), diag::note_declared_at);
|
|
}
|
|
} else {
|
|
S.FFDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CheckCallDepth(InterpState &S, CodePtr OpPC) {
|
|
if ((S.Current->getDepth() + 1) > S.getLangOpts().ConstexprCallDepth) {
|
|
S.FFDiag(S.Current->getSource(OpPC),
|
|
diag::note_constexpr_depth_limit_exceeded)
|
|
<< S.getLangOpts().ConstexprCallDepth;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CheckThis(InterpState &S, CodePtr OpPC, const Pointer &This) {
|
|
if (!This.isZero())
|
|
return true;
|
|
|
|
const SourceInfo &Loc = S.Current->getSource(OpPC);
|
|
|
|
bool IsImplicit = false;
|
|
if (const auto *E = dyn_cast_if_present<CXXThisExpr>(Loc.asExpr()))
|
|
IsImplicit = E->isImplicit();
|
|
|
|
if (S.getLangOpts().CPlusPlus11)
|
|
S.FFDiag(Loc, diag::note_constexpr_this) << IsImplicit;
|
|
else
|
|
S.FFDiag(Loc);
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CheckPure(InterpState &S, CodePtr OpPC, const CXXMethodDecl *MD) {
|
|
if (!MD->isPureVirtual())
|
|
return true;
|
|
const SourceInfo &E = S.Current->getSource(OpPC);
|
|
S.FFDiag(E, diag::note_constexpr_pure_virtual_call, 1) << MD;
|
|
S.Note(MD->getLocation(), diag::note_declared_at);
|
|
return false;
|
|
}
|
|
|
|
bool CheckPotentialReinterpretCast(InterpState &S, CodePtr OpPC,
|
|
const Pointer &Ptr) {
|
|
if (!S.inConstantContext())
|
|
return true;
|
|
|
|
const SourceInfo &E = S.Current->getSource(OpPC);
|
|
S.CCEDiag(E, diag::note_constexpr_invalid_cast)
|
|
<< 2 << S.getLangOpts().CPlusPlus << S.Current->getRange(OpPC);
|
|
return false;
|
|
}
|
|
|
|
bool CheckFloatResult(InterpState &S, CodePtr OpPC, const Floating &Result,
|
|
APFloat::opStatus Status) {
|
|
const SourceInfo &E = S.Current->getSource(OpPC);
|
|
|
|
// [expr.pre]p4:
|
|
// If during the evaluation of an expression, the result is not
|
|
// mathematically defined [...], the behavior is undefined.
|
|
// FIXME: C++ rules require us to not conform to IEEE 754 here.
|
|
if (Result.isNan()) {
|
|
S.CCEDiag(E, diag::note_constexpr_float_arithmetic)
|
|
<< /*NaN=*/true << S.Current->getRange(OpPC);
|
|
return S.noteUndefinedBehavior();
|
|
}
|
|
|
|
// In a constant context, assume that any dynamic rounding mode or FP
|
|
// exception state matches the default floating-point environment.
|
|
if (S.inConstantContext())
|
|
return true;
|
|
|
|
FPOptions FPO = E.asExpr()->getFPFeaturesInEffect(S.Ctx.getLangOpts());
|
|
|
|
if ((Status & APFloat::opInexact) &&
|
|
FPO.getRoundingMode() == llvm::RoundingMode::Dynamic) {
|
|
// Inexact result means that it depends on rounding mode. If the requested
|
|
// mode is dynamic, the evaluation cannot be made in compile time.
|
|
S.FFDiag(E, diag::note_constexpr_dynamic_rounding);
|
|
return false;
|
|
}
|
|
|
|
if ((Status != APFloat::opOK) &&
|
|
(FPO.getRoundingMode() == llvm::RoundingMode::Dynamic ||
|
|
FPO.getExceptionMode() != LangOptions::FPE_Ignore ||
|
|
FPO.getAllowFEnvAccess())) {
|
|
S.FFDiag(E, diag::note_constexpr_float_arithmetic_strict);
|
|
return false;
|
|
}
|
|
|
|
if ((Status & APFloat::opStatus::opInvalidOp) &&
|
|
FPO.getExceptionMode() != LangOptions::FPE_Ignore) {
|
|
// There is no usefully definable result.
|
|
S.FFDiag(E);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// We aleady know the given DeclRefExpr is invalid for some reason,
|
|
/// now figure out why and print appropriate diagnostics.
|
|
bool CheckDeclRef(InterpState &S, CodePtr OpPC, const DeclRefExpr *DR) {
|
|
const ValueDecl *D = DR->getDecl();
|
|
const SourceInfo &E = S.Current->getSource(OpPC);
|
|
|
|
if (isa<ParmVarDecl>(D)) {
|
|
if (S.getLangOpts().CPlusPlus11) {
|
|
S.FFDiag(E, diag::note_constexpr_function_param_value_unknown) << D;
|
|
S.Note(D->getLocation(), diag::note_declared_at) << D->getSourceRange();
|
|
} else {
|
|
S.FFDiag(E);
|
|
}
|
|
} else if (const auto *VD = dyn_cast<VarDecl>(D)) {
|
|
if (!VD->getType().isConstQualified()) {
|
|
diagnoseNonConstVariable(S, OpPC, VD);
|
|
return false;
|
|
}
|
|
|
|
// const, but no initializer.
|
|
if (!VD->getAnyInitializer()) {
|
|
S.FFDiag(E, diag::note_constexpr_var_init_unknown, 1) << VD;
|
|
S.Note(VD->getLocation(), diag::note_declared_at) << VD->getSourceRange();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool Interpret(InterpState &S, APValue &Result) {
|
|
// The current stack frame when we started Interpret().
|
|
// This is being used by the ops to determine wheter
|
|
// to return from this function and thus terminate
|
|
// interpretation.
|
|
const InterpFrame *StartFrame = S.Current;
|
|
assert(!S.Current->isRoot());
|
|
CodePtr PC = S.Current->getPC();
|
|
|
|
// Empty program.
|
|
if (!PC)
|
|
return true;
|
|
|
|
for (;;) {
|
|
auto Op = PC.read<Opcode>();
|
|
CodePtr OpPC = PC;
|
|
|
|
switch (Op) {
|
|
#define GET_INTERP
|
|
#include "Opcodes.inc"
|
|
#undef GET_INTERP
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace interp
|
|
} // namespace clang
|