blob: eeb7fa9379f5ccd7ab8639ca0a71d9ab287e1955 [file] [log] [blame]
//===--- Context.cpp - Context 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 "Context.h"
#include "ByteCodeEmitter.h"
#include "ByteCodeExprGen.h"
#include "ByteCodeStmtGen.h"
#include "EvalEmitter.h"
#include "Interp.h"
#include "InterpFrame.h"
#include "InterpStack.h"
#include "PrimType.h"
#include "Program.h"
#include "clang/AST/Expr.h"
#include "clang/Basic/TargetInfo.h"
using namespace clang;
using namespace clang::interp;
Context::Context(ASTContext &Ctx) : Ctx(Ctx), P(new Program(*this)) {}
Context::~Context() {}
bool Context::isPotentialConstantExpr(State &Parent, const FunctionDecl *FD) {
assert(Stk.empty());
Function *Func = P->getFunction(FD);
if (!Func || !Func->hasBody()) {
if (auto R = ByteCodeStmtGen<ByteCodeEmitter>(*this, *P).compileFunc(FD)) {
Func = *R;
} else {
handleAllErrors(R.takeError(), [&Parent](ByteCodeGenError &Err) {
Parent.FFDiag(Err.getRange().getBegin(),
diag::err_experimental_clang_interp_failed)
<< Err.getRange();
});
return false;
}
}
APValue DummyResult;
if (!Run(Parent, Func, DummyResult)) {
return false;
}
return Func->isConstexpr();
}
bool Context::evaluateAsRValue(State &Parent, const Expr *E, APValue &Result) {
assert(Stk.empty());
ByteCodeExprGen<EvalEmitter> C(*this, *P, Parent, Stk, Result);
if (Check(Parent, C.interpretExpr(E))) {
assert(Stk.empty());
#ifndef NDEBUG
// Make sure we don't rely on some value being still alive in
// InterpStack memory.
Stk.clear();
#endif
return true;
}
Stk.clear();
return false;
}
bool Context::evaluateAsInitializer(State &Parent, const VarDecl *VD,
APValue &Result) {
assert(Stk.empty());
ByteCodeExprGen<EvalEmitter> C(*this, *P, Parent, Stk, Result);
if (Check(Parent, C.interpretDecl(VD))) {
assert(Stk.empty());
#ifndef NDEBUG
// Make sure we don't rely on some value being still alive in
// InterpStack memory.
Stk.clear();
#endif
return true;
}
Stk.clear();
return false;
}
const LangOptions &Context::getLangOpts() const { return Ctx.getLangOpts(); }
std::optional<PrimType> Context::classify(QualType T) const {
if (T->isFunctionPointerType() || T->isFunctionReferenceType())
return PT_FnPtr;
if (T->isReferenceType() || T->isPointerType())
return PT_Ptr;
if (T->isBooleanType())
return PT_Bool;
if (T->isSignedIntegerOrEnumerationType()) {
switch (Ctx.getIntWidth(T)) {
case 64:
return PT_Sint64;
case 32:
return PT_Sint32;
case 16:
return PT_Sint16;
case 8:
return PT_Sint8;
default:
return {};
}
}
if (T->isUnsignedIntegerOrEnumerationType()) {
switch (Ctx.getIntWidth(T)) {
case 64:
return PT_Uint64;
case 32:
return PT_Uint32;
case 16:
return PT_Uint16;
case 8:
return PT_Uint8;
default:
return {};
}
}
if (T->isNullPtrType())
return PT_Ptr;
if (T->isFloatingType())
return PT_Float;
if (auto *AT = dyn_cast<AtomicType>(T))
return classify(AT->getValueType());
return {};
}
unsigned Context::getCharBit() const {
return Ctx.getTargetInfo().getCharWidth();
}
/// Simple wrapper around getFloatTypeSemantics() to make code a
/// little shorter.
const llvm::fltSemantics &Context::getFloatSemantics(QualType T) const {
return Ctx.getFloatTypeSemantics(T);
}
bool Context::Run(State &Parent, const Function *Func, APValue &Result) {
InterpState State(Parent, *P, Stk, *this);
State.Current = new InterpFrame(State, Func, /*Caller=*/nullptr, {});
if (Interpret(State, Result))
return true;
Stk.clear();
return false;
}
bool Context::Check(State &Parent, llvm::Expected<bool> &&Flag) {
if (Flag)
return *Flag;
handleAllErrors(Flag.takeError(), [&Parent](ByteCodeGenError &Err) {
Parent.FFDiag(Err.getRange().getBegin(),
diag::err_experimental_clang_interp_failed)
<< Err.getRange();
});
return false;
}
// TODO: Virtual bases?
const CXXMethodDecl *
Context::getOverridingFunction(const CXXRecordDecl *DynamicDecl,
const CXXRecordDecl *StaticDecl,
const CXXMethodDecl *InitialFunction) const {
const CXXRecordDecl *CurRecord = DynamicDecl;
const CXXMethodDecl *FoundFunction = InitialFunction;
for (;;) {
const CXXMethodDecl *Overrider =
FoundFunction->getCorrespondingMethodDeclaredInClass(CurRecord, false);
if (Overrider)
return Overrider;
// Common case of only one base class.
if (CurRecord->getNumBases() == 1) {
CurRecord = CurRecord->bases_begin()->getType()->getAsCXXRecordDecl();
continue;
}
// Otherwise, go to the base class that will lead to the StaticDecl.
for (const CXXBaseSpecifier &Spec : CurRecord->bases()) {
const CXXRecordDecl *Base = Spec.getType()->getAsCXXRecordDecl();
if (Base == StaticDecl || Base->isDerivedFrom(StaticDecl)) {
CurRecord = Base;
break;
}
}
}
llvm_unreachable(
"Couldn't find an overriding function in the class hierarchy?");
return nullptr;
}