CodeGenTypes.cpp revision 6f41c17ae854c8a26126e5ea1c3cd53bd746b7ba
15f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--- CodeGenTypes.cpp - Type translation for LLVM CodeGen -------------===// 25f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 35f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// The LLVM Compiler Infrastructure 45f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 75f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 85f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 95f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump// This is the code that handles AST -> LLVM type lowering. 115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "CodeGenTypes.h" 15de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/ASTContext.h" 16c4a1dea2dc56bd1357ec91b829a0b9e68229a13eDaniel Dunbar#include "clang/AST/DeclObjC.h" 17742cd1b7bb86b52b23b335d47abbd842dac0e1bfFariborz Jahanian#include "clang/AST/DeclCXX.h" 18de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/Expr.h" 1919cc4abea06a9b49e0e16a50d335c064cd723572Anders Carlsson#include "clang/AST/RecordLayout.h" 205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "llvm/DerivedTypes.h" 214e533287e6a9adac78c9ac370612581aad9b8c5eAnders Carlsson#include "llvm/Module.h" 22d9e9ede6b1703849da739629904dad197306e527Devang Patel#include "llvm/Target/TargetData.h" 235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2445c25ba11cbf8c9a461def5b03f6ee9481e06769Daniel Dunbar#include "CGCall.h" 2545372a6fdcd2b0840704569478db456822e02baeAnders Carlsson#include "CGRecordLayoutBuilder.h" 2645c25ba11cbf8c9a461def5b03f6ee9481e06769Daniel Dunbar 275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace CodeGen; 295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 307a4718e813e5e99d478567a482217c7eef8572c5Devang PatelCodeGenTypes::CodeGenTypes(ASTContext &Ctx, llvm::Module& M, 3182d0a418c8699fc6f4a9417457ffe93d43bba1c1Anton Korobeynikov const llvm::TargetData &TD, const ABIInfo &Info) 326b1da0ea19c12346192f5ea4d70872c13bfcc82aDaniel Dunbar : Context(Ctx), Target(Ctx.Target), TheModule(M), TheTargetData(TD), 3382d0a418c8699fc6f4a9417457ffe93d43bba1c1Anton Korobeynikov TheABIInfo(Info) { 34d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner} 355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 36b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang PatelCodeGenTypes::~CodeGenTypes() { 371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (llvm::DenseMap<const Type *, CGRecordLayout *>::iterator 381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump I = CGRecordLayouts.begin(), E = CGRecordLayouts.end(); 39b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel I != E; ++I) 40b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel delete I->second; 416f41c17ae854c8a26126e5ea1c3cd53bd746b7baChris Lattner 426f41c17ae854c8a26126e5ea1c3cd53bd746b7baChris Lattner for (llvm::FoldingSet<CGFunctionInfo>::iterator 436f41c17ae854c8a26126e5ea1c3cd53bd746b7baChris Lattner I = FunctionInfos.begin(), E = FunctionInfos.end(); I != E; ) 446f41c17ae854c8a26126e5ea1c3cd53bd746b7baChris Lattner delete &*I++; 45b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel} 46b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel 475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// ConvertType - Convert the specified type to its LLVM form. 485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst llvm::Type *CodeGenTypes::ConvertType(QualType T) { 49fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner llvm::PATypeHolder Result = ConvertTypeRecursive(T); 50fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner 51fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // Any pointers that were converted defered evaluation of their pointee type, 52fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // creating an opaque type instead. This is in order to avoid problems with 53fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // circular types. Loop through all these defered pointees, if any, and 54fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // resolve them now. 55fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner while (!PointersToResolve.empty()) { 566f41c17ae854c8a26126e5ea1c3cd53bd746b7baChris Lattner std::pair<QualType, llvm::OpaqueType*> P = PointersToResolve.pop_back_val(); 576f41c17ae854c8a26126e5ea1c3cd53bd746b7baChris Lattner 58fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // We can handle bare pointers here because we know that the only pointers 59fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // to the Opaque type are P.second and from other types. Refining the 60fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // opqaue type away will invalidate P.second, but we don't mind :). 6157a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman const llvm::Type *NT = ConvertTypeForMemRecursive(P.first); 62fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner P.second->refineAbstractTypeTo(NT); 63fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner } 64fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner 65fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return Result; 66fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner} 67fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner 68fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattnerconst llvm::Type *CodeGenTypes::ConvertTypeRecursive(QualType T) { 6909dc6660487fc2f4a4bb2032e30123d3e0da7230Chris Lattner T = Context.getCanonicalType(T); 701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7130ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel // See if type is already cached. 720ffe89ab1e4890899e0e11a6f68223567a69b38aDevang Patel llvm::DenseMap<Type *, llvm::PATypeHolder>::iterator 739619662a1d42e2008b865d3459c0677e149dad1bChris Lattner I = TypeCache.find(T.getTypePtr()); 743c40085b373d8e6e4523812e06f73a0cb9d5142cDevang Patel // If type is found in map and this is not a definition for a opaque 75fae6e2994a51d8ec1e61b6eb68765247c83b1ccfChris Lattner // place holder type then use it. Otherwise, convert type T. 764581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner if (I != TypeCache.end()) 7747c87b4b160d45285b24b1b7f4e3cbaaed3dc464Devang Patel return I->second.get(); 7830ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel 7930ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel const llvm::Type *ResultType = ConvertNewType(T); 801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TypeCache.insert(std::make_pair(T.getTypePtr(), 814581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner llvm::PATypeHolder(ResultType))); 8230ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel return ResultType; 8330ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel} 8430ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel 8557a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedmanconst llvm::Type *CodeGenTypes::ConvertTypeForMemRecursive(QualType T) { 8657a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman const llvm::Type *ResultType = ConvertTypeRecursive(T); 876f41c17ae854c8a26126e5ea1c3cd53bd746b7baChris Lattner if (ResultType->isInteger(1)) 880032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::IntegerType::get(getLLVMContext(), 890032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson (unsigned)Context.getTypeSize(T)); 906f41c17ae854c8a26126e5ea1c3cd53bd746b7baChris Lattner // FIXME: Should assert that the llvm type and AST type has the same size. 9157a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman return ResultType; 9257a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman} 9357a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman 944581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// ConvertTypeForMem - Convert type T into a llvm::Type. This differs from 954581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// ConvertType in that it is used to convert to the memory representation for 964581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// a type. For example, the scalar representation for _Bool is i1, but the 974581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// memory representation is usually i8 or i32, depending on the target. 9819009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattnerconst llvm::Type *CodeGenTypes::ConvertTypeForMem(QualType T) { 9919009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner const llvm::Type *R = ConvertType(T); 1001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10119009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner // If this is a non-bool type, don't map it. 1026f41c17ae854c8a26126e5ea1c3cd53bd746b7baChris Lattner if (!R->isInteger(1)) 10319009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner return R; 1041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10519009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner // Otherwise, return an integer of the target-specified size. 1060032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::IntegerType::get(getLLVMContext(), 1070032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson (unsigned)Context.getTypeSize(T)); 1081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10919009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner} 11019009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner 111b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman// Code to verify a given function type is complete, i.e. the return type 112b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman// and all of the argument types are complete. 113b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedmanstatic const TagType *VerifyFuncTypeComplete(const Type* T) { 114b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman const FunctionType *FT = cast<FunctionType>(T); 1156217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const TagType* TT = FT->getResultType()->getAs<TagType>()) 116b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman if (!TT->getDecl()->isDefinition()) 117b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman return TT; 118b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(T)) 119b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman for (unsigned i = 0; i < FPT->getNumArgs(); i++) 1206217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const TagType* TT = FPT->getArgType(i)->getAs<TagType>()) 121b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman if (!TT->getDecl()->isDefinition()) 122b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman return TT; 123b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman return 0; 124b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman} 125b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman 126c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattner/// UpdateCompletedType - When we find the full definition for a TagDecl, 127c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattner/// replace the 'opaque' type we previously made for it if applicable. 128c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattnervoid CodeGenTypes::UpdateCompletedType(const TagDecl *TD) { 129e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump const Type *Key = Context.getTagDeclType(TD).getTypePtr(); 1301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump llvm::DenseMap<const Type*, llvm::PATypeHolder>::iterator TDTI = 131efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar TagDeclTypes.find(Key); 1326ef58e36bbbfa232fe8b50309361e841985abfc6Chris Lattner if (TDTI == TagDeclTypes.end()) return; 1331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1346ef58e36bbbfa232fe8b50309361e841985abfc6Chris Lattner // Remember the opaque LLVM type for this tagdecl. 135d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner llvm::PATypeHolder OpaqueHolder = TDTI->second; 136d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner assert(isa<llvm::OpaqueType>(OpaqueHolder.get()) && 1376ef58e36bbbfa232fe8b50309361e841985abfc6Chris Lattner "Updating compilation of an already non-opaque type?"); 1381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 139d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner // Remove it from TagDeclTypes so that it will be regenerated. 140d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner TagDeclTypes.erase(TDTI); 141d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 1428fb1dd005f4cb530bca11d622362d39727294420Chris Lattner // Generate the new type. 1438fb1dd005f4cb530bca11d622362d39727294420Chris Lattner const llvm::Type *NT = ConvertTagDeclType(TD); 144d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 1458fb1dd005f4cb530bca11d622362d39727294420Chris Lattner // Refine the old opaque type to its new definition. 1468fb1dd005f4cb530bca11d622362d39727294420Chris Lattner cast<llvm::OpaqueType>(OpaqueHolder.get())->refineAbstractTypeTo(NT); 147b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman 148b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // Since we just completed a tag type, check to see if any function types 149b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // were completed along with the tag type. 150b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // FIXME: This is very inefficient; if we track which function types depend 151b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // on which tag types, though, it should be reasonably efficient. 152b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman llvm::DenseMap<const Type*, llvm::PATypeHolder>::iterator i; 153b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman for (i = FunctionTypes.begin(); i != FunctionTypes.end(); ++i) { 154b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman if (const TagType* TT = VerifyFuncTypeComplete(i->first)) { 155b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // This function type still depends on an incomplete tag type; make sure 156b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // that tag type has an associated opaque type. 157b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman ConvertTagDeclType(TT->getDecl()); 158b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman } else { 159b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // This function no longer depends on an incomplete tag type; create the 160b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // function type, and refine the opaque type to the new function type. 161b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman llvm::PATypeHolder OpaqueHolder = i->second; 162b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman const llvm::Type *NFT = ConvertNewType(QualType(i->first, 0)); 163b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman cast<llvm::OpaqueType>(OpaqueHolder.get())->refineAbstractTypeTo(NFT); 164b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman FunctionTypes.erase(i); 165b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman } 166b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman } 167d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner} 168d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 1691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic const llvm::Type* getTypeForFormat(llvm::LLVMContext &VMContext, 1700032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson const llvm::fltSemantics &format) { 171b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::IEEEsingle) 1720032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::Type::getFloatTy(VMContext); 173b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::IEEEdouble) 1740032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::Type::getDoubleTy(VMContext); 175b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::IEEEquad) 1760032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::Type::getFP128Ty(VMContext); 177b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::PPCDoubleDouble) 1780032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::Type::getPPC_FP128Ty(VMContext); 179b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::x87DoubleExtended) 1800032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::Type::getX86_FP80Ty(VMContext); 181b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner assert(0 && "Unknown float format!"); 182f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return 0; 183f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman} 184f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman 18530ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patelconst llvm::Type *CodeGenTypes::ConvertNewType(QualType T) { 186e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCall const clang::Type &Ty = *Context.getCanonicalType(T).getTypePtr(); 1871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Ty.getTypeClass()) { 18972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define TYPE(Class, Base) 19072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define ABSTRACT_TYPE(Class, Base) 19172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 19272564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define DEPENDENT_TYPE(Class, Base) case Type::Class: 19372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#include "clang/AST/TypeNodes.def" 19472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor assert(false && "Non-canonical or dependent types aren't possible."); 19572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor break; 19672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 1975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Builtin: { 1985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (cast<BuiltinType>(Ty).getKind()) { 1995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Void: 200de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff case BuiltinType::ObjCId: 201de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff case BuiltinType::ObjCClass: 20213dcd00615de5c4279d97bdf63cd5f0a14fd9dccFariborz Jahanian case BuiltinType::ObjCSel: 2035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // LLVM void type can only be used as the result of a function call. Just 2045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // map to the same as char. 2050032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::IntegerType::get(getLLVMContext(), 8); 2065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Bool: 20819009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner // Note that we always return bool as i1 for use as a scalar type. 2090032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::Type::getInt1Ty(getLLVMContext()); 2101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 211d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::Char_S: 212d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::Char_U: 213d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::SChar: 214d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::UChar: 2155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Short: 2165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::UShort: 2175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Int: 2185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::UInt: 2195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Long: 2205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::ULong: 2215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::LongLong: 2225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::ULongLong: 223afef76e43a30380b3c612a674738f2f574c8f166Argyrios Kyrtzidis case BuiltinType::WChar: 224f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case BuiltinType::Char16: 225f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case BuiltinType::Char32: 2260032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::IntegerType::get(getLLVMContext(), 22798be4943e8dc4f3905629a7102668960873cf863Chris Lattner static_cast<unsigned>(Context.getTypeSize(T))); 2281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 229f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman case BuiltinType::Float: 230c8b1227fa8c17d9881815e40c04e19334be536f8Nate Begeman case BuiltinType::Double: 2315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::LongDouble: 2321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return getTypeForFormat(getLLVMContext(), 2330032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson Context.getFloatTypeSemantics(T)); 2341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 235c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson case BuiltinType::NullPtr: { 236c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson // Model std::nullptr_t as i8* 237c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson const llvm::Type *Ty = llvm::IntegerType::get(getLLVMContext(), 8); 238c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson return llvm::PointerType::getUnqual(Ty); 239c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson } 240c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson 2412df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::UInt128: 2422df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::Int128: 2430032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::IntegerType::get(getLLVMContext(), 128); 2448c69235d21dfb067efb530a8cf1f35d633394270Eli Friedman 2458c69235d21dfb067efb530a8cf1f35d633394270Eli Friedman case BuiltinType::Overload: 2468c69235d21dfb067efb530a8cf1f35d633394270Eli Friedman case BuiltinType::Dependent: 2478c69235d21dfb067efb530a8cf1f35d633394270Eli Friedman case BuiltinType::UndeducedAuto: 2488c69235d21dfb067efb530a8cf1f35d633394270Eli Friedman assert(0 && "Unexpected builtin type!"); 2498c69235d21dfb067efb530a8cf1f35d633394270Eli Friedman break; 2505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2518c69235d21dfb067efb530a8cf1f35d633394270Eli Friedman assert(0 && "Unknown builtin type!"); 2525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 2535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Complex: { 2551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const llvm::Type *EltTy = 256fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner ConvertTypeRecursive(cast<ComplexType>(Ty).getElementType()); 25747a434ff3d49e7906eda88e8e8242e4297725b32Owen Anderson return llvm::StructType::get(TheModule.getContext(), EltTy, EltTy, NULL); 2585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2597c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl case Type::LValueReference: 2607c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl case Type::RValueReference: { 2616aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar const ReferenceType &RTy = cast<ReferenceType>(Ty); 2626aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar QualType ETy = RTy.getPointeeType(); 2638c8f69ec1477424e11faef6b235505584d61e522Owen Anderson llvm::OpaqueType *PointeeType = llvm::OpaqueType::get(getLLVMContext()); 2646aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar PointersToResolve.push_back(std::make_pair(ETy, PointeeType)); 2656aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar return llvm::PointerType::get(PointeeType, ETy.getAddressSpace()); 2666aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar } 2675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Pointer: { 2686aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar const PointerType &PTy = cast<PointerType>(Ty); 269fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner QualType ETy = PTy.getPointeeType(); 2708c8f69ec1477424e11faef6b235505584d61e522Owen Anderson llvm::OpaqueType *PointeeType = llvm::OpaqueType::get(getLLVMContext()); 2716aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar PointersToResolve.push_back(std::make_pair(ETy, PointeeType)); 272fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return llvm::PointerType::get(PointeeType, ETy.getAddressSpace()); 2735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 275fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case Type::VariableArray: { 276fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff const VariableArrayType &A = cast<VariableArrayType>(Ty); 2770953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert(A.getIndexTypeCVRQualifiers() == 0 && 2785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer "FIXME: We only handle trivial array types so far!"); 279c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // VLAs resolve to the innermost element type; this matches 280c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // the return of alloca, and there isn't any obviously better choice. 28157a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman return ConvertTypeForMemRecursive(A.getElementType()); 282c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman } 283c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman case Type::IncompleteArray: { 284c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman const IncompleteArrayType &A = cast<IncompleteArrayType>(Ty); 2850953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert(A.getIndexTypeCVRQualifiers() == 0 && 286c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman "FIXME: We only handle trivial array types so far!"); 287c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // int X[] -> [0 x int] 28857a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman return llvm::ArrayType::get(ConvertTypeForMemRecursive(A.getElementType()), 0); 2895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 290fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case Type::ConstantArray: { 291fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff const ConstantArrayType &A = cast<ConstantArrayType>(Ty); 29257a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman const llvm::Type *EltTy = ConvertTypeForMemRecursive(A.getElementType()); 293fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff return llvm::ArrayType::get(EltTy, A.getSize().getZExtValue()); 294fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff } 295213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman case Type::ExtVector: 2965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Vector: { 2975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const VectorType &VT = cast<VectorType>(Ty); 298fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return llvm::VectorType::get(ConvertTypeRecursive(VT.getElementType()), 2995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer VT.getNumElements()); 3005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::FunctionNoProto: 302bb36d331f439f49859efcfb4435c61762fbba6f9Daniel Dunbar case Type::FunctionProto: { 303b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // First, check whether we can build the full function type. 304b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman if (const TagType* TT = VerifyFuncTypeComplete(&Ty)) { 305b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // This function's type depends on an incomplete tag type; make sure 306b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // we have an opaque type corresponding to the tag type. 307b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman ConvertTagDeclType(TT->getDecl()); 308b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // Create an opaque type for this function type, save it, and return it. 3098c8f69ec1477424e11faef6b235505584d61e522Owen Anderson llvm::Type *ResultType = llvm::OpaqueType::get(getLLVMContext()); 310b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman FunctionTypes.insert(std::make_pair(&Ty, ResultType)); 311b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman return ResultType; 312b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman } 313b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // The function type can be built; call the appropriate routines to 314b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // build it. 3159a1a9c41cf7e2735f059bb0c1d85f3207f637b22Chris Lattner if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(&Ty)) 316b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman return GetFunctionType(getFunctionInfo(FPT), FPT->isVariadic()); 3179a1a9c41cf7e2735f059bb0c1d85f3207f637b22Chris Lattner 3189a1a9c41cf7e2735f059bb0c1d85f3207f637b22Chris Lattner const FunctionNoProtoType *FNPT = cast<FunctionNoProtoType>(&Ty); 3199a1a9c41cf7e2735f059bb0c1d85f3207f637b22Chris Lattner return GetFunctionType(getFunctionInfo(FNPT), true); 320bb36d331f439f49859efcfb4435c61762fbba6f9Daniel Dunbar } 3211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 322391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner case Type::ObjCInterface: { 323412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar // Objective-C interfaces are always opaque (outside of the 324412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar // runtime, which can do whatever it likes); we never refine 325412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar // these. 326412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar const llvm::Type *&T = InterfaceTypes[cast<ObjCInterfaceType>(&Ty)]; 327412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar if (!T) 3288c8f69ec1477424e11faef6b235505584d61e522Owen Anderson T = llvm::OpaqueType::get(getLLVMContext()); 329412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar return T; 330391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner } 3311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff case Type::ObjCObjectPointer: { 33328e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar // Protocol qualifications do not influence the LLVM type, we just return a 33428e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar // pointer to the underlying interface type. We don't need to worry about 33528e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar // recursive conversion. 3361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const llvm::Type *T = 33728e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar ConvertTypeRecursive(cast<ObjCObjectPointerType>(Ty).getPointeeType()); 33828e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar return llvm::PointerType::getUnqual(T); 33914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 34028e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar 34172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Record: 34272564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Enum: { 343de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner const TagDecl *TD = cast<TagType>(Ty).getDecl(); 3448fb1dd005f4cb530bca11d622362d39727294420Chris Lattner const llvm::Type *Res = ConvertTagDeclType(TD); 3451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 346de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner std::string TypeName(TD->getKindName()); 347de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner TypeName += '.'; 3481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 349de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner // Name the codegen type after the typedef name 350de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner // if there is no tag type name available 351de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner if (TD->getIdentifier()) 3526b7fc1344d440b2378d7a1825046c60617cadae2Anders Carlsson // FIXME: We should not have to check for a null decl context here. 3536b7fc1344d440b2378d7a1825046c60617cadae2Anders Carlsson // Right now we do it because the implicit Obj-C decls don't have one. 3546b7fc1344d440b2378d7a1825046c60617cadae2Anders Carlsson TypeName += TD->getDeclContext() ? TD->getQualifiedNameAsString() : 3556b7fc1344d440b2378d7a1825046c60617cadae2Anders Carlsson TD->getNameAsString(); 356de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner else if (const TypedefType *TdT = dyn_cast<TypedefType>(T)) 3576b7fc1344d440b2378d7a1825046c60617cadae2Anders Carlsson // FIXME: We should not have to check for a null decl context here. 3586b7fc1344d440b2378d7a1825046c60617cadae2Anders Carlsson // Right now we do it because the implicit Obj-C decls don't have one. 3596b7fc1344d440b2378d7a1825046c60617cadae2Anders Carlsson TypeName += TdT->getDecl()->getDeclContext() ? 3606b7fc1344d440b2378d7a1825046c60617cadae2Anders Carlsson TdT->getDecl()->getQualifiedNameAsString() : 3616b7fc1344d440b2378d7a1825046c60617cadae2Anders Carlsson TdT->getDecl()->getNameAsString(); 362de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner else 363de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner TypeName += "anon"; 3641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TheModule.addTypeName(TypeName, Res); 366de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner return Res; 367de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner } 3689048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar 3699048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar case Type::BlockPointer: { 3704e174f1b1e95faacc21da2eac70f7853807f3ea3Daniel Dunbar const QualType FTy = cast<BlockPointerType>(Ty).getPointeeType(); 3718c8f69ec1477424e11faef6b235505584d61e522Owen Anderson llvm::OpaqueType *PointeeType = llvm::OpaqueType::get(getLLVMContext()); 372209bb438042ef7652b2b046e43d4ffb5a00d9725Fariborz Jahanian PointersToResolve.push_back(std::make_pair(FTy, PointeeType)); 373209bb438042ef7652b2b046e43d4ffb5a00d9725Fariborz Jahanian return llvm::PointerType::get(PointeeType, FTy.getAddressSpace()); 3749048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar } 375424c51d3d4bea87291919b75e73ca59386702ad5Sebastian Redl 3760e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson case Type::MemberPointer: { 3770e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson // FIXME: This is ABI dependent. We use the Itanium C++ ABI. 3780e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson // http://www.codesourcery.com/public/cxx-abi/abi.html#member-pointers 3790e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson // If we ever want to support other ABIs this needs to be abstracted. 3800e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson 3810e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson QualType ETy = cast<MemberPointerType>(Ty).getPointeeType(); 3824a2251bb06a03166e34b509ca840b36f816c4081Eli Friedman const llvm::Type *PtrDiffTy = 3834a2251bb06a03166e34b509ca840b36f816c4081Eli Friedman ConvertTypeRecursive(Context.getPointerDiffType()); 3846f41c17ae854c8a26126e5ea1c3cd53bd746b7baChris Lattner if (ETy->isFunctionType()) 3854a2251bb06a03166e34b509ca840b36f816c4081Eli Friedman return llvm::StructType::get(TheModule.getContext(), PtrDiffTy, PtrDiffTy, 3860e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson NULL); 3876f41c17ae854c8a26126e5ea1c3cd53bd746b7baChris Lattner return PtrDiffTy; 3880e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson } 3897532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 3907532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor case Type::TemplateSpecialization: 3917532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor assert(false && "Dependent types can't get here"); 3925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // FIXME: implement. 3958c8f69ec1477424e11faef6b235505584d61e522Owen Anderson return llvm::OpaqueType::get(getLLVMContext()); 3965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 398fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner/// ConvertTagDeclType - Lay out a tagged decl type like struct or union or 399fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner/// enum. 4008fb1dd005f4cb530bca11d622362d39727294420Chris Lattnerconst llvm::Type *CodeGenTypes::ConvertTagDeclType(const TagDecl *TD) { 401cad86653942d4e33c2674ea40e77d7fe59990130Fariborz Jahanian 402cad86653942d4e33c2674ea40e77d7fe59990130Fariborz Jahanian // FIXME. This may have to move to a better place. 403cad86653942d4e33c2674ea40e77d7fe59990130Fariborz Jahanian if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TD)) { 404cad86653942d4e33c2674ea40e77d7fe59990130Fariborz Jahanian for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(), 405cad86653942d4e33c2674ea40e77d7fe59990130Fariborz Jahanian e = RD->bases_end(); i != e; ++i) { 406cad86653942d4e33c2674ea40e77d7fe59990130Fariborz Jahanian if (!i->isVirtual()) { 407cad86653942d4e33c2674ea40e77d7fe59990130Fariborz Jahanian const CXXRecordDecl *Base = 4086217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl()); 409cad86653942d4e33c2674ea40e77d7fe59990130Fariborz Jahanian ConvertTagDeclType(Base); 410cad86653942d4e33c2674ea40e77d7fe59990130Fariborz Jahanian } 411cad86653942d4e33c2674ea40e77d7fe59990130Fariborz Jahanian } 412cad86653942d4e33c2674ea40e77d7fe59990130Fariborz Jahanian } 4131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 414efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar // TagDecl's are not necessarily unique, instead use the (clang) 415efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar // type connected to the decl. 4161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const Type *Key = 417e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump Context.getTagDeclType(TD).getTypePtr(); 4181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump llvm::DenseMap<const Type*, llvm::PATypeHolder>::iterator TDTI = 419efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar TagDeclTypes.find(Key); 4201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4215de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // If we've already compiled this tag type, use the previous definition. 4225de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner if (TDTI != TagDeclTypes.end()) 423fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner return TDTI->second; 4241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4255de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // If this is still a forward definition, just define an opaque type to use 4265de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // for this tagged decl. 427fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner if (!TD->isDefinition()) { 4288c8f69ec1477424e11faef6b235505584d61e522Owen Anderson llvm::Type *ResultType = llvm::OpaqueType::get(getLLVMContext()); 429efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar TagDeclTypes.insert(std::make_pair(Key, ResultType)); 4305de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner return ResultType; 4315de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner } 4321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4335de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // Okay, this is a definition of a type. Compile the implementation now. 4341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4356f41c17ae854c8a26126e5ea1c3cd53bd746b7baChris Lattner if (TD->isEnum()) // Don't bother storing enums in TagDeclTypes. 436fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return ConvertTypeRecursive(cast<EnumDecl>(TD)->getIntegerType()); 4371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4385de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // This decl could well be recursive. In this case, insert an opaque 4395de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // definition of this type, which the recursive uses will get. We will then 4405de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // refine this opaque version later. 4415de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 4425de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // Create new OpaqueType now for later use in case this is a recursive 4435de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // type. This will later be refined to the actual type. 4448c8f69ec1477424e11faef6b235505584d61e522Owen Anderson llvm::PATypeHolder ResultHolder = llvm::OpaqueType::get(getLLVMContext()); 445efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar TagDeclTypes.insert(std::make_pair(Key, ResultHolder)); 4461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4475de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner const RecordDecl *RD = cast<const RecordDecl>(TD); 448ae287239879386b9abf6da50a67bbb7fe81897f1Daniel Dunbar 449696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson // Layout fields. 4506f41c17ae854c8a26126e5ea1c3cd53bd746b7baChris Lattner CGRecordLayout *Layout = CGRecordLayoutBuilder::ComputeLayout(*this, RD); 4511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 452696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson CGRecordLayouts[Key] = Layout; 4536f41c17ae854c8a26126e5ea1c3cd53bd746b7baChris Lattner const llvm::Type *ResultType = Layout->getLLVMType(); 4541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4555de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // Refine our Opaque type to ResultType. This can invalidate ResultType, so 4565de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // make sure to read the result out of the holder. 4575de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner cast<llvm::OpaqueType>(ResultHolder.get()) 4585de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner ->refineAbstractTypeTo(ResultType); 4591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4605de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner return ResultHolder.get(); 4611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump} 462fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 463b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel/// getLLVMFieldNo - Return llvm::StructType element number 464b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel/// that corresponds to the field FD. 465b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patelunsigned CodeGenTypes::getLLVMFieldNo(const FieldDecl *FD) { 4668330ceeebb3bfac31116b387b90ff2ce3cef85e4Anders Carlsson assert(!FD->isBitField() && "Don't use getLLVMFieldNo on bit fields!"); 4671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 468ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner llvm::DenseMap<const FieldDecl*, unsigned>::iterator I = FieldInfo.find(FD); 46921fdf416723e8c475812a0324a1f9fafc949c25fHartmut Kaiser assert (I != FieldInfo.end() && "Unable to find field info"); 470391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner return I->second; 471391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner} 472391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 473c4c429a1a5947ba9be64d3070741d98362872265Devang Patel/// addFieldInfo - Assign field number to field FD. 4742c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venanciovoid CodeGenTypes::addFieldInfo(const FieldDecl *FD, unsigned No) { 4752c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio FieldInfo[FD] = No; 4762c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio} 4772c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio 4782c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio/// getBitFieldInfo - Return the BitFieldInfo that corresponds to the field FD. 4792c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos VenancioCodeGenTypes::BitFieldInfo CodeGenTypes::getBitFieldInfo(const FieldDecl *FD) { 4802c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio llvm::DenseMap<const FieldDecl *, BitFieldInfo>::iterator 4812c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio I = BitFields.find(FD); 4822c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio assert (I != BitFields.end() && "Unable to find bitfield info"); 4832c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio return I->second; 4842c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio} 4852c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio 4862c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio/// addBitFieldInfo - Assign a start bit and a size to field FD. 4878330ceeebb3bfac31116b387b90ff2ce3cef85e4Anders Carlssonvoid CodeGenTypes::addBitFieldInfo(const FieldDecl *FD, unsigned FieldNo, 4888330ceeebb3bfac31116b387b90ff2ce3cef85e4Anders Carlsson unsigned Start, unsigned Size) { 4898330ceeebb3bfac31116b387b90ff2ce3cef85e4Anders Carlsson BitFields.insert(std::make_pair(FD, BitFieldInfo(FieldNo, Start, Size))); 490b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel} 491b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel 49288a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel/// getCGRecordLayout - Return record layout info for the given llvm::Type. 493ad3e7118c40711faf5f51f08d599dbd525d3408aAnders Carlssonconst CGRecordLayout & 494af31913e48c96fddb45a0fd33f25617546502cbbChris LattnerCodeGenTypes::getCGRecordLayout(const TagDecl *TD) const { 4956f41c17ae854c8a26126e5ea1c3cd53bd746b7baChris Lattner const Type *Key = Context.getTagDeclType(TD).getTypePtr(); 4963958b502404b4bd67f26fee398cb347abe89e6a8Jeffrey Yasskin llvm::DenseMap<const Type*, CGRecordLayout *>::const_iterator I 497efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar = CGRecordLayouts.find(Key); 4981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert (I != CGRecordLayouts.end() 499b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel && "Unable to find record layout information for type"); 500ad3e7118c40711faf5f51f08d599dbd525d3408aAnders Carlsson return *I->second; 501b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel} 502