ASTContext.cpp revision 561d3abc881033776ece385a01a510e1cbc1fa92
15f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--- ASTContext.cpp - Context to hold long-lived AST nodes ------------===// 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 file implements the ASTContext interface. 115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/AST/ASTContext.h" 15bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck#include "clang/AST/CharUnits.h" 1649aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidis#include "clang/AST/DeclCXX.h" 17980e508ca70d6de75d2abfd96b4681fc98bb2698Steve Naroff#include "clang/AST/DeclObjC.h" 18aaba5e346dffdbad5d1c42765a89e4a7afb0da67Douglas Gregor#include "clang/AST/DeclTemplate.h" 19b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis#include "clang/AST/TypeLoc.h" 20e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar#include "clang/AST/Expr.h" 21ea1471e0e967548c596a71469702f8846dbaf3c0John McCall#include "clang/AST/ExprCXX.h" 222cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor#include "clang/AST/ExternalASTSource.h" 237b90340c9c7d07aef4e301e72b5e8a30d5f4f0c8Argyrios Kyrtzidis#include "clang/AST/ASTMutationListener.h" 2419cc4abea06a9b49e0e16a50d335c064cd723572Anders Carlsson#include "clang/AST/RecordLayout.h" 2514110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne#include "clang/AST/Mangle.h" 261b63e4f732dbc73d90abf886b4d21f8e3a165f6dChris Lattner#include "clang/Basic/Builtins.h" 27a9376d470ccb0eac74fe09a6b2a18a890f1d17c4Chris Lattner#include "clang/Basic/SourceManager.h" 285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Basic/TargetInfo.h" 29f5942a44880be26878592eb052b737579349411eBenjamin Kramer#include "llvm/ADT/SmallString.h" 3085f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson#include "llvm/ADT/StringExtras.h" 316fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman#include "llvm/Support/MathExtras.h" 32f5942a44880be26878592eb052b737579349411eBenjamin Kramer#include "llvm/Support/raw_ostream.h" 330c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek#include "llvm/Support/Capacity.h" 34071cc7deffad608165b1ddd5263e8bf181861520Charles Davis#include "CXXABI.h" 352636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis#include <map> 3629445a0542d128cd7ee587ee52229670b9b54a12Anders Carlsson 375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 391827403a7138946305c0058f262e02b595cf882fDouglas Gregorunsigned ASTContext::NumImplicitDefaultConstructors; 401827403a7138946305c0058f262e02b595cf882fDouglas Gregorunsigned ASTContext::NumImplicitDefaultConstructorsDeclared; 41225843186e3972ce798d3de00f86da9008b15a0eDouglas Gregorunsigned ASTContext::NumImplicitCopyConstructors; 42225843186e3972ce798d3de00f86da9008b15a0eDouglas Gregorunsigned ASTContext::NumImplicitCopyConstructorsDeclared; 43ffe37fdda5b4b4f162a45155c30d9f60ce110c12Sean Huntunsigned ASTContext::NumImplicitMoveConstructors; 44ffe37fdda5b4b4f162a45155c30d9f60ce110c12Sean Huntunsigned ASTContext::NumImplicitMoveConstructorsDeclared; 45a376d10acfacf19d6dfa41069f7929739a18dd7aDouglas Gregorunsigned ASTContext::NumImplicitCopyAssignmentOperators; 46a376d10acfacf19d6dfa41069f7929739a18dd7aDouglas Gregorunsigned ASTContext::NumImplicitCopyAssignmentOperatorsDeclared; 47ffe37fdda5b4b4f162a45155c30d9f60ce110c12Sean Huntunsigned ASTContext::NumImplicitMoveAssignmentOperators; 48ffe37fdda5b4b4f162a45155c30d9f60ce110c12Sean Huntunsigned ASTContext::NumImplicitMoveAssignmentOperatorsDeclared; 494923aa25eb39d64106a5817c02d560a3aecf8b2cDouglas Gregorunsigned ASTContext::NumImplicitDestructors; 504923aa25eb39d64106a5817c02d560a3aecf8b2cDouglas Gregorunsigned ASTContext::NumImplicitDestructorsDeclared; 514923aa25eb39d64106a5817c02d560a3aecf8b2cDouglas Gregor 525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerenum FloatingRank { 53aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov HalfRank, FloatRank, DoubleRank, LongDoubleRank 545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}; 555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 563e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregorvoid 573e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas GregorASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID, 583e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor TemplateTemplateParmDecl *Parm) { 593e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor ID.AddInteger(Parm->getDepth()); 603e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor ID.AddInteger(Parm->getPosition()); 6161c4d28e36cd3f1be392cb77f07436d1fa6b0f9fDouglas Gregor ID.AddBoolean(Parm->isParameterPack()); 623e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 633e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor TemplateParameterList *Params = Parm->getTemplateParameters(); 643e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor ID.AddInteger(Params->size()); 653e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor for (TemplateParameterList::const_iterator P = Params->begin(), 663e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PEnd = Params->end(); 673e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor P != PEnd; ++P) { 683e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) { 693e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor ID.AddInteger(0); 703e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor ID.AddBoolean(TTP->isParameterPack()); 713e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor continue; 723e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor } 733e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 743e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) { 753e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor ID.AddInteger(1); 7661c4d28e36cd3f1be392cb77f07436d1fa6b0f9fDouglas Gregor ID.AddBoolean(NTTP->isParameterPack()); 773e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor ID.AddPointer(NTTP->getType().getAsOpaquePtr()); 786952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor if (NTTP->isExpandedParameterPack()) { 796952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ID.AddBoolean(true); 806952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ID.AddInteger(NTTP->getNumExpansionTypes()); 816952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) 826952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ID.AddPointer(NTTP->getExpansionType(I).getAsOpaquePtr()); 836952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor } else 846952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ID.AddBoolean(false); 853e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor continue; 863e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor } 873e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 883e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P); 893e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor ID.AddInteger(2); 903e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor Profile(ID, TTP); 913e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor } 923e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor} 933e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 943e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas GregorTemplateTemplateParmDecl * 953e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas GregorASTContext::getCanonicalTemplateTemplateParmDecl( 964ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad TemplateTemplateParmDecl *TTP) const { 973e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // Check if we already have a canonical template template parameter. 983e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor llvm::FoldingSetNodeID ID; 993e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor CanonicalTemplateTemplateParm::Profile(ID, TTP); 1003e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor void *InsertPos = 0; 1013e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor CanonicalTemplateTemplateParm *Canonical 1023e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos); 1033e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor if (Canonical) 1043e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor return Canonical->getParam(); 1053e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 1063e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // Build a canonical template parameter list. 1073e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor TemplateParameterList *Params = TTP->getTemplateParameters(); 1085f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<NamedDecl *, 4> CanonParams; 1093e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor CanonParams.reserve(Params->size()); 1103e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor for (TemplateParameterList::const_iterator P = Params->begin(), 1113e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PEnd = Params->end(); 1123e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor P != PEnd; ++P) { 1133e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) 1143e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor CanonParams.push_back( 1153e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor TemplateTypeParmDecl::Create(*this, getTranslationUnitDecl(), 116344577e6b58f42d18dc8118c8903b49a85dc005eAbramo Bagnara SourceLocation(), 117344577e6b58f42d18dc8118c8903b49a85dc005eAbramo Bagnara SourceLocation(), 118344577e6b58f42d18dc8118c8903b49a85dc005eAbramo Bagnara TTP->getDepth(), 1193e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor TTP->getIndex(), 0, false, 1203e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor TTP->isParameterPack())); 1213e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor else if (NonTypeTemplateParmDecl *NTTP 1226952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(*P)) { 1236952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor QualType T = getCanonicalType(NTTP->getType()); 1246952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(T); 1256952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor NonTypeTemplateParmDecl *Param; 1266952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor if (NTTP->isExpandedParameterPack()) { 1275f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 2> ExpandedTypes; 1285f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TypeSourceInfo *, 2> ExpandedTInfos; 1296952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) { 1306952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ExpandedTypes.push_back(getCanonicalType(NTTP->getExpansionType(I))); 1316952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ExpandedTInfos.push_back( 1326952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor getTrivialTypeSourceInfo(ExpandedTypes.back())); 1336952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor } 1346952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor 1356952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(), 136ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara SourceLocation(), 137ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara SourceLocation(), 1386952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor NTTP->getDepth(), 1396952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor NTTP->getPosition(), 0, 1406952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor T, 1416952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor TInfo, 1426952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ExpandedTypes.data(), 1436952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ExpandedTypes.size(), 1446952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ExpandedTInfos.data()); 1456952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor } else { 1466952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(), 147ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara SourceLocation(), 148ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara SourceLocation(), 1496952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor NTTP->getDepth(), 1506952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor NTTP->getPosition(), 0, 1516952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor T, 1526952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor NTTP->isParameterPack(), 1536952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor TInfo); 1546952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor } 1556952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor CanonParams.push_back(Param); 1566952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor 1576952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor } else 1583e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor CanonParams.push_back(getCanonicalTemplateTemplateParmDecl( 1593e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor cast<TemplateTemplateParmDecl>(*P))); 1603e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor } 1613e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 1623e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor TemplateTemplateParmDecl *CanonTTP 1633e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor = TemplateTemplateParmDecl::Create(*this, getTranslationUnitDecl(), 1643e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor SourceLocation(), TTP->getDepth(), 16561c4d28e36cd3f1be392cb77f07436d1fa6b0f9fDouglas Gregor TTP->getPosition(), 16661c4d28e36cd3f1be392cb77f07436d1fa6b0f9fDouglas Gregor TTP->isParameterPack(), 16761c4d28e36cd3f1be392cb77f07436d1fa6b0f9fDouglas Gregor 0, 1683e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor TemplateParameterList::Create(*this, SourceLocation(), 1693e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor SourceLocation(), 1703e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor CanonParams.data(), 1713e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor CanonParams.size(), 1723e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor SourceLocation())); 1733e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 1743e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // Get the new insert position for the node we care about. 1753e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos); 1763e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor assert(Canonical == 0 && "Shouldn't be in the map!"); 1773e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor (void)Canonical; 1783e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 1793e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // Create the canonical template template parameter entry. 1803e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor Canonical = new (*this) CanonicalTemplateTemplateParm(CanonTTP); 1813e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos); 1823e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor return CanonTTP; 1833e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor} 1843e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 185071cc7deffad608165b1ddd5263e8bf181861520Charles DavisCXXABI *ASTContext::createCXXABI(const TargetInfo &T) { 186ee79a4c30e5d1c5285551c9a25b8ec6d45d46aa7John McCall if (!LangOpts.CPlusPlus) return 0; 187ee79a4c30e5d1c5285551c9a25b8ec6d45d46aa7John McCall 18820cf717034ba1f20fc47c025ecb72ed9b631ad13Charles Davis switch (T.getCXXABI()) { 189ee79a4c30e5d1c5285551c9a25b8ec6d45d46aa7John McCall case CXXABI_ARM: 190ee79a4c30e5d1c5285551c9a25b8ec6d45d46aa7John McCall return CreateARMCXXABI(*this); 191ee79a4c30e5d1c5285551c9a25b8ec6d45d46aa7John McCall case CXXABI_Itanium: 192071cc7deffad608165b1ddd5263e8bf181861520Charles Davis return CreateItaniumCXXABI(*this); 19320cf717034ba1f20fc47c025ecb72ed9b631ad13Charles Davis case CXXABI_Microsoft: 19420cf717034ba1f20fc47c025ecb72ed9b631ad13Charles Davis return CreateMicrosoftCXXABI(*this); 19520cf717034ba1f20fc47c025ecb72ed9b631ad13Charles Davis } 196ee79a4c30e5d1c5285551c9a25b8ec6d45d46aa7John McCall return 0; 197071cc7deffad608165b1ddd5263e8bf181861520Charles Davis} 198071cc7deffad608165b1ddd5263e8bf181861520Charles Davis 199bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregorstatic const LangAS::Map *getAddressSpaceMap(const TargetInfo &T, 200207f4d8543529221932af82836016a2ef066c917Peter Collingbourne const LangOptions &LOpts) { 201207f4d8543529221932af82836016a2ef066c917Peter Collingbourne if (LOpts.FakeAddressSpaceMap) { 202207f4d8543529221932af82836016a2ef066c917Peter Collingbourne // The fake address space map must have a distinct entry for each 203207f4d8543529221932af82836016a2ef066c917Peter Collingbourne // language-specific address space. 204207f4d8543529221932af82836016a2ef066c917Peter Collingbourne static const unsigned FakeAddrSpaceMap[] = { 205207f4d8543529221932af82836016a2ef066c917Peter Collingbourne 1, // opencl_global 206207f4d8543529221932af82836016a2ef066c917Peter Collingbourne 2, // opencl_local 207207f4d8543529221932af82836016a2ef066c917Peter Collingbourne 3 // opencl_constant 208207f4d8543529221932af82836016a2ef066c917Peter Collingbourne }; 209bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor return &FakeAddrSpaceMap; 210207f4d8543529221932af82836016a2ef066c917Peter Collingbourne } else { 211bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor return &T.getAddressSpaceMap(); 212207f4d8543529221932af82836016a2ef066c917Peter Collingbourne } 213207f4d8543529221932af82836016a2ef066c917Peter Collingbourne} 214207f4d8543529221932af82836016a2ef066c917Peter Collingbourne 2153e3cd93b2fd9644e970c389e715c13883faf68b6Douglas GregorASTContext::ASTContext(LangOptions& LOpts, SourceManager &SM, 216bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor const TargetInfo *t, 217e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar IdentifierTable &idents, SelectorTable &sels, 2181b63e4f732dbc73d90abf886b4d21f8e3a165f6dChris Lattner Builtin::Context &builtins, 219bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor unsigned size_reserve, 220bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor bool DelayInitialization) 221bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor : FunctionProtoTypes(this_()), 222bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor TemplateSpecializationTypes(this_()), 223bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor DependentTemplateSpecializationTypes(this_()), 224bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor SubstTemplateTemplateParmPacks(this_()), 225bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor GlobalNestedNameSpecifier(0), 226bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Int128Decl(0), UInt128Decl(0), 227bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor ObjCIdDecl(0), ObjCSelDecl(0), ObjCClassDecl(0), 228e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor CFConstantStringTypeDecl(0), ObjCInstanceTypeDecl(0), 229bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor FILEDecl(0), 230e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola jmp_bufDecl(0), sigjmp_bufDecl(0), ucontext_tDecl(0), 231e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola BlockDescriptorType(0), BlockDescriptorExtendedType(0), 232e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola cudaConfigureCallDecl(0), 233e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor NullTypeSourceInfo(QualType()), 234e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor FirstLocalImport(), LastLocalImport(), 235bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor SourceMgr(SM), LangOpts(LOpts), 23630c42404202d2e2512e51efc6066bd614cfdb5a4Douglas Gregor AddrSpaceMap(0), Target(t), PrintingPolicy(LOpts), 237bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Idents(idents), Selectors(sels), 238bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor BuiltinInfo(builtins), 239bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor DeclarationNames(*this), 24030c42404202d2e2512e51efc6066bd614cfdb5a4Douglas Gregor ExternalSource(0), Listener(0), 241bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor LastSDM(0, 0), 242bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor UniqueBlockByRefTypeID(0) 243bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor{ 2441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (size_reserve > 0) Types.reserve(size_reserve); 245e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar TUDecl = TranslationUnitDecl::Create(*this); 246bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor 247bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor if (!DelayInitialization) { 248bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor assert(t && "No target supplied for ASTContext initialization"); 249bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor InitBuiltinTypes(*t); 250bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor } 251e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar} 252e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar 2535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerASTContext::~ASTContext() { 2543478eb6872d836600caf45b0f81c2065d685d6e0Ted Kremenek // Release the DenseMaps associated with DeclContext objects. 2553478eb6872d836600caf45b0f81c2065d685d6e0Ted Kremenek // FIXME: Is this the ideal solution? 2563478eb6872d836600caf45b0f81c2065d685d6e0Ted Kremenek ReleaseDeclContextMaps(); 2577d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 25863fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor // Call all of the deallocation functions. 25963fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor for (unsigned I = 0, N = Deallocations.size(); I != N; ++I) 26063fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor Deallocations[I].first(Deallocations[I].second); 2610054531488928a424666ac11fcdc6bcc5112de52Douglas Gregor 2627d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor // Release all of the memory associated with overridden C++ methods. 2637d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor for (llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::iterator 2647d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor OM = OverriddenMethods.begin(), OMEnd = OverriddenMethods.end(); 2657d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor OM != OMEnd; ++OM) 2667d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor OM->second.Destroy(); 2673478eb6872d836600caf45b0f81c2065d685d6e0Ted Kremenek 268dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek // ASTRecordLayout objects in ASTRecordLayouts must always be destroyed 26963fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor // because they can contain DenseMaps. 27063fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor for (llvm::DenseMap<const ObjCContainerDecl*, 27163fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor const ASTRecordLayout*>::iterator 27263fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor I = ObjCLayouts.begin(), E = ObjCLayouts.end(); I != E; ) 27363fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor // Increment in loop to prevent using deallocated memory. 27463fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor if (ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second)) 27563fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor R->Destroy(*this); 27663fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor 277dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator 278dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) { 279dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek // Increment in loop to prevent using deallocated memory. 280dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek if (ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second)) 281dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek R->Destroy(*this); 282dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek } 2836320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 2846320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(), 2856320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor AEnd = DeclAttrs.end(); 2866320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor A != AEnd; ++A) 2876320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor A->second->~AttrVec(); 2886320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor} 289ab452ba8323d1985e08bade2bced588cddf2cc28Douglas Gregor 2900054531488928a424666ac11fcdc6bcc5112de52Douglas Gregorvoid ASTContext::AddDeallocation(void (*Callback)(void*), void *Data) { 2910054531488928a424666ac11fcdc6bcc5112de52Douglas Gregor Deallocations.push_back(std::make_pair(Callback, Data)); 2920054531488928a424666ac11fcdc6bcc5112de52Douglas Gregor} 2930054531488928a424666ac11fcdc6bcc5112de52Douglas Gregor 2941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid 2952cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas GregorASTContext::setExternalSource(llvm::OwningPtr<ExternalASTSource> &Source) { 2962cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor ExternalSource.reset(Source.take()); 2972cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor} 2982cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor 2995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid ASTContext::PrintStats() const { 300cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << "\n*** AST Context Stats:\n"; 301cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << " " << Types.size() << " types total.\n"; 3027c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 303dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor unsigned counts[] = { 3041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump#define TYPE(Name, Parent) 0, 305dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor#define ABSTRACT_TYPE(Name, Parent) 306dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor#include "clang/AST/TypeNodes.def" 307dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor 0 // Extra 308dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor }; 309c2ee10d79f70036af652a395ac1f8273f3d04e12Douglas Gregor 3105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0, e = Types.size(); i != e; ++i) { 3115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Type *T = Types[i]; 312dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor counts[(unsigned)T->getTypeClass()]++; 3135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 315dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor unsigned Idx = 0; 316dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor unsigned TotalBytes = 0; 317dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor#define TYPE(Name, Parent) \ 318dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor if (counts[Idx]) \ 319cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << " " << counts[Idx] << " " << #Name \ 320cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " types\n"; \ 321dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor TotalBytes += counts[Idx] * sizeof(Name##Type); \ 322dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor ++Idx; 323dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor#define ABSTRACT_TYPE(Name, Parent) 324dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor#include "clang/AST/TypeNodes.def" 3251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 326cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << "Total bytes = " << TotalBytes << "\n"; 327cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth 3284923aa25eb39d64106a5817c02d560a3aecf8b2cDouglas Gregor // Implicit special member functions. 329cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << NumImplicitDefaultConstructorsDeclared << "/" 330cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << NumImplicitDefaultConstructors 331cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " implicit default constructors created\n"; 332cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << NumImplicitCopyConstructorsDeclared << "/" 333cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << NumImplicitCopyConstructors 334cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " implicit copy constructors created\n"; 335ffe37fdda5b4b4f162a45155c30d9f60ce110c12Sean Hunt if (getLangOptions().CPlusPlus) 336cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << NumImplicitMoveConstructorsDeclared << "/" 337cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << NumImplicitMoveConstructors 338cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " implicit move constructors created\n"; 339cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << NumImplicitCopyAssignmentOperatorsDeclared << "/" 340cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << NumImplicitCopyAssignmentOperators 341cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " implicit copy assignment operators created\n"; 342ffe37fdda5b4b4f162a45155c30d9f60ce110c12Sean Hunt if (getLangOptions().CPlusPlus) 343cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << NumImplicitMoveAssignmentOperatorsDeclared << "/" 344cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << NumImplicitMoveAssignmentOperators 345cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " implicit move assignment operators created\n"; 346cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << NumImplicitDestructorsDeclared << "/" 347cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << NumImplicitDestructors 348cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " implicit destructors created\n"; 349cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth 3502cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor if (ExternalSource.get()) { 351cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << "\n"; 3522cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor ExternalSource->PrintStats(); 3532cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor } 354cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth 35563fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor BumpAlloc.PrintStats(); 3565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 358772eeaefef2c883aabe35caf4543e7e32d290183Douglas GregorTypedefDecl *ASTContext::getInt128Decl() const { 359772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor if (!Int128Decl) { 360772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(Int128Ty); 361772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor Int128Decl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 362772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor getTranslationUnitDecl(), 363772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor SourceLocation(), 364772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor SourceLocation(), 365772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor &Idents.get("__int128_t"), 366772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor TInfo); 367772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor } 368772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor 369772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor return Int128Decl; 370772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor} 371772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor 372772eeaefef2c883aabe35caf4543e7e32d290183Douglas GregorTypedefDecl *ASTContext::getUInt128Decl() const { 373772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor if (!UInt128Decl) { 374772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(UnsignedInt128Ty); 375772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor UInt128Decl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 376772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor getTranslationUnitDecl(), 377772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor SourceLocation(), 378772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor SourceLocation(), 379772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor &Idents.get("__uint128_t"), 380772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor TInfo); 381772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor } 382772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor 383772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor return UInt128Decl; 384772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor} 3855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 386e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCallvoid ASTContext::InitBuiltinType(CanQualType &R, BuiltinType::Kind K) { 3876b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall BuiltinType *Ty = new (*this, TypeAlignment) BuiltinType(K); 388e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCall R = CanQualType::CreateUnsafe(QualType(Ty, 0)); 3896b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall Types.push_back(Ty); 3905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 392bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregorvoid ASTContext::InitBuiltinTypes(const TargetInfo &Target) { 393bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor assert((!this->Target || this->Target == &Target) && 394bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor "Incorrect target reinitialization"); 3955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(VoidTy.isNull() && "Context reinitialized?"); 3961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 397bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor this->Target = &Target; 398bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor 399bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor ABI.reset(createCXXABI(Target)); 400bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor AddrSpaceMap = getAddressSpaceMap(Target, LangOpts); 401bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor 4025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p19. 4035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(VoidTy, BuiltinType::Void); 4041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p2. 4065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(BoolTy, BuiltinType::Bool); 4075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p3. 40815b91764d08e886391c865c4a444d7b51141c284Eli Friedman if (LangOpts.CharIsSigned) 4095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(CharTy, BuiltinType::Char_S); 4105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer else 4115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(CharTy, BuiltinType::Char_U); 4125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p4. 4135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(SignedCharTy, BuiltinType::SChar); 4145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(ShortTy, BuiltinType::Short); 4155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(IntTy, BuiltinType::Int); 4165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(LongTy, BuiltinType::Long); 4175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(LongLongTy, BuiltinType::LongLong); 4181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p6. 4205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(UnsignedCharTy, BuiltinType::UChar); 4215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(UnsignedShortTy, BuiltinType::UShort); 4225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(UnsignedIntTy, BuiltinType::UInt); 4235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(UnsignedLongTy, BuiltinType::ULong); 4245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(UnsignedLongLongTy, BuiltinType::ULongLong); 4251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p10. 4275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(FloatTy, BuiltinType::Float); 4285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(DoubleTy, BuiltinType::Double); 4295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(LongDoubleTy, BuiltinType::LongDouble); 43064c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 4312df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner // GNU extension, 128-bit integers. 4322df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner InitBuiltinType(Int128Ty, BuiltinType::Int128); 4332df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner InitBuiltinType(UnsignedInt128Ty, BuiltinType::UInt128); 4342df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner 4353f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner if (LangOpts.CPlusPlus) { // C++ 3.9.1p5 436d3d77cd138f8e830f6547b6f83fcd5721ccf5f5dEli Friedman if (TargetInfo::isTypeSigned(Target.getWCharType())) 4373f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner InitBuiltinType(WCharTy, BuiltinType::WChar_S); 4383f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner else // -fshort-wchar makes wchar_t be unsigned. 4393f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner InitBuiltinType(WCharTy, BuiltinType::WChar_U); 4403f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner } else // C99 4413a2503227c3db04a3619735127483263c1075ef7Chris Lattner WCharTy = getFromTargetType(Target.getWCharType()); 44264c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 443f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++ 444f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith InitBuiltinType(Char16Ty, BuiltinType::Char16); 445f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith else // C99 446f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith Char16Ty = getFromTargetType(Target.getChar16Type()); 447f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith 448f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++ 449f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith InitBuiltinType(Char32Ty, BuiltinType::Char32); 450f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith else // C99 451f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith Char32Ty = getFromTargetType(Target.getChar32Type()); 452f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith 453898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // Placeholder type for type-dependent expressions whose type is 454898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // completely unknown. No code should ever check a type against 455898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // DependentTy and users should never see it; however, it is here to 456898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // help diagnose failures to properly check for type-dependent 457898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // expressions. 458898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor InitBuiltinType(DependentTy, BuiltinType::Dependent); 4598e9bebdea69c590dedfbf27374114cb76fe12fbdDouglas Gregor 4602a984cad5ac3fdceeff2bd99daa7b90979313475John McCall // Placeholder type for functions. 4612a984cad5ac3fdceeff2bd99daa7b90979313475John McCall InitBuiltinType(OverloadTy, BuiltinType::Overload); 4622a984cad5ac3fdceeff2bd99daa7b90979313475John McCall 463864c041e118155c2b1ce0ba36942a3da5a4a055eJohn McCall // Placeholder type for bound members. 464864c041e118155c2b1ce0ba36942a3da5a4a055eJohn McCall InitBuiltinType(BoundMemberTy, BuiltinType::BoundMember); 465864c041e118155c2b1ce0ba36942a3da5a4a055eJohn McCall 4663c3b7f90a863af43fa63043d396553ecf205351cJohn McCall // Placeholder type for pseudo-objects. 4673c3b7f90a863af43fa63043d396553ecf205351cJohn McCall InitBuiltinType(PseudoObjectTy, BuiltinType::PseudoObject); 4683c3b7f90a863af43fa63043d396553ecf205351cJohn McCall 4691de4d4e8cb2e9c88809fea8092bc6e835a5473d2John McCall // "any" type; useful for debugger-like clients. 4701de4d4e8cb2e9c88809fea8092bc6e835a5473d2John McCall InitBuiltinType(UnknownAnyTy, BuiltinType::UnknownAny); 4711de4d4e8cb2e9c88809fea8092bc6e835a5473d2John McCall 4720ddaeb9b031070ec64afe92d9892875ac44df427John McCall // Placeholder type for unbridged ARC casts. 4730ddaeb9b031070ec64afe92d9892875ac44df427John McCall InitBuiltinType(ARCUnbridgedCastTy, BuiltinType::ARCUnbridgedCast); 4740ddaeb9b031070ec64afe92d9892875ac44df427John McCall 4755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p11. 4765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer FloatComplexTy = getComplexType(FloatTy); 4775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer DoubleComplexTy = getComplexType(DoubleTy); 4785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer LongDoubleComplexTy = getComplexType(LongDoubleTy); 4798e9bebdea69c590dedfbf27374114cb76fe12fbdDouglas Gregor 4807e219e47de26346885d667131977bd9ca2d7662aSteve Naroff BuiltinVaListType = QualType(); 4811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 48213dcd00615de5c4279d97bdf63cd5f0a14fd9dccFariborz Jahanian // Builtin types for 'id', 'Class', and 'SEL'. 483de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId); 484de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff InitBuiltinType(ObjCBuiltinClassTy, BuiltinType::ObjCClass); 48513dcd00615de5c4279d97bdf63cd5f0a14fd9dccFariborz Jahanian InitBuiltinType(ObjCBuiltinSelTy, BuiltinType::ObjCSel); 48614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 487a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCConstantStringType = QualType(); 4881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 48933e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // void * type 49033e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian VoidPtrTy = getPointerType(VoidTy); 4916e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl 4926e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl // nullptr type (C++0x 2.14.7) 4936e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl InitBuiltinType(NullPtrTy, BuiltinType::NullPtr); 494aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov 495aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov // half type (OpenCL 6.1.1.1) / ARM NEON __fp16 496aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov InitBuiltinType(HalfTy, BuiltinType::Half); 4975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 4985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 499d6471f7c1921c7802804ce3ff6fe9768310f72b9David BlaikieDiagnosticsEngine &ASTContext::getDiagnostics() const { 50078a916ec5ff5b66adec3c499e1b9af7b87668309Argyrios Kyrtzidis return SourceMgr.getDiagnostics(); 50178a916ec5ff5b66adec3c499e1b9af7b87668309Argyrios Kyrtzidis} 50278a916ec5ff5b66adec3c499e1b9af7b87668309Argyrios Kyrtzidis 5036320064d0c60fa8683f5623881c9394fd4aa7689Douglas GregorAttrVec& ASTContext::getDeclAttrs(const Decl *D) { 5046320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor AttrVec *&Result = DeclAttrs[D]; 5056320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor if (!Result) { 5066320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor void *Mem = Allocate(sizeof(AttrVec)); 5076320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor Result = new (Mem) AttrVec; 5086320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor } 5096320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 5106320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor return *Result; 5116320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor} 5126320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 5136320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor/// \brief Erase the attributes corresponding to the given declaration. 5146320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregorvoid ASTContext::eraseDeclAttrs(const Decl *D) { 5156320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D); 5166320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor if (Pos != DeclAttrs.end()) { 5176320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor Pos->second->~AttrVec(); 5186320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor DeclAttrs.erase(Pos); 5196320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor } 5206320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor} 5216320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 522251b4ff2578e26959a4c036140ccd61c5e9292f2Douglas GregorMemberSpecializationInfo * 523663b5a0be7261c29bc4c526a71cffcfa02d4153eDouglas GregorASTContext::getInstantiatedFromStaticDataMember(const VarDecl *Var) { 5247caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor assert(Var->isStaticDataMember() && "Not a static data member"); 525663b5a0be7261c29bc4c526a71cffcfa02d4153eDouglas Gregor llvm::DenseMap<const VarDecl *, MemberSpecializationInfo *>::iterator Pos 5267caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor = InstantiatedFromStaticDataMember.find(Var); 5277caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor if (Pos == InstantiatedFromStaticDataMember.end()) 5287caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor return 0; 5291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5307caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor return Pos->second; 5317caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor} 5327caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor 5331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid 534251b4ff2578e26959a4c036140ccd61c5e9292f2Douglas GregorASTContext::setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl, 5359421adc43891e272156fab640e5d5ee5054b779cArgyrios Kyrtzidis TemplateSpecializationKind TSK, 5369421adc43891e272156fab640e5d5ee5054b779cArgyrios Kyrtzidis SourceLocation PointOfInstantiation) { 5377caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor assert(Inst->isStaticDataMember() && "Not a static data member"); 5387caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor assert(Tmpl->isStaticDataMember() && "Not a static data member"); 5397caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor assert(!InstantiatedFromStaticDataMember[Inst] && 5407caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor "Already noted what static data member was instantiated from"); 541251b4ff2578e26959a4c036140ccd61c5e9292f2Douglas Gregor InstantiatedFromStaticDataMember[Inst] 5429421adc43891e272156fab640e5d5ee5054b779cArgyrios Kyrtzidis = new (*this) MemberSpecializationInfo(Tmpl, TSK, PointOfInstantiation); 5437caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor} 5447caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor 545af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois PichetFunctionDecl *ASTContext::getClassScopeSpecializationPattern( 546af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet const FunctionDecl *FD){ 547af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet assert(FD && "Specialization is 0"); 548af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet llvm::DenseMap<const FunctionDecl*, FunctionDecl *>::const_iterator Pos 5490d95f0d7b81110f77e99e833f766d19be7b7e072Francois Pichet = ClassScopeSpecializationPattern.find(FD); 5500d95f0d7b81110f77e99e833f766d19be7b7e072Francois Pichet if (Pos == ClassScopeSpecializationPattern.end()) 551af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet return 0; 552af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet 553af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet return Pos->second; 554af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet} 555af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet 556af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichetvoid ASTContext::setClassScopeSpecializationPattern(FunctionDecl *FD, 557af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet FunctionDecl *Pattern) { 558af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet assert(FD && "Specialization is 0"); 559af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet assert(Pattern && "Class scope specialization pattern is 0"); 5600d95f0d7b81110f77e99e833f766d19be7b7e072Francois Pichet ClassScopeSpecializationPattern[FD] = Pattern; 561af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet} 562af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet 5637ba107a1863ddfa1664555854f0d7bdb3c491c92John McCallNamedDecl * 564ed97649e9574b9d854fa4d6109c9333ae0993554John McCallASTContext::getInstantiatedFromUsingDecl(UsingDecl *UUD) { 5657ba107a1863ddfa1664555854f0d7bdb3c491c92John McCall llvm::DenseMap<UsingDecl *, NamedDecl *>::const_iterator Pos 566ed97649e9574b9d854fa4d6109c9333ae0993554John McCall = InstantiatedFromUsingDecl.find(UUD); 567ed97649e9574b9d854fa4d6109c9333ae0993554John McCall if (Pos == InstantiatedFromUsingDecl.end()) 5680d8df780aef1acda5962347a32591efc629b6748Anders Carlsson return 0; 5691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5700d8df780aef1acda5962347a32591efc629b6748Anders Carlsson return Pos->second; 5710d8df780aef1acda5962347a32591efc629b6748Anders Carlsson} 5720d8df780aef1acda5962347a32591efc629b6748Anders Carlsson 5730d8df780aef1acda5962347a32591efc629b6748Anders Carlssonvoid 574ed97649e9574b9d854fa4d6109c9333ae0993554John McCallASTContext::setInstantiatedFromUsingDecl(UsingDecl *Inst, NamedDecl *Pattern) { 575ed97649e9574b9d854fa4d6109c9333ae0993554John McCall assert((isa<UsingDecl>(Pattern) || 576ed97649e9574b9d854fa4d6109c9333ae0993554John McCall isa<UnresolvedUsingValueDecl>(Pattern) || 577ed97649e9574b9d854fa4d6109c9333ae0993554John McCall isa<UnresolvedUsingTypenameDecl>(Pattern)) && 578ed97649e9574b9d854fa4d6109c9333ae0993554John McCall "pattern decl is not a using decl"); 579ed97649e9574b9d854fa4d6109c9333ae0993554John McCall assert(!InstantiatedFromUsingDecl[Inst] && "pattern already exists"); 580ed97649e9574b9d854fa4d6109c9333ae0993554John McCall InstantiatedFromUsingDecl[Inst] = Pattern; 581ed97649e9574b9d854fa4d6109c9333ae0993554John McCall} 582ed97649e9574b9d854fa4d6109c9333ae0993554John McCall 583ed97649e9574b9d854fa4d6109c9333ae0993554John McCallUsingShadowDecl * 584ed97649e9574b9d854fa4d6109c9333ae0993554John McCallASTContext::getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst) { 585ed97649e9574b9d854fa4d6109c9333ae0993554John McCall llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos 586ed97649e9574b9d854fa4d6109c9333ae0993554John McCall = InstantiatedFromUsingShadowDecl.find(Inst); 587ed97649e9574b9d854fa4d6109c9333ae0993554John McCall if (Pos == InstantiatedFromUsingShadowDecl.end()) 588ed97649e9574b9d854fa4d6109c9333ae0993554John McCall return 0; 589ed97649e9574b9d854fa4d6109c9333ae0993554John McCall 590ed97649e9574b9d854fa4d6109c9333ae0993554John McCall return Pos->second; 591ed97649e9574b9d854fa4d6109c9333ae0993554John McCall} 592ed97649e9574b9d854fa4d6109c9333ae0993554John McCall 593ed97649e9574b9d854fa4d6109c9333ae0993554John McCallvoid 594ed97649e9574b9d854fa4d6109c9333ae0993554John McCallASTContext::setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, 595ed97649e9574b9d854fa4d6109c9333ae0993554John McCall UsingShadowDecl *Pattern) { 596ed97649e9574b9d854fa4d6109c9333ae0993554John McCall assert(!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists"); 597ed97649e9574b9d854fa4d6109c9333ae0993554John McCall InstantiatedFromUsingShadowDecl[Inst] = Pattern; 5980d8df780aef1acda5962347a32591efc629b6748Anders Carlsson} 5990d8df780aef1acda5962347a32591efc629b6748Anders Carlsson 600d8b285fee4471f393da8ee30f552ceacdc362afaAnders CarlssonFieldDecl *ASTContext::getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) { 601d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos 602d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson = InstantiatedFromUnnamedFieldDecl.find(Field); 603d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson if (Pos == InstantiatedFromUnnamedFieldDecl.end()) 604d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson return 0; 6051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 606d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson return Pos->second; 607d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson} 608d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson 609d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlssonvoid ASTContext::setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, 610d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson FieldDecl *Tmpl) { 611d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson assert(!Inst->getDeclName() && "Instantiated field decl is not unnamed"); 612d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson assert(!Tmpl->getDeclName() && "Template field decl is not unnamed"); 613d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson assert(!InstantiatedFromUnnamedFieldDecl[Inst] && 614d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson "Already noted what unnamed field was instantiated from"); 6151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 616d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl; 617d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson} 618d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson 61914d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanianbool ASTContext::ZeroBitfieldFollowsNonBitfield(const FieldDecl *FD, 62014d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanian const FieldDecl *LastFD) const { 62114d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanian return (FD->isBitField() && LastFD && !LastFD->isBitField() && 622a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith FD->getBitWidthValue(*this) == 0); 62314d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanian} 62414d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanian 625340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanianbool ASTContext::ZeroBitfieldFollowsBitfield(const FieldDecl *FD, 626340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanian const FieldDecl *LastFD) const { 627340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanian return (FD->isBitField() && LastFD && LastFD->isBitField() && 628a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith FD->getBitWidthValue(*this) == 0 && 629a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith LastFD->getBitWidthValue(*this) != 0); 630340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanian} 631340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanian 6329b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanianbool ASTContext::BitfieldFollowsBitfield(const FieldDecl *FD, 6339b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanian const FieldDecl *LastFD) const { 6349b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanian return (FD->isBitField() && LastFD && LastFD->isBitField() && 635a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith FD->getBitWidthValue(*this) && 636a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith LastFD->getBitWidthValue(*this)); 6379b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanian} 6389b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanian 639dd7fddb5b6883326e52b278a9b7e9cefea29aae0Chad Rosierbool ASTContext::NonBitfieldFollowsBitfield(const FieldDecl *FD, 64052bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian const FieldDecl *LastFD) const { 64152bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian return (!FD->isBitField() && LastFD && LastFD->isBitField() && 642a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith LastFD->getBitWidthValue(*this)); 64352bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian} 64452bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian 645dd7fddb5b6883326e52b278a9b7e9cefea29aae0Chad Rosierbool ASTContext::BitfieldFollowsNonBitfield(const FieldDecl *FD, 64652bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian const FieldDecl *LastFD) const { 64752bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian return (FD->isBitField() && LastFD && !LastFD->isBitField() && 648a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith FD->getBitWidthValue(*this)); 64952bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian} 65052bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian 6517d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas GregorASTContext::overridden_cxx_method_iterator 6527d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas GregorASTContext::overridden_methods_begin(const CXXMethodDecl *Method) const { 6537d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 6547d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor = OverriddenMethods.find(Method); 6557d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor if (Pos == OverriddenMethods.end()) 6567d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor return 0; 6577d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 6587d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor return Pos->second.begin(); 6597d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor} 6607d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 6617d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas GregorASTContext::overridden_cxx_method_iterator 6627d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas GregorASTContext::overridden_methods_end(const CXXMethodDecl *Method) const { 6637d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 6647d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor = OverriddenMethods.find(Method); 6657d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor if (Pos == OverriddenMethods.end()) 6667d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor return 0; 6677d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 6687d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor return Pos->second.end(); 6697d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor} 6707d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 671c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidisunsigned 672c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios KyrtzidisASTContext::overridden_methods_size(const CXXMethodDecl *Method) const { 673c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 674c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis = OverriddenMethods.find(Method); 675c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis if (Pos == OverriddenMethods.end()) 676c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis return 0; 677c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis 678c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis return Pos->second.size(); 679c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis} 680c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis 6817d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregorvoid ASTContext::addOverriddenMethod(const CXXMethodDecl *Method, 6827d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor const CXXMethodDecl *Overridden) { 6837d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor OverriddenMethods[Method].push_back(Overridden); 6847d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor} 6857d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 686e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregorvoid ASTContext::addedLocalImportDecl(ImportDecl *Import) { 687e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor assert(!Import->NextLocalImport && "Import declaration already in the chain"); 688e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor assert(!Import->isFromASTFile() && "Non-local import declaration"); 689e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor if (!FirstLocalImport) { 690e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor FirstLocalImport = Import; 691e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor LastLocalImport = Import; 692e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor return; 693e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor } 694e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor 695e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor LastLocalImport->NextLocalImport = Import; 696e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor LastLocalImport = Import; 697e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor} 698e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor 699464175bba1318bef7905122e9fda20cff926df78Chris Lattner//===----------------------------------------------------------------------===// 700464175bba1318bef7905122e9fda20cff926df78Chris Lattner// Type Sizing and Analysis 701464175bba1318bef7905122e9fda20cff926df78Chris Lattner//===----------------------------------------------------------------------===// 702a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 703b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner/// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified 704b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner/// scalar floating point type. 705b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattnerconst llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const { 706183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const BuiltinType *BT = T->getAs<BuiltinType>(); 707b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner assert(BT && "Not a floating point type!"); 708b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner switch (BT->getKind()) { 709b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Not a floating point type!"); 710aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov case BuiltinType::Half: return Target->getHalfFormat(); 711bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor case BuiltinType::Float: return Target->getFloatFormat(); 712bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor case BuiltinType::Double: return Target->getDoubleFormat(); 713bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor case BuiltinType::LongDouble: return Target->getLongDoubleFormat(); 714b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner } 715b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner} 716b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner 7178b752f10c394b140f9ef89e049cbad1a7676fc25Ken Dyck/// getDeclAlign - Return a conservative estimate of the alignment of the 718af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner/// specified decl. Note that bitfields do not have a valid alignment, so 719af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner/// this method will assert on them. 7205d484e8cf710207010720589d89602233de61d01Sebastian Redl/// If @p RefAsPointee, references are treated like their underlying type 7215d484e8cf710207010720589d89602233de61d01Sebastian Redl/// (for alignof), else they're treated like pointers (for CodeGen). 7224ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getDeclAlign(const Decl *D, bool RefAsPointee) const { 723bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor unsigned Align = Target->getCharWidth(); 724dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman 7254081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall bool UseAlignAttrOnly = false; 7264081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall if (unsigned AlignFromAttr = D->getMaxAlignment()) { 7274081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall Align = AlignFromAttr; 7284081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall 7294081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // __attribute__((aligned)) can increase or decrease alignment 7304081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // *except* on a struct or struct member, where it only increases 7314081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // alignment unless 'packed' is also specified. 7324081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // 73382d0b0aab9088e977c2a44c4a5a90479c63149fePeter Collingbourne // It is an error for alignas to decrease alignment, so we can 7344081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // ignore that possibility; Sema should diagnose it. 7354081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall if (isa<FieldDecl>(D)) { 7364081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall UseAlignAttrOnly = D->hasAttr<PackedAttr>() || 7374081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>(); 7384081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall } else { 7394081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall UseAlignAttrOnly = true; 7404081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall } 7414081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall } 74278a7d7d79964119a3f35b262eb154b5cbf1001edFariborz Jahanian else if (isa<FieldDecl>(D)) 74378a7d7d79964119a3f35b262eb154b5cbf1001edFariborz Jahanian UseAlignAttrOnly = 74478a7d7d79964119a3f35b262eb154b5cbf1001edFariborz Jahanian D->hasAttr<PackedAttr>() || 74578a7d7d79964119a3f35b262eb154b5cbf1001edFariborz Jahanian cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>(); 746dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman 747ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // If we're using the align attribute only, just ignore everything 748ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // else about the declaration and its type. 7494081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall if (UseAlignAttrOnly) { 750ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // do nothing 751ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 7524081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall } else if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) { 753af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner QualType T = VD->getType(); 7546217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const ReferenceType* RT = T->getAs<ReferenceType>()) { 7555d484e8cf710207010720589d89602233de61d01Sebastian Redl if (RefAsPointee) 7565d484e8cf710207010720589d89602233de61d01Sebastian Redl T = RT->getPointeeType(); 7575d484e8cf710207010720589d89602233de61d01Sebastian Redl else 7585d484e8cf710207010720589d89602233de61d01Sebastian Redl T = getPointerType(RT->getPointeeType()); 7595d484e8cf710207010720589d89602233de61d01Sebastian Redl } 7605d484e8cf710207010720589d89602233de61d01Sebastian Redl if (!T->isIncompleteType() && !T->isFunctionType()) { 7613b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Adjust alignments of declarations with array type by the 7623b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // large-array alignment on the target. 763bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor unsigned MinWidth = Target->getLargeArrayMinWidth(); 7643b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall const ArrayType *arrayType; 7653b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (MinWidth && (arrayType = getAsArrayType(T))) { 7663b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (isa<VariableArrayType>(arrayType)) 767bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = std::max(Align, Target->getLargeArrayAlign()); 7683b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall else if (isa<ConstantArrayType>(arrayType) && 7693b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall MinWidth <= getTypeSize(cast<ConstantArrayType>(arrayType))) 770bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = std::max(Align, Target->getLargeArrayAlign()); 7713b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 7723b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Walk through any array types while we're at it. 7733b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall T = getBaseElementType(arrayType); 7746deecb0d46bcfd048e651d2db7c4fb0d6407da96Rafael Espindola } 7759f1210c3280104417a4ad30f0a00825ac8fa718aChad Rosier Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr())); 776dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman } 777ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 778ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // Fields can be subject to extra alignment constraints, like if 779ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // the field is packed, the struct is packed, or the struct has a 780ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // a max-field-alignment constraint (#pragma pack). So calculate 781ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // the actual alignment of the field within the struct, and then 782ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // (as we're expected to) constrain that by the alignment of the type. 783ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall if (const FieldDecl *field = dyn_cast<FieldDecl>(VD)) { 784ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // So calculate the alignment of the field. 785ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall const ASTRecordLayout &layout = getASTRecordLayout(field->getParent()); 786ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 787ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // Start with the record's overall alignment. 788dac54c124e302d6f028ea5723c425b7f66fc7c71Ken Dyck unsigned fieldAlign = toBits(layout.getAlignment()); 789ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 790ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // Use the GCD of that and the offset within the record. 791ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall uint64_t offset = layout.getFieldOffset(field->getFieldIndex()); 792ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall if (offset > 0) { 793ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // Alignment is always a power of 2, so the GCD will be a power of 2, 794ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // which means we get to do this crazy thing instead of Euclid's. 795ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall uint64_t lowBitOfOffset = offset & (~offset + 1); 796ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall if (lowBitOfOffset < fieldAlign) 797ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall fieldAlign = static_cast<unsigned>(lowBitOfOffset); 798ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall } 799ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 800ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall Align = std::min(Align, fieldAlign); 80105f62474dd2b0f1cb69adbe0787f2868788aa949Charles Davis } 802af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner } 803dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman 804eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(Align); 805af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner} 806b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner 807ea1471e0e967548c596a71469702f8846dbaf3c0John McCallstd::pair<CharUnits, CharUnits> 808bee5a79fc95e3003d755031e3d2bb4410a71e1c1Ken DyckASTContext::getTypeInfoInChars(const Type *T) const { 809ea1471e0e967548c596a71469702f8846dbaf3c0John McCall std::pair<uint64_t, unsigned> Info = getTypeInfo(T); 810eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return std::make_pair(toCharUnitsFromBits(Info.first), 811eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck toCharUnitsFromBits(Info.second)); 812ea1471e0e967548c596a71469702f8846dbaf3c0John McCall} 813ea1471e0e967548c596a71469702f8846dbaf3c0John McCall 814ea1471e0e967548c596a71469702f8846dbaf3c0John McCallstd::pair<CharUnits, CharUnits> 815bee5a79fc95e3003d755031e3d2bb4410a71e1c1Ken DyckASTContext::getTypeInfoInChars(QualType T) const { 816ea1471e0e967548c596a71469702f8846dbaf3c0John McCall return getTypeInfoInChars(T.getTypePtr()); 817ea1471e0e967548c596a71469702f8846dbaf3c0John McCall} 818ea1471e0e967548c596a71469702f8846dbaf3c0John McCall 819a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner/// getTypeSize - Return the size of the specified type, in bits. This method 820a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner/// does not work on incomplete types. 8210953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// 8220953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// FIXME: Pointers into different addr spaces could have different sizes and 8230953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// alignment requirements: getPointerInfo should take an AddrSpace, this 8240953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// should take a QualType, &c. 825d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattnerstd::pair<uint64_t, unsigned> 8264ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getTypeInfo(const Type *T) const { 8275e301007e31e14c8ff647288e1b8bd8dbf8a5fe4Mike Stump uint64_t Width=0; 8285e301007e31e14c8ff647288e1b8bd8dbf8a5fe4Mike Stump unsigned Align=8; 829a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner switch (T->getTypeClass()) { 83072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define TYPE(Class, Base) 83172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define ABSTRACT_TYPE(Class, Base) 83218857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor#define NON_CANONICAL_TYPE(Class, Base) 83372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define DEPENDENT_TYPE(Class, Base) case Type::Class: 83472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#include "clang/AST/TypeNodes.def" 835d3d49bb27c7ffd9accc0a6c00e887111c0348845John McCall llvm_unreachable("Should not see dependent types"); 83672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor break; 83772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 8385d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner case Type::FunctionNoProto: 8395d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner case Type::FunctionProto: 84018857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor // GCC extension: alignof(function) = 32 bits 84118857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Width = 0; 84218857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Align = 32; 84318857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor break; 84418857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 84572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::IncompleteArray: 846fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case Type::VariableArray: 84718857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Width = 0; 84818857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Align = getTypeAlign(cast<ArrayType>(T)->getElementType()); 84918857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor break; 85018857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 851fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case Type::ConstantArray: { 8521d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const ConstantArrayType *CAT = cast<ConstantArrayType>(T); 8531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 85498be4943e8dc4f3905629a7102668960873cf863Chris Lattner std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(CAT->getElementType()); 855fea966a4103ed9c018d1494b95e9d09b161f5a70Abramo Bagnara uint64_t Size = CAT->getSize().getZExtValue(); 856fea966a4103ed9c018d1494b95e9d09b161f5a70Abramo Bagnara assert((Size == 0 || EltInfo.first <= (uint64_t)(-1)/Size) && "Overflow in array type bit size evaluation"); 857fea966a4103ed9c018d1494b95e9d09b161f5a70Abramo Bagnara Width = EltInfo.first*Size; 858030d8846c7e520330007087e949f621989876e3aChris Lattner Align = EltInfo.second; 859cd88b4171753dcb2bc0a21d78f1597c796bb8a20Argyrios Kyrtzidis Width = llvm::RoundUpToAlignment(Width, Align); 860030d8846c7e520330007087e949f621989876e3aChris Lattner break; 8615c09a02a5db85e08a432b6eeced9aa656349710dChristopher Lamb } 862213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman case Type::ExtVector: 863030d8846c7e520330007087e949f621989876e3aChris Lattner case Type::Vector: { 8649fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner const VectorType *VT = cast<VectorType>(T); 8659fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(VT->getElementType()); 8669fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner Width = EltInfo.first*VT->getNumElements(); 8674bd998bbc228915d2b9cae5b67879de48940d05eEli Friedman Align = Width; 8686fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // If the alignment is not a power of 2, round up to the next power of 2. 8696fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // This happens for non-power-of-2 length vectors. 8708eefcd353c1d06a10104f69e5079ebab3183f9a3Dan Gohman if (Align & (Align-1)) { 8719fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner Align = llvm::NextPowerOf2(Align); 8729fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner Width = llvm::RoundUpToAlignment(Width, Align); 8739fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner } 874030d8846c7e520330007087e949f621989876e3aChris Lattner break; 875030d8846c7e520330007087e949f621989876e3aChris Lattner } 8765d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner 8779e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner case Type::Builtin: 878a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner switch (cast<BuiltinType>(T)->getKind()) { 879b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Unknown builtin type!"); 880d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::Void: 88118857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor // GCC extension: alignof(void) = 8 bits. 88218857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Width = 0; 88318857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Align = 8; 88418857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor break; 88518857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 8866f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Bool: 887bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getBoolWidth(); 888bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getBoolAlign(); 8896f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 890692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::Char_S: 891692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::Char_U: 892692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::UChar: 8936f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::SChar: 894bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getCharWidth(); 895bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getCharAlign(); 8966f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 8973f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_S: 8983f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_U: 899bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getWCharWidth(); 900bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getWCharAlign(); 90164c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis break; 902f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case BuiltinType::Char16: 903bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getChar16Width(); 904bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getChar16Align(); 905f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith break; 906f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case BuiltinType::Char32: 907bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getChar32Width(); 908bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getChar32Align(); 909f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith break; 910692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::UShort: 9116f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Short: 912bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getShortWidth(); 913bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getShortAlign(); 9146f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 915692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::UInt: 9166f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Int: 917bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getIntWidth(); 918bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getIntAlign(); 9196f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 920692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::ULong: 9216f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Long: 922bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getLongWidth(); 923bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getLongAlign(); 9246f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 925692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::ULongLong: 9266f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::LongLong: 927bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getLongLongWidth(); 928bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getLongLongAlign(); 9296f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 930ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner case BuiltinType::Int128: 931ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner case BuiltinType::UInt128: 932ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner Width = 128; 933ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner Align = 128; // int128_t is 128-bit aligned on all targets. 934ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner break; 935aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov case BuiltinType::Half: 936aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Width = Target->getHalfWidth(); 937aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Align = Target->getHalfAlign(); 938aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov break; 9396f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Float: 940bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getFloatWidth(); 941bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getFloatAlign(); 9426f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 9436f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Double: 944bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getDoubleWidth(); 945bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getDoubleAlign(); 9466f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 9476f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::LongDouble: 948bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getLongDoubleWidth(); 949bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getLongDoubleAlign(); 9506f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 9516e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl case BuiltinType::NullPtr: 952bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t) 953bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(0); // == sizeof(void*) 9541590d9c0fec4c710c2962e4bb71f76979b5163d3Sebastian Redl break; 955e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian case BuiltinType::ObjCId: 956e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian case BuiltinType::ObjCClass: 957e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian case BuiltinType::ObjCSel: 958bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(0); 959bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(0); 960e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian break; 961a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner } 962bfef6d7c67831a135d6ab79931f010f750a730adChris Lattner break; 963d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff case Type::ObjCObjectPointer: 964bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(0); 965bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(0); 9666f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 967485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff case Type::BlockPointer: { 968207f4d8543529221932af82836016a2ef066c917Peter Collingbourne unsigned AS = getTargetAddressSpace( 969207f4d8543529221932af82836016a2ef066c917Peter Collingbourne cast<BlockPointerType>(T)->getPointeeType()); 970bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(AS); 971bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(AS); 972485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff break; 973485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff } 9745d484e8cf710207010720589d89602233de61d01Sebastian Redl case Type::LValueReference: 9755d484e8cf710207010720589d89602233de61d01Sebastian Redl case Type::RValueReference: { 9765d484e8cf710207010720589d89602233de61d01Sebastian Redl // alignof and sizeof should never enter this code path here, so we go 9775d484e8cf710207010720589d89602233de61d01Sebastian Redl // the pointer route. 978207f4d8543529221932af82836016a2ef066c917Peter Collingbourne unsigned AS = getTargetAddressSpace( 979207f4d8543529221932af82836016a2ef066c917Peter Collingbourne cast<ReferenceType>(T)->getPointeeType()); 980bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(AS); 981bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(AS); 9825d484e8cf710207010720589d89602233de61d01Sebastian Redl break; 9835d484e8cf710207010720589d89602233de61d01Sebastian Redl } 984f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner case Type::Pointer: { 985207f4d8543529221932af82836016a2ef066c917Peter Collingbourne unsigned AS = getTargetAddressSpace(cast<PointerType>(T)->getPointeeType()); 986bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(AS); 987bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(AS); 988f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner break; 989f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner } 990f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl case Type::MemberPointer: { 991071cc7deffad608165b1ddd5263e8bf181861520Charles Davis const MemberPointerType *MPT = cast<MemberPointerType>(T); 9921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump std::pair<uint64_t, unsigned> PtrDiffInfo = 9931cca74ef3627a3a0ab14501d23e336548f6611b2Anders Carlsson getTypeInfo(getPointerDiffType()); 994071cc7deffad608165b1ddd5263e8bf181861520Charles Davis Width = PtrDiffInfo.first * ABI->getMemberPointerSize(MPT); 9951cca74ef3627a3a0ab14501d23e336548f6611b2Anders Carlsson Align = PtrDiffInfo.second; 9961cca74ef3627a3a0ab14501d23e336548f6611b2Anders Carlsson break; 997f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl } 9985d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner case Type::Complex: { 9995d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner // Complex types have the same alignment as their elements, but twice the 10005d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner // size. 10011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump std::pair<uint64_t, unsigned> EltInfo = 100298be4943e8dc4f3905629a7102668960873cf863Chris Lattner getTypeInfo(cast<ComplexType>(T)->getElementType()); 10039e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner Width = EltInfo.first*2; 10045d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner Align = EltInfo.second; 10055d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner break; 10065d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner } 1007c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCObject: 1008c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return getTypeInfo(cast<ObjCObjectType>(T)->getBaseType().getTypePtr()); 100944a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel case Type::ObjCInterface: { 10101d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const ObjCInterfaceType *ObjCI = cast<ObjCInterfaceType>(T); 101144a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl()); 1012dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck Width = toBits(Layout.getSize()); 1013dac54c124e302d6f028ea5723c425b7f66fc7c71Ken Dyck Align = toBits(Layout.getAlignment()); 101444a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel break; 101544a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel } 101672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Record: 101772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Enum: { 10181d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const TagType *TT = cast<TagType>(T); 10191d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar 10201d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar if (TT->getDecl()->isInvalidDecl()) { 102122ce41d9fc8509da65858c75bf5b3c4dae2d8c04Douglas Gregor Width = 8; 102222ce41d9fc8509da65858c75bf5b3c4dae2d8c04Douglas Gregor Align = 8; 10238389eab190afef3462f6418b8d8fb70fb01c4005Chris Lattner break; 10248389eab190afef3462f6418b8d8fb70fb01c4005Chris Lattner } 10251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10261d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar if (const EnumType *ET = dyn_cast<EnumType>(TT)) 10277176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner return getTypeInfo(ET->getDecl()->getIntegerType()); 10287176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner 10291d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const RecordType *RT = cast<RecordType>(TT); 10307176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner const ASTRecordLayout &Layout = getASTRecordLayout(RT->getDecl()); 1031dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck Width = toBits(Layout.getSize()); 1032dac54c124e302d6f028ea5723c425b7f66fc7c71Ken Dyck Align = toBits(Layout.getAlignment()); 1033dc0d73e6495404418acf8548875aeaff07791a74Chris Lattner break; 1034a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner } 10357532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 10369fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner case Type::SubstTemplateTypeParm: 103749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall return getTypeInfo(cast<SubstTemplateTypeParmType>(T)-> 103849a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall getReplacementType().getTypePtr()); 103949a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 104034b41d939a1328f484511c6002ba2456db879a29Richard Smith case Type::Auto: { 104134b41d939a1328f484511c6002ba2456db879a29Richard Smith const AutoType *A = cast<AutoType>(T); 104234b41d939a1328f484511c6002ba2456db879a29Richard Smith assert(A->isDeduced() && "Cannot request the size of a dependent type"); 1043dc856aff4428380baa9afb5577ea04f8fb6beb13Matt Beaumont-Gay return getTypeInfo(A->getDeducedType().getTypePtr()); 104434b41d939a1328f484511c6002ba2456db879a29Richard Smith } 104534b41d939a1328f484511c6002ba2456db879a29Richard Smith 1046075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara case Type::Paren: 1047075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return getTypeInfo(cast<ParenType>(T)->getInnerType().getTypePtr()); 1048075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 104918857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor case Type::Typedef: { 1050162e1c1b487352434552147967c3dd296ebee2f7Richard Smith const TypedefNameDecl *Typedef = cast<TypedefType>(T)->getDecl(); 1051df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor std::pair<uint64_t, unsigned> Info 1052df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor = getTypeInfo(Typedef->getUnderlyingType().getTypePtr()); 1053c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner // If the typedef has an aligned attribute on it, it overrides any computed 1054c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner // alignment we have. This violates the GCC documentation (which says that 1055c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner // attribute(aligned) can only round up) but matches its implementation. 1056c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner if (unsigned AttrAlign = Typedef->getMaxAlignment()) 1057c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner Align = AttrAlign; 1058c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner else 1059c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner Align = Info.second; 1060df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor Width = Info.first; 10617532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor break; 10627176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner } 106318857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 106418857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor case Type::TypeOfExpr: 106518857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor return getTypeInfo(cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType() 106618857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor .getTypePtr()); 106718857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 106818857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor case Type::TypeOf: 106918857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor return getTypeInfo(cast<TypeOfType>(T)->getUnderlyingType().getTypePtr()); 107018857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 1071395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson case Type::Decltype: 1072395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson return getTypeInfo(cast<DecltypeType>(T)->getUnderlyingExpr()->getType() 1073395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson .getTypePtr()); 1074395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson 1075ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt case Type::UnaryTransform: 1076ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt return getTypeInfo(cast<UnaryTransformType>(T)->getUnderlyingType()); 1077ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt 1078465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara case Type::Elaborated: 1079465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr()); 10801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10819d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall case Type::Attributed: 10829d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall return getTypeInfo( 10839d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall cast<AttributedType>(T)->getEquivalentType().getTypePtr()); 10849d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 10853e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith case Type::TemplateSpecialization: { 10861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(getCanonicalType(T) != T && 108718857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor "Cannot request the size of a dependent type"); 10883e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith const TemplateSpecializationType *TST = cast<TemplateSpecializationType>(T); 10893e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith // A type alias template specialization may refer to a typedef with the 10903e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith // aligned attribute on it. 10913e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith if (TST->isTypeAlias()) 10923e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith return getTypeInfo(TST->getAliasedType().getTypePtr()); 10933e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith else 10943e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith return getTypeInfo(getCanonicalType(T)); 10953e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith } 10963e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith 1097b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: { 10982be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman std::pair<uint64_t, unsigned> Info 10992be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman = getTypeInfo(cast<AtomicType>(T)->getValueType()); 11002be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman Width = Info.first; 11012be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman Align = Info.second; 11022be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman if (Width != 0 && Width <= Target->getMaxAtomicPromoteWidth() && 11032be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman llvm::isPowerOf2_64(Width)) { 11042be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // We can potentially perform lock-free atomic operations for this 11052be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // type; promote the alignment appropriately. 11062be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // FIXME: We could potentially promote the width here as well... 11072be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // is that worthwhile? (Non-struct atomic types generally have 11082be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // power-of-two size anyway, but structs might not. Requires a bit 11092be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // of implementation work to make sure we zero out the extra bits.) 11102be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman Align = static_cast<unsigned>(Width); 11112be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman } 1112b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 1113b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 111418857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor } 11151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11162be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman assert(llvm::isPowerOf2_32(Align) && "Alignment must be power of 2"); 11179e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner return std::make_pair(Width, Align); 1118a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner} 1119a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 1120eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck/// toCharUnitsFromBits - Convert a size in bits to a size in characters. 1121eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen DyckCharUnits ASTContext::toCharUnitsFromBits(int64_t BitSize) const { 1122eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return CharUnits::fromQuantity(BitSize / getCharWidth()); 1123eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck} 1124eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck 1125dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck/// toBits - Convert a size in characters to a size in characters. 1126dd76a9ab9ea675671200f94b18ce95766841952bKen Dyckint64_t ASTContext::toBits(CharUnits CharSize) const { 1127dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck return CharSize.getQuantity() * getCharWidth(); 1128dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck} 1129dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck 1130bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck/// getTypeSizeInChars - Return the size of the specified type, in characters. 1131bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck/// This method does not work on incomplete types. 11324ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeSizeInChars(QualType T) const { 1133eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeSize(T)); 1134bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck} 11354ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeSizeInChars(const Type *T) const { 1136eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeSize(T)); 1137bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck} 1138bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck 113916e20cce43385001f33f8e3f90ee345609c805d1Ken Dyck/// getTypeAlignInChars - Return the ABI-specified alignment of a type, in 114086fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck/// characters. This method does not work on incomplete types. 11414ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeAlignInChars(QualType T) const { 1142eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeAlign(T)); 114386fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck} 11444ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeAlignInChars(const Type *T) const { 1145eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeAlign(T)); 114686fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck} 114786fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck 114834ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// getPreferredTypeAlign - Return the "preferred" alignment of the specified 114934ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// type for the current target in bits. This can be different than the ABI 115034ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// alignment in cases where it is beneficial for performance to overalign 115134ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// a data type. 11524ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadunsigned ASTContext::getPreferredTypeAlign(const Type *T) const { 115334ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner unsigned ABIAlign = getTypeAlign(T); 11541eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman 11551eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman // Double and long long should be naturally aligned if possible. 1156183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ComplexType* CT = T->getAs<ComplexType>()) 11571eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman T = CT->getElementType().getTypePtr(); 11581eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman if (T->isSpecificBuiltinType(BuiltinType::Double) || 11591eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman T->isSpecificBuiltinType(BuiltinType::LongLong)) 11601eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman return std::max(ABIAlign, (unsigned)getTypeSize(T)); 11611eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman 116234ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner return ABIAlign; 116334ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner} 116434ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner 11652c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// DeepCollectObjCIvars - 11662c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// This routine first collects all declared, but not synthesized, ivars in 11672c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// super class and then collects all ivars, including those synthesized for 11682c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// current class. This routine is used for implementation of current class 11692c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// when all ivars, declared and synthesized are known. 11709820074dd47d37681085e964cd3392ac0b3e67b9Fariborz Jahanian/// 11712c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanianvoid ASTContext::DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, 11722c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian bool leafClass, 1173db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const { 11742c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass()) 11752c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian DeepCollectObjCIvars(SuperClass, false, Ivars); 11762c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian if (!leafClass) { 11772c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(), 11782c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian E = OI->ivar_end(); I != E; ++I) 117911062e11236b7bc689dad150e8b490fd6b063ec3Fariborz Jahanian Ivars.push_back(*I); 11803060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 1181bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian ObjCInterfaceDecl *IDecl = const_cast<ObjCInterfaceDecl *>(OI); 1182db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose for (const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv; 1183bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian Iv= Iv->getNextIvar()) 1184bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian Ivars.push_back(Iv); 1185bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian } 11869820074dd47d37681085e964cd3392ac0b3e67b9Fariborz Jahanian} 11879820074dd47d37681085e964cd3392ac0b3e67b9Fariborz Jahanian 1188e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// CollectInheritedProtocols - Collect all protocols in current class and 1189e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// those inherited by it. 1190e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanianvoid ASTContext::CollectInheritedProtocols(const Decl *CDecl, 1191432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) { 1192e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (const ObjCInterfaceDecl *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) { 119353b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek // We can use protocol_iterator here instead of 119453b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek // all_referenced_protocol_iterator since we are walking all categories. 119553b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek for (ObjCInterfaceDecl::all_protocol_iterator P = OI->all_referenced_protocol_begin(), 119653b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek PE = OI->all_referenced_protocol_end(); P != PE; ++P) { 1197e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian ObjCProtocolDecl *Proto = (*P); 11983fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert(Proto->getCanonicalDecl()); 1199e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 1200b2f812165676230bce5d0215e49a4749c451ca9cFariborz Jahanian PE = Proto->protocol_end(); P != PE; ++P) { 12013fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert((*P)->getCanonicalDecl()); 1202e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(*P, Protocols); 1203e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1204b2f812165676230bce5d0215e49a4749c451ca9cFariborz Jahanian } 1205e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 1206e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian // Categories of this Interface. 1207e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (const ObjCCategoryDecl *CDeclChain = OI->getCategoryList(); 1208e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CDeclChain; CDeclChain = CDeclChain->getNextClassCategory()) 1209e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(CDeclChain, Protocols); 1210e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (ObjCInterfaceDecl *SD = OI->getSuperClass()) 1211e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian while (SD) { 1212e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(SD, Protocols); 1213e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian SD = SD->getSuperClass(); 1214e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1215b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer } else if (const ObjCCategoryDecl *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) { 121653b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek for (ObjCCategoryDecl::protocol_iterator P = OC->protocol_begin(), 1217e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = OC->protocol_end(); P != PE; ++P) { 1218e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian ObjCProtocolDecl *Proto = (*P); 12193fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert(Proto->getCanonicalDecl()); 1220e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 1221e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = Proto->protocol_end(); P != PE; ++P) 1222e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(*P, Protocols); 1223e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1224b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer } else if (const ObjCProtocolDecl *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) { 1225e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = OP->protocol_begin(), 1226e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = OP->protocol_end(); P != PE; ++P) { 1227e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian ObjCProtocolDecl *Proto = (*P); 12283fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert(Proto->getCanonicalDecl()); 1229e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 1230e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = Proto->protocol_end(); P != PE; ++P) 1231e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(*P, Protocols); 1232e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1233e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1234e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian} 1235e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 12364ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadunsigned ASTContext::CountNonClassIvars(const ObjCInterfaceDecl *OI) const { 12373bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian unsigned count = 0; 12383bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian // Count ivars declared in class extension. 123980aa1cd7973561889e51c1c152c8990a8de9c953Fariborz Jahanian for (const ObjCCategoryDecl *CDecl = OI->getFirstClassExtension(); CDecl; 124080aa1cd7973561889e51c1c152c8990a8de9c953Fariborz Jahanian CDecl = CDecl->getNextClassExtension()) 1241b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer count += CDecl->ivar_size(); 1242b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer 12433bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian // Count ivar defined in this class's implementation. This 12443bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian // includes synthesized ivars. 12453bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian if (ObjCImplementationDecl *ImplDecl = OI->getImplementation()) 1246b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer count += ImplDecl->ivar_size(); 1247b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer 12488e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian return count; 12498e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian} 12508e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian 12518a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Get the implementation of ObjCInterfaceDecl,or NULL if none exists. 12528a1d722f13df383600f36d77f842957c8adb5f1bArgyrios KyrtzidisObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) { 12538a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator 12548a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis I = ObjCImpls.find(D); 12558a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis if (I != ObjCImpls.end()) 12568a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return cast<ObjCImplementationDecl>(I->second); 12578a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return 0; 12588a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 12598a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Get the implementation of ObjCCategoryDecl, or NULL if none exists. 12608a1d722f13df383600f36d77f842957c8adb5f1bArgyrios KyrtzidisObjCCategoryImplDecl *ASTContext::getObjCImplementation(ObjCCategoryDecl *D) { 12618a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator 12628a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis I = ObjCImpls.find(D); 12638a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis if (I != ObjCImpls.end()) 12648a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return cast<ObjCCategoryImplDecl>(I->second); 12658a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return 0; 12668a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 12678a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis 12688a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Set the implementation of ObjCInterfaceDecl. 12698a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidisvoid ASTContext::setObjCImplementation(ObjCInterfaceDecl *IFaceD, 12708a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCImplementationDecl *ImplD) { 12718a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis assert(IFaceD && ImplD && "Passed null params"); 12728a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCImpls[IFaceD] = ImplD; 12738a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 12748a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Set the implementation of ObjCCategoryDecl. 12758a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidisvoid ASTContext::setObjCImplementation(ObjCCategoryDecl *CatD, 12768a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCCategoryImplDecl *ImplD) { 12778a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis assert(CatD && ImplD && "Passed null params"); 12788a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCImpls[CatD] = ImplD; 12798a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 12808a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis 128187ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios KyrtzidisObjCInterfaceDecl *ASTContext::getObjContainingInterface(NamedDecl *ND) const { 128287ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(ND->getDeclContext())) 128387ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return ID; 128487ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(ND->getDeclContext())) 128587ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return CD->getClassInterface(); 128687ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis if (ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(ND->getDeclContext())) 128787ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return IMD->getClassInterface(); 128887ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis 128987ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return 0; 129087ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis} 129187ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis 12921ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian/// \brief Get the copy initialization expression of VarDecl,or NULL if 12931ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian/// none exists. 1294830937bc1100fba7682f7c32c40512085870f50cFariborz JahanianExpr *ASTContext::getBlockVarCopyInits(const VarDecl*VD) { 1295d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian assert(VD && "Passed null params"); 1296d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian assert(VD->hasAttr<BlocksAttr>() && 1297d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian "getBlockVarCopyInits - not __block var"); 1298830937bc1100fba7682f7c32c40512085870f50cFariborz Jahanian llvm::DenseMap<const VarDecl*, Expr*>::iterator 1299d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian I = BlockVarCopyInits.find(VD); 13001ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian return (I != BlockVarCopyInits.end()) ? cast<Expr>(I->second) : 0; 13011ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian} 13021ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian 13031ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian/// \brief Set the copy inialization expression of a block var decl. 13041ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanianvoid ASTContext::setBlockVarCopyInits(VarDecl*VD, Expr* Init) { 13051ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian assert(VD && Init && "Passed null params"); 1306d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian assert(VD->hasAttr<BlocksAttr>() && 1307d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian "setBlockVarCopyInits - not __block var"); 13081ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian BlockVarCopyInits[VD] = Init; 13091ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian} 13101ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian 1311a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall/// \brief Allocate an uninitialized TypeSourceInfo. 1312b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// 1313a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall/// The caller should initialize the memory held by TypeSourceInfo using 1314b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// the TypeLoc wrappers. 1315b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// 1316b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// \param T the type that will be the basis for type source info. This type 1317b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// should refer to how the declarator was written in source code, not to 1318b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// what type semantic analysis resolved the declarator to. 1319a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCallTypeSourceInfo *ASTContext::CreateTypeSourceInfo(QualType T, 13204ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned DataSize) const { 1321109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall if (!DataSize) 1322109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall DataSize = TypeLoc::getFullDataSizeForType(T); 1323109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall else 1324109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall assert(DataSize == TypeLoc::getFullDataSizeForType(T) && 1325a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall "incorrect data size provided to CreateTypeSourceInfo!"); 1326109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall 1327a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall TypeSourceInfo *TInfo = 1328a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall (TypeSourceInfo*)BumpAlloc.Allocate(sizeof(TypeSourceInfo) + DataSize, 8); 1329a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall new (TInfo) TypeSourceInfo(T); 1330a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall return TInfo; 1331b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis} 1332b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis 1333a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCallTypeSourceInfo *ASTContext::getTrivialTypeSourceInfo(QualType T, 13346952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor SourceLocation L) const { 1335a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall TypeSourceInfo *DI = CreateTypeSourceInfo(T); 1336c21c7e9c2cded68f91be15be6847c9649242dc17Douglas Gregor DI->getTypeLoc().initialize(const_cast<ASTContext &>(*this), L); 1337a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall return DI; 1338a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall} 1339a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall 1340b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbarconst ASTRecordLayout & 13414ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const { 1342b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar return getObjCLayout(D, 0); 1343b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar} 1344b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar 1345b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbarconst ASTRecordLayout & 13464ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getASTObjCImplementationLayout( 13474ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const ObjCImplementationDecl *D) const { 1348b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar return getObjCLayout(D->getClassInterface(), D); 1349b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar} 1350b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar 1351a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner//===----------------------------------------------------------------------===// 1352a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner// Type creation/memoization methods 1353a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner//===----------------------------------------------------------------------===// 1354a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 13554ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 13563b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallASTContext::getExtQualType(const Type *baseType, Qualifiers quals) const { 13573b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall unsigned fastQuals = quals.getFastQualifiers(); 13583b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall quals.removeFastQualifiers(); 13590953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 13600953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Check if we've already instantiated this type. 13610953e767ff7817f97b3ab20896b229891eeff45bJohn McCall llvm::FoldingSetNodeID ID; 13623b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ExtQuals::Profile(ID, baseType, quals); 13633b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall void *insertPos = 0; 13643b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (ExtQuals *eq = ExtQualNodes.FindNodeOrInsertPos(ID, insertPos)) { 13653b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert(eq->getQualifiers() == quals); 13663b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(eq, fastQuals); 13670953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 13680953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 13693b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If the base type is not canonical, make the appropriate canonical type. 13703b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType canon; 13713b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!baseType->isCanonicalUnqualified()) { 13723b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = baseType->getCanonicalTypeInternal().split(); 13733b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall canonSplit.second.addConsistentQualifiers(quals); 13743b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall canon = getExtQualType(canonSplit.first, canonSplit.second); 13753b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 13763b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Re-find the insert position. 13773b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos); 13783b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall } 13793b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 13803b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ExtQuals *eq = new (*this, TypeAlignment) ExtQuals(baseType, canon, quals); 13813b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ExtQualNodes.InsertNode(eq, insertPos); 13823b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(eq, fastQuals); 13830953e767ff7817f97b3ab20896b229891eeff45bJohn McCall} 13840953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 13854ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 13864ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getAddrSpaceQualType(QualType T, unsigned AddressSpace) const { 1387f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner QualType CanT = getCanonicalType(T); 1388f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner if (CanT.getAddressSpace() == AddressSpace) 1389f46699ce225811d8d9dbab9d00189a0e54469457Chris Lattner return T; 1390b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris Lattner 13910953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If we are composing extended qualifiers together, merge together 13920953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // into one ExtQuals node. 13930953e767ff7817f97b3ab20896b229891eeff45bJohn McCall QualifierCollector Quals; 13940953e767ff7817f97b3ab20896b229891eeff45bJohn McCall const Type *TypeNode = Quals.strip(T); 13951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 13960953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If this type already has an address space specified, it cannot get 13970953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // another one. 13980953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert(!Quals.hasAddressSpace() && 13990953e767ff7817f97b3ab20896b229891eeff45bJohn McCall "Type cannot be in multiple addr spaces!"); 14000953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Quals.addAddressSpace(AddressSpace); 14011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14020953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return getExtQualType(TypeNode, Quals); 1403ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb} 1404ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb 1405b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris LattnerQualType ASTContext::getObjCGCQualType(QualType T, 14064ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Qualifiers::GC GCAttr) const { 1407d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian QualType CanT = getCanonicalType(T); 1408b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris Lattner if (CanT.getObjCGCAttr() == GCAttr) 1409d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian return T; 14101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14117f040a9d817cd1c72b565e92abff473510bf9e1dJohn McCall if (const PointerType *ptr = T->getAs<PointerType>()) { 14127f040a9d817cd1c72b565e92abff473510bf9e1dJohn McCall QualType Pointee = ptr->getPointeeType(); 141358f9f2c884af6b72d036b746a016d8031d31cb7aSteve Naroff if (Pointee->isAnyPointerType()) { 14144027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian QualType ResultType = getObjCGCQualType(Pointee, GCAttr); 14154027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian return getPointerType(ResultType); 14164027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian } 14174027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian } 14181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14190953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If we are composing extended qualifiers together, merge together 14200953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // into one ExtQuals node. 14210953e767ff7817f97b3ab20896b229891eeff45bJohn McCall QualifierCollector Quals; 14220953e767ff7817f97b3ab20896b229891eeff45bJohn McCall const Type *TypeNode = Quals.strip(T); 14231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14240953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If this type already has an ObjCGC specified, it cannot get 14250953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // another one. 14260953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert(!Quals.hasObjCGCAttr() && 14270953e767ff7817f97b3ab20896b229891eeff45bJohn McCall "Type cannot have multiple ObjCGCs!"); 14280953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Quals.addObjCGCAttr(GCAttr); 14291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14300953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return getExtQualType(TypeNode, Quals); 1431d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian} 1432a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 1433e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCallconst FunctionType *ASTContext::adjustFunctionType(const FunctionType *T, 1434e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall FunctionType::ExtInfo Info) { 1435e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall if (T->getExtInfo() == Info) 1436e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall return T; 1437e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 1438e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall QualType Result; 1439e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall if (const FunctionNoProtoType *FNPT = dyn_cast<FunctionNoProtoType>(T)) { 1440e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall Result = getFunctionNoProtoType(FNPT->getResultType(), Info); 1441e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall } else { 1442e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall const FunctionProtoType *FPT = cast<FunctionProtoType>(T); 1443e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 1444e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall EPI.ExtInfo = Info; 1445e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall Result = getFunctionType(FPT->getResultType(), FPT->arg_type_begin(), 1446e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall FPT->getNumArgs(), EPI); 1447e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall } 1448e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 1449e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall return cast<FunctionType>(Result.getTypePtr()); 1450e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall} 1451e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 14525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getComplexType - Return the uniqued reference to the type for a complex 14535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// number with the specified element type. 14544ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getComplexType(QualType T) const { 14555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique pointers, to guarantee there is only one pointer of a particular 14565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 14575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 14585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ComplexType::Profile(ID, T); 14591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 14615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos)) 14625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(CT, 0); 14631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the pointee type isn't canonical, this won't be a canonical type either, 14655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // so fill in the canonical type field. 14665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 1467467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!T.isCanonical()) { 1468f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner Canonical = getComplexType(getCanonicalType(T)); 14691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 14715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos); 1472c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 14735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 14746b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ComplexType *New = new (*this, TypeAlignment) ComplexType(T, Canonical); 14755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 14765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ComplexTypes.InsertNode(New, InsertPos); 14775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 14785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 14795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 14805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getPointerType - Return the uniqued reference to the type for a pointer to 14815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// the specified type. 14824ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getPointerType(QualType T) const { 14835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique pointers, to guarantee there is only one pointer of a particular 14845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 14855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 14865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PointerType::Profile(ID, T); 14871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 14895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 14905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(PT, 0); 14911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the pointee type isn't canonical, this won't be a canonical type either, 14935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // so fill in the canonical type field. 14945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 1495467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!T.isCanonical()) { 1496f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner Canonical = getPointerType(getCanonicalType(T)); 14971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 14995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1500c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 15015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 15026b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall PointerType *New = new (*this, TypeAlignment) PointerType(T, Canonical); 15035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 15045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PointerTypes.InsertNode(New, InsertPos); 15055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 15065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 15075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 15081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getBlockPointerType - Return the uniqued reference to the type for 15095618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff/// a pointer to the specified block. 15104ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getBlockPointerType(QualType T) const { 1511296e8d5fdcf9946f51e866adc8d281379e51efe9Steve Naroff assert(T->isFunctionType() && "block of function types only"); 1512296e8d5fdcf9946f51e866adc8d281379e51efe9Steve Naroff // Unique pointers, to guarantee there is only one block of a particular 15135618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // structure. 15145618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff llvm::FoldingSetNodeID ID; 15155618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerType::Profile(ID, T); 15161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15175618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff void *InsertPos = 0; 15185618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff if (BlockPointerType *PT = 15195618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 15205618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff return QualType(PT, 0); 15211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the block pointee type isn't canonical, this won't be a canonical 15235618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // type either so fill in the canonical type field. 15245618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff QualType Canonical; 1525467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!T.isCanonical()) { 15265618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff Canonical = getBlockPointerType(getCanonicalType(T)); 15271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15285618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // Get the new insert position for the node we care about. 15295618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerType *NewIP = 15305618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1531c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 15325618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff } 15336b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall BlockPointerType *New 15346b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) BlockPointerType(T, Canonical); 15355618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff Types.push_back(New); 15365618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerTypes.InsertNode(New, InsertPos); 15375618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff return QualType(New, 0); 15385618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff} 15395618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff 15407c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// getLValueReferenceType - Return the uniqued reference to the type for an 15417c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// lvalue reference to the specified type. 15424ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 15434ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getLValueReferenceType(QualType T, bool SpelledAsLValue) const { 15449625e44c0252485277a340746ed8ac950686156fDouglas Gregor assert(getCanonicalType(T) != OverloadTy && 15459625e44c0252485277a340746ed8ac950686156fDouglas Gregor "Unresolved overloaded function type"); 15469625e44c0252485277a340746ed8ac950686156fDouglas Gregor 15475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique pointers, to guarantee there is only one pointer of a particular 15485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 15495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 155054e14c4db764c0636160d26c5bbf491637c83a76John McCall ReferenceType::Profile(ID, T, SpelledAsLValue); 15515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 15525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 15537c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl if (LValueReferenceType *RT = 15547c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 15555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(RT, 0); 15567c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 155754e14c4db764c0636160d26c5bbf491637c83a76John McCall const ReferenceType *InnerRef = T->getAs<ReferenceType>(); 155854e14c4db764c0636160d26c5bbf491637c83a76John McCall 15595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the referencee type isn't canonical, this won't be a canonical type 15605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // either, so fill in the canonical type field. 15615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 156254e14c4db764c0636160d26c5bbf491637c83a76John McCall if (!SpelledAsLValue || InnerRef || !T.isCanonical()) { 156354e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T); 156454e14c4db764c0636160d26c5bbf491637c83a76John McCall Canonical = getLValueReferenceType(getCanonicalType(PointeeType)); 15657c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 15667c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // Get the new insert position for the node we care about. 15677c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceType *NewIP = 15687c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 1569c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 15707c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl } 15717c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 15726b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall LValueReferenceType *New 157354e14c4db764c0636160d26c5bbf491637c83a76John McCall = new (*this, TypeAlignment) LValueReferenceType(T, Canonical, 157454e14c4db764c0636160d26c5bbf491637c83a76John McCall SpelledAsLValue); 15757c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl Types.push_back(New); 15767c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceTypes.InsertNode(New, InsertPos); 157754e14c4db764c0636160d26c5bbf491637c83a76John McCall 15787c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl return QualType(New, 0); 15797c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl} 15807c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 15817c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// getRValueReferenceType - Return the uniqued reference to the type for an 15827c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// rvalue reference to the specified type. 15834ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getRValueReferenceType(QualType T) const { 15847c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // Unique pointers, to guarantee there is only one pointer of a particular 15857c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // structure. 15867c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl llvm::FoldingSetNodeID ID; 158754e14c4db764c0636160d26c5bbf491637c83a76John McCall ReferenceType::Profile(ID, T, false); 15887c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 15897c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl void *InsertPos = 0; 15907c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl if (RValueReferenceType *RT = 15917c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 15927c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl return QualType(RT, 0); 15937c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 159454e14c4db764c0636160d26c5bbf491637c83a76John McCall const ReferenceType *InnerRef = T->getAs<ReferenceType>(); 159554e14c4db764c0636160d26c5bbf491637c83a76John McCall 15967c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // If the referencee type isn't canonical, this won't be a canonical type 15977c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // either, so fill in the canonical type field. 15987c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl QualType Canonical; 159954e14c4db764c0636160d26c5bbf491637c83a76John McCall if (InnerRef || !T.isCanonical()) { 160054e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T); 160154e14c4db764c0636160d26c5bbf491637c83a76John McCall Canonical = getRValueReferenceType(getCanonicalType(PointeeType)); 16027c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 16035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 16047c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceType *NewIP = 16057c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 1606c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 16075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 16085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 16096b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall RValueReferenceType *New 16106b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) RValueReferenceType(T, Canonical); 16115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 16127c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceTypes.InsertNode(New, InsertPos); 16135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 16145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 16155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1616f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl/// getMemberPointerType - Return the uniqued reference to the type for a 1617f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl/// member pointer to the specified type, in the specified class. 16184ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) const { 1619f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // Unique pointers, to guarantee there is only one pointer of a particular 1620f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // structure. 1621f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl llvm::FoldingSetNodeID ID; 1622f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerType::Profile(ID, T, Cls); 1623f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1624f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl void *InsertPos = 0; 1625f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl if (MemberPointerType *PT = 1626f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 1627f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl return QualType(PT, 0); 1628f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1629f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // If the pointee or class type isn't canonical, this won't be a canonical 1630f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // type either, so fill in the canonical type field. 1631f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl QualType Canonical; 163287c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) { 1633f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls)); 1634f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1635f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // Get the new insert position for the node we care about. 1636f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerType *NewIP = 1637f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1638c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 1639f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl } 16406b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall MemberPointerType *New 16416b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical); 1642f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl Types.push_back(New); 1643f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerTypes.InsertNode(New, InsertPos); 1644f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl return QualType(New, 0); 1645f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl} 1646f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 16471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getConstantArrayType - Return the unique reference to the type for an 1648fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff/// array of the specified element type. 16491eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType ASTContext::getConstantArrayType(QualType EltTy, 165038aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner const llvm::APInt &ArySizeIn, 1651c9406125e2cac9208098655ac8058c095c2c3a65Steve Naroff ArrayType::ArraySizeModifier ASM, 165263e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara unsigned IndexTypeQuals) const { 1653923d56d436f750bc1f29db50e641078725558a1bSebastian Redl assert((EltTy->isDependentType() || 1654923d56d436f750bc1f29db50e641078725558a1bSebastian Redl EltTy->isIncompleteType() || EltTy->isConstantSizeType()) && 1655587cbdfd95f4b0aaccc14b31f5debe85d5daf7edEli Friedman "Constant array of VLAs is illegal!"); 1656587cbdfd95f4b0aaccc14b31f5debe85d5daf7edEli Friedman 165738aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner // Convert the array size into a canonical width matching the pointer size for 165838aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner // the target. 165938aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner llvm::APInt ArySize(ArySizeIn); 16609f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad ArySize = 1661bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor ArySize.zextOrTrunc(Target->getPointerWidth(getTargetAddressSpace(EltTy))); 16621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 166463e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, IndexTypeQuals); 16651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 16671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (ConstantArrayType *ATP = 16687192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos)) 16695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(ATP, 0); 16701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16713b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If the element type isn't canonical or has qualifiers, this won't 16723b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // be a canonical type either, so fill in the canonical type field. 16733b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType Canon; 16743b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) { 16753b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = getCanonicalType(EltTy).split(); 16763b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Canon = getConstantArrayType(QualType(canonSplit.first, 0), ArySize, 167763e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara ASM, IndexTypeQuals); 16783b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Canon = getQualifiedType(Canon, canonSplit.second); 16793b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 16805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 16811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ConstantArrayType *NewIP = 16827192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos); 1683c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 16845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 16851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16866b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ConstantArrayType *New = new(*this,TypeAlignment) 168763e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara ConstantArrayType(EltTy, Canon, ArySize, ASM, IndexTypeQuals); 16887192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek ConstantArrayTypes.InsertNode(New, InsertPos); 16895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 16905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 16915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 16925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1693ce8890371fcdb983ae487c87fa40606a34896ff7John McCall/// getVariableArrayDecayedType - Turns the given type, which may be 1694ce8890371fcdb983ae487c87fa40606a34896ff7John McCall/// variably-modified, into the corresponding type with all the known 1695ce8890371fcdb983ae487c87fa40606a34896ff7John McCall/// sizes replaced with [*]. 1696ce8890371fcdb983ae487c87fa40606a34896ff7John McCallQualType ASTContext::getVariableArrayDecayedType(QualType type) const { 1697ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Vastly most common case. 1698ce8890371fcdb983ae487c87fa40606a34896ff7John McCall if (!type->isVariablyModifiedType()) return type; 1699ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1700ce8890371fcdb983ae487c87fa40606a34896ff7John McCall QualType result; 1701ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1702ce8890371fcdb983ae487c87fa40606a34896ff7John McCall SplitQualType split = type.getSplitDesugaredType(); 1703ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const Type *ty = split.first; 1704ce8890371fcdb983ae487c87fa40606a34896ff7John McCall switch (ty->getTypeClass()) { 1705ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#define TYPE(Class, Base) 1706ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#define ABSTRACT_TYPE(Class, Base) 1707ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 1708ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#include "clang/AST/TypeNodes.def" 1709ce8890371fcdb983ae487c87fa40606a34896ff7John McCall llvm_unreachable("didn't desugar past all non-canonical types?"); 1710ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1711ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // These types should never be variably-modified. 1712ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Builtin: 1713ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Complex: 1714ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Vector: 1715ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ExtVector: 1716ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentSizedExtVector: 1717ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ObjCObject: 1718ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ObjCInterface: 1719ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ObjCObjectPointer: 1720ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Record: 1721ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Enum: 1722ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::UnresolvedUsing: 1723ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TypeOfExpr: 1724ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TypeOf: 1725ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Decltype: 1726ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt case Type::UnaryTransform: 1727ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentName: 1728ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::InjectedClassName: 1729ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TemplateSpecialization: 1730ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentTemplateSpecialization: 1731ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TemplateTypeParm: 1732ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::SubstTemplateTypeParmPack: 173334b41d939a1328f484511c6002ba2456db879a29Richard Smith case Type::Auto: 1734ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::PackExpansion: 1735ce8890371fcdb983ae487c87fa40606a34896ff7John McCall llvm_unreachable("type should never be variably-modified"); 1736ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1737ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // These types can be variably-modified but should never need to 1738ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // further decay. 1739ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::FunctionNoProto: 1740ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::FunctionProto: 1741ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::BlockPointer: 1742ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::MemberPointer: 1743ce8890371fcdb983ae487c87fa40606a34896ff7John McCall return type; 1744ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1745ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // These types can be variably-modified. All these modifications 1746ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // preserve structure except as noted by comments. 1747ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // TODO: if we ever care about optimizing VLAs, there are no-op 1748ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // optimizations available here. 1749ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Pointer: 1750ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getPointerType(getVariableArrayDecayedType( 1751ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cast<PointerType>(ty)->getPointeeType())); 1752ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1753ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1754ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::LValueReference: { 1755ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const LValueReferenceType *lv = cast<LValueReferenceType>(ty); 1756ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getLValueReferenceType( 1757ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(lv->getPointeeType()), 1758ce8890371fcdb983ae487c87fa40606a34896ff7John McCall lv->isSpelledAsLValue()); 1759ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1760745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 1761ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1762ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::RValueReference: { 1763ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const RValueReferenceType *lv = cast<RValueReferenceType>(ty); 1764ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getRValueReferenceType( 1765ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(lv->getPointeeType())); 1766ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1767745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 1768745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1769b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: { 1770b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman const AtomicType *at = cast<AtomicType>(ty); 1771b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman result = getAtomicType(getVariableArrayDecayedType(at->getValueType())); 1772b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman break; 1773b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 1774b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 1775ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ConstantArray: { 1776ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const ConstantArrayType *cat = cast<ConstantArrayType>(ty); 1777ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getConstantArrayType( 1778ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(cat->getElementType()), 1779ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cat->getSize(), 1780ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cat->getSizeModifier(), 1781ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cat->getIndexTypeCVRQualifiers()); 1782ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1783745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 1784745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1785ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentSizedArray: { 1786ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const DependentSizedArrayType *dat = cast<DependentSizedArrayType>(ty); 1787ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getDependentSizedArrayType( 1788ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(dat->getElementType()), 1789ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getSizeExpr(), 1790ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getSizeModifier(), 1791ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getIndexTypeCVRQualifiers(), 1792ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getBracketsRange()); 1793ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1794ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1795ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1796ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Turn incomplete types into [*] types. 1797ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::IncompleteArray: { 1798ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const IncompleteArrayType *iat = cast<IncompleteArrayType>(ty); 1799ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getVariableArrayType( 1800ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(iat->getElementType()), 1801ce8890371fcdb983ae487c87fa40606a34896ff7John McCall /*size*/ 0, 1802ce8890371fcdb983ae487c87fa40606a34896ff7John McCall ArrayType::Normal, 1803ce8890371fcdb983ae487c87fa40606a34896ff7John McCall iat->getIndexTypeCVRQualifiers(), 1804ce8890371fcdb983ae487c87fa40606a34896ff7John McCall SourceRange()); 1805ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1806ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1807ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1808ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Turn VLA types into [*] types. 1809ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::VariableArray: { 1810ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const VariableArrayType *vat = cast<VariableArrayType>(ty); 1811ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getVariableArrayType( 1812ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(vat->getElementType()), 1813ce8890371fcdb983ae487c87fa40606a34896ff7John McCall /*size*/ 0, 1814ce8890371fcdb983ae487c87fa40606a34896ff7John McCall ArrayType::Star, 1815ce8890371fcdb983ae487c87fa40606a34896ff7John McCall vat->getIndexTypeCVRQualifiers(), 1816ce8890371fcdb983ae487c87fa40606a34896ff7John McCall vat->getBracketsRange()); 1817ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1818ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1819ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1820ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1821ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Apply the top-level qualifiers from the original. 1822ce8890371fcdb983ae487c87fa40606a34896ff7John McCall return getQualifiedType(result, split.second); 1823ce8890371fcdb983ae487c87fa40606a34896ff7John McCall} 1824745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1825bdbf7b030a3e0ddb95240076683830e6f78c79a5Steve Naroff/// getVariableArrayType - Returns a non-unique reference to the type for a 1826bdbf7b030a3e0ddb95240076683830e6f78c79a5Steve Naroff/// variable array of the specified element type. 18277e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas GregorQualType ASTContext::getVariableArrayType(QualType EltTy, 18287e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor Expr *NumElts, 1829c9406125e2cac9208098655ac8058c095c2c3a65Steve Naroff ArrayType::ArraySizeModifier ASM, 183063e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara unsigned IndexTypeQuals, 18314ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad SourceRange Brackets) const { 1832c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // Since we don't unique expressions, it isn't possible to unique VLA's 1833c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // that have an expression provided for their size. 18343b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType Canon; 1835715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor 18363b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Be sure to pull qualifiers off the element type. 18373b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) { 18383b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = getCanonicalType(EltTy).split(); 18393b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Canon = getVariableArrayType(QualType(canonSplit.first, 0), NumElts, ASM, 184063e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara IndexTypeQuals, Brackets); 18413b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Canon = getQualifiedType(Canon, canonSplit.second); 1842715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor } 1843715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor 18446b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall VariableArrayType *New = new(*this, TypeAlignment) 184563e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara VariableArrayType(EltTy, Canon, NumElts, ASM, IndexTypeQuals, Brackets); 1846c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1847c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman VariableArrayTypes.push_back(New); 1848c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman Types.push_back(New); 1849c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman return QualType(New, 0); 1850c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman} 1851c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1852898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// getDependentSizedArrayType - Returns a non-unique reference to 1853898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// the type for a dependently-sized array of the specified element 185404d4beee4b86af20a9e4457023d3925cab8f9908Douglas Gregor/// type. 18553b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getDependentSizedArrayType(QualType elementType, 18563b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Expr *numElements, 1857898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor ArrayType::ArraySizeModifier ASM, 18583b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall unsigned elementTypeQuals, 18593b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SourceRange brackets) const { 18603b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert((!numElements || numElements->isTypeDependent() || 18613b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall numElements->isValueDependent()) && 1862898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor "Size must be type- or value-dependent!"); 1863898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 18643b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Dependently-sized array types that do not have a specified number 18653b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // of elements will have their sizes deduced from a dependent 18663b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // initializer. We do no canonicalization here at all, which is okay 18673b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // because they can't be used in most locations. 18683b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!numElements) { 18693b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType *newType 18703b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall = new (*this, TypeAlignment) 18713b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType(*this, elementType, QualType(), 18723b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall numElements, ASM, elementTypeQuals, 18733b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall brackets); 18743b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(newType); 18753b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(newType, 0); 1876cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor } 1877cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor 18783b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Otherwise, we actually build a new type every time, but we 18793b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // also build a canonical type. 18801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 18813b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonElementType = getCanonicalType(elementType).split(); 1882898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 18833b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall void *insertPos = 0; 18843b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall llvm::FoldingSetNodeID ID; 18853b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType::Profile(ID, *this, 18863b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType(canonElementType.first, 0), 18873b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ASM, elementTypeQuals, numElements); 18883b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 18893b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Look for an existing type with these properties. 18903b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType *canonTy = 18913b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos); 18923b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 18933b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If we don't have one, build one. 18943b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!canonTy) { 18953b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall canonTy = new (*this, TypeAlignment) 18963b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType(*this, QualType(canonElementType.first, 0), 18973b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType(), numElements, ASM, elementTypeQuals, 18983b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall brackets); 18993b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayTypes.InsertNode(canonTy, insertPos); 19003b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(canonTy); 19013b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall } 19023b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19033b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Apply qualifiers from the element type to the array. 19043b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType canon = getQualifiedType(QualType(canonTy,0), 19053b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall canonElementType.second); 19063b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19073b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If we didn't need extra canonicalization for the element type, 19083b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // then just use that as our result. 19093b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (QualType(canonElementType.first, 0) == elementType) 19103b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return canon; 19113b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19123b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Otherwise, we need to build a type which follows the spelling 19133b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // of the element type. 19143b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType *sugaredType 19153b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall = new (*this, TypeAlignment) 19163b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType(*this, elementType, canon, numElements, 19173b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ASM, elementTypeQuals, brackets); 19183b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(sugaredType); 19193b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(sugaredType, 0); 19203b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall} 19213b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19223b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getIncompleteArrayType(QualType elementType, 1923c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman ArrayType::ArraySizeModifier ASM, 19243b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall unsigned elementTypeQuals) const { 1925c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman llvm::FoldingSetNodeID ID; 19263b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType::Profile(ID, elementType, ASM, elementTypeQuals); 1927c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19283b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall void *insertPos = 0; 19293b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (IncompleteArrayType *iat = 19303b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos)) 19313b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(iat, 0); 1932c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1933c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // If the element type isn't canonical, this won't be a canonical type 19343b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // either, so fill in the canonical type field. We also have to pull 19353b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // qualifiers off the element type. 19363b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType canon; 1937c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19383b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!elementType.isCanonical() || elementType.hasLocalQualifiers()) { 19393b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = getCanonicalType(elementType).split(); 19403b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall canon = getIncompleteArrayType(QualType(canonSplit.first, 0), 19413b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ASM, elementTypeQuals); 19423b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall canon = getQualifiedType(canon, canonSplit.second); 1943c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1944c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // Get the new insert position for the node we care about. 19453b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType *existing = 19463b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos); 19473b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert(!existing && "Shouldn't be in the map!"); (void) existing; 19482bd24ba6d10f8c811c8e2a57c8397e07082ba497Ted Kremenek } 1949c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19503b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType *newType = new (*this, TypeAlignment) 19513b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType(elementType, canon, ASM, elementTypeQuals); 1952c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19533b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayTypes.InsertNode(newType, insertPos); 19543b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(newType); 19553b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(newType, 0); 1956fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff} 1957fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff 195873322924127c873c13101b705dd823f5539ffa5fSteve Naroff/// getVectorType - Return the unique reference to a vector type of 195973322924127c873c13101b705dd823f5539ffa5fSteve Naroff/// the specified element type and size. VectorType must be a built-in type. 196082287d19ded35248c4ce6a425ce74116a13ce44eJohn ThompsonQualType ASTContext::getVectorType(QualType vecType, unsigned NumElts, 19614ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad VectorType::VectorKind VecKind) const { 19623b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert(vecType->isBuiltinType()); 19631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 19645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Check if we've already instantiated a vector of this type. 19655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 1966e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType::Profile(ID, vecType, NumElts, Type::Vector, VecKind); 1967788b0fd67e1992f23555454efcdb16a19dfefac3Chris Lattner 19685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 19695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 19705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(VTP, 0); 19715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 19725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the element type isn't canonical, this won't be a canonical type either, 19735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // so fill in the canonical type field. 19745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 1975255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor if (!vecType.isCanonical()) { 1976231da7eb3dd13007e5e40fffe48998e5ef284e06Bob Wilson Canonical = getVectorType(getCanonicalType(vecType), NumElts, VecKind); 19771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 19785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 19795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 1980c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 19815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 19826b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall VectorType *New = new (*this, TypeAlignment) 1983e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType(vecType, NumElts, Canonical, VecKind); 19845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer VectorTypes.InsertNode(New, InsertPos); 19855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 19865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 19875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 19885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1989213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman/// getExtVectorType - Return the unique reference to an extended vector type of 199073322924127c873c13101b705dd823f5539ffa5fSteve Naroff/// the specified element type and size. VectorType must be a built-in type. 19914ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 19924ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getExtVectorType(QualType vecType, unsigned NumElts) const { 19934ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor assert(vecType->isBuiltinType() || vecType->isDependentType()); 19941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 199573322924127c873c13101b705dd823f5539ffa5fSteve Naroff // Check if we've already instantiated a vector of this type. 199673322924127c873c13101b705dd823f5539ffa5fSteve Naroff llvm::FoldingSetNodeID ID; 1997788b0fd67e1992f23555454efcdb16a19dfefac3Chris Lattner VectorType::Profile(ID, vecType, NumElts, Type::ExtVector, 1998e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType::GenericVector); 199973322924127c873c13101b705dd823f5539ffa5fSteve Naroff void *InsertPos = 0; 200073322924127c873c13101b705dd823f5539ffa5fSteve Naroff if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 200173322924127c873c13101b705dd823f5539ffa5fSteve Naroff return QualType(VTP, 0); 200273322924127c873c13101b705dd823f5539ffa5fSteve Naroff 200373322924127c873c13101b705dd823f5539ffa5fSteve Naroff // If the element type isn't canonical, this won't be a canonical type either, 200473322924127c873c13101b705dd823f5539ffa5fSteve Naroff // so fill in the canonical type field. 200573322924127c873c13101b705dd823f5539ffa5fSteve Naroff QualType Canonical; 2006467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!vecType.isCanonical()) { 2007213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman Canonical = getExtVectorType(getCanonicalType(vecType), NumElts); 20081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 200973322924127c873c13101b705dd823f5539ffa5fSteve Naroff // Get the new insert position for the node we care about. 201073322924127c873c13101b705dd823f5539ffa5fSteve Naroff VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2011c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 201273322924127c873c13101b705dd823f5539ffa5fSteve Naroff } 20136b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ExtVectorType *New = new (*this, TypeAlignment) 20146b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ExtVectorType(vecType, NumElts, Canonical); 201573322924127c873c13101b705dd823f5539ffa5fSteve Naroff VectorTypes.InsertNode(New, InsertPos); 201673322924127c873c13101b705dd823f5539ffa5fSteve Naroff Types.push_back(New); 201773322924127c873c13101b705dd823f5539ffa5fSteve Naroff return QualType(New, 0); 201873322924127c873c13101b705dd823f5539ffa5fSteve Naroff} 201973322924127c873c13101b705dd823f5539ffa5fSteve Naroff 20204ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 20214ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getDependentSizedExtVectorType(QualType vecType, 20224ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Expr *SizeExpr, 20234ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad SourceLocation AttrLoc) const { 20242ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor llvm::FoldingSetNodeID ID; 20251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump DependentSizedExtVectorType::Profile(ID, *this, getCanonicalType(vecType), 20262ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor SizeExpr); 20271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20282ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor void *InsertPos = 0; 20292ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor DependentSizedExtVectorType *Canon 20302ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos); 20312ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor DependentSizedExtVectorType *New; 20322ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor if (Canon) { 20332ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor // We already have a canonical version of this array type; use it as 20342ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor // the canonical type for a newly-built type. 20356b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall New = new (*this, TypeAlignment) 20366b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall DependentSizedExtVectorType(*this, vecType, QualType(Canon, 0), 20376b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall SizeExpr, AttrLoc); 20382ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } else { 20392ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor QualType CanonVecTy = getCanonicalType(vecType); 20402ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor if (CanonVecTy == vecType) { 20416b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall New = new (*this, TypeAlignment) 20426b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall DependentSizedExtVectorType(*this, vecType, QualType(), SizeExpr, 20436b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall AttrLoc); 2044789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2045789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentSizedExtVectorType *CanonCheck 2046789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2047789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!CanonCheck && "Dependent-sized ext_vector canonical type broken"); 2048789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CanonCheck; 20492ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor DependentSizedExtVectorTypes.InsertNode(New, InsertPos); 20502ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } else { 20512ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr, 20522ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor SourceLocation()); 20536b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall New = new (*this, TypeAlignment) 20546b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall DependentSizedExtVectorType(*this, vecType, Canon, SizeExpr, AttrLoc); 20552ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } 20562ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } 20571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20589cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor Types.push_back(New); 20599cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor return QualType(New, 0); 20609cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor} 20619cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor 206272564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'. 20635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 20644ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 20654ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getFunctionNoProtoType(QualType ResultTy, 20664ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const FunctionType::ExtInfo &Info) const { 2067cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv DefaultCC = Info.getCC(); 2068cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv CallConv = (LangOpts.MRTD && DefaultCC == CC_Default) ? 2069cfe9af250f466e7e38becea4428990448ae07737Roman Divacky CC_X86StdCall : DefaultCC; 20705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique functions, to guarantee there is only one function of a particular 20715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 20725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 2073264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionNoProtoType::Profile(ID, ResultTy, Info); 20741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 20761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (FunctionNoProtoType *FT = 207772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) 20785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(FT, 0); 20791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 2081ab8bbf4ebd3e3e6eab913cb044772a62b7581941Douglas Gregor if (!ResultTy.isCanonical() || 208204a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall getCanonicalCallConv(CallConv) != CallConv) { 2083264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola Canonical = 2084264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola getFunctionNoProtoType(getCanonicalType(ResultTy), 2085264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola Info.withCallingConv(getCanonicalCallConv(CallConv))); 20861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 208872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoType *NewIP = 208972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos); 2090c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 20915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 20921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2093cfe9af250f466e7e38becea4428990448ae07737Roman Divacky FunctionProtoType::ExtInfo newInfo = Info.withCallingConv(CallConv); 20946b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall FunctionNoProtoType *New = new (*this, TypeAlignment) 2095cfe9af250f466e7e38becea4428990448ae07737Roman Divacky FunctionNoProtoType(ResultTy, Canonical, newInfo); 20965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 209772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoTypes.InsertNode(New, InsertPos); 20985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 20995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 21005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 21015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getFunctionType - Return a normal function type with a typed argument 21025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// list. isVariadic indicates whether the argument list includes '...'. 21034ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 21044ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getFunctionType(QualType ResultTy, 21054ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const QualType *ArgArray, unsigned NumArgs, 21064ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const FunctionProtoType::ExtProtoInfo &EPI) const { 21075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique functions, to guarantee there is only one function of a particular 21085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 21095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 21108026f6d82f7fa544bc0453714fe94bca62a1196eSebastian Redl FunctionProtoType::Profile(ID, ResultTy, ArgArray, NumArgs, EPI, *this); 21115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 21125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 21131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (FunctionProtoType *FTP = 211472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) 21155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(FTP, 0); 2116465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 2117465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl // Determine whether the type being created is already canonical or not. 21188b5b4099c61a136e9a1714c4d8a593febe942268Sebastian Redl bool isCanonical= EPI.ExceptionSpecType == EST_None && ResultTy.isCanonical(); 21195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0; i != NumArgs && isCanonical; ++i) 212054e14c4db764c0636160d26c5bbf491637c83a76John McCall if (!ArgArray[i].isCanonicalAsParam()) 21215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer isCanonical = false; 21225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2123cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv DefaultCC = EPI.ExtInfo.getCC(); 2124cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv CallConv = (LangOpts.MRTD && DefaultCC == CC_Default) ? 2125cfe9af250f466e7e38becea4428990448ae07737Roman Divacky CC_X86StdCall : DefaultCC; 2126e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 21275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this type isn't canonical, get the canonical version of it. 2128465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl // The exception spec is not part of the canonical type. 21295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 213004a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall if (!isCanonical || getCanonicalCallConv(CallConv) != CallConv) { 21315f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 16> CanonicalArgs; 21325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer CanonicalArgs.reserve(NumArgs); 21335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0; i != NumArgs; ++i) 213454e14c4db764c0636160d26c5bbf491637c83a76John McCall CanonicalArgs.push_back(getCanonicalParamType(ArgArray[i])); 2135465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 2136e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo CanonicalEPI = EPI; 21378b5b4099c61a136e9a1714c4d8a593febe942268Sebastian Redl CanonicalEPI.ExceptionSpecType = EST_None; 21388b5b4099c61a136e9a1714c4d8a593febe942268Sebastian Redl CanonicalEPI.NumExceptions = 0; 2139e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall CanonicalEPI.ExtInfo 2140e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall = CanonicalEPI.ExtInfo.withCallingConv(getCanonicalCallConv(CallConv)); 2141e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 2142f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner Canonical = getFunctionType(getCanonicalType(ResultTy), 2143beaaccd8e2a8748f77b66e2b330fb9136937e14cJay Foad CanonicalArgs.data(), NumArgs, 2144e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall CanonicalEPI); 2145465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 21465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 214772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoType *NewIP = 214872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos); 2149c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 21505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2151465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 2152f85e193739c953358c865005855253af4f68a497John McCall // FunctionProtoType objects are allocated with extra bytes after 2153f85e193739c953358c865005855253af4f68a497John McCall // them for three variable size arrays at the end: 2154f85e193739c953358c865005855253af4f68a497John McCall // - parameter types 2155f85e193739c953358c865005855253af4f68a497John McCall // - exception types 2156f85e193739c953358c865005855253af4f68a497John McCall // - consumed-arguments flags 2157f85e193739c953358c865005855253af4f68a497John McCall // Instead of the exception types, there could be a noexcept 2158f85e193739c953358c865005855253af4f68a497John McCall // expression. 2159e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall size_t Size = sizeof(FunctionProtoType) + 216060618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl NumArgs * sizeof(QualType); 216160618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl if (EPI.ExceptionSpecType == EST_Dynamic) 216260618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl Size += EPI.NumExceptions * sizeof(QualType); 216360618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl else if (EPI.ExceptionSpecType == EST_ComputedNoexcept) { 21648026f6d82f7fa544bc0453714fe94bca62a1196eSebastian Redl Size += sizeof(Expr*); 216560618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl } 2166f85e193739c953358c865005855253af4f68a497John McCall if (EPI.ConsumedArguments) 2167f85e193739c953358c865005855253af4f68a497John McCall Size += NumArgs * sizeof(bool); 2168f85e193739c953358c865005855253af4f68a497John McCall 2169e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType *FTP = (FunctionProtoType*) Allocate(Size, TypeAlignment); 2170cfe9af250f466e7e38becea4428990448ae07737Roman Divacky FunctionProtoType::ExtProtoInfo newEPI = EPI; 2171cfe9af250f466e7e38becea4428990448ae07737Roman Divacky newEPI.ExtInfo = EPI.ExtInfo.withCallingConv(CallConv); 21728026f6d82f7fa544bc0453714fe94bca62a1196eSebastian Redl new (FTP) FunctionProtoType(ResultTy, ArgArray, NumArgs, Canonical, newEPI); 21735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(FTP); 217472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoTypes.InsertNode(FTP, InsertPos); 21755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(FTP, 0); 21765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 21775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 21783cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall#ifndef NDEBUG 21793cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallstatic bool NeedsInjectedClassNameType(const RecordDecl *D) { 21803cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (!isa<CXXRecordDecl>(D)) return false; 21813cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall const CXXRecordDecl *RD = cast<CXXRecordDecl>(D); 21823cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (isa<ClassTemplatePartialSpecializationDecl>(RD)) 21833cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return true; 21843cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (RD->getDescribedClassTemplate() && 21853cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall !isa<ClassTemplateSpecializationDecl>(RD)) 21863cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return true; 21873cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return false; 21883cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall} 21893cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall#endif 21903cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 21913cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall/// getInjectedClassNameType - Return the unique reference to the 21923cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall/// injected class name type for the specified templated declaration. 21933cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallQualType ASTContext::getInjectedClassNameType(CXXRecordDecl *Decl, 21944ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType TST) const { 21953cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(NeedsInjectedClassNameType(Decl)); 21963cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (Decl->TypeForDecl) { 21973cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(isa<InjectedClassNameType>(Decl->TypeForDecl)); 2198ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor } else if (CXXRecordDecl *PrevDecl = Decl->getPreviousDecl()) { 21993cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(PrevDecl->TypeForDecl && "previous declaration has no type"); 22003cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall Decl->TypeForDecl = PrevDecl->TypeForDecl; 22013cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(isa<InjectedClassNameType>(Decl->TypeForDecl)); 22023cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } else { 2203f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Type *newType = 220431f17ecbef57b5679c017c375db330546b7b5145John McCall new (*this, TypeAlignment) InjectedClassNameType(Decl, TST); 2205f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2206f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 22073cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } 22083cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return QualType(Decl->TypeForDecl, 0); 22093cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall} 22103cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 22112ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor/// getTypeDeclType - Return the unique reference to the type for the 22122ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor/// specified type declaration. 22134ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTypeDeclTypeSlow(const TypeDecl *Decl) const { 22141e6759e9e33dcaa73ce14c8a908ac9f87ac16463Argyrios Kyrtzidis assert(Decl && "Passed null for Decl param"); 2215becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall assert(!Decl->TypeForDecl && "TypeForDecl present in slow case"); 22161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2217162e1c1b487352434552147967c3dd296ebee2f7Richard Smith if (const TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Decl)) 22182ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor return getTypedefType(Typedef); 2219becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall 2220becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall assert(!isa<TemplateTypeParmDecl>(Decl) && 2221becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall "Template type parameter types are always available."); 2222becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall 222319c8576b7328f4dc2d07682f5da552875c1912efJohn McCall if (const RecordDecl *Record = dyn_cast<RecordDecl>(Decl)) { 2224ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor assert(!Record->getPreviousDecl() && 2225becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall "struct/union has previous declaration"); 2226becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall assert(!NeedsInjectedClassNameType(Record)); 2227400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return getRecordType(Record); 222819c8576b7328f4dc2d07682f5da552875c1912efJohn McCall } else if (const EnumDecl *Enum = dyn_cast<EnumDecl>(Decl)) { 2229ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor assert(!Enum->getPreviousDecl() && 2230becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall "enum has previous declaration"); 2231400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return getEnumType(Enum); 223219c8576b7328f4dc2d07682f5da552875c1912efJohn McCall } else if (const UnresolvedUsingTypenameDecl *Using = 2233ed97649e9574b9d854fa4d6109c9333ae0993554John McCall dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) { 2234f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Type *newType = new (*this, TypeAlignment) UnresolvedUsingType(Using); 2235f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2236f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 22379fdbab3cbc2fc04bcaf5768023d83707f3151144Mike Stump } else 2238becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall llvm_unreachable("TypeDecl without a type?"); 223949aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidis 224049aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidis return QualType(Decl->TypeForDecl, 0); 22412ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor} 22422ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor 22435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getTypedefType - Return the unique reference to the type for the 2244162e1c1b487352434552147967c3dd296ebee2f7Richard Smith/// specified typedef name decl. 22459763e221e16026ddf487d2564ed349d2c874a1a1Argyrios KyrtzidisQualType 2246162e1c1b487352434552147967c3dd296ebee2f7Richard SmithASTContext::getTypedefType(const TypedefNameDecl *Decl, 2247162e1c1b487352434552147967c3dd296ebee2f7Richard Smith QualType Canonical) const { 22485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 22491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 22509763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis if (Canonical.isNull()) 22519763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis Canonical = getCanonicalType(Decl->getUnderlyingType()); 2252f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall TypedefType *newType = new(*this, TypeAlignment) 22536b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypedefType(Type::Typedef, Decl, Canonical); 2254f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2255f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 2256f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall return QualType(newType, 0); 22575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 22585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 22594ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getRecordType(const RecordDecl *Decl) const { 2260400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 2261400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2262ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor if (const RecordDecl *PrevDecl = Decl->getPreviousDecl()) 2263400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (PrevDecl->TypeForDecl) 2264400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0); 2265400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2266f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall RecordType *newType = new (*this, TypeAlignment) RecordType(Decl); 2267f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2268f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 2269f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall return QualType(newType, 0); 2270400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis} 2271400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 22724ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getEnumType(const EnumDecl *Decl) const { 2273400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 2274400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2275ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor if (const EnumDecl *PrevDecl = Decl->getPreviousDecl()) 2276400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (PrevDecl->TypeForDecl) 2277400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0); 2278400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2279f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall EnumType *newType = new (*this, TypeAlignment) EnumType(Decl); 2280f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2281f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 2282f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall return QualType(newType, 0); 2283400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis} 2284400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 22859d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCallQualType ASTContext::getAttributedType(AttributedType::Kind attrKind, 22869d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall QualType modifiedType, 22879d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall QualType equivalentType) { 22889d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall llvm::FoldingSetNodeID id; 22899d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedType::Profile(id, attrKind, modifiedType, equivalentType); 22909d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 22919d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall void *insertPos = 0; 22929d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedType *type = AttributedTypes.FindNodeOrInsertPos(id, insertPos); 22939d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall if (type) return QualType(type, 0); 22949d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 22959d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall QualType canon = getCanonicalType(equivalentType); 22969d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall type = new (*this, TypeAlignment) 22979d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedType(canon, attrKind, modifiedType, equivalentType); 22989d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 22999d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall Types.push_back(type); 23009d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedTypes.InsertNode(type, insertPos); 23019d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23029d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall return QualType(type, 0); 23039d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall} 23049d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23059d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 230649a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall/// \brief Retrieve a substitution-result type. 230749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCallQualType 230849a832bd499d6f61c23655f1fac99f0dd229756eJohn McCallASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm, 23094ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType Replacement) const { 2310467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(Replacement.isCanonical() 231149a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall && "replacement types must always be canonical"); 231249a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 231349a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall llvm::FoldingSetNodeID ID; 231449a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmType::Profile(ID, Parm, Replacement); 231549a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall void *InsertPos = 0; 231649a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmType *SubstParm 231749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 231849a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 231949a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall if (!SubstParm) { 232049a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstParm = new (*this, TypeAlignment) 232149a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmType(Parm, Replacement); 232249a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall Types.push_back(SubstParm); 232349a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos); 232449a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall } 232549a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 232649a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall return QualType(SubstParm, 0); 232749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall} 232849a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 2329c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor/// \brief Retrieve a 2330c3069d618f4661d923cb1b5c4525b082fce73b04Douglas GregorQualType ASTContext::getSubstTemplateTypeParmPackType( 2331c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor const TemplateTypeParmType *Parm, 2332c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor const TemplateArgument &ArgPack) { 2333c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor#ifndef NDEBUG 2334c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor for (TemplateArgument::pack_iterator P = ArgPack.pack_begin(), 2335c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor PEnd = ArgPack.pack_end(); 2336c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor P != PEnd; ++P) { 2337c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor assert(P->getKind() == TemplateArgument::Type &&"Pack contains a non-type"); 2338c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor assert(P->getAsType().isCanonical() && "Pack contains non-canonical type"); 2339c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor } 2340c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor#endif 2341c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2342c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor llvm::FoldingSetNodeID ID; 2343c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmPackType::Profile(ID, Parm, ArgPack); 2344c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor void *InsertPos = 0; 2345c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor if (SubstTemplateTypeParmPackType *SubstParm 2346c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor = SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos)) 2347c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor return QualType(SubstParm, 0); 2348c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2349c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor QualType Canon; 2350c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor if (!Parm->isCanonicalUnqualified()) { 2351c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor Canon = getCanonicalType(QualType(Parm, 0)); 2352c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor Canon = getSubstTemplateTypeParmPackType(cast<TemplateTypeParmType>(Canon), 2353c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor ArgPack); 2354c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos); 2355c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor } 2356c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2357c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmPackType *SubstParm 2358c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor = new (*this, TypeAlignment) SubstTemplateTypeParmPackType(Parm, Canon, 2359c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor ArgPack); 2360c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor Types.push_back(SubstParm); 2361c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos); 2362c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor return QualType(SubstParm, 0); 2363c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor} 2364c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2365fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor/// \brief Retrieve the template type parameter type for a template 23661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// parameter or parameter pack with the given depth, index, and (optionally) 236776e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson/// name. 23681eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index, 236976e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson bool ParameterPack, 23704fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TemplateTypeParmDecl *TTPDecl) const { 2371fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor llvm::FoldingSetNodeID ID; 23724fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, TTPDecl); 2373fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor void *InsertPos = 0; 23741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateTypeParmType *TypeParm 2375fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 2376fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 2377fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor if (TypeParm) 2378fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor return QualType(TypeParm, 0); 23791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 23804fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth if (TTPDecl) { 238176e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack); 23824fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TypeParm = new (*this, TypeAlignment) TemplateTypeParmType(TTPDecl, Canon); 2383789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2384789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor TemplateTypeParmType *TypeCheck 2385789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 2386789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!TypeCheck && "Template type parameter canonical type broken"); 2387789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)TypeCheck; 238876e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson } else 23896b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypeParm = new (*this, TypeAlignment) 23906b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TemplateTypeParmType(Depth, Index, ParameterPack); 2391fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 2392fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor Types.push_back(TypeParm); 2393fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos); 2394fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 2395fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor return QualType(TypeParm, 0); 2396fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor} 2397fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 23983cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallTypeSourceInfo * 23993cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallASTContext::getTemplateSpecializationTypeInfo(TemplateName Name, 24003cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall SourceLocation NameLoc, 24013cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall const TemplateArgumentListInfo &Args, 24023e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType Underlying) const { 24037c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Name.getAsDependentTemplateName() && 24047c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 24053e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType TST = getTemplateSpecializationType(Name, Args, Underlying); 24063cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 24073cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TypeSourceInfo *DI = CreateTypeSourceInfo(TST); 24083cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TemplateSpecializationTypeLoc TL 24093cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall = cast<TemplateSpecializationTypeLoc>(DI->getTypeLoc()); 24103cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setTemplateNameLoc(NameLoc); 24113cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setLAngleLoc(Args.getLAngleLoc()); 24123cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setRAngleLoc(Args.getRAngleLoc()); 24133cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 24143cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setArgLocInfo(i, Args[i].getLocInfo()); 24153cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return DI; 24163cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall} 24173cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 24181eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType 24197532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas GregorASTContext::getTemplateSpecializationType(TemplateName Template, 2420d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall const TemplateArgumentListInfo &Args, 24213e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType Underlying) const { 24227c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Template.getAsDependentTemplateName() && 24237c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 24247c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor 2425d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall unsigned NumArgs = Args.size(); 2426d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall 24275f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> ArgVec; 2428833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall ArgVec.reserve(NumArgs); 2429833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall for (unsigned i = 0; i != NumArgs; ++i) 2430833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall ArgVec.push_back(Args[i].getArgument()); 2431833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 243231f17ecbef57b5679c017c375db330546b7b5145John McCall return getTemplateSpecializationType(Template, ArgVec.data(), NumArgs, 24333e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith Underlying); 2434833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall} 2435833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 2436833ca991c1bfc967f0995974ca86f66ba1f666b5John McCallQualType 2437833ca991c1bfc967f0995974ca86f66ba1f666b5John McCallASTContext::getTemplateSpecializationType(TemplateName Template, 24387532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor const TemplateArgument *Args, 24397532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor unsigned NumArgs, 24403e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType Underlying) const { 24417c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Template.getAsDependentTemplateName() && 24427c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 24430f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor // Look through qualified template names. 24440f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 24450f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor Template = TemplateName(QTN->getTemplateDecl()); 24467c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor 24473e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith bool isTypeAlias = 24483e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith Template.getAsTemplateDecl() && 24493e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith isa<TypeAliasTemplateDecl>(Template.getAsTemplateDecl()); 24503e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith 24513e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType CanonType; 24523e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith if (!Underlying.isNull()) 24533e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith CanonType = getCanonicalType(Underlying); 24543e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith else { 24553e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith assert(!isTypeAlias && 24563e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith "Underlying type for template alias must be computed by caller"); 24573e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith CanonType = getCanonicalTemplateSpecializationType(Template, Args, 24583e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith NumArgs); 24593e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith } 2460fc705b84347e6fb4746a1a7e26949f64c2f2f358Douglas Gregor 24611275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // Allocate the (non-canonical) template specialization type, but don't 24621275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // try to unique it: these types typically have location information that 24631275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // we don't unique and don't want to lose. 24643e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith void *Mem = Allocate(sizeof(TemplateSpecializationType) + 24653e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith sizeof(TemplateArgument) * NumArgs + 24663e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith (isTypeAlias ? sizeof(QualType) : 0), 24676b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypeAlignment); 24681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateSpecializationType *Spec 2469ef99001908e799c388f1363b1e607dad5f5b57d3John McCall = new (Mem) TemplateSpecializationType(Template, 247031f17ecbef57b5679c017c375db330546b7b5145John McCall Args, NumArgs, 24713e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith CanonType, 24723e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith isTypeAlias ? Underlying : QualType()); 24731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 247455f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor Types.push_back(Spec); 24751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return QualType(Spec, 0); 247655f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor} 247755f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 24781eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType 24799763e221e16026ddf487d2564ed349d2c874a1a1Argyrios KyrtzidisASTContext::getCanonicalTemplateSpecializationType(TemplateName Template, 24809763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis const TemplateArgument *Args, 24814ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned NumArgs) const { 24827c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Template.getAsDependentTemplateName() && 24837c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 24843e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith assert((!Template.getAsTemplateDecl() || 24853e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith !isa<TypeAliasTemplateDecl>(Template.getAsTemplateDecl())) && 24863e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith "Underlying type for template alias must be computed by caller"); 24873e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith 24880f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor // Look through qualified template names. 24890f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 24900f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor Template = TemplateName(QTN->getTemplateDecl()); 24917c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor 24929763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Build the canonical template specialization type. 24939763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateName CanonTemplate = getCanonicalTemplateName(Template); 24945f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> CanonArgs; 24959763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.reserve(NumArgs); 24969763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis for (unsigned I = 0; I != NumArgs; ++I) 24979763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.push_back(getCanonicalTemplateArgument(Args[I])); 24989763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 24999763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Determine whether this canonical template specialization type already 25009763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // exists. 25019763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis llvm::FoldingSetNodeID ID; 25029763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateSpecializationType::Profile(ID, CanonTemplate, 25039763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.data(), NumArgs, *this); 25049763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25059763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis void *InsertPos = 0; 25069763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateSpecializationType *Spec 25079763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 25089763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25099763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis if (!Spec) { 25109763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Allocate a new canonical template specialization type. 25119763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis void *Mem = Allocate((sizeof(TemplateSpecializationType) + 25129763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis sizeof(TemplateArgument) * NumArgs), 25139763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TypeAlignment); 25149763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis Spec = new (Mem) TemplateSpecializationType(CanonTemplate, 25159763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.data(), NumArgs, 25163e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType(), QualType()); 25179763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis Types.push_back(Spec); 25189763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateSpecializationTypes.InsertNode(Spec, InsertPos); 25199763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis } 25209763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25219763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis assert(Spec->isDependentType() && 25229763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis "Non-dependent template-id type must have a canonical type"); 25239763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis return QualType(Spec, 0); 25249763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis} 25259763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25269763e221e16026ddf487d2564ed349d2c874a1a1Argyrios KyrtzidisQualType 2527465d41b92b2c862f3062c412a0538db65c6a2661Abramo BagnaraASTContext::getElaboratedType(ElaboratedTypeKeyword Keyword, 2528465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara NestedNameSpecifier *NNS, 25294ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType NamedType) const { 2530e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor llvm::FoldingSetNodeID ID; 2531465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedType::Profile(ID, Keyword, NNS, NamedType); 2532e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor 2533e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor void *InsertPos = 0; 2534465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedType *T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos); 2535e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor if (T) 2536e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor return QualType(T, 0); 2537e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor 2538789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor QualType Canon = NamedType; 2539789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor if (!Canon.isCanonical()) { 2540789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor Canon = getCanonicalType(NamedType); 2541465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedType *CheckT = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos); 2542465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara assert(!CheckT && "Elaborated canonical type broken"); 2543789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CheckT; 2544789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor } 2545789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2546465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara T = new (*this) ElaboratedType(Keyword, NNS, NamedType, Canon); 2547e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor Types.push_back(T); 2548465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedTypes.InsertNode(T, InsertPos); 2549e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor return QualType(T, 0); 2550e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor} 2551e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor 2552075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo BagnaraQualType 25534ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getParenType(QualType InnerType) const { 2554075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara llvm::FoldingSetNodeID ID; 2555075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenType::Profile(ID, InnerType); 2556075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 2557075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara void *InsertPos = 0; 2558075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenType *T = ParenTypes.FindNodeOrInsertPos(ID, InsertPos); 2559075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara if (T) 2560075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return QualType(T, 0); 2561075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 2562075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara QualType Canon = InnerType; 2563075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara if (!Canon.isCanonical()) { 2564075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara Canon = getCanonicalType(InnerType); 2565075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos); 2566075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara assert(!CheckT && "Paren canonical type broken"); 2567075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara (void)CheckT; 2568075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara } 2569075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 2570075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara T = new (*this) ParenType(InnerType, Canon); 2571075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara Types.push_back(T); 2572075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenTypes.InsertNode(T, InsertPos); 2573075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return QualType(T, 0); 2574075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara} 2575075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 25764a2023f5014e82389d5980d307b89c545dbbac81Douglas GregorQualType ASTContext::getDependentNameType(ElaboratedTypeKeyword Keyword, 25774a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor NestedNameSpecifier *NNS, 25784a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor const IdentifierInfo *Name, 25794ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType Canon) const { 2580d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor assert(NNS->isDependent() && "nested-name-specifier must be dependent"); 2581d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2582d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor if (Canon.isNull()) { 2583d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 25844a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor ElaboratedTypeKeyword CanonKeyword = Keyword; 25854a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor if (Keyword == ETK_None) 25864a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor CanonKeyword = ETK_Typename; 25874a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor 25884a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor if (CanonNNS != NNS || CanonKeyword != Keyword) 25894a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor Canon = getDependentNameType(CanonKeyword, CanonNNS, Name); 2590d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor } 2591d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2592d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor llvm::FoldingSetNodeID ID; 25934a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor DependentNameType::Profile(ID, Keyword, NNS, Name); 2594d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2595d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor void *InsertPos = 0; 25964714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor DependentNameType *T 25974714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos); 2598d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor if (T) 2599d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor return QualType(T, 0); 2600d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 26014a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor T = new (*this) DependentNameType(Keyword, NNS, Name, Canon); 2602d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor Types.push_back(T); 26034714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor DependentNameTypes.InsertNode(T, InsertPos); 26041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return QualType(T, 0); 2605d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor} 2606d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 26071eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType 260833500955d731c73717af52088b7fc0e7a85681e7John McCallASTContext::getDependentTemplateSpecializationType( 260933500955d731c73717af52088b7fc0e7a85681e7John McCall ElaboratedTypeKeyword Keyword, 26104a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor NestedNameSpecifier *NNS, 261133500955d731c73717af52088b7fc0e7a85681e7John McCall const IdentifierInfo *Name, 26124ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const TemplateArgumentListInfo &Args) const { 261333500955d731c73717af52088b7fc0e7a85681e7John McCall // TODO: avoid this copy 26145f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 16> ArgCopy; 261533500955d731c73717af52088b7fc0e7a85681e7John McCall for (unsigned I = 0, E = Args.size(); I != E; ++I) 261633500955d731c73717af52088b7fc0e7a85681e7John McCall ArgCopy.push_back(Args[I].getArgument()); 261733500955d731c73717af52088b7fc0e7a85681e7John McCall return getDependentTemplateSpecializationType(Keyword, NNS, Name, 261833500955d731c73717af52088b7fc0e7a85681e7John McCall ArgCopy.size(), 261933500955d731c73717af52088b7fc0e7a85681e7John McCall ArgCopy.data()); 262033500955d731c73717af52088b7fc0e7a85681e7John McCall} 262133500955d731c73717af52088b7fc0e7a85681e7John McCall 262233500955d731c73717af52088b7fc0e7a85681e7John McCallQualType 262333500955d731c73717af52088b7fc0e7a85681e7John McCallASTContext::getDependentTemplateSpecializationType( 262433500955d731c73717af52088b7fc0e7a85681e7John McCall ElaboratedTypeKeyword Keyword, 262533500955d731c73717af52088b7fc0e7a85681e7John McCall NestedNameSpecifier *NNS, 262633500955d731c73717af52088b7fc0e7a85681e7John McCall const IdentifierInfo *Name, 262733500955d731c73717af52088b7fc0e7a85681e7John McCall unsigned NumArgs, 26284ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const TemplateArgument *Args) const { 2629aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor assert((!NNS || NNS->isDependent()) && 2630aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor "nested-name-specifier must be dependent"); 26311734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 2632789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor llvm::FoldingSetNodeID ID; 263333500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS, 263433500955d731c73717af52088b7fc0e7a85681e7John McCall Name, NumArgs, Args); 2635789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2636789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor void *InsertPos = 0; 263733500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationType *T 263833500955d731c73717af52088b7fc0e7a85681e7John McCall = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 2639789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor if (T) 2640789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor return QualType(T, 0); 2641789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 264233500955d731c73717af52088b7fc0e7a85681e7John McCall NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 264333500955d731c73717af52088b7fc0e7a85681e7John McCall 264433500955d731c73717af52088b7fc0e7a85681e7John McCall ElaboratedTypeKeyword CanonKeyword = Keyword; 264533500955d731c73717af52088b7fc0e7a85681e7John McCall if (Keyword == ETK_None) CanonKeyword = ETK_Typename; 26461734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 264733500955d731c73717af52088b7fc0e7a85681e7John McCall bool AnyNonCanonArgs = false; 26485f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 16> CanonArgs(NumArgs); 264933500955d731c73717af52088b7fc0e7a85681e7John McCall for (unsigned I = 0; I != NumArgs; ++I) { 265033500955d731c73717af52088b7fc0e7a85681e7John McCall CanonArgs[I] = getCanonicalTemplateArgument(Args[I]); 265133500955d731c73717af52088b7fc0e7a85681e7John McCall if (!CanonArgs[I].structurallyEquals(Args[I])) 265233500955d731c73717af52088b7fc0e7a85681e7John McCall AnyNonCanonArgs = true; 2653789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor } 26541734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 265533500955d731c73717af52088b7fc0e7a85681e7John McCall QualType Canon; 265633500955d731c73717af52088b7fc0e7a85681e7John McCall if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) { 265733500955d731c73717af52088b7fc0e7a85681e7John McCall Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS, 265833500955d731c73717af52088b7fc0e7a85681e7John McCall Name, NumArgs, 265933500955d731c73717af52088b7fc0e7a85681e7John McCall CanonArgs.data()); 266033500955d731c73717af52088b7fc0e7a85681e7John McCall 266133500955d731c73717af52088b7fc0e7a85681e7John McCall // Find the insert position again. 266233500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 266333500955d731c73717af52088b7fc0e7a85681e7John McCall } 266433500955d731c73717af52088b7fc0e7a85681e7John McCall 266533500955d731c73717af52088b7fc0e7a85681e7John McCall void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) + 266633500955d731c73717af52088b7fc0e7a85681e7John McCall sizeof(TemplateArgument) * NumArgs), 266733500955d731c73717af52088b7fc0e7a85681e7John McCall TypeAlignment); 2668ef99001908e799c388f1363b1e607dad5f5b57d3John McCall T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS, 266933500955d731c73717af52088b7fc0e7a85681e7John McCall Name, NumArgs, Args, Canon); 26701734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor Types.push_back(T); 267133500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationTypes.InsertNode(T, InsertPos); 26721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return QualType(T, 0); 26731734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor} 26741734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 2675cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas GregorQualType ASTContext::getPackExpansionType(QualType Pattern, 2676cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor llvm::Optional<unsigned> NumExpansions) { 26777536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor llvm::FoldingSetNodeID ID; 2678cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor PackExpansionType::Profile(ID, Pattern, NumExpansions); 26797536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 26807536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor assert(Pattern->containsUnexpandedParameterPack() && 26817536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor "Pack expansions must expand one or more parameter packs"); 26827536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor void *InsertPos = 0; 26837536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor PackExpansionType *T 26847536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor = PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos); 26857536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor if (T) 26867536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor return QualType(T, 0); 26877536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 26887536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor QualType Canon; 26897536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor if (!Pattern.isCanonical()) { 2690cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor Canon = getPackExpansionType(getCanonicalType(Pattern), NumExpansions); 26917536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 26927536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor // Find the insert position again. 26937536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos); 26947536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor } 26957536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 2696cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor T = new (*this) PackExpansionType(Pattern, Canon, NumExpansions); 26977536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor Types.push_back(T); 26987536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor PackExpansionTypes.InsertNode(T, InsertPos); 26997536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor return QualType(T, 0); 27007536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor} 27017536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 270288cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner/// CmpProtocolNames - Comparison predicate for sorting protocols 270388cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner/// alphabetically. 270488cb27a160adc305783a44f922ee4b216006ebf9Chris Lattnerstatic bool CmpProtocolNames(const ObjCProtocolDecl *LHS, 270588cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner const ObjCProtocolDecl *RHS) { 27062e1cd4264d363ca869bf37ef160902f211d21b8cDouglas Gregor return LHS->getDeclName() < RHS->getDeclName(); 270788cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner} 270888cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 2709c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCallstatic bool areSortedAndUniqued(ObjCProtocolDecl * const *Protocols, 271054e14c4db764c0636160d26c5bbf491637c83a76John McCall unsigned NumProtocols) { 271154e14c4db764c0636160d26c5bbf491637c83a76John McCall if (NumProtocols == 0) return true; 271254e14c4db764c0636160d26c5bbf491637c83a76John McCall 271361cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor if (Protocols[0]->getCanonicalDecl() != Protocols[0]) 271461cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor return false; 271561cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor 271654e14c4db764c0636160d26c5bbf491637c83a76John McCall for (unsigned i = 1; i != NumProtocols; ++i) 271761cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor if (!CmpProtocolNames(Protocols[i-1], Protocols[i]) || 271861cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor Protocols[i]->getCanonicalDecl() != Protocols[i]) 271954e14c4db764c0636160d26c5bbf491637c83a76John McCall return false; 272054e14c4db764c0636160d26c5bbf491637c83a76John McCall return true; 272154e14c4db764c0636160d26c5bbf491637c83a76John McCall} 272254e14c4db764c0636160d26c5bbf491637c83a76John McCall 272354e14c4db764c0636160d26c5bbf491637c83a76John McCallstatic void SortAndUniqueProtocols(ObjCProtocolDecl **Protocols, 272488cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner unsigned &NumProtocols) { 272588cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner ObjCProtocolDecl **ProtocolsEnd = Protocols+NumProtocols; 27261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 272788cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner // Sort protocols, keyed by name. 272888cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner std::sort(Protocols, Protocols+NumProtocols, CmpProtocolNames); 272988cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 273061cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor // Canonicalize. 273161cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor for (unsigned I = 0, N = NumProtocols; I != N; ++I) 273261cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor Protocols[I] = Protocols[I]->getCanonicalDecl(); 273361cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor 273488cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner // Remove duplicates. 273588cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner ProtocolsEnd = std::unique(Protocols, ProtocolsEnd); 273688cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner NumProtocols = ProtocolsEnd-Protocols; 273788cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner} 273888cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 2739c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCallQualType ASTContext::getObjCObjectType(QualType BaseType, 2740c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCProtocolDecl * const *Protocols, 27414ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned NumProtocols) const { 2742c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // If the base type is an interface and there aren't any protocols 2743c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // to add, then the interface type will do just fine. 2744c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!NumProtocols && isa<ObjCInterfaceType>(BaseType)) 2745c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return BaseType; 2746d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff 2747c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Look in the folding set for an existing type. 2748c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall llvm::FoldingSetNodeID ID; 2749c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypeImpl::Profile(ID, BaseType, Protocols, NumProtocols); 2750d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff void *InsertPos = 0; 2751c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos)) 2752c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return QualType(QT, 0); 2753d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff 2754c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Build the canonical type, which has the canonical base type and 2755c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // a sorted-and-uniqued list of protocols. 275654e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType Canonical; 2757c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall bool ProtocolsSorted = areSortedAndUniqued(Protocols, NumProtocols); 2758c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!ProtocolsSorted || !BaseType.isCanonical()) { 2759c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!ProtocolsSorted) { 27605f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<ObjCProtocolDecl*, 8> Sorted(Protocols, 27610237941e0beb0c929934b66ad29443b484d987feBenjamin Kramer Protocols + NumProtocols); 276254e14c4db764c0636160d26c5bbf491637c83a76John McCall unsigned UniqueCount = NumProtocols; 276354e14c4db764c0636160d26c5bbf491637c83a76John McCall 276454e14c4db764c0636160d26c5bbf491637c83a76John McCall SortAndUniqueProtocols(&Sorted[0], UniqueCount); 2765c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Canonical = getObjCObjectType(getCanonicalType(BaseType), 2766c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall &Sorted[0], UniqueCount); 276754e14c4db764c0636160d26c5bbf491637c83a76John McCall } else { 2768c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Canonical = getObjCObjectType(getCanonicalType(BaseType), 2769c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Protocols, NumProtocols); 277054e14c4db764c0636160d26c5bbf491637c83a76John McCall } 277154e14c4db764c0636160d26c5bbf491637c83a76John McCall 277254e14c4db764c0636160d26c5bbf491637c83a76John McCall // Regenerate InsertPos. 2773c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos); 277454e14c4db764c0636160d26c5bbf491637c83a76John McCall } 277554e14c4db764c0636160d26c5bbf491637c83a76John McCall 2776c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall unsigned Size = sizeof(ObjCObjectTypeImpl); 2777c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Size += NumProtocols * sizeof(ObjCProtocolDecl *); 2778fd6a0887a099256c35a5b23e9afd517ffe95fa0aDouglas Gregor void *Mem = Allocate(Size, TypeAlignment); 2779c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypeImpl *T = 2780c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall new (Mem) ObjCObjectTypeImpl(Canonical, BaseType, Protocols, NumProtocols); 27811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2782c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Types.push_back(T); 2783c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypes.InsertNode(T, InsertPos); 2784c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return QualType(T, 0); 2785d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff} 278688cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 2787c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall/// getObjCObjectPointerType - Return a ObjCObjectPointerType type for 2788c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall/// the given object type. 27894ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getObjCObjectPointerType(QualType ObjectT) const { 27904b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian llvm::FoldingSetNodeID ID; 2791c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerType::Profile(ID, ObjectT); 27921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 27934b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian void *InsertPos = 0; 2794c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (ObjCObjectPointerType *QT = 2795c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 27964b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian return QualType(QT, 0); 27971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2798c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Find the canonical object type. 279954e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType Canonical; 2800c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!ObjectT.isCanonical()) { 2801c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Canonical = getObjCObjectPointerType(getCanonicalType(ObjectT)); 280254e14c4db764c0636160d26c5bbf491637c83a76John McCall 2803c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Regenerate InsertPos. 2804c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 280554e14c4db764c0636160d26c5bbf491637c83a76John McCall } 280654e14c4db764c0636160d26c5bbf491637c83a76John McCall 2807c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // No match. 2808c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall void *Mem = Allocate(sizeof(ObjCObjectPointerType), TypeAlignment); 2809c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerType *QType = 2810c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall new (Mem) ObjCObjectPointerType(Canonical, ObjectT); 281124fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis 281224fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis Types.push_back(QType); 2813c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerTypes.InsertNode(QType, InsertPos); 281424fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis return QualType(QType, 0); 281524fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis} 281624fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis 2817deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor/// getObjCInterfaceType - Return the unique reference to the type for the 2818deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor/// specified ObjC interface decl. The list of protocols is optional. 28190af550115df1f57f17a4f125ff0e8b34820c65d1Douglas GregorQualType ASTContext::getObjCInterfaceType(const ObjCInterfaceDecl *Decl, 28200af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor ObjCInterfaceDecl *PrevDecl) const { 2821deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor if (Decl->TypeForDecl) 2822deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor return QualType(Decl->TypeForDecl, 0); 282374c730ad1f6818b676b0bad46d806a9176950328Sebastian Redl 28240af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor if (PrevDecl) { 28250af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor assert(PrevDecl->TypeForDecl && "previous decl has no TypeForDecl"); 28260af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor Decl->TypeForDecl = PrevDecl->TypeForDecl; 28270af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor return QualType(PrevDecl->TypeForDecl, 0); 28280af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor } 28290af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor 28308d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor // Prefer the definition, if there is one. 28318d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor if (const ObjCInterfaceDecl *Def = Decl->getDefinition()) 28328d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor Decl = Def; 28338d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor 2834deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor void *Mem = Allocate(sizeof(ObjCInterfaceType), TypeAlignment); 2835deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor ObjCInterfaceType *T = new (Mem) ObjCInterfaceType(Decl); 2836deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor Decl->TypeForDecl = T; 2837deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor Types.push_back(T); 2838deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor return QualType(T, 0); 2839c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall} 2840c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 284172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor/// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique 284272564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor/// TypeOfExprType AST's (since expression's are never shared). For example, 28439752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// multiple declarations that refer to "typeof(x)" all contain different 28441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// DeclRefExpr's. This doesn't effect the type checker, since it operates 28459752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// on canonical type's (which are always unique). 28464ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTypeOfExprType(Expr *tofExpr) const { 2847dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor TypeOfExprType *toe; 2848b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor if (tofExpr->isTypeDependent()) { 2849b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor llvm::FoldingSetNodeID ID; 2850b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor DependentTypeOfExprType::Profile(ID, *this, tofExpr); 28511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2852b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor void *InsertPos = 0; 2853b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor DependentTypeOfExprType *Canon 2854b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos); 2855b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor if (Canon) { 2856b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor // We already have a "canonical" version of an identical, dependent 2857b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor // typeof(expr) type. Use that as our canonical type. 28586b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, 2859b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor QualType((TypeOfExprType*)Canon, 0)); 28603060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 2861b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor // Build a new, canonical typeof(expr) type. 28626b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall Canon 28636b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr); 2864b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor DependentTypeOfExprTypes.InsertNode(Canon, InsertPos); 2865b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor toe = Canon; 2866b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor } 2867b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor } else { 2868dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor QualType Canonical = getCanonicalType(tofExpr->getType()); 28696b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical); 2870dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor } 28719752f25748d954df99087d741ea35db37ff16beaSteve Naroff Types.push_back(toe); 28729752f25748d954df99087d741ea35db37ff16beaSteve Naroff return QualType(toe, 0); 2873d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff} 2874d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff 28759752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// getTypeOfType - Unlike many "get<Type>" functions, we don't unique 28769752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// TypeOfType AST's. The only motivation to unique these nodes would be 28779752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be 28781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// an issue. This doesn't effect the type checker, since it operates 28799752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// on canonical type's (which are always unique). 28804ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTypeOfType(QualType tofType) const { 2881f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner QualType Canonical = getCanonicalType(tofType); 28826b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypeOfType *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical); 28839752f25748d954df99087d741ea35db37ff16beaSteve Naroff Types.push_back(tot); 28849752f25748d954df99087d741ea35db37ff16beaSteve Naroff return QualType(tot, 0); 2885d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff} 2886d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff 288760a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson/// getDecltypeForExpr - Given an expr, will return the decltype for that 288860a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson/// expression, according to the rules in C++0x [dcl.type.simple]p4 28894ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadstatic QualType getDecltypeForExpr(const Expr *e, const ASTContext &Context) { 2890a07c33e64e1169e4261f7748c7f9191091a3ad2eAnders Carlsson if (e->isTypeDependent()) 2891a07c33e64e1169e4261f7748c7f9191091a3ad2eAnders Carlsson return Context.DependentTy; 28921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 289360a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson // If e is an id expression or a class member access, decltype(e) is defined 289460a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson // as the type of the entity named by e. 289560a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(e)) { 289660a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson if (const ValueDecl *VD = dyn_cast<ValueDecl>(DRE->getDecl())) 289760a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson return VD->getType(); 289860a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson } 289960a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson if (const MemberExpr *ME = dyn_cast<MemberExpr>(e)) { 290060a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson if (const FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) 290160a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson return FD->getType(); 290260a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson } 290360a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson // If e is a function call or an invocation of an overloaded operator, 290460a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson // (parentheses around e are ignored), decltype(e) is defined as the 290560a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson // return type of that function. 290660a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson if (const CallExpr *CE = dyn_cast<CallExpr>(e->IgnoreParens())) 290760a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson return CE->getCallReturnType(); 29081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 290960a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson QualType T = e->getType(); 29101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 29111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Otherwise, where T is the type of e, if e is an lvalue, decltype(e) is 291260a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson // defined as T&, otherwise decltype(e) is defined as T. 29137eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall if (e->isLValue()) 291460a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson T = Context.getLValueReferenceType(T); 29151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 291660a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson return T; 291760a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson} 291860a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson 2919395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson/// getDecltypeType - Unlike many "get<Type>" functions, we don't unique 2920395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson/// DecltypeType AST's. The only motivation to unique these nodes would be 2921395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson/// memory savings. Since decltype(t) is fairly uncommon, space shouldn't be 29221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// an issue. This doesn't effect the type checker, since it operates 292339e02032b01874a0d02ba85a4cd3922adda81376David Blaikie/// on canonical types (which are always unique). 29244ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getDecltypeType(Expr *e) const { 2925dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor DecltypeType *dt; 2926561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor 2927561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // C++0x [temp.type]p2: 2928561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // If an expression e involves a template parameter, decltype(e) denotes a 2929561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // unique dependent type. Two such decltype-specifiers refer to the same 2930561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // type only if their expressions are equivalent (14.5.6.1). 2931561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor if (e->isInstantiationDependent()) { 29329d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor llvm::FoldingSetNodeID ID; 29339d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor DependentDecltypeType::Profile(ID, *this, e); 29341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 29359d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor void *InsertPos = 0; 29369d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor DependentDecltypeType *Canon 29379d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos); 29389d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor if (Canon) { 29399d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor // We already have a "canonical" version of an equivalent, dependent 29409d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor // decltype type. Use that as our canonical type. 29416b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall dt = new (*this, TypeAlignment) DecltypeType(e, DependentTy, 29429d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor QualType((DecltypeType*)Canon, 0)); 29433060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 29449d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor // Build a new, canonical typeof(expr) type. 29456b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall Canon = new (*this, TypeAlignment) DependentDecltypeType(*this, e); 29469d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor DependentDecltypeTypes.InsertNode(Canon, InsertPos); 29479d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor dt = Canon; 29489d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor } 29499d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor } else { 2950dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor QualType T = getDecltypeForExpr(e, *this); 29516b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall dt = new (*this, TypeAlignment) DecltypeType(e, T, getCanonicalType(T)); 2952dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor } 2953395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson Types.push_back(dt); 2954395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson return QualType(dt, 0); 2955395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson} 2956395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson 2957ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt/// getUnaryTransformationType - We don't unique these, since the memory 2958ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt/// savings are minimal and these are rare. 2959ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean HuntQualType ASTContext::getUnaryTransformType(QualType BaseType, 2960ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt QualType UnderlyingType, 2961ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt UnaryTransformType::UTTKind Kind) 2962ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt const { 2963ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt UnaryTransformType *Ty = 296469d9775da47a4b9f165dbc33277f02982928a94eDouglas Gregor new (*this, TypeAlignment) UnaryTransformType (BaseType, UnderlyingType, 296569d9775da47a4b9f165dbc33277f02982928a94eDouglas Gregor Kind, 296669d9775da47a4b9f165dbc33277f02982928a94eDouglas Gregor UnderlyingType->isDependentType() ? 296769d9775da47a4b9f165dbc33277f02982928a94eDouglas Gregor QualType() : UnderlyingType); 2968ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt Types.push_back(Ty); 2969ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt return QualType(Ty, 0); 2970ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt} 2971ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt 2972483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith/// getAutoType - We only unique auto types after they've been deduced. 297334b41d939a1328f484511c6002ba2456db879a29Richard SmithQualType ASTContext::getAutoType(QualType DeducedType) const { 2974483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith void *InsertPos = 0; 2975483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith if (!DeducedType.isNull()) { 2976483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith // Look in the folding set for an existing type. 2977483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith llvm::FoldingSetNodeID ID; 2978483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith AutoType::Profile(ID, DeducedType); 2979483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith if (AutoType *AT = AutoTypes.FindNodeOrInsertPos(ID, InsertPos)) 2980483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith return QualType(AT, 0); 2981483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith } 2982483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith 2983483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith AutoType *AT = new (*this, TypeAlignment) AutoType(DeducedType); 2984483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith Types.push_back(AT); 2985483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith if (InsertPos) 2986483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith AutoTypes.InsertNode(AT, InsertPos); 2987483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith return QualType(AT, 0); 298834b41d939a1328f484511c6002ba2456db879a29Richard Smith} 298934b41d939a1328f484511c6002ba2456db879a29Richard Smith 2990b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman/// getAtomicType - Return the uniqued reference to the atomic type for 2991b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman/// the given value type. 2992b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli FriedmanQualType ASTContext::getAtomicType(QualType T) const { 2993b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // Unique pointers, to guarantee there is only one pointer of a particular 2994b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // structure. 2995b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman llvm::FoldingSetNodeID ID; 2996b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicType::Profile(ID, T); 2997b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 2998b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman void *InsertPos = 0; 2999b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos)) 3000b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return QualType(AT, 0); 3001b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 3002b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // If the atomic value type isn't canonical, this won't be a canonical type 3003b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // either, so fill in the canonical type field. 3004b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType Canonical; 3005b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (!T.isCanonical()) { 3006b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman Canonical = getAtomicType(getCanonicalType(T)); 3007b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 3008b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // Get the new insert position for the node we care about. 3009b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos); 3010b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 3011b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 3012b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicType *New = new (*this, TypeAlignment) AtomicType(T, Canonical); 3013b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman Types.push_back(New); 3014b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicTypes.InsertNode(New, InsertPos); 3015b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return QualType(New, 0); 3016b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman} 3017b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 3018ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// getAutoDeductType - Get type pattern for deducing against 'auto'. 3019ad762fcdc16b9e4705b12b09d92b8c026212b906Richard SmithQualType ASTContext::getAutoDeductType() const { 3020ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith if (AutoDeductTy.isNull()) 3021ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith AutoDeductTy = getAutoType(QualType()); 3022ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith assert(!AutoDeductTy.isNull() && "can't build 'auto' pattern"); 3023ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith return AutoDeductTy; 3024ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith} 3025ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith 3026ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// getAutoRRefDeductType - Get type pattern for deducing against 'auto &&'. 3027ad762fcdc16b9e4705b12b09d92b8c026212b906Richard SmithQualType ASTContext::getAutoRRefDeductType() const { 3028ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith if (AutoRRefDeductTy.isNull()) 3029ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith AutoRRefDeductTy = getRValueReferenceType(getAutoDeductType()); 3030ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith assert(!AutoRRefDeductTy.isNull() && "can't build 'auto &&' pattern"); 3031ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith return AutoRRefDeductTy; 3032ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith} 3033ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith 30345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getTagDeclType - Return the unique reference to the type for the 30355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// specified TagDecl (struct/union/class/enum) decl. 30364ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTagDeclType(const TagDecl *Decl) const { 3037d778f88d32b96a74c9edb7342c81357606a7cdc0Ted Kremenek assert (Decl); 3038e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump // FIXME: What is the design on getTagDeclType when it requires casting 3039e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump // away const? mutable? 3040e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump return getTypeDeclType(const_cast<TagDecl*>(Decl)); 30415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 30425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 30431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getSizeType - Return the unique type for "size_t" (C99 7.17), the result 30441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and 30451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// needs to agree with the definition in <stddef.h>. 3046a3ccda58913cc1a4b8564e349448b12acc462da7Anders CarlssonCanQualType ASTContext::getSizeType() const { 3047bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor return getFromTargetType(Target->getSizeType()); 30485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 30495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 305029e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg/// getIntMaxType - Return the unique type for "intmax_t" (C99 7.18.1.5). 305129e97cb35fab314388f62b68fefa78947e93c1dcHans WennborgCanQualType ASTContext::getIntMaxType() const { 305229e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg return getFromTargetType(Target->getIntMaxType()); 305329e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg} 305429e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg 305529e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg/// getUIntMaxType - Return the unique type for "uintmax_t" (C99 7.18.1.5). 305629e97cb35fab314388f62b68fefa78947e93c1dcHans WennborgCanQualType ASTContext::getUIntMaxType() const { 305729e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg return getFromTargetType(Target->getUIntMaxType()); 305829e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg} 305929e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg 306064c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// getSignedWCharType - Return the type of "signed wchar_t". 306164c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// Used when in C++, as a GCC extension. 306264c438a4be2a871fa43c78264663ba1e9788b94dArgyrios KyrtzidisQualType ASTContext::getSignedWCharType() const { 306364c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis // FIXME: derive from "Target" ? 306464c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis return WCharTy; 306564c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis} 306664c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 306764c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// getUnsignedWCharType - Return the type of "unsigned wchar_t". 306864c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// Used when in C++, as a GCC extension. 306964c438a4be2a871fa43c78264663ba1e9788b94dArgyrios KyrtzidisQualType ASTContext::getUnsignedWCharType() const { 307064c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis // FIXME: derive from "Target" ? 307164c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis return UnsignedIntTy; 307264c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis} 307364c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 307429e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg/// getPointerDiffType - Return the unique type for "ptrdiff_t" (C99 7.17) 30758b9023ba35a86838789e2c9034a6128728c547aaChris Lattner/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9). 30768b9023ba35a86838789e2c9034a6128728c547aaChris LattnerQualType ASTContext::getPointerDiffType() const { 3077bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor return getFromTargetType(Target->getPtrDiffType(0)); 30788b9023ba35a86838789e2c9034a6128728c547aaChris Lattner} 30798b9023ba35a86838789e2c9034a6128728c547aaChris Lattner 3080e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner//===----------------------------------------------------------------------===// 3081e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner// Type Operators 3082e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner//===----------------------------------------------------------------------===// 3083e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner 30844ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCanQualType ASTContext::getCanonicalParamType(QualType T) const { 308554e14c4db764c0636160d26c5bbf491637c83a76John McCall // Push qualifiers into arrays, and then discard any remaining 308654e14c4db764c0636160d26c5bbf491637c83a76John McCall // qualifiers. 308754e14c4db764c0636160d26c5bbf491637c83a76John McCall T = getCanonicalType(T); 3088745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian T = getVariableArrayDecayedType(T); 308954e14c4db764c0636160d26c5bbf491637c83a76John McCall const Type *Ty = T.getTypePtr(); 309054e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType Result; 309154e14c4db764c0636160d26c5bbf491637c83a76John McCall if (isa<ArrayType>(Ty)) { 309254e14c4db764c0636160d26c5bbf491637c83a76John McCall Result = getArrayDecayedType(QualType(Ty,0)); 309354e14c4db764c0636160d26c5bbf491637c83a76John McCall } else if (isa<FunctionType>(Ty)) { 309454e14c4db764c0636160d26c5bbf491637c83a76John McCall Result = getPointerType(QualType(Ty, 0)); 309554e14c4db764c0636160d26c5bbf491637c83a76John McCall } else { 309654e14c4db764c0636160d26c5bbf491637c83a76John McCall Result = QualType(Ty, 0); 309754e14c4db764c0636160d26c5bbf491637c83a76John McCall } 309854e14c4db764c0636160d26c5bbf491637c83a76John McCall 309954e14c4db764c0636160d26c5bbf491637c83a76John McCall return CanQualType::CreateUnsafe(Result); 310054e14c4db764c0636160d26c5bbf491637c83a76John McCall} 310154e14c4db764c0636160d26c5bbf491637c83a76John McCall 310262c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCallQualType ASTContext::getUnqualifiedArrayType(QualType type, 310362c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall Qualifiers &quals) { 310462c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall SplitQualType splitType = type.getSplitUnqualifiedType(); 310562c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 310662c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // FIXME: getSplitUnqualifiedType() actually walks all the way to 310762c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // the unqualified desugared type and then drops it on the floor. 310862c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // We then have to strip that sugar back off with 310962c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // getUnqualifiedDesugaredType(), which is silly. 311062c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall const ArrayType *AT = 311162c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall dyn_cast<ArrayType>(splitType.first->getUnqualifiedDesugaredType()); 311262c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 311362c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // If we don't have an array, just use the results in splitType. 31149dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (!AT) { 311562c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall quals = splitType.second; 311662c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return QualType(splitType.first, 0); 311728e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth } 311828e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 311962c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // Otherwise, recurse on the array's element type. 312062c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall QualType elementType = AT->getElementType(); 312162c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall QualType unqualElementType = getUnqualifiedArrayType(elementType, quals); 312262c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 312362c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // If that didn't change the element type, AT has no qualifiers, so we 312462c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // can just use the results in splitType. 312562c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall if (elementType == unqualElementType) { 312662c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall assert(quals.empty()); // from the recursive call 312762c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall quals = splitType.second; 312862c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return QualType(splitType.first, 0); 312962c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall } 313062c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 313162c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // Otherwise, add in the qualifiers from the outermost type, then 313262c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // build the type back up. 313362c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall quals.addConsistentQualifiers(splitType.second); 313428e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31359dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) { 313662c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getConstantArrayType(unqualElementType, CAT->getSize(), 313728e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth CAT->getSizeModifier(), 0); 313828e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth } 313928e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31409dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) { 314162c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getIncompleteArrayType(unqualElementType, IAT->getSizeModifier(), 0); 314228e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth } 314328e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31449dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(AT)) { 314562c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getVariableArrayType(unqualElementType, 31463fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall VAT->getSizeExpr(), 31479dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor VAT->getSizeModifier(), 31489dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor VAT->getIndexTypeCVRQualifiers(), 31499dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor VAT->getBracketsRange()); 31509dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor } 31519dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor 31529dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor const DependentSizedArrayType *DSAT = cast<DependentSizedArrayType>(AT); 315362c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getDependentSizedArrayType(unqualElementType, DSAT->getSizeExpr(), 315428e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth DSAT->getSizeModifier(), 0, 315528e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth SourceRange()); 315628e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth} 315728e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31585a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// UnwrapSimilarPointerTypes - If T1 and T2 are pointer types that 31595a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// may be similar (C++ 4.4), replaces T1 and T2 with the type that 31605a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// they point to and return true. If T1 and T2 aren't pointer types 31615a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// or pointer-to-member types, or if they are not similar at this 31625a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// level, returns false and leaves T1 and T2 unchanged. Top-level 31635a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// qualifiers on T1 and T2 are ignored. This function will typically 31645a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// be called in a loop that successively "unwraps" pointer and 31655a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// pointer-to-member types to compare them at each level. 31665a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregorbool ASTContext::UnwrapSimilarPointerTypes(QualType &T1, QualType &T2) { 31675a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor const PointerType *T1PtrType = T1->getAs<PointerType>(), 31685a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor *T2PtrType = T2->getAs<PointerType>(); 31695a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (T1PtrType && T2PtrType) { 31705a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T1 = T1PtrType->getPointeeType(); 31715a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T2 = T2PtrType->getPointeeType(); 31725a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return true; 31735a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 31745a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 31755a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor const MemberPointerType *T1MPType = T1->getAs<MemberPointerType>(), 31765a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor *T2MPType = T2->getAs<MemberPointerType>(); 31775a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (T1MPType && T2MPType && 31785a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0), 31795a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor QualType(T2MPType->getClass(), 0))) { 31805a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T1 = T1MPType->getPointeeType(); 31815a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T2 = T2MPType->getPointeeType(); 31825a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return true; 31835a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 31845a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 31855a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (getLangOptions().ObjC1) { 31865a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor const ObjCObjectPointerType *T1OPType = T1->getAs<ObjCObjectPointerType>(), 31875a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor *T2OPType = T2->getAs<ObjCObjectPointerType>(); 31885a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (T1OPType && T2OPType) { 31895a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T1 = T1OPType->getPointeeType(); 31905a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T2 = T2OPType->getPointeeType(); 31915a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return true; 31925a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 31935a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 31945a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 31955a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor // FIXME: Block pointers, too? 31965a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 31975a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return false; 31985a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor} 31995a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 32004ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadDeclarationNameInfo 32014ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getNameForTemplate(TemplateName Name, 32024ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad SourceLocation NameLoc) const { 3203146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall switch (Name.getKind()) { 3204146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::QualifiedTemplate: 3205146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::Template: 32062577743c5650c646fb705df01403707e94f2df04Abramo Bagnara // DNInfo work in progress: CHECKME: what about DNLoc? 3207146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo(Name.getAsTemplateDecl()->getDeclName(), 3208146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall NameLoc); 32092577743c5650c646fb705df01403707e94f2df04Abramo Bagnara 3210146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::OverloadedTemplate: { 3211146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall OverloadedTemplateStorage *Storage = Name.getAsOverloadedTemplate(); 3212146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall // DNInfo work in progress: CHECKME: what about DNLoc? 3213146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo((*Storage->begin())->getDeclName(), NameLoc); 3214146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3215146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3216146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::DependentTemplate: { 3217146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall DependentTemplateName *DTN = Name.getAsDependentTemplateName(); 32182577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DeclarationName DName; 321980ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall if (DTN->isIdentifier()) { 32202577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DName = DeclarationNames.getIdentifier(DTN->getIdentifier()); 32212577743c5650c646fb705df01403707e94f2df04Abramo Bagnara return DeclarationNameInfo(DName, NameLoc); 322280ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall } else { 32232577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DName = DeclarationNames.getCXXOperatorName(DTN->getOperator()); 32242577743c5650c646fb705df01403707e94f2df04Abramo Bagnara // DNInfo work in progress: FIXME: source locations? 32252577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DeclarationNameLoc DNLoc; 32262577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DNLoc.CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding(); 32272577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DNLoc.CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding(); 32282577743c5650c646fb705df01403707e94f2df04Abramo Bagnara return DeclarationNameInfo(DName, NameLoc, DNLoc); 322980ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall } 323080ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall } 323180ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall 3232146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParm: { 3233146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage *subst 3234146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParm(); 3235146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo(subst->getParameter()->getDeclName(), 3236146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall NameLoc); 3237146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3238146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3239146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParmPack: { 3240146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmPackStorage *subst 3241146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParmPack(); 3242146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo(subst->getParameterPack()->getDeclName(), 3243146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall NameLoc); 3244146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3245146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3246146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3247146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm_unreachable("bad template name kind!"); 324880ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall} 324980ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall 32504ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) const { 3251146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall switch (Name.getKind()) { 3252146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::QualifiedTemplate: 3253146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::Template: { 3254146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateDecl *Template = Name.getAsTemplateDecl(); 32553e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor if (TemplateTemplateParmDecl *TTP 3256146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = dyn_cast<TemplateTemplateParmDecl>(Template)) 32573e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor Template = getCanonicalTemplateTemplateParmDecl(TTP); 32583e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 32593e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // The canonical template name is the canonical template declaration. 326097fbaa2a38804268a024f1a104b43fcf8b4411b0Argyrios Kyrtzidis return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl())); 32613e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor } 326225a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor 3263146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::OverloadedTemplate: 3264146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm_unreachable("cannot canonicalize overloaded template"); 3265146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3266146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::DependentTemplate: { 3267146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall DependentTemplateName *DTN = Name.getAsDependentTemplateName(); 3268146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall assert(DTN && "Non-dependent template names must refer to template decls."); 3269146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DTN->CanonicalTemplateName; 3270146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3271146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3272146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParm: { 3273146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage *subst 3274146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParm(); 3275146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return getCanonicalTemplateName(subst->getReplacement()); 32761aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor } 32771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3278146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParmPack: { 3279146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmPackStorage *subst 3280146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParmPack(); 3281146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateTemplateParmDecl *canonParameter 3282146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = getCanonicalTemplateTemplateParmDecl(subst->getParameterPack()); 3283146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateArgument canonArgPack 3284146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = getCanonicalTemplateArgument(subst->getArgumentPack()); 3285146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return getSubstTemplateTemplateParmPack(canonParameter, canonArgPack); 3286146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3287146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3288146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3289146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm_unreachable("bad template name!"); 329025a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor} 329125a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor 3292db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregorbool ASTContext::hasSameTemplateName(TemplateName X, TemplateName Y) { 3293db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor X = getCanonicalTemplateName(X); 3294db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Y = getCanonicalTemplateName(Y); 3295db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return X.getAsVoidPointer() == Y.getAsVoidPointer(); 3296db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor} 3297db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor 32981eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpTemplateArgument 32994ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const { 33001275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor switch (Arg.getKind()) { 33011275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Null: 33021275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor return Arg; 33031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33041275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Expression: 33051275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor return Arg; 33061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33071275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Declaration: 3308833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall return TemplateArgument(Arg.getAsDecl()->getCanonicalDecl()); 33091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3310788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 3311788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate())); 3312a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 3313a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 3314a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return TemplateArgument(getCanonicalTemplateName( 3315a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Arg.getAsTemplateOrTemplatePattern()), 33162be29f423acad3bbe39099a78db2805acb5bdf17Douglas Gregor Arg.getNumTemplateExpansions()); 3317a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 33181275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Integral: 3319833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall return TemplateArgument(*Arg.getAsIntegral(), 33201275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor getCanonicalType(Arg.getIntegralType())); 33211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33221275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Type: 3323833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall return TemplateArgument(getCanonicalType(Arg.getAsType())); 33241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33251275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Pack: { 332687dd697dcc8ecb64df73ae64d61b8c80ff0c157cDouglas Gregor if (Arg.pack_size() == 0) 332787dd697dcc8ecb64df73ae64d61b8c80ff0c157cDouglas Gregor return Arg; 332887dd697dcc8ecb64df73ae64d61b8c80ff0c157cDouglas Gregor 3329910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgument *CanonArgs 3330910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor = new (*this) TemplateArgument[Arg.pack_size()]; 33311275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor unsigned Idx = 0; 33321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (TemplateArgument::pack_iterator A = Arg.pack_begin(), 33331275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor AEnd = Arg.pack_end(); 33341275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor A != AEnd; (void)++A, ++Idx) 33351275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor CanonArgs[Idx] = getCanonicalTemplateArgument(*A); 33361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3337910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor return TemplateArgument(CanonArgs, Arg.pack_size()); 33381275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor } 33391275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor } 33401275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor 33411275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // Silence GCC warning 3342b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unhandled template argument kind"); 33431275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor} 33441275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor 3345d57959af02b4af695276f4204443afe6e5d86bd8Douglas GregorNestedNameSpecifier * 33464ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const { 33471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (!NNS) 3348d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor return 0; 3349d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3350d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor switch (NNS->getKind()) { 3351d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::Identifier: 3352d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // Canonicalize the prefix but keep the identifier the same. 33531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return NestedNameSpecifier::Create(*this, 3354d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor getCanonicalNestedNameSpecifier(NNS->getPrefix()), 3355d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor NNS->getAsIdentifier()); 3356d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3357d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::Namespace: 3358d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // A namespace is canonical; build a nested-name-specifier with 3359d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // this namespace and no prefix. 336014aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor return NestedNameSpecifier::Create(*this, 0, 336114aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor NNS->getAsNamespace()->getOriginalNamespace()); 336214aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor 336314aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor case NestedNameSpecifier::NamespaceAlias: 336414aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor // A namespace is canonical; build a nested-name-specifier with 336514aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor // this namespace and no prefix. 336614aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor return NestedNameSpecifier::Create(*this, 0, 336714aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor NNS->getAsNamespaceAlias()->getNamespace() 336814aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor ->getOriginalNamespace()); 3369d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3370d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::TypeSpec: 3371d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::TypeSpecWithTemplate: { 3372d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor QualType T = getCanonicalType(QualType(NNS->getAsType(), 0)); 3373264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor 3374264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // If we have some kind of dependent-named type (e.g., "typename T::type"), 3375264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // break it apart into its prefix and identifier, then reconsititute those 3376264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // as the canonical nested-name-specifier. This is required to canonicalize 3377264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // a dependent nested-name-specifier involving typedefs of dependent-name 3378264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // types, e.g., 3379264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // typedef typename T::type T1; 3380264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // typedef typename T1::type T2; 3381264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor if (const DependentNameType *DNT = T->getAs<DependentNameType>()) { 3382264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor NestedNameSpecifier *Prefix 3383264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor = getCanonicalNestedNameSpecifier(DNT->getQualifier()); 3384264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor return NestedNameSpecifier::Create(*this, Prefix, 3385264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor const_cast<IdentifierInfo *>(DNT->getIdentifier())); 3386264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor } 3387264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor 3388643f84353b3b7bbf9b73bcbc7da0ef8a39a5ca99Douglas Gregor // Do the same thing as above, but with dependent-named specializations. 3389264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor if (const DependentTemplateSpecializationType *DTST 3390264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor = T->getAs<DependentTemplateSpecializationType>()) { 3391264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor NestedNameSpecifier *Prefix 3392264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor = getCanonicalNestedNameSpecifier(DTST->getQualifier()); 3393aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor 3394aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor T = getDependentTemplateSpecializationType(DTST->getKeyword(), 3395aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor Prefix, DTST->getIdentifier(), 3396aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor DTST->getNumArgs(), 3397aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor DTST->getArgs()); 3398264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor T = getCanonicalType(T); 3399264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor } 3400264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor 34013b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return NestedNameSpecifier::Create(*this, 0, false, 34023b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall const_cast<Type*>(T.getTypePtr())); 3403d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor } 3404d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3405d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::Global: 3406d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // The global specifier is canonical and unique. 3407d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor return NNS; 3408d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor } 3409d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3410d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // Required to silence a GCC warning 3411d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor return 0; 3412d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor} 3413d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3414c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 34154ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadconst ArrayType *ASTContext::getAsArrayType(QualType T) const { 3416c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Handle the non-qualified case efficiently. 3417a4923eb7c4b04d360cb2747641a5e92818edf804Douglas Gregor if (!T.hasLocalQualifiers()) { 3418c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Handle the common positive case fast. 3419c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const ArrayType *AT = dyn_cast<ArrayType>(T)) 3420c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return AT; 3421c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner } 34221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 34230953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Handle the common negative case fast. 34243b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!isa<ArrayType>(T.getCanonicalType())) 3425c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return 0; 34261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 34270953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Apply any qualifiers from the array type to the element type. This 3428c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // implements C99 6.7.3p8: "If the specification of an array type includes 3429c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // any type qualifiers, the element type is so qualified, not the array type." 34301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3431c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // If we get here, we either have type qualifiers on the type, or we have 3432c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // sugar such as a typedef in the way. If we have type qualifiers on the type 343350d62d1b4a98adbc83de8f8cd1379ea1c25656f7Douglas Gregor // we must propagate them down into the element type. 34340953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 34353b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType split = T.getSplitDesugaredType(); 34363b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Qualifiers qs = split.second; 34371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3438c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // If we have a simple case, just return now. 34393b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall const ArrayType *ATy = dyn_cast<ArrayType>(split.first); 34403b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (ATy == 0 || qs.empty()) 3441c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return ATy; 34421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3443c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Otherwise, we have an array and we have qualifiers on it. Push the 3444c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // qualifiers into the array element type and return a new array type. 34453b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType NewEltTy = getQualifiedType(ATy->getElementType(), qs); 34461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3447c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(ATy)) 3448c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(), 3449c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner CAT->getSizeModifier(), 34500953e767ff7817f97b3ab20896b229891eeff45bJohn McCall CAT->getIndexTypeCVRQualifiers())); 3451c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(ATy)) 3452c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return cast<ArrayType>(getIncompleteArrayType(NewEltTy, 3453c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner IAT->getSizeModifier(), 34540953e767ff7817f97b3ab20896b229891eeff45bJohn McCall IAT->getIndexTypeCVRQualifiers())); 3455898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 34561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const DependentSizedArrayType *DSAT 3457898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor = dyn_cast<DependentSizedArrayType>(ATy)) 3458898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return cast<ArrayType>( 34591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getDependentSizedArrayType(NewEltTy, 34603fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall DSAT->getSizeExpr(), 3461898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor DSAT->getSizeModifier(), 34620953e767ff7817f97b3ab20896b229891eeff45bJohn McCall DSAT->getIndexTypeCVRQualifiers(), 34637e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor DSAT->getBracketsRange())); 34641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3465c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner const VariableArrayType *VAT = cast<VariableArrayType>(ATy); 34667e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor return cast<ArrayType>(getVariableArrayType(NewEltTy, 34673fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall VAT->getSizeExpr(), 3468c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner VAT->getSizeModifier(), 34690953e767ff7817f97b3ab20896b229891eeff45bJohn McCall VAT->getIndexTypeCVRQualifiers(), 34707e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor VAT->getBracketsRange())); 347177c9647cae939104c6cb2b6a4dd8ca859d2e5770Chris Lattner} 347277c9647cae939104c6cb2b6a4dd8ca859d2e5770Chris Lattner 347379e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas GregorQualType ASTContext::getAdjustedParameterType(QualType T) { 347479e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // C99 6.7.5.3p7: 347579e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // A declaration of a parameter as "array of type" shall be 347679e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // adjusted to "qualified pointer to type", where the type 347779e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // qualifiers (if any) are those specified within the [ and ] of 347879e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // the array type derivation. 347979e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor if (T->isArrayType()) 348079e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return getArrayDecayedType(T); 348179e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 348279e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // C99 6.7.5.3p8: 348379e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // A declaration of a parameter as "function returning type" 348479e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // shall be adjusted to "pointer to function returning type", as 348579e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // in 6.3.2.1. 348679e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor if (T->isFunctionType()) 348779e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return getPointerType(T); 348879e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 348979e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return T; 349079e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor} 349179e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 349279e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas GregorQualType ASTContext::getSignatureParameterType(QualType T) { 349379e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor T = getVariableArrayDecayedType(T); 349479e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor T = getAdjustedParameterType(T); 349579e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return T.getUnqualifiedType(); 349679e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor} 349779e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 3498e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// getArrayDecayedType - Return the properly qualified result of decaying the 3499e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// specified array type to a pointer. This operation is non-trivial when 3500e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// handling typedefs etc. The canonical type of "T" must be an array type, 3501e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// this returns a pointer to a properly qualified element of the array. 3502e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// 3503e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// See C99 6.7.5.3p7 and C99 6.3.2.1p3. 35044ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getArrayDecayedType(QualType Ty) const { 3505c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Get the element type with 'getAsArrayType' so that we don't lose any 3506c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // typedefs in the element type of the array. This also handles propagation 3507c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // of type qualifiers from the array type into the element type if present 3508c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // (C99 6.7.3p8). 3509c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner const ArrayType *PrettyArrayType = getAsArrayType(Ty); 3510c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner assert(PrettyArrayType && "Not an array type!"); 35111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3512c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner QualType PtrTy = getPointerType(PrettyArrayType->getElementType()); 3513e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner 3514e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner // int x[restrict 4] -> int *restrict 35150953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return getQualifiedType(PtrTy, PrettyArrayType->getIndexTypeQualifiers()); 3516e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner} 3517e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner 35183b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getBaseElementType(const ArrayType *array) const { 35193b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return getBaseElementType(array->getElementType()); 35205e03f9ea8174ae588c5e69ec6b5ef4c68f8fd766Douglas Gregor} 35215e03f9ea8174ae588c5e69ec6b5ef4c68f8fd766Douglas Gregor 35223b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getBaseElementType(QualType type) const { 35233b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Qualifiers qs; 35243b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall while (true) { 35253b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType split = type.getSplitDesugaredType(); 35263b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall const ArrayType *array = split.first->getAsArrayTypeUnsafe(); 35273b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!array) break; 35281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 35293b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall type = array->getElementType(); 35303b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall qs.addConsistentQualifiers(split.second); 35313b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall } 35321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 35333b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return getQualifiedType(type, qs); 35346183a99b064b397d98297904fbd6cf00fe1f453dAnders Carlsson} 35356183a99b064b397d98297904fbd6cf00fe1f453dAnders Carlsson 35360de78998e7bda473b408437053e48661b510d453Fariborz Jahanian/// getConstantArrayElementCount - Returns number of constant array elements. 35371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpuint64_t 35380de78998e7bda473b408437053e48661b510d453Fariborz JahanianASTContext::getConstantArrayElementCount(const ConstantArrayType *CA) const { 35390de78998e7bda473b408437053e48661b510d453Fariborz Jahanian uint64_t ElementCount = 1; 35400de78998e7bda473b408437053e48661b510d453Fariborz Jahanian do { 35410de78998e7bda473b408437053e48661b510d453Fariborz Jahanian ElementCount *= CA->getSize().getZExtValue(); 35420de78998e7bda473b408437053e48661b510d453Fariborz Jahanian CA = dyn_cast<ConstantArrayType>(CA->getElementType()); 35430de78998e7bda473b408437053e48661b510d453Fariborz Jahanian } while (CA); 35440de78998e7bda473b408437053e48661b510d453Fariborz Jahanian return ElementCount; 35450de78998e7bda473b408437053e48661b510d453Fariborz Jahanian} 35460de78998e7bda473b408437053e48661b510d453Fariborz Jahanian 35475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getFloatingRank - Return a relative rank for floating point types. 35485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// This routine will assert if passed a built-in type that isn't a float. 3549a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattnerstatic FloatingRank getFloatingRank(QualType T) { 3550183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ComplexType *CT = T->getAs<ComplexType>()) 35515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return getFloatingRank(CT->getElementType()); 3552a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner 3553183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall assert(T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type"); 3554183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall switch (T->getAs<BuiltinType>()->getKind()) { 3555b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("getFloatingRank(): not a floating type"); 3556aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov case BuiltinType::Half: return HalfRank; 35575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Float: return FloatRank; 35585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Double: return DoubleRank; 35595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::LongDouble: return LongDoubleRank; 35605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 35615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 35625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 35631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getFloatingTypeOfSizeWithinDomain - Returns a real floating 35641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// point or a complex type (based on typeDomain/typeSize). 3565716c7304ff5d27a95e1e7823acd1d09d5ec3e37fSteve Naroff/// 'typeDomain' is a real floating point or complex type. 3566716c7304ff5d27a95e1e7823acd1d09d5ec3e37fSteve Naroff/// 'typeSize' is a real floating point or complex type. 35671361b11066239ea15764a2a844405352d87296b3Chris LattnerQualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size, 35681361b11066239ea15764a2a844405352d87296b3Chris Lattner QualType Domain) const { 35691361b11066239ea15764a2a844405352d87296b3Chris Lattner FloatingRank EltRank = getFloatingRank(Size); 35701361b11066239ea15764a2a844405352d87296b3Chris Lattner if (Domain->isComplexType()) { 35711361b11066239ea15764a2a844405352d87296b3Chris Lattner switch (EltRank) { 3572561d3abc881033776ece385a01a510e1cbc1fa92David Blaikie case HalfRank: llvm_unreachable("Complex half is not supported"); 3573f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff case FloatRank: return FloatComplexTy; 3574f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff case DoubleRank: return DoubleComplexTy; 3575f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff case LongDoubleRank: return LongDoubleComplexTy; 3576f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff } 3577f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff } 35781361b11066239ea15764a2a844405352d87296b3Chris Lattner 35791361b11066239ea15764a2a844405352d87296b3Chris Lattner assert(Domain->isRealFloatingType() && "Unknown domain!"); 35801361b11066239ea15764a2a844405352d87296b3Chris Lattner switch (EltRank) { 3581561d3abc881033776ece385a01a510e1cbc1fa92David Blaikie case HalfRank: llvm_unreachable("Half ranks are not valid here"); 35821361b11066239ea15764a2a844405352d87296b3Chris Lattner case FloatRank: return FloatTy; 35831361b11066239ea15764a2a844405352d87296b3Chris Lattner case DoubleRank: return DoubleTy; 35841361b11066239ea15764a2a844405352d87296b3Chris Lattner case LongDoubleRank: return LongDoubleTy; 35855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3586561d3abc881033776ece385a01a510e1cbc1fa92David Blaikie llvm_unreachable("getFloatingRank(): illegal value for rank"); 35875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 35885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 35897cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// getFloatingTypeOrder - Compare the rank of the two specified floating 35907cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// point types, ignoring the domain of the type (i.e. 'double' == 35917cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If 35921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// LHS < RHS, return -1. 35934ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadint ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) const { 3594a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner FloatingRank LHSR = getFloatingRank(LHS); 3595a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner FloatingRank RHSR = getFloatingRank(RHS); 35961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3597a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner if (LHSR == RHSR) 3598fb0d49669aa370b4c0993c5cee60275ef9fd6518Steve Naroff return 0; 3599a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner if (LHSR > RHSR) 3600fb0d49669aa370b4c0993c5cee60275ef9fd6518Steve Naroff return 1; 3601fb0d49669aa370b4c0993c5cee60275ef9fd6518Steve Naroff return -1; 36025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 36035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3604f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This 3605f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner/// routine will assert if passed a built-in type that isn't an integer or enum, 3606f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner/// or if it is not canonicalized. 3607f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCallunsigned ASTContext::getIntegerRank(const Type *T) const { 3608467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(T->isCanonicalUnqualified() && "T should be canonicalized"); 3609f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith 3610f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner switch (cast<BuiltinType>(T)->getKind()) { 3611b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("getIntegerRank(): not a built-in integer"); 36127cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Bool: 3613f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 1 + (getIntWidth(BoolTy) << 3); 36147cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Char_S: 36157cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Char_U: 36167cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::SChar: 36177cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::UChar: 3618f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 2 + (getIntWidth(CharTy) << 3); 36197cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Short: 36207cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::UShort: 3621f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 3 + (getIntWidth(ShortTy) << 3); 36227cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Int: 36237cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::UInt: 3624f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 4 + (getIntWidth(IntTy) << 3); 36257cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Long: 36267cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::ULong: 3627f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 5 + (getIntWidth(LongTy) << 3); 36287cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::LongLong: 36297cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::ULongLong: 3630f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 6 + (getIntWidth(LongLongTy) << 3); 36312df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::Int128: 36322df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::UInt128: 36332df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner return 7 + (getIntWidth(Int128Ty) << 3); 3634f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner } 3635f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner} 3636f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner 363704e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// \brief Whether this is a promotable bitfield reference according 363804e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// to C99 6.3.1.1p2, bullet 2 (and GCC extensions). 363904e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// 364004e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// \returns the type this bit-field will promote to, or NULL if no 364104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// promotion occurs. 36424ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::isPromotableBitField(Expr *E) const { 3643ceafbdeb93ecf323cca74e660bf54504c86f3b71Douglas Gregor if (E->isTypeDependent() || E->isValueDependent()) 3644ceafbdeb93ecf323cca74e660bf54504c86f3b71Douglas Gregor return QualType(); 3645ceafbdeb93ecf323cca74e660bf54504c86f3b71Douglas Gregor 364604e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman FieldDecl *Field = E->getBitField(); 364704e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman if (!Field) 364804e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return QualType(); 364904e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 365004e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman QualType FT = Field->getType(); 365104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 3652a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith uint64_t BitWidth = Field->getBitWidthValue(*this); 365304e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman uint64_t IntSize = getTypeSize(IntTy); 365404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // GCC extension compatibility: if the bit-field size is less than or equal 365504e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // to the size of int, it gets promoted no matter what its type is. 365604e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // For instance, unsigned long bf : 4 gets promoted to signed int. 365704e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman if (BitWidth < IntSize) 365804e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return IntTy; 365904e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 366004e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman if (BitWidth == IntSize) 366104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return FT->isSignedIntegerType() ? IntTy : UnsignedIntTy; 366204e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 366304e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // Types bigger than int are not subject to promotions, and therefore act 366404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // like the base type. 366504e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // FIXME: This doesn't quite match what gcc does, but what gcc does here 366604e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // is ridiculous. 366704e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return QualType(); 366804e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman} 366904e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 3670a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman/// getPromotedIntegerType - Returns the type that Promotable will 3671a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman/// promote to: C99 6.3.1.1p2, assuming that Promotable is a promotable 3672a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman/// integer type. 36734ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getPromotedIntegerType(QualType Promotable) const { 3674a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman assert(!Promotable.isNull()); 3675a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman assert(Promotable->isPromotableIntegerType()); 3676842aef8d942a880eeb9535d40de31a86838264cbJohn McCall if (const EnumType *ET = Promotable->getAs<EnumType>()) 3677842aef8d942a880eeb9535d40de31a86838264cbJohn McCall return ET->getDecl()->getPromotionType(); 367868a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman 367968a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman if (const BuiltinType *BT = Promotable->getAs<BuiltinType>()) { 368068a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // C++ [conv.prom]: A prvalue of type char16_t, char32_t, or wchar_t 368168a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // (3.9.1) can be converted to a prvalue of the first of the following 368268a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // types that can represent all the values of its underlying type: 368368a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // int, unsigned int, long int, unsigned long int, long long int, or 368468a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // unsigned long long int [...] 368568a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // FIXME: Is there some better way to compute this? 368668a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman if (BT->getKind() == BuiltinType::WChar_S || 368768a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman BT->getKind() == BuiltinType::WChar_U || 368868a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman BT->getKind() == BuiltinType::Char16 || 368968a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman BT->getKind() == BuiltinType::Char32) { 369068a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman bool FromIsSigned = BT->getKind() == BuiltinType::WChar_S; 369168a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman uint64_t FromSize = getTypeSize(BT); 369268a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman QualType PromoteTypes[] = { IntTy, UnsignedIntTy, LongTy, UnsignedLongTy, 369368a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman LongLongTy, UnsignedLongLongTy }; 369468a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman for (size_t Idx = 0; Idx < llvm::array_lengthof(PromoteTypes); ++Idx) { 369568a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman uint64_t ToSize = getTypeSize(PromoteTypes[Idx]); 369668a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman if (FromSize < ToSize || 369768a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman (FromSize == ToSize && 369868a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) 369968a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman return PromoteTypes[Idx]; 370068a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman } 370168a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman llvm_unreachable("char type should fit into long long"); 370268a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman } 370368a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman } 370468a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman 370568a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // At this point, we should have a signed or unsigned integer type. 3706a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman if (Promotable->isSignedIntegerType()) 3707a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman return IntTy; 3708a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman uint64_t PromotableSize = getTypeSize(Promotable); 3709a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman uint64_t IntSize = getTypeSize(IntTy); 3710a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman assert(Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize); 3711a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman return (PromotableSize != IntSize) ? IntTy : UnsignedIntTy; 3712a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman} 3713a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman 371431862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis/// \brief Recurses in pointer/array types until it finds an objc retainable 371531862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis/// type and returns its ownership. 371631862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios KyrtzidisQualifiers::ObjCLifetime ASTContext::getInnerObjCOwnership(QualType T) const { 371731862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis while (!T.isNull()) { 371831862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis if (T.getObjCLifetime() != Qualifiers::OCL_None) 371931862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis return T.getObjCLifetime(); 372031862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis if (T->isArrayType()) 372131862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis T = getBaseElementType(T); 372231862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis else if (const PointerType *PT = T->getAs<PointerType>()) 372331862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis T = PT->getPointeeType(); 372431862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis else if (const ReferenceType *RT = T->getAs<ReferenceType>()) 372528445f0b62f6aed851ff87ce64d9b19200d3211fArgyrios Kyrtzidis T = RT->getPointeeType(); 372631862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis else 372731862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis break; 372831862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis } 372931862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis 373031862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis return Qualifiers::OCL_None; 373131862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis} 373231862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis 37331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getIntegerTypeOrder - Returns the highest ranked integer type: 37347cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If 37351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// LHS < RHS, return -1. 37364ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadint ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) const { 3737f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall const Type *LHSC = getCanonicalType(LHS).getTypePtr(); 3738f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall const Type *RHSC = getCanonicalType(RHS).getTypePtr(); 37397cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSC == RHSC) return 0; 37401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3741f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner bool LHSUnsigned = LHSC->isUnsignedIntegerType(); 3742f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner bool RHSUnsigned = RHSC->isUnsignedIntegerType(); 37431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37447cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner unsigned LHSRank = getIntegerRank(LHSC); 37457cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner unsigned RHSRank = getIntegerRank(RHSC); 37461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37477cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned. 37487cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSRank == RHSRank) return 0; 37497cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return LHSRank > RHSRank ? 1 : -1; 37507cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner } 37511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37527cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // Otherwise, the LHS is signed and the RHS is unsigned or visa versa. 37537cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSUnsigned) { 37547cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the unsigned [LHS] type is larger, return it. 37557cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSRank >= RHSRank) 37567cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return 1; 37571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37587cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the signed type can represent all values of the unsigned type, it 37597cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // wins. Because we are dealing with 2's complement and types that are 37601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // powers of two larger than each other, this is always safe. 37617cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return -1; 37627cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner } 37637cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner 37647cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the unsigned [RHS] type is larger, return it. 37657cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (RHSRank >= LHSRank) 37667cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return -1; 37671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37687cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the signed type can represent all values of the unsigned type, it 37697cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // wins. Because we are dealing with 2's complement and types that are 37701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // powers of two larger than each other, this is always safe. 37717cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return 1; 37725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 377371993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson 377479cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlssonstatic RecordDecl * 3775ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo BagnaraCreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK, 3776ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara DeclContext *DC, IdentifierInfo *Id) { 3777ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara SourceLocation Loc; 377879cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson if (Ctx.getLangOptions().CPlusPlus) 3779ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 378079cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson else 3781ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 378279cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson} 3783ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara 37841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump// getCFConstantStringType - Return the type used for constant CFStrings. 37854ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getCFConstantStringType() const { 378671993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson if (!CFConstantStringTypeDecl) { 37871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump CFConstantStringTypeDecl = 3788ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara CreateRecordDecl(*this, TTK_Struct, TUDecl, 378979cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson &Idents.get("NSConstantString")); 37905cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall CFConstantStringTypeDecl->startDefinition(); 379179cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson 3792f06273f8bbacb086a46bde456429c8d08f6d07eeAnders Carlsson QualType FieldTypes[4]; 37931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 379471993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson // const int *isa; 37950953e767ff7817f97b3ab20896b229891eeff45bJohn McCall FieldTypes[0] = getPointerType(IntTy.withConst()); 3796f06273f8bbacb086a46bde456429c8d08f6d07eeAnders Carlsson // int flags; 3797f06273f8bbacb086a46bde456429c8d08f6d07eeAnders Carlsson FieldTypes[1] = IntTy; 379871993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson // const char *str; 37990953e767ff7817f97b3ab20896b229891eeff45bJohn McCall FieldTypes[2] = getPointerType(CharTy.withConst()); 380071993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson // long length; 38011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump FieldTypes[3] = LongTy; 38021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 380344b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor // Create fields 380444b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor for (unsigned i = 0; i < 4; ++i) { 38051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump FieldDecl *Field = FieldDecl::Create(*this, CFConstantStringTypeDecl, 3806ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara SourceLocation(), 380744b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor SourceLocation(), 0, 3808a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 38091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump /*BitWidth=*/0, 38107a614d8380297fcd2bc23986241905d97222948cRichard Smith /*Mutable=*/false, 38117a614d8380297fcd2bc23986241905d97222948cRichard Smith /*HasInit=*/false); 38122888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 381317945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis CFConstantStringTypeDecl->addDecl(Field); 381444b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor } 381544b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor 3816838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor CFConstantStringTypeDecl->completeDefinition(); 381771993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson } 38181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 381971993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson return getTagDeclType(CFConstantStringTypeDecl); 38208467583c2704e7a9691ea56939a029015f0ade0aGabor Greif} 3821b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson 3822319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregorvoid ASTContext::setCFConstantStringType(QualType T) { 38236217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek const RecordType *Rec = T->getAs<RecordType>(); 3824319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor assert(Rec && "Invalid CFConstantStringType"); 3825319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor CFConstantStringTypeDecl = Rec->getDecl(); 3826319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor} 3827319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor 38284ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getBlockDescriptorType() const { 3829adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump if (BlockDescriptorType) 3830adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump return getTagDeclType(BlockDescriptorType); 3831adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3832adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump RecordDecl *T; 3833adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump // FIXME: Needs the FlagAppleBlock bit. 3834ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara T = CreateRecordDecl(*this, TTK_Struct, TUDecl, 383579cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson &Idents.get("__block_descriptor")); 38365cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall T->startDefinition(); 3837adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3838adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump QualType FieldTypes[] = { 3839adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump UnsignedLongTy, 3840adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump UnsignedLongTy, 3841adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump }; 3842adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3843adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump const char *FieldNames[] = { 3844adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump "reserved", 3845083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "Size" 3846adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump }; 3847adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3848adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump for (size_t i = 0; i < 2; ++i) { 3849ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 3850adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump SourceLocation(), 3851adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump &Idents.get(FieldNames[i]), 3852a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 3853adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump /*BitWidth=*/0, 38547a614d8380297fcd2bc23986241905d97222948cRichard Smith /*Mutable=*/false, 38557a614d8380297fcd2bc23986241905d97222948cRichard Smith /*HasInit=*/false); 38562888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 3857adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump T->addDecl(Field); 3858adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump } 3859adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3860838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor T->completeDefinition(); 3861adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3862adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump BlockDescriptorType = T; 3863adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3864adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump return getTagDeclType(BlockDescriptorType); 3865adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump} 3866adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 38674ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getBlockDescriptorExtendedType() const { 3868083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump if (BlockDescriptorExtendedType) 3869083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump return getTagDeclType(BlockDescriptorExtendedType); 3870083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3871083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump RecordDecl *T; 3872083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump // FIXME: Needs the FlagAppleBlock bit. 3873ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara T = CreateRecordDecl(*this, TTK_Struct, TUDecl, 387479cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson &Idents.get("__block_descriptor_withcopydispose")); 38755cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall T->startDefinition(); 3876083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3877083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump QualType FieldTypes[] = { 3878083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump UnsignedLongTy, 3879083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump UnsignedLongTy, 3880083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump getPointerType(VoidPtrTy), 3881083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump getPointerType(VoidPtrTy) 3882083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump }; 3883083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3884083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump const char *FieldNames[] = { 3885083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "reserved", 3886083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "Size", 3887083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "CopyFuncPtr", 3888083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "DestroyFuncPtr" 3889083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump }; 3890083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3891083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump for (size_t i = 0; i < 4; ++i) { 3892ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 3893083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump SourceLocation(), 3894083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump &Idents.get(FieldNames[i]), 3895a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 3896083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump /*BitWidth=*/0, 38977a614d8380297fcd2bc23986241905d97222948cRichard Smith /*Mutable=*/false, 38987a614d8380297fcd2bc23986241905d97222948cRichard Smith /*HasInit=*/false); 38992888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 3900083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump T->addDecl(Field); 3901083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump } 3902083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3903838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor T->completeDefinition(); 3904083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3905083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump BlockDescriptorExtendedType = T; 3906083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3907083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump return getTagDeclType(BlockDescriptorExtendedType); 3908083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump} 3909083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 39104ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadbool ASTContext::BlockRequiresCopying(QualType Ty) const { 3911f85e193739c953358c865005855253af4f68a497John McCall if (Ty->isObjCRetainableType()) 3912af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump return true; 3913e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian if (getLangOptions().CPlusPlus) { 3914e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian if (const RecordType *RT = Ty->getAs<RecordType>()) { 3915e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 3916ffe37fdda5b4b4f162a45155c30d9f60ce110c12Sean Hunt return RD->hasConstCopyConstructor(); 3917e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian 3918e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian } 3919e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian } 3920af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump return false; 3921af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump} 3922af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 39234ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 39245f9e272e632e951b1efe824cd16acb4d96077930Chris LattnerASTContext::BuildByRefType(StringRef DeclName, QualType Ty) const { 3925af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // type = struct __Block_byref_1_X { 3926ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // void *__isa; 3927af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // struct __Block_byref_1_X *__forwarding; 3928ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // unsigned int __flags; 3929ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // unsigned int __size; 3930a7e6845660f91ec611427e1db842780e1ec12bdbEli Friedman // void *__copy_helper; // as needed 3931a7e6845660f91ec611427e1db842780e1ec12bdbEli Friedman // void *__destroy_help // as needed 3932af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // int X; 3933ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // } * 3934ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump 3935af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump bool HasCopyAndDispose = BlockRequiresCopying(Ty); 3936af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3937af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // FIXME: Move up 3938f5942a44880be26878592eb052b737579349411eBenjamin Kramer llvm::SmallString<36> Name; 3939f5942a44880be26878592eb052b737579349411eBenjamin Kramer llvm::raw_svector_ostream(Name) << "__Block_byref_" << 3940f5942a44880be26878592eb052b737579349411eBenjamin Kramer ++UniqueBlockByRefTypeID << '_' << DeclName; 3941af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump RecordDecl *T; 3942ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara T = CreateRecordDecl(*this, TTK_Struct, TUDecl, &Idents.get(Name.str())); 3943af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump T->startDefinition(); 3944af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump QualType Int32Ty = IntTy; 3945af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump assert(getIntWidth(IntTy) == 32 && "non-32bit int not supported"); 3946af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump QualType FieldTypes[] = { 3947af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(VoidPtrTy), 3948af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(getTagDeclType(T)), 3949af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump Int32Ty, 3950af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump Int32Ty, 3951af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(VoidPtrTy), 3952af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(VoidPtrTy), 3953af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump Ty 3954af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump }; 3955af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 39565f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner StringRef FieldNames[] = { 3957af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__isa", 3958af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__forwarding", 3959af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__flags", 3960af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__size", 3961af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__copy_helper", 3962af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__destroy_helper", 3963af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump DeclName, 3964af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump }; 3965af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3966af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump for (size_t i = 0; i < 7; ++i) { 3967af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump if (!HasCopyAndDispose && i >=4 && i <= 5) 3968af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump continue; 3969af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 3970ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara SourceLocation(), 3971af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump &Idents.get(FieldNames[i]), 3972a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 39737a614d8380297fcd2bc23986241905d97222948cRichard Smith /*BitWidth=*/0, /*Mutable=*/false, 39747a614d8380297fcd2bc23986241905d97222948cRichard Smith /*HasInit=*/false); 39752888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 3976af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump T->addDecl(Field); 3977af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump } 3978af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3979838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor T->completeDefinition(); 3980af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3981af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump return getPointerType(getTagDeclType(T)); 3982ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump} 3983ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump 3984e97179c675b341927807c718be215c8d1aab8acbDouglas GregorTypedefDecl *ASTContext::getObjCInstanceTypeDecl() { 3985e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor if (!ObjCInstanceTypeDecl) 3986e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor ObjCInstanceTypeDecl = TypedefDecl::Create(*this, 3987e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor getTranslationUnitDecl(), 3988e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor SourceLocation(), 3989e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor SourceLocation(), 3990e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor &Idents.get("instancetype"), 3991e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor getTrivialTypeSourceInfo(getObjCIdType())); 3992e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor return ObjCInstanceTypeDecl; 3993e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor} 3994e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor 3995e8c49533521c40643653f943d47229e62d277f88Anders Carlsson// This returns true if a type has been typedefed to BOOL: 3996e8c49533521c40643653f943d47229e62d277f88Anders Carlsson// typedef <type> BOOL; 39972d99833e8c956775f2183601cd120b65b569c867Chris Lattnerstatic bool isTypeTypedefedAsBOOL(QualType T) { 3998e8c49533521c40643653f943d47229e62d277f88Anders Carlsson if (const TypedefType *TT = dyn_cast<TypedefType>(T)) 3999bb49c3ee5d270485f4b273691fd14bc97403fa5dChris Lattner if (IdentifierInfo *II = TT->getDecl()->getIdentifier()) 4000bb49c3ee5d270485f4b273691fd14bc97403fa5dChris Lattner return II->isStr("BOOL"); 40011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 400285f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson return false; 400385f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson} 400485f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson 4005a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek/// getObjCEncodingTypeSize returns size of type for objective-c encoding 400633e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian/// purpose. 40074ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getObjCEncodingTypeSize(QualType type) const { 4008f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor if (!type->isIncompleteArrayType() && type->isIncompleteType()) 4009f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return CharUnits::Zero(); 4010f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4011199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits sz = getTypeSizeInChars(type); 40121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 401333e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Make all integer and enum types at least as large as an int 40142ade35e2cfd554e49d35a52047cea98a82787af9Douglas Gregor if (sz.isPositive() && type->isIntegralOrEnumerationType()) 4015199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck sz = std::max(sz, getTypeSizeInChars(IntTy)); 401633e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Treat arrays as pointers, since that's how they're passed in. 401733e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian else if (type->isArrayType()) 4018199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck sz = getTypeSizeInChars(VoidPtrTy); 4019aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck return sz; 4020199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck} 4021199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck 4022199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyckstatic inline 4023199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyckstd::string charUnitsToString(const CharUnits &CU) { 4024199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck return llvm::itostr(CU.getQuantity()); 402533e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian} 402633e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian 40276b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall/// getObjCEncodingForBlock - Return the encoded type for this block 40285e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall/// declaration. 40296b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCallstd::string ASTContext::getObjCEncodingForBlock(const BlockExpr *Expr) const { 40306b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall std::string S; 40316b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall 40325e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall const BlockDecl *Decl = Expr->getBlockDecl(); 40335e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall QualType BlockTy = 40345e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall Expr->getType()->getAs<BlockPointerType>()->getPointeeType(); 40355e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Encode result type. 4036c71a4915ca216847599d03cab4ed1c5086b0eb43John McCall getObjCEncodingForType(BlockTy->getAs<FunctionType>()->getResultType(), S); 40375e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Compute size of all parameters. 40385e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Start with computing size of a pointer in number of bytes. 40395e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // FIXME: There might(should) be a better way of doing this computation! 40405e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall SourceLocation Loc; 4041199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy); 4042199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits ParmOffset = PtrSize; 40436f46c2653c1545cc3fef0c0df996d18160160ce8Fariborz Jahanian for (BlockDecl::param_const_iterator PI = Decl->param_begin(), 40445e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall E = Decl->param_end(); PI != E; ++PI) { 40455e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall QualType PType = (*PI)->getType(); 4046aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck CharUnits sz = getObjCEncodingTypeSize(PType); 4047199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck assert (sz.isPositive() && "BlockExpr - Incomplete param type"); 40485e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall ParmOffset += sz; 40495e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall } 40505e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Size of the argument frame 4051199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 40525e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Block pointer and offset. 40535e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall S += "@?0"; 40545e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall 40555e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Argument types. 40565e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall ParmOffset = PtrSize; 40575e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall for (BlockDecl::param_const_iterator PI = Decl->param_begin(), E = 40585e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall Decl->param_end(); PI != E; ++PI) { 40595e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall ParmVarDecl *PVDecl = *PI; 40605e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall QualType PType = PVDecl->getOriginalType(); 40615e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall if (const ArrayType *AT = 40625e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 40635e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Use array's original type only if it has known number of 40645389f48b24937ad7b4093307128b3cbf25235654David Chisnall // elements. 40655389f48b24937ad7b4093307128b3cbf25235654David Chisnall if (!isa<ConstantArrayType>(AT)) 40665389f48b24937ad7b4093307128b3cbf25235654David Chisnall PType = PVDecl->getType(); 40675389f48b24937ad7b4093307128b3cbf25235654David Chisnall } else if (PType->isFunctionType()) 40685389f48b24937ad7b4093307128b3cbf25235654David Chisnall PType = PVDecl->getType(); 40695389f48b24937ad7b4093307128b3cbf25235654David Chisnall getObjCEncodingForType(PType, S); 40705389f48b24937ad7b4093307128b3cbf25235654David Chisnall S += charUnitsToString(ParmOffset); 40715389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmOffset += getObjCEncodingTypeSize(PType); 40725389f48b24937ad7b4093307128b3cbf25235654David Chisnall } 40736b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall 40746b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall return S; 40755389f48b24937ad7b4093307128b3cbf25235654David Chisnall} 40765389f48b24937ad7b4093307128b3cbf25235654David Chisnall 4077f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregorbool ASTContext::getObjCEncodingForFunctionDecl(const FunctionDecl *Decl, 40785389f48b24937ad7b4093307128b3cbf25235654David Chisnall std::string& S) { 40795389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Encode result type. 40805389f48b24937ad7b4093307128b3cbf25235654David Chisnall getObjCEncodingForType(Decl->getResultType(), S); 40815389f48b24937ad7b4093307128b3cbf25235654David Chisnall CharUnits ParmOffset; 40825389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Compute size of all parameters. 40835389f48b24937ad7b4093307128b3cbf25235654David Chisnall for (FunctionDecl::param_const_iterator PI = Decl->param_begin(), 40845389f48b24937ad7b4093307128b3cbf25235654David Chisnall E = Decl->param_end(); PI != E; ++PI) { 40855389f48b24937ad7b4093307128b3cbf25235654David Chisnall QualType PType = (*PI)->getType(); 40865389f48b24937ad7b4093307128b3cbf25235654David Chisnall CharUnits sz = getObjCEncodingTypeSize(PType); 4087f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor if (sz.isZero()) 4088f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return true; 4089f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 40905389f48b24937ad7b4093307128b3cbf25235654David Chisnall assert (sz.isPositive() && 4091f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor "getObjCEncodingForFunctionDecl - Incomplete param type"); 40925389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmOffset += sz; 40935389f48b24937ad7b4093307128b3cbf25235654David Chisnall } 40945389f48b24937ad7b4093307128b3cbf25235654David Chisnall S += charUnitsToString(ParmOffset); 40955389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmOffset = CharUnits::Zero(); 40965389f48b24937ad7b4093307128b3cbf25235654David Chisnall 40975389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Argument types. 40985389f48b24937ad7b4093307128b3cbf25235654David Chisnall for (FunctionDecl::param_const_iterator PI = Decl->param_begin(), 40995389f48b24937ad7b4093307128b3cbf25235654David Chisnall E = Decl->param_end(); PI != E; ++PI) { 41005389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmVarDecl *PVDecl = *PI; 41015389f48b24937ad7b4093307128b3cbf25235654David Chisnall QualType PType = PVDecl->getOriginalType(); 41025389f48b24937ad7b4093307128b3cbf25235654David Chisnall if (const ArrayType *AT = 41035389f48b24937ad7b4093307128b3cbf25235654David Chisnall dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 41045389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Use array's original type only if it has known number of 41055e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // elements. 41065e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall if (!isa<ConstantArrayType>(AT)) 41075e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall PType = PVDecl->getType(); 41085e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall } else if (PType->isFunctionType()) 41095e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall PType = PVDecl->getType(); 41105e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall getObjCEncodingForType(PType, S); 4111199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 4112aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck ParmOffset += getObjCEncodingTypeSize(PType); 41135e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall } 4114f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4115f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return false; 41165e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall} 41175e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall 4118dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson/// getObjCEncodingForMethodParameter - Return the encoded type for a single 4119dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson/// method parameter or return type. If Extended, include class names and 4120dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson/// block object types. 4121dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilsonvoid ASTContext::getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT, 4122dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson QualType T, std::string& S, 4123dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool Extended) const { 4124dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Encode type qualifer, 'in', 'inout', etc. for the parameter. 4125dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeQualifier(QT, S); 4126dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Encode parameter type. 4127dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeImpl(T, S, true, true, 0, 4128dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson true /*OutermostType*/, 4129dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /*EncodingProperty*/, 4130dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /*StructField*/, 4131dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson Extended /*EncodeBlockParameters*/, 4132dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson Extended /*EncodeClassNames*/); 4133dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson} 4134dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson 4135a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek/// getObjCEncodingForMethodDecl - Return the encoded type for this method 413633e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian/// declaration. 4137f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregorbool ASTContext::getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl, 4138dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson std::string& S, 4139dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool Extended) const { 4140c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: This is not very efficient. 4141dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Encode return type. 4142dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForMethodParameter(Decl->getObjCDeclQualifier(), 4143dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson Decl->getResultType(), S, Extended); 414433e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Compute size of all parameters. 414533e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Start with computing size of a pointer in number of bytes. 414633e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // FIXME: There might(should) be a better way of doing this computation! 414733e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian SourceLocation Loc; 4148199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy); 414933e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // The first two arguments (self and _cmd) are pointers; account for 415033e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // their size. 4151199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits ParmOffset = 2 * PtrSize; 4152491306a83c4f0f49f95a3bcbca8580cb98a91c7aArgyrios Kyrtzidis for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(), 41537732cc9c0fdc97a2f8cce4e5933d8103213d1aefFariborz Jahanian E = Decl->sel_param_end(); PI != E; ++PI) { 415489951a86b594513c2a013532ed45d197413b1087Chris Lattner QualType PType = (*PI)->getType(); 4155aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck CharUnits sz = getObjCEncodingTypeSize(PType); 4156f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor if (sz.isZero()) 4157f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return true; 4158f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4159199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck assert (sz.isPositive() && 4160199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck "getObjCEncodingForMethodDecl - Incomplete param type"); 416133e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian ParmOffset += sz; 416233e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian } 4163199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 416433e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian S += "@0:"; 4165199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(PtrSize); 41661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 416733e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Argument types. 416833e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian ParmOffset = 2 * PtrSize; 4169491306a83c4f0f49f95a3bcbca8580cb98a91c7aArgyrios Kyrtzidis for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(), 41707732cc9c0fdc97a2f8cce4e5933d8103213d1aefFariborz Jahanian E = Decl->sel_param_end(); PI != E; ++PI) { 4171491306a83c4f0f49f95a3bcbca8580cb98a91c7aArgyrios Kyrtzidis const ParmVarDecl *PVDecl = *PI; 41721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType PType = PVDecl->getOriginalType(); 41734306d3cb9116605728252e2738df24b9f6ab53c3Fariborz Jahanian if (const ArrayType *AT = 4174ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 4175ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff // Use array's original type only if it has known number of 4176ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff // elements. 4177bb3fde337fb712c0e6da8790d431621be4793048Steve Naroff if (!isa<ConstantArrayType>(AT)) 4178ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff PType = PVDecl->getType(); 4179ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff } else if (PType->isFunctionType()) 4180ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff PType = PVDecl->getType(); 4181dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForMethodParameter(PVDecl->getObjCDeclQualifier(), 4182dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson PType, S, Extended); 4183199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 4184aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck ParmOffset += getObjCEncodingTypeSize(PType); 418533e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian } 4186f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4187f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return false; 418833e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian} 418933e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian 4190c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar/// getObjCEncodingForPropertyDecl - Return the encoded type for this 419183bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// property declaration. If non-NULL, Container must be either an 4192c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar/// ObjCCategoryImplDecl or ObjCImplementationDecl; it should only be 4193c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar/// NULL when getting encodings for protocol properties. 41941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// Property attributes are stored as a comma-delimited C string. The simple 41951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// attributes readonly and bycopy are encoded as single characters. The 41961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// parametrized attributes, getter=name, setter=name, and ivar=name, are 41971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// encoded as single characters, followed by an identifier. Property types 41981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// are also encoded as a parametrized attribute. The characters used to encode 419983bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// these attributes are defined by the following enumeration: 420083bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// @code 420183bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// enum PropertyAttributes { 420283bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyReadOnly = 'R', // property is read-only. 420383bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyBycopy = 'C', // property is a copy of the value last assigned 420483bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyByref = '&', // property is a reference to the value last assigned 420583bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyDynamic = 'D', // property is dynamic 420683bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyGetter = 'G', // followed by getter selector name 420783bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertySetter = 'S', // followed by setter selector name 420883bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyInstanceVariable = 'V' // followed by instance variable name 420983bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyType = 't' // followed by old-style type encoding. 421083bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyWeak = 'W' // 'weak' property 421183bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyStrong = 'P' // property GC'able 421283bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyNonAtomic = 'N' // property non-atomic 421383bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// }; 421483bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// @endcode 42151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid ASTContext::getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD, 4216c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar const Decl *Container, 42174ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad std::string& S) const { 4218c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // Collect information from the property implementation decl(s). 4219c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar bool Dynamic = false; 4220c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar ObjCPropertyImplDecl *SynthesizePID = 0; 4221c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4222c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: Duplicated code due to poor abstraction. 4223c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (Container) { 42241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const ObjCCategoryImplDecl *CID = 4225c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar dyn_cast<ObjCCategoryImplDecl>(Container)) { 4226c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar for (ObjCCategoryImplDecl::propimpl_iterator 422717945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis i = CID->propimpl_begin(), e = CID->propimpl_end(); 4228653f1b1bf293a9bd96fd4dd6372e779cc7af1597Douglas Gregor i != e; ++i) { 4229c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar ObjCPropertyImplDecl *PID = *i; 4230c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyDecl() == PD) { 4231c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) { 4232c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar Dynamic = true; 4233c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 4234c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar SynthesizePID = PID; 4235c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4236c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4237c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4238c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 423961710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner const ObjCImplementationDecl *OID=cast<ObjCImplementationDecl>(Container); 4240c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar for (ObjCCategoryImplDecl::propimpl_iterator 424117945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis i = OID->propimpl_begin(), e = OID->propimpl_end(); 4242653f1b1bf293a9bd96fd4dd6372e779cc7af1597Douglas Gregor i != e; ++i) { 4243c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar ObjCPropertyImplDecl *PID = *i; 4244c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyDecl() == PD) { 4245c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) { 4246c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar Dynamic = true; 4247c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 4248c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar SynthesizePID = PID; 4249c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4250c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 42511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 4252c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4253c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4254c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4255c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: This is not very efficient. 4256c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S = "T"; 4257c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4258c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // Encode result type. 4259090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian // GCC has some special rules regarding encoding of properties which 4260090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian // closely resembles encoding of ivars. 42611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(PD->getType(), S, true, true, 0, 4262090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian true /* outermost type */, 4263090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian true /* encoding for property */); 4264c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4265c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PD->isReadOnly()) { 4266c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",R"; 4267c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 4268c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar switch (PD->getSetterKind()) { 4269c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case ObjCPropertyDecl::Assign: break; 4270c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case ObjCPropertyDecl::Copy: S += ",C"; break; 42711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case ObjCPropertyDecl::Retain: S += ",&"; break; 42723a02b44e3948f7762dbfba94b7961281ca29d022Fariborz Jahanian case ObjCPropertyDecl::Weak: S += ",W"; break; 4273c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4274c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4275c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4276c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // It really isn't clear at all what this means, since properties 4277c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // are "dynamic by default". 4278c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (Dynamic) 4279c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",D"; 4280c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4281090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic) 4282090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian S += ",N"; 42831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4284c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) { 4285c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",G"; 4286077bf5e2f48acfa9e7d69429b6e4ba86ea14896dChris Lattner S += PD->getGetterName().getAsString(); 4287c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4288c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4289c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) { 4290c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",S"; 4291077bf5e2f48acfa9e7d69429b6e4ba86ea14896dChris Lattner S += PD->getSetterName().getAsString(); 4292c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4293c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4294c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (SynthesizePID) { 4295c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar const ObjCIvarDecl *OID = SynthesizePID->getPropertyIvarDecl(); 4296c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",V"; 429739f34e97d6a468f0a7dfa5664c61217cffc65b74Chris Lattner S += OID->getNameAsString(); 4298c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4299c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4300c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: OBJCGC: weak & strong 4301c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar} 4302c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4303a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian/// getLegacyIntegralTypeEncoding - 43041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// Another legacy compatibility encoding: 32-bit longs are encoded as 43051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// 'l' or 'L' , but not always. For typedefs, we need to use 4306a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian/// 'i' or 'I' instead if encoding a struct field, or a pointer! 4307a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian/// 4308a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanianvoid ASTContext::getLegacyIntegralTypeEncoding (QualType &PointeeTy) const { 43098e1fab243ab8023b7ee3899745386b3b3a4258f8Mike Stump if (isa<TypedefType>(PointeeTy.getTypePtr())) { 4310183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const BuiltinType *BT = PointeeTy->getAs<BuiltinType>()) { 43114ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (BT->getKind() == BuiltinType::ULong && getIntWidth(PointeeTy) == 32) 4312a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian PointeeTy = UnsignedIntTy; 43131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump else 43144ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (BT->getKind() == BuiltinType::Long && getIntWidth(PointeeTy) == 32) 4315a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian PointeeTy = IntTy; 4316a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4317a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4318a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian} 4319a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian 43207d6b46d9a9d75dea8ef9f6973dd50633c1f37963Fariborz Jahanianvoid ASTContext::getObjCEncodingForType(QualType T, std::string& S, 43214ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const FieldDecl *Field) const { 432282a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // We follow the behavior of gcc, expanding structures which are 432382a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // directly pointed to, and expanding embedded structures. Note that 432482a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // these rules are sufficient to prevent recursive encoding of the 432582a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // same type. 43261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(T, S, true, true, Field, 43275b8c7d9fb620ba3a71e996d61e7b9bdf763b5c09Fariborz Jahanian true /* outermost type */); 432882a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar} 432982a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar 433064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnallstatic char ObjCEncodingForPrimitiveKind(const ASTContext *C, QualType T) { 433164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall switch (T->getAs<BuiltinType>()->getKind()) { 4332b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Unhandled builtin type kind"); 433364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Void: return 'v'; 433464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Bool: return 'B'; 433564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Char_U: 433664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UChar: return 'C'; 433764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UShort: return 'S'; 433864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UInt: return 'I'; 433964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::ULong: 43404ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad return C->getIntWidth(T) == 32 ? 'L' : 'Q'; 434164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UInt128: return 'T'; 434264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::ULongLong: return 'Q'; 434364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Char_S: 434464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::SChar: return 'c'; 434564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Short: return 's'; 43463f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_S: 43473f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_U: 434864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Int: return 'i'; 434964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Long: 43504ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad return C->getIntWidth(T) == 32 ? 'l' : 'q'; 435164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::LongLong: return 'q'; 435264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Int128: return 't'; 435364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Float: return 'f'; 435464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Double: return 'd'; 43553a0be84b2aed8563150cdbd976a98838afa261ebDaniel Dunbar case BuiltinType::LongDouble: return 'D'; 435664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall } 435764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall} 435864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall 43595471bc85b69912e3b448de004498a80c0de32296Douglas Gregorstatic char ObjCEncodingForEnumType(const ASTContext *C, const EnumType *ET) { 43605471bc85b69912e3b448de004498a80c0de32296Douglas Gregor EnumDecl *Enum = ET->getDecl(); 43615471bc85b69912e3b448de004498a80c0de32296Douglas Gregor 43625471bc85b69912e3b448de004498a80c0de32296Douglas Gregor // The encoding of an non-fixed enum type is always 'i', regardless of size. 43635471bc85b69912e3b448de004498a80c0de32296Douglas Gregor if (!Enum->isFixed()) 43645471bc85b69912e3b448de004498a80c0de32296Douglas Gregor return 'i'; 43655471bc85b69912e3b448de004498a80c0de32296Douglas Gregor 43665471bc85b69912e3b448de004498a80c0de32296Douglas Gregor // The encoding of a fixed enum type matches its fixed underlying type. 43675471bc85b69912e3b448de004498a80c0de32296Douglas Gregor return ObjCEncodingForPrimitiveKind(C, Enum->getIntegerType()); 43685471bc85b69912e3b448de004498a80c0de32296Douglas Gregor} 43695471bc85b69912e3b448de004498a80c0de32296Douglas Gregor 43704ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadstatic void EncodeBitField(const ASTContext *Ctx, std::string& S, 437164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall QualType T, const FieldDecl *FD) { 4372a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith assert(FD->isBitField() && "not a bitfield - getObjCEncodingForTypeImpl"); 43738b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian S += 'b'; 437464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // The NeXT runtime encodes bit fields as b followed by the number of bits. 437564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // The GNU runtime requires more information; bitfields are encoded as b, 437664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // then the offset (in bits) of the first element, then the type of the 437764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // bitfield, then the size in bits. For example, in this structure: 437864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // 437964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // struct 438064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // { 438164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // int integer; 438264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // int flags:2; 438364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // }; 438464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // On a 32-bit system, the encoding for flags would be b2 for the NeXT 438564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // runtime, but b32i2 for the GNU runtime. The reason for this extra 438664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // information is not especially sensible, but we're stuck with it for 438764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // compatibility with GCC, although providing it breaks anything that 438864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // actually uses runtime introspection and wants to work on both runtimes... 438964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall if (!Ctx->getLangOptions().NeXTRuntime) { 439064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall const RecordDecl *RD = FD->getParent(); 439164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall const ASTRecordLayout &RL = Ctx->getASTRecordLayout(RD); 439282905749d5c8d8b4edec11de754a73349cb96603Eli Friedman S += llvm::utostr(RL.getFieldOffset(FD->getFieldIndex())); 43935471bc85b69912e3b448de004498a80c0de32296Douglas Gregor if (const EnumType *ET = T->getAs<EnumType>()) 43945471bc85b69912e3b448de004498a80c0de32296Douglas Gregor S += ObjCEncodingForEnumType(Ctx, ET); 4395c7ff82c2040f45eaad2eddea0e4461dddc972cd1David Chisnall else 43964ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad S += ObjCEncodingForPrimitiveKind(Ctx, T); 439764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall } 4398a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith S += llvm::utostr(FD->getBitWidthValue(*Ctx)); 43998b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian} 44008b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian 440101eb9b9683535d8a65c704ad2c545903409e2d36Daniel Dunbar// FIXME: Use SmallString for accumulating string. 440282a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbarvoid ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S, 440382a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar bool ExpandPointedToStructures, 440482a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar bool ExpandStructures, 4405153bfe5795e2c1a5a738e73d3784964e082237fcDaniel Dunbar const FieldDecl *FD, 4406090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian bool OutermostType, 44072636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis bool EncodingProperty, 4408dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool StructField, 4409dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool EncodeBlockParameters, 4410dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool EncodeClassNames) const { 441164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall if (T->getAs<BuiltinType>()) { 4412ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (FD && FD->isBitField()) 441364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall return EncodeBitField(this, S, T, FD); 441464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall S += ObjCEncodingForPrimitiveKind(this, T); 4415ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4416ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 44171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4418183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ComplexType *CT = T->getAs<ComplexType>()) { 4419c612f7bc9a6379cd7e7c2dd306d05938e890051bAnders Carlsson S += 'j'; 44201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(CT->getElementType(), S, false, false, 0, false, 4421c612f7bc9a6379cd7e7c2dd306d05938e890051bAnders Carlsson false); 4422ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4423ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 442460bce3ef20a4c9684e3825cdd739fefb9810327dFariborz Jahanian 4425aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian // encoding for pointer or r3eference types. 4426aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian QualType PointeeTy; 44276217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const PointerType *PT = T->getAs<PointerType>()) { 44288d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian if (PT->isObjCSelType()) { 44298d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian S += ':'; 44308d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian return; 44318d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian } 4432aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian PointeeTy = PT->getPointeeType(); 4433aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian } 4434aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian else if (const ReferenceType *RT = T->getAs<ReferenceType>()) 4435aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian PointeeTy = RT->getPointeeType(); 4436aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian if (!PointeeTy.isNull()) { 4437a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian bool isReadOnly = false; 4438a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // For historical/compatibility reasons, the read-only qualifier of the 4439a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // pointee gets emitted _before_ the '^'. The read-only qualifier of 4440a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // the pointer itself gets ignored, _unless_ we are looking at a typedef! 44411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Also, do not emit the 'r' for anything but the outermost type! 44428e1fab243ab8023b7ee3899745386b3b3a4258f8Mike Stump if (isa<TypedefType>(T.getTypePtr())) { 4443a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian if (OutermostType && T.isConstQualified()) { 4444a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian isReadOnly = true; 4445a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian S += 'r'; 4446a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 44479fdbab3cbc2fc04bcaf5768023d83707f3151144Mike Stump } else if (OutermostType) { 4448a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian QualType P = PointeeTy; 44496217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek while (P->getAs<PointerType>()) 44506217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek P = P->getAs<PointerType>()->getPointeeType(); 4451a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian if (P.isConstQualified()) { 4452a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian isReadOnly = true; 4453a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian S += 'r'; 4454a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4455a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4456a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian if (isReadOnly) { 4457a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // Another legacy compatibility encoding. Some ObjC qualifier and type 4458a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // combinations need to be rearranged. 4459a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // Rewrite "in const" from "nr" to "rn" 44605f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner if (StringRef(S).endswith("nr")) 44610237941e0beb0c929934b66ad29443b484d987feBenjamin Kramer S.replace(S.end()-2, S.end(), "rn"); 4462a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 44631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 446485f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson if (PointeeTy->isCharType()) { 446585f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson // char pointer types should be encoded as '*' unless it is a 446685f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson // type that has been typedef'd to 'BOOL'. 4467e8c49533521c40643653f943d47229e62d277f88Anders Carlsson if (!isTypeTypedefedAsBOOL(PointeeTy)) { 446885f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson S += '*'; 446985f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson return; 447085f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson } 44716217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek } else if (const RecordType *RTy = PointeeTy->getAs<RecordType>()) { 44729533a7fdb8397421f3be52e879442460a87389f6Steve Naroff // GCC binary compat: Need to convert "struct objc_class *" to "#". 44739533a7fdb8397421f3be52e879442460a87389f6Steve Naroff if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_class")) { 44749533a7fdb8397421f3be52e879442460a87389f6Steve Naroff S += '#'; 44759533a7fdb8397421f3be52e879442460a87389f6Steve Naroff return; 44769533a7fdb8397421f3be52e879442460a87389f6Steve Naroff } 44779533a7fdb8397421f3be52e879442460a87389f6Steve Naroff // GCC binary compat: Need to convert "struct objc_object *" to "@". 44789533a7fdb8397421f3be52e879442460a87389f6Steve Naroff if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_object")) { 44799533a7fdb8397421f3be52e879442460a87389f6Steve Naroff S += '@'; 44809533a7fdb8397421f3be52e879442460a87389f6Steve Naroff return; 44819533a7fdb8397421f3be52e879442460a87389f6Steve Naroff } 44829533a7fdb8397421f3be52e879442460a87389f6Steve Naroff // fall through... 448385f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson } 448485f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson S += '^'; 4485a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian getLegacyIntegralTypeEncoding(PointeeTy); 4486a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian 44871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(PointeeTy, S, false, ExpandPointedToStructures, 448843822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian NULL); 4489ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4490ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 4491aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian 4492ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (const ArrayType *AT = 4493ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner // Ignore type qualifiers etc. 4494ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner dyn_cast<ArrayType>(T->getCanonicalTypeInternal())) { 44952636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (isa<IncompleteArrayType>(AT) && !StructField) { 4496559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson // Incomplete arrays are encoded as a pointer to the array element. 4497559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += '^'; 4498559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson 44991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(AT->getElementType(), S, 4500559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson false, ExpandStructures, FD); 4501559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson } else { 4502559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += '['; 45031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45042636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) { 45052636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (getTypeSize(CAT->getElementType()) == 0) 45062636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '0'; 45072636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis else 45082636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += llvm::utostr(CAT->getSize().getZExtValue()); 45092636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 4510559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson //Variable length arrays are encoded as a regular array with 0 elements. 45112636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert((isa<VariableArrayType>(AT) || isa<IncompleteArrayType>(AT)) && 45122636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis "Unknown array type!"); 4513559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += '0'; 4514559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson } 45151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(AT->getElementType(), S, 4517559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson false, ExpandStructures, FD); 4518559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += ']'; 4519559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson } 4520ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4521ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 45221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4523183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (T->getAs<FunctionType>()) { 4524c0a87b7db06643178ad2cbce0767548c139ea387Anders Carlsson S += '?'; 4525ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4526ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 45271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45286217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const RecordType *RTy = T->getAs<RecordType>()) { 452982a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar RecordDecl *RDecl = RTy->getDecl(); 4530d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar S += RDecl->isUnion() ? '(' : '{'; 4531502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar // Anonymous structures print as '?' 4532502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar if (const IdentifierInfo *II = RDecl->getIdentifier()) { 4533502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar S += II->getName(); 45346fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian if (ClassTemplateSpecializationDecl *Spec 45356fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian = dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) { 45366fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 45376fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian std::string TemplateArgsStr 45386fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian = TemplateSpecializationType::PrintTemplateArgumentList( 4539910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgs.data(), 4540910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgs.size(), 454130c42404202d2e2512e51efc6066bd614cfdb5a4Douglas Gregor (*this).getPrintingPolicy()); 45426fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian 45436fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian S += TemplateArgsStr; 45446fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian } 4545502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar } else { 4546502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar S += '?'; 4547502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar } 45480d504c1da852e58ff802545c823ecff3b6c654b8Daniel Dunbar if (ExpandStructures) { 45497d6b46d9a9d75dea8ef9f6973dd50633c1f37963Fariborz Jahanian S += '='; 45502636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!RDecl->isUnion()) { 45512636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForStructureImpl(RDecl, S, FD); 45522636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 45532636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (RecordDecl::field_iterator Field = RDecl->field_begin(), 45542636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldEnd = RDecl->field_end(); 45552636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis Field != FieldEnd; ++Field) { 45562636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (FD) { 45572636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 45582636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += Field->getNameAsString(); 45592636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 45602636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 45611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45622636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // Special case bit-fields. 45632636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (Field->isBitField()) { 45642636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForTypeImpl(Field->getType(), S, false, true, 45652636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis (*Field)); 45662636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 45672636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis QualType qt = Field->getType(); 45682636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getLegacyIntegralTypeEncoding(qt); 45692636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForTypeImpl(qt, S, false, true, 45702636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FD, /*OutermostType*/false, 45712636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*EncodingProperty*/false, 45722636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*StructField*/true); 45732636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 4574d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar } 45757d6b46d9a9d75dea8ef9f6973dd50633c1f37963Fariborz Jahanian } 45766de88a873a4cbe06d72602eef57d68006730a80bFariborz Jahanian } 4577d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar S += RDecl->isUnion() ? ')' : '}'; 4578ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4579ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 4580e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian 45815471bc85b69912e3b448de004498a80c0de32296Douglas Gregor if (const EnumType *ET = T->getAs<EnumType>()) { 45828b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian if (FD && FD->isBitField()) 458364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall EncodeBitField(this, S, T, FD); 45848b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian else 45855471bc85b69912e3b448de004498a80c0de32296Douglas Gregor S += ObjCEncodingForEnumType(this, ET); 4586ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4587ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 45881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4589dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (const BlockPointerType *BT = T->getAs<BlockPointerType>()) { 459021a98b188857d690aa4510c52ac4317ffa0908a8Steve Naroff S += "@?"; // Unlike a pointer-to-function, which is "^?". 4591dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (EncodeBlockParameters) { 4592dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson const FunctionType *FT = BT->getPointeeType()->getAs<FunctionType>(); 4593dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson 4594dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson S += '<'; 4595dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Block return type 4596dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeImpl(FT->getResultType(), S, 4597dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson ExpandPointedToStructures, ExpandStructures, 4598dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson FD, 4599dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* OutermostType */, 4600dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodingProperty, 4601dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* StructField */, 4602dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeBlockParameters, 4603dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeClassNames); 4604dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Block self 4605dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson S += "@?"; 4606dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Block parameters 4607dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FT)) { 4608dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson for (FunctionProtoType::arg_type_iterator I = FPT->arg_type_begin(), 4609dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson E = FPT->arg_type_end(); I && (I != E); ++I) { 4610dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeImpl(*I, S, 4611dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson ExpandPointedToStructures, 4612dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson ExpandStructures, 4613dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson FD, 4614dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* OutermostType */, 4615dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodingProperty, 4616dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* StructField */, 4617dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeBlockParameters, 4618dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeClassNames); 4619dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson } 4620dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson } 4621dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson S += '>'; 4622dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson } 4623ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4624ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4626c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Ignore protocol qualifiers when mangling at this level. 4627c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OT = T->getAs<ObjCObjectType>()) 4628c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall T = OT->getBaseType(); 4629c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 46300953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (const ObjCInterfaceType *OIT = T->getAs<ObjCInterfaceType>()) { 463143822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian // @encode(class_name) 46320953e767ff7817f97b3ab20896b229891eeff45bJohn McCall ObjCInterfaceDecl *OI = OIT->getDecl(); 463343822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += '{'; 463443822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian const IdentifierInfo *II = OI->getIdentifier(); 463543822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += II->getName(); 463643822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += '='; 4637db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose SmallVector<const ObjCIvarDecl*, 32> Ivars; 46382c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian DeepCollectObjCIvars(OI, true, Ivars); 46392c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian for (unsigned i = 0, e = Ivars.size(); i != e; ++i) { 4640db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose const FieldDecl *Field = cast<FieldDecl>(Ivars[i]); 46412c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian if (Field->isBitField()) 46422c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian getObjCEncodingForTypeImpl(Field->getType(), S, false, true, Field); 464343822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian else 46442c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian getObjCEncodingForTypeImpl(Field->getType(), S, false, true, FD); 464543822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian } 464643822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += '}'; 4647ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 464843822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian } 46491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4650183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ObjCObjectPointerType *OPT = T->getAs<ObjCObjectPointerType>()) { 465114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (OPT->isObjCIdType()) { 465214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '@'; 465314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 4654ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 465627d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) { 465727d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff // FIXME: Consider if we need to output qualifiers for 'Class<p>'. 465827d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff // Since this is a binary compatibility issue, need to consult with runtime 465927d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff // folks. Fortunately, this is a *very* obsure construct. 466014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '#'; 466114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 4662ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4664ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (OPT->isObjCQualifiedIdType()) { 46651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(getObjCIdType(), S, 466614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff ExpandPointedToStructures, 466714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff ExpandStructures, FD); 4668dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (FD || EncodingProperty || EncodeClassNames) { 466914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff // Note that we do extended encoding of protocol qualifer list 467014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff // Only when doing ivar or property encoding. 467114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '"'; 467267ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(), 467367ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff E = OPT->qual_end(); I != E; ++I) { 467414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '<'; 467514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += (*I)->getNameAsString(); 467614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '>'; 467714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 467814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '"'; 467914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 468014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 4681ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4683ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner QualType PointeeTy = OPT->getPointeeType(); 4684ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (!EncodingProperty && 4685ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner isa<TypedefType>(PointeeTy.getTypePtr())) { 4686ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner // Another historical/compatibility reason. 46871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // We encode the underlying type which comes out as 4688ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner // {...}; 4689ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '^'; 46901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(PointeeTy, S, 46911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump false, ExpandPointedToStructures, 4692ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner NULL); 469314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 469414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 4695ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner 4696ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '@'; 4697dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (OPT->getInterfaceDecl() && 4698dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson (FD || EncodingProperty || EncodeClassNames)) { 4699ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '"'; 470027d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff S += OPT->getInterfaceDecl()->getIdentifier()->getName(); 470167ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(), 470267ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff E = OPT->qual_end(); I != E; ++I) { 4703ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '<'; 4704ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += (*I)->getNameAsString(); 4705ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '>'; 47061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 4707ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '"'; 4708ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 4709ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4710ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 47111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4712532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall // gcc just blithely ignores member pointers. 4713532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall // TODO: maybe there should be a mangling for these 4714532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall if (T->getAs<MemberPointerType>()) 4715532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall return; 4716e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian 4717e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian if (T->isVectorType()) { 4718e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian // This matches gcc's encoding, even though technically it is 4719e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian // insufficient. 4720e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian // FIXME. We should do a better job than gcc. 4721e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian return; 4722e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian } 4723e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian 4724b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("@encode for type not implemented!"); 472585f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson} 472685f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson 47272636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidisvoid ASTContext::getObjCEncodingForStructureImpl(RecordDecl *RDecl, 47282636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::string &S, 47292636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis const FieldDecl *FD, 47302636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis bool includeVBases) const { 47312636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert(RDecl && "Expected non-null RecordDecl"); 47322636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert(!RDecl->isUnion() && "Should not be called for unions"); 47332636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!RDecl->getDefinition()) 47342636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis return; 47352636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47362636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CXXRecordDecl *CXXRec = dyn_cast<CXXRecordDecl>(RDecl); 47372636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::multimap<uint64_t, NamedDecl *> FieldOrBaseOffsets; 47382636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis const ASTRecordLayout &layout = getASTRecordLayout(RDecl); 47392636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47402636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRec) { 47412636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (CXXRecordDecl::base_class_iterator 47422636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BI = CXXRec->bases_begin(), 47432636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BE = CXXRec->bases_end(); BI != BE; ++BI) { 47442636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!BI->isVirtual()) { 47452636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CXXRecordDecl *base = BI->getType()->getAsCXXRecordDecl(); 4746829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis if (base->isEmpty()) 4747829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis continue; 47482636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = layout.getBaseClassOffsetInBits(base); 47492636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs), 47502636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::make_pair(offs, base)); 47512636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47522636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47532636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47542636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47552636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis unsigned i = 0; 47562636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (RecordDecl::field_iterator Field = RDecl->field_begin(), 47572636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldEnd = RDecl->field_end(); 47582636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis Field != FieldEnd; ++Field, ++i) { 47592636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = layout.getFieldOffset(i); 47602636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs), 47612636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::make_pair(offs, *Field)); 47622636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47632636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47642636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRec && includeVBases) { 47652636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (CXXRecordDecl::base_class_iterator 47662636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BI = CXXRec->vbases_begin(), 47672636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BE = CXXRec->vbases_end(); BI != BE; ++BI) { 47682636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CXXRecordDecl *base = BI->getType()->getAsCXXRecordDecl(); 4769829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis if (base->isEmpty()) 4770829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis continue; 47712636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = layout.getVBaseClassOffsetInBits(base); 477219aa8609a5d04eed9b81aa1c4608e8a4f3df6ccdArgyrios Kyrtzidis if (FieldOrBaseOffsets.find(offs) == FieldOrBaseOffsets.end()) 477319aa8609a5d04eed9b81aa1c4608e8a4f3df6ccdArgyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.end(), 477419aa8609a5d04eed9b81aa1c4608e8a4f3df6ccdArgyrios Kyrtzidis std::make_pair(offs, base)); 47752636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47762636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47772636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47782636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CharUnits size; 47792636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRec) { 47802636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis size = includeVBases ? layout.getSize() : layout.getNonVirtualSize(); 47812636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 47822636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis size = layout.getSize(); 47832636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47842636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47852636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t CurOffs = 0; 47862636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::multimap<uint64_t, NamedDecl *>::iterator 47872636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurLayObj = FieldOrBaseOffsets.begin(); 47882636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 4789cb8061e321bc6f46f154529885028256c7ae1fb2Argyrios Kyrtzidis if ((CurLayObj != FieldOrBaseOffsets.end() && CurLayObj->first != 0) || 4790cb8061e321bc6f46f154529885028256c7ae1fb2Argyrios Kyrtzidis (CurLayObj == FieldOrBaseOffsets.end() && 4791cb8061e321bc6f46f154529885028256c7ae1fb2Argyrios Kyrtzidis CXXRec && CXXRec->isDynamicClass())) { 47922636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert(CXXRec && CXXRec->isDynamicClass() && 47932636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis "Offset 0 was empty but no VTable ?"); 47942636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (FD) { 47952636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += "\"_vptr$"; 47962636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::string recname = CXXRec->getNameAsString(); 47972636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (recname.empty()) recname = "?"; 47982636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += recname; 47992636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 48002636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48012636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += "^^?"; 48022636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurOffs += getTypeSize(VoidPtrTy); 48032636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48042636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48052636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!RDecl->hasFlexibleArrayMember()) { 48062636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // Mark the end of the structure. 48072636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = toBits(size); 48082636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs), 48092636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::make_pair(offs, (NamedDecl*)0)); 48102636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48112636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48122636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (; CurLayObj != FieldOrBaseOffsets.end(); ++CurLayObj) { 48132636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert(CurOffs <= CurLayObj->first); 48142636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48152636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CurOffs < CurLayObj->first) { 48162636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t padding = CurLayObj->first - CurOffs; 48172636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // FIXME: There doesn't seem to be a way to indicate in the encoding that 48182636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // packing/alignment of members is different that normal, in which case 48192636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // the encoding will be out-of-sync with the real layout. 48202636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // If the runtime switches to just consider the size of types without 48212636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // taking into account alignment, we could make padding explicit in the 48222636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // encoding (e.g. using arrays of chars). The encoding strings would be 48232636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // longer then though. 48242636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurOffs += padding; 48252636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48262636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48272636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis NamedDecl *dcl = CurLayObj->second; 48282636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (dcl == 0) 48292636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis break; // reached end of structure. 48302636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48312636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRecordDecl *base = dyn_cast<CXXRecordDecl>(dcl)) { 48322636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // We expand the bases without their virtual bases since those are going 48332636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // in the initial structure. Note that this differs from gcc which 48342636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // expands virtual bases each time one is encountered in the hierarchy, 48352636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // making the encoding type bigger than it really is. 48362636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForStructureImpl(base, S, FD, /*includeVBases*/false); 4837829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis assert(!base->isEmpty()); 4838829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis CurOffs += toBits(getASTRecordLayout(base).getNonVirtualSize()); 48392636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 48402636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldDecl *field = cast<FieldDecl>(dcl); 48412636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (FD) { 48422636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 48432636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += field->getNameAsString(); 48442636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 48452636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48462636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48472636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (field->isBitField()) { 48482636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis EncodeBitField(this, S, field->getType(), field); 4849a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith CurOffs += field->getBitWidthValue(*this); 48502636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 48512636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis QualType qt = field->getType(); 48522636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getLegacyIntegralTypeEncoding(qt); 48532636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForTypeImpl(qt, S, false, true, FD, 48542636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*OutermostType*/false, 48552636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*EncodingProperty*/false, 48562636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*StructField*/true); 48572636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurOffs += getTypeSize(field->getType()); 48582636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48592636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48602636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48612636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis} 48622636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT, 4864ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian std::string& S) const { 4865ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_In) 4866ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'n'; 4867ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Inout) 4868ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'N'; 4869ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Out) 4870ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'o'; 4871ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Bycopy) 4872ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'O'; 4873ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Byref) 4874ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'R'; 4875ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Oneway) 4876ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'V'; 4877ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian} 4878ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian 4879ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattnervoid ASTContext::setBuiltinVaListType(QualType T) { 4880b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson assert(BuiltinVaListType.isNull() && "__builtin_va_list type already set!"); 48811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4882b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson BuiltinVaListType = T; 4883b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson} 4884b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson 48854dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas GregorTypedefDecl *ASTContext::getObjCIdDecl() const { 48864dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor if (!ObjCIdDecl) { 48874dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor QualType T = getObjCObjectType(ObjCBuiltinIdTy, 0, 0); 48884dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor T = getObjCObjectPointerType(T); 48894dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor TypeSourceInfo *IdInfo = getTrivialTypeSourceInfo(T); 48904dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor ObjCIdDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 48914dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor getTranslationUnitDecl(), 48924dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor SourceLocation(), SourceLocation(), 48934dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor &Idents.get("id"), IdInfo); 48944dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor } 48954dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor 48964dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor return ObjCIdDecl; 48977e219e47de26346885d667131977bd9ca2d7662aSteve Naroff} 48987e219e47de26346885d667131977bd9ca2d7662aSteve Naroff 48997a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas GregorTypedefDecl *ASTContext::getObjCSelDecl() const { 49007a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor if (!ObjCSelDecl) { 49017a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor QualType SelT = getPointerType(ObjCBuiltinSelTy); 49027a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor TypeSourceInfo *SelInfo = getTrivialTypeSourceInfo(SelT); 49037a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor ObjCSelDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 49047a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor getTranslationUnitDecl(), 49057a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor SourceLocation(), SourceLocation(), 49067a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor &Idents.get("SEL"), SelInfo); 49077a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor } 49087a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor return ObjCSelDecl; 4909b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian} 4910b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian 4911ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattnervoid ASTContext::setObjCProtoType(QualType QT) { 4912a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCProtoType = QT; 4913390d50a725497e99247dc104a7d2c2a255d3af14Fariborz Jahanian} 4914390d50a725497e99247dc104a7d2c2a255d3af14Fariborz Jahanian 491579d6726921897811232554ed94c5d77b5b7b3fc0Douglas GregorTypedefDecl *ASTContext::getObjCClassDecl() const { 491679d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor if (!ObjCClassDecl) { 491779d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor QualType T = getObjCObjectType(ObjCBuiltinClassTy, 0, 0); 491879d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor T = getObjCObjectPointerType(T); 491979d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor TypeSourceInfo *ClassInfo = getTrivialTypeSourceInfo(T); 492079d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor ObjCClassDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 492179d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor getTranslationUnitDecl(), 492279d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor SourceLocation(), SourceLocation(), 492379d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor &Idents.get("Class"), ClassInfo); 492479d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor } 492579d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor 492679d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor return ObjCClassDecl; 49278baaca50f07d0c10bba69c8d88c1b9078c92d06dAnders Carlsson} 49288baaca50f07d0c10bba69c8d88c1b9078c92d06dAnders Carlsson 4929a526c5c67e5a0473c340903ee542ce570119665fTed Kremenekvoid ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) { 49301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(ObjCConstantStringType.isNull() && 49312198891824c38d45b2279de5d5e3ef9394eb457cSteve Naroff "'NSConstantString' type already set!"); 49321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4933a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCConstantStringType = getObjCInterfaceType(Decl); 49342198891824c38d45b2279de5d5e3ef9394eb457cSteve Naroff} 49352198891824c38d45b2279de5d5e3ef9394eb457cSteve Naroff 49360bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall/// \brief Retrieve the template name that corresponds to a non-empty 49370bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall/// lookup. 49384ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName 49394ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getOverloadedTemplateName(UnresolvedSetIterator Begin, 49404ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad UnresolvedSetIterator End) const { 49410bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall unsigned size = End - Begin; 49420bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall assert(size > 1 && "set is not overloaded!"); 49437532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 49440bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall void *memory = Allocate(sizeof(OverloadedTemplateStorage) + 49450bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall size * sizeof(FunctionTemplateDecl*)); 49460bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall OverloadedTemplateStorage *OT = new(memory) OverloadedTemplateStorage(size); 49470bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall 49480bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall NamedDecl **Storage = OT->getStorage(); 4949eec51cf1ba5f0e62c9cdb81b5c63babdd6e649abJohn McCall for (UnresolvedSetIterator I = Begin; I != End; ++I) { 49500bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall NamedDecl *D = *I; 49510bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall assert(isa<FunctionTemplateDecl>(D) || 49520bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall (isa<UsingShadowDecl>(D) && 49530bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall isa<FunctionTemplateDecl>(D->getUnderlyingDecl()))); 49540bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall *Storage++ = D; 49557532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor } 49567532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 49570bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall return TemplateName(OT); 49587532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor} 49597532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 4960d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor/// \brief Retrieve the template name that represents a qualified 4961d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor/// template name such as \c std::vector. 49624ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName 49634ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS, 49644ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad bool TemplateKeyword, 49654ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad TemplateDecl *Template) const { 49660f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor assert(NNS && "Missing nested-name-specifier in qualified template name"); 49670f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor 4968789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor // FIXME: Canonicalization? 4969d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor llvm::FoldingSetNodeID ID; 4970d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template); 49711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4972d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor void *InsertPos = 0; 4973d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QualifiedTemplateName *QTN = 49740bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 4975d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor if (!QTN) { 4976d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QTN = new (*this,4) QualifiedTemplateName(NNS, TemplateKeyword, Template); 4977d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QualifiedTemplateNames.InsertNode(QTN, InsertPos); 4978d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor } 49791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4980d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor return TemplateName(QTN); 4981d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor} 4982d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor 49837532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor/// \brief Retrieve the template name that represents a dependent 49847532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor/// template name such as \c MetaFun::template apply. 49854ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName 49864ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getDependentTemplateName(NestedNameSpecifier *NNS, 49874ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const IdentifierInfo *Name) const { 49881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert((!NNS || NNS->isDependent()) && 49893b6afbb99a1c44b4076f8e15fb7311405941b306Douglas Gregor "Nested name specifier must be dependent"); 49907532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 49917532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor llvm::FoldingSetNodeID ID; 49927532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateName::Profile(ID, NNS, Name); 49937532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 49947532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor void *InsertPos = 0; 49957532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateName *QTN = 49967532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 49977532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 49987532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor if (QTN) 49997532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor return TemplateName(QTN); 50007532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 50017532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 50027532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor if (CanonNNS == NNS) { 50037532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Name); 50047532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor } else { 50057532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor TemplateName Canon = getDependentTemplateName(CanonNNS, Name); 50067532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Name, Canon); 5007789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateName *CheckQTN = 5008789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 5009789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!CheckQTN && "Dependent type name canonicalization broken"); 5010789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CheckQTN; 50117532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor } 50127532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 50137532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateNames.InsertNode(QTN, InsertPos); 50147532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor return TemplateName(QTN); 50157532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor} 50167532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 5017ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor/// \brief Retrieve the template name that represents a dependent 5018ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor/// template name such as \c MetaFun::template operator+. 5019ca1bdd7c269a2390d43c040a60511edd017ee130Douglas GregorTemplateName 5020ca1bdd7c269a2390d43c040a60511edd017ee130Douglas GregorASTContext::getDependentTemplateName(NestedNameSpecifier *NNS, 50214ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad OverloadedOperatorKind Operator) const { 5022ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor assert((!NNS || NNS->isDependent()) && 5023ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor "Nested name specifier must be dependent"); 5024ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5025ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor llvm::FoldingSetNodeID ID; 5026ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor DependentTemplateName::Profile(ID, NNS, Operator); 5027ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5028ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor void *InsertPos = 0; 5029789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateName *QTN 5030789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 5031ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5032ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor if (QTN) 5033ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor return TemplateName(QTN); 5034ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5035ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 5036ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor if (CanonNNS == NNS) { 5037ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Operator); 5038ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor } else { 5039ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor TemplateName Canon = getDependentTemplateName(CanonNNS, Operator); 5040ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Operator, Canon); 5041789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 5042789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateName *CheckQTN 5043789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 5044789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!CheckQTN && "Dependent template name canonicalization broken"); 5045789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CheckQTN; 5046ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor } 5047ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5048ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor DependentTemplateNames.InsertNode(QTN, InsertPos); 5049ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor return TemplateName(QTN); 5050ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor} 5051ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 50521aee05d08b2184acadeb36de300e216390780d6cDouglas GregorTemplateName 5053146060435c3efce95c95a092c7a1eb651cfb9ae0John McCallASTContext::getSubstTemplateTemplateParm(TemplateTemplateParmDecl *param, 5054146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateName replacement) const { 5055146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm::FoldingSetNodeID ID; 5056146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage::Profile(ID, param, replacement); 5057146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5058146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall void *insertPos = 0; 5059146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage *subst 5060146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = SubstTemplateTemplateParms.FindNodeOrInsertPos(ID, insertPos); 5061146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5062146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall if (!subst) { 5063146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall subst = new (*this) SubstTemplateTemplateParmStorage(param, replacement); 5064146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParms.InsertNode(subst, insertPos); 5065146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 5066146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5067146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return TemplateName(subst); 5068146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall} 5069146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5070146060435c3efce95c95a092c7a1eb651cfb9ae0John McCallTemplateName 50711aee05d08b2184acadeb36de300e216390780d6cDouglas GregorASTContext::getSubstTemplateTemplateParmPack(TemplateTemplateParmDecl *Param, 50721aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor const TemplateArgument &ArgPack) const { 50731aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor ASTContext &Self = const_cast<ASTContext &>(*this); 50741aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor llvm::FoldingSetNodeID ID; 50751aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor SubstTemplateTemplateParmPackStorage::Profile(ID, Self, Param, ArgPack); 50761aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 50771aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor void *InsertPos = 0; 50781aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor SubstTemplateTemplateParmPackStorage *Subst 50791aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor = SubstTemplateTemplateParmPacks.FindNodeOrInsertPos(ID, InsertPos); 50801aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 50811aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor if (!Subst) { 5082146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall Subst = new (*this) SubstTemplateTemplateParmPackStorage(Param, 50831aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor ArgPack.pack_size(), 50841aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor ArgPack.pack_begin()); 50851aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor SubstTemplateTemplateParmPacks.InsertNode(Subst, InsertPos); 50861aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor } 50871aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 50881aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor return TemplateName(Subst); 50891aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor} 50901aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 5091b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor/// getFromTargetType - Given one of the integer types provided by 5092d934112e6170b0fd940d8e40db6936cea2cdcf62Douglas Gregor/// TargetInfo, produce the corresponding type. The unsigned @p Type 5093d934112e6170b0fd940d8e40db6936cea2cdcf62Douglas Gregor/// is actually a value of type @c TargetInfo::IntType. 5094e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCallCanQualType ASTContext::getFromTargetType(unsigned Type) const { 5095b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor switch (Type) { 5096e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCall case TargetInfo::NoInt: return CanQualType(); 5097b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedShort: return ShortTy; 5098b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedShort: return UnsignedShortTy; 5099b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedInt: return IntTy; 5100b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedInt: return UnsignedIntTy; 5101b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedLong: return LongTy; 5102b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedLong: return UnsignedLongTy; 5103b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedLongLong: return LongLongTy; 5104b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedLongLong: return UnsignedLongLongTy; 5105b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor } 5106b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor 5107b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unhandled TargetInfo::IntType value"); 5108b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor} 5109b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek 5110b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek//===----------------------------------------------------------------------===// 5111b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek// Type Predicates. 5112b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek//===----------------------------------------------------------------------===// 5113b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek 51144fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian/// getObjCGCAttr - Returns one of GCNone, Weak or Strong objc's 51154fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian/// garbage collection attribute. 51164fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian/// 5117ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCallQualifiers::GC ASTContext::getObjCGCAttrKind(QualType Ty) const { 5118e289d81369914678db386f6aa86faf8f178e245dDouglas Gregor if (getLangOptions().getGC() == LangOptions::NonGC) 5119ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall return Qualifiers::GCNone; 5120ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall 5121ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall assert(getLangOptions().ObjC1); 5122ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall Qualifiers::GC GCAttrs = Ty.getObjCGCAttr(); 5123ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall 5124ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // Default behaviour under objective-C's gc is for ObjC pointers 5125ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // (or pointers to them) be treated as though they were declared 5126ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // as __strong. 5127ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall if (GCAttrs == Qualifiers::GCNone) { 5128ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType()) 5129ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall return Qualifiers::Strong; 5130ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall else if (Ty->isPointerType()) 5131ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall return getObjCGCAttrKind(Ty->getAs<PointerType>()->getPointeeType()); 5132ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall } else { 5133ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // It's not valid to set GC attributes on anything that isn't a 5134ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // pointer. 5135ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall#ifndef NDEBUG 5136ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall QualType CT = Ty->getCanonicalTypeInternal(); 5137ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall while (const ArrayType *AT = dyn_cast<ArrayType>(CT)) 5138ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall CT = AT->getElementType(); 5139ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall assert(CT->isAnyPointerType() || CT->isBlockPointerType()); 5140ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall#endif 51414fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian } 5142b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris Lattner return GCAttrs; 51434fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian} 51444fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian 51456ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner//===----------------------------------------------------------------------===// 51466ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner// Type Compatibility Testing 51476ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner//===----------------------------------------------------------------------===// 5148770951b5bb6028a8d326ddb4a13cef7d4a128162Chris Lattner 51491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// areCompatVectorTypes - Return true if the two specified vector types are 51506ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner/// compatible. 51516ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattnerstatic bool areCompatVectorTypes(const VectorType *LHS, 51526ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner const VectorType *RHS) { 5153467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified()); 51546ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner return LHS->getElementType() == RHS->getElementType() && 515561710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner LHS->getNumElements() == RHS->getNumElements(); 51566ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner} 51576ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner 5158255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregorbool ASTContext::areCompatibleVectorTypes(QualType FirstVec, 5159255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor QualType SecondVec) { 5160255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor assert(FirstVec->isVectorType() && "FirstVec should be a vector type"); 5161255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor assert(SecondVec->isVectorType() && "SecondVec should be a vector type"); 5162255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 5163255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor if (hasSameUnqualifiedType(FirstVec, SecondVec)) 5164255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor return true; 5165255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 5166f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson // Treat Neon vector types and most AltiVec vector types as if they are the 5167f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson // equivalent GCC vector types. 5168255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor const VectorType *First = FirstVec->getAs<VectorType>(); 5169255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor const VectorType *Second = SecondVec->getAs<VectorType>(); 5170f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson if (First->getNumElements() == Second->getNumElements() && 5171255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor hasSameType(First->getElementType(), Second->getElementType()) && 5172f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson First->getVectorKind() != VectorType::AltiVecPixel && 5173f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson First->getVectorKind() != VectorType::AltiVecBool && 5174f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson Second->getVectorKind() != VectorType::AltiVecPixel && 5175f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson Second->getVectorKind() != VectorType::AltiVecBool) 5176255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor return true; 5177255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 5178255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor return false; 5179255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor} 5180255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 51814084c306635b70f37029dca938444e6013f08684Steve Naroff//===----------------------------------------------------------------------===// 51824084c306635b70f37029dca938444e6013f08684Steve Naroff// ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's. 51834084c306635b70f37029dca938444e6013f08684Steve Naroff//===----------------------------------------------------------------------===// 51844084c306635b70f37029dca938444e6013f08684Steve Naroff 51854084c306635b70f37029dca938444e6013f08684Steve Naroff/// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the 51864084c306635b70f37029dca938444e6013f08684Steve Naroff/// inheritance hierarchy of 'rProto'. 51874ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadbool 51884ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto, 51894ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad ObjCProtocolDecl *rProto) const { 51903fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor if (declaresSameEntity(lProto, rProto)) 519114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return true; 51924084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCProtocolDecl::protocol_iterator PI = rProto->protocol_begin(), 51934084c306635b70f37029dca938444e6013f08684Steve Naroff E = rProto->protocol_end(); PI != E; ++PI) 51944084c306635b70f37029dca938444e6013f08684Steve Naroff if (ProtocolCompatibleWithProtocol(lProto, *PI)) 51954084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 51964084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 51974084c306635b70f37029dca938444e6013f08684Steve Naroff} 519814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 51994084c306635b70f37029dca938444e6013f08684Steve Naroff/// QualifiedIdConformsQualifiedId - compare id<p,...> with id<p1,...> 52004084c306635b70f37029dca938444e6013f08684Steve Naroff/// return true if lhs's protocols conform to rhs's protocol; false 52014084c306635b70f37029dca938444e6013f08684Steve Naroff/// otherwise. 52024084c306635b70f37029dca938444e6013f08684Steve Naroffbool ASTContext::QualifiedIdConformsQualifiedId(QualType lhs, QualType rhs) { 52034084c306635b70f37029dca938444e6013f08684Steve Naroff if (lhs->isObjCQualifiedIdType() && rhs->isObjCQualifiedIdType()) 52044084c306635b70f37029dca938444e6013f08684Steve Naroff return ObjCQualifiedIdTypesAreCompatible(lhs, rhs, false); 52054084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 52064084c306635b70f37029dca938444e6013f08684Steve Naroff} 52074084c306635b70f37029dca938444e6013f08684Steve Naroff 5208a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian/// ObjCQualifiedClassTypesAreCompatible - compare Class<p,...> and 5209a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian/// Class<p1, ...>. 5210a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanianbool ASTContext::ObjCQualifiedClassTypesAreCompatible(QualType lhs, 5211a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian QualType rhs) { 5212a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian const ObjCObjectPointerType *lhsQID = lhs->getAs<ObjCObjectPointerType>(); 5213a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>(); 5214a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian assert ((lhsQID && rhsOPT) && "ObjCQualifiedClassTypesAreCompatible"); 5215a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 5216a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 5217a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian E = lhsQID->qual_end(); I != E; ++I) { 5218a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian bool match = false; 5219a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian ObjCProtocolDecl *lhsProto = *I; 5220a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(), 5221a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian E = rhsOPT->qual_end(); J != E; ++J) { 5222a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian ObjCProtocolDecl *rhsProto = *J; 5223a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto)) { 5224a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian match = true; 5225a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian break; 5226a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian } 5227a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian } 5228a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian if (!match) 5229a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian return false; 5230a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian } 5231a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian return true; 5232a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian} 5233a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 52344084c306635b70f37029dca938444e6013f08684Steve Naroff/// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an 52354084c306635b70f37029dca938444e6013f08684Steve Naroff/// ObjCQualifiedIDType. 52364084c306635b70f37029dca938444e6013f08684Steve Naroffbool ASTContext::ObjCQualifiedIdTypesAreCompatible(QualType lhs, QualType rhs, 52374084c306635b70f37029dca938444e6013f08684Steve Naroff bool compare) { 52384084c306635b70f37029dca938444e6013f08684Steve Naroff // Allow id<P..> and an 'id' or void* type in all cases. 52391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (lhs->isVoidPointerType() || 52404084c306635b70f37029dca938444e6013f08684Steve Naroff lhs->isObjCIdType() || lhs->isObjCClassType()) 52414084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 52421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump else if (rhs->isVoidPointerType() || 52434084c306635b70f37029dca938444e6013f08684Steve Naroff rhs->isObjCIdType() || rhs->isObjCClassType()) 52444084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 52454084c306635b70f37029dca938444e6013f08684Steve Naroff 52464084c306635b70f37029dca938444e6013f08684Steve Naroff if (const ObjCObjectPointerType *lhsQID = lhs->getAsObjCQualifiedIdType()) { 5247183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>(); 52481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 52494084c306635b70f37029dca938444e6013f08684Steve Naroff if (!rhsOPT) return false; 52501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 52514084c306635b70f37029dca938444e6013f08684Steve Naroff if (rhsOPT->qual_empty()) { 52521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the RHS is a unqualified interface pointer "NSString*", 52534084c306635b70f37029dca938444e6013f08684Steve Naroff // make sure we check the class hierarchy. 52544084c306635b70f37029dca938444e6013f08684Steve Naroff if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) { 52554084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 52564084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsQID->qual_end(); I != E; ++I) { 52574084c306635b70f37029dca938444e6013f08684Steve Naroff // when comparing an id<P> on lhs with a static type on rhs, 52584084c306635b70f37029dca938444e6013f08684Steve Naroff // see if static class implements all of id's protocols, directly or 52594084c306635b70f37029dca938444e6013f08684Steve Naroff // through its super class and categories. 52600fd8904c5f71a11d29f67716c3ebdf7ad1c855fbFariborz Jahanian if (!rhsID->ClassImplementsProtocol(*I, true)) 52614084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 52624084c306635b70f37029dca938444e6013f08684Steve Naroff } 52634084c306635b70f37029dca938444e6013f08684Steve Naroff } 52644084c306635b70f37029dca938444e6013f08684Steve Naroff // If there are no qualifiers and no interface, we have an 'id'. 52654084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 52664084c306635b70f37029dca938444e6013f08684Steve Naroff } 52671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Both the right and left sides have qualifiers. 52684084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 52694084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsQID->qual_end(); I != E; ++I) { 52704084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *lhsProto = *I; 52714084c306635b70f37029dca938444e6013f08684Steve Naroff bool match = false; 5272de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff 5273de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff // when comparing an id<P> on lhs with a static type on rhs, 5274de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff // see if static class implements all of id's protocols, directly or 5275de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff // through its super class and categories. 52764084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(), 52774084c306635b70f37029dca938444e6013f08684Steve Naroff E = rhsOPT->qual_end(); J != E; ++J) { 52784084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *rhsProto = *J; 52794084c306635b70f37029dca938444e6013f08684Steve Naroff if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 52804084c306635b70f37029dca938444e6013f08684Steve Naroff (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 52814084c306635b70f37029dca938444e6013f08684Steve Naroff match = true; 52828f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff break; 52838f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff } 5284de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff } 52851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the RHS is a qualified interface pointer "NSString<P>*", 52864084c306635b70f37029dca938444e6013f08684Steve Naroff // make sure we check the class hierarchy. 52874084c306635b70f37029dca938444e6013f08684Steve Naroff if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) { 52884084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 52894084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsQID->qual_end(); I != E; ++I) { 52904084c306635b70f37029dca938444e6013f08684Steve Naroff // when comparing an id<P> on lhs with a static type on rhs, 52914084c306635b70f37029dca938444e6013f08684Steve Naroff // see if static class implements all of id's protocols, directly or 52924084c306635b70f37029dca938444e6013f08684Steve Naroff // through its super class and categories. 52930fd8904c5f71a11d29f67716c3ebdf7ad1c855fbFariborz Jahanian if (rhsID->ClassImplementsProtocol(*I, true)) { 52944084c306635b70f37029dca938444e6013f08684Steve Naroff match = true; 52954084c306635b70f37029dca938444e6013f08684Steve Naroff break; 52964084c306635b70f37029dca938444e6013f08684Steve Naroff } 52974084c306635b70f37029dca938444e6013f08684Steve Naroff } 52984084c306635b70f37029dca938444e6013f08684Steve Naroff } 52994084c306635b70f37029dca938444e6013f08684Steve Naroff if (!match) 5300de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff return false; 5301de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff } 53021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5303de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff return true; 5304de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff } 53051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 53064084c306635b70f37029dca938444e6013f08684Steve Naroff const ObjCObjectPointerType *rhsQID = rhs->getAsObjCQualifiedIdType(); 53074084c306635b70f37029dca938444e6013f08684Steve Naroff assert(rhsQID && "One of the LHS/RHS should be id<x>"); 53084084c306635b70f37029dca938444e6013f08684Steve Naroff 53091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const ObjCObjectPointerType *lhsOPT = 53104084c306635b70f37029dca938444e6013f08684Steve Naroff lhs->getAsObjCInterfacePointerType()) { 5311de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // If both the right and left sides have qualifiers. 53124084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsOPT->qual_begin(), 53134084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsOPT->qual_end(); I != E; ++I) { 53144084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *lhsProto = *I; 53154084c306635b70f37029dca938444e6013f08684Steve Naroff bool match = false; 53164084c306635b70f37029dca938444e6013f08684Steve Naroff 5317de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // when comparing an id<P> on rhs with a static type on lhs, 53184084c306635b70f37029dca938444e6013f08684Steve Naroff // see if static class implements all of id's protocols, directly or 53194084c306635b70f37029dca938444e6013f08684Steve Naroff // through its super class and categories. 5320de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // First, lhs protocols in the qualifier list must be found, direct 5321de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // or indirect in rhs's qualifier list or it is a mismatch. 53224084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(), 53234084c306635b70f37029dca938444e6013f08684Steve Naroff E = rhsQID->qual_end(); J != E; ++J) { 53244084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *rhsProto = *J; 53254084c306635b70f37029dca938444e6013f08684Steve Naroff if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 53264084c306635b70f37029dca938444e6013f08684Steve Naroff (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 53274084c306635b70f37029dca938444e6013f08684Steve Naroff match = true; 53284084c306635b70f37029dca938444e6013f08684Steve Naroff break; 53294084c306635b70f37029dca938444e6013f08684Steve Naroff } 53304084c306635b70f37029dca938444e6013f08684Steve Naroff } 53314084c306635b70f37029dca938444e6013f08684Steve Naroff if (!match) 53324084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 53334084c306635b70f37029dca938444e6013f08684Steve Naroff } 5334de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian 5335de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // Static class's protocols, or its super class or category protocols 5336de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // must be found, direct or indirect in rhs's qualifier list or it is a mismatch. 5337de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (ObjCInterfaceDecl *lhsID = lhsOPT->getInterfaceDecl()) { 5338de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols; 5339de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian CollectInheritedProtocols(lhsID, LHSInheritedProtocols); 5340de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // This is rather dubious but matches gcc's behavior. If lhs has 5341de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // no type qualifier and its class has no static protocol(s) 5342de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // assume that it is mismatch. 5343de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (LHSInheritedProtocols.empty() && lhsOPT->qual_empty()) 5344de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian return false; 5345de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 5346de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian LHSInheritedProtocols.begin(), 5347de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian E = LHSInheritedProtocols.end(); I != E; ++I) { 5348de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian bool match = false; 5349de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian ObjCProtocolDecl *lhsProto = (*I); 5350de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(), 5351de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian E = rhsQID->qual_end(); J != E; ++J) { 5352de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian ObjCProtocolDecl *rhsProto = *J; 5353de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 5354de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 5355de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian match = true; 5356de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian break; 5357de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 5358de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 5359de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (!match) 5360de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian return false; 5361de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 5362de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 53634084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 53644084c306635b70f37029dca938444e6013f08684Steve Naroff } 53654084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 53664084c306635b70f37029dca938444e6013f08684Steve Naroff} 53674084c306635b70f37029dca938444e6013f08684Steve Naroff 53684084c306635b70f37029dca938444e6013f08684Steve Naroff/// canAssignObjCInterfaces - Return true if the two interface types are 53694084c306635b70f37029dca938444e6013f08684Steve Naroff/// compatible for assignment from RHS to LHS. This handles validation of any 53704084c306635b70f37029dca938444e6013f08684Steve Naroff/// protocol qualifiers on the LHS or RHS. 53714084c306635b70f37029dca938444e6013f08684Steve Naroff/// 53724084c306635b70f37029dca938444e6013f08684Steve Naroffbool ASTContext::canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, 53734084c306635b70f37029dca938444e6013f08684Steve Naroff const ObjCObjectPointerType *RHSOPT) { 5374c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* LHS = LHSOPT->getObjectType(); 5375c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* RHS = RHSOPT->getObjectType(); 5376c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 53774084c306635b70f37029dca938444e6013f08684Steve Naroff // If either type represents the built-in 'id' or 'Class' types, return true. 5378c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHS->isObjCUnqualifiedIdOrClass() || 5379c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall RHS->isObjCUnqualifiedIdOrClass()) 53804084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 53814084c306635b70f37029dca938444e6013f08684Steve Naroff 5382c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHS->isObjCQualifiedId() || RHS->isObjCQualifiedId()) 53831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0), 53841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType(RHSOPT,0), 53854084c306635b70f37029dca938444e6013f08684Steve Naroff false); 5386a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 5387a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian if (LHS->isObjCQualifiedClass() && RHS->isObjCQualifiedClass()) 5388a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian return ObjCQualifiedClassTypesAreCompatible(QualType(LHSOPT,0), 5389a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian QualType(RHSOPT,0)); 5390a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 5391c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // If we have 2 user-defined types, fall into that path. 5392c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHS->getInterface() && RHS->getInterface()) 53934084c306635b70f37029dca938444e6013f08684Steve Naroff return canAssignObjCInterfaces(LHS, RHS); 53941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 53954084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 539614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff} 539714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 5398132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// canAssignObjCInterfacesInBlockPointer - This routine is specifically written 5399fc8f0e14ad142ed811e90fbd9a30e419e301c717Chris Lattner/// for providing type-safety for objective-c pointers used to pass/return 5400132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// arguments in block literals. When passed as arguments, passing 'A*' where 5401132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// 'id' is expected is not OK. Passing 'Sub *" where 'Super *" is expected is 5402132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// not OK. For the return type, the opposite is not OK. 5403132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanianbool ASTContext::canAssignObjCInterfacesInBlockPointer( 5404132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian const ObjCObjectPointerType *LHSOPT, 5405a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian const ObjCObjectPointerType *RHSOPT, 5406a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian bool BlockReturnType) { 5407a98344869c278295f38e106583906377520079b8Fariborz Jahanian if (RHSOPT->isObjCBuiltinType() || LHSOPT->isObjCIdType()) 5408132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return true; 5409132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5410132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHSOPT->isObjCBuiltinType()) { 5411132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return RHSOPT->isObjCBuiltinType() || RHSOPT->isObjCQualifiedIdType(); 5412132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 5413132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5414a98344869c278295f38e106583906377520079b8Fariborz Jahanian if (LHSOPT->isObjCQualifiedIdType() || RHSOPT->isObjCQualifiedIdType()) 5415132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0), 5416132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian QualType(RHSOPT,0), 5417132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian false); 5418132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5419132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType(); 5420132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType(); 5421132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHS && RHS) { // We have 2 user-defined types. 5422132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHS != RHS) { 5423132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHS->getDecl()->isSuperClassOf(RHS->getDecl())) 5424a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian return BlockReturnType; 5425132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (RHS->getDecl()->isSuperClassOf(LHS->getDecl())) 5426a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian return !BlockReturnType; 5427132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 5428132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian else 5429132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return true; 5430132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 5431132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return false; 5432132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian} 5433132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5434e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// getIntersectionOfProtocols - This routine finds the intersection of set 5435e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// of protocols inherited from two distinct objective-c pointer objects. 5436e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// It is used to build composite qualifier list of the composite type of 5437e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// the conditional expression involving two objective-c pointer objects. 5438e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanianstatic 5439e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanianvoid getIntersectionOfProtocols(ASTContext &Context, 5440e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian const ObjCObjectPointerType *LHSOPT, 5441e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian const ObjCObjectPointerType *RHSOPT, 54425f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<ObjCProtocolDecl *> &IntersectionOfProtocols) { 5443e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5444c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* LHS = LHSOPT->getObjectType(); 5445c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* RHS = RHSOPT->getObjectType(); 5446c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(LHS->getInterface() && "LHS must have an interface base"); 5447c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(RHS->getInterface() && "RHS must have an interface base"); 5448e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5449e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocolSet; 5450e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian unsigned LHSNumProtocols = LHS->getNumProtocols(); 5451e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (LHSNumProtocols > 0) 5452e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian InheritedProtocolSet.insert(LHS->qual_begin(), LHS->qual_end()); 5453e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian else { 5454432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols; 5455c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Context.CollectInheritedProtocols(LHS->getInterface(), 5456c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall LHSInheritedProtocols); 5457e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian InheritedProtocolSet.insert(LHSInheritedProtocols.begin(), 5458e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian LHSInheritedProtocols.end()); 5459e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 5460e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5461e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian unsigned RHSNumProtocols = RHS->getNumProtocols(); 5462e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (RHSNumProtocols > 0) { 5463cb421fa690da545b58a720abe5f1c49b166dbde7Dan Gohman ObjCProtocolDecl **RHSProtocols = 5464cb421fa690da545b58a720abe5f1c49b166dbde7Dan Gohman const_cast<ObjCProtocolDecl **>(RHS->qual_begin()); 5465e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (unsigned i = 0; i < RHSNumProtocols; ++i) 5466e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (InheritedProtocolSet.count(RHSProtocols[i])) 5467e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian IntersectionOfProtocols.push_back(RHSProtocols[i]); 54683060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 5469432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> RHSInheritedProtocols; 5470c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Context.CollectInheritedProtocols(RHS->getInterface(), 5471c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall RHSInheritedProtocols); 5472432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 5473432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian RHSInheritedProtocols.begin(), 5474432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian E = RHSInheritedProtocols.end(); I != E; ++I) 5475432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian if (InheritedProtocolSet.count((*I))) 5476432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian IntersectionOfProtocols.push_back((*I)); 5477e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 5478e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian} 5479e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5480db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// areCommonBaseCompatible - Returns common base class of the two classes if 5481db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// one found. Note that this is O'2 algorithm. But it will be called as the 5482db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// last type comparison in a ?-exp of ObjC pointer types before a 5483db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// warning is issued. So, its invokation is extremely rare. 5484db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz JahanianQualType ASTContext::areCommonBaseCompatible( 5485c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectPointerType *Lptr, 5486c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectPointerType *Rptr) { 5487c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType *LHS = Lptr->getObjectType(); 5488c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType *RHS = Rptr->getObjectType(); 5489c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCInterfaceDecl* LDecl = LHS->getInterface(); 5490c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCInterfaceDecl* RDecl = RHS->getInterface(); 549160ef308e51c71b760d7f598c1b763ceb7b768148Douglas Gregor if (!LDecl || !RDecl || (declaresSameEntity(LDecl, RDecl))) 5492db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian return QualType(); 5493db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian 54947c2bdcb4d30f2d370b4367664e6a11b075ce2cb3Fariborz Jahanian do { 5495c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall LHS = cast<ObjCInterfaceType>(getObjCInterfaceType(LDecl)); 5496e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (canAssignObjCInterfaces(LHS, RHS)) { 54975f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<ObjCProtocolDecl *, 8> Protocols; 5498c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall getIntersectionOfProtocols(*this, Lptr, Rptr, Protocols); 5499c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 5500c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall QualType Result = QualType(LHS, 0); 5501c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!Protocols.empty()) 5502c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Result = getObjCObjectType(Result, Protocols.data(), Protocols.size()); 5503c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Result = getObjCObjectPointerType(Result); 5504c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return Result; 5505e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 55067c2bdcb4d30f2d370b4367664e6a11b075ce2cb3Fariborz Jahanian } while ((LDecl = LDecl->getSuperClass())); 5507db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian 5508db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian return QualType(); 5509db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian} 5510db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian 5511c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCallbool ASTContext::canAssignObjCInterfaces(const ObjCObjectType *LHS, 5512c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType *RHS) { 5513c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(LHS->getInterface() && "LHS is not an interface type"); 5514c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(RHS->getInterface() && "RHS is not an interface type"); 5515c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 55166ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // Verify that the base decls are compatible: the RHS must be a subclass of 55176ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // the LHS. 5518c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!LHS->getInterface()->isSuperClassOf(RHS->getInterface())) 55196ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner return false; 55201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 55216ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // RHS must have a superset of the protocols in the LHS. If the LHS is not 55226ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // protocol qualified at all, then we are good. 5523c15cb2af27514ecc879daba9aa01389c5203685dSteve Naroff if (LHS->getNumProtocols() == 0) 55246ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner return true; 55251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5526b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // Okay, we know the LHS has protocol qualifiers. If the RHS doesn't, 5527b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // more detailed analysis is required. 5528b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (RHS->getNumProtocols() == 0) { 5529b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // OK, if LHS is a superclass of RHS *and* 5530b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // this superclass is assignment compatible with LHS. 5531b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // false otherwise. 5532627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian bool IsSuperClass = 5533627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian LHS->getInterface()->isSuperClassOf(RHS->getInterface()); 5534627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian if (IsSuperClass) { 5535b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // OK if conversion of LHS to SuperClass results in narrowing of types 5536b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // ; i.e., SuperClass may implement at least one of the protocols 5537b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // in LHS's protocol list. Example, SuperObj<P1> = lhs<P1,P2> is ok. 5538b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // But not SuperObj<P1,P2,P3> = lhs<P1,P2>. 5539b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> SuperClassInheritedProtocols; 5540627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian CollectInheritedProtocols(RHS->getInterface(), SuperClassInheritedProtocols); 5541b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // If super class has no protocols, it is not a match. 5542b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (SuperClassInheritedProtocols.empty()) 5543b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return false; 5544b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian 5545b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian for (ObjCObjectType::qual_iterator LHSPI = LHS->qual_begin(), 5546b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian LHSPE = LHS->qual_end(); 5547b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian LHSPI != LHSPE; LHSPI++) { 5548b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian bool SuperImplementsProtocol = false; 5549b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian ObjCProtocolDecl *LHSProto = (*LHSPI); 5550b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian 5551b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 5552b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian SuperClassInheritedProtocols.begin(), 5553b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian E = SuperClassInheritedProtocols.end(); I != E; ++I) { 5554b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian ObjCProtocolDecl *SuperClassProto = (*I); 5555b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (SuperClassProto->lookupProtocolNamed(LHSProto->getIdentifier())) { 5556b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian SuperImplementsProtocol = true; 5557b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian break; 5558b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5559b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5560b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (!SuperImplementsProtocol) 5561b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return false; 5562b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5563b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return true; 5564b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5565b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return false; 5566b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 55671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5568c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall for (ObjCObjectType::qual_iterator LHSPI = LHS->qual_begin(), 5569c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall LHSPE = LHS->qual_end(); 557091b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff LHSPI != LHSPE; LHSPI++) { 557191b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff bool RHSImplementsProtocol = false; 557291b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff 557391b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // If the RHS doesn't implement the protocol on the left, the types 557491b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // are incompatible. 5575c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall for (ObjCObjectType::qual_iterator RHSPI = RHS->qual_begin(), 5576c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall RHSPE = RHS->qual_end(); 55778f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff RHSPI != RHSPE; RHSPI++) { 55788f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff if ((*RHSPI)->lookupProtocolNamed((*LHSPI)->getIdentifier())) { 557991b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff RHSImplementsProtocol = true; 55808f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff break; 55818f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff } 558291b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff } 558391b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // FIXME: For better diagnostics, consider passing back the protocol name. 558491b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff if (!RHSImplementsProtocol) 558591b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff return false; 558691b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff } 558791b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // The RHS implements all protocols listed on the LHS. 558891b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff return true; 55896ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner} 55906ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner 5591389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroffbool ASTContext::areComparableObjCPointerTypes(QualType LHS, QualType RHS) { 5592389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff // get the "pointed to" types 5593183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const ObjCObjectPointerType *LHSOPT = LHS->getAs<ObjCObjectPointerType>(); 5594183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const ObjCObjectPointerType *RHSOPT = RHS->getAs<ObjCObjectPointerType>(); 55951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 559614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (!LHSOPT || !RHSOPT) 5597389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff return false; 559814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 559914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return canAssignObjCInterfaces(LHSOPT, RHSOPT) || 560014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff canAssignObjCInterfaces(RHSOPT, LHSOPT); 5601389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff} 5602389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff 5603569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregorbool ASTContext::canBindObjCObjectType(QualType To, QualType From) { 5604569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor return canAssignObjCInterfaces( 5605569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor getObjCObjectPointerType(To)->getAs<ObjCObjectPointerType>(), 5606569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor getObjCObjectPointerType(From)->getAs<ObjCObjectPointerType>()); 5607569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor} 5608569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor 56091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible, 5610ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff/// both shall have the identically qualified version of a compatible type. 56111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// C99 6.2.7p1: Two types have compatible types if their types are the 5612ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff/// same. See 6.7.[2,3,5] for additional rules. 5613447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregorbool ASTContext::typesAreCompatible(QualType LHS, QualType RHS, 5614447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool CompareUnqualified) { 56150e709abafbd939326850501f795cc7a92c88a354Douglas Gregor if (getLangOptions().CPlusPlus) 56160e709abafbd939326850501f795cc7a92c88a354Douglas Gregor return hasSameType(LHS, RHS); 56170e709abafbd939326850501f795cc7a92c88a354Douglas Gregor 5618447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor return !mergeTypes(LHS, RHS, false, CompareUnqualified).isNull(); 56193d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman} 56203d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 5621c286f3835eb6001c61664cef5d610dfaf80a6e9bFariborz Jahanianbool ASTContext::propertyTypesAreCompatible(QualType LHS, QualType RHS) { 562282378391dfc3b2fc22f63dbf1552bd9aed39dc42Fariborz Jahanian return typesAreCompatible(LHS, RHS); 5623c286f3835eb6001c61664cef5d610dfaf80a6e9bFariborz Jahanian} 5624c286f3835eb6001c61664cef5d610dfaf80a6e9bFariborz Jahanian 5625132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanianbool ASTContext::typesAreBlockPointerCompatible(QualType LHS, QualType RHS) { 5626132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return !mergeTypes(LHS, RHS, true).isNull(); 5627132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian} 5628132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 56294846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// mergeTransparentUnionType - if T is a transparent union type and a member 56304846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// of T is compatible with SubType, return the merged type, else return 56314846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// QualType() 56324846675e0e42d1802b0ffd8972a45e72aeb3758dPeter CollingbourneQualType ASTContext::mergeTransparentUnionType(QualType T, QualType SubType, 56334846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool OfBlockPointer, 56344846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool Unqualified) { 56354846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (const RecordType *UT = T->getAsUnionType()) { 56364846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne RecordDecl *UD = UT->getDecl(); 56374846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (UD->hasAttr<TransparentUnionAttr>()) { 56384846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne for (RecordDecl::field_iterator it = UD->field_begin(), 56394846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne itend = UD->field_end(); it != itend; ++it) { 5640f91d7572ee7fa6f2926c8e7e816039a1154a59f8Peter Collingbourne QualType ET = it->getType().getUnqualifiedType(); 56414846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType MT = mergeTypes(ET, SubType, OfBlockPointer, Unqualified); 56424846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (!MT.isNull()) 56434846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return MT; 56444846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne } 56454846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne } 56464846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne } 56474846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 56484846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return QualType(); 56494846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne} 56504846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 56514846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// mergeFunctionArgumentTypes - merge two types which appear as function 56524846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// argument types 56534846675e0e42d1802b0ffd8972a45e72aeb3758dPeter CollingbourneQualType ASTContext::mergeFunctionArgumentTypes(QualType lhs, QualType rhs, 56544846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool OfBlockPointer, 56554846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool Unqualified) { 56564846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne // GNU extension: two types are compatible if they appear as a function 56574846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne // argument, one of the types is a transparent union type and the other 56584846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne // type is compatible with a union member 56594846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType lmerge = mergeTransparentUnionType(lhs, rhs, OfBlockPointer, 56604846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne Unqualified); 56614846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (!lmerge.isNull()) 56624846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return lmerge; 56634846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 56644846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType rmerge = mergeTransparentUnionType(rhs, lhs, OfBlockPointer, 56654846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne Unqualified); 56664846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (!rmerge.isNull()) 56674846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return rmerge; 56684846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 56694846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return mergeTypes(lhs, rhs, OfBlockPointer, Unqualified); 56704846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne} 56714846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 5672132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz JahanianQualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs, 5673447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool OfBlockPointer, 5674447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool Unqualified) { 5675183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const FunctionType *lbase = lhs->getAs<FunctionType>(); 5676183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const FunctionType *rbase = rhs->getAs<FunctionType>(); 567772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase); 567872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase); 56793d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman bool allLTypes = true; 56803d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman bool allRTypes = true; 56813d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 56823d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Check return type 5683132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian QualType retType; 5684d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian if (OfBlockPointer) { 5685d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian QualType RHS = rbase->getResultType(); 5686d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian QualType LHS = lbase->getResultType(); 5687d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian bool UnqualifiedResult = Unqualified; 5688d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian if (!UnqualifiedResult) 5689d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian UnqualifiedResult = (!RHS.hasQualifiers() && LHS.hasQualifiers()); 5690a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian retType = mergeTypes(LHS, RHS, true, UnqualifiedResult, true); 5691d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian } 5692132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian else 56938cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall retType = mergeTypes(lbase->getResultType(), rbase->getResultType(), false, 56948cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall Unqualified); 56953d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (retType.isNull()) return QualType(); 5696447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5697447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) 5698447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor retType = retType.getUnqualifiedType(); 5699447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5700447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor CanQualType LRetType = getCanonicalType(lbase->getResultType()); 5701447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor CanQualType RRetType = getCanonicalType(rbase->getResultType()); 5702447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5703447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LRetType = LRetType.getUnqualifiedType(); 5704447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RRetType = RRetType.getUnqualifiedType(); 5705447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 5706447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5707447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (getCanonicalType(retType) != LRetType) 570861710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allLTypes = false; 5709447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (getCanonicalType(retType) != RRetType) 571061710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allRTypes = false; 57118cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 57126a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // FIXME: double check this 57136a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // FIXME: should we error if lbase->getRegParmAttr() != 0 && 57146a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // rbase->getRegParmAttr() != 0 && 57156a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // lbase->getRegParmAttr() != rbase->getRegParmAttr()? 5716264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo lbaseInfo = lbase->getExtInfo(); 5717264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo rbaseInfo = rbase->getExtInfo(); 57188cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 57198cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall // Compatible functions must have compatible calling conventions 57208cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall if (!isSameCallConv(lbaseInfo.getCC(), rbaseInfo.getCC())) 57218cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall return QualType(); 57228cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 57238cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall // Regparm is part of the calling convention. 5724a49218e17bcbb1acde0245773173e2c0c42f4f19Eli Friedman if (lbaseInfo.getHasRegParm() != rbaseInfo.getHasRegParm()) 5725a49218e17bcbb1acde0245773173e2c0c42f4f19Eli Friedman return QualType(); 57268cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall if (lbaseInfo.getRegParm() != rbaseInfo.getRegParm()) 57278cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall return QualType(); 57288cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 5729f85e193739c953358c865005855253af4f68a497John McCall if (lbaseInfo.getProducesResult() != rbaseInfo.getProducesResult()) 5730f85e193739c953358c865005855253af4f68a497John McCall return QualType(); 5731f85e193739c953358c865005855253af4f68a497John McCall 573253c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian // functypes which return are preferred over those that do not. 573353c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian if (lbaseInfo.getNoReturn() && !rbaseInfo.getNoReturn()) 57346a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar allLTypes = false; 573553c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian else if (!lbaseInfo.getNoReturn() && rbaseInfo.getNoReturn()) 57366a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar allRTypes = false; 573753c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian // FIXME: some uses, e.g. conditional exprs, really want this to be 'both'. 573853c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian bool NoReturn = lbaseInfo.getNoReturn() || rbaseInfo.getNoReturn(); 57391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5740f85e193739c953358c865005855253af4f68a497John McCall FunctionType::ExtInfo einfo = lbaseInfo.withNoReturn(NoReturn); 5741e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 57423d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto && rproto) { // two C99 style function prototypes 5743465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl assert(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() && 5744465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl "C++ shouldn't be here"); 57453d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman unsigned lproto_nargs = lproto->getNumArgs(); 57463d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman unsigned rproto_nargs = rproto->getNumArgs(); 57473d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 57483d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Compatible functions must have the same number of arguments 57493d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto_nargs != rproto_nargs) 57503d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 57513d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 57523d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Variadic and non-variadic functions aren't compatible 57533d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto->isVariadic() != rproto->isVariadic()) 57543d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 57553d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 57567fb5e4888221cd36652d078c6b171ac55e7f406dArgyrios Kyrtzidis if (lproto->getTypeQuals() != rproto->getTypeQuals()) 57577fb5e4888221cd36652d078c6b171ac55e7f406dArgyrios Kyrtzidis return QualType(); 57587fb5e4888221cd36652d078c6b171ac55e7f406dArgyrios Kyrtzidis 575978213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (LangOpts.ObjCAutoRefCount && 576078213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian !FunctionTypesMatchOnNSConsumedAttrs(rproto, lproto)) 576178213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return QualType(); 576278213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian 57633d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Check argument compatibility 57645f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 10> types; 57653d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman for (unsigned i = 0; i < lproto_nargs; i++) { 57663d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType largtype = lproto->getArgType(i).getUnqualifiedType(); 57673d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType rargtype = rproto->getArgType(i).getUnqualifiedType(); 57684846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType argtype = mergeFunctionArgumentTypes(largtype, rargtype, 57694846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne OfBlockPointer, 57704846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne Unqualified); 57713d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (argtype.isNull()) return QualType(); 5772447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5773447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) 5774447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor argtype = argtype.getUnqualifiedType(); 5775447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 57763d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman types.push_back(argtype); 5777447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5778447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor largtype = largtype.getUnqualifiedType(); 5779447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor rargtype = rargtype.getUnqualifiedType(); 5780447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 5781447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 578261710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (getCanonicalType(argtype) != getCanonicalType(largtype)) 578361710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allLTypes = false; 578461710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (getCanonicalType(argtype) != getCanonicalType(rargtype)) 578561710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allRTypes = false; 57863d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 578778213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian 57883d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allLTypes) return lhs; 57893d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allRTypes) return rhs; 5790e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 5791e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI = lproto->getExtProtoInfo(); 5792e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall EPI.ExtInfo = einfo; 5793e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall return getFunctionType(retType, types.begin(), types.size(), EPI); 57943d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 57953d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 57963d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto) allRTypes = false; 57973d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (rproto) allLTypes = false; 57983d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 579972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor const FunctionProtoType *proto = lproto ? lproto : rproto; 58003d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (proto) { 5801465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl assert(!proto->hasExceptionSpec() && "C++ shouldn't be here"); 58023d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (proto->isVariadic()) return QualType(); 58033d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Check that the types are compatible with the types that 58043d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // would result from default argument promotions (C99 6.7.5.3p15). 58053d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // The only types actually affected are promotable integer 58063d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // types and floats, which would be passed as a different 58073d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // type depending on whether the prototype is visible. 58083d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman unsigned proto_nargs = proto->getNumArgs(); 58093d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman for (unsigned i = 0; i < proto_nargs; ++i) { 58103d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType argTy = proto->getArgType(i); 5811b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor 5812b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor // Look at the promotion type of enum types, since that is the type used 5813b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor // to pass enum values. 5814b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor if (const EnumType *Enum = argTy->getAs<EnumType>()) 5815b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor argTy = Enum->getDecl()->getPromotionType(); 5816b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor 58173d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (argTy->isPromotableIntegerType() || 58183d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman getCanonicalType(argTy).getUnqualifiedType() == FloatTy) 58193d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 58203d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 58213d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 58223d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allLTypes) return lhs; 58233d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allRTypes) return rhs; 5824e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 5825e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI = proto->getExtProtoInfo(); 5826e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall EPI.ExtInfo = einfo; 58273d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return getFunctionType(retType, proto->arg_type_begin(), 5828e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall proto->getNumArgs(), EPI); 58293d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 58303d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 58313d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allLTypes) return lhs; 58323d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allRTypes) return rhs; 58338cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall return getFunctionNoProtoType(retType, einfo); 58343d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman} 58353d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 5836132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz JahanianQualType ASTContext::mergeTypes(QualType LHS, QualType RHS, 5837447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool OfBlockPointer, 5838a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian bool Unqualified, bool BlockReturnType) { 583943d69750e7f7b26076e7474dec8839bb777b260fBill Wendling // C++ [expr]: If an expression initially has the type "reference to T", the 584043d69750e7f7b26076e7474dec8839bb777b260fBill Wendling // type is adjusted to "T" prior to any further analysis, the expression 584143d69750e7f7b26076e7474dec8839bb777b260fBill Wendling // designates the object or function denoted by the reference, and the 58427c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // expression is an lvalue unless the reference is an rvalue reference and 58437c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // the expression is a function call (possibly inside parentheses). 58440e709abafbd939326850501f795cc7a92c88a354Douglas Gregor assert(!LHS->getAs<ReferenceType>() && "LHS is a reference type?"); 58450e709abafbd939326850501f795cc7a92c88a354Douglas Gregor assert(!RHS->getAs<ReferenceType>() && "RHS is a reference type?"); 5846447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5847447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5848447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHS = LHS.getUnqualifiedType(); 5849447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHS = RHS.getUnqualifiedType(); 5850447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 58510e709abafbd939326850501f795cc7a92c88a354Douglas Gregor 58523d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType LHSCan = getCanonicalType(LHS), 58533d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman RHSCan = getCanonicalType(RHS); 58543d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 5855f3692dc4a47dc48d10cec0415c6e9e39b7a39707Chris Lattner // If two types are identical, they are compatible. 58563d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (LHSCan == RHSCan) 58573d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 58583d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 58590953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If the qualifiers are different, the types aren't compatible... mostly. 5860a4923eb7c4b04d360cb2747641a5e92818edf804Douglas Gregor Qualifiers LQuals = LHSCan.getLocalQualifiers(); 5861a4923eb7c4b04d360cb2747641a5e92818edf804Douglas Gregor Qualifiers RQuals = RHSCan.getLocalQualifiers(); 58620953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (LQuals != RQuals) { 58630953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If any of these qualifiers are different, we have a type 58640953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // mismatch. 58650953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() || 5866f85e193739c953358c865005855253af4f68a497John McCall LQuals.getAddressSpace() != RQuals.getAddressSpace() || 5867f85e193739c953358c865005855253af4f68a497John McCall LQuals.getObjCLifetime() != RQuals.getObjCLifetime()) 58680953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return QualType(); 58690953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 58700953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Exactly one GC qualifier difference is allowed: __strong is 58710953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // okay if the other type has no GC qualifier but is an Objective 58720953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // C object pointer (i.e. implicitly strong by default). We fix 58730953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // this by pretending that the unqualified type was actually 58740953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // qualified __strong. 58750953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers::GC GC_L = LQuals.getObjCGCAttr(); 58760953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers::GC GC_R = RQuals.getObjCGCAttr(); 58770953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements"); 58780953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 58790953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak) 58800953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return QualType(); 58810953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 58820953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (GC_L == Qualifiers::Strong && RHSCan->isObjCObjectPointerType()) { 58830953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return mergeTypes(LHS, getObjCGCQualType(RHS, Qualifiers::Strong)); 58840953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 58850953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (GC_R == Qualifiers::Strong && LHSCan->isObjCObjectPointerType()) { 58860953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return mergeTypes(getObjCGCQualType(LHS, Qualifiers::Strong), RHS); 58870953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 58883d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 58890953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 58900953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 58910953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Okay, qualifiers are equal. 58923d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 5893852d63b806c5cbd730c6b9d696e2e27d02546b49Eli Friedman Type::TypeClass LHSClass = LHSCan->getTypeClass(); 5894852d63b806c5cbd730c6b9d696e2e27d02546b49Eli Friedman Type::TypeClass RHSClass = RHSCan->getTypeClass(); 5895f3692dc4a47dc48d10cec0415c6e9e39b7a39707Chris Lattner 58961adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner // We want to consider the two function types to be the same for these 58971adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner // comparisons, just force one to the other. 58981adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto; 58991adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto; 59004c721d381fb279899337d120edd4a24d405e56b2Eli Friedman 59014c721d381fb279899337d120edd4a24d405e56b2Eli Friedman // Same as above for arrays 5902a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray) 5903a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner LHSClass = Type::ConstantArray; 5904a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray) 5905a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner RHSClass = Type::ConstantArray; 59061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5907c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // ObjCInterfaces are just specialized ObjCObjects. 5908c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject; 5909c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject; 5910c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 5911213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // Canonicalize ExtVector -> Vector. 5912213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (LHSClass == Type::ExtVector) LHSClass = Type::Vector; 5913213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (RHSClass == Type::ExtVector) RHSClass = Type::Vector; 59141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 59154e78fd0a960eaa7e97467f2e8f390f3a57da279bSteve Naroff // If the canonical type classes don't match. 59164e78fd0a960eaa7e97467f2e8f390f3a57da279bSteve Naroff if (LHSClass != RHSClass) { 59171adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner // C99 6.7.2.2p4: Each enumerated type shall be compatible with char, 59181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // a signed integer type, or an unsigned integer type. 5919842aef8d942a880eeb9535d40de31a86838264cbJohn McCall // Compatibility is based on the underlying type, not the promotion 5920842aef8d942a880eeb9535d40de31a86838264cbJohn McCall // type. 5921183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const EnumType* ETy = LHS->getAs<EnumType>()) { 59223d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (ETy->getDecl()->getIntegerType() == RHSCan.getUnqualifiedType()) 59233d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return RHS; 5924bab96968886f4b77083f4e26a28986ddb1e42d67Eli Friedman } 5925183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const EnumType* ETy = RHS->getAs<EnumType>()) { 59263d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (ETy->getDecl()->getIntegerType() == LHSCan.getUnqualifiedType()) 59273d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 5928bab96968886f4b77083f4e26a28986ddb1e42d67Eli Friedman } 59291adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner 59303d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 5931ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff } 59323d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 59334a74678ed6c3dedac05d02b1ee341f1db869f049Steve Naroff // The canonical type classes match. 59341adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner switch (LHSClass) { 593572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define TYPE(Class, Base) 593672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define ABSTRACT_TYPE(Class, Base) 5937ad5e73887052193afda72db8efcb812bd083a4a8John McCall#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class: 593872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 593972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define DEPENDENT_TYPE(Class, Base) case Type::Class: 594072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#include "clang/AST/TypeNodes.def" 5941b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Non-canonical and dependent types shouldn't get here"); 594272564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 59437c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl case Type::LValueReference: 59447c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl case Type::RValueReference: 594572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::MemberPointer: 5946b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("C++ should never be in mergeTypes"); 594772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 5948c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCInterface: 594972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::IncompleteArray: 595072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::VariableArray: 595172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::FunctionProto: 595272564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::ExtVector: 5953b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Types are eliminated above"); 595472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 59551adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::Pointer: 59563d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman { 59573d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Merge two pointer types, while trying to preserve typedef info 59586217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType LHSPointee = LHS->getAs<PointerType>()->getPointeeType(); 59596217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType RHSPointee = RHS->getAs<PointerType>()->getPointeeType(); 5960447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5961447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHSPointee = LHSPointee.getUnqualifiedType(); 5962447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHSPointee = RHSPointee.getUnqualifiedType(); 5963447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 5964447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor QualType ResultType = mergeTypes(LHSPointee, RHSPointee, false, 5965447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor Unqualified); 59663d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (ResultType.isNull()) return QualType(); 596707d258756dc856c6987c394a0972884e6ed46765Eli Friedman if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType)) 596861710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return LHS; 596907d258756dc856c6987c394a0972884e6ed46765Eli Friedman if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType)) 597061710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return RHS; 59713d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return getPointerType(ResultType); 59723d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 5973c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff case Type::BlockPointer: 5974c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff { 5975c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff // Merge two block pointer types, while trying to preserve typedef info 59766217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType LHSPointee = LHS->getAs<BlockPointerType>()->getPointeeType(); 59776217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType RHSPointee = RHS->getAs<BlockPointerType>()->getPointeeType(); 5978447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5979447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHSPointee = LHSPointee.getUnqualifiedType(); 5980447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHSPointee = RHSPointee.getUnqualifiedType(); 5981447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 5982447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor QualType ResultType = mergeTypes(LHSPointee, RHSPointee, OfBlockPointer, 5983447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor Unqualified); 5984c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff if (ResultType.isNull()) return QualType(); 5985c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType)) 5986c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff return LHS; 5987c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType)) 5988c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff return RHS; 5989c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff return getBlockPointerType(ResultType); 5990c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff } 5991b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: 5992b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman { 5993b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // Merge two pointer types, while trying to preserve typedef info 5994b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType LHSValue = LHS->getAs<AtomicType>()->getValueType(); 5995b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType RHSValue = RHS->getAs<AtomicType>()->getValueType(); 5996b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (Unqualified) { 5997b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman LHSValue = LHSValue.getUnqualifiedType(); 5998b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman RHSValue = RHSValue.getUnqualifiedType(); 5999b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 6000b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType ResultType = mergeTypes(LHSValue, RHSValue, false, 6001b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman Unqualified); 6002b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (ResultType.isNull()) return QualType(); 6003b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (getCanonicalType(LHSValue) == getCanonicalType(ResultType)) 6004b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return LHS; 6005b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (getCanonicalType(RHSValue) == getCanonicalType(ResultType)) 6006b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return RHS; 6007b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return getAtomicType(ResultType); 6008b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 60091adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::ConstantArray: 60103d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman { 60113d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const ConstantArrayType* LCAT = getAsConstantArrayType(LHS); 60123d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const ConstantArrayType* RCAT = getAsConstantArrayType(RHS); 60133d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (LCAT && RCAT && RCAT->getSize() != LCAT->getSize()) 60143d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 60153d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 60163d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType LHSElem = getAsArrayType(LHS)->getElementType(); 60173d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType RHSElem = getAsArrayType(RHS)->getElementType(); 6018447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 6019447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHSElem = LHSElem.getUnqualifiedType(); 6020447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHSElem = RHSElem.getUnqualifiedType(); 6021447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 6022447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 6023447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor QualType ResultType = mergeTypes(LHSElem, RHSElem, false, Unqualified); 60243d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (ResultType.isNull()) return QualType(); 602561710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (LCAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType)) 602661710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return LHS; 602761710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (RCAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType)) 602861710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return RHS; 60293bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (LCAT) return getConstantArrayType(ResultType, LCAT->getSize(), 60303bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman ArrayType::ArraySizeModifier(), 0); 60313bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (RCAT) return getConstantArrayType(ResultType, RCAT->getSize(), 60323bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman ArrayType::ArraySizeModifier(), 0); 60333d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const VariableArrayType* LVAT = getAsVariableArrayType(LHS); 60343d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const VariableArrayType* RVAT = getAsVariableArrayType(RHS); 603561710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (LVAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType)) 603661710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return LHS; 603761710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (RVAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType)) 603861710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return RHS; 60393d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (LVAT) { 60403d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // FIXME: This isn't correct! But tricky to implement because 60413d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // the array's size has to be the size of LHS, but the type 60423d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // has to be different. 60433d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 60443d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 60453d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (RVAT) { 60463d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // FIXME: This isn't correct! But tricky to implement because 60473d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // the array's size has to be the size of RHS, but the type 60483d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // has to be different. 60493d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return RHS; 60503d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 60513bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (getCanonicalType(LHSElem) == getCanonicalType(ResultType)) return LHS; 60523bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (getCanonicalType(RHSElem) == getCanonicalType(ResultType)) return RHS; 60537e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor return getIncompleteArrayType(ResultType, 60547e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor ArrayType::ArraySizeModifier(), 0); 60553d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 60561adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::FunctionNoProto: 6057447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor return mergeFunctionTypes(LHS, RHS, OfBlockPointer, Unqualified); 605872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Record: 605972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Enum: 60603d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 60611adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::Builtin: 60623cc4c0c3058a788689b8fc73c0ac139544435c97Chris Lattner // Only exactly equal builtin types are compatible, which is tested above. 60633d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 606464cfdb7da3cb744642fe8a99ad5c851ad3c930b2Daniel Dunbar case Type::Complex: 606564cfdb7da3cb744642fe8a99ad5c851ad3c930b2Daniel Dunbar // Distinct complex types are incompatible. 606664cfdb7da3cb744642fe8a99ad5c851ad3c930b2Daniel Dunbar return QualType(); 60673cc4c0c3058a788689b8fc73c0ac139544435c97Chris Lattner case Type::Vector: 60685a61f0e5c5aaecd5713c3fa4b78be7167a7eeff2Eli Friedman // FIXME: The merged type should be an ExtVector! 60691c471f3e1c0ec8cbc82447bb35908dfc55463e46John McCall if (areCompatVectorTypes(LHSCan->getAs<VectorType>(), 60701c471f3e1c0ec8cbc82447bb35908dfc55463e46John McCall RHSCan->getAs<VectorType>())) 60713d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 607261710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return QualType(); 6073c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCObject: { 6074c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Check if the types are assignment compatible. 60755a61f0e5c5aaecd5713c3fa4b78be7167a7eeff2Eli Friedman // FIXME: This should be type compatibility, e.g. whether 60765a61f0e5c5aaecd5713c3fa4b78be7167a7eeff2Eli Friedman // "LHS x; RHS x;" at global scope is legal. 6077c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* LHSIface = LHS->getAs<ObjCObjectType>(); 6078c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* RHSIface = RHS->getAs<ObjCObjectType>(); 6079c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (canAssignObjCInterfaces(LHSIface, RHSIface)) 60805fd659db11922fc12a58e478f7b745f9656b15a7Steve Naroff return LHS; 60815fd659db11922fc12a58e478f7b745f9656b15a7Steve Naroff 60823d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 608361490e9a965cfee8a78c12c6802138844f04250dCedric Venet } 608414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff case Type::ObjCObjectPointer: { 6085132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (OfBlockPointer) { 6086132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (canAssignObjCInterfacesInBlockPointer( 6087132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian LHS->getAs<ObjCObjectPointerType>(), 6088a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian RHS->getAs<ObjCObjectPointerType>(), 6089a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian BlockReturnType)) 6090132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return LHS; 6091132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return QualType(); 6092132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 6093183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (canAssignObjCInterfaces(LHS->getAs<ObjCObjectPointerType>(), 6094183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall RHS->getAs<ObjCObjectPointerType>())) 609514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return LHS; 609614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 6097bc76dd06eb881c70c9775b74bab8b88cd747f173Steve Naroff return QualType(); 6098132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 6099ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff } 610072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 610172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor return QualType(); 6102ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff} 61037192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek 610478213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanianbool ASTContext::FunctionTypesMatchOnNSConsumedAttrs( 610578213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian const FunctionProtoType *FromFunctionType, 610678213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian const FunctionProtoType *ToFunctionType) { 610778213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (FromFunctionType->hasAnyConsumedArgs() != 610878213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ToFunctionType->hasAnyConsumedArgs()) 610978213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return false; 611078213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian FunctionProtoType::ExtProtoInfo FromEPI = 611178213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian FromFunctionType->getExtProtoInfo(); 611278213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian FunctionProtoType::ExtProtoInfo ToEPI = 611378213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ToFunctionType->getExtProtoInfo(); 611478213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (FromEPI.ConsumedArguments && ToEPI.ConsumedArguments) 611578213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumArgs(); 611678213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ArgIdx != NumArgs; ++ArgIdx) { 611778213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (FromEPI.ConsumedArguments[ArgIdx] != 611878213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ToEPI.ConsumedArguments[ArgIdx]) 611978213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return false; 612078213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian } 612178213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return true; 612278213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian} 612378213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian 61242390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian/// mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and 61252390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian/// 'RHS' attributes and returns the merged version; including for function 61262390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian/// return types. 61272390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz JahanianQualType ASTContext::mergeObjCGCQualifiers(QualType LHS, QualType RHS) { 61282390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType LHSCan = getCanonicalType(LHS), 61292390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian RHSCan = getCanonicalType(RHS); 61302390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // If two types are identical, they are compatible. 61312390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LHSCan == RHSCan) 61322390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return LHS; 61332390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (RHSCan->isFunctionType()) { 61342390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (!LHSCan->isFunctionType()) 61352390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61362390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType OldReturnType = 61372390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian cast<FunctionType>(RHSCan.getTypePtr())->getResultType(); 61382390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType NewReturnType = 61392390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian cast<FunctionType>(LHSCan.getTypePtr())->getResultType(); 61402390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType ResReturnType = 61412390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian mergeObjCGCQualifiers(NewReturnType, OldReturnType); 61422390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResReturnType.isNull()) 61432390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61442390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResReturnType == NewReturnType || ResReturnType == OldReturnType) { 61452390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // id foo(); ... __strong id foo(); or: __strong id foo(); ... id foo(); 61462390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // In either case, use OldReturnType to build the new function type. 61472390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian const FunctionType *F = LHS->getAs<FunctionType>(); 61482390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (const FunctionProtoType *FPT = cast<FunctionProtoType>(F)) { 6149e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 6150e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall EPI.ExtInfo = getFunctionExtInfo(LHS); 61512390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType ResultType 61522390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian = getFunctionType(OldReturnType, FPT->arg_type_begin(), 6153e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FPT->getNumArgs(), EPI); 61542390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return ResultType; 61552390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 61562390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 61572390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61582390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 61592390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 61602390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // If the qualifiers are different, the types can still be merged. 61612390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers LQuals = LHSCan.getLocalQualifiers(); 61622390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers RQuals = RHSCan.getLocalQualifiers(); 61632390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LQuals != RQuals) { 61642390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // If any of these qualifiers are different, we have a type mismatch. 61652390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() || 61662390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian LQuals.getAddressSpace() != RQuals.getAddressSpace()) 61672390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61682390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 61692390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // Exactly one GC qualifier difference is allowed: __strong is 61702390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // okay if the other type has no GC qualifier but is an Objective 61712390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // C object pointer (i.e. implicitly strong by default). We fix 61722390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // this by pretending that the unqualified type was actually 61732390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // qualified __strong. 61742390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers::GC GC_L = LQuals.getObjCGCAttr(); 61752390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers::GC GC_R = RQuals.getObjCGCAttr(); 61762390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements"); 61772390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 61782390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak) 61792390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61802390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 61812390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (GC_L == Qualifiers::Strong) 61822390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return LHS; 61832390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (GC_R == Qualifiers::Strong) 61842390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return RHS; 61852390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61862390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 61872390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 61882390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LHSCan->isObjCObjectPointerType() && RHSCan->isObjCObjectPointerType()) { 61892390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType LHSBaseQT = LHS->getAs<ObjCObjectPointerType>()->getPointeeType(); 61902390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType RHSBaseQT = RHS->getAs<ObjCObjectPointerType>()->getPointeeType(); 61912390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType ResQT = mergeObjCGCQualifiers(LHSBaseQT, RHSBaseQT); 61922390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResQT == LHSBaseQT) 61932390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return LHS; 61942390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResQT == RHSBaseQT) 61952390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return RHS; 61962390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 61972390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61982390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian} 61992390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 62005426bf6456a5aeac416a9150de157904d101c819Chris Lattner//===----------------------------------------------------------------------===// 6201ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman// Integer Predicates 6202ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman//===----------------------------------------------------------------------===// 620388054dee0402e4d3c1f64e6b697acc47195c0d72Chris Lattner 62044ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadunsigned ASTContext::getIntWidth(QualType T) const { 6205f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall if (const EnumType *ET = dyn_cast<EnumType>(T)) 620629a7f3342c3c6dd15d914c61ae22246c36d51ce7Eli Friedman T = ET->getDecl()->getIntegerType(); 62071274ccd90aec0b205fc838c3d504821ccfb55482Douglas Gregor if (T->isBooleanType()) 62081274ccd90aec0b205fc838c3d504821ccfb55482Douglas Gregor return 1; 6209f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman // For builtin types, just use the standard type sizing method 6210ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return (unsigned)getTypeSize(T); 6211ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman} 6212ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman 6213ad74a758189180b8ab8faea648e4766c3bfd7fcbEli FriedmanQualType ASTContext::getCorrespondingUnsignedType(QualType T) { 6214f60946222721d9ba3c059563935c17b84703187aDouglas Gregor assert(T->hasSignedIntegerRepresentation() && "Unexpected type"); 62156a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner 62166a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner // Turn <4 x signed int> -> <4 x unsigned int> 62176a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner if (const VectorType *VTy = T->getAs<VectorType>()) 62186a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner return getVectorType(getCorrespondingUnsignedType(VTy->getElementType()), 6219e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VTy->getNumElements(), VTy->getVectorKind()); 62206a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner 62216a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner // For enums, we return the unsigned version of the base type. 62226a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner if (const EnumType *ETy = T->getAs<EnumType>()) 6223ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman T = ETy->getDecl()->getIntegerType(); 62246a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner 62256a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner const BuiltinType *BTy = T->getAs<BuiltinType>(); 62266a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner assert(BTy && "Unexpected signed integer type"); 6227ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman switch (BTy->getKind()) { 6228ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Char_S: 6229ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::SChar: 6230ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedCharTy; 6231ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Short: 6232ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedShortTy; 6233ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Int: 6234ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedIntTy; 6235ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Long: 6236ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedLongTy; 6237ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::LongLong: 6238ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedLongLongTy; 62392df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::Int128: 62402df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner return UnsignedInt128Ty; 6241ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman default: 6242b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unexpected signed integer type"); 6243ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman } 6244ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman} 6245ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman 62467b90340c9c7d07aef4e301e72b5e8a30d5f4f0c8Argyrios KyrtzidisASTMutationListener::~ASTMutationListener() { } 62477b90340c9c7d07aef4e301e72b5e8a30d5f4f0c8Argyrios Kyrtzidis 624886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 624986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner//===----------------------------------------------------------------------===// 625086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner// Builtin Type Computation 625186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner//===----------------------------------------------------------------------===// 625286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 625386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner/// DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the 625433daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// pointer over the consumed characters. This returns the resultant type. If 625533daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// AllowTypeModifiers is false then modifier like * are not parsed, just basic 625633daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// types. This allows "v2i*" to be parsed as a pointer to a v2i instead of 625733daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// a vector of "i*". 625814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner/// 625914e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner/// RequiresICE is filled in on return to indicate whether the value is required 626014e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner/// to be an Integer Constant Expression. 62614ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadstatic QualType DecodeTypeFromStr(const char *&Str, const ASTContext &Context, 626286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner ASTContext::GetBuiltinTypeError &Error, 626314e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner bool &RequiresICE, 626433daae66462e8f51ee153463b32bdefd60c801aaChris Lattner bool AllowTypeModifiers) { 626586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // Modifiers. 626686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner int HowLong = 0; 626786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner bool Signed = false, Unsigned = false; 626814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE = false; 6269393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner 627033daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // Read the prefixed modifiers first. 627186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner bool Done = false; 627286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner while (!Done) { 627386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner switch (*Str++) { 62741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump default: Done = true; --Str; break; 6275393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner case 'I': 627614e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE = true; 6277393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner break; 627886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'S': 627986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Unsigned && "Can't use both 'S' and 'U' modifiers!"); 628086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Signed && "Can't use 'S' modifier multiple times!"); 628186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Signed = true; 628286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 628386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'U': 628486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Signed && "Can't use both 'S' and 'U' modifiers!"); 628586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Unsigned && "Can't use 'S' modifier multiple times!"); 628686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Unsigned = true; 628786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 628886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'L': 628986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong <= 2 && "Can't have LLLL modifier"); 629086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner ++HowLong; 629186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 629286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 629386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 629486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 629586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner QualType Type; 62961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 629786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // Read the base type. 629886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner switch (*Str++) { 6299b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Unknown builtin type letter!"); 630086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'v': 630186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && 630286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "Bad modifiers used with 'v'!"); 630386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.VoidTy; 630486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 630586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'f': 630686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && 630786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "Bad modifiers used with 'f'!"); 630886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.FloatTy; 630986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 631086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'd': 631186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong < 2 && !Signed && !Unsigned && 631286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "Bad modifiers used with 'd'!"); 631386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (HowLong) 631486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.LongDoubleTy; 631586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 631686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.DoubleTy; 631786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 631886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 's': 631986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && "Bad modifiers used with 's'!"); 632086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Unsigned) 632186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.UnsignedShortTy; 632286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 632386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.ShortTy; 632486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 632586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'i': 632686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (HowLong == 3) 632786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty; 632886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else if (HowLong == 2) 632986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy; 633086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else if (HowLong == 1) 633186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedLongTy : Context.LongTy; 633286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 633386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedIntTy : Context.IntTy; 633486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 633586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'c': 633686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && "Bad modifiers used with 'c'!"); 633786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Signed) 633886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.SignedCharTy; 633986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else if (Unsigned) 634086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.UnsignedCharTy; 634186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 634286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.CharTy; 634386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 634486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'b': // boolean 634586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'b'!"); 634686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.BoolTy; 634786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 634886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'z': // size_t. 634986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'z'!"); 635086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getSizeType(); 635186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 635286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'F': 635386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getCFConstantStringType(); 635486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 6355ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian case 'G': 6356ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian Type = Context.getObjCIdType(); 6357ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian break; 6358ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian case 'H': 6359ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian Type = Context.getObjCSelType(); 6360ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian break; 636186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'a': 636286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getBuiltinVaListType(); 636386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Type.isNull() && "builtin va list type not initialized!"); 636486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 636586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'A': 636686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // This is a "reference" to a va_list; however, what exactly 636786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // this means depends on how va_list is defined. There are two 636886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // different kinds of va_list: ones passed by value, and ones 636986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // passed by reference. An example of a by-value va_list is 637086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // x86, where va_list is a char*. An example of by-ref va_list 637186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // is x86-64, where va_list is a __va_list_tag[1]. For x86, 637286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // we want this argument to be a char*&; for x86-64, we want 637386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // it to be a __va_list_tag*. 637486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getBuiltinVaListType(); 637586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Type.isNull() && "builtin va list type not initialized!"); 637614e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner if (Type->isArrayType()) 637786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getArrayDecayedType(Type); 637814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner else 637986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getLValueReferenceType(Type); 638086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 638186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'V': { 638286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner char *End; 638386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner unsigned NumElements = strtoul(Str, &End, 10); 638486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(End != Str && "Missing vector size"); 638586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Str = End; 63861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 638714e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType ElementType = DecodeTypeFromStr(Str, Context, Error, 638814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE, false); 638914e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert(!RequiresICE && "Can't require vector ICE"); 639033daae66462e8f51ee153463b32bdefd60c801aaChris Lattner 639133daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // TODO: No way to make AltiVec vectors in builtins yet. 6392788b0fd67e1992f23555454efcdb16a19dfefac3Chris Lattner Type = Context.getVectorType(ElementType, NumElements, 6393e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType::GenericVector); 639486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 639586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 6396d3a23b238a2b2c0f11e6ac4951c7410a8c5717bfDouglas Gregor case 'X': { 639714e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE, 639814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner false); 639914e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert(!RequiresICE && "Can't require complex ICE"); 6400d3a23b238a2b2c0f11e6ac4951c7410a8c5717bfDouglas Gregor Type = Context.getComplexType(ElementType); 6401d3a23b238a2b2c0f11e6ac4951c7410a8c5717bfDouglas Gregor break; 6402cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian } 6403cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian case 'Y' : { 6404cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian Type = Context.getPointerDiffType(); 6405cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian break; 6406cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian } 64079a5a7e7351f78345a72c4956af25590f6d40ebcdChris Lattner case 'P': 6408c29f77b769bcc5b6dc85e72c8e3cc2e348e5cf25Douglas Gregor Type = Context.getFILEType(); 6409c29f77b769bcc5b6dc85e72c8e3cc2e348e5cf25Douglas Gregor if (Type.isNull()) { 6410f711c41dd9412a8182793259d355c4f6979ed5edMike Stump Error = ASTContext::GE_Missing_stdio; 641186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return QualType(); 641286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 6413fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump break; 64149a5a7e7351f78345a72c4956af25590f6d40ebcdChris Lattner case 'J': 6415f711c41dd9412a8182793259d355c4f6979ed5edMike Stump if (Signed) 6416782fa308a765aeac2acb39c4e697c937ec21185bMike Stump Type = Context.getsigjmp_bufType(); 6417f711c41dd9412a8182793259d355c4f6979ed5edMike Stump else 6418f711c41dd9412a8182793259d355c4f6979ed5edMike Stump Type = Context.getjmp_bufType(); 6419f711c41dd9412a8182793259d355c4f6979ed5edMike Stump 6420fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump if (Type.isNull()) { 6421f711c41dd9412a8182793259d355c4f6979ed5edMike Stump Error = ASTContext::GE_Missing_setjmp; 6422fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump return QualType(); 6423fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump } 6424fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump break; 6425e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola case 'K': 6426e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'K'!"); 6427e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola Type = Context.getucontext_tType(); 6428e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola 6429e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola if (Type.isNull()) { 6430e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola Error = ASTContext::GE_Missing_ucontext; 6431e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola return QualType(); 6432e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola } 6433e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola break; 6434782fa308a765aeac2acb39c4e697c937ec21185bMike Stump } 64351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 643633daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // If there are modifiers and if we're allowed to parse them, go for it. 643733daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Done = !AllowTypeModifiers; 643886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner while (!Done) { 6439187ab37a05b8f7015b9f39cc8cd9129a0c6d0b48John McCall switch (char c = *Str++) { 644033daae66462e8f51ee153463b32bdefd60c801aaChris Lattner default: Done = true; --Str; break; 644133daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case '*': 644233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case '&': { 644333daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // Both pointers and references can have their pointee types 644433daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // qualified with an address space. 644533daae66462e8f51ee153463b32bdefd60c801aaChris Lattner char *End; 644633daae66462e8f51ee153463b32bdefd60c801aaChris Lattner unsigned AddrSpace = strtoul(Str, &End, 10); 644733daae66462e8f51ee153463b32bdefd60c801aaChris Lattner if (End != Str && AddrSpace != 0) { 644833daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getAddrSpaceQualType(Type, AddrSpace); 644933daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Str = End; 645033daae66462e8f51ee153463b32bdefd60c801aaChris Lattner } 645133daae66462e8f51ee153463b32bdefd60c801aaChris Lattner if (c == '*') 645233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getPointerType(Type); 645333daae66462e8f51ee153463b32bdefd60c801aaChris Lattner else 645433daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getLValueReferenceType(Type); 645533daae66462e8f51ee153463b32bdefd60c801aaChris Lattner break; 645633daae66462e8f51ee153463b32bdefd60c801aaChris Lattner } 645733daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // FIXME: There's no way to have a built-in with an rvalue ref arg. 645833daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case 'C': 645933daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Type.withConst(); 646033daae66462e8f51ee153463b32bdefd60c801aaChris Lattner break; 646133daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case 'D': 646233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getVolatileType(Type); 646333daae66462e8f51ee153463b32bdefd60c801aaChris Lattner break; 646486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 646586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 6466393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner 646714e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert((!RequiresICE || Type->isIntegralOrEnumerationType()) && 6468393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner "Integer constant 'I' type must be an integer"); 64691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 647086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return Type; 647186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner} 647286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 647386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner/// GetBuiltinType - Return the type for the specified builtin. 647433daae66462e8f51ee153463b32bdefd60c801aaChris LattnerQualType ASTContext::GetBuiltinType(unsigned Id, 647514e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner GetBuiltinTypeError &Error, 64764ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned *IntegerConstantArgs) const { 647733daae66462e8f51ee153463b32bdefd60c801aaChris Lattner const char *TypeStr = BuiltinInfo.GetTypeString(Id); 64781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 64795f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 8> ArgTypes; 64801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 648114e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner bool RequiresICE = false; 648286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Error = GE_None; 648314e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType ResType = DecodeTypeFromStr(TypeStr, *this, Error, 648414e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE, true); 648586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Error != GE_None) 648686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return QualType(); 648714e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner 648814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert(!RequiresICE && "Result of intrinsic cannot be required to be an ICE"); 648914e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner 649086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner while (TypeStr[0] && TypeStr[0] != '.') { 649114e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType Ty = DecodeTypeFromStr(TypeStr, *this, Error, RequiresICE, true); 649286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Error != GE_None) 649386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return QualType(); 649486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 649514e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner // If this argument is required to be an IntegerConstantExpression and the 649614e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner // caller cares, fill in the bitmask we return. 649714e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner if (RequiresICE && IntegerConstantArgs) 649814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner *IntegerConstantArgs |= 1 << ArgTypes.size(); 649914e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner 650086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // Do array -> pointer decay. The builtin should use the decayed type. 650186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Ty->isArrayType()) 650286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Ty = getArrayDecayedType(Ty); 65031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 650486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner ArgTypes.push_back(Ty); 650586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 650686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 650786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert((TypeStr[0] != '.' || TypeStr[1] == 0) && 650886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "'.' should only occur at end of builtin type list!"); 650986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 651000ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall FunctionType::ExtInfo EI; 651100ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall if (BuiltinInfo.isNoReturn(Id)) EI = EI.withNoReturn(true); 651200ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall 651300ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall bool Variadic = (TypeStr[0] == '.'); 651400ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall 651500ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall // We really shouldn't be making a no-proto type here, especially in C++. 651600ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall if (ArgTypes.empty() && Variadic) 651700ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall return getFunctionNoProtoType(ResType, EI); 6518ce056bcaa1c97b89a4b2de2112c62d060863be2bDouglas Gregor 6519e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI; 652000ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall EPI.ExtInfo = EI; 652100ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall EPI.Variadic = Variadic; 6522e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 6523e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall return getFunctionType(ResType, ArgTypes.data(), ArgTypes.size(), EPI); 652486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner} 6525a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman 652690e99a84ddd020e8fda79643748243725a2ed071Argyrios KyrtzidisGVALinkage ASTContext::GetGVALinkageForFunction(const FunctionDecl *FD) { 652790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis GVALinkage External = GVA_StrongExternal; 652890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 652990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis Linkage L = FD->getLinkage(); 653090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (L) { 653190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case NoLinkage: 653290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case InternalLinkage: 653390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case UniqueExternalLinkage: 653490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_Internal; 653590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 653690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case ExternalLinkage: 653790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (FD->getTemplateSpecializationKind()) { 653890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_Undeclared: 653990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitSpecialization: 654090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis External = GVA_StrongExternal; 654190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis break; 654290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 654390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDefinition: 654490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_ExplicitTemplateInstantiation; 654590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 654690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDeclaration: 654790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ImplicitInstantiation: 654890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis External = GVA_TemplateInstantiation; 654990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis break; 655090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 655190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 655290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 655390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (!FD->isInlined()) 655490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return External; 655590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 655690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (!getLangOptions().CPlusPlus || FD->hasAttr<GNUInlineAttr>()) { 655790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // GNU or C99 inline semantics. Determine whether this symbol should be 655890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // externally visible. 655990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (FD->isInlineDefinitionExternallyVisible()) 656090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return External; 656190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 656290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // C99 inline semantics, where the symbol is not externally visible. 656390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_C99Inline; 656490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 656590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 656690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // C++0x [temp.explicit]p9: 656790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // [ Note: The intent is that an inline function that is the subject of 656890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // an explicit instantiation declaration will still be implicitly 656990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // instantiated when used so that the body can be considered for 657090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // inlining, but that no out-of-line copy of the inline function would be 657190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // generated in the translation unit. -- end note ] 657290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (FD->getTemplateSpecializationKind() 657390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis == TSK_ExplicitInstantiationDeclaration) 657490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_C99Inline; 657590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 657690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_CXXInline; 657790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis} 657890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 657990e99a84ddd020e8fda79643748243725a2ed071Argyrios KyrtzidisGVALinkage ASTContext::GetGVALinkageForVariable(const VarDecl *VD) { 658090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // If this is a static data member, compute the kind of template 658190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // specialization. Otherwise, this variable is not part of a 658290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // template. 658390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis TemplateSpecializationKind TSK = TSK_Undeclared; 658490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (VD->isStaticDataMember()) 658590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis TSK = VD->getTemplateSpecializationKind(); 658690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 658790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis Linkage L = VD->getLinkage(); 658890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (L == ExternalLinkage && getLangOptions().CPlusPlus && 658990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis VD->getType()->getLinkage() == UniqueExternalLinkage) 659090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis L = UniqueExternalLinkage; 659190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 659290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (L) { 659390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case NoLinkage: 659490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case InternalLinkage: 659590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case UniqueExternalLinkage: 659690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_Internal; 659790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 659890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case ExternalLinkage: 659990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (TSK) { 660090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_Undeclared: 660190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitSpecialization: 660290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_StrongExternal; 660390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 660490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDeclaration: 660590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis llvm_unreachable("Variable should not be instantiated"); 660690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Fall through to treat this like any other instantiation. 660790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 660890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDefinition: 660990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_ExplicitTemplateInstantiation; 661090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 661190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ImplicitInstantiation: 661290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_TemplateInstantiation; 661390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 661490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 661590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 661690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_StrongExternal; 661790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis} 661890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 66194ac7c0bb39696e92fd220118fedc484c09a69870Argyrios Kyrtzidisbool ASTContext::DeclMustBeEmitted(const Decl *D) { 662090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 662190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (!VD->isFileVarDecl()) 662290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 6623144b38a7995cbe0928e34fbcc865bb2d2be4f7a3Argyrios Kyrtzidis } else if (!isa<FunctionDecl>(D)) 662490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 662590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 6626ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis // Weak references don't produce any output by themselves. 6627ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis if (D->hasAttr<WeakRefAttr>()) 6628ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis return false; 6629ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis 663090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Aliases and used decls are required. 663190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (D->hasAttr<AliasAttr>() || D->hasAttr<UsedAttr>()) 663290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 663390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 663490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 663590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Forward declarations aren't required. 663610620eb5164e31208fcbf0437cd79ae535ed0559Sean Hunt if (!FD->doesThisDeclarationHaveABody()) 6637dce67a70a86db8758c926a76fdd980f5369d5746Nick Lewycky return FD->doesDeclarationForceExternallyVisibleDefinition(); 663890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 663990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Constructors and destructors are required. 664090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (FD->hasAttr<ConstructorAttr>() || FD->hasAttr<DestructorAttr>()) 664190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 664290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 664390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // The key function for a class is required. 664490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 664590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis const CXXRecordDecl *RD = MD->getParent(); 664690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (MD->isOutOfLine() && RD->isDynamicClass()) { 664790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis const CXXMethodDecl *KeyFunc = getKeyFunction(RD); 664890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (KeyFunc && KeyFunc->getCanonicalDecl() == MD->getCanonicalDecl()) 664990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 665090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 665190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 665290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 665390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis GVALinkage Linkage = GetGVALinkageForFunction(FD); 665490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 665590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // static, static inline, always_inline, and extern inline functions can 665690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // always be deferred. Normal inline functions can be deferred in C99/C++. 665790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Implicit template instantiations can also be deferred in C++. 665890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (Linkage == GVA_Internal || Linkage == GVA_C99Inline || 665990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) 666090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 666190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 666290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 666394da1587f7d584fc61df793229d197969f204cd9Douglas Gregor 666490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis const VarDecl *VD = cast<VarDecl>(D); 666590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis assert(VD->isFileVarDecl() && "Expected file scoped var"); 666690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 6667ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly) 6668ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis return false; 6669ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis 667090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Structs that have non-trivial constructors or destructors are required. 667190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 667290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // FIXME: Handle references. 6673023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt // FIXME: Be more selective about which constructors we care about. 667490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const RecordType *RT = VD->getType()->getAs<RecordType>()) { 667590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 6676023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt if (RD->hasDefinition() && !(RD->hasTrivialDefaultConstructor() && 6677023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt RD->hasTrivialCopyConstructor() && 6678023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt RD->hasTrivialMoveConstructor() && 6679023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt RD->hasTrivialDestructor())) 668090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 668190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 668290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 668390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 668490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis GVALinkage L = GetGVALinkageForVariable(VD); 668590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (L == GVA_Internal || L == GVA_TemplateInstantiation) { 668690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (!(VD->getInit() && VD->getInit()->HasSideEffects(*this))) 668790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 668890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 668990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 669090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 669190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis} 6692071cc7deffad608165b1ddd5263e8bf181861520Charles Davis 6693ee743f903858e337434ac0335f147f4de4ecae05Charles DavisCallingConv ASTContext::getDefaultMethodCallConv() { 6694ee743f903858e337434ac0335f147f4de4ecae05Charles Davis // Pass through to the C++ ABI object 6695ee743f903858e337434ac0335f147f4de4ecae05Charles Davis return ABI->getDefaultMethodCallConv(); 6696ee743f903858e337434ac0335f147f4de4ecae05Charles Davis} 6697ee743f903858e337434ac0335f147f4de4ecae05Charles Davis 66984ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadbool ASTContext::isNearlyEmpty(const CXXRecordDecl *RD) const { 6699dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson // Pass through to the C++ ABI object 6700dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson return ABI->isNearlyEmpty(RD); 6701dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson} 6702dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson 670314110477887e3dc168ffc6c191e72d705051f99ePeter CollingbourneMangleContext *ASTContext::createMangleContext() { 6704bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor switch (Target->getCXXABI()) { 670514110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne case CXXABI_ARM: 670614110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne case CXXABI_Itanium: 670714110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne return createItaniumMangleContext(*this, getDiagnostics()); 670814110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne case CXXABI_Microsoft: 670914110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne return createMicrosoftMangleContext(*this, getDiagnostics()); 671014110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne } 6711b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unsupported ABI"); 671214110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne} 671314110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne 6714071cc7deffad608165b1ddd5263e8bf181861520Charles DavisCXXABI::~CXXABI() {} 6715ba29bd25515fbd99e98ba0fedb9d93617b27609eTed Kremenek 6716ba29bd25515fbd99e98ba0fedb9d93617b27609eTed Kremeneksize_t ASTContext::getSideTableAllocatedMemory() const { 67170c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek return ASTRecordLayouts.getMemorySize() 67180c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(ObjCLayouts) 67190c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(KeyFunctions) 67200c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(ObjCImpls) 67210c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(BlockVarCopyInits) 67220c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(DeclAttrs) 67230c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromStaticDataMember) 67240c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromUsingDecl) 67250c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromUsingShadowDecl) 67260c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromUnnamedFieldDecl) 67270c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(OverriddenMethods) 67280c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(Types) 6729af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet + llvm::capacity_in_bytes(VariableArrayTypes) 67300d95f0d7b81110f77e99e833f766d19be7b7e072Francois Pichet + llvm::capacity_in_bytes(ClassScopeSpecializationPattern); 6731ba29bd25515fbd99e98ba0fedb9d93617b27609eTed Kremenek} 6732d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek 6733d211cb709510fbe7e75167b9feee0050851d001aTed Kremenekvoid ASTContext::setParameterIndex(const ParmVarDecl *D, unsigned int index) { 6734d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek ParamIndices[D] = index; 6735d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek} 6736d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek 6737d211cb709510fbe7e75167b9feee0050851d001aTed Kremenekunsigned ASTContext::getParameterIndex(const ParmVarDecl *D) const { 6738d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek ParameterIndexTable::const_iterator I = ParamIndices.find(D); 6739d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek assert(I != ParamIndices.end() && 6740d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek "ParmIndices lacks entry set by ParmVarDecl"); 6741d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek return I->second; 6742d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek} 6743