Coverage Report

Created: 2020-02-25 14:32

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/AST/Interp/Descriptor.h
Line
Count
Source (jump to first uncovered line)
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
0
  const Decl *asDecl() const { return Source.dyn_cast<const Decl *>(); }
113
0
  const Expr *asExpr() const { return Source.dyn_cast<const Expr *>(); }
114
115
0
  const ValueDecl *asValueDecl() const {
116
0
    return dyn_cast_or_null<ValueDecl>(asDecl());
117
0
  }
118
119
0
  const FieldDecl *asFieldDecl() const {
120
0
    return dyn_cast_or_null<FieldDecl>(asDecl());
121
0
  }
122
123
0
  const RecordDecl *asRecordDecl() const {
124
0
    return dyn_cast_or_null<RecordDecl>(asDecl());
125
0
  }
126
127
  /// Returns the size of the object without metadata.
128
0
  unsigned getSize() const {
129
0
    assert(!isUnknownSizeArray() && "Array of unknown size");
130
0
    return Size;
131
0
  }
132
133
  /// Returns the allocated size, including metadata.
134
0
  unsigned getAllocSize() const { return AllocSize; }
135
  /// returns the size of an element when the structure is viewed as an array.
136
0
  unsigned getElemSize()  const { return ElemSize; }
137
138
  /// Returns the number of elements stored in the block.
139
0
  unsigned getNumElems() const {
140
0
    return Size == UnknownSizeMark ? 0 : (getSize() / getElemSize());
141
0
  }
142
143
  /// Checks if the descriptor is of an array of primitives.
144
0
  bool isPrimitiveArray() const { return IsArray && !ElemDesc; }
145
  /// Checks if the descriptor is of an array of zero size.
146
0
  bool isZeroSizeArray() const { return Size == 0; }
147
  /// Checks if the descriptor is of an array of unknown size.
148
0
  bool isUnknownSizeArray() const { return Size == UnknownSizeMark; }
149
150
  /// Checks if the descriptor is of a primitive.
151
0
  bool isPrimitive() const { return !IsArray && !ElemRecord; }
152
153
  /// Checks if the descriptor is of an array.
154
0
  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