clang  10.0.0svn
Descriptor.h
Go to the documentation of this file.
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 
112  const Decl *asDecl() const { return Source.dyn_cast<const Decl *>(); }
113  const Expr *asExpr() const { return Source.dyn_cast<const Expr *>(); }
114 
115  const ValueDecl *asValueDecl() const {
116  return dyn_cast_or_null<ValueDecl>(asDecl());
117  }
118 
119  const FieldDecl *asFieldDecl() const {
120  return dyn_cast_or_null<FieldDecl>(asDecl());
121  }
122 
123  const RecordDecl *asRecordDecl() const {
124  return dyn_cast_or_null<RecordDecl>(asDecl());
125  }
126 
127  /// Returns the size of the object without metadata.
128  unsigned getSize() const {
129  assert(!isUnknownSizeArray() && "Array of unknown size");
130  return Size;
131  }
132 
133  /// Returns the allocated size, including metadata.
134  unsigned getAllocSize() const { return AllocSize; }
135  /// returns the size of an element when the structure is viewed as an array.
136  unsigned getElemSize() const { return ElemSize; }
137 
138  /// Returns the number of elements stored in the block.
139  unsigned getNumElems() const {
140  return Size == UnknownSizeMark ? 0 : (getSize() / getElemSize());
141  }
142 
143  /// Checks if the descriptor is of an array of primitives.
144  bool isPrimitiveArray() const { return IsArray && !ElemDesc; }
145  /// Checks if the descriptor is of an array of zero size.
146  bool isZeroSizeArray() const { return Size == 0; }
147  /// Checks if the descriptor is of an array of unknown size.
148  bool isUnknownSizeArray() const { return Size == UnknownSizeMark; }
149 
150  /// Checks if the descriptor is of a primitive.
151  bool isPrimitive() const { return !IsArray && !ElemRecord; }
152 
153  /// Checks if the descriptor is of an array.
154  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.
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 
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
unsigned IsMutable
Flag indicating if the field is mutable (if in a record).
Definition: Descriptor.h:180
unsigned llvm::PointerUnion< const Decl *, const Expr * > DeclTy
Definition: Descriptor.h:26
A (possibly-)qualified type.
Definition: Type.h:643
bool isPrimitive() const
Checks if the descriptor is of a primitive.
Definition: Descriptor.h:151
unsigned getElemSize() const
returns the size of an element when the structure is viewed as an array.
Definition: Descriptor.h:136
unsigned IsActive
Flag indicating if the field is the active member of a union.
Definition: Descriptor.h:178
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
bool isPrimitiveArray() const
Checks if the descriptor is of an array of primitives.
Definition: Descriptor.h:144
The base class of the type hierarchy.
Definition: Type.h:1436
Descriptor(const DeclTy &D, PrimType Type, bool IsConst, bool IsTemporary, bool IsMutable)
Allocates a descriptor for a primitive.
Definition: Descriptor.cpp:188
QualType getType() const
Definition: Descriptor.cpp:245
const BlockMoveFn MoveFn
Definition: Descriptor.h:85
const FieldDecl * asFieldDecl() const
Definition: Descriptor.h:119
Represents a struct/union/class.
Definition: Decl.h:3662
Represents a member of a struct/union/class.
Definition: Decl.h:2643
Bitfield tracking the initialisation status of elements of primitive arrays.
Definition: Descriptor.h:189
unsigned IsInitialized
For primitive fields, it indicates if the field was initialized.
Definition: Descriptor.h:174
A memory block, either on the stack or in the heap.
Definition: Block.h:37
const Decl * asDecl() const
Definition: Descriptor.h:112
Token to denote structures of unknown size.
Definition: Descriptor.h:67
Structure/Class descriptor.
Definition: Record.h:23
Inline descriptor embedded in structures and arrays.
Definition: Descriptor.h:163
PrimType
Enumeration of the primitive types of the VM.
Definition: PrimType.h:27
#define CHAR_BIT
Definition: limits.h:63
unsigned getSize() const
Returns the size of the object without metadata.
Definition: Descriptor.h:128
const ValueDecl * asValueDecl() const
Definition: Descriptor.h:115
Describes a memory block created by an allocation site.
Definition: Descriptor.h:51
const RecordDecl * asRecordDecl() const
Definition: Descriptor.h:123
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:644
This represents one expression.
Definition: Expr.h:108
bool isZeroSizeArray() const
Checks if the descriptor is of an array of zero size.
Definition: Descriptor.h:146
unsigned IsBase
Flag indicating if the field is an embedded base class.
Definition: Descriptor.h:176
void(*)(Block *Storage, char *SrcFieldPtr, char *DstFieldPtr, Descriptor *FieldDesc) BlockMoveFn
Invoked when a block with pointers referencing it goes out of scope.
Definition: Descriptor.h:45
const bool IsTemporary
Flag indicating if the block is a temporary.
Definition: Descriptor.h:78
bool isArray() const
Checks if the descriptor is of an array.
Definition: Descriptor.h:154
const BlockCtorFn CtorFn
Storage management methods.
Definition: Descriptor.h:83
unsigned IsConst
Flag indicating if the storage is constant or not.
Definition: Descriptor.h:169
Encodes a location in the source.
unsigned getAllocSize() const
Returns the allocated size, including metadata.
Definition: Descriptor.h:134
const bool IsArray
Flag indicating if the block is an array.
Definition: Descriptor.h:80
void(*)(Block *Storage, char *FieldPtr, Descriptor *FieldDesc) BlockDtorFn
Invoked when a block is destroyed.
Definition: Descriptor.h:38
const Expr * asExpr() const
Definition: Descriptor.h:113
SourceLocation getLocation() const
Definition: Descriptor.cpp:253
Dataflow Directional Tag Classes.
const BlockDtorFn DtorFn
Definition: Descriptor.h:84
void(*)(Block *Storage, char *FieldPtr, bool IsConst, bool IsMutable, bool IsActive, Descriptor *FieldDesc) BlockCtorFn
Invoked whenever a block is created.
Definition: Descriptor.h:33
unsigned InterpSize
Object size as used by the interpreter.
Definition: Descriptor.h:48
bool isUnknownSizeArray() const
Checks if the descriptor is of an array of unknown size.
Definition: Descriptor.h:148
Record *const ElemRecord
Pointer to the record, if block contains records.
Definition: Descriptor.h:70
unsigned getNumElems() const
Returns the number of elements stored in the block.
Definition: Descriptor.h:139
void initialize(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema)
Descriptor *const ElemDesc
Descriptor of the array element.
Definition: Descriptor.h:72
unsigned Offset
Offset inside the structure/array.
Definition: Descriptor.h:165