Introduce ValueCleanup for managed destruction of JIT values

Author: SahilPatidar

clang/include/clang/Interpreter/Interpreter.h

@@ -218,12 +218,6 @@ class Interpreter {
 
   std::unique_ptr<llvm::orc::LLJITBuilder> JITBuilder;
 
-  /// @}
-  /// @name Value and pretty printing support
-  /// @{
-
-  std::string ValueDataToString(const Value &V) const;
-
   llvm::Expected<Expr *> convertExprToValue(Expr *E, bool IsOOP = false);
 
   // When we deallocate clang::Value we need to run the destructor of the type.

clang/include/clang/Interpreter/Value.h

@@ -95,6 +95,50 @@ class QualType;
   X(double, Double)                                                            \
   X(long double, LongDouble)
 
+class Value;
+
+/// \struct ValueCleanup
+/// \brief Encapsulates destructor invocation for REPL values.
+///
+/// `ValueCleanup` provides the logic to run object destructors in the JIT
+/// process. It captures the runtime addresses of the destructor wrapper
+/// functions and the object destructor itself.
+///
+/// Typical usage:
+///  - Constructed when a JIT'd type requires cleanup.
+///  - Attached to a `Value` via `setValueCleanup`.
+///  - Invoked through `operator()(Value&)` to run the destructor on demand.
+struct ValueCleanup {
+  using DtorLookupFn =
+      std::function<llvm::Expected<llvm::orc::ExecutorAddr>(QualType Ty)>;
+  llvm::orc::ExecutionSession *ES;
+  llvm::orc::ExecutorAddr DtorWrapperFn;
+  llvm::orc::ExecutorAddr DtorFn;
+  DtorLookupFn ObjDtor;
+  ValueCleanup() = default;
+  ValueCleanup(llvm::orc::ExecutionSession *ES,
+               llvm::orc::ExecutorAddr WrapperFn,
+               llvm::orc::ExecutorAddr DtorFn, DtorLookupFn Dtor)
+      : ES(ES), DtorWrapperFn(WrapperFn), DtorFn(DtorFn),
+        ObjDtor(std::move(Dtor)) {}
+  ~ValueCleanup() = default;
+  void operator()(Value &V);
+};
+
+/// \class Value
+/// \brief Represents a dynamically typed value in the REPL.
+///
+/// `Value` provides a type-erased container for runtime values that can be
+/// produced or consumed by the REPL. It supports multiple storage kinds:
+///
+///  - Builtin scalars (int, float, etc.)
+///  - Arrays of `Value`
+///  - Pointers (with optional pointee tracking)
+///  - Strings
+///  - An empty state (`K_None`)
+///
+/// `Value` also integrates with `ValueCleanup`, which holds runtime
+/// destructor logic for objects that require cleanup.
 class REPL_EXTERNAL_VISIBILITY Value final {
 public:
   enum BuiltinKind {
@@ -105,6 +149,7 @@ class REPL_EXTERNAL_VISIBILITY Value final {
   };
 
 private:
+  /// Storage for builtin scalar values.
   struct Builtins {
   private:
     BuiltinKind BK = K_Unspecified;
@@ -137,6 +182,7 @@ class REPL_EXTERNAL_VISIBILITY Value final {
 #undef X
   };
 
+  /// Represents an array of `Value` elements.
   struct ArrValue {
     std::vector<Value> Elements;
     uint64_t ArrSize;
@@ -147,6 +193,7 @@ class REPL_EXTERNAL_VISIBILITY Value final {
     }
   };
 
+  /// Represents a pointer. Holds the address and optionally a pointee `Value`.
   struct PtrValue {
     uint64_t Addr = 0;
     Value *Pointee; // optional for str
@@ -157,6 +204,7 @@ class REPL_EXTERNAL_VISIBILITY Value final {
     }
   };
 
+  /// Represents a string value (wrapper over std::string).
   struct StrValue {
     std::string StringBuf;
     StrValue(std::string str) : StringBuf(std::move(str)) {}
@@ -173,11 +221,16 @@ class REPL_EXTERNAL_VISIBILITY Value final {
   ValKind VKind = K_None;
   DataType Data;
 
+  /// Optional cleanup action (e.g. call dtor in JIT runtime).
+  std::optional<ValueCleanup> Cleanup = std::nullopt;
+
 public:
   Value() = default;
   explicit Value(QualType Ty, ValKind K) : Ty(Ty), VKind(K) {}
   Value(const Value &RHS);
-  Value(Value &&RHS) : Ty(RHS.Ty), VKind(RHS.VKind), Data(RHS.Data) {
+  Value(Value &&RHS)
+      : Ty(RHS.Ty), VKind(RHS.VKind), Data(RHS.Data),
+        Cleanup(std::move(RHS.Cleanup)) {
     RHS.VKind = K_None;
   }
 
@@ -206,6 +259,7 @@ class REPL_EXTERNAL_VISIBILITY Value final {
       destroy();
   }
 
+  // ---- Raw buffer conversion ----
   template <typename T> static T as(std::vector<uint8_t> &raw) {
     T v{};
     // assert(raw.size() >= sizeof(T) && "Buffer too small for type!");
@@ -266,12 +320,14 @@ class REPL_EXTERNAL_VISIBILITY Value final {
   const StrValue &asStr() const { return const_cast<Value *>(this)->asStr(); }
 
 public:
+  // ---- Query helpers ----
   bool hasBuiltinThis(BuiltinKind K) const {
     if (isBuiltin())
       return asBuiltin().getKind() == K;
     return false;
   }
 
+  // ---- String accessors ----
   void setStrVal(const char *buf) {
     assert(isStr() && "Not a Str");
     asStr().StringBuf = buf;
@@ -287,9 +343,10 @@ class REPL_EXTERNAL_VISIBILITY Value final {
     return StringRef(asStr().StringBuf);
   }
 
+  // ---- Array accessors ----
   uint64_t getArraySize() const { return asArray().ArrSize; }
 
-  uint64_t getArrayInitializedElts() const { return asArray().ArrSize; }
+  uint64_t getArrayInitializedElts() const { return asArray().Elements.size(); }
 
   Value &getArrayInitializedElt(unsigned I) {
     assert(isArray() && "Invalid accessor");
@@ -301,6 +358,7 @@ class REPL_EXTERNAL_VISIBILITY Value final {
     return const_cast<Value *>(this)->getArrayInitializedElt(I);
   }
 
+  // ---- Pointer accessors ----
   bool HasPointee() const {
     assert(isPointer() && "Invalid accessor");
     return !(asPointer().Pointee->isAbsent());
@@ -317,6 +375,7 @@ class REPL_EXTERNAL_VISIBILITY Value final {
 
   uint64_t getAddr() const { return asPointer().Addr; }
 
+  // ---- Builtin setters/getters ----
 #define X(type, name)                                                          \
   void set##name(type Val) { asBuiltin().set##name(Val); }                     \
   type get##name() const { return asBuiltin().get##name(); }
@@ -329,10 +388,19 @@ class REPL_EXTERNAL_VISIBILITY Value final {
   void print(llvm::raw_ostream &Out, ASTContext &Ctx) const;
   void dump(ASTContext &Ctx) const;
 
-  // ---- clear ----
-  void clear() { destroy(); }
+  // ---- Cleanup & destruction ----
+  void setValueCleanup(ValueCleanup VC) {
+    assert(!Cleanup.has_value());
+    Cleanup.emplace(std::move(VC));
+  }
+  void clear() {
+    if (Cleanup.has_value())
+      (*Cleanup)(*this);
+    destroy();
+  }
 
 private:
+  // ---- Constructors for each kind ----
   void MakeBuiltIns() {
     assert(isAbsent() && "Bad state change");
     new ((void *)(char *)&Data) Builtins(BuiltinKind::K_Unspecified);
@@ -408,6 +476,13 @@ class ValueToString {
   std::string ArrayToString(const Value &A);
 };
 
+/// \class ValueResultManager
+/// \brief Manages values returned from JIT code.
+///
+/// Each result is registered with a unique ID and its `QualType`.
+/// The JIT code later calls back into the runtime with that ID, and
+/// `deliverResult` uses it to look up the type, read the value from memory,
+/// and attach any destructor cleanup before making it available to the host.
 class ValueResultManager {
 public:
   using ValueId = uint64_t;
@@ -418,9 +493,12 @@ class ValueResultManager {
   static std::unique_ptr<ValueResultManager>
   Create(llvm::orc::LLJIT &EE, ASTContext &Ctx, bool IsOutOfProcess = false);
 
-  ValueId registerPendingResult(QualType QT) {
+  ValueId registerPendingResult(QualType QT,
+                                std::optional<ValueCleanup> VC = std::nullopt) {
     ValueId NewID = NextID.fetch_add(1, std::memory_order_relaxed);
     IdToType.insert({NewID, QT});
+    if (VC)
+      IdToValCleanup.insert({NewID, std::move(*VC)});
     return NewID;
   }
 
@@ -439,6 +517,7 @@ class ValueResultManager {
   llvm::orc::MemoryAccess &MemAcc;
   Value LastVal;
   llvm::DenseMap<ValueId, clang::QualType> IdToType;
+  llvm::DenseMap<ValueId, ValueCleanup> IdToValCleanup;
 };
 
 } // namespace clang

clang/lib/Interpreter/Interpreter.cpp

@@ -341,6 +341,9 @@ const char *const Runtimes = R"(
     void __clang_Interpreter_SetValueCopyArr(const T (*Src)[N], void* Placement, unsigned long Size) {
       __clang_Interpreter_SetValueCopyArr(Src[0], Placement, Size);
     }
+    EXTERN_C void __clang_Interpreter_destroyObj(unsigned char *ptr) {
+      delete[] ptr;
+    }
 #else
     #define EXTERN_C extern
     EXTERN_C void *memcpy(void *restrict dst, const void *restrict src, __SIZE_TYPE__ n);

clang/lib/Interpreter/InterpreterValuePrinter.cpp

@@ -156,8 +156,6 @@ static std::string FunctionToString(ASTContext &Ctx, QualType QT,
 
 namespace clang {
 
-std::string Interpreter::ValueDataToString(const Value &V) const { return ""; }
-
 std::string ValueToString::toString(const Value *Buf) {
 
   switch (Buf->getKind()) {
@@ -597,9 +595,9 @@ class InterfaceKindVisitor : public TypeVisitor<InterfaceKindVisitor, bool> {
   }
 
   bool VisitRecordType(const RecordType *Ty) {
-    // Args.push_back(
-    //     Converter.handleRecordTypeExpr(Ty, QualType(Ty, 0), E).get());
-    return false;
+    Args.push_back(
+        Converter.handleRecordTypeExpr(Ty, QualType(Ty, 0), E).get());
+    return true;
   }
 
   bool VisitConstantArrayType(const ConstantArrayType *Ty) {
@@ -626,10 +624,18 @@ class InterfaceKindVisitor : public TypeVisitor<InterfaceKindVisitor, bool> {
   }
 };
 
-enum RunTimeFnTag { OrcSendResult, ClangSendResult, ClangDestroyObj };
+enum RunTimeFnTag {
+  OrcSendResult,
+  ClangSendResult,
+  ClangDestroyObj,
+  OrcRunDtorWrapper,
+  ClangRunDtorWrapper
+};
 
 static constexpr llvm::StringRef RunTimeFnTagName[] = {
-    "__orc_rt_SendResultValue", "__clang_Interpreter_SendResultValue"};
+    "__orc_rt_SendResultValue", "__clang_Interpreter_SendResultValue",
+    "__clang_Interpreter_destroyObj", "__orc_rt_runDtor",
+    "__clang_Interpreter_runDtor"};
 
 // This synthesizes a call expression to a speciall
 // function that is responsible for generating the Value.
@@ -674,6 +680,10 @@ llvm::Expected<Expr *> Interpreter::convertExprToValue(Expr *E, bool isOOP) {
     if (llvm::Error Err = LookupInterface(ValuePrintingInfo[ClangSendResult],
                                           RunTimeFnTagName[ClangSendResult]))
       return std::move(Err);
+
+    if (llvm::Error Err = LookupInterface(ValuePrintingInfo[ClangDestroyObj],
+                                          RunTimeFnTagName[ClangDestroyObj]))
+      return std::move(Err);
   }
 
   llvm::SmallVector<Expr *, 4> AdjustedArgs;
@@ -696,7 +706,49 @@ llvm::Expected<Expr *> Interpreter::convertExprToValue(Expr *E, bool isOOP) {
     Ty = Ctx.getLValueReferenceType(Ty);
   }
 
-  auto ID = ValMgr->registerPendingResult(Ty);
+  std::optional<ValueCleanup> CleanUp = std::nullopt;
+  if (DesugaredTy->isRecordType() && E->isPRValue())
+    if (auto *CXXRD = DesugaredTy->getAsCXXRecordDecl()) {
+      auto *Dtor = S.LookupDestructor(CXXRD);
+      Dtor->addAttr(UsedAttr::CreateImplicit(Ctx));
+      getCompilerInstance()->getASTConsumer().HandleTopLevelDecl(
+          DeclGroupRef(Dtor));
+
+      auto ObjDtor =
+          [this](QualType Ty) -> llvm::Expected<llvm::orc::ExecutorAddr> {
+        if (auto *CXXRD = Ty->getAsCXXRecordDecl())
+          return this->CompileDtorCall(CXXRD);
+        return llvm::make_error<llvm::StringError>(
+            "destructor not found!", llvm::inconvertibleErrorCode());
+      };
+
+      std::string DestroyObjFnName = RunTimeFnTagName[ClangDestroyObj].str();
+      std::string RunDtorWrapperFnName =
+          RunTimeFnTagName[isOOP ? OrcRunDtorWrapper : ClangRunDtorWrapper]
+              .str();
+
+      // #if defined(__APPLE__)
+      //       // On macOS, runtime symbols may require a leading underscore
+      //       DestroyObjFnName.insert(0, "_");
+      //       RunDtorWrapperFnName.insert(0, "_");
+      // #endif
+
+      auto RunDtorWrapperAddr = getSymbolAddress(RunDtorWrapperFnName);
+      if (!RunDtorWrapperAddr)
+        return RunDtorWrapperAddr.takeError();
+
+      auto DestroyObjAddr = getSymbolAddress(DestroyObjFnName);
+      if (!DestroyObjAddr)
+        return DestroyObjAddr.takeError();
+
+      if (auto E = getExecutionEngine()) {
+        CleanUp = std::make_optional<ValueCleanup>(
+            &E->getExecutionSession(), *RunDtorWrapperAddr, *DestroyObjAddr,
+            std::move(ObjDtor));
+      }
+    }
+
+  auto ID = ValMgr->registerPendingResult(Ty, std::move(CleanUp));
 
   AdjustedArgs.push_back(IntegerLiteralExpr(Ctx, ID));
 
@@ -731,6 +783,20 @@ __clang_Interpreter_SendResultValue(void *Ctx, uint64_t Id, void *Addr) {
       [](llvm::Error Err) { llvm::cantFail(std::move(Err)); }, Id,
       llvm::orc::ExecutorAddr::fromPtr(Addr));
 }
+
+REPL_EXTERNAL_VISIBILITY llvm::orc::shared::CWrapperFunctionResult
+__clang_Interpreter_runDtor(char *ArgData, size_t ArgSize) {
+  return llvm::orc::shared::WrapperFunction<llvm::orc::shared::SPSError(
+      llvm::orc::shared::SPSExecutorAddr, llvm::orc::shared::SPSExecutorAddr)>::
+      handle(ArgData, ArgSize,
+             [](llvm::orc::ExecutorAddr DtorFn,
+                llvm::orc::ExecutorAddr This) -> llvm::Error {
+               DtorFn.toPtr<void (*)(unsigned char *)>()(
+                   This.toPtr<unsigned char *>());
+               return llvm::Error::success();
+             })
+          .release();
+}
 }
 
 // A trampoline to work around the fact that operator placement new cannot