CodeGenTypes.cpp revision b7cfe88e88cb4f46308de89cf3f0c81bfe624128
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// 105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// This is the code that handles AST -> LLVM type lowering. 115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "CodeGenTypes.h" 155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Basic/TargetInfo.h" 165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/AST/AST.h" 175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "llvm/DerivedTypes.h" 184e533287e6a9adac78c9ac370612581aad9b8c5eAnders Carlsson#include "llvm/Module.h" 19d9e9ede6b1703849da739629904dad197306e527Devang Patel#include "llvm/Target/TargetData.h" 205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace CodeGen; 235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 24057afddf0fab91d979d6a750667d56a345225c96Devang Patelnamespace { 2588a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel /// RecordOrganizer - This helper class, used by CGRecordLayout, layouts 26057afddf0fab91d979d6a750667d56a345225c96Devang Patel /// structs and unions. It manages transient information used during layout. 274c4635c6cd8114bfa3ee20628fa1f03e67ac1e55Devang Patel /// FIXME : Handle field aligments. Handle packed structs. 28057afddf0fab91d979d6a750667d56a345225c96Devang Patel class RecordOrganizer { 29057afddf0fab91d979d6a750667d56a345225c96Devang Patel public: 30cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman explicit RecordOrganizer(CodeGenTypes &Types, const RecordDecl& Record) : 31cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman CGT(Types), RD(Record), STy(NULL) {} 320bd41f2cea0639395e8ab7ef8fd6df2c1999b6aeDevang Patel 3386522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel /// layoutStructFields - Do the actual work and lay out all fields. Create 34057afddf0fab91d979d6a750667d56a345225c96Devang Patel /// corresponding llvm struct type. This should be invoked only after 35057afddf0fab91d979d6a750667d56a345225c96Devang Patel /// all fields are added. 3688a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel void layoutStructFields(const ASTRecordLayout &RL); 3786522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel 3886522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel /// layoutUnionFields - Do the actual work and lay out all fields. Create 3986522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel /// corresponding llvm struct type. This should be invoked only after 4086522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel /// all fields are added. 41cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman void layoutUnionFields(const ASTRecordLayout &RL); 42057afddf0fab91d979d6a750667d56a345225c96Devang Patel 43057afddf0fab91d979d6a750667d56a345225c96Devang Patel /// getLLVMType - Return associated llvm struct type. This may be NULL 44057afddf0fab91d979d6a750667d56a345225c96Devang Patel /// if fields are not laid out. 45057afddf0fab91d979d6a750667d56a345225c96Devang Patel llvm::Type *getLLVMType() const { 46057afddf0fab91d979d6a750667d56a345225c96Devang Patel return STy; 47057afddf0fab91d979d6a750667d56a345225c96Devang Patel } 48057afddf0fab91d979d6a750667d56a345225c96Devang Patel 49eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel llvm::SmallSet<unsigned, 8> &getPaddingFields() { 505bfc1a7ecb853cf87d10e720a07b9fbcd2a223eeDevang Patel return PaddingFields; 515bfc1a7ecb853cf87d10e720a07b9fbcd2a223eeDevang Patel } 525bfc1a7ecb853cf87d10e720a07b9fbcd2a223eeDevang Patel 53057afddf0fab91d979d6a750667d56a345225c96Devang Patel private: 54f9fef925644a6c40b344a43ab9ebdb08a707de53Devang Patel CodeGenTypes &CGT; 55cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman const RecordDecl& RD; 56057afddf0fab91d979d6a750667d56a345225c96Devang Patel llvm::Type *STy; 57eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel llvm::SmallSet<unsigned, 8> PaddingFields; 58057afddf0fab91d979d6a750667d56a345225c96Devang Patel }; 59057afddf0fab91d979d6a750667d56a345225c96Devang Patel} 60057afddf0fab91d979d6a750667d56a345225c96Devang Patel 617a4718e813e5e99d478567a482217c7eef8572c5Devang PatelCodeGenTypes::CodeGenTypes(ASTContext &Ctx, llvm::Module& M, 627a4718e813e5e99d478567a482217c7eef8572c5Devang Patel const llvm::TargetData &TD) 637a4718e813e5e99d478567a482217c7eef8572c5Devang Patel : Context(Ctx), Target(Ctx.Target), TheModule(M), TheTargetData(TD) { 64d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner} 655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 66b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang PatelCodeGenTypes::~CodeGenTypes() { 67af31913e48c96fddb45a0fd33f25617546502cbbChris Lattner for(llvm::DenseMap<const TagDecl *, CGRecordLayout *>::iterator 6888a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel I = CGRecordLayouts.begin(), E = CGRecordLayouts.end(); 69b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel I != E; ++I) 70b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel delete I->second; 7188a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel CGRecordLayouts.clear(); 72b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel} 73b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel 745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// ConvertType - Convert the specified type to its LLVM form. 755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst llvm::Type *CodeGenTypes::ConvertType(QualType T) { 76fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner llvm::PATypeHolder Result = ConvertTypeRecursive(T); 77fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner 78fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // Any pointers that were converted defered evaluation of their pointee type, 79fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // creating an opaque type instead. This is in order to avoid problems with 80fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // circular types. Loop through all these defered pointees, if any, and 81fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // resolve them now. 82fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner while (!PointersToResolve.empty()) { 83fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner std::pair<const PointerLikeType *, llvm::OpaqueType*> P = 84fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner PointersToResolve.back(); 85fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner PointersToResolve.pop_back(); 86fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // We can handle bare pointers here because we know that the only pointers 87fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // to the Opaque type are P.second and from other types. Refining the 88fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // opqaue type away will invalidate P.second, but we don't mind :). 89fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner const llvm::Type *NT = ConvertTypeRecursive(P.first->getPointeeType()); 90fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner P.second->refineAbstractTypeTo(NT); 91fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner } 92fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner 93fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return Result; 94fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner} 95fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner 96fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattnerconst llvm::Type *CodeGenTypes::ConvertTypeRecursive(QualType T) { 9730ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel // See if type is already cached. 980ffe89ab1e4890899e0e11a6f68223567a69b38aDevang Patel llvm::DenseMap<Type *, llvm::PATypeHolder>::iterator 995de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner I = TypeCache.find(T.getCanonicalType().getTypePtr()); 1003c40085b373d8e6e4523812e06f73a0cb9d5142cDevang Patel // If type is found in map and this is not a definition for a opaque 101fae6e2994a51d8ec1e61b6eb68765247c83b1ccfChris Lattner // place holder type then use it. Otherwise, convert type T. 1024581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner if (I != TypeCache.end()) 10347c87b4b160d45285b24b1b7f4e3cbaaed3dc464Devang Patel return I->second.get(); 10430ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel 10530ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel const llvm::Type *ResultType = ConvertNewType(T); 1065de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner TypeCache.insert(std::make_pair(T.getCanonicalType().getTypePtr(), 1074581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner llvm::PATypeHolder(ResultType))); 10830ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel return ResultType; 10930ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel} 11030ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel 1114581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// ConvertTypeForMem - Convert type T into a llvm::Type. This differs from 1124581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// ConvertType in that it is used to convert to the memory representation for 1134581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// a type. For example, the scalar representation for _Bool is i1, but the 1144581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// memory representation is usually i8 or i32, depending on the target. 11519009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattnerconst llvm::Type *CodeGenTypes::ConvertTypeForMem(QualType T) { 11619009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner const llvm::Type *R = ConvertType(T); 11719009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner 11819009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner // If this is a non-bool type, don't map it. 11919009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner if (R != llvm::Type::Int1Ty) 12019009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner return R; 12119009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner 12219009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner // Otherwise, return an integer of the target-specified size. 12398be4943e8dc4f3905629a7102668960873cf863Chris Lattner return llvm::IntegerType::get((unsigned)Context.getTypeSize(T)); 12419009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner 12519009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner} 12619009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner 127c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattner/// UpdateCompletedType - When we find the full definition for a TagDecl, 128c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattner/// replace the 'opaque' type we previously made for it if applicable. 129c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattnervoid CodeGenTypes::UpdateCompletedType(const TagDecl *TD) { 130d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner llvm::DenseMap<const TagDecl*, llvm::PATypeHolder>::iterator TDTI = 1316ef58e36bbbfa232fe8b50309361e841985abfc6Chris Lattner TagDeclTypes.find(TD); 1326ef58e36bbbfa232fe8b50309361e841985abfc6Chris Lattner if (TDTI == TagDeclTypes.end()) return; 1336ef58e36bbbfa232fe8b50309361e841985abfc6Chris Lattner 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?"); 138d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 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); 147d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner} 148d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 149391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner/// Produces a vector containing the all of the instance variables in an 150391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner/// Objective-C object, in the order that they appear. Used to create LLVM 151391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner/// structures corresponding to Objective-C objects. 152391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattnervoid CodeGenTypes::CollectObjCIvarTypes(ObjCInterfaceDecl *ObjCClass, 153ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner std::vector<const llvm::Type*> &IvarTypes) { 154391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner ObjCInterfaceDecl *SuperClass = ObjCClass->getSuperClass(); 155ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner if (SuperClass) 156391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner CollectObjCIvarTypes(SuperClass, IvarTypes); 157ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner for (ObjCInterfaceDecl::ivar_iterator I = ObjCClass->ivar_begin(), 158ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner E = ObjCClass->ivar_end(); I != E; ++I) { 159ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner IvarTypes.push_back(ConvertType((*I)->getType())); 160ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner ObjCIvarInfo[*I] = IvarTypes.size() - 1; 161391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner } 162391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner} 16319009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner 1644111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattnerconst llvm::Type *CodeGenTypes::ConvertReturnType(QualType T) { 1654111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner if (T->isVoidType()) 1664111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner return llvm::Type::VoidTy; // Result of function uses llvm void. 1674111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner else 1684111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner return ConvertType(T); 1694111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner} 1704111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner 171b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattnerstatic const llvm::Type* getTypeForFormat(const llvm::fltSemantics &format) { 172b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::IEEEsingle) 173f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return llvm::Type::FloatTy; 174b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::IEEEdouble) 175f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return llvm::Type::DoubleTy; 176b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::IEEEquad) 177f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return llvm::Type::FP128Ty; 178b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::PPCDoubleDouble) 179f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return llvm::Type::PPC_FP128Ty; 180b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::x87DoubleExtended) 181f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return llvm::Type::X86_FP80Ty; 182b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner assert(0 && "Unknown float format!"); 183f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return 0; 184f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman} 185f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman 18630ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patelconst llvm::Type *CodeGenTypes::ConvertNewType(QualType T) { 1875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const clang::Type &Ty = *T.getCanonicalType(); 1885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Ty.getTypeClass()) { 190d14faaa7ecbdf1dae6fa4b005b2993ba3ce30770Chris Lattner case Type::TypeName: // typedef isn't canonical. 191d14faaa7ecbdf1dae6fa4b005b2993ba3ce30770Chris Lattner case Type::TypeOfExp: // typeof isn't canonical. 192d14faaa7ecbdf1dae6fa4b005b2993ba3ce30770Chris Lattner case Type::TypeOfTyp: // typeof isn't canonical. 193d14faaa7ecbdf1dae6fa4b005b2993ba3ce30770Chris Lattner assert(0 && "Non-canonical type, shouldn't happen"); 1945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Builtin: { 1955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (cast<BuiltinType>(Ty).getKind()) { 1965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Void: 1975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // LLVM void type can only be used as the result of a function call. Just 1985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // map to the same as char. 199d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner return llvm::IntegerType::get(8); 2005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Bool: 20219009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner // Note that we always return bool as i1 for use as a scalar type. 2035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return llvm::Type::Int1Ty; 2045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 205d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::Char_S: 206d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::Char_U: 207d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::SChar: 208d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::UChar: 2095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Short: 2105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::UShort: 2115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Int: 2125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::UInt: 2135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Long: 2145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::ULong: 2155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::LongLong: 2165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::ULongLong: 21747f7dbf7c0b25505ad093a317983a9b39efe0610Chris Lattner return llvm::IntegerType::get( 21898be4943e8dc4f3905629a7102668960873cf863Chris Lattner static_cast<unsigned>(Context.getTypeSize(T))); 2195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 220f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman case BuiltinType::Float: 221c8b1227fa8c17d9881815e40c04e19334be536f8Nate Begeman case BuiltinType::Double: 2225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::LongDouble: 223b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner return getTypeForFormat(Context.getFloatTypeSemantics(T)); 2245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 2265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Complex: { 228572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner const llvm::Type *EltTy = 229fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner ConvertTypeRecursive(cast<ComplexType>(Ty).getElementType()); 230572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner return llvm::StructType::get(EltTy, EltTy, NULL); 2315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 232bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner case Type::Reference: 2335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Pointer: { 234fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner const PointerLikeType &PTy = cast<PointerLikeType>(Ty); 235fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner QualType ETy = PTy.getPointeeType(); 236fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner llvm::OpaqueType *PointeeType = llvm::OpaqueType::get(); 237fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner PointersToResolve.push_back(std::make_pair(&PTy, PointeeType)); 238fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return llvm::PointerType::get(PointeeType, ETy.getAddressSpace()); 2395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 241fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case Type::VariableArray: { 242fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff const VariableArrayType &A = cast<VariableArrayType>(Ty); 243c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman assert(A.getIndexTypeQualifier() == 0 && 2445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer "FIXME: We only handle trivial array types so far!"); 245c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // VLAs resolve to the innermost element type; this matches 246c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // the return of alloca, and there isn't any obviously better choice. 247fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return ConvertTypeRecursive(A.getElementType()); 248c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman } 249c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman case Type::IncompleteArray: { 250c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman const IncompleteArrayType &A = cast<IncompleteArrayType>(Ty); 251c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman assert(A.getIndexTypeQualifier() == 0 && 252c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman "FIXME: We only handle trivial array types so far!"); 253c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // int X[] -> [0 x int] 254fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return llvm::ArrayType::get(ConvertTypeRecursive(A.getElementType()), 0); 2555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 256fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case Type::ConstantArray: { 257fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff const ConstantArrayType &A = cast<ConstantArrayType>(Ty); 258fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner const llvm::Type *EltTy = ConvertTypeRecursive(A.getElementType()); 259fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff return llvm::ArrayType::get(EltTy, A.getSize().getZExtValue()); 260fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff } 261213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman case Type::ExtVector: 2625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Vector: { 2635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const VectorType &VT = cast<VectorType>(Ty); 264fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return llvm::VectorType::get(ConvertTypeRecursive(VT.getElementType()), 2655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer VT.getNumElements()); 2665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::FunctionNoProto: 2685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::FunctionProto: { 2695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const FunctionType &FP = cast<FunctionType>(Ty); 2705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const llvm::Type *ResultType; 2715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (FP.getResultType()->isVoidType()) 2735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ResultType = llvm::Type::VoidTy; // Result of function uses llvm void. 2745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer else 275fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner ResultType = ConvertTypeRecursive(FP.getResultType()); 2765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // FIXME: Convert argument types. 2785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer bool isVarArg; 2795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer std::vector<const llvm::Type*> ArgTys; 2805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Struct return passes the struct byref. 282d79a726dc3c8af61b486948c97a183c7fe5b0179Dan Gohman if (!ResultType->isSingleValueType() && ResultType != llvm::Type::VoidTy) { 283fae6e2994a51d8ec1e61b6eb68765247c83b1ccfChris Lattner ArgTys.push_back(llvm::PointerType::get(ResultType, 284fae6e2994a51d8ec1e61b6eb68765247c83b1ccfChris Lattner FP.getResultType().getAddressSpace())); 2855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ResultType = llvm::Type::VoidTy; 2865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const FunctionTypeProto *FTP = dyn_cast<FunctionTypeProto>(&FP)) { 2895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer DecodeArgumentTypes(*FTP, ArgTys); 2905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer isVarArg = FTP->isVariadic(); 2915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } else { 2925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer isVarArg = true; 2935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2954ef9be79ca5cb133f95d3446aa20d8261806dbefChris Lattner return llvm::FunctionType::get(ResultType, ArgTys, isVarArg); 2965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 297ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb 298ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb case Type::ASQual: 299fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return 300fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner ConvertTypeRecursive(QualType(cast<ASQualType>(Ty).getBaseType(), 0)); 301b1776cb8d35dfa80bfd8606e58b8ade30dcd2438Chris Lattner 302391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner case Type::ObjCInterface: { 303391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // Warning: Use of this is strongly discouraged. Late binding of instance 304391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // variables is supported on some runtimes and so using static binding can 305391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // break code when libraries are updated. Only use this if you have 306391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // previously checked that the ObjCRuntime subclass in use does not support 307391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // late-bound ivars. 308391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner ObjCInterfaceType OIT = cast<ObjCInterfaceType>(Ty); 309391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner std::vector<const llvm::Type*> IvarTypes; 310391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner CollectObjCIvarTypes(OIT.getDecl(), IvarTypes); 311391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner return llvm::StructType::get(IvarTypes); 312391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner } 313e37882ad335896dedf345102bb425383e6221c37Fariborz Jahanian 314a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek case Type::ObjCQualifiedInterface: 315e37882ad335896dedf345102bb425383e6221c37Fariborz Jahanian assert(0 && "FIXME: add missing functionality here"); 316e37882ad335896dedf345102bb425383e6221c37Fariborz Jahanian break; 317b1776cb8d35dfa80bfd8606e58b8ade30dcd2438Chris Lattner 318a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek case Type::ObjCQualifiedId: 319c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian assert(0 && "FIXME: add missing functionality here"); 320c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian break; 321c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian 322de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner case Type::Tagged: { 323de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner const TagDecl *TD = cast<TagType>(Ty).getDecl(); 3248fb1dd005f4cb530bca11d622362d39727294420Chris Lattner const llvm::Type *Res = ConvertTagDeclType(TD); 325de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner 326de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner std::string TypeName(TD->getKindName()); 327de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner TypeName += '.'; 328de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner 329de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner // Name the codegen type after the typedef name 330de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner // if there is no tag type name available 331de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner if (TD->getIdentifier()) 332de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner TypeName += TD->getName(); 333de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner else if (const TypedefType *TdT = dyn_cast<TypedefType>(T)) 334de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner TypeName += TdT->getDecl()->getName(); 335de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner else 336de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner TypeName += "anon"; 337de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner 338de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner TheModule.addTypeName(TypeName, Res); 339de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner return Res; 340de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner } 3415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // FIXME: implement. 3445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return llvm::OpaqueType::get(); 3455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid CodeGenTypes::DecodeArgumentTypes(const FunctionTypeProto &FTP, 3485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer std::vector<const llvm::Type*> &ArgTys) { 3495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0, e = FTP.getNumArgs(); i != e; ++i) { 350fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner const llvm::Type *Ty = ConvertTypeRecursive(FTP.getArgType(i)); 351d79a726dc3c8af61b486948c97a183c7fe5b0179Dan Gohman if (Ty->isSingleValueType()) 3525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ArgTys.push_back(Ty); 353fae6e2994a51d8ec1e61b6eb68765247c83b1ccfChris Lattner else 354fae6e2994a51d8ec1e61b6eb68765247c83b1ccfChris Lattner // byval arguments are always on the stack, which is addr space #0. 355fae6e2994a51d8ec1e61b6eb68765247c83b1ccfChris Lattner ArgTys.push_back(llvm::PointerType::getUnqual(Ty)); 3565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 359fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner/// ConvertTagDeclType - Lay out a tagged decl type like struct or union or 360fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner/// enum. 3618fb1dd005f4cb530bca11d622362d39727294420Chris Lattnerconst llvm::Type *CodeGenTypes::ConvertTagDeclType(const TagDecl *TD) { 362fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner llvm::DenseMap<const TagDecl*, llvm::PATypeHolder>::iterator TDTI = 363fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner TagDeclTypes.find(TD); 364fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 3655de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // If we've already compiled this tag type, use the previous definition. 3665de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner if (TDTI != TagDeclTypes.end()) 367fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner return TDTI->second; 368fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 3695de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // If this is still a forward definition, just define an opaque type to use 3705de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // for this tagged decl. 371fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner if (!TD->isDefinition()) { 3725de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner llvm::Type *ResultType = llvm::OpaqueType::get(); 373fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner TagDeclTypes.insert(std::make_pair(TD, ResultType)); 3745de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner return ResultType; 3755de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner } 3765de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 3775de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // Okay, this is a definition of a type. Compile the implementation now. 3785de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 37939ba4aeca296b1c9f04bde7d9d3cbbf129f1abd3Argyrios Kyrtzidis if (TD->isEnum()) { 380fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner // Don't bother storing enums in TagDeclTypes. 381fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return ConvertTypeRecursive(cast<EnumDecl>(TD)->getIntegerType()); 3825de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner } 3835de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 3845de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // This decl could well be recursive. In this case, insert an opaque 3855de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // definition of this type, which the recursive uses will get. We will then 3865de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // refine this opaque version later. 3875de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 3885de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // Create new OpaqueType now for later use in case this is a recursive 3895de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // type. This will later be refined to the actual type. 3905de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner llvm::PATypeHolder ResultHolder = llvm::OpaqueType::get(); 3915de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner TagDeclTypes.insert(std::make_pair(TD, ResultHolder)); 3925de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 3935de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner const llvm::Type *ResultType; 3945de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner const RecordDecl *RD = cast<const RecordDecl>(TD); 39539ba4aeca296b1c9f04bde7d9d3cbbf129f1abd3Argyrios Kyrtzidis if (TD->isStruct() || TD->isClass()) { 396fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner // Layout fields. 397cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman RecordOrganizer RO(*this, *RD); 398fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 39998be4943e8dc4f3905629a7102668960873cf863Chris Lattner RO.layoutStructFields(Context.getASTRecordLayout(RD)); 400fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 4015de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // Get llvm::StructType. 4025de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner CGRecordLayouts[TD] = new CGRecordLayout(RO.getLLVMType(), 4035de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner RO.getPaddingFields()); 4045de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner ResultType = RO.getLLVMType(); 405fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 40639ba4aeca296b1c9f04bde7d9d3cbbf129f1abd3Argyrios Kyrtzidis } else if (TD->isUnion()) { 407fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner // Just use the largest element of the union, breaking ties with the 408fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner // highest aligned member. 409fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner if (RD->getNumMembers() != 0) { 410cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman RecordOrganizer RO(*this, *RD); 4115de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 412cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman RO.layoutUnionFields(Context.getASTRecordLayout(RD)); 4135de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 4145de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // Get llvm::StructType. 4155de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner CGRecordLayouts[TD] = new CGRecordLayout(RO.getLLVMType(), 4165de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner RO.getPaddingFields()); 4175de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner ResultType = RO.getLLVMType(); 418fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner } else { 4195de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner ResultType = llvm::StructType::get(std::vector<const llvm::Type*>()); 420fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner } 421fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner } else { 422fae6e2994a51d8ec1e61b6eb68765247c83b1ccfChris Lattner assert(0 && "FIXME: Unknown tag decl kind!"); 423fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner } 424fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 4255de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // Refine our Opaque type to ResultType. This can invalidate ResultType, so 4265de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // make sure to read the result out of the holder. 4275de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner cast<llvm::OpaqueType>(ResultHolder.get()) 4285de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner ->refineAbstractTypeTo(ResultType); 4295de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 4305de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner return ResultHolder.get(); 431fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner} 432fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 433b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel/// getLLVMFieldNo - Return llvm::StructType element number 434b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel/// that corresponds to the field FD. 435b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patelunsigned CodeGenTypes::getLLVMFieldNo(const FieldDecl *FD) { 436ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner llvm::DenseMap<const FieldDecl*, unsigned>::iterator I = FieldInfo.find(FD); 43721fdf416723e8c475812a0324a1f9fafc949c25fHartmut Kaiser assert (I != FieldInfo.end() && "Unable to find field info"); 438b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel return I->second; 439b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel} 440b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel 441391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattnerunsigned CodeGenTypes::getLLVMFieldNo(const ObjCIvarDecl *OID) { 442391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner llvm::DenseMap<const ObjCIvarDecl*, unsigned>::iterator 443391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner I = ObjCIvarInfo.find(OID); 444ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner assert(I != ObjCIvarInfo.end() && "Unable to find field info"); 445391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner return I->second; 446391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner} 447391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 448c4c429a1a5947ba9be64d3070741d98362872265Devang Patel/// addFieldInfo - Assign field number to field FD. 4492c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venanciovoid CodeGenTypes::addFieldInfo(const FieldDecl *FD, unsigned No) { 4502c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio FieldInfo[FD] = No; 4512c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio} 4522c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio 4532c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio/// getBitFieldInfo - Return the BitFieldInfo that corresponds to the field FD. 4542c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos VenancioCodeGenTypes::BitFieldInfo CodeGenTypes::getBitFieldInfo(const FieldDecl *FD) { 4552c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio llvm::DenseMap<const FieldDecl *, BitFieldInfo>::iterator 4562c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio I = BitFields.find(FD); 4572c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio assert (I != BitFields.end() && "Unable to find bitfield info"); 4582c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio return I->second; 4592c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio} 4602c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio 4612c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio/// addBitFieldInfo - Assign a start bit and a size to field FD. 4622c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venanciovoid CodeGenTypes::addBitFieldInfo(const FieldDecl *FD, unsigned Begin, 4631abc7f654df795549d4f6f3a018ddb3a8fff013aNate Begeman unsigned Size) { 4642c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio BitFields.insert(std::make_pair(FD, BitFieldInfo(Begin, Size))); 465b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel} 466b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel 46788a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel/// getCGRecordLayout - Return record layout info for the given llvm::Type. 46888a981b47c7face1b1fdaa9074256245107b9ca9Devang Patelconst CGRecordLayout * 469af31913e48c96fddb45a0fd33f25617546502cbbChris LattnerCodeGenTypes::getCGRecordLayout(const TagDecl *TD) const { 470af31913e48c96fddb45a0fd33f25617546502cbbChris Lattner llvm::DenseMap<const TagDecl*, CGRecordLayout *>::iterator I 471af31913e48c96fddb45a0fd33f25617546502cbbChris Lattner = CGRecordLayouts.find(TD); 47288a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel assert (I != CGRecordLayouts.end() 473b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel && "Unable to find record layout information for type"); 474b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel return I->second; 475b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel} 476b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel 47786522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel/// layoutStructFields - Do the actual work and lay out all fields. Create 478cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman/// corresponding llvm struct type. 479cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman/// Note that this doesn't actually try to do struct layout; it depends on 480cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman/// the layout built by the AST. (We have to do struct layout to do Sema, 481cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman/// and there's no point to duplicating the work.) 48288a981b47c7face1b1fdaa9074256245107b9ca9Devang Patelvoid RecordOrganizer::layoutStructFields(const ASTRecordLayout &RL) { 483e36a3c8b5c7db4916342e4381caa2fdc93eb5745Eli Friedman // FIXME: This code currently always generates packed structures. 484e36a3c8b5c7db4916342e4381caa2fdc93eb5745Eli Friedman // Unpacked structures are more readable, and sometimes more efficient! 485e36a3c8b5c7db4916342e4381caa2fdc93eb5745Eli Friedman // (But note that any changes here are likely to impact CGExprConstant, 486e36a3c8b5c7db4916342e4381caa2fdc93eb5745Eli Friedman // which makes some messy assumptions.) 487cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman uint64_t llvmSize = 0; 488e36a3c8b5c7db4916342e4381caa2fdc93eb5745Eli Friedman // FIXME: Make this a SmallVector 489cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman std::vector<const llvm::Type*> LLVMFields; 490cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman int NumMembers = RD.getNumMembers(); 491cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman 492cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman for (int curField = 0; curField < NumMembers; curField++) { 493cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman const FieldDecl *FD = RD.getMember(curField); 494cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman uint64_t offset = RL.getFieldOffset(curField); 495cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman const llvm::Type *Ty = CGT.ConvertTypeRecursive(FD->getType()); 496b853ca876e92ea6e171bd7bb5d161fcbc9e9b032Eli Friedman uint64_t size = CGT.getTargetData().getABITypeSizeInBits(Ty); 497cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman 498cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman if (FD->isBitField()) { 499cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman Expr *BitWidth = FD->getBitWidth(); 500cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman llvm::APSInt FieldSize(32); 501cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman bool isBitField = 502cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman BitWidth->isIntegerConstantExpr(FieldSize, CGT.getContext()); 503cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman assert (isBitField && "Invalid BitField size expression"); 504cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman uint64_t BitFieldSize = FieldSize.getZExtValue(); 505cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman 506cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // Bitfield field info is different from other field info; 507cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // it actually ignores the underlying LLVM struct because 508cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // there isn't any convenient mapping. 509cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman CGT.addFieldInfo(FD, offset / size); 510cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman CGT.addBitFieldInfo(FD, offset % size, BitFieldSize); 511cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman } else { 512cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // Put the element into the struct. This would be simpler 513cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // if we didn't bother, but it seems a bit too strange to 514cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // allocate all structs as i8 arrays. 515cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman while (llvmSize < offset) { 516cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman LLVMFields.push_back(llvm::Type::Int8Ty); 517cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman llvmSize += 8; 518d8ecd3c8f7716124e1efb278a46b6747c697668dDevang Patel } 5196e8df736939325bc2355eeb1e138ecf8b2605616Devang Patel 520cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman llvmSize += size; 521cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman CGT.addFieldInfo(FD, LLVMFields.size()); 522cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman LLVMFields.push_back(Ty); 523cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman } 524cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman } 525f9fef925644a6c40b344a43ab9ebdb08a707de53Devang Patel 526cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman while (llvmSize < RL.getSize()) { 527cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman LLVMFields.push_back(llvm::Type::Int8Ty); 528cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman llvmSize += 8; 5292c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio } 530159e3300f938ae05c0bf249508714e621cc89de5Devang Patel 5310408f6805c164f317937e97d7bc222781164bfebEli Friedman STy = llvm::StructType::get(LLVMFields, true); 532cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman assert(CGT.getTargetData().getABITypeSizeInBits(STy) == RL.getSize()); 533b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel} 534c4c429a1a5947ba9be64d3070741d98362872265Devang Patel 53586522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel/// layoutUnionFields - Do the actual work and lay out all fields. Create 53686522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel/// corresponding llvm struct type. This should be invoked only after 53786522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel/// all fields are added. 538cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedmanvoid RecordOrganizer::layoutUnionFields(const ASTRecordLayout &RL) { 539cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman for (int curField = 0; curField < RD.getNumMembers(); curField++) { 540cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman const FieldDecl *FD = RD.getMember(curField); 541cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // The offset should usually be zero, but bitfields could be strange 542cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman uint64_t offset = RL.getFieldOffset(curField); 543cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman 544cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman if (FD->isBitField()) { 545cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman Expr *BitWidth = FD->getBitWidth(); 546cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman llvm::APSInt FieldSize(32); 547cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman bool isBitField = 548cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman BitWidth->isIntegerConstantExpr(FieldSize, CGT.getContext()); 549cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman assert (isBitField && "Invalid BitField size expression"); 550cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman uint64_t BitFieldSize = FieldSize.getZExtValue(); 55186522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel 5525cada6bd7f0a9f1c0f82613924610177d676ced5Devang Patel CGT.addFieldInfo(FD, 0); 553cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman CGT.addBitFieldInfo(FD, offset, BitFieldSize); 554cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman } else { 555cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman CGT.addFieldInfo(FD, 0); 556cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman } 55786522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel } 55886522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel 559cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // This looks stupid, but it is correct in the sense that 560cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // it works no matter how complicated the sizes and alignments 561cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // of the union elements are. The natural alignment 562cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // of the result doesn't matter because anyone allocating 563cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // structures should be aligning them appropriately anyway. 564cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // FIXME: We can be a bit more intuitive in a lot of cases. 565cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman STy = llvm::ArrayType::get(llvm::Type::Int8Ty, RL.getSize() / 8); 566cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman assert(CGT.getTargetData().getABITypeSizeInBits(STy) == RL.getSize()); 567382c64365247fa01e2711da27ef4bef0653afca4Devang Patel} 568