#include "CodeGenTypes.h"
#include "CGCall.h"
#include "CGCXXABI.h"
#include "CGRecordLayout.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/Expr.h"
#include "clang/AST/RecordLayout.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Module.h"
#include "llvm/Target/TargetData.h"
using namespace clang;
using namespace CodeGen;
CodeGenTypes::CodeGenTypes(ASTContext &Ctx, llvm::Module& M,
const llvm::TargetData &TD, const ABIInfo &Info,
CGCXXABI &CXXABI)
: Context(Ctx), Target(Ctx.Target), TheModule(M), TheTargetData(TD),
TheABIInfo(Info), TheCXXABI(CXXABI) {
}
CodeGenTypes::~CodeGenTypes() {
for (llvm::DenseMap<const Type *, CGRecordLayout *>::iterator
I = CGRecordLayouts.begin(), E = CGRecordLayouts.end();
I != E; ++I)
delete I->second;
for (llvm::FoldingSet<CGFunctionInfo>::iterator
I = FunctionInfos.begin(), E = FunctionInfos.end(); I != E; )
delete &*I++;
}
void CodeGenTypes::HandleLateResolvedPointers() {
assert(!PointersToResolve.empty() && "No pointers to resolve!");
while (!PointersToResolve.empty()) {
std::pair<QualType, llvm::OpaqueType*> P = PointersToResolve.pop_back_val();
const llvm::Type *NT = ConvertTypeForMemRecursive(P.first);
P.second->refineAbstractTypeTo(NT);
}
}
void CodeGenTypes::addRecordTypeName(const RecordDecl *RD, const llvm::Type *Ty,
llvm::StringRef suffix) {
llvm::SmallString<256> TypeName;
llvm::raw_svector_ostream OS(TypeName);
OS << RD->getKindName() << '.';
if (RD->getIdentifier()) {
if (RD->getDeclContext())
OS << RD->getQualifiedNameAsString();
else
RD->printName(OS);
} else if (const TypedefNameDecl *TDD = RD->getTypedefNameForAnonDecl()) {
if (TDD->getDeclContext())
OS << TDD->getQualifiedNameAsString();
else
TDD->printName(OS);
} else
OS << "anon";
if (!suffix.empty())
OS << suffix;
TheModule.addTypeName(OS.str(), Ty);
}
const llvm::Type *CodeGenTypes::ConvertType(QualType T, bool IsRecursive) {
const llvm::Type *Result = ConvertTypeRecursive(T);
if (!IsRecursive && !PointersToResolve.empty()) {
llvm::PATypeHolder ResultHandle = Result;
HandleLateResolvedPointers();
Result = ResultHandle;
}
return Result;
}
const llvm::Type *CodeGenTypes::ConvertTypeRecursive(QualType T) {
T = Context.getCanonicalType(T);
llvm::DenseMap<const Type *, llvm::PATypeHolder>::iterator
I = TypeCache.find(T.getTypePtr());
if (I != TypeCache.end())
return I->second.get();
const llvm::Type *ResultType = ConvertNewType(T);
TypeCache.insert(std::make_pair(T.getTypePtr(),
llvm::PATypeHolder(ResultType)));
return ResultType;
}
const llvm::Type *CodeGenTypes::ConvertTypeForMem(QualType T, bool IsRecursive){
const llvm::Type *R = ConvertType(T, IsRecursive);
if (!R->isIntegerTy(1))
return R;
return llvm::IntegerType::get(getLLVMContext(),
(unsigned)Context.getTypeSize(T));
}
const TagType *CodeGenTypes::VerifyFuncTypeComplete(const Type* T) {
const FunctionType *FT = cast<FunctionType>(T);
if (const TagType* TT = FT->getResultType()->getAs<TagType>())
if (!TT->getDecl()->isDefinition())
return TT;
if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(T))
for (unsigned i = 0; i < FPT->getNumArgs(); i++)
if (const TagType* TT = FPT->getArgType(i)->getAs<TagType>())
if (!TT->getDecl()->isDefinition())
return TT;
return 0;
}
void CodeGenTypes::UpdateCompletedType(const TagDecl *TD) {
const Type *Key = Context.getTagDeclType(TD).getTypePtr();
llvm::DenseMap<const Type*, llvm::PATypeHolder>::iterator TDTI =
TagDeclTypes.find(Key);
if (TDTI == TagDeclTypes.end()) return;
llvm::PATypeHolder OpaqueHolder = TDTI->second;
assert(isa<llvm::OpaqueType>(OpaqueHolder.get()) &&
"Updating compilation of an already non-opaque type?");
TagDeclTypes.erase(TDTI);
const llvm::Type *NT = ConvertTagDeclType(TD);
cast<llvm::OpaqueType>(OpaqueHolder.get())->refineAbstractTypeTo(NT);
llvm::DenseMap<const Type*, llvm::PATypeHolder>::iterator i;
for (i = FunctionTypes.begin(); i != FunctionTypes.end(); ++i) {
if (const TagType* TT = VerifyFuncTypeComplete(i->first)) {
ConvertTagDeclType(TT->getDecl());
} else {
llvm::PATypeHolder OpaqueHolder = i->second;
const llvm::Type *NFT = ConvertNewType(QualType(i->first, 0));
cast<llvm::OpaqueType>(OpaqueHolder.get())->refineAbstractTypeTo(NFT);
FunctionTypes.erase(i);
}
}
}
static const llvm::Type* getTypeForFormat(llvm::LLVMContext &VMContext,
const llvm::fltSemantics &format) {
if (&format == &llvm::APFloat::IEEEsingle)
return llvm::Type::getFloatTy(VMContext);
if (&format == &llvm::APFloat::IEEEdouble)
return llvm::Type::getDoubleTy(VMContext);
if (&format == &llvm::APFloat::IEEEquad)
return llvm::Type::getFP128Ty(VMContext);
if (&format == &llvm::APFloat::PPCDoubleDouble)
return llvm::Type::getPPC_FP128Ty(VMContext);
if (&format == &llvm::APFloat::x87DoubleExtended)
return llvm::Type::getX86_FP80Ty(VMContext);
assert(0 && "Unknown float format!");
return 0;
}
const llvm::Type *CodeGenTypes::ConvertNewType(QualType T) {
const clang::Type &Ty = *Context.getCanonicalType(T).getTypePtr();
switch (Ty.getTypeClass()) {
#define TYPE(Class, Base)
#define ABSTRACT_TYPE(Class, Base)
#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
#define DEPENDENT_TYPE(Class, Base) case Type::Class:
#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
#include "clang/AST/TypeNodes.def"
llvm_unreachable("Non-canonical or dependent types aren't possible.");
break;
case Type::Builtin: {
switch (cast<BuiltinType>(Ty).getKind()) {
case BuiltinType::Void:
case BuiltinType::ObjCId:
case BuiltinType::ObjCClass:
case BuiltinType::ObjCSel:
return llvm::Type::getInt8Ty(getLLVMContext());
case BuiltinType::Bool:
return llvm::Type::getInt1Ty(getLLVMContext());
case BuiltinType::Char_S:
case BuiltinType::Char_U:
case BuiltinType::SChar:
case BuiltinType::UChar:
case BuiltinType::Short:
case BuiltinType::UShort:
case BuiltinType::Int:
case BuiltinType::UInt:
case BuiltinType::Long:
case BuiltinType::ULong:
case BuiltinType::LongLong:
case BuiltinType::ULongLong:
case BuiltinType::WChar_S:
case BuiltinType::WChar_U:
case BuiltinType::Char16:
case BuiltinType::Char32:
return llvm::IntegerType::get(getLLVMContext(),
static_cast<unsigned>(Context.getTypeSize(T)));
case BuiltinType::Float:
case BuiltinType::Double:
case BuiltinType::LongDouble:
return getTypeForFormat(getLLVMContext(),
Context.getFloatTypeSemantics(T));
case BuiltinType::NullPtr: {
const llvm::Type *Ty = llvm::Type::getInt8Ty(getLLVMContext());
return llvm::PointerType::getUnqual(Ty);
}
case BuiltinType::UInt128:
case BuiltinType::Int128:
return llvm::IntegerType::get(getLLVMContext(), 128);
case BuiltinType::Overload:
case BuiltinType::Dependent:
case BuiltinType::BoundMember:
case BuiltinType::UnknownAny:
llvm_unreachable("Unexpected placeholder builtin type!");
break;
}
llvm_unreachable("Unknown builtin type!");
break;
}
case Type::Complex: {
const llvm::Type *EltTy =
ConvertTypeRecursive(cast<ComplexType>(Ty).getElementType());
return llvm::StructType::get(TheModule.getContext(), EltTy, EltTy, NULL);
}
case Type::LValueReference:
case Type::RValueReference: {
const ReferenceType &RTy = cast<ReferenceType>(Ty);
QualType ETy = RTy.getPointeeType();
llvm::OpaqueType *PointeeType = llvm::OpaqueType::get(getLLVMContext());
PointersToResolve.push_back(std::make_pair(ETy, PointeeType));
unsigned AS = Context.getTargetAddressSpace(ETy);
return llvm::PointerType::get(PointeeType, AS);
}
case Type::Pointer: {
const PointerType &PTy = cast<PointerType>(Ty);
QualType ETy = PTy.getPointeeType();
llvm::OpaqueType *PointeeType = llvm::OpaqueType::get(getLLVMContext());
PointersToResolve.push_back(std::make_pair(ETy, PointeeType));
unsigned AS = Context.getTargetAddressSpace(ETy);
return llvm::PointerType::get(PointeeType, AS);
}
case Type::VariableArray: {
const VariableArrayType &A = cast<VariableArrayType>(Ty);
assert(A.getIndexTypeCVRQualifiers() == 0 &&
"FIXME: We only handle trivial array types so far!");
return ConvertTypeForMemRecursive(A.getElementType());
}
case Type::IncompleteArray: {
const IncompleteArrayType &A = cast<IncompleteArrayType>(Ty);
assert(A.getIndexTypeCVRQualifiers() == 0 &&
"FIXME: We only handle trivial array types so far!");
return llvm::ArrayType::get(ConvertTypeForMemRecursive(A.getElementType()),
0);
}
case Type::ConstantArray: {
const ConstantArrayType &A = cast<ConstantArrayType>(Ty);
const llvm::Type *EltTy = ConvertTypeForMemRecursive(A.getElementType());
return llvm::ArrayType::get(EltTy, A.getSize().getZExtValue());
}
case Type::ExtVector:
case Type::Vector: {
const VectorType &VT = cast<VectorType>(Ty);
return llvm::VectorType::get(ConvertTypeRecursive(VT.getElementType()),
VT.getNumElements());
}
case Type::FunctionNoProto:
case Type::FunctionProto: {
if (const TagType *TT = VerifyFuncTypeComplete(&Ty)) {
ConvertTagDeclType(TT->getDecl());
llvm::Type *ResultType = llvm::OpaqueType::get(getLLVMContext());
FunctionTypes.insert(std::make_pair(&Ty, ResultType));
return ResultType;
}
const CGFunctionInfo *FI;
bool isVariadic;
if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(&Ty)) {
FI = &getFunctionInfo(
CanQual<FunctionProtoType>::CreateUnsafe(QualType(FPT, 0)),
true );
isVariadic = FPT->isVariadic();
} else {
const FunctionNoProtoType *FNPT = cast<FunctionNoProtoType>(&Ty);
FI = &getFunctionInfo(
CanQual<FunctionNoProtoType>::CreateUnsafe(QualType(FNPT, 0)),
true );
isVariadic = true;
}
return GetFunctionType(*FI, isVariadic, true);
}
case Type::ObjCObject:
return ConvertTypeRecursive(cast<ObjCObjectType>(Ty).getBaseType());
case Type::ObjCInterface: {
const llvm::Type *&T = InterfaceTypes[cast<ObjCInterfaceType>(&Ty)];
if (!T)
T = llvm::OpaqueType::get(getLLVMContext());
return T;
}
case Type::ObjCObjectPointer: {
const llvm::Type *T =
ConvertTypeRecursive(cast<ObjCObjectPointerType>(Ty).getPointeeType());
return llvm::PointerType::getUnqual(T);
}
case Type::Record:
case Type::Enum: {
const TagDecl *TD = cast<TagType>(Ty).getDecl();
const llvm::Type *Res = ConvertTagDeclType(TD);
if (const RecordDecl *RD = dyn_cast<RecordDecl>(TD))
addRecordTypeName(RD, Res, llvm::StringRef());
return Res;
}
case Type::BlockPointer: {
const QualType FTy = cast<BlockPointerType>(Ty).getPointeeType();
llvm::OpaqueType *PointeeType = llvm::OpaqueType::get(getLLVMContext());
PointersToResolve.push_back(std::make_pair(FTy, PointeeType));
unsigned AS = Context.getTargetAddressSpace(FTy);
return llvm::PointerType::get(PointeeType, AS);
}
case Type::MemberPointer: {
return getCXXABI().ConvertMemberPointerType(cast<MemberPointerType>(&Ty));
}
}
return llvm::OpaqueType::get(getLLVMContext());
}
const llvm::Type *CodeGenTypes::ConvertTagDeclType(const TagDecl *TD) {
const Type *Key =
Context.getTagDeclType(TD).getTypePtr();
llvm::DenseMap<const Type*, llvm::PATypeHolder>::iterator TDTI =
TagDeclTypes.find(Key);
if (TDTI != TagDeclTypes.end())
return TDTI->second;
const EnumDecl *ED = dyn_cast<EnumDecl>(TD);
if (!TD->isDefinition() && !(ED && ED->isFixed())) {
llvm::Type *ResultType = llvm::OpaqueType::get(getLLVMContext());
TagDeclTypes.insert(std::make_pair(Key, ResultType));
return ResultType;
}
if (ED) return ConvertTypeRecursive(ED->getIntegerType());
llvm::PATypeHolder ResultHolder = llvm::OpaqueType::get(getLLVMContext());
TagDeclTypes.insert(std::make_pair(Key, ResultHolder));
const RecordDecl *RD = cast<const RecordDecl>(TD);
if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TD)) {
for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
e = RD->bases_end(); i != e; ++i) {
if (!i->isVirtual()) {
const CXXRecordDecl *Base =
cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
ConvertTagDeclType(Base);
}
}
}
CGRecordLayout *Layout = ComputeRecordLayout(RD);
CGRecordLayouts[Key] = Layout;
const llvm::Type *ResultType = Layout->getLLVMType();
cast<llvm::OpaqueType>(ResultHolder.get())
->refineAbstractTypeTo(ResultType);
return ResultHolder.get();
}
const CGRecordLayout &
CodeGenTypes::getCGRecordLayout(const RecordDecl *RD) {
const Type *Key = Context.getTagDeclType(RD).getTypePtr();
const CGRecordLayout *Layout = CGRecordLayouts.lookup(Key);
if (!Layout) {
ConvertTagDeclType(RD);
Layout = CGRecordLayouts.lookup(Key);
}
assert(Layout && "Unable to find record layout information for type");
return *Layout;
}
void CodeGenTypes::addBaseSubobjectTypeName(const CXXRecordDecl *RD,
const CGRecordLayout &layout) {
llvm::StringRef suffix;
if (layout.getBaseSubobjectLLVMType() != layout.getLLVMType())
suffix = ".base";
addRecordTypeName(RD, layout.getBaseSubobjectLLVMType(), suffix);
}
bool CodeGenTypes::isZeroInitializable(QualType T) {
if (!Context.getLangOptions().CPlusPlus)
return true;
T = Context.getBaseElementType(T);
if (const RecordType *RT = T->getAs<RecordType>()) {
const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
return isZeroInitializable(RD);
}
if (const MemberPointerType *MPT = T->getAs<MemberPointerType>())
return getCXXABI().isZeroInitializable(MPT);
return true;
}
bool CodeGenTypes::isZeroInitializable(const CXXRecordDecl *RD) {
return getCGRecordLayout(RD).isZeroInitializable();
}