clang/lib/Interpreter/Value.cpp

   1 //===------------ Value.cpp - Definition of interpreter value -------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file defines the class that used to represent a value in incremental
  10 // C++.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Interpreter/Value.h"
  15 #include "clang/AST/ASTContext.h"
  16 #include "clang/AST/Type.h"
  17 #include "clang/Interpreter/Interpreter.h"
  18 #include "llvm/ADT/StringExtras.h"
  19 #include "llvm/Support/ErrorHandling.h"
  20 #include "llvm/Support/raw_os_ostream.h"
  21 #include <cassert>
  22 #include <cstdint>
  23 #include <utility>
  24
  25 namespace {
  26
  27 // This is internal buffer maintained by Value, used to hold temporaries.
  28 class ValueStorage {
  29 public:
  30   using DtorFunc = void (*)(void *);
  31
  32   static unsigned char *CreatePayload(void *DtorF, size_t AllocSize,
  33                                       size_t ElementsSize) {
  34     if (AllocSize < sizeof(Canary))
  35       AllocSize = sizeof(Canary);
  36     unsigned char *Buf =
  37         new unsigned char[ValueStorage::getPayloadOffset() + AllocSize];
  38     ValueStorage *VS = new (Buf) ValueStorage(DtorF, AllocSize, ElementsSize);
  39     std::memcpy(VS->getPayload(), Canary, sizeof(Canary));
  40     return VS->getPayload();
  41   }
  42
  43   unsigned char *getPayload() { return Storage; }
  44   const unsigned char *getPayload() const { return Storage; }
  45
  46   static unsigned getPayloadOffset() {
  47     static ValueStorage Dummy(nullptr, 0, 0);
  48     return Dummy.getPayload() - reinterpret_cast<unsigned char *>(&Dummy);
  49   }
  50
  51   static ValueStorage *getFromPayload(void *Payload) {
  52     ValueStorage *R = reinterpret_cast<ValueStorage *>(
  53         (unsigned char *)Payload - getPayloadOffset());
  54     return R;
  55   }
  56
  57   void Retain() { ++RefCnt; }
  58
  59   void Release() {
  60     assert(RefCnt > 0 && "Can't release if reference count is already zero");
  61     if (--RefCnt == 0) {
  62       // We have a non-trivial dtor.
  63       if (Dtor && IsAlive()) {
  64         assert(Elements && "We at least should have 1 element in Value");
  65         size_t Stride = AllocSize / Elements;
  66         for (size_t Idx = 0; Idx < Elements; ++Idx)
  67           (*Dtor)(getPayload() + Idx * Stride);
  68       }
  69       delete[] reinterpret_cast<unsigned char *>(this);
  70     }
  71   }
  72
  73   // Check whether the storage is valid by validating the canary bits.
  74   // If someone accidentally write some invalid bits in the storage, the canary
  75   // will be changed first, and `IsAlive` will return false then.
  76   bool IsAlive() const {
  77     return std::memcmp(getPayload(), Canary, sizeof(Canary)) != 0;
  78   }
  79
  80 private:
  81   ValueStorage(void *DtorF, size_t AllocSize, size_t ElementsNum)
  82       : RefCnt(1), Dtor(reinterpret_cast<DtorFunc>(DtorF)),
  83         AllocSize(AllocSize), Elements(ElementsNum) {}
  84
  85   mutable unsigned RefCnt;
  86   DtorFunc Dtor = nullptr;
  87   size_t AllocSize = 0;
  88   size_t Elements = 0;
  89   unsigned char Storage[1];
  90
  91   // These are some canary bits that are used for protecting the storage been
  92   // damaged.
  93   static constexpr unsigned char Canary[8] = {0x4c, 0x37, 0xad, 0x8f,
  94                                               0x2d, 0x23, 0x95, 0x91};
  95 };
  96 } // namespace
  97
  98 namespace clang {
  99
 100 static Value::Kind ConvertQualTypeToKind(const ASTContext &Ctx, QualType QT) {
 101   if (Ctx.hasSameType(QT, Ctx.VoidTy))
 102     return Value::K_Void;
 103
 104   if (const auto *ET = QT->getAs<EnumType>())
 105     QT = ET->getDecl()->getIntegerType();
 106
 107   const auto *BT = QT->getAs<BuiltinType>();
 108   if (!BT || BT->isNullPtrType())
 109     return Value::K_PtrOrObj;
 110
 111   switch (QT->castAs<BuiltinType>()->getKind()) {
 112   default:
 113     assert(false && "Type not supported");
 114     return Value::K_Unspecified;
 115 #define X(type, name)                                                          \
 116   case BuiltinType::name:                                                      \
 117     return Value::K_##name;
 118     REPL_BUILTIN_TYPES
 119 #undef X
 120   }
 121 }
 122
 123 Value::Value(Interpreter *In, void *Ty) : Interp(In), OpaqueType(Ty) {
 124   setKind(ConvertQualTypeToKind(getASTContext(), getType()));
 125   if (ValueKind == K_PtrOrObj) {
 126     QualType Canon = getType().getCanonicalType();
 127     if ((Canon->isPointerType() || Canon->isObjectType() ||
 128          Canon->isReferenceType()) &&
 129         (Canon->isRecordType() || Canon->isConstantArrayType() ||
 130          Canon->isMemberPointerType())) {
 131       IsManuallyAlloc = true;
 132       // Compile dtor function.
 133       Interpreter &Interp = getInterpreter();
 134       void *DtorF = nullptr;
 135       size_t ElementsSize = 1;
 136       QualType DtorTy = getType();
 137
 138       if (const auto *ArrTy =
 139               llvm::dyn_cast<ConstantArrayType>(DtorTy.getTypePtr())) {
 140         DtorTy = ArrTy->getElementType();
 141         llvm::APInt ArrSize(sizeof(size_t) * 8, 1);
 142         do {
 143           ArrSize *= ArrTy->getSize();
 144           ArrTy = llvm::dyn_cast<ConstantArrayType>(
 145               ArrTy->getElementType().getTypePtr());
 146         } while (ArrTy);
 147         ElementsSize = static_cast<size_t>(ArrSize.getZExtValue());
 148       }
 149       if (const auto *RT = DtorTy->getAs<RecordType>()) {
 150         if (CXXRecordDecl *CXXRD =
 151                 llvm::dyn_cast<CXXRecordDecl>(RT->getDecl())) {
 152           if (llvm::Expected<llvm::orc::ExecutorAddr> Addr =
 153                   Interp.CompileDtorCall(CXXRD))
 154             DtorF = reinterpret_cast<void *>(Addr->getValue());
 155           else
 156             llvm::logAllUnhandledErrors(Addr.takeError(), llvm::errs());
 157         }
 158       }
 159
 160       size_t AllocSize =
 161           getASTContext().getTypeSizeInChars(getType()).getQuantity();
 162       unsigned char *Payload =
 163           ValueStorage::CreatePayload(DtorF, AllocSize, ElementsSize);
 164       setPtr((void *)Payload);
 165     }
 166   }
 167 }
 168
 169 Value::Value(const Value &RHS)
 170     : Interp(RHS.Interp), OpaqueType(RHS.OpaqueType), Data(RHS.Data),
 171       ValueKind(RHS.ValueKind), IsManuallyAlloc(RHS.IsManuallyAlloc) {
 172   if (IsManuallyAlloc)
 173     ValueStorage::getFromPayload(getPtr())->Retain();
 174 }
 175
 176 Value::Value(Value &&RHS) noexcept {
 177   Interp = std::exchange(RHS.Interp, nullptr);
 178   OpaqueType = std::exchange(RHS.OpaqueType, nullptr);
 179   Data = RHS.Data;
 180   ValueKind = std::exchange(RHS.ValueKind, K_Unspecified);
 181   IsManuallyAlloc = std::exchange(RHS.IsManuallyAlloc, false);
 182
 183   if (IsManuallyAlloc)
 184     ValueStorage::getFromPayload(getPtr())->Release();
 185 }
 186
 187 Value &Value::operator=(const Value &RHS) {
 188   if (IsManuallyAlloc)
 189     ValueStorage::getFromPayload(getPtr())->Release();
 190
 191   Interp = RHS.Interp;
 192   OpaqueType = RHS.OpaqueType;
 193   Data = RHS.Data;
 194   ValueKind = RHS.ValueKind;
 195   IsManuallyAlloc = RHS.IsManuallyAlloc;
 196
 197   if (IsManuallyAlloc)
 198     ValueStorage::getFromPayload(getPtr())->Retain();
 199
 200   return *this;
 201 }
 202
 203 Value &Value::operator=(Value &&RHS) noexcept {
 204   if (this != &RHS) {
 205     if (IsManuallyAlloc)
 206       ValueStorage::getFromPayload(getPtr())->Release();
 207
 208     Interp = std::exchange(RHS.Interp, nullptr);
 209     OpaqueType = std::exchange(RHS.OpaqueType, nullptr);
 210     ValueKind = std::exchange(RHS.ValueKind, K_Unspecified);
 211     IsManuallyAlloc = std::exchange(RHS.IsManuallyAlloc, false);
 212
 213     Data = RHS.Data;
 214   }
 215   return *this;
 216 }
 217
 218 void Value::clear() {
 219   if (IsManuallyAlloc)
 220     ValueStorage::getFromPayload(getPtr())->Release();
 221   ValueKind = K_Unspecified;
 222   OpaqueType = nullptr;
 223   Interp = nullptr;
 224   IsManuallyAlloc = false;
 225 }
 226
 227 Value::~Value() { clear(); }
 228
 229 void *Value::getPtr() const {
 230   assert(ValueKind == K_PtrOrObj);
 231   return Data.m_Ptr;
 232 }
 233
 234 QualType Value::getType() const {
 235   return QualType::getFromOpaquePtr(OpaqueType);
 236 }
 237
 238 Interpreter &Value::getInterpreter() {
 239   assert(Interp != nullptr &&
 240          "Can't get interpreter from a default constructed value");
 241   return *Interp;
 242 }
 243
 244 const Interpreter &Value::getInterpreter() const {
 245   assert(Interp != nullptr &&
 246          "Can't get interpreter from a default constructed value");
 247   return *Interp;
 248 }
 249
 250 ASTContext &Value::getASTContext() { return getInterpreter().getASTContext(); }
 251
 252 const ASTContext &Value::getASTContext() const {
 253   return getInterpreter().getASTContext();
 254 }
 255
 256 void Value::dump() const { print(llvm::outs()); }
 257
 258 void Value::printType(llvm::raw_ostream &Out) const {
 259   Out << "Not implement yet.\n";
 260 }
 261 void Value::printData(llvm::raw_ostream &Out) const {
 262   Out << "Not implement yet.\n";
 263 }
 264 void Value::print(llvm::raw_ostream &Out) const {
 265   assert(OpaqueType != nullptr && "Can't print default Value");
 266   Out << "Not implement yet.\n";
 267 }
 268
 269 } // namespace clang