Skip to content

Refactoring the API for multiple interpreter instance support #338

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Oct 27, 2024
+83 −47
Merged

Refactoring the API for multiple interpreter instance support #338

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
16 changes: 10 additions & 6 deletions include/clang/Interpreter/CppInterOp.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -77,7 +77,8 @@ namespace Cpp {
/// function, constructor or destructor.
class JitCall {
public:
friend CPPINTEROP_API JitCall MakeFunctionCallable(TCppConstFunction_t);
friend CPPINTEROP_API JitCall
MakeFunctionCallable(TInterp_t I, TCppConstFunction_t func);
enum Kind : char {
kUnknown = 0,
kGenericCall,
Expand Down Expand Up @@ -262,16 +263,16 @@ namespace Cpp {

/// This is similar to GetName() function, but besides
/// the name, it also gets the template arguments.
CPPINTEROP_API std::string GetCompleteName(TCppType_t klass);
CPPINTEROP_API std::string GetCompleteName(TCppScope_t klass);

/// Gets the "qualified" name (including the namespace) of any
/// named decl (a class, namespace, variable, or a function).
CPPINTEROP_API std::string GetQualifiedName(TCppType_t klass);
CPPINTEROP_API std::string GetQualifiedName(TCppScope_t klass);

/// This is similar to GetQualifiedName() function, but besides
/// the "qualified" name (including the namespace), it also
/// gets the template arguments.
CPPINTEROP_API std::string GetQualifiedCompleteName(TCppType_t klass);
CPPINTEROP_API std::string GetQualifiedCompleteName(TCppScope_t klass);

/// Gets the list of namespaces utilized in the supplied scope.
CPPINTEROP_API std::vector<TCppScope_t> GetUsingNamespaces(TCppScope_t scope);
Expand Down Expand Up @@ -307,13 +308,13 @@ namespace Cpp {

/// Gets the number of Base Classes for the Derived Class that
/// is passed as a parameter.
CPPINTEROP_API TCppIndex_t GetNumBases(TCppType_t klass);
CPPINTEROP_API TCppIndex_t GetNumBases(TCppScope_t klass);

/// Gets a specific Base Class using its index. Typically GetNumBases()
/// is used to get the number of Base Classes, and then that number
/// can be used to iterate through the index value to get each specific
/// base class.
CPPINTEROP_API TCppScope_t GetBaseClass(TCppType_t klass, TCppIndex_t ibase);
CPPINTEROP_API TCppScope_t GetBaseClass(TCppScope_t klass, TCppIndex_t ibase);

/// Checks if the supplied Derived Class is a sub-class of the
/// provided Base Class.
Expand Down Expand Up @@ -496,6 +497,9 @@ namespace Cpp {
/// uniform interface to call it from compiled code.
CPPINTEROP_API JitCall MakeFunctionCallable(TCppConstFunction_t func);

CPPINTEROP_API JitCall MakeFunctionCallable(TInterp_t I,
TCppConstFunction_t func);

/// Checks if a function declared is of const type or not.
CPPINTEROP_API bool IsConstMethod(TCppFunction_t method);

Expand Down
114 changes: 73 additions & 41 deletions lib/Interpreter/CppInterOp.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -857,7 +857,7 @@ namespace Cpp {

TCppIndex_t GetFunctionRequiredArgs(TCppConstFunction_t func)
{
auto *D = (const clang::Decl *) func;
const auto* D = static_cast<const clang::Decl*>(func);
if (auto* FD = llvm::dyn_cast_or_null<FunctionDecl>(D))
return FD->getMinRequiredArguments();

Expand Down Expand Up @@ -923,7 +923,8 @@ namespace Cpp {
}

bool IsFunctionDeleted(TCppConstFunction_t function) {
auto *FD = cast<const FunctionDecl>((const clang::Decl*)function);
const auto* FD =
cast<const FunctionDecl>(static_cast<const clang::Decl*>(function));
return FD->isDeleted();
}

Expand Down Expand Up @@ -1054,7 +1055,8 @@ namespace Cpp {

bool IsMethod(TCppConstFunction_t method)
{
return dyn_cast_or_null<CXXMethodDecl>((const clang::Decl*)method);
return dyn_cast_or_null<CXXMethodDecl>(
static_cast<const clang::Decl*>(method));
}

bool IsPublicMethod(TCppFunction_t method)
Expand All @@ -1073,18 +1075,18 @@ namespace Cpp {

bool IsConstructor(TCppConstFunction_t method)
{
auto *D = (const Decl *) method;
const auto* D = static_cast<const Decl*>(method);
return llvm::isa_and_nonnull<CXXConstructorDecl>(D);
}

bool IsDestructor(TCppConstFunction_t method)
{
auto *D = (const Decl *) method;
const auto* D = static_cast<const Decl*>(method);
return llvm::isa_and_nonnull<CXXDestructorDecl>(D);
}

bool IsStaticMethod(TCppConstFunction_t method) {
const auto* D = (const Decl*)method;
const auto* D = static_cast<const Decl*>(method);
if (auto *CXXMD = llvm::dyn_cast_or_null<CXXMethodDecl>(D)) {
return CXXMD->isStatic();
}
Expand Down Expand Up @@ -1207,13 +1209,11 @@ namespace Cpp {
return 0;
}

intptr_t GetVariableOffset(TCppScope_t var)
{
if (!var)
intptr_t GetVariableOffset(compat::Interpreter& I, Decl* D) {
if (!D)
return 0;

auto *D = (Decl *) var;
auto &C = getASTContext();
auto& C = I.getSema().getASTContext();

if (auto* FD = llvm::dyn_cast<FieldDecl>(D)) {
const clang::RecordDecl* RD = FD->getParent();
Expand Down Expand Up @@ -1242,7 +1242,7 @@ namespace Cpp {
compat::maybeMangleDeclName(GD, mangledName);
void* address = llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(
mangledName.c_str());
auto &I = getInterp();

if (!address)
address = I.getAddressOfGlobal(GD);
if (!address) {
Expand Down Expand Up @@ -1292,6 +1292,11 @@ namespace Cpp {
return 0;
}

intptr_t GetVariableOffset(TCppScope_t var) {
auto* D = static_cast<Decl*>(var);
return GetVariableOffset(getInterp(), D);
}

// Check if the Access Specifier of the variable matches the provided value.
bool CheckVariableAccess(TCppScope_t var, AccessSpecifier AS)
{
Expand Down Expand Up @@ -2574,26 +2579,32 @@ namespace Cpp {
} // namespace
// End of JitCall Helper Functions

CPPINTEROP_API JitCall MakeFunctionCallable(TCppConstFunction_t func) {
auto* D = (const clang::Decl*)func;
if (!D)
return {};
CPPINTEROP_API JitCall MakeFunctionCallable(TInterp_t I,
TCppConstFunction_t func) {
const auto* D = static_cast<const clang::Decl*>(func);
if (!D)
return {};

auto& I = getInterp();
// FIXME: Unify with make_wrapper.
if (auto *Dtor = dyn_cast<CXXDestructorDecl>(D)) {
if (auto Wrapper = make_dtor_wrapper(I, Dtor->getParent()))
return {JitCall::kDestructorCall, Wrapper, Dtor};
auto* interp = static_cast<compat::Interpreter*>(I);

// FIXME: Unify with make_wrapper.
if (const auto* Dtor = dyn_cast<CXXDestructorDecl>(D)) {
if (auto Wrapper = make_dtor_wrapper(*interp, Dtor->getParent()))
return {JitCall::kDestructorCall, Wrapper, Dtor};
// FIXME: else error we failed to compile the wrapper.
return {};
}

if (auto Wrapper = make_wrapper(*interp, cast<FunctionDecl>(D))) {
return {JitCall::kGenericCall, Wrapper, cast<FunctionDecl>(D)};
}
// FIXME: else error we failed to compile the wrapper.
return {};
}

if (auto Wrapper = make_wrapper(I, cast<FunctionDecl>(D))) {
return {JitCall::kGenericCall, Wrapper, cast<FunctionDecl>(D)};
CPPINTEROP_API JitCall MakeFunctionCallable(TCppConstFunction_t func) {
return MakeFunctionCallable(&getInterp(), func);
}
// FIXME: else error we failed to compile the wrapper.
return {};
}

namespace {
static std::string MakeResourcesPath() {
Expand Down Expand Up @@ -2842,7 +2853,8 @@ namespace Cpp {
return DLM->searchLibrariesForSymbol(mangled_name, search_system);
}

bool InsertOrReplaceJitSymbol(const char* linker_mangled_name,
bool InsertOrReplaceJitSymbol(compat::Interpreter& I,
const char* linker_mangled_name,
uint64_t address) {
// FIXME: This approach is problematic since we could replace a symbol
// whose address was already taken by clients.
Expand All @@ -2869,7 +2881,6 @@ namespace Cpp {
using namespace llvm;
using namespace llvm::orc;

auto& I = getInterp();
auto Symbol = compat::getSymbolAddress(I, linker_mangled_name);
llvm::orc::LLJIT& Jit = *compat::getExecutionEngine(I);
llvm::orc::ExecutionSession& ES = Jit.getExecutionSession();
Expand Down Expand Up @@ -2930,6 +2941,11 @@ namespace Cpp {
return false;
}

bool InsertOrReplaceJitSymbol(const char* linker_mangled_name,
uint64_t address) {
return InsertOrReplaceJitSymbol(getInterp(), linker_mangled_name, address);
}

std::string ObjToString(const char *type, void *obj) {
return getInterp().toString(type, obj);
}
Expand Down Expand Up @@ -2979,9 +2995,8 @@ namespace Cpp {
// return C.getElaboratedType(ETK_None, NS, TT);
}

static Decl* InstantiateTemplate(TemplateDecl* TemplateD,
ArrayRef<TemplateArgument> TemplateArgs,
Sema& S) {
Decl* InstantiateTemplate(TemplateDecl* TemplateD,
ArrayRef<TemplateArgument> TemplateArgs, Sema& S) {
// Create a list of template arguments.
TemplateArgumentListInfo TLI{};
for (auto TA : TemplateArgs)
Expand All @@ -2991,10 +3006,11 @@ namespace Cpp {
return InstantiateTemplate(TemplateD, TLI, S);
}

TCppScope_t InstantiateTemplate(TCppScope_t tmpl,
TCppScope_t InstantiateTemplate(compat::Interpreter& I, TCppScope_t tmpl,
const TemplateArgInfo* template_args,
size_t template_args_size) {
ASTContext &C = getASTContext();
auto& S = I.getSema();
auto& C = S.getASTContext();

llvm::SmallVector<TemplateArgument> TemplateArgs;
TemplateArgs.reserve(template_args_size);
Expand All @@ -3015,9 +3031,16 @@ namespace Cpp {

// We will create a new decl, push a transaction.
#ifdef USE_CLING
cling::Interpreter::PushTransactionRAII RAII(&getInterp());
cling::Interpreter::PushTransactionRAII RAII(&I);
#endif
return InstantiateTemplate(TmplD, TemplateArgs, getSema());
return InstantiateTemplate(TmplD, TemplateArgs, S);
}

TCppScope_t InstantiateTemplate(TCppScope_t tmpl,
const TemplateArgInfo* template_args,
size_t template_args_size) {
return InstantiateTemplate(getInterp(), tmpl, template_args,
template_args_size);
}

void GetClassTemplateInstantiationArgs(TCppScope_t templ_instance,
Expand Down Expand Up @@ -3241,15 +3264,15 @@ namespace Cpp {
}

// FIXME: Add optional arguments to the operator new.
TCppObject_t Construct(TCppScope_t scope,
void* arena/*=nullptr*/) {
TCppObject_t Construct(compat::Interpreter& interp, TCppScope_t scope,
void* arena /*=nullptr*/) {
auto* Class = (Decl*) scope;
// FIXME: Diagnose.
if (!HasDefaultConstructor(Class))
return nullptr;

auto* const Ctor = GetDefaultConstructor(Class);
if (JitCall JC = MakeFunctionCallable(Ctor)) {
if (JitCall JC = MakeFunctionCallable(&interp, Ctor)) {
if (arena) {
JC.Invoke(&arena, {}, (void*)~0); // Tell Invoke to use placement new.
return arena;
Expand All @@ -3262,15 +3285,24 @@ namespace Cpp {
return nullptr;
}

void Destruct(TCppObject_t This, TCppScope_t scope, bool withFree /*=true*/) {
Decl* Class = (Decl*)scope;
if (auto wrapper = make_dtor_wrapper(getInterp(), Class)) {
TCppObject_t Construct(TCppScope_t scope, void* arena /*=nullptr*/) {
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

also removed the Impl suffix.

return Construct(getInterp(), scope, arena);
}

void Destruct(compat::Interpreter& interp, TCppObject_t This, Decl* Class,
bool withFree) {
if (auto wrapper = make_dtor_wrapper(interp, Class)) {
(*wrapper)(This, /*nary=*/0, withFree);
return;
}
// FIXME: Diagnose.
}

void Destruct(TCppObject_t This, TCppScope_t scope, bool withFree /*=true*/) {
auto* Class = static_cast<Decl*>(scope);
Destruct(getInterp(), This, Class, withFree);
}

class StreamCaptureInfo {
std::unique_ptr<FILE, decltype(std::fclose)*> m_TempFile;
int m_FD = -1;
Expand Down