[clang-repl] Reimplement value printing using MemoryAccess to support in-process and out-of-process

Author: SahilPatidar

clang/include/clang/Interpreter/Interpreter.h

@@ -109,10 +109,7 @@ class Interpreter {
 
   unsigned InitPTUSize = 0;
 
-  // This member holds the last result of the value printing. It's a class
-  // member because we might want to access it after more inputs. If no value
-  // printing happens, it's in an invalid state.
-  Value LastValue;
+  std::unique_ptr<ValueResultManager> ValMgr;
 
   /// Compiler instance performing the incremental compilation.
   std::unique_ptr<CompilerInstance> CI;
@@ -185,7 +182,7 @@ class Interpreter {
 
   llvm::Expected<PartialTranslationUnit &> Parse(llvm::StringRef Code);
   llvm::Error Execute(PartialTranslationUnit &T);
-  llvm::Error ParseAndExecute(llvm::StringRef Code, Value *V = nullptr);
+  llvm::Error ParseAndExecute(llvm::StringRef Code);
 
   /// Undo N previous incremental inputs.
   llvm::Error Undo(unsigned N = 1);
@@ -226,9 +223,8 @@ class Interpreter {
   /// @{
 
   std::string ValueDataToString(const Value &V) const;
-  std::string ValueTypeToString(const Value &V) const;
 
-  llvm::Expected<Expr *> convertExprToValue(Expr *E);
+  llvm::Expected<Expr *> convertExprToValue(Expr *E, bool IsOOP = true);
 
   // When we deallocate clang::Value we need to run the destructor of the type.
   // This function forces emission of the needed dtor.

clang/include/clang/Interpreter/Value.h

@@ -32,8 +32,11 @@
 
 #ifndef LLVM_CLANG_INTERPRETER_VALUE_H
 #define LLVM_CLANG_INTERPRETER_VALUE_H
-
+#include "llvm/ADT/FunctionExtras.h"
 #include "llvm/Config/llvm-config.h" // for LLVM_BUILD_LLVM_DYLIB, LLVM_BUILD_SHARED_LIBS
+#include "llvm/ExecutionEngine/Orc/LLJIT.h"
+#include "llvm/ExecutionEngine/Orc/MemoryAccess.h"
+#include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
 #include "llvm/Support/Compiler.h"
 #include <cassert>
 #include <cstdint>
@@ -107,7 +110,7 @@ class REPL_EXTERNAL_VISIBILITY Value {
     REPL_BUILTIN_TYPES
 #undef X
 
-    K_Void,
+        K_Void,
     K_PtrOrObj,
     K_Unspecified
   };
@@ -206,5 +209,48 @@ template <> inline void *Value::as() const {
     return Data.m_Ptr;
   return (void *)as<uintptr_t>();
 }
+
+class ValueBuffer {
+public:
+  QualType Ty;
+  virtual ~ValueBuffer() = default;
+  virtual std::string toString() const = 0;
+  virtual bool isValid() const = 0;
+};
+
+class ValueResultManager {
+public:
+  using ValueId = uint64_t;
+  using SendResultFn = llvm::unique_function<void(llvm::Error)>;
+
+  explicit ValueResultManager(ASTContext &Ctx, llvm::orc::MemoryAccess &MemAcc);
+
+  static std::unique_ptr<ValueResultManager>
+  Create(llvm::orc::LLJIT &EE, ASTContext &Ctx, bool IsOutOfProcess = true);
+
+  ValueId registerPendingResult(QualType QT) {
+    ValueId NewID = NextID.fetch_add(1, std::memory_order_relaxed);
+    IdToType.insert({NewID, QT});
+    return NewID;
+  }
+
+  void resetAndDump();
+
+  void deliverResult(SendResultFn SendResult, ValueId ID,
+                     llvm::orc::ExecutorAddr VAddr);
+
+private:
+  std::atomic<ValueId> NextID{1};
+  void Initialize(llvm::orc::LLJIT &EE);
+
+  std::string ValueTypeToString(QualType QT) const;
+
+  mutable std::mutex Mutex;
+  ASTContext &Ctx;
+  llvm::orc::MemoryAccess &MemAcc;
+  std::unique_ptr<ValueBuffer> ValBuf = nullptr;
+  llvm::DenseMap<ValueId, clang::QualType> IdToType;
+};
+
 } // namespace clang
 #endif

clang/lib/Interpreter/Interpreter.cpp

@@ -302,6 +302,9 @@ Interpreter::Interpreter(std::unique_ptr<CompilerInstance> Instance,
         return;
       }
   }
+
+  ValMgr = ValueResultManager::Create(IncrExecutor->GetExecutionEngine(),
+                                      getASTContext());
 }
 
 Interpreter::~Interpreter() {
@@ -324,6 +327,7 @@ Interpreter::~Interpreter() {
 // code them.
 const char *const Runtimes = R"(
     #define __CLANG_REPL__ 1
+
 #ifdef __cplusplus
     #define EXTERN_C extern "C"
     struct __clang_Interpreter_NewTag{} __ci_newtag;
@@ -344,6 +348,8 @@ const char *const Runtimes = R"(
       memcpy(Placement, Src, Size);
     }
 #endif // __cplusplus
+  EXTERN_C void __clang_Interpreter_SendResultValue(void *Ctx, unsigned long long, void*);
+  EXTERN_C void __orc_rt_SendResultValue(unsigned long long, void*);
   EXTERN_C void *__clang_Interpreter_SetValueWithAlloc(void*, void*, void*);
   EXTERN_C void __clang_Interpreter_SetValueNoAlloc(void *This, void *OutVal, void *OpaqueType, ...);
 )";
@@ -699,7 +705,7 @@ llvm::Error Interpreter::Execute(PartialTranslationUnit &T) {
   return llvm::Error::success();
 }
 
-llvm::Error Interpreter::ParseAndExecute(llvm::StringRef Code, Value *V) {
+llvm::Error Interpreter::ParseAndExecute(llvm::StringRef Code) {
 
   auto PTU = Parse(Code);
   if (!PTU)
@@ -708,12 +714,8 @@ llvm::Error Interpreter::ParseAndExecute(llvm::StringRef Code, Value *V) {
     if (llvm::Error Err = Execute(*PTU))
       return Err;
 
-  if (LastValue.isValid()) {
-    if (!V) {
-      LastValue.dump();
-      LastValue.clear();
-    } else
-      *V = std::move(LastValue);
+  if (ValMgr) {
+    ValMgr->resetAndDump();
   }
   return llvm::Error::success();
 }