CodeGenTypes.cpp revision 3f59c975aa5d047f7edd1b900b5e885c38af0ef7
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" 15270e203b50ed8791e61afd357596bcf050cf2bfdDaniel Dunbar#include "CGCall.h" 16f16aa103d3afd42fbca2ab346f191bf745cec092John McCall#include "CGCXXABI.h" 172924ade97ee4228fcf3518d89cd4bd1653236b48Daniel Dunbar#include "CGRecordLayout.h" 18de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/ASTContext.h" 19c4a1dea2dc56bd1357ec91b829a0b9e68229a13eDaniel Dunbar#include "clang/AST/DeclObjC.h" 20742cd1b7bb86b52b23b335d47abbd842dac0e1bfFariborz Jahanian#include "clang/AST/DeclCXX.h" 21de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/Expr.h" 2219cc4abea06a9b49e0e16a50d335c064cd723572Anders Carlsson#include "clang/AST/RecordLayout.h" 235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "llvm/DerivedTypes.h" 244e533287e6a9adac78c9ac370612581aad9b8c5eAnders Carlsson#include "llvm/Module.h" 25d9e9ede6b1703849da739629904dad197306e527Devang Patel#include "llvm/Target/TargetData.h" 265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace CodeGen; 285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 297a4718e813e5e99d478567a482217c7eef8572c5Devang PatelCodeGenTypes::CodeGenTypes(ASTContext &Ctx, llvm::Module& M, 30f16aa103d3afd42fbca2ab346f191bf745cec092John McCall const llvm::TargetData &TD, const ABIInfo &Info, 31f16aa103d3afd42fbca2ab346f191bf745cec092John McCall CGCXXABI &CXXABI) 326b1da0ea19c12346192f5ea4d70872c13bfcc82aDaniel Dunbar : Context(Ctx), Target(Ctx.Target), TheModule(M), TheTargetData(TD), 33f16aa103d3afd42fbca2ab346f191bf745cec092John McCall TheABIInfo(Info), TheCXXABI(CXXABI) { 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 47a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattner/// HandleLateResolvedPointers - For top-level ConvertType calls, this handles 48a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattner/// pointers that are referenced but have not been converted yet. This is used 49a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattner/// to handle cyclic structures properly. 50a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattnervoid CodeGenTypes::HandleLateResolvedPointers() { 51a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattner assert(!PointersToResolve.empty() && "No pointers to resolve!"); 52bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner 53bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner // Any pointers that were converted deferred evaluation of their pointee type, 54fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // creating an opaque type instead. This is in order to avoid problems with 55fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // circular types. Loop through all these defered pointees, if any, and 56fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // resolve them now. 57fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner while (!PointersToResolve.empty()) { 586f41c17ae854c8a26126e5ea1c3cd53bd746b7baChris Lattner std::pair<QualType, llvm::OpaqueType*> P = PointersToResolve.pop_back_val(); 596f41c17ae854c8a26126e5ea1c3cd53bd746b7baChris Lattner 60fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // We can handle bare pointers here because we know that the only pointers 61fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // to the Opaque type are P.second and from other types. Refining the 62fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // opqaue type away will invalidate P.second, but we don't mind :). 6357a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman const llvm::Type *NT = ConvertTypeForMemRecursive(P.first); 64fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner P.second->refineAbstractTypeTo(NT); 65fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner } 66a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattner} 67fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner 68a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattner 69a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattner/// ConvertType - Convert the specified type to its LLVM form. 70a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattnerconst llvm::Type *CodeGenTypes::ConvertType(QualType T, bool IsRecursive) { 71a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattner const llvm::Type *Result = ConvertTypeRecursive(T); 72a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattner 73a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattner // If this is a top-level call to ConvertType and sub-conversions caused 74a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattner // pointers to get lazily built as opaque types, resolve the pointers, which 75a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattner // might cause Result to be merged away. 76a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattner if (!IsRecursive && !PointersToResolve.empty()) { 77a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattner llvm::PATypeHolder ResultHandle = Result; 78a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattner HandleLateResolvedPointers(); 79a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattner Result = ResultHandle; 80a9fa85841102e81daaa23650d89b120fe9dacedcChris Lattner } 81fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return Result; 82fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner} 83fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner 84fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattnerconst llvm::Type *CodeGenTypes::ConvertTypeRecursive(QualType T) { 8509dc6660487fc2f4a4bb2032e30123d3e0da7230Chris Lattner T = Context.getCanonicalType(T); 861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 8730ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel // See if type is already cached. 880ffe89ab1e4890899e0e11a6f68223567a69b38aDevang Patel llvm::DenseMap<Type *, llvm::PATypeHolder>::iterator 899619662a1d42e2008b865d3459c0677e149dad1bChris Lattner I = TypeCache.find(T.getTypePtr()); 903c40085b373d8e6e4523812e06f73a0cb9d5142cDevang Patel // If type is found in map and this is not a definition for a opaque 91fae6e2994a51d8ec1e61b6eb68765247c83b1ccfChris Lattner // place holder type then use it. Otherwise, convert type T. 924581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner if (I != TypeCache.end()) 9347c87b4b160d45285b24b1b7f4e3cbaaed3dc464Devang Patel return I->second.get(); 9430ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel 9530ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel const llvm::Type *ResultType = ConvertNewType(T); 961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TypeCache.insert(std::make_pair(T.getTypePtr(), 974581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner llvm::PATypeHolder(ResultType))); 9830ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel return ResultType; 9930ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel} 10030ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel 1014581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// ConvertTypeForMem - Convert type T into a llvm::Type. This differs from 1024581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// ConvertType in that it is used to convert to the memory representation for 1034581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// a type. For example, the scalar representation for _Bool is i1, but the 1044581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// memory representation is usually i8 or i32, depending on the target. 105bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattnerconst llvm::Type *CodeGenTypes::ConvertTypeForMem(QualType T, bool IsRecursive){ 106bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner const llvm::Type *R = ConvertType(T, IsRecursive); 1071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10819009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner // If this is a non-bool type, don't map it. 109f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (!R->isIntegerTy(1)) 11019009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner return R; 1111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11219009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner // Otherwise, return an integer of the target-specified size. 1130032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::IntegerType::get(getLLVMContext(), 1140032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson (unsigned)Context.getTypeSize(T)); 1151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11619009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner} 11719009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner 118b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman// Code to verify a given function type is complete, i.e. the return type 119b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman// and all of the argument types are complete. 120c00129a08c829bb34f22dc13727043c994c85644Eli Friedmanconst TagType *CodeGenTypes::VerifyFuncTypeComplete(const Type* T) { 121b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman const FunctionType *FT = cast<FunctionType>(T); 1226217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const TagType* TT = FT->getResultType()->getAs<TagType>()) 123b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman if (!TT->getDecl()->isDefinition()) 124b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman return TT; 125b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(T)) 126b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman for (unsigned i = 0; i < FPT->getNumArgs(); i++) 1276217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const TagType* TT = FPT->getArgType(i)->getAs<TagType>()) 128b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman if (!TT->getDecl()->isDefinition()) 129b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman return TT; 130b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman return 0; 131b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman} 132b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman 133c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattner/// UpdateCompletedType - When we find the full definition for a TagDecl, 134c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattner/// replace the 'opaque' type we previously made for it if applicable. 135c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattnervoid CodeGenTypes::UpdateCompletedType(const TagDecl *TD) { 136e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump const Type *Key = Context.getTagDeclType(TD).getTypePtr(); 1371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump llvm::DenseMap<const Type*, llvm::PATypeHolder>::iterator TDTI = 138efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar TagDeclTypes.find(Key); 1396ef58e36bbbfa232fe8b50309361e841985abfc6Chris Lattner if (TDTI == TagDeclTypes.end()) return; 1401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1416ef58e36bbbfa232fe8b50309361e841985abfc6Chris Lattner // Remember the opaque LLVM type for this tagdecl. 142d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner llvm::PATypeHolder OpaqueHolder = TDTI->second; 143d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner assert(isa<llvm::OpaqueType>(OpaqueHolder.get()) && 1446ef58e36bbbfa232fe8b50309361e841985abfc6Chris Lattner "Updating compilation of an already non-opaque type?"); 1451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 146d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner // Remove it from TagDeclTypes so that it will be regenerated. 147d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner TagDeclTypes.erase(TDTI); 148d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 1498fb1dd005f4cb530bca11d622362d39727294420Chris Lattner // Generate the new type. 1508fb1dd005f4cb530bca11d622362d39727294420Chris Lattner const llvm::Type *NT = ConvertTagDeclType(TD); 151d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 1528fb1dd005f4cb530bca11d622362d39727294420Chris Lattner // Refine the old opaque type to its new definition. 1538fb1dd005f4cb530bca11d622362d39727294420Chris Lattner cast<llvm::OpaqueType>(OpaqueHolder.get())->refineAbstractTypeTo(NT); 154b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman 155b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // Since we just completed a tag type, check to see if any function types 156b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // were completed along with the tag type. 157b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // FIXME: This is very inefficient; if we track which function types depend 158b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // on which tag types, though, it should be reasonably efficient. 159b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman llvm::DenseMap<const Type*, llvm::PATypeHolder>::iterator i; 160b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman for (i = FunctionTypes.begin(); i != FunctionTypes.end(); ++i) { 161b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman if (const TagType* TT = VerifyFuncTypeComplete(i->first)) { 162b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // This function type still depends on an incomplete tag type; make sure 163b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // that tag type has an associated opaque type. 164b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman ConvertTagDeclType(TT->getDecl()); 165b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman } else { 166b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // This function no longer depends on an incomplete tag type; create the 167b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // function type, and refine the opaque type to the new function type. 168b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman llvm::PATypeHolder OpaqueHolder = i->second; 169b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman const llvm::Type *NFT = ConvertNewType(QualType(i->first, 0)); 170b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman cast<llvm::OpaqueType>(OpaqueHolder.get())->refineAbstractTypeTo(NFT); 171b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman FunctionTypes.erase(i); 172b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman } 173b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman } 174d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner} 175d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 1761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic const llvm::Type* getTypeForFormat(llvm::LLVMContext &VMContext, 1770032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson const llvm::fltSemantics &format) { 178b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::IEEEsingle) 1790032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::Type::getFloatTy(VMContext); 180b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::IEEEdouble) 1810032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::Type::getDoubleTy(VMContext); 182b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::IEEEquad) 1830032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::Type::getFP128Ty(VMContext); 184b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::PPCDoubleDouble) 1850032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::Type::getPPC_FP128Ty(VMContext); 186b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::x87DoubleExtended) 1870032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::Type::getX86_FP80Ty(VMContext); 188b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner assert(0 && "Unknown float format!"); 189f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return 0; 190f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman} 191f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman 19230ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patelconst llvm::Type *CodeGenTypes::ConvertNewType(QualType T) { 193e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCall const clang::Type &Ty = *Context.getCanonicalType(T).getTypePtr(); 1941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Ty.getTypeClass()) { 19672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define TYPE(Class, Base) 19772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define ABSTRACT_TYPE(Class, Base) 19872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 19972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define DEPENDENT_TYPE(Class, Base) case Type::Class: 200ad5e73887052193afda72db8efcb812bd083a4a8John McCall#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class: 20172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#include "clang/AST/TypeNodes.def" 20272564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor assert(false && "Non-canonical or dependent types aren't possible."); 20372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor break; 20472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 2055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Builtin: { 2065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (cast<BuiltinType>(Ty).getKind()) { 2075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Void: 208de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff case BuiltinType::ObjCId: 209de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff case BuiltinType::ObjCClass: 21013dcd00615de5c4279d97bdf63cd5f0a14fd9dccFariborz Jahanian case BuiltinType::ObjCSel: 2115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // LLVM void type can only be used as the result of a function call. Just 2125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // map to the same as char. 21377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner return llvm::Type::getInt8Ty(getLLVMContext()); 2145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Bool: 21619009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner // Note that we always return bool as i1 for use as a scalar type. 2170032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::Type::getInt1Ty(getLLVMContext()); 2181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 219d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::Char_S: 220d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::Char_U: 221d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::SChar: 222d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::UChar: 2235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Short: 2245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::UShort: 2255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Int: 2265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::UInt: 2275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Long: 2285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::ULong: 2295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::LongLong: 2305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::ULongLong: 2313f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_S: 2323f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_U: 233f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case BuiltinType::Char16: 234f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case BuiltinType::Char32: 2350032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::IntegerType::get(getLLVMContext(), 23698be4943e8dc4f3905629a7102668960873cf863Chris Lattner static_cast<unsigned>(Context.getTypeSize(T))); 2371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 238f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman case BuiltinType::Float: 239c8b1227fa8c17d9881815e40c04e19334be536f8Nate Begeman case BuiltinType::Double: 2405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::LongDouble: 2411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return getTypeForFormat(getLLVMContext(), 2420032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson Context.getFloatTypeSemantics(T)); 2431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 244c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson case BuiltinType::NullPtr: { 245c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson // Model std::nullptr_t as i8* 24677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *Ty = llvm::Type::getInt8Ty(getLLVMContext()); 247c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson return llvm::PointerType::getUnqual(Ty); 248c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson } 249c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson 2502df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::UInt128: 2512df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::Int128: 2520032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson return llvm::IntegerType::get(getLLVMContext(), 128); 2538c69235d21dfb067efb530a8cf1f35d633394270Eli Friedman 2548c69235d21dfb067efb530a8cf1f35d633394270Eli Friedman case BuiltinType::Overload: 2558c69235d21dfb067efb530a8cf1f35d633394270Eli Friedman case BuiltinType::Dependent: 2568c69235d21dfb067efb530a8cf1f35d633394270Eli Friedman case BuiltinType::UndeducedAuto: 2578c69235d21dfb067efb530a8cf1f35d633394270Eli Friedman assert(0 && "Unexpected builtin type!"); 2588c69235d21dfb067efb530a8cf1f35d633394270Eli Friedman break; 2595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2608c69235d21dfb067efb530a8cf1f35d633394270Eli Friedman assert(0 && "Unknown builtin type!"); 2615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 2625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Complex: { 2641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const llvm::Type *EltTy = 265fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner ConvertTypeRecursive(cast<ComplexType>(Ty).getElementType()); 26647a434ff3d49e7906eda88e8e8242e4297725b32Owen Anderson return llvm::StructType::get(TheModule.getContext(), EltTy, EltTy, NULL); 2675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2687c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl case Type::LValueReference: 2697c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl case Type::RValueReference: { 2706aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar const ReferenceType &RTy = cast<ReferenceType>(Ty); 2716aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar QualType ETy = RTy.getPointeeType(); 2728c8f69ec1477424e11faef6b235505584d61e522Owen Anderson llvm::OpaqueType *PointeeType = llvm::OpaqueType::get(getLLVMContext()); 2736aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar PointersToResolve.push_back(std::make_pair(ETy, PointeeType)); 2746aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar return llvm::PointerType::get(PointeeType, ETy.getAddressSpace()); 2756aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar } 2765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Pointer: { 2776aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar const PointerType &PTy = cast<PointerType>(Ty); 278fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner QualType ETy = PTy.getPointeeType(); 2798c8f69ec1477424e11faef6b235505584d61e522Owen Anderson llvm::OpaqueType *PointeeType = llvm::OpaqueType::get(getLLVMContext()); 2806aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar PointersToResolve.push_back(std::make_pair(ETy, PointeeType)); 281fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return llvm::PointerType::get(PointeeType, ETy.getAddressSpace()); 2825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 284fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case Type::VariableArray: { 285fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff const VariableArrayType &A = cast<VariableArrayType>(Ty); 2860953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert(A.getIndexTypeCVRQualifiers() == 0 && 2875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer "FIXME: We only handle trivial array types so far!"); 288c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // VLAs resolve to the innermost element type; this matches 289c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // the return of alloca, and there isn't any obviously better choice. 29057a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman return ConvertTypeForMemRecursive(A.getElementType()); 291c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman } 292c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman case Type::IncompleteArray: { 293c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman const IncompleteArrayType &A = cast<IncompleteArrayType>(Ty); 2940953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert(A.getIndexTypeCVRQualifiers() == 0 && 295c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman "FIXME: We only handle trivial array types so far!"); 296c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // int X[] -> [0 x int] 297bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner return llvm::ArrayType::get(ConvertTypeForMemRecursive(A.getElementType()), 298bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner 0); 2995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 300fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case Type::ConstantArray: { 301fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff const ConstantArrayType &A = cast<ConstantArrayType>(Ty); 30257a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman const llvm::Type *EltTy = ConvertTypeForMemRecursive(A.getElementType()); 303fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff return llvm::ArrayType::get(EltTy, A.getSize().getZExtValue()); 304fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff } 305213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman case Type::ExtVector: 3065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Vector: { 3075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const VectorType &VT = cast<VectorType>(Ty); 308fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return llvm::VectorType::get(ConvertTypeRecursive(VT.getElementType()), 3095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer VT.getNumElements()); 3105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::FunctionNoProto: 312bb36d331f439f49859efcfb4435c61762fbba6f9Daniel Dunbar case Type::FunctionProto: { 313bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner // First, check whether we can build the full function type. If the 314bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner // function type depends on an incomplete type (e.g. a struct or enum), we 315bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner // cannot lower the function type. Instead, turn it into an Opaque pointer 316bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner // and have UpdateCompletedType revisit the function type when/if the opaque 317bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner // argument type is defined. 318ce93399f26f23735b8e291321f18ad54f64cb58aChris Lattner if (const TagType *TT = VerifyFuncTypeComplete(&Ty)) { 319b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // This function's type depends on an incomplete tag type; make sure 320b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // we have an opaque type corresponding to the tag type. 321b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman ConvertTagDeclType(TT->getDecl()); 322b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // Create an opaque type for this function type, save it, and return it. 3238c8f69ec1477424e11faef6b235505584d61e522Owen Anderson llvm::Type *ResultType = llvm::OpaqueType::get(getLLVMContext()); 324b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman FunctionTypes.insert(std::make_pair(&Ty, ResultType)); 325b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman return ResultType; 326b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman } 327bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner 328b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // The function type can be built; call the appropriate routines to 329b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // build it. 330bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner const CGFunctionInfo *FI; 331bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner bool isVariadic; 332bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(&Ty)) { 333bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner FI = &getFunctionInfo( 334bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner CanQual<FunctionProtoType>::CreateUnsafe(QualType(FPT, 0)), 335bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner true /*Recursive*/); 336bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner isVariadic = FPT->isVariadic(); 337bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner } else { 338bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner const FunctionNoProtoType *FNPT = cast<FunctionNoProtoType>(&Ty); 339bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner FI = &getFunctionInfo( 340bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner CanQual<FunctionNoProtoType>::CreateUnsafe(QualType(FNPT, 0)), 341bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner true /*Recursive*/); 342bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner isVariadic = true; 343bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner } 344bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner 345bcaedaed309ce453a992fdeef4a4c908cc7d9dfbChris Lattner return GetFunctionType(*FI, isVariadic, true); 346bb36d331f439f49859efcfb4435c61762fbba6f9Daniel Dunbar } 3471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 348c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCObject: 349c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return ConvertTypeRecursive(cast<ObjCObjectType>(Ty).getBaseType()); 350c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 351391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner case Type::ObjCInterface: { 352412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar // Objective-C interfaces are always opaque (outside of the 353412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar // runtime, which can do whatever it likes); we never refine 354412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar // these. 355412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar const llvm::Type *&T = InterfaceTypes[cast<ObjCInterfaceType>(&Ty)]; 356412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar if (!T) 3578c8f69ec1477424e11faef6b235505584d61e522Owen Anderson T = llvm::OpaqueType::get(getLLVMContext()); 358412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar return T; 359391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner } 3601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 36114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff case Type::ObjCObjectPointer: { 36228e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar // Protocol qualifications do not influence the LLVM type, we just return a 36328e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar // pointer to the underlying interface type. We don't need to worry about 36428e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar // recursive conversion. 3651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const llvm::Type *T = 36628e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar ConvertTypeRecursive(cast<ObjCObjectPointerType>(Ty).getPointeeType()); 36728e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar return llvm::PointerType::getUnqual(T); 36814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 36928e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar 37072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Record: 37172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Enum: { 372de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner const TagDecl *TD = cast<TagType>(Ty).getDecl(); 3738fb1dd005f4cb530bca11d622362d39727294420Chris Lattner const llvm::Type *Res = ConvertTagDeclType(TD); 3741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3752348c6268a84a55445af73cc6fe26136b2b4dc87Benjamin Kramer llvm::SmallString<256> TypeName; 3762348c6268a84a55445af73cc6fe26136b2b4dc87Benjamin Kramer llvm::raw_svector_ostream OS(TypeName); 3772348c6268a84a55445af73cc6fe26136b2b4dc87Benjamin Kramer OS << TD->getKindName() << '.'; 3781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 379de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner // Name the codegen type after the typedef name 380de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner // if there is no tag type name available 3812348c6268a84a55445af73cc6fe26136b2b4dc87Benjamin Kramer if (TD->getIdentifier()) { 3826b7fc1344d440b2378d7a1825046c60617cadae2Anders Carlsson // FIXME: We should not have to check for a null decl context here. 3836b7fc1344d440b2378d7a1825046c60617cadae2Anders Carlsson // Right now we do it because the implicit Obj-C decls don't have one. 3842348c6268a84a55445af73cc6fe26136b2b4dc87Benjamin Kramer if (TD->getDeclContext()) 3852348c6268a84a55445af73cc6fe26136b2b4dc87Benjamin Kramer OS << TD->getQualifiedNameAsString(); 3862348c6268a84a55445af73cc6fe26136b2b4dc87Benjamin Kramer else 3872348c6268a84a55445af73cc6fe26136b2b4dc87Benjamin Kramer TD->printName(OS); 388cb690b111f698f0e16e59ed82ab6a7d660edb6d1Anders Carlsson } else if (const TypedefDecl *TDD = TD->getTypedefForAnonDecl()) { 3896b7fc1344d440b2378d7a1825046c60617cadae2Anders Carlsson // FIXME: We should not have to check for a null decl context here. 3906b7fc1344d440b2378d7a1825046c60617cadae2Anders Carlsson // Right now we do it because the implicit Obj-C decls don't have one. 391cb690b111f698f0e16e59ed82ab6a7d660edb6d1Anders Carlsson if (TDD->getDeclContext()) 392cb690b111f698f0e16e59ed82ab6a7d660edb6d1Anders Carlsson OS << TDD->getQualifiedNameAsString(); 3932348c6268a84a55445af73cc6fe26136b2b4dc87Benjamin Kramer else 394cb690b111f698f0e16e59ed82ab6a7d660edb6d1Anders Carlsson TDD->printName(OS); 395cb690b111f698f0e16e59ed82ab6a7d660edb6d1Anders Carlsson } else 3962348c6268a84a55445af73cc6fe26136b2b4dc87Benjamin Kramer OS << "anon"; 3971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3982348c6268a84a55445af73cc6fe26136b2b4dc87Benjamin Kramer TheModule.addTypeName(OS.str(), Res); 399de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner return Res; 400de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner } 4019048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar 4029048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar case Type::BlockPointer: { 4034e174f1b1e95faacc21da2eac70f7853807f3ea3Daniel Dunbar const QualType FTy = cast<BlockPointerType>(Ty).getPointeeType(); 4048c8f69ec1477424e11faef6b235505584d61e522Owen Anderson llvm::OpaqueType *PointeeType = llvm::OpaqueType::get(getLLVMContext()); 405209bb438042ef7652b2b046e43d4ffb5a00d9725Fariborz Jahanian PointersToResolve.push_back(std::make_pair(FTy, PointeeType)); 406209bb438042ef7652b2b046e43d4ffb5a00d9725Fariborz Jahanian return llvm::PointerType::get(PointeeType, FTy.getAddressSpace()); 4079048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar } 408424c51d3d4bea87291919b75e73ca59386702ad5Sebastian Redl 4090e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson case Type::MemberPointer: { 4100bab0cdab751248ca389a5592bcb70eac5d39260John McCall return getCXXABI().ConvertMemberPointerType(cast<MemberPointerType>(&Ty)); 4110e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson } 4125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 4131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // FIXME: implement. 4158c8f69ec1477424e11faef6b235505584d61e522Owen Anderson return llvm::OpaqueType::get(getLLVMContext()); 4165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 4175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 418fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner/// ConvertTagDeclType - Lay out a tagged decl type like struct or union or 419fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner/// enum. 4208fb1dd005f4cb530bca11d622362d39727294420Chris Lattnerconst llvm::Type *CodeGenTypes::ConvertTagDeclType(const TagDecl *TD) { 421efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar // TagDecl's are not necessarily unique, instead use the (clang) 422efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar // type connected to the decl. 4231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const Type *Key = 424e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump Context.getTagDeclType(TD).getTypePtr(); 4251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump llvm::DenseMap<const Type*, llvm::PATypeHolder>::iterator TDTI = 426efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar TagDeclTypes.find(Key); 4271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4285de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // If we've already compiled this tag type, use the previous definition. 4295de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner if (TDTI != TagDeclTypes.end()) 430fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner return TDTI->second; 4311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4321274ccd90aec0b205fc838c3d504821ccfb55482Douglas Gregor const EnumDecl *ED = dyn_cast<EnumDecl>(TD); 4331274ccd90aec0b205fc838c3d504821ccfb55482Douglas Gregor 4345cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall // If this is still a forward declaration, just define an opaque 4355cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall // type to use for this tagged decl. 4361274ccd90aec0b205fc838c3d504821ccfb55482Douglas Gregor // C++0x: If this is a enumeration type with fixed underlying type, 4371274ccd90aec0b205fc838c3d504821ccfb55482Douglas Gregor // consider it complete. 4381274ccd90aec0b205fc838c3d504821ccfb55482Douglas Gregor if (!TD->isDefinition() && !(ED && ED->isFixed())) { 4398c8f69ec1477424e11faef6b235505584d61e522Owen Anderson llvm::Type *ResultType = llvm::OpaqueType::get(getLLVMContext()); 440efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar TagDeclTypes.insert(std::make_pair(Key, ResultType)); 4415de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner return ResultType; 4425de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner } 4431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4445de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // Okay, this is a definition of a type. Compile the implementation now. 4451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4461274ccd90aec0b205fc838c3d504821ccfb55482Douglas Gregor if (ED) // Don't bother storing enums in TagDeclTypes. 4471274ccd90aec0b205fc838c3d504821ccfb55482Douglas Gregor return ConvertTypeRecursive(ED->getIntegerType()); 4481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4495de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // This decl could well be recursive. In this case, insert an opaque 4505de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // definition of this type, which the recursive uses will get. We will then 4515de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // refine this opaque version later. 4525de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 4535de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // Create new OpaqueType now for later use in case this is a recursive 4545de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // type. This will later be refined to the actual type. 4558c8f69ec1477424e11faef6b235505584d61e522Owen Anderson llvm::PATypeHolder ResultHolder = llvm::OpaqueType::get(getLLVMContext()); 456efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar TagDeclTypes.insert(std::make_pair(Key, ResultHolder)); 4571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4585de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner const RecordDecl *RD = cast<const RecordDecl>(TD); 459ae287239879386b9abf6da50a67bbb7fe81897f1Daniel Dunbar 46086ff308724171494395a840fd2efbe25e62f352eJohn McCall // Force conversion of non-virtual base classes recursively. 46186ff308724171494395a840fd2efbe25e62f352eJohn McCall if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TD)) { 46286ff308724171494395a840fd2efbe25e62f352eJohn McCall for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(), 46386ff308724171494395a840fd2efbe25e62f352eJohn McCall e = RD->bases_end(); i != e; ++i) { 46486ff308724171494395a840fd2efbe25e62f352eJohn McCall if (!i->isVirtual()) { 46586ff308724171494395a840fd2efbe25e62f352eJohn McCall const CXXRecordDecl *Base = 46686ff308724171494395a840fd2efbe25e62f352eJohn McCall cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl()); 46786ff308724171494395a840fd2efbe25e62f352eJohn McCall ConvertTagDeclType(Base); 46886ff308724171494395a840fd2efbe25e62f352eJohn McCall } 46986ff308724171494395a840fd2efbe25e62f352eJohn McCall } 47086ff308724171494395a840fd2efbe25e62f352eJohn McCall } 47186ff308724171494395a840fd2efbe25e62f352eJohn McCall 472696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson // Layout fields. 473270e203b50ed8791e61afd357596bcf050cf2bfdDaniel Dunbar CGRecordLayout *Layout = ComputeRecordLayout(RD); 4741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 475696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson CGRecordLayouts[Key] = Layout; 4766f41c17ae854c8a26126e5ea1c3cd53bd746b7baChris Lattner const llvm::Type *ResultType = Layout->getLLVMType(); 4771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4785de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // Refine our Opaque type to ResultType. This can invalidate ResultType, so 4795de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // make sure to read the result out of the holder. 4805de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner cast<llvm::OpaqueType>(ResultHolder.get()) 4815de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner ->refineAbstractTypeTo(ResultType); 4821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4835de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner return ResultHolder.get(); 4841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump} 485fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 4862d987772c2ba3bff93b9fbe7b73bf06eed2b1607Anders Carlsson/// getCGRecordLayout - Return record layout info for the given record decl. 487ad3e7118c40711faf5f51f08d599dbd525d3408aAnders Carlssonconst CGRecordLayout & 4882d987772c2ba3bff93b9fbe7b73bf06eed2b1607Anders CarlssonCodeGenTypes::getCGRecordLayout(const RecordDecl *RD) { 4892d987772c2ba3bff93b9fbe7b73bf06eed2b1607Anders Carlsson const Type *Key = Context.getTagDeclType(RD).getTypePtr(); 49082926963cccbc54bc707d5dcf79389166046ef08Anders Carlsson 491270e203b50ed8791e61afd357596bcf050cf2bfdDaniel Dunbar const CGRecordLayout *Layout = CGRecordLayouts.lookup(Key); 492c8f01ebbce3c874b43ee78535f7d179517f5f436Anders Carlsson if (!Layout) { 4932d987772c2ba3bff93b9fbe7b73bf06eed2b1607Anders Carlsson // Compute the type information. 4942d987772c2ba3bff93b9fbe7b73bf06eed2b1607Anders Carlsson ConvertTagDeclType(RD); 495c8f01ebbce3c874b43ee78535f7d179517f5f436Anders Carlsson 496c8f01ebbce3c874b43ee78535f7d179517f5f436Anders Carlsson // Now try again. 497c8f01ebbce3c874b43ee78535f7d179517f5f436Anders Carlsson Layout = CGRecordLayouts.lookup(Key); 498c8f01ebbce3c874b43ee78535f7d179517f5f436Anders Carlsson } 499c8f01ebbce3c874b43ee78535f7d179517f5f436Anders Carlsson 500270e203b50ed8791e61afd357596bcf050cf2bfdDaniel Dunbar assert(Layout && "Unable to find record layout information for type"); 501270e203b50ed8791e61afd357596bcf050cf2bfdDaniel Dunbar return *Layout; 502b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel} 5033e5af908ebf4c56b657c488bb2ca22f418e0868bAnders Carlsson 504f16aa103d3afd42fbca2ab346f191bf745cec092John McCallbool CodeGenTypes::isZeroInitializable(QualType T) { 5053e5af908ebf4c56b657c488bb2ca22f418e0868bAnders Carlsson // No need to check for member pointers when not compiling C++. 5063e5af908ebf4c56b657c488bb2ca22f418e0868bAnders Carlsson if (!Context.getLangOptions().CPlusPlus) 507f16aa103d3afd42fbca2ab346f191bf745cec092John McCall return true; 5083e5af908ebf4c56b657c488bb2ca22f418e0868bAnders Carlsson 5093e5af908ebf4c56b657c488bb2ca22f418e0868bAnders Carlsson T = Context.getBaseElementType(T); 5103e5af908ebf4c56b657c488bb2ca22f418e0868bAnders Carlsson 511f16aa103d3afd42fbca2ab346f191bf745cec092John McCall // Records are non-zero-initializable if they contain any 512f16aa103d3afd42fbca2ab346f191bf745cec092John McCall // non-zero-initializable subobjects. 5133e5af908ebf4c56b657c488bb2ca22f418e0868bAnders Carlsson if (const RecordType *RT = T->getAs<RecordType>()) { 5143e5af908ebf4c56b657c488bb2ca22f418e0868bAnders Carlsson const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 515f16aa103d3afd42fbca2ab346f191bf745cec092John McCall return isZeroInitializable(RD); 5163e5af908ebf4c56b657c488bb2ca22f418e0868bAnders Carlsson } 517f16aa103d3afd42fbca2ab346f191bf745cec092John McCall 518f16aa103d3afd42fbca2ab346f191bf745cec092John McCall // We have to ask the ABI about member pointers. 5193e5af908ebf4c56b657c488bb2ca22f418e0868bAnders Carlsson if (const MemberPointerType *MPT = T->getAs<MemberPointerType>()) 520f16aa103d3afd42fbca2ab346f191bf745cec092John McCall return getCXXABI().isZeroInitializable(MPT); 5213e5af908ebf4c56b657c488bb2ca22f418e0868bAnders Carlsson 522f16aa103d3afd42fbca2ab346f191bf745cec092John McCall // Everything else is okay. 523f16aa103d3afd42fbca2ab346f191bf745cec092John McCall return true; 5243e5af908ebf4c56b657c488bb2ca22f418e0868bAnders Carlsson} 525c39211d2aef5b8ca2bc69c9fb81ca3dfb3711eb0Anders Carlsson 526f16aa103d3afd42fbca2ab346f191bf745cec092John McCallbool CodeGenTypes::isZeroInitializable(const CXXRecordDecl *RD) { 5273379e9bd71c0e0051bd97e90d4f2ec964078091dAnders Carlsson return getCGRecordLayout(RD).isZeroInitializable(); 528c39211d2aef5b8ca2bc69c9fb81ca3dfb3711eb0Anders Carlsson} 529