nils.hoelscher
/
llvm-for-llvmta
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
llvm-for-llvmta/tools/clang/lib/AST/Interp/Program.cpp

365 lines
11 KiB
C++
Raw Blame History

//===--- Program.cpp - Bytecode for the constexpr VM ------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "Program.h"
#include "ByteCodeStmtGen.h"
#include "Context.h"
#include "Function.h"
#include "Opcode.h"
#include "PrimType.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclCXX.h"
using namespace clang;
using namespace clang::interp;
unsigned Program::createGlobalString(const StringLiteral *S) {
const size_t CharWidth = S->getCharByteWidth();
const size_t BitWidth = CharWidth * Ctx.getCharBit();
PrimType CharType;
switch (CharWidth) {
case 1:
CharType = PT_Sint8;
break;
case 2:
CharType = PT_Uint16;
break;
case 4:
CharType = PT_Uint32;
break;
default:
llvm_unreachable("unsupported character width");
}
// Create a descriptor for the string.
Descriptor *Desc = allocateDescriptor(S, CharType, S->getLength() + 1,
/*isConst=*/true,
/*isTemporary=*/false,
/*isMutable=*/false);
// Allocate storage for the string.
// The byte length does not include the null terminator.
unsigned I = Globals.size();
unsigned Sz = Desc->getAllocSize();
auto *G = new (Allocator, Sz) Global(Desc, /*isStatic=*/true,
/*isExtern=*/false);
Globals.push_back(G);
// Construct the string in storage.
const Pointer Ptr(G->block());
for (unsigned I = 0, N = S->getLength(); I <= N; ++I) {
Pointer Field = Ptr.atIndex(I).narrow();
const uint32_t CodePoint = I == N ? 0 : S->getCodeUnit(I);
switch (CharType) {
case PT_Sint8: {
using T = PrimConv<PT_Sint8>::T;
Field.deref<T>() = T::from(CodePoint, BitWidth);
break;
}
case PT_Uint16: {
using T = PrimConv<PT_Uint16>::T;
Field.deref<T>() = T::from(CodePoint, BitWidth);
break;
}
case PT_Uint32: {
using T = PrimConv<PT_Uint32>::T;
Field.deref<T>() = T::from(CodePoint, BitWidth);
break;
}
default:
llvm_unreachable("unsupported character type");
}
}
return I;
}
Pointer Program::getPtrGlobal(unsigned Idx) {
assert(Idx < Globals.size());
return Pointer(Globals[Idx]->block());
}
llvm::Optional<unsigned> Program::getGlobal(const ValueDecl *VD) {
auto It = GlobalIndices.find(VD);
if (It != GlobalIndices.end())
return It->second;
// Find any previous declarations which were aleady evaluated.
llvm::Optional<unsigned> Index;
for (const Decl *P = VD; P; P = P->getPreviousDecl()) {
auto It = GlobalIndices.find(P);
if (It != GlobalIndices.end()) {
Index = It->second;
break;
}
}
// Map the decl to the existing index.
if (Index) {
GlobalIndices[VD] = *Index;
return {};
}
return Index;
}
llvm::Optional<unsigned> Program::getOrCreateGlobal(const ValueDecl *VD) {
if (auto Idx = getGlobal(VD))
return Idx;
if (auto Idx = createGlobal(VD)) {
GlobalIndices[VD] = *Idx;
return Idx;
}
return {};
}
llvm::Optional<unsigned> Program::getOrCreateDummy(const ParmVarDecl *PD) {
auto &ASTCtx = Ctx.getASTContext();
// Create a pointer to an incomplete array of the specified elements.
QualType ElemTy = PD->getType()->castAs<PointerType>()->getPointeeType();
QualType Ty = ASTCtx.getIncompleteArrayType(ElemTy, ArrayType::Normal, 0);
// Dedup blocks since they are immutable and pointers cannot be compared.
auto It = DummyParams.find(PD);
if (It != DummyParams.end())
return It->second;
if (auto Idx = createGlobal(PD, Ty, /*isStatic=*/true, /*isExtern=*/true)) {
DummyParams[PD] = *Idx;
return Idx;
}
return {};
}
llvm::Optional<unsigned> Program::createGlobal(const ValueDecl *VD) {
bool IsStatic, IsExtern;
if (auto *Var = dyn_cast<VarDecl>(VD)) {
IsStatic = !Var->hasLocalStorage();
IsExtern = !Var->getAnyInitializer();
} else {
IsStatic = false;
IsExtern = true;
}
if (auto Idx = createGlobal(VD, VD->getType(), IsStatic, IsExtern)) {
for (const Decl *P = VD; P; P = P->getPreviousDecl())
GlobalIndices[P] = *Idx;
return *Idx;
}
return {};
}
llvm::Optional<unsigned> Program::createGlobal(const Expr *E) {
return createGlobal(E, E->getType(), /*isStatic=*/true, /*isExtern=*/false);
}
llvm::Optional<unsigned> Program::createGlobal(const DeclTy &D, QualType Ty,
bool IsStatic, bool IsExtern) {
// Create a descriptor for the global.
Descriptor *Desc;
const bool IsConst = Ty.isConstQualified();
const bool IsTemporary = D.dyn_cast<const Expr *>();
if (auto T = Ctx.classify(Ty)) {
Desc = createDescriptor(D, *T, IsConst, IsTemporary);
} else {
Desc = createDescriptor(D, Ty.getTypePtr(), IsConst, IsTemporary);
}
if (!Desc)
return {};
// Allocate a block for storage.
unsigned I = Globals.size();
auto *G = new (Allocator, Desc->getAllocSize())
Global(getCurrentDecl(), Desc, IsStatic, IsExtern);
G->block()->invokeCtor();
Globals.push_back(G);
return I;
}
Function *Program::getFunction(const FunctionDecl *F) {
F = F->getDefinition();
auto It = Funcs.find(F);
return It == Funcs.end() ? nullptr : It->second.get();
}
llvm::Expected<Function *> Program::getOrCreateFunction(const FunctionDecl *F) {
if (Function *Func = getFunction(F)) {
return Func;
}
// Try to compile the function if it wasn't compiled yet.
if (const FunctionDecl *FD = F->getDefinition())
return ByteCodeStmtGen<ByteCodeEmitter>(Ctx, *this).compileFunc(FD);
// A relocation which traps if not resolved.
return nullptr;
}
Record *Program::getOrCreateRecord(const RecordDecl *RD) {
// Use the actual definition as a key.
RD = RD->getDefinition();
if (!RD)
return nullptr;
// Deduplicate records.
auto It = Records.find(RD);
if (It != Records.end()) {
return It->second;
}
// Number of bytes required by fields and base classes.
unsigned Size = 0;
// Number of bytes required by virtual base.
unsigned VirtSize = 0;
// Helper to get a base descriptor.
auto GetBaseDesc = [this](const RecordDecl *BD, Record *BR) -> Descriptor * {
if (!BR)
return nullptr;
return allocateDescriptor(BD, BR, /*isConst=*/false,
/*isTemporary=*/false,
/*isMutable=*/false);
};
// Reserve space for base classes.
Record::BaseList Bases;
Record::VirtualBaseList VirtBases;
if (auto *CD = dyn_cast<CXXRecordDecl>(RD)) {
for (const CXXBaseSpecifier &Spec : CD->bases()) {
if (Spec.isVirtual())
continue;
const RecordDecl *BD = Spec.getType()->castAs<RecordType>()->getDecl();
Record *BR = getOrCreateRecord(BD);
if (Descriptor *Desc = GetBaseDesc(BD, BR)) {
Size += align(sizeof(InlineDescriptor));
Bases.push_back({BD, Size, Desc, BR});
Size += align(BR->getSize());
continue;
}
return nullptr;
}
for (const CXXBaseSpecifier &Spec : CD->vbases()) {
const RecordDecl *BD = Spec.getType()->castAs<RecordType>()->getDecl();
Record *BR = getOrCreateRecord(BD);
if (Descriptor *Desc = GetBaseDesc(BD, BR)) {
VirtSize += align(sizeof(InlineDescriptor));
VirtBases.push_back({BD, VirtSize, Desc, BR});
VirtSize += align(BR->getSize());
continue;
}
return nullptr;
}
}
// Reserve space for fields.
Record::FieldList Fields;
for (const FieldDecl *FD : RD->fields()) {
// Reserve space for the field's descriptor and the offset.
Size += align(sizeof(InlineDescriptor));
// Classify the field and add its metadata.
QualType FT = FD->getType();
const bool IsConst = FT.isConstQualified();
const bool IsMutable = FD->isMutable();
Descriptor *Desc;
if (llvm::Optional<PrimType> T = Ctx.classify(FT)) {
Desc = createDescriptor(FD, *T, IsConst, /*isTemporary=*/false,
IsMutable);
} else {
Desc = createDescriptor(FD, FT.getTypePtr(), IsConst,
/*isTemporary=*/false, IsMutable);
}
if (!Desc)
return nullptr;
Fields.push_back({FD, Size, Desc});
Size += align(Desc->getAllocSize());
}
Record *R = new (Allocator) Record(RD, std::move(Bases), std::move(Fields),
std::move(VirtBases), VirtSize, Size);
Records.insert({RD, R});
return R;
}
Descriptor *Program::createDescriptor(const DeclTy &D, const Type *Ty,
bool IsConst, bool IsTemporary,
bool IsMutable) {
// Classes and structures.
if (auto *RT = Ty->getAs<RecordType>()) {
if (auto *Record = getOrCreateRecord(RT->getDecl()))
return allocateDescriptor(D, Record, IsConst, IsTemporary, IsMutable);
}
// Arrays.
if (auto ArrayType = Ty->getAsArrayTypeUnsafe()) {
QualType ElemTy = ArrayType->getElementType();
// Array of well-known bounds.
if (auto CAT = dyn_cast<ConstantArrayType>(ArrayType)) {
size_t NumElems = CAT->getSize().getZExtValue();
if (llvm::Optional<PrimType> T = Ctx.classify(ElemTy)) {
// Arrays of primitives.
unsigned ElemSize = primSize(*T);
if (std::numeric_limits<unsigned>::max() / ElemSize <= NumElems) {
return {};
}
return allocateDescriptor(D, *T, NumElems, IsConst, IsTemporary,
IsMutable);
} else {
// Arrays of composites. In this case, the array is a list of pointers,
// followed by the actual elements.
Descriptor *Desc =
createDescriptor(D, ElemTy.getTypePtr(), IsConst, IsTemporary);
if (!Desc)
return nullptr;
InterpSize ElemSize = Desc->getAllocSize() + sizeof(InlineDescriptor);
if (std::numeric_limits<unsigned>::max() / ElemSize <= NumElems)
return {};
return allocateDescriptor(D, Desc, NumElems, IsConst, IsTemporary,
IsMutable);
}
}
// Array of unknown bounds - cannot be accessed and pointer arithmetic
// is forbidden on pointers to such objects.
if (isa<IncompleteArrayType>(ArrayType)) {
if (llvm::Optional<PrimType> T = Ctx.classify(ElemTy)) {
return allocateDescriptor(D, *T, IsTemporary,
Descriptor::UnknownSize{});
} else {
Descriptor *Desc =
createDescriptor(D, ElemTy.getTypePtr(), IsConst, IsTemporary);
if (!Desc)
return nullptr;
return allocateDescriptor(D, Desc, IsTemporary,
Descriptor::UnknownSize{});
}
}
}
// Atomic types.
if (auto *AT = Ty->getAs<AtomicType>()) {
const Type *InnerTy = AT->getValueType().getTypePtr();
return createDescriptor(D, InnerTy, IsConst, IsTemporary, IsMutable);
}
// Complex types - represented as arrays of elements.
if (auto *CT = Ty->getAs<ComplexType>()) {
PrimType ElemTy = *Ctx.classify(CT->getElementType());
return allocateDescriptor(D, ElemTy, 2, IsConst, IsTemporary, IsMutable);
}
return nullptr;
}
Reference in New Issue View Git Blame Copy Permalink