1 //===-- InterpBlock.h - Allocated blocks for the interpreter -*- C++ ----*-===// 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 // Defines the classes describing allocated blocks. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_CLANG_AST_INTERP_BLOCK_H 14 #define LLVM_CLANG_AST_INTERP_BLOCK_H 15 16 #include "Descriptor.h" 17 #include "clang/AST/Decl.h" 18 #include "clang/AST/DeclCXX.h" 19 #include "clang/AST/Expr.h" 20 #include "clang/AST/ComparisonCategories.h" 21 #include "llvm/ADT/PointerUnion.h" 22 #include "llvm/Support/raw_ostream.h" 23 24 namespace clang { 25 namespace interp { 26 class Block; 27 class DeadBlock; 28 class InterpState; 29 class Pointer; 30 enum PrimType : unsigned; 31 32 /// A memory block, either on the stack or in the heap. 33 /// 34 /// The storage described by the block is immediately followed by 35 /// optional metadata, which is followed by the actual data. 36 /// 37 /// Block* rawData() data() 38 /// │ │ │ 39 /// │ │ │ 40 /// ▼ ▼ ▼ 41 /// ┌───────────────┬─────────────────────────┬─────────────────┐ 42 /// │ Block │ Metadata │ Data │ 43 /// │ sizeof(Block) │ Desc->getMetadataSize() │ Desc->getSize() │ 44 /// └───────────────┴─────────────────────────┴─────────────────┘ 45 /// 46 /// Desc->getAllocSize() describes the size after the Block, i.e. 47 /// the data size and the metadata size. 48 /// 49 class Block final { 50 public: 51 // Creates a new block. 52 Block(const std::optional<unsigned> &DeclID, Descriptor *Desc, 53 bool IsStatic = false, bool IsExtern = false) DeclID(DeclID)54 : DeclID(DeclID), IsStatic(IsStatic), IsExtern(IsExtern), Desc(Desc) {} 55 56 Block(Descriptor *Desc, bool IsStatic = false, bool IsExtern = false) 57 : DeclID((unsigned)-1), IsStatic(IsStatic), IsExtern(IsExtern), 58 Desc(Desc) {} 59 60 /// Returns the block's descriptor. getDescriptor()61 Descriptor *getDescriptor() const { return Desc; } 62 /// Checks if the block has any live pointers. hasPointers()63 bool hasPointers() const { return Pointers; } 64 /// Checks if the block is extern. isExtern()65 bool isExtern() const { return IsExtern; } 66 /// Checks if the block has static storage duration. isStatic()67 bool isStatic() const { return IsStatic; } 68 /// Checks if the block is temporary. isTemporary()69 bool isTemporary() const { return Desc->IsTemporary; } 70 /// Returns the size of the block. getSize()71 InterpSize getSize() const { return Desc->getAllocSize(); } 72 /// Returns the declaration ID. getDeclID()73 std::optional<unsigned> getDeclID() const { return DeclID; } 74 75 /// Returns a pointer to the stored data. 76 /// You are allowed to read Desc->getSize() bytes from this address. data()77 char *data() { 78 // rawData might contain metadata as well. 79 size_t DataOffset = Desc->getMetadataSize(); 80 return rawData() + DataOffset; 81 } data()82 const char *data() const { 83 // rawData might contain metadata as well. 84 size_t DataOffset = Desc->getMetadataSize(); 85 return rawData() + DataOffset; 86 } 87 88 /// Returns a pointer to the raw data, including metadata. 89 /// You are allowed to read Desc->getAllocSize() bytes from this address. rawData()90 char *rawData() { return reinterpret_cast<char *>(this) + sizeof(Block); } rawData()91 const char *rawData() const { 92 return reinterpret_cast<const char *>(this) + sizeof(Block); 93 } 94 95 /// Returns a view over the data. 96 template <typename T> deref()97 T &deref() { return *reinterpret_cast<T *>(data()); } 98 99 /// Invokes the constructor. invokeCtor()100 void invokeCtor() { 101 std::memset(rawData(), 0, Desc->getAllocSize()); 102 if (Desc->CtorFn) 103 Desc->CtorFn(this, data(), Desc->IsConst, Desc->IsMutable, 104 /*isActive=*/true, Desc); 105 } 106 107 // Invokes the Destructor. invokeDtor()108 void invokeDtor() { 109 if (Desc->DtorFn) 110 Desc->DtorFn(this, data(), Desc); 111 } 112 113 protected: 114 friend class Pointer; 115 friend class DeadBlock; 116 friend class InterpState; 117 Block(Descriptor * Desc,bool IsExtern,bool IsStatic,bool IsDead)118 Block(Descriptor *Desc, bool IsExtern, bool IsStatic, bool IsDead) 119 : IsStatic(IsStatic), IsExtern(IsExtern), IsDead(true), Desc(Desc) {} 120 121 // Deletes a dead block at the end of its lifetime. 122 void cleanup(); 123 124 // Pointer chain management. 125 void addPointer(Pointer *P); 126 void removePointer(Pointer *P); 127 void movePointer(Pointer *From, Pointer *To); 128 129 /// Start of the chain of pointers. 130 Pointer *Pointers = nullptr; 131 /// Unique identifier of the declaration. 132 std::optional<unsigned> DeclID; 133 /// Flag indicating if the block has static storage duration. 134 bool IsStatic = false; 135 /// Flag indicating if the block is an extern. 136 bool IsExtern = false; 137 /// Flag indicating if the pointer is dead. 138 bool IsDead = false; 139 /// Pointer to the stack slot descriptor. 140 Descriptor *Desc; 141 }; 142 143 /// Descriptor for a dead block. 144 /// 145 /// Dead blocks are chained in a double-linked list to deallocate them 146 /// whenever pointers become dead. 147 class DeadBlock final { 148 public: 149 /// Copies the block. 150 DeadBlock(DeadBlock *&Root, Block *Blk); 151 152 /// Returns a pointer to the stored data. data()153 char *data() { return B.data(); } 154 155 private: 156 friend class Block; 157 friend class InterpState; 158 159 void free(); 160 161 /// Root pointer of the list. 162 DeadBlock *&Root; 163 /// Previous block in the list. 164 DeadBlock *Prev; 165 /// Next block in the list. 166 DeadBlock *Next; 167 168 /// Actual block storing data and tracking pointers. 169 Block B; 170 }; 171 172 } // namespace interp 173 } // namespace clang 174 175 #endif 176