CodeGenTypes.cpp revision 696798febaf1f69020cdf7474b91e71736c5aa69
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" 15de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/ASTContext.h" 16c4a1dea2dc56bd1357ec91b829a0b9e68229a13eDaniel Dunbar#include "clang/AST/DeclObjC.h" 17742cd1b7bb86b52b23b335d47abbd842dac0e1bfFariborz Jahanian#include "clang/AST/DeclCXX.h" 18de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/Expr.h" 1919cc4abea06a9b49e0e16a50d335c064cd723572Anders Carlsson#include "clang/AST/RecordLayout.h" 205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "llvm/DerivedTypes.h" 214e533287e6a9adac78c9ac370612581aad9b8c5eAnders Carlsson#include "llvm/Module.h" 22d9e9ede6b1703849da739629904dad197306e527Devang Patel#include "llvm/Target/TargetData.h" 235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2445c25ba11cbf8c9a461def5b03f6ee9481e06769Daniel Dunbar#include "CGCall.h" 2545372a6fdcd2b0840704569478db456822e02baeAnders Carlsson#include "CGRecordLayoutBuilder.h" 2645c25ba11cbf8c9a461def5b03f6ee9481e06769Daniel Dunbar 275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace CodeGen; 295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 30057afddf0fab91d979d6a750667d56a345225c96Devang Patelnamespace { 3188a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel /// RecordOrganizer - This helper class, used by CGRecordLayout, layouts 32057afddf0fab91d979d6a750667d56a345225c96Devang Patel /// structs and unions. It manages transient information used during layout. 334c4635c6cd8114bfa3ee20628fa1f03e67ac1e55Devang Patel /// FIXME : Handle field aligments. Handle packed structs. 34057afddf0fab91d979d6a750667d56a345225c96Devang Patel class RecordOrganizer { 35057afddf0fab91d979d6a750667d56a345225c96Devang Patel public: 36cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman explicit RecordOrganizer(CodeGenTypes &Types, const RecordDecl& Record) : 37cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman CGT(Types), RD(Record), STy(NULL) {} 380bd41f2cea0639395e8ab7ef8fd6df2c1999b6aeDevang Patel 3986522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel /// layoutStructFields - Do the actual work and lay out all fields. Create 40057afddf0fab91d979d6a750667d56a345225c96Devang Patel /// corresponding llvm struct type. This should be invoked only after 41057afddf0fab91d979d6a750667d56a345225c96Devang Patel /// all fields are added. 4288a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel void layoutStructFields(const ASTRecordLayout &RL); 4386522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel 4486522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel /// layoutUnionFields - Do the actual work and lay out all fields. Create 4586522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel /// corresponding llvm struct type. This should be invoked only after 4686522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel /// all fields are added. 47cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman void layoutUnionFields(const ASTRecordLayout &RL); 48057afddf0fab91d979d6a750667d56a345225c96Devang Patel 49057afddf0fab91d979d6a750667d56a345225c96Devang Patel /// getLLVMType - Return associated llvm struct type. This may be NULL 50057afddf0fab91d979d6a750667d56a345225c96Devang Patel /// if fields are not laid out. 51057afddf0fab91d979d6a750667d56a345225c96Devang Patel llvm::Type *getLLVMType() const { 52057afddf0fab91d979d6a750667d56a345225c96Devang Patel return STy; 53057afddf0fab91d979d6a750667d56a345225c96Devang Patel } 54057afddf0fab91d979d6a750667d56a345225c96Devang Patel 55eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel llvm::SmallSet<unsigned, 8> &getPaddingFields() { 565bfc1a7ecb853cf87d10e720a07b9fbcd2a223eeDevang Patel return PaddingFields; 575bfc1a7ecb853cf87d10e720a07b9fbcd2a223eeDevang Patel } 585bfc1a7ecb853cf87d10e720a07b9fbcd2a223eeDevang Patel 59057afddf0fab91d979d6a750667d56a345225c96Devang Patel private: 60f9fef925644a6c40b344a43ab9ebdb08a707de53Devang Patel CodeGenTypes &CGT; 61cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman const RecordDecl& RD; 62057afddf0fab91d979d6a750667d56a345225c96Devang Patel llvm::Type *STy; 63eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel llvm::SmallSet<unsigned, 8> PaddingFields; 64057afddf0fab91d979d6a750667d56a345225c96Devang Patel }; 65057afddf0fab91d979d6a750667d56a345225c96Devang Patel} 66057afddf0fab91d979d6a750667d56a345225c96Devang Patel 677a4718e813e5e99d478567a482217c7eef8572c5Devang PatelCodeGenTypes::CodeGenTypes(ASTContext &Ctx, llvm::Module& M, 687a4718e813e5e99d478567a482217c7eef8572c5Devang Patel const llvm::TargetData &TD) 696b1da0ea19c12346192f5ea4d70872c13bfcc82aDaniel Dunbar : Context(Ctx), Target(Ctx.Target), TheModule(M), TheTargetData(TD), 706b1da0ea19c12346192f5ea4d70872c13bfcc82aDaniel Dunbar TheABIInfo(0) { 71d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner} 725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 73b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang PatelCodeGenTypes::~CodeGenTypes() { 74efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar for(llvm::DenseMap<const Type *, CGRecordLayout *>::iterator 7588a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel I = CGRecordLayouts.begin(), E = CGRecordLayouts.end(); 76b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel I != E; ++I) 77b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel delete I->second; 7888a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel CGRecordLayouts.clear(); 79b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel} 80b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel 815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// ConvertType - Convert the specified type to its LLVM form. 825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst llvm::Type *CodeGenTypes::ConvertType(QualType T) { 83fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner llvm::PATypeHolder Result = ConvertTypeRecursive(T); 84fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner 85fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // Any pointers that were converted defered evaluation of their pointee type, 86fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // creating an opaque type instead. This is in order to avoid problems with 87fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // circular types. Loop through all these defered pointees, if any, and 88fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // resolve them now. 89fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner while (!PointersToResolve.empty()) { 906aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar std::pair<QualType, llvm::OpaqueType*> P = 91fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner PointersToResolve.back(); 92fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner PointersToResolve.pop_back(); 93fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // We can handle bare pointers here because we know that the only pointers 94fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // to the Opaque type are P.second and from other types. Refining the 95fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // opqaue type away will invalidate P.second, but we don't mind :). 9657a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman const llvm::Type *NT = ConvertTypeForMemRecursive(P.first); 97fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner P.second->refineAbstractTypeTo(NT); 98fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner } 99fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner 100fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return Result; 101fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner} 102fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner 103fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattnerconst llvm::Type *CodeGenTypes::ConvertTypeRecursive(QualType T) { 10409dc6660487fc2f4a4bb2032e30123d3e0da7230Chris Lattner T = Context.getCanonicalType(T); 1059619662a1d42e2008b865d3459c0677e149dad1bChris Lattner 10630ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel // See if type is already cached. 1070ffe89ab1e4890899e0e11a6f68223567a69b38aDevang Patel llvm::DenseMap<Type *, llvm::PATypeHolder>::iterator 1089619662a1d42e2008b865d3459c0677e149dad1bChris Lattner I = TypeCache.find(T.getTypePtr()); 1093c40085b373d8e6e4523812e06f73a0cb9d5142cDevang Patel // If type is found in map and this is not a definition for a opaque 110fae6e2994a51d8ec1e61b6eb68765247c83b1ccfChris Lattner // place holder type then use it. Otherwise, convert type T. 1114581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner if (I != TypeCache.end()) 11247c87b4b160d45285b24b1b7f4e3cbaaed3dc464Devang Patel return I->second.get(); 11330ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel 11430ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel const llvm::Type *ResultType = ConvertNewType(T); 1159619662a1d42e2008b865d3459c0677e149dad1bChris Lattner TypeCache.insert(std::make_pair(T.getTypePtr(), 1164581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner llvm::PATypeHolder(ResultType))); 11730ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel return ResultType; 11830ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel} 11930ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel 12057a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedmanconst llvm::Type *CodeGenTypes::ConvertTypeForMemRecursive(QualType T) { 12157a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman const llvm::Type *ResultType = ConvertTypeRecursive(T); 12257a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman if (ResultType == llvm::Type::Int1Ty) 12357a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman return llvm::IntegerType::get((unsigned)Context.getTypeSize(T)); 12457a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman return ResultType; 12557a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman} 12657a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman 1274581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// ConvertTypeForMem - Convert type T into a llvm::Type. This differs from 1284581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// ConvertType in that it is used to convert to the memory representation for 1294581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// a type. For example, the scalar representation for _Bool is i1, but the 1304581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// memory representation is usually i8 or i32, depending on the target. 13119009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattnerconst llvm::Type *CodeGenTypes::ConvertTypeForMem(QualType T) { 13219009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner const llvm::Type *R = ConvertType(T); 13319009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner 13419009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner // If this is a non-bool type, don't map it. 13519009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner if (R != llvm::Type::Int1Ty) 13619009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner return R; 13719009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner 13819009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner // Otherwise, return an integer of the target-specified size. 13998be4943e8dc4f3905629a7102668960873cf863Chris Lattner return llvm::IntegerType::get((unsigned)Context.getTypeSize(T)); 14019009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner 14119009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner} 14219009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner 143b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman// Code to verify a given function type is complete, i.e. the return type 144b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman// and all of the argument types are complete. 145b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedmanstatic const TagType *VerifyFuncTypeComplete(const Type* T) { 146b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman const FunctionType *FT = cast<FunctionType>(T); 14735366a67baa970c287c714c957cf78a4131cf60dTed Kremenek if (const TagType* TT = FT->getResultType()->getAsTagType()) 148b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman if (!TT->getDecl()->isDefinition()) 149b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman return TT; 150b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(T)) 151b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman for (unsigned i = 0; i < FPT->getNumArgs(); i++) 15235366a67baa970c287c714c957cf78a4131cf60dTed Kremenek if (const TagType* TT = FPT->getArgType(i)->getAsTagType()) 153b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman if (!TT->getDecl()->isDefinition()) 154b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman return TT; 155b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman return 0; 156b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman} 157b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman 158c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattner/// UpdateCompletedType - When we find the full definition for a TagDecl, 159c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattner/// replace the 'opaque' type we previously made for it if applicable. 160c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattnervoid CodeGenTypes::UpdateCompletedType(const TagDecl *TD) { 161efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar const Type *Key = 162efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar Context.getTagDeclType(const_cast<TagDecl*>(TD)).getTypePtr(); 163efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar llvm::DenseMap<const Type*, llvm::PATypeHolder>::iterator TDTI = 164efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar TagDeclTypes.find(Key); 1656ef58e36bbbfa232fe8b50309361e841985abfc6Chris Lattner if (TDTI == TagDeclTypes.end()) return; 1666ef58e36bbbfa232fe8b50309361e841985abfc6Chris Lattner 1676ef58e36bbbfa232fe8b50309361e841985abfc6Chris Lattner // Remember the opaque LLVM type for this tagdecl. 168d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner llvm::PATypeHolder OpaqueHolder = TDTI->second; 169d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner assert(isa<llvm::OpaqueType>(OpaqueHolder.get()) && 1706ef58e36bbbfa232fe8b50309361e841985abfc6Chris Lattner "Updating compilation of an already non-opaque type?"); 171d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 172d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner // Remove it from TagDeclTypes so that it will be regenerated. 173d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner TagDeclTypes.erase(TDTI); 174d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 1758fb1dd005f4cb530bca11d622362d39727294420Chris Lattner // Generate the new type. 1768fb1dd005f4cb530bca11d622362d39727294420Chris Lattner const llvm::Type *NT = ConvertTagDeclType(TD); 177d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 1788fb1dd005f4cb530bca11d622362d39727294420Chris Lattner // Refine the old opaque type to its new definition. 1798fb1dd005f4cb530bca11d622362d39727294420Chris Lattner cast<llvm::OpaqueType>(OpaqueHolder.get())->refineAbstractTypeTo(NT); 180b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman 181b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // Since we just completed a tag type, check to see if any function types 182b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // were completed along with the tag type. 183b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // FIXME: This is very inefficient; if we track which function types depend 184b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // on which tag types, though, it should be reasonably efficient. 185b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman llvm::DenseMap<const Type*, llvm::PATypeHolder>::iterator i; 186b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman for (i = FunctionTypes.begin(); i != FunctionTypes.end(); ++i) { 187b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman if (const TagType* TT = VerifyFuncTypeComplete(i->first)) { 188b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // This function type still depends on an incomplete tag type; make sure 189b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // that tag type has an associated opaque type. 190b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman ConvertTagDeclType(TT->getDecl()); 191b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman } else { 192b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // This function no longer depends on an incomplete tag type; create the 193b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // function type, and refine the opaque type to the new function type. 194b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman llvm::PATypeHolder OpaqueHolder = i->second; 195b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman const llvm::Type *NFT = ConvertNewType(QualType(i->first, 0)); 196b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman cast<llvm::OpaqueType>(OpaqueHolder.get())->refineAbstractTypeTo(NFT); 197b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman FunctionTypes.erase(i); 198b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman } 199b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman } 200d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner} 201d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 202b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattnerstatic const llvm::Type* getTypeForFormat(const llvm::fltSemantics &format) { 203b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::IEEEsingle) 204f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return llvm::Type::FloatTy; 205b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::IEEEdouble) 206f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return llvm::Type::DoubleTy; 207b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::IEEEquad) 208f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return llvm::Type::FP128Ty; 209b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::PPCDoubleDouble) 210f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return llvm::Type::PPC_FP128Ty; 211b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::x87DoubleExtended) 212f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return llvm::Type::X86_FP80Ty; 213b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner assert(0 && "Unknown float format!"); 214f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return 0; 215f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman} 216f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman 21730ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patelconst llvm::Type *CodeGenTypes::ConvertNewType(QualType T) { 2189619662a1d42e2008b865d3459c0677e149dad1bChris Lattner const clang::Type &Ty = *Context.getCanonicalType(T); 2195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Ty.getTypeClass()) { 22172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define TYPE(Class, Base) 22272564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define ABSTRACT_TYPE(Class, Base) 22372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 22472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define DEPENDENT_TYPE(Class, Base) case Type::Class: 22572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#include "clang/AST/TypeNodes.def" 22672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor assert(false && "Non-canonical or dependent types aren't possible."); 22772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor break; 22872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 2295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Builtin: { 2305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (cast<BuiltinType>(Ty).getKind()) { 231afef76e43a30380b3c612a674738f2f574c8f166Argyrios Kyrtzidis default: assert(0 && "Unknown builtin type!"); 2325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Void: 233de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff case BuiltinType::ObjCId: 234de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff case BuiltinType::ObjCClass: 2355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // LLVM void type can only be used as the result of a function call. Just 2365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // map to the same as char. 237d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner return llvm::IntegerType::get(8); 2385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Bool: 24019009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner // Note that we always return bool as i1 for use as a scalar type. 2415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return llvm::Type::Int1Ty; 2425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 243d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::Char_S: 244d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::Char_U: 245d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::SChar: 246d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::UChar: 2475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Short: 2485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::UShort: 2495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Int: 2505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::UInt: 2515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Long: 2525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::ULong: 2535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::LongLong: 2545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::ULongLong: 255afef76e43a30380b3c612a674738f2f574c8f166Argyrios Kyrtzidis case BuiltinType::WChar: 256f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case BuiltinType::Char16: 257f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case BuiltinType::Char32: 25847f7dbf7c0b25505ad093a317983a9b39efe0610Chris Lattner return llvm::IntegerType::get( 25998be4943e8dc4f3905629a7102668960873cf863Chris Lattner static_cast<unsigned>(Context.getTypeSize(T))); 2605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 261f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman case BuiltinType::Float: 262c8b1227fa8c17d9881815e40c04e19334be536f8Nate Begeman case BuiltinType::Double: 2635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::LongDouble: 264b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner return getTypeForFormat(Context.getFloatTypeSemantics(T)); 2652df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner 2662df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::UInt128: 2672df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::Int128: 2682df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner return llvm::IntegerType::get(128); 2695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 2715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 272f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman case Type::FixedWidthInt: 273f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return llvm::IntegerType::get(cast<FixedWidthIntType>(T)->getWidth()); 2745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Complex: { 275572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner const llvm::Type *EltTy = 276fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner ConvertTypeRecursive(cast<ComplexType>(Ty).getElementType()); 277572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner return llvm::StructType::get(EltTy, EltTy, NULL); 2785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2797c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl case Type::LValueReference: 2807c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl case Type::RValueReference: { 2816aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar const ReferenceType &RTy = cast<ReferenceType>(Ty); 2826aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar QualType ETy = RTy.getPointeeType(); 2836aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar llvm::OpaqueType *PointeeType = llvm::OpaqueType::get(); 2846aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar PointersToResolve.push_back(std::make_pair(ETy, PointeeType)); 2856aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar return llvm::PointerType::get(PointeeType, ETy.getAddressSpace()); 2866aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar } 2875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Pointer: { 2886aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar const PointerType &PTy = cast<PointerType>(Ty); 289fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner QualType ETy = PTy.getPointeeType(); 290fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner llvm::OpaqueType *PointeeType = llvm::OpaqueType::get(); 2916aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar PointersToResolve.push_back(std::make_pair(ETy, PointeeType)); 292fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return llvm::PointerType::get(PointeeType, ETy.getAddressSpace()); 2935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 295fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case Type::VariableArray: { 296fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff const VariableArrayType &A = cast<VariableArrayType>(Ty); 297c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman assert(A.getIndexTypeQualifier() == 0 && 2985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer "FIXME: We only handle trivial array types so far!"); 299c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // VLAs resolve to the innermost element type; this matches 300c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // the return of alloca, and there isn't any obviously better choice. 30157a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman return ConvertTypeForMemRecursive(A.getElementType()); 302c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman } 303c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman case Type::IncompleteArray: { 304c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman const IncompleteArrayType &A = cast<IncompleteArrayType>(Ty); 305c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman assert(A.getIndexTypeQualifier() == 0 && 306c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman "FIXME: We only handle trivial array types so far!"); 307c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // int X[] -> [0 x int] 30857a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman return llvm::ArrayType::get(ConvertTypeForMemRecursive(A.getElementType()), 0); 3095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 310fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case Type::ConstantArray: { 311fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff const ConstantArrayType &A = cast<ConstantArrayType>(Ty); 31257a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman const llvm::Type *EltTy = ConvertTypeForMemRecursive(A.getElementType()); 313fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff return llvm::ArrayType::get(EltTy, A.getSize().getZExtValue()); 314fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff } 315213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman case Type::ExtVector: 3165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Vector: { 3175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const VectorType &VT = cast<VectorType>(Ty); 318fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return llvm::VectorType::get(ConvertTypeRecursive(VT.getElementType()), 3195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer VT.getNumElements()); 3205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::FunctionNoProto: 322bb36d331f439f49859efcfb4435c61762fbba6f9Daniel Dunbar case Type::FunctionProto: { 323b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // First, check whether we can build the full function type. 324b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman if (const TagType* TT = VerifyFuncTypeComplete(&Ty)) { 325b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // This function's type depends on an incomplete tag type; make sure 326b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // we have an opaque type corresponding to the tag type. 327b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman ConvertTagDeclType(TT->getDecl()); 328b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // Create an opaque type for this function type, save it, and return it. 329b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman llvm::Type *ResultType = llvm::OpaqueType::get(); 330b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman FunctionTypes.insert(std::make_pair(&Ty, ResultType)); 331b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman return ResultType; 332b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman } 333b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // The function type can be built; call the appropriate routines to 334b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman // build it. 3359a1a9c41cf7e2735f059bb0c1d85f3207f637b22Chris Lattner if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(&Ty)) 336b3b6b9b27ab8bdb2a435a5a92ce62e74e3399377Eli Friedman return GetFunctionType(getFunctionInfo(FPT), FPT->isVariadic()); 3379a1a9c41cf7e2735f059bb0c1d85f3207f637b22Chris Lattner 3389a1a9c41cf7e2735f059bb0c1d85f3207f637b22Chris Lattner const FunctionNoProtoType *FNPT = cast<FunctionNoProtoType>(&Ty); 3399a1a9c41cf7e2735f059bb0c1d85f3207f637b22Chris Lattner return GetFunctionType(getFunctionInfo(FNPT), true); 340bb36d331f439f49859efcfb4435c61762fbba6f9Daniel Dunbar } 341ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb 342f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian case Type::ExtQual: 343fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return 344f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian ConvertTypeRecursive(QualType(cast<ExtQualType>(Ty).getBaseType(), 0)); 345b1776cb8d35dfa80bfd8606e58b8ade30dcd2438Chris Lattner 346391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner case Type::ObjCInterface: { 347412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar // Objective-C interfaces are always opaque (outside of the 348412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar // runtime, which can do whatever it likes); we never refine 349412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar // these. 350412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar const llvm::Type *&T = InterfaceTypes[cast<ObjCInterfaceType>(&Ty)]; 351412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar if (!T) 352412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar T = llvm::OpaqueType::get(); 353412f59b23fc502b199b9ca96c72ef5d5ad21d62bDaniel Dunbar return T; 354391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner } 355e37882ad335896dedf345102bb425383e6221c37Fariborz Jahanian 35614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff case Type::ObjCObjectPointer: { 35728e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar // Protocol qualifications do not influence the LLVM type, we just return a 35828e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar // pointer to the underlying interface type. We don't need to worry about 35928e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar // recursive conversion. 36028e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar const llvm::Type *T = 36128e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar ConvertTypeRecursive(cast<ObjCObjectPointerType>(Ty).getPointeeType()); 36228e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar return llvm::PointerType::getUnqual(T); 36314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 36428e478010eb4d789da85c6378dbfa9d66b95830bDaniel Dunbar 36572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Record: 36672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Enum: { 367de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner const TagDecl *TD = cast<TagType>(Ty).getDecl(); 3688fb1dd005f4cb530bca11d622362d39727294420Chris Lattner const llvm::Type *Res = ConvertTagDeclType(TD); 369de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner 370de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner std::string TypeName(TD->getKindName()); 371de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner TypeName += '.'; 372de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner 373de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner // Name the codegen type after the typedef name 374de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner // if there is no tag type name available 375de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner if (TD->getIdentifier()) 376d9d22dd9c94618490dbffb0e2caf222530ca39d3Chris Lattner TypeName += TD->getNameAsString(); 377de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner else if (const TypedefType *TdT = dyn_cast<TypedefType>(T)) 378d9d22dd9c94618490dbffb0e2caf222530ca39d3Chris Lattner TypeName += TdT->getDecl()->getNameAsString(); 379de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner else 380de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner TypeName += "anon"; 381de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner 382de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner TheModule.addTypeName(TypeName, Res); 383de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner return Res; 384de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner } 3859048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar 3869048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar case Type::BlockPointer: { 3874e174f1b1e95faacc21da2eac70f7853807f3ea3Daniel Dunbar const QualType FTy = cast<BlockPointerType>(Ty).getPointeeType(); 388209bb438042ef7652b2b046e43d4ffb5a00d9725Fariborz Jahanian llvm::OpaqueType *PointeeType = llvm::OpaqueType::get(); 389209bb438042ef7652b2b046e43d4ffb5a00d9725Fariborz Jahanian PointersToResolve.push_back(std::make_pair(FTy, PointeeType)); 390209bb438042ef7652b2b046e43d4ffb5a00d9725Fariborz Jahanian return llvm::PointerType::get(PointeeType, FTy.getAddressSpace()); 3919048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar } 392424c51d3d4bea87291919b75e73ca59386702ad5Sebastian Redl 3930e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson case Type::MemberPointer: { 3940e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson // FIXME: This is ABI dependent. We use the Itanium C++ ABI. 3950e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson // http://www.codesourcery.com/public/cxx-abi/abi.html#member-pointers 3960e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson // If we ever want to support other ABIs this needs to be abstracted. 3970e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson 3980e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson QualType ETy = cast<MemberPointerType>(Ty).getPointeeType(); 3990e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson if (ETy->isFunctionType()) { 4000e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson return llvm::StructType::get(ConvertType(Context.getPointerDiffType()), 4010e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson ConvertType(Context.getPointerDiffType()), 4020e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson NULL); 4030e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson } else 4040e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson return ConvertType(Context.getPointerDiffType()); 4050e650017acdbbeb0c590e77bbea88c200ea1caefAnders Carlsson } 4067532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 4077532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor case Type::TemplateSpecialization: 4087532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor assert(false && "Dependent types can't get here"); 4095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 4105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // FIXME: implement. 4125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return llvm::OpaqueType::get(); 4135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 4145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 415fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner/// ConvertTagDeclType - Lay out a tagged decl type like struct or union or 416fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner/// enum. 4178fb1dd005f4cb530bca11d622362d39727294420Chris Lattnerconst llvm::Type *CodeGenTypes::ConvertTagDeclType(const TagDecl *TD) { 418efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar // TagDecl's are not necessarily unique, instead use the (clang) 419efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar // type connected to the decl. 420efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar const Type *Key = 421efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar Context.getTagDeclType(const_cast<TagDecl*>(TD)).getTypePtr(); 422efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar llvm::DenseMap<const Type*, llvm::PATypeHolder>::iterator TDTI = 423efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar TagDeclTypes.find(Key); 424fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 4255de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // If we've already compiled this tag type, use the previous definition. 4265de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner if (TDTI != TagDeclTypes.end()) 427fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner return TDTI->second; 428fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 4295de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // If this is still a forward definition, just define an opaque type to use 4305de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // for this tagged decl. 431fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner if (!TD->isDefinition()) { 4325de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner llvm::Type *ResultType = llvm::OpaqueType::get(); 433efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar TagDeclTypes.insert(std::make_pair(Key, ResultType)); 4345de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner return ResultType; 4355de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner } 4365de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 4375de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // Okay, this is a definition of a type. Compile the implementation now. 4385de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 43939ba4aeca296b1c9f04bde7d9d3cbbf129f1abd3Argyrios Kyrtzidis if (TD->isEnum()) { 440fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner // Don't bother storing enums in TagDeclTypes. 441fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return ConvertTypeRecursive(cast<EnumDecl>(TD)->getIntegerType()); 4425de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner } 4435de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 4445de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // This decl could well be recursive. In this case, insert an opaque 4455de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // definition of this type, which the recursive uses will get. We will then 4465de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // refine this opaque version later. 4475de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 4485de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // Create new OpaqueType now for later use in case this is a recursive 4495de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // type. This will later be refined to the actual type. 4505de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner llvm::PATypeHolder ResultHolder = llvm::OpaqueType::get(); 451efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar TagDeclTypes.insert(std::make_pair(Key, ResultHolder)); 4525de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 4535de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner const llvm::Type *ResultType; 4545de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner const RecordDecl *RD = cast<const RecordDecl>(TD); 455ae287239879386b9abf6da50a67bbb7fe81897f1Daniel Dunbar 456696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson // Layout fields. 457696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson CGRecordLayout *Layout = 458696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson CGRecordLayoutBuilder::ComputeLayout(*this, RD); 459fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 460696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson if (!Layout) { 461696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson // Layout fields. 462696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson RecordOrganizer RO(*this, *RD); 463696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson 464696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson if (TD->isStruct() || TD->isClass()) 465696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson RO.layoutStructFields(Context.getASTRecordLayout(RD)); 466696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson else { 467696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson assert(TD->isUnion() && "unknown tag decl kind!"); 468696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson RO.layoutUnionFields(Context.getASTRecordLayout(RD)); 469ae287239879386b9abf6da50a67bbb7fe81897f1Daniel Dunbar } 470696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson 471696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson Layout = new CGRecordLayout(RO.getLLVMType(), 472696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson RO.getPaddingFields()); 473fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner } 474696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson 475696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson CGRecordLayouts[Key] = Layout; 476696798febaf1f69020cdf7474b91e71736c5aa69Anders Carlsson ResultType = Layout->getLLVMType(); 477fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 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); 4825de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 4835de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner return ResultHolder.get(); 484fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner} 485fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 486b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel/// getLLVMFieldNo - Return llvm::StructType element number 487b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel/// that corresponds to the field FD. 488b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patelunsigned CodeGenTypes::getLLVMFieldNo(const FieldDecl *FD) { 4898330ceeebb3bfac31116b387b90ff2ce3cef85e4Anders Carlsson assert(!FD->isBitField() && "Don't use getLLVMFieldNo on bit fields!"); 4908330ceeebb3bfac31116b387b90ff2ce3cef85e4Anders Carlsson 491ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner llvm::DenseMap<const FieldDecl*, unsigned>::iterator I = FieldInfo.find(FD); 49221fdf416723e8c475812a0324a1f9fafc949c25fHartmut Kaiser assert (I != FieldInfo.end() && "Unable to find field info"); 493391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner return I->second; 494391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner} 495391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 496c4c429a1a5947ba9be64d3070741d98362872265Devang Patel/// addFieldInfo - Assign field number to field FD. 4972c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venanciovoid CodeGenTypes::addFieldInfo(const FieldDecl *FD, unsigned No) { 4982c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio FieldInfo[FD] = No; 4992c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio} 5002c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio 5012c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio/// getBitFieldInfo - Return the BitFieldInfo that corresponds to the field FD. 5022c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos VenancioCodeGenTypes::BitFieldInfo CodeGenTypes::getBitFieldInfo(const FieldDecl *FD) { 5032c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio llvm::DenseMap<const FieldDecl *, BitFieldInfo>::iterator 5042c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio I = BitFields.find(FD); 5052c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio assert (I != BitFields.end() && "Unable to find bitfield info"); 5062c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio return I->second; 5072c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio} 5082c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio 5092c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio/// addBitFieldInfo - Assign a start bit and a size to field FD. 5108330ceeebb3bfac31116b387b90ff2ce3cef85e4Anders Carlssonvoid CodeGenTypes::addBitFieldInfo(const FieldDecl *FD, unsigned FieldNo, 5118330ceeebb3bfac31116b387b90ff2ce3cef85e4Anders Carlsson unsigned Start, unsigned Size) { 5128330ceeebb3bfac31116b387b90ff2ce3cef85e4Anders Carlsson BitFields.insert(std::make_pair(FD, BitFieldInfo(FieldNo, Start, Size))); 513b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel} 514b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel 51588a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel/// getCGRecordLayout - Return record layout info for the given llvm::Type. 51688a981b47c7face1b1fdaa9074256245107b9ca9Devang Patelconst CGRecordLayout * 517af31913e48c96fddb45a0fd33f25617546502cbbChris LattnerCodeGenTypes::getCGRecordLayout(const TagDecl *TD) const { 518efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar const Type *Key = 519efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar Context.getTagDeclType(const_cast<TagDecl*>(TD)).getTypePtr(); 520efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar llvm::DenseMap<const Type*, CGRecordLayout *>::iterator I 521efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar = CGRecordLayouts.find(Key); 52288a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel assert (I != CGRecordLayouts.end() 523b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel && "Unable to find record layout information for type"); 524b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel return I->second; 525b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel} 526b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel 52786522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel/// layoutStructFields - Do the actual work and lay out all fields. Create 528cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman/// corresponding llvm struct type. 529cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman/// Note that this doesn't actually try to do struct layout; it depends on 530cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman/// the layout built by the AST. (We have to do struct layout to do Sema, 531cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman/// and there's no point to duplicating the work.) 53288a981b47c7face1b1fdaa9074256245107b9ca9Devang Patelvoid RecordOrganizer::layoutStructFields(const ASTRecordLayout &RL) { 533e36a3c8b5c7db4916342e4381caa2fdc93eb5745Eli Friedman // FIXME: This code currently always generates packed structures. 534e36a3c8b5c7db4916342e4381caa2fdc93eb5745Eli Friedman // Unpacked structures are more readable, and sometimes more efficient! 535e36a3c8b5c7db4916342e4381caa2fdc93eb5745Eli Friedman // (But note that any changes here are likely to impact CGExprConstant, 536e36a3c8b5c7db4916342e4381caa2fdc93eb5745Eli Friedman // which makes some messy assumptions.) 537cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman uint64_t llvmSize = 0; 538e36a3c8b5c7db4916342e4381caa2fdc93eb5745Eli Friedman // FIXME: Make this a SmallVector 539cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman std::vector<const llvm::Type*> LLVMFields; 540742cd1b7bb86b52b23b335d47abbd842dac0e1bfFariborz Jahanian 54144b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor unsigned curField = 0; 542742cd1b7bb86b52b23b335d47abbd842dac0e1bfFariborz Jahanian // Adjust by number of bases. 543742cd1b7bb86b52b23b335d47abbd842dac0e1bfFariborz Jahanian // FIXME. This will probably change when virtual bases are supported. 544742cd1b7bb86b52b23b335d47abbd842dac0e1bfFariborz Jahanian if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(&RD)) 545742cd1b7bb86b52b23b335d47abbd842dac0e1bfFariborz Jahanian curField += CXXRD->getNumBases(); 546742cd1b7bb86b52b23b335d47abbd842dac0e1bfFariborz Jahanian 54717945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis for (RecordDecl::field_iterator Field = RD.field_begin(), 54817945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis FieldEnd = RD.field_end(); 54944b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor Field != FieldEnd; ++Field) { 550cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman uint64_t offset = RL.getFieldOffset(curField); 55157a84fb51de4f3de50debcf12dd194af8c6aaa58Eli Friedman const llvm::Type *Ty = CGT.ConvertTypeForMemRecursive(Field->getType()); 5529408c45009b417e758749b3d95cdfb87dcb68ea9Duncan Sands uint64_t size = CGT.getTargetData().getTypeAllocSizeInBits(Ty); 553cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman 55444b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor if (Field->isBitField()) { 555070eff4df45a810f0fb3a50e932f6d95713875d4Eli Friedman uint64_t BitFieldSize = 556070eff4df45a810f0fb3a50e932f6d95713875d4Eli Friedman Field->getBitWidth()->EvaluateAsInt(CGT.getContext()).getZExtValue(); 557cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman 558cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // Bitfield field info is different from other field info; 559cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // it actually ignores the underlying LLVM struct because 560cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // there isn't any convenient mapping. 5618330ceeebb3bfac31116b387b90ff2ce3cef85e4Anders Carlsson CGT.addBitFieldInfo(*Field, offset / size, offset % size, BitFieldSize); 562cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman } else { 563cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // Put the element into the struct. This would be simpler 564cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // if we didn't bother, but it seems a bit too strange to 565cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // allocate all structs as i8 arrays. 566cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman while (llvmSize < offset) { 567cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman LLVMFields.push_back(llvm::Type::Int8Ty); 568cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman llvmSize += 8; 569d8ecd3c8f7716124e1efb278a46b6747c697668dDevang Patel } 5706e8df736939325bc2355eeb1e138ecf8b2605616Devang Patel 571cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman llvmSize += size; 57244b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor CGT.addFieldInfo(*Field, LLVMFields.size()); 573cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman LLVMFields.push_back(Ty); 574cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman } 57544b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor ++curField; 576cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman } 577f9fef925644a6c40b344a43ab9ebdb08a707de53Devang Patel 578cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman while (llvmSize < RL.getSize()) { 579cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman LLVMFields.push_back(llvm::Type::Int8Ty); 580cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman llvmSize += 8; 5812c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio } 582159e3300f938ae05c0bf249508714e621cc89de5Devang Patel 5830408f6805c164f317937e97d7bc222781164bfebEli Friedman STy = llvm::StructType::get(LLVMFields, true); 5849408c45009b417e758749b3d95cdfb87dcb68ea9Duncan Sands assert(CGT.getTargetData().getTypeAllocSizeInBits(STy) == RL.getSize()); 585b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel} 586c4c429a1a5947ba9be64d3070741d98362872265Devang Patel 58786522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel/// layoutUnionFields - Do the actual work and lay out all fields. Create 58886522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel/// corresponding llvm struct type. This should be invoked only after 58986522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel/// all fields are added. 590cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedmanvoid RecordOrganizer::layoutUnionFields(const ASTRecordLayout &RL) { 59144b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor unsigned curField = 0; 59217945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis for (RecordDecl::field_iterator Field = RD.field_begin(), 59317945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis FieldEnd = RD.field_end(); 59444b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor Field != FieldEnd; ++Field) { 595cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // The offset should usually be zero, but bitfields could be strange 596cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman uint64_t offset = RL.getFieldOffset(curField); 59734e7946831a63f96d3ba3478c74ca8e25ee52d7eDouglas Gregor CGT.ConvertTypeRecursive(Field->getType()); 598cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman 59944b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor if (Field->isBitField()) { 60044b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor Expr *BitWidth = Field->getBitWidth(); 60132442bbc98bafa512fa42d46fedf60ed7d79f574Daniel Dunbar uint64_t BitFieldSize = 6029a901bb63990574ff0bcc12ff851d7a71cff8ddbEli Friedman BitWidth->EvaluateAsInt(CGT.getContext()).getZExtValue(); 60386522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel 6048330ceeebb3bfac31116b387b90ff2ce3cef85e4Anders Carlsson CGT.addBitFieldInfo(*Field, 0, offset, BitFieldSize); 605cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman } else { 60644b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor CGT.addFieldInfo(*Field, 0); 607cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman } 60844b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor ++curField; 60986522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel } 61086522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel 611cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // This looks stupid, but it is correct in the sense that 612cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // it works no matter how complicated the sizes and alignments 613cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // of the union elements are. The natural alignment 614cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // of the result doesn't matter because anyone allocating 615cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // structures should be aligning them appropriately anyway. 616cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // FIXME: We can be a bit more intuitive in a lot of cases. 617fd6f08525f9292255249b2434af4c6b2bc02ee93Eli Friedman // FIXME: Make this a struct type to work around PR2399; the 618fd6f08525f9292255249b2434af4c6b2bc02ee93Eli Friedman // C backend doesn't like structs using array types. 619fd6f08525f9292255249b2434af4c6b2bc02ee93Eli Friedman std::vector<const llvm::Type*> LLVMFields; 620fd6f08525f9292255249b2434af4c6b2bc02ee93Eli Friedman LLVMFields.push_back(llvm::ArrayType::get(llvm::Type::Int8Ty, 621fd6f08525f9292255249b2434af4c6b2bc02ee93Eli Friedman RL.getSize() / 8)); 622fd6f08525f9292255249b2434af4c6b2bc02ee93Eli Friedman STy = llvm::StructType::get(LLVMFields, true); 6239408c45009b417e758749b3d95cdfb87dcb68ea9Duncan Sands assert(CGT.getTargetData().getTypeAllocSizeInBits(STy) == RL.getSize()); 624382c64365247fa01e2711da27ef4bef0653afca4Devang Patel} 625