CodeGenTypes.cpp revision 6aeae7fa9cfaacba3a4077d62c01c2531d88a63e
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" 17de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/Expr.h" 18e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar#include "clang/AST/RecordLayout.h" 195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "llvm/DerivedTypes.h" 204e533287e6a9adac78c9ac370612581aad9b8c5eAnders Carlsson#include "llvm/Module.h" 21d9e9ede6b1703849da739629904dad197306e527Devang Patel#include "llvm/Target/TargetData.h" 225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2345c25ba11cbf8c9a461def5b03f6ee9481e06769Daniel Dunbar#include "CGCall.h" 2445c25ba11cbf8c9a461def5b03f6ee9481e06769Daniel Dunbar 255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace CodeGen; 275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 28057afddf0fab91d979d6a750667d56a345225c96Devang Patelnamespace { 2988a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel /// RecordOrganizer - This helper class, used by CGRecordLayout, layouts 30057afddf0fab91d979d6a750667d56a345225c96Devang Patel /// structs and unions. It manages transient information used during layout. 314c4635c6cd8114bfa3ee20628fa1f03e67ac1e55Devang Patel /// FIXME : Handle field aligments. Handle packed structs. 32057afddf0fab91d979d6a750667d56a345225c96Devang Patel class RecordOrganizer { 33057afddf0fab91d979d6a750667d56a345225c96Devang Patel public: 34cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman explicit RecordOrganizer(CodeGenTypes &Types, const RecordDecl& Record) : 35cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman CGT(Types), RD(Record), STy(NULL) {} 360bd41f2cea0639395e8ab7ef8fd6df2c1999b6aeDevang Patel 3786522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel /// layoutStructFields - Do the actual work and lay out all fields. Create 38057afddf0fab91d979d6a750667d56a345225c96Devang Patel /// corresponding llvm struct type. This should be invoked only after 39057afddf0fab91d979d6a750667d56a345225c96Devang Patel /// all fields are added. 4088a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel void layoutStructFields(const ASTRecordLayout &RL); 4186522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel 4286522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel /// layoutUnionFields - Do the actual work and lay out all fields. Create 4386522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel /// corresponding llvm struct type. This should be invoked only after 4486522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel /// all fields are added. 45cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman void layoutUnionFields(const ASTRecordLayout &RL); 46057afddf0fab91d979d6a750667d56a345225c96Devang Patel 47057afddf0fab91d979d6a750667d56a345225c96Devang Patel /// getLLVMType - Return associated llvm struct type. This may be NULL 48057afddf0fab91d979d6a750667d56a345225c96Devang Patel /// if fields are not laid out. 49057afddf0fab91d979d6a750667d56a345225c96Devang Patel llvm::Type *getLLVMType() const { 50057afddf0fab91d979d6a750667d56a345225c96Devang Patel return STy; 51057afddf0fab91d979d6a750667d56a345225c96Devang Patel } 52057afddf0fab91d979d6a750667d56a345225c96Devang Patel 53eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel llvm::SmallSet<unsigned, 8> &getPaddingFields() { 545bfc1a7ecb853cf87d10e720a07b9fbcd2a223eeDevang Patel return PaddingFields; 555bfc1a7ecb853cf87d10e720a07b9fbcd2a223eeDevang Patel } 565bfc1a7ecb853cf87d10e720a07b9fbcd2a223eeDevang Patel 57057afddf0fab91d979d6a750667d56a345225c96Devang Patel private: 58f9fef925644a6c40b344a43ab9ebdb08a707de53Devang Patel CodeGenTypes &CGT; 59cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman const RecordDecl& RD; 60057afddf0fab91d979d6a750667d56a345225c96Devang Patel llvm::Type *STy; 61eae1560d4fb99b9df814bc12c0419825996156cdDevang Patel llvm::SmallSet<unsigned, 8> PaddingFields; 62057afddf0fab91d979d6a750667d56a345225c96Devang Patel }; 63057afddf0fab91d979d6a750667d56a345225c96Devang Patel} 64057afddf0fab91d979d6a750667d56a345225c96Devang Patel 657a4718e813e5e99d478567a482217c7eef8572c5Devang PatelCodeGenTypes::CodeGenTypes(ASTContext &Ctx, llvm::Module& M, 667a4718e813e5e99d478567a482217c7eef8572c5Devang Patel const llvm::TargetData &TD) 676b1da0ea19c12346192f5ea4d70872c13bfcc82aDaniel Dunbar : Context(Ctx), Target(Ctx.Target), TheModule(M), TheTargetData(TD), 686b1da0ea19c12346192f5ea4d70872c13bfcc82aDaniel Dunbar TheABIInfo(0) { 69d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner} 705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 71b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang PatelCodeGenTypes::~CodeGenTypes() { 72efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar for(llvm::DenseMap<const Type *, CGRecordLayout *>::iterator 7388a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel I = CGRecordLayouts.begin(), E = CGRecordLayouts.end(); 74b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel I != E; ++I) 75b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel delete I->second; 7688a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel CGRecordLayouts.clear(); 77b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel} 78b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel 795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// ConvertType - Convert the specified type to its LLVM form. 805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst llvm::Type *CodeGenTypes::ConvertType(QualType T) { 81fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner llvm::PATypeHolder Result = ConvertTypeRecursive(T); 82fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner 83fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // Any pointers that were converted defered evaluation of their pointee type, 84fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // creating an opaque type instead. This is in order to avoid problems with 85fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // circular types. Loop through all these defered pointees, if any, and 86fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // resolve them now. 87fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner while (!PointersToResolve.empty()) { 886aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar std::pair<QualType, llvm::OpaqueType*> P = 89fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner PointersToResolve.back(); 90fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner PointersToResolve.pop_back(); 91fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // We can handle bare pointers here because we know that the only pointers 92fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // to the Opaque type are P.second and from other types. Refining the 93fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner // opqaue type away will invalidate P.second, but we don't mind :). 946aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar const llvm::Type *NT = ConvertTypeRecursive(P.first); 95fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner P.second->refineAbstractTypeTo(NT); 96fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner } 97fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner 98fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return Result; 99fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner} 100fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner 101fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattnerconst llvm::Type *CodeGenTypes::ConvertTypeRecursive(QualType T) { 1029619662a1d42e2008b865d3459c0677e149dad1bChris Lattner T = Context.getCanonicalType(T);; 1039619662a1d42e2008b865d3459c0677e149dad1bChris Lattner 10430ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel // See if type is already cached. 1050ffe89ab1e4890899e0e11a6f68223567a69b38aDevang Patel llvm::DenseMap<Type *, llvm::PATypeHolder>::iterator 1069619662a1d42e2008b865d3459c0677e149dad1bChris Lattner I = TypeCache.find(T.getTypePtr()); 1073c40085b373d8e6e4523812e06f73a0cb9d5142cDevang Patel // If type is found in map and this is not a definition for a opaque 108fae6e2994a51d8ec1e61b6eb68765247c83b1ccfChris Lattner // place holder type then use it. Otherwise, convert type T. 1094581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner if (I != TypeCache.end()) 11047c87b4b160d45285b24b1b7f4e3cbaaed3dc464Devang Patel return I->second.get(); 11130ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel 11230ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel const llvm::Type *ResultType = ConvertNewType(T); 1139619662a1d42e2008b865d3459c0677e149dad1bChris Lattner TypeCache.insert(std::make_pair(T.getTypePtr(), 1144581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner llvm::PATypeHolder(ResultType))); 11530ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel return ResultType; 11630ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel} 11730ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patel 1184581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// ConvertTypeForMem - Convert type T into a llvm::Type. This differs from 1194581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// ConvertType in that it is used to convert to the memory representation for 1204581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// a type. For example, the scalar representation for _Bool is i1, but the 1214581fff8af09a156a9dcc4de62587385c5da9574Chris Lattner/// memory representation is usually i8 or i32, depending on the target. 12219009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattnerconst llvm::Type *CodeGenTypes::ConvertTypeForMem(QualType T) { 12319009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner const llvm::Type *R = ConvertType(T); 12419009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner 12519009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner // If this is a non-bool type, don't map it. 12619009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner if (R != llvm::Type::Int1Ty) 12719009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner return R; 12819009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner 12919009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner // Otherwise, return an integer of the target-specified size. 13098be4943e8dc4f3905629a7102668960873cf863Chris Lattner return llvm::IntegerType::get((unsigned)Context.getTypeSize(T)); 13119009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner 13219009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner} 13319009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner 134c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattner/// UpdateCompletedType - When we find the full definition for a TagDecl, 135c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattner/// replace the 'opaque' type we previously made for it if applicable. 136c5b8806cda286cf41866176ef98011fdaa68da01Chris Lattnervoid CodeGenTypes::UpdateCompletedType(const TagDecl *TD) { 137efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar const Type *Key = 138efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar Context.getTagDeclType(const_cast<TagDecl*>(TD)).getTypePtr(); 139efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar llvm::DenseMap<const Type*, llvm::PATypeHolder>::iterator TDTI = 140efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar TagDeclTypes.find(Key); 1416ef58e36bbbfa232fe8b50309361e841985abfc6Chris Lattner if (TDTI == TagDeclTypes.end()) return; 1426ef58e36bbbfa232fe8b50309361e841985abfc6Chris Lattner 1436ef58e36bbbfa232fe8b50309361e841985abfc6Chris Lattner // Remember the opaque LLVM type for this tagdecl. 144d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner llvm::PATypeHolder OpaqueHolder = TDTI->second; 145d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner assert(isa<llvm::OpaqueType>(OpaqueHolder.get()) && 1466ef58e36bbbfa232fe8b50309361e841985abfc6Chris Lattner "Updating compilation of an already non-opaque type?"); 147d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 148d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner // Remove it from TagDeclTypes so that it will be regenerated. 149d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner TagDeclTypes.erase(TDTI); 150d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 1518fb1dd005f4cb530bca11d622362d39727294420Chris Lattner // Generate the new type. 1528fb1dd005f4cb530bca11d622362d39727294420Chris Lattner const llvm::Type *NT = ConvertTagDeclType(TD); 153d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 1548fb1dd005f4cb530bca11d622362d39727294420Chris Lattner // Refine the old opaque type to its new definition. 1558fb1dd005f4cb530bca11d622362d39727294420Chris Lattner cast<llvm::OpaqueType>(OpaqueHolder.get())->refineAbstractTypeTo(NT); 156d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner} 157d86e6bc7ab4388a578daf46e7c76be9122a25072Chris Lattner 158b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattnerstatic const llvm::Type* getTypeForFormat(const llvm::fltSemantics &format) { 159b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::IEEEsingle) 160f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return llvm::Type::FloatTy; 161b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::IEEEdouble) 162f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return llvm::Type::DoubleTy; 163b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::IEEEquad) 164f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return llvm::Type::FP128Ty; 165b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::PPCDoubleDouble) 166f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return llvm::Type::PPC_FP128Ty; 167b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner if (&format == &llvm::APFloat::x87DoubleExtended) 168f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return llvm::Type::X86_FP80Ty; 169b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner assert(0 && "Unknown float format!"); 170f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman return 0; 171f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman} 172f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman 17330ec9972be5a5af1f7a2277360dfa3aa1540b4faDevang Patelconst llvm::Type *CodeGenTypes::ConvertNewType(QualType T) { 1749619662a1d42e2008b865d3459c0677e149dad1bChris Lattner const clang::Type &Ty = *Context.getCanonicalType(T); 1755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Ty.getTypeClass()) { 177d14faaa7ecbdf1dae6fa4b005b2993ba3ce30770Chris Lattner case Type::TypeName: // typedef isn't canonical. 17872c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor case Type::TemplateTypeParm:// template type parameters never generated 17955f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor case Type::ClassTemplateSpecialization: // these types are always sugar 180898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor case Type::DependentSizedArray: // dependent types are never generated 181d14faaa7ecbdf1dae6fa4b005b2993ba3ce30770Chris Lattner case Type::TypeOfExp: // typeof isn't canonical. 182d14faaa7ecbdf1dae6fa4b005b2993ba3ce30770Chris Lattner case Type::TypeOfTyp: // typeof isn't canonical. 183d14faaa7ecbdf1dae6fa4b005b2993ba3ce30770Chris Lattner assert(0 && "Non-canonical type, shouldn't happen"); 1845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Builtin: { 1855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (cast<BuiltinType>(Ty).getKind()) { 186afef76e43a30380b3c612a674738f2f574c8f166Argyrios Kyrtzidis default: assert(0 && "Unknown builtin type!"); 1875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Void: 1885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // LLVM void type can only be used as the result of a function call. Just 1895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // map to the same as char. 190d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner return llvm::IntegerType::get(8); 1915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Bool: 19319009e6fe7e0f51d2e49f4c94928a048c11c5281Chris Lattner // Note that we always return bool as i1 for use as a scalar type. 1945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return llvm::Type::Int1Ty; 1955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 196d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::Char_S: 197d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::Char_U: 198d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::SChar: 199d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::UChar: 2005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Short: 2015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::UShort: 2025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Int: 2035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::UInt: 2045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Long: 2055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::ULong: 2065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::LongLong: 2075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::ULongLong: 208afef76e43a30380b3c612a674738f2f574c8f166Argyrios Kyrtzidis case BuiltinType::WChar: 20947f7dbf7c0b25505ad093a317983a9b39efe0610Chris Lattner return llvm::IntegerType::get( 21098be4943e8dc4f3905629a7102668960873cf863Chris Lattner static_cast<unsigned>(Context.getTypeSize(T))); 2115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 212f6a943e047f541619a2202f9e43b20b3d7c0a96dEli Friedman case BuiltinType::Float: 213c8b1227fa8c17d9881815e40c04e19334be536f8Nate Begeman case BuiltinType::Double: 2145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::LongDouble: 215b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner return getTypeForFormat(Context.getFloatTypeSemantics(T)); 2165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 2185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 219f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman case Type::FixedWidthInt: 220f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return llvm::IntegerType::get(cast<FixedWidthIntType>(T)->getWidth()); 2215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Complex: { 222572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner const llvm::Type *EltTy = 223fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner ConvertTypeRecursive(cast<ComplexType>(Ty).getElementType()); 224572cf09ae8a78af1c56d40b016ec4cf1837163acChris Lattner return llvm::StructType::get(EltTy, EltTy, NULL); 2255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2266aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar case Type::Reference: { 2276aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar const ReferenceType &RTy = cast<ReferenceType>(Ty); 2286aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar QualType ETy = RTy.getPointeeType(); 2296aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar llvm::OpaqueType *PointeeType = llvm::OpaqueType::get(); 2306aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar PointersToResolve.push_back(std::make_pair(ETy, PointeeType)); 2316aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar return llvm::PointerType::get(PointeeType, ETy.getAddressSpace()); 2326aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar } 2335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Type::Pointer: { 2346aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar const PointerType &PTy = cast<PointerType>(Ty); 235fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner QualType ETy = PTy.getPointeeType(); 236fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner llvm::OpaqueType *PointeeType = llvm::OpaqueType::get(); 2376aeae7fa9cfaacba3a4077d62c01c2531d88a63eDaniel Dunbar PointersToResolve.push_back(std::make_pair(ETy, 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: 268541b63b1a9db77e4a8670e9823711c2c12e58afbDaniel Dunbar return GetFunctionType(getFunctionInfo(cast<FunctionTypeNoProto>(&Ty)), 269bb36d331f439f49859efcfb4435c61762fbba6f9Daniel Dunbar true); 270bb36d331f439f49859efcfb4435c61762fbba6f9Daniel Dunbar case Type::FunctionProto: { 271bb36d331f439f49859efcfb4435c61762fbba6f9Daniel Dunbar const FunctionTypeProto *FTP = cast<FunctionTypeProto>(&Ty); 272541b63b1a9db77e4a8670e9823711c2c12e58afbDaniel Dunbar return GetFunctionType(getFunctionInfo(FTP), FTP->isVariadic()); 273bb36d331f439f49859efcfb4435c61762fbba6f9Daniel Dunbar } 274ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb 275f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian case Type::ExtQual: 276fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return 277f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian ConvertTypeRecursive(QualType(cast<ExtQualType>(Ty).getBaseType(), 0)); 278b1776cb8d35dfa80bfd8606e58b8ade30dcd2438Chris Lattner 279391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner case Type::ObjCInterface: { 280391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // Warning: Use of this is strongly discouraged. Late binding of instance 281391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // variables is supported on some runtimes and so using static binding can 282391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // break code when libraries are updated. Only use this if you have 283391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // previously checked that the ObjCRuntime subclass in use does not support 284391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // late-bound ivars. 285fd64bb635dc221baa19f81d5d2a084f7eb269f7fFariborz Jahanian // We are issuing warnings elsewhere! 286391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner ObjCInterfaceType OIT = cast<ObjCInterfaceType>(Ty); 287fd64bb635dc221baa19f81d5d2a084f7eb269f7fFariborz Jahanian ObjCInterfaceDecl *ID = OIT.getDecl(); 288a769c004a2874504c17ea8afccbc4ad35fc33c9fFariborz Jahanian const RecordDecl *RD = Context.addRecordToClass(ID); 289fd64bb635dc221baa19f81d5d2a084f7eb269f7fFariborz Jahanian return ConvertTagDeclType(cast<TagDecl>(RD)); 290391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner } 291e37882ad335896dedf345102bb425383e6221c37Fariborz Jahanian 2926c2dae7923f887b5f7746dd84c2d9535eb2112c0Anders Carlsson case Type::ObjCQualifiedInterface: { 2936c2dae7923f887b5f7746dd84c2d9535eb2112c0Anders Carlsson ObjCQualifiedInterfaceType QIT = cast<ObjCQualifiedInterfaceType>(Ty); 2946c2dae7923f887b5f7746dd84c2d9535eb2112c0Anders Carlsson 2956c2dae7923f887b5f7746dd84c2d9535eb2112c0Anders Carlsson return ConvertTypeRecursive(Context.getObjCInterfaceType(QIT.getDecl())); 2966c2dae7923f887b5f7746dd84c2d9535eb2112c0Anders Carlsson } 297b1776cb8d35dfa80bfd8606e58b8ade30dcd2438Chris Lattner 298a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek case Type::ObjCQualifiedId: 299f7f52e7bf5a4dc36d45b98531e0b21e343fc19deSteve Naroff case Type::ObjCQualifiedClass: 30098c5ead87d720d8b68b6f236c3c3579a388fc882Daniel Dunbar // Protocols don't influence the LLVM type. 30198c5ead87d720d8b68b6f236c3c3579a388fc882Daniel Dunbar return ConvertTypeRecursive(Context.getObjCIdType()); 302c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian 303de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner case Type::Tagged: { 304de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner const TagDecl *TD = cast<TagType>(Ty).getDecl(); 3058fb1dd005f4cb530bca11d622362d39727294420Chris Lattner const llvm::Type *Res = ConvertTagDeclType(TD); 306de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner 307de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner std::string TypeName(TD->getKindName()); 308de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner TypeName += '.'; 309de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner 310de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner // Name the codegen type after the typedef name 311de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner // if there is no tag type name available 312de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner if (TD->getIdentifier()) 313d9d22dd9c94618490dbffb0e2caf222530ca39d3Chris Lattner TypeName += TD->getNameAsString(); 314de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner else if (const TypedefType *TdT = dyn_cast<TypedefType>(T)) 315d9d22dd9c94618490dbffb0e2caf222530ca39d3Chris Lattner TypeName += TdT->getDecl()->getNameAsString(); 316de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner else 317de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner TypeName += "anon"; 318de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner 319de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner TheModule.addTypeName(TypeName, Res); 320de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner return Res; 321de0efb3b6eac36bdeae0e60f753a974cc4118a31Chris Lattner } 3229048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar 3239048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar case Type::BlockPointer: { 3244e174f1b1e95faacc21da2eac70f7853807f3ea3Daniel Dunbar const QualType FTy = cast<BlockPointerType>(Ty).getPointeeType(); 3254e174f1b1e95faacc21da2eac70f7853807f3ea3Daniel Dunbar return llvm::PointerType::get(ConvertTypeRecursive(FTy), 3264e174f1b1e95faacc21da2eac70f7853807f3ea3Daniel Dunbar FTy.getAddressSpace()); 3279048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar } 328424c51d3d4bea87291919b75e73ca59386702ad5Sebastian Redl 329424c51d3d4bea87291919b75e73ca59386702ad5Sebastian Redl case Type::MemberPointer: 330424c51d3d4bea87291919b75e73ca59386702ad5Sebastian Redl // FIXME: Implement C++ pointer-to-member. The GCC representation is 331424c51d3d4bea87291919b75e73ca59386702ad5Sebastian Redl // documented here: 332424c51d3d4bea87291919b75e73ca59386702ad5Sebastian Redl // http://gcc.gnu.org/onlinedocs/gccint/Type-Layout.html#Type-Layout 333424c51d3d4bea87291919b75e73ca59386702ad5Sebastian Redl assert(0 && "FIXME: We can't handle member pointers yet."); 334424c51d3d4bea87291919b75e73ca59386702ad5Sebastian Redl return llvm::OpaqueType::get(); 3355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // FIXME: implement. 3385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return llvm::OpaqueType::get(); 3395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 341fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner/// ConvertTagDeclType - Lay out a tagged decl type like struct or union or 342fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner/// enum. 3438fb1dd005f4cb530bca11d622362d39727294420Chris Lattnerconst llvm::Type *CodeGenTypes::ConvertTagDeclType(const TagDecl *TD) { 344efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar // TagDecl's are not necessarily unique, instead use the (clang) 345efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar // type connected to the decl. 346efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar const Type *Key = 347efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar Context.getTagDeclType(const_cast<TagDecl*>(TD)).getTypePtr(); 348efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar llvm::DenseMap<const Type*, llvm::PATypeHolder>::iterator TDTI = 349efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar TagDeclTypes.find(Key); 350fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 3515de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // If we've already compiled this tag type, use the previous definition. 3525de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner if (TDTI != TagDeclTypes.end()) 353fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner return TDTI->second; 354fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 3555de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // If this is still a forward definition, just define an opaque type to use 3565de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // for this tagged decl. 357fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner if (!TD->isDefinition()) { 3585de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner llvm::Type *ResultType = llvm::OpaqueType::get(); 359efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar TagDeclTypes.insert(std::make_pair(Key, ResultType)); 3605de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner return ResultType; 3615de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner } 3625de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 3635de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // Okay, this is a definition of a type. Compile the implementation now. 3645de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 36539ba4aeca296b1c9f04bde7d9d3cbbf129f1abd3Argyrios Kyrtzidis if (TD->isEnum()) { 366fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner // Don't bother storing enums in TagDeclTypes. 367fce71b8ea53b6eb9c1630da24659289bc848f837Chris Lattner return ConvertTypeRecursive(cast<EnumDecl>(TD)->getIntegerType()); 3685de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner } 3695de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 3705de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // This decl could well be recursive. In this case, insert an opaque 3715de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // definition of this type, which the recursive uses will get. We will then 3725de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // refine this opaque version later. 3735de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 3745de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // Create new OpaqueType now for later use in case this is a recursive 3755de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // type. This will later be refined to the actual type. 3765de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner llvm::PATypeHolder ResultHolder = llvm::OpaqueType::get(); 377efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar TagDeclTypes.insert(std::make_pair(Key, ResultHolder)); 3785de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 3795de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner const llvm::Type *ResultType; 3805de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner const RecordDecl *RD = cast<const RecordDecl>(TD); 38139ba4aeca296b1c9f04bde7d9d3cbbf129f1abd3Argyrios Kyrtzidis if (TD->isStruct() || TD->isClass()) { 382fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner // Layout fields. 383cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman RecordOrganizer RO(*this, *RD); 384fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 38598be4943e8dc4f3905629a7102668960873cf863Chris Lattner RO.layoutStructFields(Context.getASTRecordLayout(RD)); 386fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 3875de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // Get llvm::StructType. 388efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar const Type *Key = 389efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar Context.getTagDeclType(const_cast<TagDecl*>(TD)).getTypePtr(); 390efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar CGRecordLayouts[Key] = new CGRecordLayout(RO.getLLVMType(), 391efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar RO.getPaddingFields()); 3925de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner ResultType = RO.getLLVMType(); 393fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 39439ba4aeca296b1c9f04bde7d9d3cbbf129f1abd3Argyrios Kyrtzidis } else if (TD->isUnion()) { 395fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner // Just use the largest element of the union, breaking ties with the 396fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner // highest aligned member. 397e267ff35b2f4e9d2b0d8bf24109d41cc7398b61bDouglas Gregor if (!RD->field_empty()) { 398cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman RecordOrganizer RO(*this, *RD); 3995de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 400cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman RO.layoutUnionFields(Context.getASTRecordLayout(RD)); 4015de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 4025de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // Get llvm::StructType. 403efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar const Type *Key = 404efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar Context.getTagDeclType(const_cast<TagDecl*>(TD)).getTypePtr(); 405efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar CGRecordLayouts[Key] = new CGRecordLayout(RO.getLLVMType(), 406efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar RO.getPaddingFields()); 4075de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner ResultType = RO.getLLVMType(); 408fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner } else { 4095de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner ResultType = llvm::StructType::get(std::vector<const llvm::Type*>()); 410fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner } 411fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner } else { 412fae6e2994a51d8ec1e61b6eb68765247c83b1ccfChris Lattner assert(0 && "FIXME: Unknown tag decl kind!"); 4133304e55f613ce34d9a14c3aaf06f5949408b3092Chris Lattner abort(); 414fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner } 415fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 4165de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // Refine our Opaque type to ResultType. This can invalidate ResultType, so 4175de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner // make sure to read the result out of the holder. 4185de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner cast<llvm::OpaqueType>(ResultHolder.get()) 4195de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner ->refineAbstractTypeTo(ResultType); 4205de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner 4215de00fcf7c923a14bb79bdbaabb2faeb5633d85aChris Lattner return ResultHolder.get(); 422fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner} 423fc3b8e9c1381d5e6ec361591d649c56a870ff971Chris Lattner 424b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel/// getLLVMFieldNo - Return llvm::StructType element number 425b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel/// that corresponds to the field FD. 426b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patelunsigned CodeGenTypes::getLLVMFieldNo(const FieldDecl *FD) { 427ce5605ecf76d8cde6372138f830bb144d174ced9Chris Lattner llvm::DenseMap<const FieldDecl*, unsigned>::iterator I = FieldInfo.find(FD); 42821fdf416723e8c475812a0324a1f9fafc949c25fHartmut Kaiser assert (I != FieldInfo.end() && "Unable to find field info"); 429391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner return I->second; 430391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner} 431391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 432c4c429a1a5947ba9be64d3070741d98362872265Devang Patel/// addFieldInfo - Assign field number to field FD. 4332c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venanciovoid CodeGenTypes::addFieldInfo(const FieldDecl *FD, unsigned No) { 4342c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio FieldInfo[FD] = No; 4352c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio} 4362c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio 4372c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio/// getBitFieldInfo - Return the BitFieldInfo that corresponds to the field FD. 4382c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos VenancioCodeGenTypes::BitFieldInfo CodeGenTypes::getBitFieldInfo(const FieldDecl *FD) { 4392c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio llvm::DenseMap<const FieldDecl *, BitFieldInfo>::iterator 4402c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio I = BitFields.find(FD); 4412c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio assert (I != BitFields.end() && "Unable to find bitfield info"); 4422c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio return I->second; 4432c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio} 4442c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio 4452c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio/// addBitFieldInfo - Assign a start bit and a size to field FD. 4462c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venanciovoid CodeGenTypes::addBitFieldInfo(const FieldDecl *FD, unsigned Begin, 4471abc7f654df795549d4f6f3a018ddb3a8fff013aNate Begeman unsigned Size) { 4482c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio BitFields.insert(std::make_pair(FD, BitFieldInfo(Begin, Size))); 449b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel} 450b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel 45188a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel/// getCGRecordLayout - Return record layout info for the given llvm::Type. 45288a981b47c7face1b1fdaa9074256245107b9ca9Devang Patelconst CGRecordLayout * 453af31913e48c96fddb45a0fd33f25617546502cbbChris LattnerCodeGenTypes::getCGRecordLayout(const TagDecl *TD) const { 454efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar const Type *Key = 455efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar Context.getTagDeclType(const_cast<TagDecl*>(TD)).getTypePtr(); 456efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar llvm::DenseMap<const Type*, CGRecordLayout *>::iterator I 457efb6d0dc3eafbcf4f8cd053138bd1abed1dda8d4Daniel Dunbar = CGRecordLayouts.find(Key); 45888a981b47c7face1b1fdaa9074256245107b9ca9Devang Patel assert (I != CGRecordLayouts.end() 459b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel && "Unable to find record layout information for type"); 460b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel return I->second; 461b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel} 462b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel 46386522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel/// layoutStructFields - Do the actual work and lay out all fields. Create 464cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman/// corresponding llvm struct type. 465cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman/// Note that this doesn't actually try to do struct layout; it depends on 466cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman/// the layout built by the AST. (We have to do struct layout to do Sema, 467cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman/// and there's no point to duplicating the work.) 46888a981b47c7face1b1fdaa9074256245107b9ca9Devang Patelvoid RecordOrganizer::layoutStructFields(const ASTRecordLayout &RL) { 469e36a3c8b5c7db4916342e4381caa2fdc93eb5745Eli Friedman // FIXME: This code currently always generates packed structures. 470e36a3c8b5c7db4916342e4381caa2fdc93eb5745Eli Friedman // Unpacked structures are more readable, and sometimes more efficient! 471e36a3c8b5c7db4916342e4381caa2fdc93eb5745Eli Friedman // (But note that any changes here are likely to impact CGExprConstant, 472e36a3c8b5c7db4916342e4381caa2fdc93eb5745Eli Friedman // which makes some messy assumptions.) 473cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman uint64_t llvmSize = 0; 474e36a3c8b5c7db4916342e4381caa2fdc93eb5745Eli Friedman // FIXME: Make this a SmallVector 475cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman std::vector<const llvm::Type*> LLVMFields; 476cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman 47744b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor unsigned curField = 0; 478f8d49f64ef6ab7e632717a31631fc289aab69428Douglas Gregor for (RecordDecl::field_iterator Field = RD.field_begin(), 479f8d49f64ef6ab7e632717a31631fc289aab69428Douglas Gregor FieldEnd = RD.field_end(); 48044b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor Field != FieldEnd; ++Field) { 481cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman uint64_t offset = RL.getFieldOffset(curField); 48244b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor const llvm::Type *Ty = CGT.ConvertTypeRecursive(Field->getType()); 483491c7b77cd8ec8570f646d43b937a5aec688bcbfDaniel Dunbar uint64_t size = CGT.getTargetData().getTypePaddedSizeInBits(Ty); 484cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman 48544b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor if (Field->isBitField()) { 48644b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor Expr *BitWidth = Field->getBitWidth(); 487cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman llvm::APSInt FieldSize(32); 488cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman bool isBitField = 489cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman BitWidth->isIntegerConstantExpr(FieldSize, CGT.getContext()); 4903304e55f613ce34d9a14c3aaf06f5949408b3092Chris Lattner assert(isBitField && "Invalid BitField size expression"); 4913304e55f613ce34d9a14c3aaf06f5949408b3092Chris Lattner isBitField=isBitField; // silence warning. 4923304e55f613ce34d9a14c3aaf06f5949408b3092Chris Lattner uint64_t BitFieldSize = FieldSize.getZExtValue(); 493cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman 494cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // Bitfield field info is different from other field info; 495cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // it actually ignores the underlying LLVM struct because 496cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // there isn't any convenient mapping. 49744b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor CGT.addFieldInfo(*Field, offset / size); 49844b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor CGT.addBitFieldInfo(*Field, offset % size, BitFieldSize); 499cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman } else { 500cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // Put the element into the struct. This would be simpler 501cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // if we didn't bother, but it seems a bit too strange to 502cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // allocate all structs as i8 arrays. 503cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman while (llvmSize < offset) { 504cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman LLVMFields.push_back(llvm::Type::Int8Ty); 505cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman llvmSize += 8; 506d8ecd3c8f7716124e1efb278a46b6747c697668dDevang Patel } 5076e8df736939325bc2355eeb1e138ecf8b2605616Devang Patel 508cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman llvmSize += size; 50944b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor CGT.addFieldInfo(*Field, LLVMFields.size()); 510cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman LLVMFields.push_back(Ty); 511cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman } 51244b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor ++curField; 513cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman } 514f9fef925644a6c40b344a43ab9ebdb08a707de53Devang Patel 515cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman while (llvmSize < RL.getSize()) { 516cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman LLVMFields.push_back(llvm::Type::Int8Ty); 517cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman llvmSize += 8; 5182c46ce8de96787aa8e040690a80896f1148c29b0Lauro Ramos Venancio } 519159e3300f938ae05c0bf249508714e621cc89de5Devang Patel 5200408f6805c164f317937e97d7bc222781164bfebEli Friedman STy = llvm::StructType::get(LLVMFields, true); 521491c7b77cd8ec8570f646d43b937a5aec688bcbfDaniel Dunbar assert(CGT.getTargetData().getTypePaddedSizeInBits(STy) == RL.getSize()); 522b84a06e68ffd71da22e3c75b6e4bbdba37816413Devang Patel} 523c4c429a1a5947ba9be64d3070741d98362872265Devang Patel 52486522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel/// layoutUnionFields - Do the actual work and lay out all fields. Create 52586522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel/// corresponding llvm struct type. This should be invoked only after 52686522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel/// all fields are added. 527cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedmanvoid RecordOrganizer::layoutUnionFields(const ASTRecordLayout &RL) { 52844b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor unsigned curField = 0; 529f8d49f64ef6ab7e632717a31631fc289aab69428Douglas Gregor for (RecordDecl::field_iterator Field = RD.field_begin(), 530f8d49f64ef6ab7e632717a31631fc289aab69428Douglas Gregor FieldEnd = RD.field_end(); 53144b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor Field != FieldEnd; ++Field) { 532cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // The offset should usually be zero, but bitfields could be strange 533cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman uint64_t offset = RL.getFieldOffset(curField); 53434e7946831a63f96d3ba3478c74ca8e25ee52d7eDouglas Gregor CGT.ConvertTypeRecursive(Field->getType()); 535cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman 53644b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor if (Field->isBitField()) { 53744b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor Expr *BitWidth = Field->getBitWidth(); 53832442bbc98bafa512fa42d46fedf60ed7d79f574Daniel Dunbar uint64_t BitFieldSize = 53932442bbc98bafa512fa42d46fedf60ed7d79f574Daniel Dunbar BitWidth->getIntegerConstantExprValue(CGT.getContext()).getZExtValue(); 54086522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel 54144b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor CGT.addFieldInfo(*Field, 0); 54244b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor CGT.addBitFieldInfo(*Field, offset, BitFieldSize); 543cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman } else { 54444b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor CGT.addFieldInfo(*Field, 0); 545cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman } 54644b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor ++curField; 54786522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel } 54886522b9e84d0c39f09b54e888538ad64e89788c4Devang Patel 549cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // This looks stupid, but it is correct in the sense that 550cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // it works no matter how complicated the sizes and alignments 551cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // of the union elements are. The natural alignment 552cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // of the result doesn't matter because anyone allocating 553cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // structures should be aligning them appropriately anyway. 554cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman // FIXME: We can be a bit more intuitive in a lot of cases. 555cbadaf6ced6d664015ee409f62ab1bc20ae0bf73Eli Friedman STy = llvm::ArrayType::get(llvm::Type::Int8Ty, RL.getSize() / 8); 556491c7b77cd8ec8570f646d43b937a5aec688bcbfDaniel Dunbar assert(CGT.getTargetData().getTypePaddedSizeInBits(STy) == RL.getSize()); 557382c64365247fa01e2711da27ef4bef0653afca4Devang Patel} 558