store

Author: vgvassilev

clang/include/clang/Interpreter/Interpreter.h

@@ -78,22 +78,26 @@ class IncrementalCompilerBuilder {
   llvm::StringRef CudaSDKPath;
 };
 
-/// Generate glue code between the Interpreter's built-in runtime and user code.
-class RuntimeInterfaceBuilder {
-public:
-  virtual ~RuntimeInterfaceBuilder() = default;
+class Interpreter;
+/// Provides a callback class allowing to listen to interpreter events and to
+/// specialize some operations.
+class InterpreterCallbacks {
+  Interpreter &Interp;
 
-  using TransformExprFunction = ExprResult(RuntimeInterfaceBuilder *Builder,
-                                           Expr *, ArrayRef<Expr *>);
-  virtual TransformExprFunction *getPrintValueTransformer() = 0;
+public:
+  InterpreterCallbacks(Interpreter &I) : Interp(I) {}
+  virtual ~InterpreterCallbacks();
+  virtual void ProcessingTopLevelStmtDecl(TopLevelStmtDecl *D);
 };
 
 /// Provides top-level interfaces for incremental compilation and execution.
 class Interpreter {
+  friend Value;
+
   std::unique_ptr<llvm::orc::ThreadSafeContext> TSCtx;
+  std::unique_ptr<InterpreterCallbacks> InterpreterCB;
   std::unique_ptr<IncrementalParser> IncrParser;
   std::unique_ptr<IncrementalExecutor> IncrExecutor;
-  std::unique_ptr<RuntimeInterfaceBuilder> RuntimeIB;
 
   // An optional parser for CUDA offloading
   std::unique_ptr<IncrementalParser> DeviceParser;
@@ -105,10 +109,16 @@ class Interpreter {
   // printing happens, it's in an invalid state.
   Value LastValue;
 
-  // Add a call to an Expr to report its result. We query the function from
-  // RuntimeInterfaceBuilder once and store it as a function pointer to avoid
-  // frequent virtual function calls.
-  RuntimeInterfaceBuilder::TransformExprFunction *AddPrintValueCall = nullptr;
+  // The cached declaration of std::string used as a return type for the built
+  // trampoline. This is done in C++ to simplify the memory management for
+  // user-defined printing functions.
+  Decl *StdString = nullptr;
+
+  // A cache for the compiled destructors used to for de-allocation of managed
+  // clang::Values.
+  llvm::DenseMap<CXXRecordDecl *, llvm::orc::ExecutorAddr> Dtors;
+
+  std::array<Expr *, 4> ValuePrintingInfo = {0};
 
 protected:
   // Derived classes can use an extended interface of the Interpreter.
@@ -123,23 +133,8 @@ class Interpreter {
   // JIT engine. In particular, it doesn't run cleanup or destructors.
   void ResetExecutor();
 
-  // Lazily construct the RuntimeInterfaceBuilder. The provided instance will be
-  // used for the entire lifetime of the interpreter. The default implementation
-  // targets the in-process __clang_Interpreter runtime. Override this to use a
-  // custom runtime.
-  virtual std::unique_ptr<RuntimeInterfaceBuilder> FindRuntimeInterface();
-
 public:
   virtual ~Interpreter();
-
-  // class SynthesizingCodeRAII {
-
-  // };
-
-  // SynthesizingCodeRAII EnterCodeSynthesisScope() {
-
-  // }
-
   static llvm::Expected<std::unique_ptr<Interpreter>>
   create(std::unique_ptr<CompilerInstance> CI);
   static llvm::Expected<std::unique_ptr<Interpreter>>
@@ -154,7 +149,6 @@ class Interpreter {
   llvm::Expected<PartialTranslationUnit &> Parse(llvm::StringRef Code);
   llvm::Error Execute(PartialTranslationUnit &T);
   llvm::Error ParseAndExecute(llvm::StringRef Code, Value *V = nullptr);
-  llvm::Expected<llvm::orc::ExecutorAddr> CompileDtorCall(CXXRecordDecl *CXXRD);
 
   /// Undo N previous incremental inputs.
   llvm::Error Undo(unsigned N = 1);
@@ -176,25 +170,32 @@ class Interpreter {
   llvm::Expected<llvm::orc::ExecutorAddr>
   getSymbolAddressFromLinkerName(llvm::StringRef LinkerName) const;
 
-  enum InterfaceKind { NoAlloc, WithAlloc, CopyArray, NewTag };
-
-  const llvm::SmallVectorImpl<Expr *> &getValuePrintingInfo() const {
-    return ValuePrintingInfo;
+  InterpreterCallbacks *getInterpreterCallbacks() {
+    return InterpreterCB.get();
+  }
+  const InterpreterCallbacks *getInterpreterCallbacks() const {
+    return const_cast<Interpreter *>(this)->getInterpreterCallbacks();
+  }
+  void setInterpreterCallbacks(std::unique_ptr<InterpreterCallbacks> CB) {
+    InterpreterCB = std::move(CB);
   }
 
-  Expr *SynthesizeExpr(Expr *E);
+  llvm::Expected<Expr *> SynthesizeExpr(Expr *E);
 
   std::unique_ptr<llvm::Module> GenModule();
 
 private:
   size_t getEffectivePTUSize() const;
   void markUserCodeStart();
 
-  llvm::DenseMap<CXXRecordDecl *, llvm::orc::ExecutorAddr> Dtors;
+  std::unique_ptr<llvm::orc::LLJITBuilder> JITBuilder;
 
-  llvm::SmallVector<Expr *, 4> ValuePrintingInfo;
+  std::string ValueDataToString(const Value &V);
+  std::string ValueTypeToString(const Value &V) const;
 
-  std::unique_ptr<llvm::orc::LLJITBuilder> JITBuilder;
+  // When we deallocate clang::Value we need to run the destructor of the type.
+  // This function forces emission of the needed dtor.
+  llvm::Expected<llvm::orc::ExecutorAddr> CompileDtorCall(CXXRecordDecl *CXXRD);
 };
 } // namespace clang
 

clang/include/clang/Interpreter/Value.h

@@ -119,9 +119,9 @@ class REPL_EXTERNAL_VISIBILITY Value {
   ~Value();
 
   void printType(llvm::raw_ostream &Out) const;
-  void printData(llvm::raw_ostream &Out) const;
-  void print(llvm::raw_ostream &Out) const;
-  void dump() const;
+  void printData(llvm::raw_ostream &Out);
+  void print(llvm::raw_ostream &Out);
+  void dump();
   void clear();
 
   ASTContext &getASTContext();

clang/lib/Interpreter/DeviceOffload.cpp

@@ -24,11 +24,12 @@
 namespace clang {
 
 IncrementalCUDADeviceParser::IncrementalCUDADeviceParser(
-    Interpreter &Interp, std::unique_ptr<CompilerInstance> Instance,
-    IncrementalParser &HostParser, llvm::LLVMContext &LLVMCtx,
+    std::unique_ptr<CompilerInstance> Instance, IncrementalParser &HostParser,
+    llvm::LLVMContext &LLVMCtx,
     llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> FS,
     llvm::Error &Err)
-    : IncrementalParser(Interp, std::move(Instance), LLVMCtx, Err),
+    : IncrementalParser(std::move(Instance), LLVMCtx, Err,
+                        /*InterpreterCallbacks=*/nullptr),
       HostParser(HostParser), VFS(FS) {
   if (Err)
     return;

clang/lib/Interpreter/DeviceOffload.h

@@ -22,8 +22,8 @@ namespace clang {
 class IncrementalCUDADeviceParser : public IncrementalParser {
 public:
   IncrementalCUDADeviceParser(
-      Interpreter &Interp, std::unique_ptr<CompilerInstance> Instance,
-      IncrementalParser &HostParser, llvm::LLVMContext &LLVMCtx,
+      std::unique_ptr<CompilerInstance> Instance, IncrementalParser &HostParser,
+      llvm::LLVMContext &LLVMCtx,
       llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> VFS,
       llvm::Error &Err);
 

clang/lib/Interpreter/IncrementalParser.cpp

@@ -32,23 +32,24 @@
 namespace clang {
 
 class IncrementalASTConsumer final : public ASTConsumer {
-  Interpreter &Interp;
+  InterpreterCallbacks *CB;
   std::unique_ptr<ASTConsumer> Consumer;
 
 public:
-  IncrementalASTConsumer(Interpreter &InterpRef, std::unique_ptr<ASTConsumer> C)
-      : Interp(InterpRef), Consumer(std::move(C)) {}
+  IncrementalASTConsumer(std::unique_ptr<ASTConsumer> C,
+                         InterpreterCallbacks *CB)
+      : CB(CB), Consumer(std::move(C)) {}
 
   bool HandleTopLevelDecl(DeclGroupRef DGR) override final {
     if (DGR.isNull())
       return true;
     if (!Consumer)
       return true;
 
-    for (Decl *D : DGR)
-      if (auto *TSD = llvm::dyn_cast<TopLevelStmtDecl>(D);
-          TSD && TSD->isSemiMissing())
-        TSD->setStmt(Interp.SynthesizeExpr(cast<Expr>(TSD->getStmt())));
+    if (CB)
+      for (Decl *D : DGR)
+        if (auto *TLSD = llvm::dyn_cast<TopLevelStmtDecl>(D))
+          CB->ProcessingTopLevelStmtDecl(TLSD);
 
     return Consumer->HandleTopLevelDecl(DGR);
   }
@@ -199,10 +200,9 @@ CodeGenerator *IncrementalParser::getCodeGen() const {
 
 IncrementalParser::IncrementalParser() {}
 
-IncrementalParser::IncrementalParser(Interpreter &Interp,
-                                     std::unique_ptr<CompilerInstance> Instance,
+IncrementalParser::IncrementalParser(std::unique_ptr<CompilerInstance> Instance,
                                      llvm::LLVMContext &LLVMCtx,
-                                     llvm::Error &Err)
+                                     llvm::Error &Err, InterpreterCallbacks *CB)
     : CI(std::move(Instance)) {
   llvm::ErrorAsOutParameter EAO(&Err);
   Act = std::make_unique<IncrementalAction>(*CI, LLVMCtx, Err);
@@ -214,7 +214,7 @@ IncrementalParser::IncrementalParser(Interpreter &Interp,
     CachedInCodeGenModule = GenModule();
 
   std::unique_ptr<ASTConsumer> IncrConsumer =
-      std::make_unique<IncrementalASTConsumer>(Interp, CI->takeASTConsumer());
+      std::make_unique<IncrementalASTConsumer>(CI->takeASTConsumer(), CB);
   CI->setASTConsumer(std::move(IncrConsumer));
   Consumer = &CI->getASTConsumer();
   P.reset(

clang/lib/Interpreter/IncrementalParser.h

@@ -34,7 +34,7 @@ class CompilerInstance;
 class Parser;
 
 class IncrementalAction;
-class Interpreter;
+class InterpreterCallbacks;
 /// Provides support for incremental compilation. Keeps track of the state
 /// changes between the subsequent incremental input.
 ///
@@ -66,9 +66,9 @@ class IncrementalParser {
   IncrementalParser();
 
 public:
-  IncrementalParser(Interpreter &Interp,
-                    std::unique_ptr<CompilerInstance> Instance,
-                    llvm::LLVMContext &LLVMCtx, llvm::Error &Err);
+  IncrementalParser(std::unique_ptr<CompilerInstance> Instance,
+                    llvm::LLVMContext &LLVMCtx, llvm::Error &Err,
+                    InterpreterCallbacks *CB);
   virtual ~IncrementalParser();
 
   CompilerInstance *getCI() { return CI.get(); }