| 1 |
//===--- Descriptor.cpp - 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 |
#include "Descriptor.h" |
| 10 |
#include "Boolean.h" |
| 11 |
#include "Pointer.h" |
| 12 |
#include "PrimType.h" |
| 13 |
#include "Record.h" |
| 14 |
|
| 15 |
using namespace clang; |
| 16 |
using namespace clang::interp; |
| 17 |
|
| 18 |
template <typename T> |
| 19 |
static void ctorTy(Block *, char *Ptr, bool, bool, bool, Descriptor *) { |
| 20 |
new (Ptr) T(); |
| 21 |
} |
| 22 |
|
| 23 |
template <typename T> static void dtorTy(Block *, char *Ptr, Descriptor *) { |
| 24 |
reinterpret_cast<T *>(Ptr)->~T(); |
| 25 |
} |
| 26 |
|
| 27 |
template <typename T> |
| 28 |
static void moveTy(Block *, char *Src, char *Dst, Descriptor *) { |
| 29 |
auto *SrcPtr = reinterpret_cast<T *>(Src); |
| 30 |
auto *DstPtr = reinterpret_cast<T *>(Dst); |
| 31 |
new (DstPtr) T(std::move(*SrcPtr)); |
| 32 |
} |
| 33 |
|
| 34 |
template <typename T> |
| 35 |
static void ctorArrayTy(Block *, char *Ptr, bool, bool, bool, Descriptor *D) { |
| 36 |
for (unsigned I = 0, NE = D->getNumElems(); I < NE; ++I) { |
| 37 |
new (&reinterpret_cast<T *>(Ptr)[I]) T(); |
| 38 |
} |
| 39 |
} |
| 40 |
|
| 41 |
template <typename T> |
| 42 |
static void dtorArrayTy(Block *, char *Ptr, Descriptor *D) { |
| 43 |
InitMap *IM = *reinterpret_cast<InitMap **>(Ptr); |
| 44 |
if (IM != (InitMap *)-1) |
| 45 |
free(IM); |
| 46 |
|
| 47 |
Ptr += sizeof(InitMap *); |
| 48 |
for (unsigned I = 0, NE = D->getNumElems(); I < NE; ++I) { |
| 49 |
reinterpret_cast<T *>(Ptr)[I].~T(); |
| 50 |
} |
| 51 |
} |
| 52 |
|
| 53 |
template <typename T> |
| 54 |
static void moveArrayTy(Block *, char *Src, char *Dst, Descriptor *D) { |
| 55 |
for (unsigned I = 0, NE = D->getNumElems(); I < NE; ++I) { |
| 56 |
auto *SrcPtr = &reinterpret_cast<T *>(Src)[I]; |
| 57 |
auto *DstPtr = &reinterpret_cast<T *>(Dst)[I]; |
| 58 |
new (DstPtr) T(std::move(*SrcPtr)); |
| 59 |
} |
| 60 |
} |
| 61 |
|
| 62 |
static void ctorArrayDesc(Block *B, char *Ptr, bool IsConst, bool IsMutable, |
| 63 |
bool IsActive, Descriptor *D) { |
| 64 |
const unsigned NumElems = D->getNumElems(); |
| 65 |
const unsigned ElemSize = |
| 66 |
D->ElemDesc->getAllocSize() + sizeof(InlineDescriptor); |
| 67 |
|
| 68 |
unsigned ElemOffset = 0; |
| 69 |
for (unsigned I = 0; I < NumElems; ++I, ElemOffset += ElemSize) { |
| 70 |
auto *ElemPtr = Ptr + ElemOffset; |
| 71 |
auto *Desc = reinterpret_cast<InlineDescriptor *>(ElemPtr); |
| 72 |
auto *ElemLoc = reinterpret_cast<char *>(Desc + 1); |
| 73 |
auto *SD = D->ElemDesc; |
| 74 |
|
| 75 |
Desc->Offset = ElemOffset + sizeof(InlineDescriptor); |
| 76 |
Desc->Desc = SD; |
| 77 |
Desc->IsInitialized = true; |
| 78 |
Desc->IsBase = false; |
| 79 |
Desc->IsActive = IsActive; |
| 80 |
Desc->IsConst = IsConst || D->IsConst; |
| 81 |
Desc->IsFieldMutable = IsMutable || D->IsMutable; |
| 82 |
if (auto Fn = D->ElemDesc->CtorFn) |
| 83 |
Fn(B, ElemLoc, Desc->IsConst, Desc->IsFieldMutable, IsActive, |
| 84 |
D->ElemDesc); |
| 85 |
} |
| 86 |
} |
| 87 |
|
| 88 |
static void dtorArrayDesc(Block *B, char *Ptr, Descriptor *D) { |
| 89 |
const unsigned NumElems = D->getNumElems(); |
| 90 |
const unsigned ElemSize = |
| 91 |
D->ElemDesc->getAllocSize() + sizeof(InlineDescriptor); |
| 92 |
|
| 93 |
unsigned ElemOffset = 0; |
| 94 |
for (unsigned I = 0; I < NumElems; ++I, ElemOffset += ElemSize) { |
| 95 |
auto *ElemPtr = Ptr + ElemOffset; |
| 96 |
auto *Desc = reinterpret_cast<InlineDescriptor *>(ElemPtr); |
| 97 |
auto *ElemLoc = reinterpret_cast<char *>(Desc + 1); |
| 98 |
if (auto Fn = D->ElemDesc->DtorFn) |
| 99 |
Fn(B, ElemLoc, D->ElemDesc); |
| 100 |
} |
| 101 |
} |
| 102 |
|
| 103 |
static void moveArrayDesc(Block *B, char *Src, char *Dst, Descriptor *D) { |
| 104 |
const unsigned NumElems = D->getNumElems(); |
| 105 |
const unsigned ElemSize = |
| 106 |
D->ElemDesc->getAllocSize() + sizeof(InlineDescriptor); |
| 107 |
|
| 108 |
unsigned ElemOffset = 0; |
| 109 |
for (unsigned I = 0; I < NumElems; ++I, ElemOffset += ElemSize) { |
| 110 |
auto *SrcPtr = Src + ElemOffset; |
| 111 |
auto *DstPtr = Dst + ElemOffset; |
| 112 |
|
| 113 |
auto *SrcDesc = reinterpret_cast<InlineDescriptor *>(SrcPtr); |
| 114 |
auto *SrcElemLoc = reinterpret_cast<char *>(SrcDesc + 1); |
| 115 |
auto *DstDesc = reinterpret_cast<InlineDescriptor *>(DstPtr); |
| 116 |
auto *DstElemLoc = reinterpret_cast<char *>(DstDesc + 1); |
| 117 |
|
| 118 |
*DstDesc = *SrcDesc; |
| 119 |
if (auto Fn = D->ElemDesc->MoveFn) |
| 120 |
Fn(B, SrcElemLoc, DstElemLoc, D->ElemDesc); |
| 121 |
} |
| 122 |
} |
| 123 |
|
| 124 |
static void ctorRecord(Block *B, char *Ptr, bool IsConst, bool IsMutable, |
| 125 |
bool IsActive, Descriptor *D) { |
| 126 |
const bool IsUnion = D->ElemRecord->isUnion(); |
| 127 |
auto CtorSub = [=](unsigned SubOff, Descriptor *F, bool IsBase) { |
| 128 |
auto *Desc = reinterpret_cast<InlineDescriptor *>(Ptr + SubOff) - 1; |
| 129 |
Desc->Offset = SubOff; |
| 130 |
Desc->Desc = F; |
| 131 |
Desc->IsInitialized = F->IsArray && !IsBase; |
| 132 |
Desc->IsBase = IsBase; |
| 133 |
Desc->IsActive = IsActive && !IsUnion; |
| 134 |
Desc->IsConst = IsConst || F->IsConst; |
| 135 |
Desc->IsFieldMutable = IsMutable || F->IsMutable; |
| 136 |
if (auto Fn = F->CtorFn) |
| 137 |
Fn(B, Ptr + SubOff, Desc->IsConst, Desc->IsFieldMutable, Desc->IsActive, |
| 138 |
F); |
| 139 |
}; |
| 140 |
for (const auto &B : D->ElemRecord->bases()) |
| 141 |
CtorSub(B.Offset, B.Desc, /*isBase=*/true); |
| 142 |
for (const auto &F : D->ElemRecord->fields()) |
| 143 |
CtorSub(F.Offset, F.Desc, /*isBase=*/false); |
| 144 |
for (const auto &V : D->ElemRecord->virtual_bases()) |
| 145 |
CtorSub(V.Offset, V.Desc, /*isBase=*/true); |
| 146 |
} |
| 147 |
|
| 148 |
static void dtorRecord(Block *B, char *Ptr, Descriptor *D) { |
| 149 |
auto DtorSub = [=](unsigned SubOff, Descriptor *F) { |
| 150 |
if (auto Fn = F->DtorFn) |
| 151 |
Fn(B, Ptr + SubOff, F); |
| 152 |
}; |
| 153 |
for (const auto &F : D->ElemRecord->bases()) |
| 154 |
DtorSub(F.Offset, F.Desc); |
| 155 |
for (const auto &F : D->ElemRecord->fields()) |
| 156 |
DtorSub(F.Offset, F.Desc); |
| 157 |
for (const auto &F : D->ElemRecord->virtual_bases()) |
| 158 |
DtorSub(F.Offset, F.Desc); |
| 159 |
} |
| 160 |
|
| 161 |
static void moveRecord(Block *B, char *Src, char *Dst, Descriptor *D) { |
| 162 |
for (const auto &F : D->ElemRecord->fields()) { |
| 163 |
auto FieldOff = F.Offset; |
| 164 |
auto FieldDesc = F.Desc; |
| 165 |
|
| 166 |
*(reinterpret_cast<Descriptor **>(Dst + FieldOff) - 1) = FieldDesc; |
| 167 |
if (auto Fn = FieldDesc->MoveFn) |
| 168 |
Fn(B, Src + FieldOff, Dst + FieldOff, FieldDesc); |
| 169 |
} |
| 170 |
} |
| 171 |
|
| 172 |
static BlockCtorFn getCtorPrim(PrimType Type) { |
| 173 |
COMPOSITE_TYPE_SWITCH(Type, return ctorTy<T>, return nullptr); |
| 174 |
} |
| 175 |
|
| 176 |
static BlockDtorFn getDtorPrim(PrimType Type) { |
| 177 |
COMPOSITE_TYPE_SWITCH(Type, return dtorTy<T>, return nullptr); |
| 178 |
} |
| 179 |
|
| 180 |
static BlockMoveFn getMovePrim(PrimType Type) { |
| 181 |
COMPOSITE_TYPE_SWITCH(Type, return moveTy<T>, return nullptr); |
| 182 |
} |
| 183 |
|
| 184 |
static BlockCtorFn getCtorArrayPrim(PrimType Type) { |
| 185 |
COMPOSITE_TYPE_SWITCH(Type, return ctorArrayTy<T>, return nullptr); |
| 186 |
} |
| 187 |
|
| 188 |
static BlockDtorFn getDtorArrayPrim(PrimType Type) { |
| 189 |
TYPE_SWITCH(Type, return dtorArrayTy<T>); |
| 190 |
llvm_unreachable("unknown Expr"); |
| 191 |
} |
| 192 |
|
| 193 |
static BlockMoveFn getMoveArrayPrim(PrimType Type) { |
| 194 |
COMPOSITE_TYPE_SWITCH(Type, return moveArrayTy<T>, return nullptr); |
| 195 |
} |
| 196 |
|
| 197 |
Descriptor::Descriptor(const DeclTy &D, PrimType Type, MetadataSize MD, |
| 198 |
bool IsConst, bool IsTemporary, bool IsMutable) |
| 199 |
: Source(D), ElemSize(primSize(Type)), Size(ElemSize), |
| 200 |
MDSize(MD.value_or(0)), AllocSize(align(Size + MDSize)), IsConst(IsConst), |
| 201 |
IsMutable(IsMutable), IsTemporary(IsTemporary), CtorFn(getCtorPrim(Type)), |
| 202 |
DtorFn(getDtorPrim(Type)), MoveFn(getMovePrim(Type)) { |
| 203 |
assert(AllocSize >= Size); |
| 204 |
assert(Source && "Missing source"); |
| 205 |
} |
| 206 |
|
| 207 |
Descriptor::Descriptor(const DeclTy &D, PrimType Type, MetadataSize MD, |
| 208 |
size_t NumElems, bool IsConst, bool IsTemporary, |
| 209 |
bool IsMutable) |
| 210 |
: Source(D), ElemSize(primSize(Type)), Size(ElemSize * NumElems), |
| 211 |
MDSize(MD.value_or(0)), |
| 212 |
AllocSize(align(Size) + sizeof(InitMap *) + MDSize), IsConst(IsConst), |
| 213 |
IsMutable(IsMutable), IsTemporary(IsTemporary), IsArray(true), |
| 214 |
CtorFn(getCtorArrayPrim(Type)), DtorFn(getDtorArrayPrim(Type)), |
| 215 |
MoveFn(getMoveArrayPrim(Type)) { |
| 216 |
assert(Source && "Missing source"); |
| 217 |
} |
| 218 |
|
| 219 |
Descriptor::Descriptor(const DeclTy &D, PrimType Type, bool IsTemporary, |
| 220 |
UnknownSize) |
| 221 |
: Source(D), ElemSize(primSize(Type)), Size(UnknownSizeMark), MDSize(0), |
| 222 |
AllocSize(alignof(void *)), IsConst(true), IsMutable(false), |
| 223 |
IsTemporary(IsTemporary), IsArray(true), CtorFn(getCtorArrayPrim(Type)), |
| 224 |
DtorFn(getDtorArrayPrim(Type)), MoveFn(getMoveArrayPrim(Type)) { |
| 225 |
assert(Source && "Missing source"); |
| 226 |
} |
| 227 |
|
| 228 |
Descriptor::Descriptor(const DeclTy &D, Descriptor *Elem, MetadataSize MD, |
| 229 |
unsigned NumElems, bool IsConst, bool IsTemporary, |
| 230 |
bool IsMutable) |
| 231 |
: Source(D), ElemSize(Elem->getAllocSize() + sizeof(InlineDescriptor)), |
| 232 |
Size(ElemSize * NumElems), MDSize(MD.value_or(0)), |
| 233 |
AllocSize(std::max<size_t>(alignof(void *), Size) + MDSize), |
| 234 |
ElemDesc(Elem), IsConst(IsConst), IsMutable(IsMutable), |
| 235 |
IsTemporary(IsTemporary), IsArray(true), CtorFn(ctorArrayDesc), |
| 236 |
DtorFn(dtorArrayDesc), MoveFn(moveArrayDesc) { |
| 237 |
assert(Source && "Missing source"); |
| 238 |
} |
| 239 |
|
| 240 |
Descriptor::Descriptor(const DeclTy &D, Descriptor *Elem, bool IsTemporary, |
| 241 |
UnknownSize) |
| 242 |
: Source(D), ElemSize(Elem->getAllocSize() + sizeof(InlineDescriptor)), |
| 243 |
Size(UnknownSizeMark), MDSize(0), AllocSize(alignof(void *)), |
| 244 |
ElemDesc(Elem), IsConst(true), IsMutable(false), IsTemporary(IsTemporary), |
| 245 |
IsArray(true), CtorFn(ctorArrayDesc), DtorFn(dtorArrayDesc), |
| 246 |
MoveFn(moveArrayDesc) { |
| 247 |
assert(Source && "Missing source"); |
| 248 |
} |
| 249 |
|
| 250 |
Descriptor::Descriptor(const DeclTy &D, Record *R, MetadataSize MD, |
| 251 |
bool IsConst, bool IsTemporary, bool IsMutable) |
| 252 |
: Source(D), ElemSize(std::max<size_t>(alignof(void *), R->getFullSize())), |
| 253 |
Size(ElemSize), MDSize(MD.value_or(0)), AllocSize(Size + MDSize), |
| 254 |
ElemRecord(R), IsConst(IsConst), IsMutable(IsMutable), |
| 255 |
IsTemporary(IsTemporary), CtorFn(ctorRecord), DtorFn(dtorRecord), |
| 256 |
MoveFn(moveRecord) { |
| 257 |
assert(Source && "Missing source"); |
| 258 |
} |
| 259 |
|
| 260 |
QualType Descriptor::getType() const { |
| 261 |
if (auto *E = asExpr()) |
| 262 |
return E->getType(); |
| 263 |
if (auto *D = asValueDecl()) |
| 264 |
return D->getType(); |
| 265 |
llvm_unreachable("Invalid descriptor type"); |
| 266 |
} |
| 267 |
|
| 268 |
SourceLocation Descriptor::getLocation() const { |
| 269 |
if (auto *D = Source.dyn_cast<const Decl *>()) |
| 270 |
return D->getLocation(); |
| 271 |
if (auto *E = Source.dyn_cast<const Expr *>()) |
| 272 |
return E->getExprLoc(); |
| 273 |
llvm_unreachable("Invalid descriptor type"); |
| 274 |
} |
| 275 |
|
| 276 |
InitMap::InitMap(unsigned N) : UninitFields(N) { |
| 277 |
std::fill_n(data(), (N + PER_FIELD - 1) / PER_FIELD, 0); |
| 278 |
} |
| 279 |
|
| 280 |
InitMap::T *InitMap::data() { |
| 281 |
auto *Start = reinterpret_cast<char *>(this) + align(sizeof(InitMap)); |
| 282 |
return reinterpret_cast<T *>(Start); |
| 283 |
} |
| 284 |
|
| 285 |
const InitMap::T *InitMap::data() const { |
| 286 |
auto *Start = reinterpret_cast<const char *>(this) + align(sizeof(InitMap)); |
| 287 |
return reinterpret_cast<const T *>(Start); |
| 288 |
} |
| 289 |
|
| 290 |
bool InitMap::initialize(unsigned I) { |
| 291 |
unsigned Bucket = I / PER_FIELD; |
| 292 |
T Mask = T(1) << (I % PER_FIELD); |
| 293 |
if (!(data()[Bucket] & Mask)) { |
| 294 |
data()[Bucket] |= Mask; |
| 295 |
UninitFields -= 1; |
| 296 |
} |
| 297 |
return UninitFields == 0; |
| 298 |
} |
| 299 |
|
| 300 |
bool InitMap::isInitialized(unsigned I) const { |
| 301 |
unsigned Bucket = I / PER_FIELD; |
| 302 |
return data()[Bucket] & (T(1) << (I % PER_FIELD)); |
| 303 |
} |
| 304 |
|
| 305 |
InitMap *InitMap::allocate(unsigned N) { |
| 306 |
const size_t NumFields = ((N + PER_FIELD - 1) / PER_FIELD); |
| 307 |
const size_t Size = align(sizeof(InitMap)) + NumFields * PER_FIELD; |
| 308 |
return new (malloc(Size)) InitMap(N); |
| 309 |
} |