Make Value's destructor safe by updating ArrValue and StrValue

Author: SahilPatidar

clang/include/clang/Interpreter/Value.h

@@ -185,17 +185,19 @@ class REPL_EXTERNAL_VISIBILITY Value final {
   }
     REPL_BUILTIN_TYPES
 #undef X
+
+    Builtins(const Builtins &) = delete;
+    Builtins &operator=(const Builtins &) = delete;
   };
 
   /// Represents an array of `Value` elements.
   struct ArrValue {
-    std::vector<Value> Elements;
+    Value *Elements;
     uint64_t ArrSize;
-    ArrValue(uint64_t Size) : ArrSize(Size) {
-      Elements.reserve(ArrSize);
-      for (uint64_t I = 0; I < ArrSize; ++I)
-        Elements.emplace_back();
-    }
+    ArrValue(uint64_t Size) : Elements(new Value[Size]), ArrSize(Size) {}
+    ~ArrValue() { delete[] Elements; }
+    ArrValue(const ArrValue &) = delete;
+    ArrValue &operator=(const ArrValue &) = delete;
   };
 
   /// Represents a pointer. Holds the address and optionally a pointee `Value`.
@@ -207,13 +209,37 @@ class REPL_EXTERNAL_VISIBILITY Value final {
       if (Pointee != nullptr)
         delete Pointee;
     }
+
+    PtrValue(const PtrValue &) = delete;
+    PtrValue &operator=(const PtrValue &) = delete;
   };
 
   /// Represents a string value (wrapper over std::string).
   struct StrValue {
-    std::string StringBuf;
-    StrValue(std::string str) : StringBuf(std::move(str)) {}
-    ~StrValue() = default;
+    char *Buf;
+    size_t Length;
+
+    StrValue(const char *Str) {
+      Length = strlen(Str);
+      Buf = new char[Length + 1];
+      memcpy(Buf, Str, Length);
+      Buf[Length] = '\0';
+    }
+
+    ~StrValue() { delete[] Buf; }
+
+    StrValue(const StrValue &) = delete;
+    StrValue &operator=(const StrValue &) = delete;
+
+    void set(const char *Str) {
+      delete[] Buf;
+      Length = strlen(Str);
+      Buf = new char[Length + 1];
+      memcpy(Buf, Str, Length);
+      Buf[Length] = '\0';
+    }
+
+    const char *get() const { return Buf; }
   };
 
 public:
@@ -230,7 +256,7 @@ class REPL_EXTERNAL_VISIBILITY Value final {
   std::optional<ValueCleanup> Cleanup = std::nullopt;
 
 public:
-  Value() = default;
+  Value() : VKind(K_None) {}
   explicit Value(QualType Ty) : Ty(Ty), VKind(K_None) {}
   Value(const Value &RHS);
   Value(Value &&RHS)
@@ -335,23 +361,18 @@ class REPL_EXTERNAL_VISIBILITY Value final {
   // ---- String accessors ----
   void setStrVal(const char *buf) {
     assert(isStr() && "Not a Str");
-    asStr().StringBuf = buf;
-  }
-
-  StringRef getStrVal() {
-    assert(isStr() && "Not a Str");
-    return StringRef(asStr().StringBuf);
+    asStr().set(buf);
   }
 
-  const StringRef getStrVal() const {
+  const char *getStrVal() const {
     assert(isStr() && "Not a Str");
-    return StringRef(asStr().StringBuf);
+    return asStr().get();
   }
 
   // ---- Array accessors ----
   uint64_t getArraySize() const { return asArray().ArrSize; }
 
-  uint64_t getArrayInitializedElts() const { return asArray().Elements.size(); }
+  uint64_t getArrayInitializedElts() const { return asArray().ArrSize; }
 
   Value &getArrayInitializedElt(unsigned I) {
     assert(isArray() && "Invalid accessor");
@@ -427,7 +448,7 @@ class REPL_EXTERNAL_VISIBILITY Value final {
     VKind = K_Pointer;
   }
 
-  void MakeStr(std::string Str = "") {
+  void MakeStr(const char *Str) {
     assert(isAbsent() && "Bad state change");
     new ((void *)(char *)&Data) StrValue(Str);
     VKind = K_Str;

clang/lib/Interpreter/InterpreterValuePrinter.cpp

@@ -155,6 +155,16 @@ static std::string FunctionToString(ASTContext &Ctx, QualType QT,
   return Str;
 }
 
+static std::string CharPtrToString(const char *Ptr) {
+  if (!Ptr)
+    return "0";
+
+  std::string Result = "\"";
+  Result += Ptr;
+  Result += '"';
+  return Result;
+}
+
 namespace clang {
 
 std::string ValueToString::toString(const Value *Buf) {
@@ -291,7 +301,7 @@ std::string ValueToString::PointerToString(const Value &P) {
     // char* -> print string literal
     if (PointeeTy->isCharType()) {
       if (P.HasPointee() && P.getPointerPointee().isStr())
-        return "\"" + P.getPointerPointee().getStrVal().str() + "\"";
+        return CharPtrToString(P.getPointerPointee().getStrVal());
       return std::to_string(P.getAddr());
     }
 

clang/lib/Interpreter/Value.cpp

@@ -162,7 +162,7 @@ Value::Value(const Value &RHS)
     break;
   }
   case K_Str:
-    MakeStr(RHS.getStrVal().str());
+    MakeStr(RHS.getStrVal());
     break;
   }
 }