forked from OSchip/llvm-project
432 lines
15 KiB
C++
432 lines
15 KiB
C++
//===--- CGCXXRTTI.cpp - Emit LLVM Code for C++ RTTI descriptors ----------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This contains code dealing with C++ code generation of RTTI descriptors.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/AST/Type.h"
|
|
#include "clang/AST/RecordLayout.h"
|
|
#include "CodeGenModule.h"
|
|
using namespace clang;
|
|
using namespace CodeGen;
|
|
|
|
namespace {
|
|
class RTTIBuilder {
|
|
CodeGenModule &CGM; // Per-module state.
|
|
llvm::LLVMContext &VMContext;
|
|
const llvm::Type *Int8PtrTy;
|
|
llvm::SmallSet<const CXXRecordDecl *, 16> SeenVBase;
|
|
llvm::SmallSet<const CXXRecordDecl *, 32> SeenBase;
|
|
public:
|
|
RTTIBuilder(CodeGenModule &cgm)
|
|
: CGM(cgm), VMContext(cgm.getModule().getContext()),
|
|
Int8PtrTy(llvm::Type::getInt8PtrTy(VMContext)) { }
|
|
|
|
/// BuildVtableRef - Build a reference to a vtable.
|
|
llvm::Constant *BuildVtableRef(const char *Name) {
|
|
// Build a descriptor for Name
|
|
llvm::Constant *GV = CGM.getModule().getGlobalVariable(Name);
|
|
if (GV)
|
|
GV = llvm::ConstantExpr::getBitCast(GV,
|
|
llvm::PointerType::get(Int8PtrTy, 0));
|
|
else {
|
|
llvm::GlobalVariable::LinkageTypes linktype;
|
|
linktype = llvm::GlobalValue::ExternalLinkage;
|
|
GV = new llvm::GlobalVariable(CGM.getModule(), Int8PtrTy,
|
|
true, linktype, 0, Name);
|
|
}
|
|
llvm::Constant *C;
|
|
C = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), 2);
|
|
C = llvm::ConstantExpr::getInBoundsGetElementPtr(GV, &C, 1);
|
|
return llvm::ConstantExpr::getBitCast(C, Int8PtrTy);
|
|
}
|
|
|
|
llvm::Constant *BuildName(QualType Ty, bool Hidden, bool Extern) {
|
|
llvm::SmallString<256> OutName;
|
|
CGM.getMangleContext().mangleCXXRTTIName(Ty, OutName);
|
|
llvm::StringRef Name = OutName.str();
|
|
|
|
llvm::GlobalVariable::LinkageTypes linktype;
|
|
linktype = llvm::GlobalValue::LinkOnceODRLinkage;
|
|
if (!Extern)
|
|
linktype = llvm::GlobalValue::InternalLinkage;
|
|
|
|
llvm::GlobalVariable *GV;
|
|
GV = CGM.getModule().getGlobalVariable(Name);
|
|
if (GV && !GV->isDeclaration())
|
|
return llvm::ConstantExpr::getBitCast(GV, Int8PtrTy);
|
|
|
|
llvm::Constant *C;
|
|
C = llvm::ConstantArray::get(VMContext, Name.substr(4));
|
|
|
|
llvm::GlobalVariable *OGV = GV;
|
|
GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(), true, linktype,
|
|
C, Name);
|
|
if (OGV) {
|
|
GV->takeName(OGV);
|
|
llvm::Constant *NewPtr = llvm::ConstantExpr::getBitCast(GV,
|
|
OGV->getType());
|
|
OGV->replaceAllUsesWith(NewPtr);
|
|
OGV->eraseFromParent();
|
|
}
|
|
if (Hidden)
|
|
GV->setVisibility(llvm::GlobalVariable::HiddenVisibility);
|
|
return llvm::ConstantExpr::getBitCast(GV, Int8PtrTy);
|
|
};
|
|
|
|
/// - BuildFlags - Build a psABI __flags value for __vmi_class_type_info.
|
|
llvm::Constant *BuildFlags(int f) {
|
|
return llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), f);
|
|
}
|
|
|
|
/// BuildBaseCount - Build a psABI __base_count value for
|
|
/// __vmi_class_type_info.
|
|
llvm::Constant *BuildBaseCount(unsigned c) {
|
|
return llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), c);
|
|
}
|
|
|
|
llvm::Constant *BuildTypeRef(QualType Ty) {
|
|
llvm::Constant *C;
|
|
|
|
if (!CGM.getContext().getLangOptions().RTTI)
|
|
return llvm::Constant::getNullValue(Int8PtrTy);
|
|
|
|
llvm::SmallString<256> OutName;
|
|
CGM.getMangleContext().mangleCXXRTTI(Ty, OutName);
|
|
llvm::StringRef Name = OutName.str();
|
|
|
|
C = CGM.getModule().getGlobalVariable(Name);
|
|
if (C)
|
|
return llvm::ConstantExpr::getBitCast(C, Int8PtrTy);
|
|
|
|
llvm::GlobalVariable::LinkageTypes linktype;
|
|
linktype = llvm::GlobalValue::ExternalLinkage;;
|
|
|
|
C = new llvm::GlobalVariable(CGM.getModule(), Int8PtrTy, true, linktype,
|
|
0, Name);
|
|
return llvm::ConstantExpr::getBitCast(C, Int8PtrTy);
|
|
}
|
|
|
|
llvm::Constant *Buildclass_type_infoRef(const CXXRecordDecl *RD) {
|
|
return BuildTypeRef(CGM.getContext().getTagDeclType(RD));
|
|
}
|
|
|
|
/// CalculateFlags - Calculate the flags for the __vmi_class_type_info
|
|
/// datastructure. 1 for non-diamond repeated inheritance, 2 for a dimond
|
|
/// shaped class.
|
|
int CalculateFlags(const CXXRecordDecl*RD) {
|
|
int flags = 0;
|
|
if (SeenBase.count(RD))
|
|
flags |= 1;
|
|
else
|
|
SeenBase.insert(RD);
|
|
for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
|
|
e = RD->bases_end(); i != e; ++i) {
|
|
const CXXRecordDecl *Base =
|
|
cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
|
|
if (i->isVirtual()) {
|
|
if (SeenVBase.count(Base))
|
|
flags |= 2;
|
|
else
|
|
SeenVBase.insert(Base);
|
|
}
|
|
flags |= CalculateFlags(Base);
|
|
}
|
|
return flags;
|
|
}
|
|
|
|
bool SimpleInheritance(const CXXRecordDecl *RD) {
|
|
if (RD->getNumBases() != 1)
|
|
return false;
|
|
CXXRecordDecl::base_class_const_iterator i = RD->bases_begin();
|
|
if (i->isVirtual())
|
|
return false;
|
|
if (i->getAccessSpecifier() != AS_public)
|
|
return false;
|
|
|
|
const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
|
|
const CXXRecordDecl *Base =
|
|
cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
|
|
if (Layout.getBaseClassOffset(Base) != 0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
llvm::Constant *finish(std::vector<llvm::Constant *> &info,
|
|
llvm::GlobalVariable *GV,
|
|
llvm::StringRef Name, bool Hidden, bool Extern) {
|
|
llvm::GlobalVariable::LinkageTypes linktype;
|
|
linktype = llvm::GlobalValue::LinkOnceODRLinkage;
|
|
if (!Extern)
|
|
linktype = llvm::GlobalValue::InternalLinkage;
|
|
|
|
llvm::Constant *C;
|
|
C = llvm::ConstantStruct::get(VMContext, &info[0], info.size(), false);
|
|
|
|
llvm::GlobalVariable *OGV = GV;
|
|
GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(), true, linktype,
|
|
C, Name);
|
|
if (OGV) {
|
|
GV->takeName(OGV);
|
|
llvm::Constant *NewPtr = llvm::ConstantExpr::getBitCast(GV,
|
|
OGV->getType());
|
|
OGV->replaceAllUsesWith(NewPtr);
|
|
OGV->eraseFromParent();
|
|
}
|
|
if (Hidden)
|
|
GV->setVisibility(llvm::GlobalVariable::HiddenVisibility);
|
|
return llvm::ConstantExpr::getBitCast(GV, Int8PtrTy);
|
|
}
|
|
|
|
|
|
llvm::Constant *Buildclass_type_info(const CXXRecordDecl *RD) {
|
|
if (!CGM.getContext().getLangOptions().RTTI)
|
|
return llvm::Constant::getNullValue(Int8PtrTy);
|
|
|
|
llvm::Constant *C;
|
|
|
|
llvm::SmallString<256> OutName;
|
|
CGM.getMangleContext().mangleCXXRTTI(CGM.getContext().getTagDeclType(RD),
|
|
OutName);
|
|
llvm::StringRef Name = OutName.str();
|
|
|
|
llvm::GlobalVariable *GV;
|
|
GV = CGM.getModule().getGlobalVariable(Name);
|
|
if (GV && !GV->isDeclaration())
|
|
return llvm::ConstantExpr::getBitCast(GV, Int8PtrTy);
|
|
|
|
std::vector<llvm::Constant *> info;
|
|
|
|
bool Hidden = CGM.getDeclVisibilityMode(RD) == LangOptions::Hidden;
|
|
bool Extern = !RD->isInAnonymousNamespace();
|
|
|
|
bool simple = false;
|
|
if (RD->getNumBases() == 0)
|
|
C = BuildVtableRef("_ZTVN10__cxxabiv117__class_type_infoE");
|
|
else if (SimpleInheritance(RD)) {
|
|
simple = true;
|
|
C = BuildVtableRef("_ZTVN10__cxxabiv120__si_class_type_infoE");
|
|
} else
|
|
C = BuildVtableRef("_ZTVN10__cxxabiv121__vmi_class_type_infoE");
|
|
info.push_back(C);
|
|
info.push_back(BuildName(CGM.getContext().getTagDeclType(RD), Hidden,
|
|
Extern));
|
|
|
|
// If we have no bases, there are no more fields.
|
|
if (RD->getNumBases()) {
|
|
if (!simple) {
|
|
info.push_back(BuildFlags(CalculateFlags(RD)));
|
|
info.push_back(BuildBaseCount(RD->getNumBases()));
|
|
}
|
|
|
|
const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
|
|
for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
|
|
e = RD->bases_end(); i != e; ++i) {
|
|
const CXXRecordDecl *Base =
|
|
cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
|
|
if (Base->isPolymorphic())
|
|
info.push_back(CGM.GenerateRTTIRef(Base));
|
|
else
|
|
info.push_back(CGM.GenerateRTTI(Base));
|
|
if (simple)
|
|
break;
|
|
int64_t offset;
|
|
if (!i->isVirtual())
|
|
offset = Layout.getBaseClassOffset(Base)/8;
|
|
else
|
|
offset = CGM.getVtableInfo().getVirtualBaseOffsetIndex(RD, Base);
|
|
offset <<= 8;
|
|
// Now set the flags.
|
|
offset += i->isVirtual() ? 1 : 0;;
|
|
offset += i->getAccessSpecifier() == AS_public ? 2 : 0;
|
|
const llvm::Type *LongTy =
|
|
CGM.getTypes().ConvertType(CGM.getContext().LongTy);
|
|
C = llvm::ConstantInt::get(LongTy, offset);
|
|
info.push_back(C);
|
|
}
|
|
}
|
|
|
|
return finish(info, GV, Name, Hidden, Extern);
|
|
}
|
|
|
|
/// - BuildFlags - Build a __flags value for __pbase_type_info.
|
|
llvm::Constant *BuildInt(int f) {
|
|
return llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), f);
|
|
}
|
|
|
|
bool DecideExtern(QualType Ty) {
|
|
// For this type, see if all components are never in an anonymous namespace.
|
|
if (const MemberPointerType *MPT = Ty->getAs<MemberPointerType>())
|
|
return (DecideExtern(MPT->getPointeeType())
|
|
&& DecideExtern(QualType(MPT->getClass(), 0)));
|
|
if (const PointerType *PT = Ty->getAs<PointerType>())
|
|
return DecideExtern(PT->getPointeeType());
|
|
if (const RecordType *RT = Ty->getAs<RecordType>())
|
|
if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
|
|
return !RD->isInAnonymousNamespace();
|
|
return true;
|
|
}
|
|
|
|
bool DecideHidden(QualType Ty) {
|
|
// For this type, see if all components are never hidden.
|
|
if (const MemberPointerType *MPT = Ty->getAs<MemberPointerType>())
|
|
return (DecideHidden(MPT->getPointeeType())
|
|
&& DecideHidden(QualType(MPT->getClass(), 0)));
|
|
if (const PointerType *PT = Ty->getAs<PointerType>())
|
|
return DecideHidden(PT->getPointeeType());
|
|
if (const RecordType *RT = Ty->getAs<RecordType>())
|
|
if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
|
|
return CGM.getDeclVisibilityMode(RD) == LangOptions::Hidden;
|
|
return false;
|
|
}
|
|
|
|
llvm::Constant *BuildPointerType(QualType Ty) {
|
|
llvm::Constant *C;
|
|
|
|
llvm::SmallString<256> OutName;
|
|
CGM.getMangleContext().mangleCXXRTTI(Ty, OutName);
|
|
llvm::StringRef Name = OutName.str();
|
|
|
|
llvm::GlobalVariable *GV;
|
|
GV = CGM.getModule().getGlobalVariable(Name);
|
|
if (GV && !GV->isDeclaration())
|
|
return llvm::ConstantExpr::getBitCast(GV, Int8PtrTy);
|
|
|
|
std::vector<llvm::Constant *> info;
|
|
|
|
bool Extern = DecideExtern(Ty);
|
|
bool Hidden = DecideHidden(Ty);
|
|
|
|
QualType PTy = Ty->getPointeeType();
|
|
QualType BTy;
|
|
bool PtrMem = false;
|
|
if (const MemberPointerType *MPT = dyn_cast<MemberPointerType>(Ty)) {
|
|
PtrMem = true;
|
|
BTy = QualType(MPT->getClass(), 0);
|
|
PTy = MPT->getPointeeType();
|
|
}
|
|
|
|
if (PtrMem)
|
|
C = BuildVtableRef("_ZTVN10__cxxabiv129__pointer_to_member_type_infoE");
|
|
else
|
|
C = BuildVtableRef("_ZTVN10__cxxabiv119__pointer_type_infoE");
|
|
info.push_back(C);
|
|
info.push_back(BuildName(Ty, Hidden, Extern));
|
|
Qualifiers Q = PTy.getQualifiers();
|
|
PTy = CGM.getContext().getCanonicalType(PTy).getUnqualifiedType();
|
|
int flags = 0;
|
|
flags += Q.hasConst() ? 0x1 : 0;
|
|
flags += Q.hasVolatile() ? 0x2 : 0;
|
|
flags += Q.hasRestrict() ? 0x4 : 0;
|
|
flags += Ty.getTypePtr()->isIncompleteType() ? 0x8 : 0;
|
|
if (PtrMem && BTy.getTypePtr()->isIncompleteType())
|
|
flags += 0x10;
|
|
|
|
info.push_back(BuildInt(flags));
|
|
info.push_back(BuildInt(0));
|
|
info.push_back(BuildType(PTy));
|
|
|
|
if (PtrMem)
|
|
info.push_back(BuildType(BTy));
|
|
|
|
// We always generate these as hidden, only the name isn't hidden.
|
|
return finish(info, GV, Name, true, Extern);
|
|
}
|
|
|
|
llvm::Constant *BuildSimpleType(QualType Ty, const char *vtbl) {
|
|
llvm::Constant *C;
|
|
|
|
llvm::SmallString<256> OutName;
|
|
CGM.getMangleContext().mangleCXXRTTI(Ty, OutName);
|
|
llvm::StringRef Name = OutName.str();
|
|
|
|
llvm::GlobalVariable *GV;
|
|
GV = CGM.getModule().getGlobalVariable(Name);
|
|
if (GV && !GV->isDeclaration())
|
|
return llvm::ConstantExpr::getBitCast(GV, Int8PtrTy);
|
|
|
|
std::vector<llvm::Constant *> info;
|
|
|
|
bool Extern = DecideExtern(Ty);
|
|
bool Hidden = DecideHidden(Ty);
|
|
|
|
C = BuildVtableRef(vtbl);
|
|
info.push_back(C);
|
|
info.push_back(BuildName(Ty, Hidden, Extern));
|
|
|
|
// We always generate these as hidden, only the name isn't hidden.
|
|
return finish(info, GV, Name, true, Extern);
|
|
}
|
|
|
|
llvm::Constant *BuildType(QualType Ty) {
|
|
const clang::Type &Type
|
|
= *CGM.getContext().getCanonicalType(Ty).getTypePtr();
|
|
|
|
if (const RecordType *RT = Ty.getTypePtr()->getAs<RecordType>())
|
|
if (const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()))
|
|
return Buildclass_type_info(RD);
|
|
|
|
switch (Type.getTypeClass()) {
|
|
default: {
|
|
assert(0 && "typeid expression");
|
|
return llvm::Constant::getNullValue(Int8PtrTy);
|
|
}
|
|
|
|
case Type::Builtin: {
|
|
// We expect all type_info objects for builtin types to be in the library.
|
|
return BuildTypeRef(Ty);
|
|
}
|
|
|
|
case Type::Pointer: {
|
|
QualType PTy = Ty->getPointeeType();
|
|
Qualifiers Q = PTy.getQualifiers();
|
|
Q.removeConst();
|
|
// T* and const T* for all builtin types T are expected in the library.
|
|
if (isa<BuiltinType>(PTy) && Q.empty())
|
|
return BuildTypeRef(Ty);
|
|
|
|
return BuildPointerType(Ty);
|
|
}
|
|
case Type::MemberPointer:
|
|
return BuildPointerType(Ty);
|
|
case Type::FunctionProto:
|
|
case Type::FunctionNoProto:
|
|
return BuildSimpleType(Ty, "_ZTVN10__cxxabiv120__function_type_infoE");
|
|
case Type::ConstantArray:
|
|
case Type::IncompleteArray:
|
|
case Type::VariableArray:
|
|
case Type::Vector:
|
|
case Type::ExtVector:
|
|
return BuildSimpleType(Ty, "_ZTVN10__cxxabiv117__array_type_infoE");
|
|
case Type::Enum:
|
|
return BuildSimpleType(Ty, "_ZTVN10__cxxabiv116__enum_type_infoE");
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
llvm::Constant *CodeGenModule::GenerateRTTIRef(const CXXRecordDecl *RD) {
|
|
RTTIBuilder b(*this);
|
|
|
|
return b.Buildclass_type_infoRef(RD);
|
|
}
|
|
|
|
llvm::Constant *CodeGenModule::GenerateRTTI(const CXXRecordDecl *RD) {
|
|
RTTIBuilder b(*this);
|
|
|
|
return b.Buildclass_type_info(RD);
|
|
}
|
|
|
|
llvm::Constant *CodeGenModule::GenerateRTTI(QualType Ty) {
|
|
RTTIBuilder b(*this);
|
|
|
|
return b.BuildType(Ty);
|
|
}
|