1 //===--- Descriptor.h - Types for the constexpr VM --------------*- 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 descriptors which characterise allocations. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_CLANG_AST_INTERP_DESCRIPTOR_H 14 #define LLVM_CLANG_AST_INTERP_DESCRIPTOR_H 15 16 #include "clang/AST/Decl.h" 17 #include "clang/AST/Expr.h" 18 19 namespace clang { 20 namespace interp { 21 class Block; 22 class Record; 23 struct Descriptor; 24 enum PrimType : unsigned; 25 26 using DeclTy = llvm::PointerUnion<const Decl *, const Expr *>; 27 28 /// Invoked whenever a block is created. The constructor method fills in the 29 /// inline descriptors of all fields and array elements. It also initializes 30 /// all the fields which contain non-trivial types. 31 using BlockCtorFn = void (*)(Block *Storage, char *FieldPtr, bool IsConst, 32 bool IsMutable, bool IsActive, 33 Descriptor *FieldDesc); 34 35 /// Invoked when a block is destroyed. Invokes the destructors of all 36 /// non-trivial nested fields of arrays and records. 37 using BlockDtorFn = void (*)(Block *Storage, char *FieldPtr, 38 Descriptor *FieldDesc); 39 40 /// Invoked when a block with pointers referencing it goes out of scope. Such 41 /// blocks are persisted: the move function copies all inline descriptors and 42 /// non-trivial fields, as existing pointers might need to reference those 43 /// descriptors. Data is not copied since it cannot be legally read. 44 using BlockMoveFn = void (*)(Block *Storage, char *SrcFieldPtr, 45 char *DstFieldPtr, Descriptor *FieldDesc); 46 47 /// Object size as used by the interpreter. 48 using InterpSize = unsigned; 49 50 /// Describes a memory block created by an allocation site. 51 struct Descriptor { 52 private: 53 /// Original declaration, used to emit the error message. 54 const DeclTy Source; 55 /// Size of an element, in host bytes. 56 const InterpSize ElemSize; 57 /// Size of the storage, in host bytes. 58 const InterpSize Size; 59 /// Size of the allocation (storage + metadata), in host bytes. 60 const InterpSize AllocSize; 61 62 /// Value to denote arrays of unknown size. 63 static constexpr unsigned UnknownSizeMark = (unsigned)-1; 64 65 public: 66 /// Token to denote structures of unknown size. 67 struct UnknownSize {}; 68 69 /// Pointer to the record, if block contains records. 70 Record *const ElemRecord = nullptr; 71 /// Descriptor of the array element. 72 Descriptor *const ElemDesc = nullptr; 73 /// Flag indicating if the block is mutable. 74 const bool IsConst = false; 75 /// Flag indicating if a field is mutable. 76 const bool IsMutable = false; 77 /// Flag indicating if the block is a temporary. 78 const bool IsTemporary = false; 79 /// Flag indicating if the block is an array. 80 const bool IsArray = false; 81 82 /// Storage management methods. 83 const BlockCtorFn CtorFn = nullptr; 84 const BlockDtorFn DtorFn = nullptr; 85 const BlockMoveFn MoveFn = nullptr; 86 87 /// Allocates a descriptor for a primitive. 88 Descriptor(const DeclTy &D, PrimType Type, bool IsConst, bool IsTemporary, 89 bool IsMutable); 90 91 /// Allocates a descriptor for an array of primitives. 92 Descriptor(const DeclTy &D, PrimType Type, size_t NumElems, bool IsConst, 93 bool IsTemporary, bool IsMutable); 94 95 /// Allocates a descriptor for an array of primitives of unknown size. 96 Descriptor(const DeclTy &D, PrimType Type, bool IsTemporary, UnknownSize); 97 98 /// Allocates a descriptor for an array of composites. 99 Descriptor(const DeclTy &D, Descriptor *Elem, unsigned NumElems, bool IsConst, 100 bool IsTemporary, bool IsMutable); 101 102 /// Allocates a descriptor for an array of composites of unknown size. 103 Descriptor(const DeclTy &D, Descriptor *Elem, bool IsTemporary, UnknownSize); 104 105 /// Allocates a descriptor for a record. 106 Descriptor(const DeclTy &D, Record *R, bool IsConst, bool IsTemporary, 107 bool IsMutable); 108 109 QualType getType() const; 110 SourceLocation getLocation() const; 111 asDeclDescriptor112 const Decl *asDecl() const { return Source.dyn_cast<const Decl *>(); } asExprDescriptor113 const Expr *asExpr() const { return Source.dyn_cast<const Expr *>(); } 114 asValueDeclDescriptor115 const ValueDecl *asValueDecl() const { 116 return dyn_cast_or_null<ValueDecl>(asDecl()); 117 } 118 asFieldDeclDescriptor119 const FieldDecl *asFieldDecl() const { 120 return dyn_cast_or_null<FieldDecl>(asDecl()); 121 } 122 asRecordDeclDescriptor123 const RecordDecl *asRecordDecl() const { 124 return dyn_cast_or_null<RecordDecl>(asDecl()); 125 } 126 127 /// Returns the size of the object without metadata. getSizeDescriptor128 unsigned getSize() const { 129 assert(!isUnknownSizeArray() && "Array of unknown size"); 130 return Size; 131 } 132 133 /// Returns the allocated size, including metadata. getAllocSizeDescriptor134 unsigned getAllocSize() const { return AllocSize; } 135 /// returns the size of an element when the structure is viewed as an array. getElemSizeDescriptor136 unsigned getElemSize() const { return ElemSize; } 137 138 /// Returns the number of elements stored in the block. getNumElemsDescriptor139 unsigned getNumElems() const { 140 return Size == UnknownSizeMark ? 0 : (getSize() / getElemSize()); 141 } 142 143 /// Checks if the descriptor is of an array of primitives. isPrimitiveArrayDescriptor144 bool isPrimitiveArray() const { return IsArray && !ElemDesc; } 145 /// Checks if the descriptor is of an array of zero size. isZeroSizeArrayDescriptor146 bool isZeroSizeArray() const { return Size == 0; } 147 /// Checks if the descriptor is of an array of unknown size. isUnknownSizeArrayDescriptor148 bool isUnknownSizeArray() const { return Size == UnknownSizeMark; } 149 150 /// Checks if the descriptor is of a primitive. isPrimitiveDescriptor151 bool isPrimitive() const { return !IsArray && !ElemRecord; } 152 153 /// Checks if the descriptor is of an array. isArrayDescriptor154 bool isArray() const { return IsArray; } 155 }; 156 157 /// Inline descriptor embedded in structures and arrays. 158 /// 159 /// Such descriptors precede all composite array elements and structure fields. 160 /// If the base of a pointer is not zero, the base points to the end of this 161 /// structure. The offset field is used to traverse the pointer chain up 162 /// to the root structure which allocated the object. 163 struct InlineDescriptor { 164 /// Offset inside the structure/array. 165 unsigned Offset; 166 167 /// Flag indicating if the storage is constant or not. 168 /// Relevant for primitive fields. 169 unsigned IsConst : 1; 170 /// For primitive fields, it indicates if the field was initialized. 171 /// Primitive fields in static storage are always initialized. 172 /// Arrays are always initialized, even though their elements might not be. 173 /// Base classes are initialized after the constructor is invoked. 174 unsigned IsInitialized : 1; 175 /// Flag indicating if the field is an embedded base class. 176 unsigned IsBase : 1; 177 /// Flag indicating if the field is the active member of a union. 178 unsigned IsActive : 1; 179 /// Flag indicating if the field is mutable (if in a record). 180 unsigned IsMutable : 1; 181 182 Descriptor *Desc; 183 }; 184 185 /// Bitfield tracking the initialisation status of elements of primitive arrays. 186 /// A pointer to this is embedded at the end of all primitive arrays. 187 /// If the map was not yet created and nothing was initialied, the pointer to 188 /// this structure is 0. If the object was fully initialized, the pointer is -1. 189 struct InitMap { 190 private: 191 /// Type packing bits. 192 using T = uint64_t; 193 /// Bits stored in a single field. 194 static constexpr uint64_t PER_FIELD = sizeof(T) * CHAR_BIT; 195 196 /// Initializes the map with no fields set. 197 InitMap(unsigned N); 198 199 /// Returns a pointer to storage. 200 T *data(); 201 202 public: 203 /// Initializes an element. Returns true when object if fully initialized. 204 bool initialize(unsigned I); 205 206 /// Checks if an element was initialized. 207 bool isInitialized(unsigned I); 208 209 /// Allocates a map holding N elements. 210 static InitMap *allocate(unsigned N); 211 212 private: 213 /// Number of fields initialized. 214 unsigned UninitFields; 215 }; 216 217 } // namespace interp 218 } // namespace clang 219 220 #endif 221