ASTContext.cpp revision eefb3d5b49c844347f212073a7e975b8118fe8e9
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 } 1967530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie llvm_unreachable("Invalid CXXABI type!"); 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), 227a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor ObjCIdDecl(0), ObjCSelDecl(0), ObjCClassDecl(0), ObjCProtocolClassDecl(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 2956f42b62b6194f53bcbc349f5d17388e1936535d7Dylan NoblesmithASTContext::setExternalSource(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 8375d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner case Type::FunctionNoProto: 8385d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner case Type::FunctionProto: 83918857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor // GCC extension: alignof(function) = 32 bits 84018857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Width = 0; 84118857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Align = 32; 84218857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor break; 84318857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 84472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::IncompleteArray: 845fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case Type::VariableArray: 84618857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Width = 0; 84718857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Align = getTypeAlign(cast<ArrayType>(T)->getElementType()); 84818857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor break; 84918857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 850fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case Type::ConstantArray: { 8511d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const ConstantArrayType *CAT = cast<ConstantArrayType>(T); 8521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 85398be4943e8dc4f3905629a7102668960873cf863Chris Lattner std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(CAT->getElementType()); 854fea966a4103ed9c018d1494b95e9d09b161f5a70Abramo Bagnara uint64_t Size = CAT->getSize().getZExtValue(); 855fea966a4103ed9c018d1494b95e9d09b161f5a70Abramo Bagnara assert((Size == 0 || EltInfo.first <= (uint64_t)(-1)/Size) && "Overflow in array type bit size evaluation"); 856fea966a4103ed9c018d1494b95e9d09b161f5a70Abramo Bagnara Width = EltInfo.first*Size; 857030d8846c7e520330007087e949f621989876e3aChris Lattner Align = EltInfo.second; 858cd88b4171753dcb2bc0a21d78f1597c796bb8a20Argyrios Kyrtzidis Width = llvm::RoundUpToAlignment(Width, Align); 859030d8846c7e520330007087e949f621989876e3aChris Lattner break; 8605c09a02a5db85e08a432b6eeced9aa656349710dChristopher Lamb } 861213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman case Type::ExtVector: 862030d8846c7e520330007087e949f621989876e3aChris Lattner case Type::Vector: { 8639fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner const VectorType *VT = cast<VectorType>(T); 8649fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(VT->getElementType()); 8659fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner Width = EltInfo.first*VT->getNumElements(); 8664bd998bbc228915d2b9cae5b67879de48940d05eEli Friedman Align = Width; 8676fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // If the alignment is not a power of 2, round up to the next power of 2. 8686fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // This happens for non-power-of-2 length vectors. 8698eefcd353c1d06a10104f69e5079ebab3183f9a3Dan Gohman if (Align & (Align-1)) { 8709fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner Align = llvm::NextPowerOf2(Align); 8719fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner Width = llvm::RoundUpToAlignment(Width, Align); 8729fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner } 873030d8846c7e520330007087e949f621989876e3aChris Lattner break; 874030d8846c7e520330007087e949f621989876e3aChris Lattner } 8755d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner 8769e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner case Type::Builtin: 877a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner switch (cast<BuiltinType>(T)->getKind()) { 878b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Unknown builtin type!"); 879d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::Void: 88018857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor // GCC extension: alignof(void) = 8 bits. 88118857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Width = 0; 88218857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Align = 8; 88318857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor break; 88418857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 8856f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Bool: 886bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getBoolWidth(); 887bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getBoolAlign(); 8886f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 889692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::Char_S: 890692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::Char_U: 891692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::UChar: 8926f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::SChar: 893bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getCharWidth(); 894bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getCharAlign(); 8956f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 8963f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_S: 8973f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_U: 898bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getWCharWidth(); 899bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getWCharAlign(); 90064c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis break; 901f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case BuiltinType::Char16: 902bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getChar16Width(); 903bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getChar16Align(); 904f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith break; 905f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case BuiltinType::Char32: 906bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getChar32Width(); 907bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getChar32Align(); 908f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith break; 909692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::UShort: 9106f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Short: 911bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getShortWidth(); 912bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getShortAlign(); 9136f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 914692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::UInt: 9156f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Int: 916bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getIntWidth(); 917bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getIntAlign(); 9186f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 919692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::ULong: 9206f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Long: 921bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getLongWidth(); 922bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getLongAlign(); 9236f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 924692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::ULongLong: 9256f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::LongLong: 926bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getLongLongWidth(); 927bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getLongLongAlign(); 9286f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 929ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner case BuiltinType::Int128: 930ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner case BuiltinType::UInt128: 931ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner Width = 128; 932ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner Align = 128; // int128_t is 128-bit aligned on all targets. 933ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner break; 934aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov case BuiltinType::Half: 935aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Width = Target->getHalfWidth(); 936aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Align = Target->getHalfAlign(); 937aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov break; 9386f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Float: 939bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getFloatWidth(); 940bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getFloatAlign(); 9416f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 9426f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Double: 943bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getDoubleWidth(); 944bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getDoubleAlign(); 9456f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 9466f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::LongDouble: 947bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getLongDoubleWidth(); 948bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getLongDoubleAlign(); 9496f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 9506e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl case BuiltinType::NullPtr: 951bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t) 952bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(0); // == sizeof(void*) 9531590d9c0fec4c710c2962e4bb71f76979b5163d3Sebastian Redl break; 954e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian case BuiltinType::ObjCId: 955e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian case BuiltinType::ObjCClass: 956e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian case BuiltinType::ObjCSel: 957bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(0); 958bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(0); 959e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian break; 960a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner } 961bfef6d7c67831a135d6ab79931f010f750a730adChris Lattner break; 962d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff case Type::ObjCObjectPointer: 963bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(0); 964bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(0); 9656f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 966485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff case Type::BlockPointer: { 967207f4d8543529221932af82836016a2ef066c917Peter Collingbourne unsigned AS = getTargetAddressSpace( 968207f4d8543529221932af82836016a2ef066c917Peter Collingbourne cast<BlockPointerType>(T)->getPointeeType()); 969bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(AS); 970bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(AS); 971485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff break; 972485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff } 9735d484e8cf710207010720589d89602233de61d01Sebastian Redl case Type::LValueReference: 9745d484e8cf710207010720589d89602233de61d01Sebastian Redl case Type::RValueReference: { 9755d484e8cf710207010720589d89602233de61d01Sebastian Redl // alignof and sizeof should never enter this code path here, so we go 9765d484e8cf710207010720589d89602233de61d01Sebastian Redl // the pointer route. 977207f4d8543529221932af82836016a2ef066c917Peter Collingbourne unsigned AS = getTargetAddressSpace( 978207f4d8543529221932af82836016a2ef066c917Peter Collingbourne cast<ReferenceType>(T)->getPointeeType()); 979bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(AS); 980bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(AS); 9815d484e8cf710207010720589d89602233de61d01Sebastian Redl break; 9825d484e8cf710207010720589d89602233de61d01Sebastian Redl } 983f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner case Type::Pointer: { 984207f4d8543529221932af82836016a2ef066c917Peter Collingbourne unsigned AS = getTargetAddressSpace(cast<PointerType>(T)->getPointeeType()); 985bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(AS); 986bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(AS); 987f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner break; 988f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner } 989f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl case Type::MemberPointer: { 990071cc7deffad608165b1ddd5263e8bf181861520Charles Davis const MemberPointerType *MPT = cast<MemberPointerType>(T); 9911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump std::pair<uint64_t, unsigned> PtrDiffInfo = 9921cca74ef3627a3a0ab14501d23e336548f6611b2Anders Carlsson getTypeInfo(getPointerDiffType()); 993071cc7deffad608165b1ddd5263e8bf181861520Charles Davis Width = PtrDiffInfo.first * ABI->getMemberPointerSize(MPT); 9941cca74ef3627a3a0ab14501d23e336548f6611b2Anders Carlsson Align = PtrDiffInfo.second; 9951cca74ef3627a3a0ab14501d23e336548f6611b2Anders Carlsson break; 996f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl } 9975d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner case Type::Complex: { 9985d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner // Complex types have the same alignment as their elements, but twice the 9995d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner // size. 10001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump std::pair<uint64_t, unsigned> EltInfo = 100198be4943e8dc4f3905629a7102668960873cf863Chris Lattner getTypeInfo(cast<ComplexType>(T)->getElementType()); 10029e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner Width = EltInfo.first*2; 10035d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner Align = EltInfo.second; 10045d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner break; 10055d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner } 1006c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCObject: 1007c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return getTypeInfo(cast<ObjCObjectType>(T)->getBaseType().getTypePtr()); 100844a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel case Type::ObjCInterface: { 10091d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const ObjCInterfaceType *ObjCI = cast<ObjCInterfaceType>(T); 101044a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl()); 1011dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck Width = toBits(Layout.getSize()); 1012dac54c124e302d6f028ea5723c425b7f66fc7c71Ken Dyck Align = toBits(Layout.getAlignment()); 101344a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel break; 101444a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel } 101572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Record: 101672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Enum: { 10171d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const TagType *TT = cast<TagType>(T); 10181d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar 10191d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar if (TT->getDecl()->isInvalidDecl()) { 102022ce41d9fc8509da65858c75bf5b3c4dae2d8c04Douglas Gregor Width = 8; 102122ce41d9fc8509da65858c75bf5b3c4dae2d8c04Douglas Gregor Align = 8; 10228389eab190afef3462f6418b8d8fb70fb01c4005Chris Lattner break; 10238389eab190afef3462f6418b8d8fb70fb01c4005Chris Lattner } 10241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10251d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar if (const EnumType *ET = dyn_cast<EnumType>(TT)) 10267176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner return getTypeInfo(ET->getDecl()->getIntegerType()); 10277176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner 10281d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const RecordType *RT = cast<RecordType>(TT); 10297176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner const ASTRecordLayout &Layout = getASTRecordLayout(RT->getDecl()); 1030dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck Width = toBits(Layout.getSize()); 1031dac54c124e302d6f028ea5723c425b7f66fc7c71Ken Dyck Align = toBits(Layout.getAlignment()); 1032dc0d73e6495404418acf8548875aeaff07791a74Chris Lattner break; 1033a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner } 10347532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 10359fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner case Type::SubstTemplateTypeParm: 103649a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall return getTypeInfo(cast<SubstTemplateTypeParmType>(T)-> 103749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall getReplacementType().getTypePtr()); 103849a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 103934b41d939a1328f484511c6002ba2456db879a29Richard Smith case Type::Auto: { 104034b41d939a1328f484511c6002ba2456db879a29Richard Smith const AutoType *A = cast<AutoType>(T); 104134b41d939a1328f484511c6002ba2456db879a29Richard Smith assert(A->isDeduced() && "Cannot request the size of a dependent type"); 1042dc856aff4428380baa9afb5577ea04f8fb6beb13Matt Beaumont-Gay return getTypeInfo(A->getDeducedType().getTypePtr()); 104334b41d939a1328f484511c6002ba2456db879a29Richard Smith } 104434b41d939a1328f484511c6002ba2456db879a29Richard Smith 1045075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara case Type::Paren: 1046075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return getTypeInfo(cast<ParenType>(T)->getInnerType().getTypePtr()); 1047075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 104818857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor case Type::Typedef: { 1049162e1c1b487352434552147967c3dd296ebee2f7Richard Smith const TypedefNameDecl *Typedef = cast<TypedefType>(T)->getDecl(); 1050df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor std::pair<uint64_t, unsigned> Info 1051df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor = getTypeInfo(Typedef->getUnderlyingType().getTypePtr()); 1052c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner // If the typedef has an aligned attribute on it, it overrides any computed 1053c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner // alignment we have. This violates the GCC documentation (which says that 1054c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner // attribute(aligned) can only round up) but matches its implementation. 1055c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner if (unsigned AttrAlign = Typedef->getMaxAlignment()) 1056c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner Align = AttrAlign; 1057c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner else 1058c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner Align = Info.second; 1059df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor Width = Info.first; 10607532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor break; 10617176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner } 106218857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 106318857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor case Type::TypeOfExpr: 106418857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor return getTypeInfo(cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType() 106518857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor .getTypePtr()); 106618857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 106718857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor case Type::TypeOf: 106818857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor return getTypeInfo(cast<TypeOfType>(T)->getUnderlyingType().getTypePtr()); 106918857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 1070395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson case Type::Decltype: 1071395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson return getTypeInfo(cast<DecltypeType>(T)->getUnderlyingExpr()->getType() 1072395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson .getTypePtr()); 1073395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson 1074ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt case Type::UnaryTransform: 1075ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt return getTypeInfo(cast<UnaryTransformType>(T)->getUnderlyingType()); 1076ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt 1077465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara case Type::Elaborated: 1078465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr()); 10791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10809d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall case Type::Attributed: 10819d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall return getTypeInfo( 10829d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall cast<AttributedType>(T)->getEquivalentType().getTypePtr()); 10839d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 10843e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith case Type::TemplateSpecialization: { 10851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(getCanonicalType(T) != T && 108618857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor "Cannot request the size of a dependent type"); 10873e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith const TemplateSpecializationType *TST = cast<TemplateSpecializationType>(T); 10883e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith // A type alias template specialization may refer to a typedef with the 10893e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith // aligned attribute on it. 10903e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith if (TST->isTypeAlias()) 10913e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith return getTypeInfo(TST->getAliasedType().getTypePtr()); 10923e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith else 10933e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith return getTypeInfo(getCanonicalType(T)); 10943e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith } 10953e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith 1096b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: { 10972be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman std::pair<uint64_t, unsigned> Info 10982be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman = getTypeInfo(cast<AtomicType>(T)->getValueType()); 10992be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman Width = Info.first; 11002be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman Align = Info.second; 11012be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman if (Width != 0 && Width <= Target->getMaxAtomicPromoteWidth() && 11022be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman llvm::isPowerOf2_64(Width)) { 11032be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // We can potentially perform lock-free atomic operations for this 11042be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // type; promote the alignment appropriately. 11052be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // FIXME: We could potentially promote the width here as well... 11062be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // is that worthwhile? (Non-struct atomic types generally have 11072be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // power-of-two size anyway, but structs might not. Requires a bit 11082be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // of implementation work to make sure we zero out the extra bits.) 11092be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman Align = static_cast<unsigned>(Width); 11102be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman } 1111b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 1112b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 111318857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor } 11141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11152be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman assert(llvm::isPowerOf2_32(Align) && "Alignment must be power of 2"); 11169e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner return std::make_pair(Width, Align); 1117a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner} 1118a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 1119eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck/// toCharUnitsFromBits - Convert a size in bits to a size in characters. 1120eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen DyckCharUnits ASTContext::toCharUnitsFromBits(int64_t BitSize) const { 1121eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return CharUnits::fromQuantity(BitSize / getCharWidth()); 1122eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck} 1123eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck 1124dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck/// toBits - Convert a size in characters to a size in characters. 1125dd76a9ab9ea675671200f94b18ce95766841952bKen Dyckint64_t ASTContext::toBits(CharUnits CharSize) const { 1126dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck return CharSize.getQuantity() * getCharWidth(); 1127dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck} 1128dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck 1129bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck/// getTypeSizeInChars - Return the size of the specified type, in characters. 1130bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck/// This method does not work on incomplete types. 11314ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeSizeInChars(QualType T) const { 1132eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeSize(T)); 1133bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck} 11344ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeSizeInChars(const Type *T) const { 1135eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeSize(T)); 1136bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck} 1137bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck 113816e20cce43385001f33f8e3f90ee345609c805d1Ken Dyck/// getTypeAlignInChars - Return the ABI-specified alignment of a type, in 113986fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck/// characters. This method does not work on incomplete types. 11404ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeAlignInChars(QualType T) const { 1141eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeAlign(T)); 114286fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck} 11434ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeAlignInChars(const Type *T) const { 1144eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeAlign(T)); 114586fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck} 114686fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck 114734ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// getPreferredTypeAlign - Return the "preferred" alignment of the specified 114834ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// type for the current target in bits. This can be different than the ABI 114934ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// alignment in cases where it is beneficial for performance to overalign 115034ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// a data type. 11514ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadunsigned ASTContext::getPreferredTypeAlign(const Type *T) const { 115234ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner unsigned ABIAlign = getTypeAlign(T); 11531eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman 11541eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman // Double and long long should be naturally aligned if possible. 1155183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ComplexType* CT = T->getAs<ComplexType>()) 11561eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman T = CT->getElementType().getTypePtr(); 11571eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman if (T->isSpecificBuiltinType(BuiltinType::Double) || 11581eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman T->isSpecificBuiltinType(BuiltinType::LongLong)) 11591eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman return std::max(ABIAlign, (unsigned)getTypeSize(T)); 11601eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman 116134ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner return ABIAlign; 116234ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner} 116334ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner 11642c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// DeepCollectObjCIvars - 11652c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// This routine first collects all declared, but not synthesized, ivars in 11662c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// super class and then collects all ivars, including those synthesized for 11672c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// current class. This routine is used for implementation of current class 11682c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// when all ivars, declared and synthesized are known. 11699820074dd47d37681085e964cd3392ac0b3e67b9Fariborz Jahanian/// 11702c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanianvoid ASTContext::DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, 11712c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian bool leafClass, 1172db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const { 11732c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass()) 11742c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian DeepCollectObjCIvars(SuperClass, false, Ivars); 11752c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian if (!leafClass) { 11762c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(), 11772c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian E = OI->ivar_end(); I != E; ++I) 117811062e11236b7bc689dad150e8b490fd6b063ec3Fariborz Jahanian Ivars.push_back(*I); 11793060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 1180bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian ObjCInterfaceDecl *IDecl = const_cast<ObjCInterfaceDecl *>(OI); 1181db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose for (const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv; 1182bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian Iv= Iv->getNextIvar()) 1183bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian Ivars.push_back(Iv); 1184bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian } 11859820074dd47d37681085e964cd3392ac0b3e67b9Fariborz Jahanian} 11869820074dd47d37681085e964cd3392ac0b3e67b9Fariborz Jahanian 1187e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// CollectInheritedProtocols - Collect all protocols in current class and 1188e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// those inherited by it. 1189e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanianvoid ASTContext::CollectInheritedProtocols(const Decl *CDecl, 1190432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) { 1191e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (const ObjCInterfaceDecl *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) { 119253b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek // We can use protocol_iterator here instead of 119353b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek // all_referenced_protocol_iterator since we are walking all categories. 119453b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek for (ObjCInterfaceDecl::all_protocol_iterator P = OI->all_referenced_protocol_begin(), 119553b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek PE = OI->all_referenced_protocol_end(); P != PE; ++P) { 1196e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian ObjCProtocolDecl *Proto = (*P); 11973fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert(Proto->getCanonicalDecl()); 1198e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 1199b2f812165676230bce5d0215e49a4749c451ca9cFariborz Jahanian PE = Proto->protocol_end(); P != PE; ++P) { 12003fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert((*P)->getCanonicalDecl()); 1201e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(*P, Protocols); 1202e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1203b2f812165676230bce5d0215e49a4749c451ca9cFariborz Jahanian } 1204e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 1205e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian // Categories of this Interface. 1206e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (const ObjCCategoryDecl *CDeclChain = OI->getCategoryList(); 1207e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CDeclChain; CDeclChain = CDeclChain->getNextClassCategory()) 1208e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(CDeclChain, Protocols); 1209e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (ObjCInterfaceDecl *SD = OI->getSuperClass()) 1210e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian while (SD) { 1211e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(SD, Protocols); 1212e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian SD = SD->getSuperClass(); 1213e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1214b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer } else if (const ObjCCategoryDecl *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) { 121553b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek for (ObjCCategoryDecl::protocol_iterator P = OC->protocol_begin(), 1216e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = OC->protocol_end(); P != PE; ++P) { 1217e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian ObjCProtocolDecl *Proto = (*P); 12183fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert(Proto->getCanonicalDecl()); 1219e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 1220e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = Proto->protocol_end(); P != PE; ++P) 1221e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(*P, Protocols); 1222e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1223b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer } else if (const ObjCProtocolDecl *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) { 1224e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = OP->protocol_begin(), 1225e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = OP->protocol_end(); P != PE; ++P) { 1226e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian ObjCProtocolDecl *Proto = (*P); 12273fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert(Proto->getCanonicalDecl()); 1228e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 1229e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = Proto->protocol_end(); P != PE; ++P) 1230e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(*P, Protocols); 1231e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1232e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1233e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian} 1234e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 12354ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadunsigned ASTContext::CountNonClassIvars(const ObjCInterfaceDecl *OI) const { 12363bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian unsigned count = 0; 12373bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian // Count ivars declared in class extension. 123880aa1cd7973561889e51c1c152c8990a8de9c953Fariborz Jahanian for (const ObjCCategoryDecl *CDecl = OI->getFirstClassExtension(); CDecl; 123980aa1cd7973561889e51c1c152c8990a8de9c953Fariborz Jahanian CDecl = CDecl->getNextClassExtension()) 1240b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer count += CDecl->ivar_size(); 1241b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer 12423bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian // Count ivar defined in this class's implementation. This 12433bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian // includes synthesized ivars. 12443bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian if (ObjCImplementationDecl *ImplDecl = OI->getImplementation()) 1245b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer count += ImplDecl->ivar_size(); 1246b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer 12478e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian return count; 12488e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian} 12498e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian 12508deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidisbool ASTContext::isSentinelNullExpr(const Expr *E) { 12518deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis if (!E) 12528deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis return false; 12538deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12548deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis // nullptr_t is always treated as null. 12558deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis if (E->getType()->isNullPtrType()) return true; 12568deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12578deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis if (E->getType()->isAnyPointerType() && 12588deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis E->IgnoreParenCasts()->isNullPointerConstant(*this, 12598deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis Expr::NPC_ValueDependentIsNull)) 12608deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis return true; 12618deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12628deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis // Unfortunately, __null has type 'int'. 12638deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis if (isa<GNUNullExpr>(E)) return true; 12648deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12658deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis return false; 12668deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis} 12678deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12688a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Get the implementation of ObjCInterfaceDecl,or NULL if none exists. 12698a1d722f13df383600f36d77f842957c8adb5f1bArgyrios KyrtzidisObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) { 12708a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator 12718a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis I = ObjCImpls.find(D); 12728a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis if (I != ObjCImpls.end()) 12738a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return cast<ObjCImplementationDecl>(I->second); 12748a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return 0; 12758a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 12768a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Get the implementation of ObjCCategoryDecl, or NULL if none exists. 12778a1d722f13df383600f36d77f842957c8adb5f1bArgyrios KyrtzidisObjCCategoryImplDecl *ASTContext::getObjCImplementation(ObjCCategoryDecl *D) { 12788a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator 12798a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis I = ObjCImpls.find(D); 12808a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis if (I != ObjCImpls.end()) 12818a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return cast<ObjCCategoryImplDecl>(I->second); 12828a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return 0; 12838a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 12848a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis 12858a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Set the implementation of ObjCInterfaceDecl. 12868a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidisvoid ASTContext::setObjCImplementation(ObjCInterfaceDecl *IFaceD, 12878a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCImplementationDecl *ImplD) { 12888a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis assert(IFaceD && ImplD && "Passed null params"); 12898a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCImpls[IFaceD] = ImplD; 12908a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 12918a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Set the implementation of ObjCCategoryDecl. 12928a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidisvoid ASTContext::setObjCImplementation(ObjCCategoryDecl *CatD, 12938a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCCategoryImplDecl *ImplD) { 12948a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis assert(CatD && ImplD && "Passed null params"); 12958a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCImpls[CatD] = ImplD; 12968a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 12978a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis 129887ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios KyrtzidisObjCInterfaceDecl *ASTContext::getObjContainingInterface(NamedDecl *ND) const { 129987ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(ND->getDeclContext())) 130087ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return ID; 130187ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(ND->getDeclContext())) 130287ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return CD->getClassInterface(); 130387ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis if (ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(ND->getDeclContext())) 130487ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return IMD->getClassInterface(); 130587ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis 130687ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return 0; 130787ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis} 130887ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis 13091ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian/// \brief Get the copy initialization expression of VarDecl,or NULL if 13101ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian/// none exists. 1311830937bc1100fba7682f7c32c40512085870f50cFariborz JahanianExpr *ASTContext::getBlockVarCopyInits(const VarDecl*VD) { 1312d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian assert(VD && "Passed null params"); 1313d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian assert(VD->hasAttr<BlocksAttr>() && 1314d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian "getBlockVarCopyInits - not __block var"); 1315830937bc1100fba7682f7c32c40512085870f50cFariborz Jahanian llvm::DenseMap<const VarDecl*, Expr*>::iterator 1316d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian I = BlockVarCopyInits.find(VD); 13171ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian return (I != BlockVarCopyInits.end()) ? cast<Expr>(I->second) : 0; 13181ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian} 13191ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian 13201ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian/// \brief Set the copy inialization expression of a block var decl. 13211ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanianvoid ASTContext::setBlockVarCopyInits(VarDecl*VD, Expr* Init) { 13221ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian assert(VD && Init && "Passed null params"); 1323d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian assert(VD->hasAttr<BlocksAttr>() && 1324d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian "setBlockVarCopyInits - not __block var"); 13251ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian BlockVarCopyInits[VD] = Init; 13261ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian} 13271ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian 1328a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall/// \brief Allocate an uninitialized TypeSourceInfo. 1329b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// 1330a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall/// The caller should initialize the memory held by TypeSourceInfo using 1331b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// the TypeLoc wrappers. 1332b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// 1333b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// \param T the type that will be the basis for type source info. This type 1334b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// should refer to how the declarator was written in source code, not to 1335b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// what type semantic analysis resolved the declarator to. 1336a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCallTypeSourceInfo *ASTContext::CreateTypeSourceInfo(QualType T, 13374ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned DataSize) const { 1338109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall if (!DataSize) 1339109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall DataSize = TypeLoc::getFullDataSizeForType(T); 1340109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall else 1341109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall assert(DataSize == TypeLoc::getFullDataSizeForType(T) && 1342a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall "incorrect data size provided to CreateTypeSourceInfo!"); 1343109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall 1344a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall TypeSourceInfo *TInfo = 1345a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall (TypeSourceInfo*)BumpAlloc.Allocate(sizeof(TypeSourceInfo) + DataSize, 8); 1346a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall new (TInfo) TypeSourceInfo(T); 1347a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall return TInfo; 1348b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis} 1349b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis 1350a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCallTypeSourceInfo *ASTContext::getTrivialTypeSourceInfo(QualType T, 13516952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor SourceLocation L) const { 1352a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall TypeSourceInfo *DI = CreateTypeSourceInfo(T); 1353c21c7e9c2cded68f91be15be6847c9649242dc17Douglas Gregor DI->getTypeLoc().initialize(const_cast<ASTContext &>(*this), L); 1354a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall return DI; 1355a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall} 1356a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall 1357b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbarconst ASTRecordLayout & 13584ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const { 1359b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar return getObjCLayout(D, 0); 1360b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar} 1361b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar 1362b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbarconst ASTRecordLayout & 13634ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getASTObjCImplementationLayout( 13644ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const ObjCImplementationDecl *D) const { 1365b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar return getObjCLayout(D->getClassInterface(), D); 1366b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar} 1367b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar 1368a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner//===----------------------------------------------------------------------===// 1369a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner// Type creation/memoization methods 1370a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner//===----------------------------------------------------------------------===// 1371a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 13724ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 13733b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallASTContext::getExtQualType(const Type *baseType, Qualifiers quals) const { 13743b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall unsigned fastQuals = quals.getFastQualifiers(); 13753b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall quals.removeFastQualifiers(); 13760953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 13770953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Check if we've already instantiated this type. 13780953e767ff7817f97b3ab20896b229891eeff45bJohn McCall llvm::FoldingSetNodeID ID; 13793b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ExtQuals::Profile(ID, baseType, quals); 13803b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall void *insertPos = 0; 13813b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (ExtQuals *eq = ExtQualNodes.FindNodeOrInsertPos(ID, insertPos)) { 13823b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert(eq->getQualifiers() == quals); 13833b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(eq, fastQuals); 13840953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 13850953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 13863b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If the base type is not canonical, make the appropriate canonical type. 13873b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType canon; 13883b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!baseType->isCanonicalUnqualified()) { 13893b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = baseType->getCanonicalTypeInternal().split(); 1390200fa53fd420aa8369586f569dbece04930ad6a3John McCall canonSplit.Quals.addConsistentQualifiers(quals); 1391200fa53fd420aa8369586f569dbece04930ad6a3John McCall canon = getExtQualType(canonSplit.Ty, canonSplit.Quals); 13923b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 13933b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Re-find the insert position. 13943b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos); 13953b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall } 13963b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 13973b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ExtQuals *eq = new (*this, TypeAlignment) ExtQuals(baseType, canon, quals); 13983b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ExtQualNodes.InsertNode(eq, insertPos); 13993b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(eq, fastQuals); 14000953e767ff7817f97b3ab20896b229891eeff45bJohn McCall} 14010953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 14024ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 14034ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getAddrSpaceQualType(QualType T, unsigned AddressSpace) const { 1404f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner QualType CanT = getCanonicalType(T); 1405f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner if (CanT.getAddressSpace() == AddressSpace) 1406f46699ce225811d8d9dbab9d00189a0e54469457Chris Lattner return T; 1407b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris Lattner 14080953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If we are composing extended qualifiers together, merge together 14090953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // into one ExtQuals node. 14100953e767ff7817f97b3ab20896b229891eeff45bJohn McCall QualifierCollector Quals; 14110953e767ff7817f97b3ab20896b229891eeff45bJohn McCall const Type *TypeNode = Quals.strip(T); 14121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14130953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If this type already has an address space specified, it cannot get 14140953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // another one. 14150953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert(!Quals.hasAddressSpace() && 14160953e767ff7817f97b3ab20896b229891eeff45bJohn McCall "Type cannot be in multiple addr spaces!"); 14170953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Quals.addAddressSpace(AddressSpace); 14181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14190953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return getExtQualType(TypeNode, Quals); 1420ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb} 1421ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb 1422b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris LattnerQualType ASTContext::getObjCGCQualType(QualType T, 14234ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Qualifiers::GC GCAttr) const { 1424d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian QualType CanT = getCanonicalType(T); 1425b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris Lattner if (CanT.getObjCGCAttr() == GCAttr) 1426d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian return T; 14271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14287f040a9d817cd1c72b565e92abff473510bf9e1dJohn McCall if (const PointerType *ptr = T->getAs<PointerType>()) { 14297f040a9d817cd1c72b565e92abff473510bf9e1dJohn McCall QualType Pointee = ptr->getPointeeType(); 143058f9f2c884af6b72d036b746a016d8031d31cb7aSteve Naroff if (Pointee->isAnyPointerType()) { 14314027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian QualType ResultType = getObjCGCQualType(Pointee, GCAttr); 14324027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian return getPointerType(ResultType); 14334027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian } 14344027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian } 14351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14360953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If we are composing extended qualifiers together, merge together 14370953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // into one ExtQuals node. 14380953e767ff7817f97b3ab20896b229891eeff45bJohn McCall QualifierCollector Quals; 14390953e767ff7817f97b3ab20896b229891eeff45bJohn McCall const Type *TypeNode = Quals.strip(T); 14401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14410953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If this type already has an ObjCGC specified, it cannot get 14420953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // another one. 14430953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert(!Quals.hasObjCGCAttr() && 14440953e767ff7817f97b3ab20896b229891eeff45bJohn McCall "Type cannot have multiple ObjCGCs!"); 14450953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Quals.addObjCGCAttr(GCAttr); 14461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14470953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return getExtQualType(TypeNode, Quals); 1448d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian} 1449a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 1450e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCallconst FunctionType *ASTContext::adjustFunctionType(const FunctionType *T, 1451e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall FunctionType::ExtInfo Info) { 1452e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall if (T->getExtInfo() == Info) 1453e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall return T; 1454e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 1455e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall QualType Result; 1456e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall if (const FunctionNoProtoType *FNPT = dyn_cast<FunctionNoProtoType>(T)) { 1457e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall Result = getFunctionNoProtoType(FNPT->getResultType(), Info); 1458e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall } else { 1459e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall const FunctionProtoType *FPT = cast<FunctionProtoType>(T); 1460e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 1461e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall EPI.ExtInfo = Info; 1462e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall Result = getFunctionType(FPT->getResultType(), FPT->arg_type_begin(), 1463e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall FPT->getNumArgs(), EPI); 1464e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall } 1465e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 1466e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall return cast<FunctionType>(Result.getTypePtr()); 1467e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall} 1468e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 14695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getComplexType - Return the uniqued reference to the type for a complex 14705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// number with the specified element type. 14714ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getComplexType(QualType T) const { 14725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique pointers, to guarantee there is only one pointer of a particular 14735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 14745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 14755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ComplexType::Profile(ID, T); 14761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 14785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos)) 14795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(CT, 0); 14801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the pointee type isn't canonical, this won't be a canonical type either, 14825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // so fill in the canonical type field. 14835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 1484467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!T.isCanonical()) { 1485f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner Canonical = getComplexType(getCanonicalType(T)); 14861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 14885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos); 1489c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 14905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 14916b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ComplexType *New = new (*this, TypeAlignment) ComplexType(T, Canonical); 14925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 14935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ComplexTypes.InsertNode(New, InsertPos); 14945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 14955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 14965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 14975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getPointerType - Return the uniqued reference to the type for a pointer to 14985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// the specified type. 14994ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getPointerType(QualType T) const { 15005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique pointers, to guarantee there is only one pointer of a particular 15015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 15025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 15035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PointerType::Profile(ID, T); 15041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 15065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 15075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(PT, 0); 15081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the pointee type isn't canonical, this won't be a canonical type either, 15105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // so fill in the canonical type field. 15115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 1512467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!T.isCanonical()) { 1513f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner Canonical = getPointerType(getCanonicalType(T)); 15141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 15165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1517c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 15185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 15196b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall PointerType *New = new (*this, TypeAlignment) PointerType(T, Canonical); 15205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 15215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PointerTypes.InsertNode(New, InsertPos); 15225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 15235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 15245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 15251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getBlockPointerType - Return the uniqued reference to the type for 15265618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff/// a pointer to the specified block. 15274ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getBlockPointerType(QualType T) const { 1528296e8d5fdcf9946f51e866adc8d281379e51efe9Steve Naroff assert(T->isFunctionType() && "block of function types only"); 1529296e8d5fdcf9946f51e866adc8d281379e51efe9Steve Naroff // Unique pointers, to guarantee there is only one block of a particular 15305618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // structure. 15315618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff llvm::FoldingSetNodeID ID; 15325618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerType::Profile(ID, T); 15331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15345618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff void *InsertPos = 0; 15355618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff if (BlockPointerType *PT = 15365618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 15375618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff return QualType(PT, 0); 15381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the block pointee type isn't canonical, this won't be a canonical 15405618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // type either so fill in the canonical type field. 15415618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff QualType Canonical; 1542467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!T.isCanonical()) { 15435618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff Canonical = getBlockPointerType(getCanonicalType(T)); 15441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15455618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // Get the new insert position for the node we care about. 15465618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerType *NewIP = 15475618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1548c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 15495618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff } 15506b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall BlockPointerType *New 15516b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) BlockPointerType(T, Canonical); 15525618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff Types.push_back(New); 15535618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerTypes.InsertNode(New, InsertPos); 15545618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff return QualType(New, 0); 15555618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff} 15565618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff 15577c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// getLValueReferenceType - Return the uniqued reference to the type for an 15587c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// lvalue reference to the specified type. 15594ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 15604ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getLValueReferenceType(QualType T, bool SpelledAsLValue) const { 15619625e44c0252485277a340746ed8ac950686156fDouglas Gregor assert(getCanonicalType(T) != OverloadTy && 15629625e44c0252485277a340746ed8ac950686156fDouglas Gregor "Unresolved overloaded function type"); 15639625e44c0252485277a340746ed8ac950686156fDouglas Gregor 15645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique pointers, to guarantee there is only one pointer of a particular 15655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 15665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 156754e14c4db764c0636160d26c5bbf491637c83a76John McCall ReferenceType::Profile(ID, T, SpelledAsLValue); 15685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 15695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 15707c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl if (LValueReferenceType *RT = 15717c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 15725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(RT, 0); 15737c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 157454e14c4db764c0636160d26c5bbf491637c83a76John McCall const ReferenceType *InnerRef = T->getAs<ReferenceType>(); 157554e14c4db764c0636160d26c5bbf491637c83a76John McCall 15765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the referencee type isn't canonical, this won't be a canonical type 15775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // either, so fill in the canonical type field. 15785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 157954e14c4db764c0636160d26c5bbf491637c83a76John McCall if (!SpelledAsLValue || InnerRef || !T.isCanonical()) { 158054e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T); 158154e14c4db764c0636160d26c5bbf491637c83a76John McCall Canonical = getLValueReferenceType(getCanonicalType(PointeeType)); 15827c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 15837c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // Get the new insert position for the node we care about. 15847c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceType *NewIP = 15857c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 1586c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 15877c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl } 15887c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 15896b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall LValueReferenceType *New 159054e14c4db764c0636160d26c5bbf491637c83a76John McCall = new (*this, TypeAlignment) LValueReferenceType(T, Canonical, 159154e14c4db764c0636160d26c5bbf491637c83a76John McCall SpelledAsLValue); 15927c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl Types.push_back(New); 15937c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceTypes.InsertNode(New, InsertPos); 159454e14c4db764c0636160d26c5bbf491637c83a76John McCall 15957c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl return QualType(New, 0); 15967c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl} 15977c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 15987c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// getRValueReferenceType - Return the uniqued reference to the type for an 15997c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// rvalue reference to the specified type. 16004ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getRValueReferenceType(QualType T) const { 16017c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // Unique pointers, to guarantee there is only one pointer of a particular 16027c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // structure. 16037c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl llvm::FoldingSetNodeID ID; 160454e14c4db764c0636160d26c5bbf491637c83a76John McCall ReferenceType::Profile(ID, T, false); 16057c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 16067c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl void *InsertPos = 0; 16077c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl if (RValueReferenceType *RT = 16087c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 16097c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl return QualType(RT, 0); 16107c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 161154e14c4db764c0636160d26c5bbf491637c83a76John McCall const ReferenceType *InnerRef = T->getAs<ReferenceType>(); 161254e14c4db764c0636160d26c5bbf491637c83a76John McCall 16137c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // If the referencee type isn't canonical, this won't be a canonical type 16147c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // either, so fill in the canonical type field. 16157c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl QualType Canonical; 161654e14c4db764c0636160d26c5bbf491637c83a76John McCall if (InnerRef || !T.isCanonical()) { 161754e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T); 161854e14c4db764c0636160d26c5bbf491637c83a76John McCall Canonical = getRValueReferenceType(getCanonicalType(PointeeType)); 16197c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 16205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 16217c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceType *NewIP = 16227c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 1623c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 16245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 16255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 16266b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall RValueReferenceType *New 16276b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) RValueReferenceType(T, Canonical); 16285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 16297c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceTypes.InsertNode(New, InsertPos); 16305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 16315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 16325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1633f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl/// getMemberPointerType - Return the uniqued reference to the type for a 1634f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl/// member pointer to the specified type, in the specified class. 16354ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) const { 1636f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // Unique pointers, to guarantee there is only one pointer of a particular 1637f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // structure. 1638f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl llvm::FoldingSetNodeID ID; 1639f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerType::Profile(ID, T, Cls); 1640f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1641f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl void *InsertPos = 0; 1642f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl if (MemberPointerType *PT = 1643f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 1644f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl return QualType(PT, 0); 1645f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1646f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // If the pointee or class type isn't canonical, this won't be a canonical 1647f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // type either, so fill in the canonical type field. 1648f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl QualType Canonical; 164987c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) { 1650f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls)); 1651f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1652f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // Get the new insert position for the node we care about. 1653f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerType *NewIP = 1654f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1655c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 1656f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl } 16576b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall MemberPointerType *New 16586b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical); 1659f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl Types.push_back(New); 1660f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerTypes.InsertNode(New, InsertPos); 1661f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl return QualType(New, 0); 1662f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl} 1663f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 16641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getConstantArrayType - Return the unique reference to the type for an 1665fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff/// array of the specified element type. 16661eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType ASTContext::getConstantArrayType(QualType EltTy, 166738aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner const llvm::APInt &ArySizeIn, 1668c9406125e2cac9208098655ac8058c095c2c3a65Steve Naroff ArrayType::ArraySizeModifier ASM, 166963e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara unsigned IndexTypeQuals) const { 1670923d56d436f750bc1f29db50e641078725558a1bSebastian Redl assert((EltTy->isDependentType() || 1671923d56d436f750bc1f29db50e641078725558a1bSebastian Redl EltTy->isIncompleteType() || EltTy->isConstantSizeType()) && 1672587cbdfd95f4b0aaccc14b31f5debe85d5daf7edEli Friedman "Constant array of VLAs is illegal!"); 1673587cbdfd95f4b0aaccc14b31f5debe85d5daf7edEli Friedman 167438aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner // Convert the array size into a canonical width matching the pointer size for 167538aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner // the target. 167638aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner llvm::APInt ArySize(ArySizeIn); 16779f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad ArySize = 1678bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor ArySize.zextOrTrunc(Target->getPointerWidth(getTargetAddressSpace(EltTy))); 16791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 168163e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, IndexTypeQuals); 16821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 16841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (ConstantArrayType *ATP = 16857192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos)) 16865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(ATP, 0); 16871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16883b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If the element type isn't canonical or has qualifiers, this won't 16893b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // be a canonical type either, so fill in the canonical type field. 16903b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType Canon; 16913b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) { 16923b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = getCanonicalType(EltTy).split(); 1693200fa53fd420aa8369586f569dbece04930ad6a3John McCall Canon = getConstantArrayType(QualType(canonSplit.Ty, 0), ArySize, 169463e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara ASM, IndexTypeQuals); 1695200fa53fd420aa8369586f569dbece04930ad6a3John McCall Canon = getQualifiedType(Canon, canonSplit.Quals); 16963b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 16975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 16981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ConstantArrayType *NewIP = 16997192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos); 1700c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 17015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 17021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 17036b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ConstantArrayType *New = new(*this,TypeAlignment) 170463e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara ConstantArrayType(EltTy, Canon, ArySize, ASM, IndexTypeQuals); 17057192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek ConstantArrayTypes.InsertNode(New, InsertPos); 17065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 17075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 17085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 17095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1710ce8890371fcdb983ae487c87fa40606a34896ff7John McCall/// getVariableArrayDecayedType - Turns the given type, which may be 1711ce8890371fcdb983ae487c87fa40606a34896ff7John McCall/// variably-modified, into the corresponding type with all the known 1712ce8890371fcdb983ae487c87fa40606a34896ff7John McCall/// sizes replaced with [*]. 1713ce8890371fcdb983ae487c87fa40606a34896ff7John McCallQualType ASTContext::getVariableArrayDecayedType(QualType type) const { 1714ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Vastly most common case. 1715ce8890371fcdb983ae487c87fa40606a34896ff7John McCall if (!type->isVariablyModifiedType()) return type; 1716ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1717ce8890371fcdb983ae487c87fa40606a34896ff7John McCall QualType result; 1718ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1719ce8890371fcdb983ae487c87fa40606a34896ff7John McCall SplitQualType split = type.getSplitDesugaredType(); 1720200fa53fd420aa8369586f569dbece04930ad6a3John McCall const Type *ty = split.Ty; 1721ce8890371fcdb983ae487c87fa40606a34896ff7John McCall switch (ty->getTypeClass()) { 1722ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#define TYPE(Class, Base) 1723ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#define ABSTRACT_TYPE(Class, Base) 1724ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 1725ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#include "clang/AST/TypeNodes.def" 1726ce8890371fcdb983ae487c87fa40606a34896ff7John McCall llvm_unreachable("didn't desugar past all non-canonical types?"); 1727ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1728ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // These types should never be variably-modified. 1729ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Builtin: 1730ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Complex: 1731ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Vector: 1732ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ExtVector: 1733ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentSizedExtVector: 1734ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ObjCObject: 1735ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ObjCInterface: 1736ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ObjCObjectPointer: 1737ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Record: 1738ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Enum: 1739ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::UnresolvedUsing: 1740ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TypeOfExpr: 1741ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TypeOf: 1742ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Decltype: 1743ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt case Type::UnaryTransform: 1744ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentName: 1745ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::InjectedClassName: 1746ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TemplateSpecialization: 1747ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentTemplateSpecialization: 1748ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TemplateTypeParm: 1749ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::SubstTemplateTypeParmPack: 175034b41d939a1328f484511c6002ba2456db879a29Richard Smith case Type::Auto: 1751ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::PackExpansion: 1752ce8890371fcdb983ae487c87fa40606a34896ff7John McCall llvm_unreachable("type should never be variably-modified"); 1753ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1754ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // These types can be variably-modified but should never need to 1755ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // further decay. 1756ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::FunctionNoProto: 1757ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::FunctionProto: 1758ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::BlockPointer: 1759ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::MemberPointer: 1760ce8890371fcdb983ae487c87fa40606a34896ff7John McCall return type; 1761ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1762ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // These types can be variably-modified. All these modifications 1763ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // preserve structure except as noted by comments. 1764ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // TODO: if we ever care about optimizing VLAs, there are no-op 1765ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // optimizations available here. 1766ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Pointer: 1767ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getPointerType(getVariableArrayDecayedType( 1768ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cast<PointerType>(ty)->getPointeeType())); 1769ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1770ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1771ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::LValueReference: { 1772ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const LValueReferenceType *lv = cast<LValueReferenceType>(ty); 1773ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getLValueReferenceType( 1774ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(lv->getPointeeType()), 1775ce8890371fcdb983ae487c87fa40606a34896ff7John McCall lv->isSpelledAsLValue()); 1776ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1777745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 1778ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1779ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::RValueReference: { 1780ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const RValueReferenceType *lv = cast<RValueReferenceType>(ty); 1781ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getRValueReferenceType( 1782ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(lv->getPointeeType())); 1783ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1784745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 1785745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1786b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: { 1787b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman const AtomicType *at = cast<AtomicType>(ty); 1788b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman result = getAtomicType(getVariableArrayDecayedType(at->getValueType())); 1789b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman break; 1790b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 1791b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 1792ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ConstantArray: { 1793ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const ConstantArrayType *cat = cast<ConstantArrayType>(ty); 1794ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getConstantArrayType( 1795ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(cat->getElementType()), 1796ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cat->getSize(), 1797ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cat->getSizeModifier(), 1798ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cat->getIndexTypeCVRQualifiers()); 1799ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1800745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 1801745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1802ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentSizedArray: { 1803ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const DependentSizedArrayType *dat = cast<DependentSizedArrayType>(ty); 1804ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getDependentSizedArrayType( 1805ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(dat->getElementType()), 1806ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getSizeExpr(), 1807ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getSizeModifier(), 1808ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getIndexTypeCVRQualifiers(), 1809ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getBracketsRange()); 1810ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1811ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1812ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1813ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Turn incomplete types into [*] types. 1814ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::IncompleteArray: { 1815ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const IncompleteArrayType *iat = cast<IncompleteArrayType>(ty); 1816ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getVariableArrayType( 1817ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(iat->getElementType()), 1818ce8890371fcdb983ae487c87fa40606a34896ff7John McCall /*size*/ 0, 1819ce8890371fcdb983ae487c87fa40606a34896ff7John McCall ArrayType::Normal, 1820ce8890371fcdb983ae487c87fa40606a34896ff7John McCall iat->getIndexTypeCVRQualifiers(), 1821ce8890371fcdb983ae487c87fa40606a34896ff7John McCall SourceRange()); 1822ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1823ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1824ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1825ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Turn VLA types into [*] types. 1826ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::VariableArray: { 1827ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const VariableArrayType *vat = cast<VariableArrayType>(ty); 1828ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getVariableArrayType( 1829ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(vat->getElementType()), 1830ce8890371fcdb983ae487c87fa40606a34896ff7John McCall /*size*/ 0, 1831ce8890371fcdb983ae487c87fa40606a34896ff7John McCall ArrayType::Star, 1832ce8890371fcdb983ae487c87fa40606a34896ff7John McCall vat->getIndexTypeCVRQualifiers(), 1833ce8890371fcdb983ae487c87fa40606a34896ff7John McCall vat->getBracketsRange()); 1834ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1835ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1836ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1837ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1838ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Apply the top-level qualifiers from the original. 1839200fa53fd420aa8369586f569dbece04930ad6a3John McCall return getQualifiedType(result, split.Quals); 1840ce8890371fcdb983ae487c87fa40606a34896ff7John McCall} 1841745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1842bdbf7b030a3e0ddb95240076683830e6f78c79a5Steve Naroff/// getVariableArrayType - Returns a non-unique reference to the type for a 1843bdbf7b030a3e0ddb95240076683830e6f78c79a5Steve Naroff/// variable array of the specified element type. 18447e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas GregorQualType ASTContext::getVariableArrayType(QualType EltTy, 18457e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor Expr *NumElts, 1846c9406125e2cac9208098655ac8058c095c2c3a65Steve Naroff ArrayType::ArraySizeModifier ASM, 184763e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara unsigned IndexTypeQuals, 18484ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad SourceRange Brackets) const { 1849c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // Since we don't unique expressions, it isn't possible to unique VLA's 1850c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // that have an expression provided for their size. 18513b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType Canon; 1852715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor 18533b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Be sure to pull qualifiers off the element type. 18543b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) { 18553b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = getCanonicalType(EltTy).split(); 1856200fa53fd420aa8369586f569dbece04930ad6a3John McCall Canon = getVariableArrayType(QualType(canonSplit.Ty, 0), NumElts, ASM, 185763e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara IndexTypeQuals, Brackets); 1858200fa53fd420aa8369586f569dbece04930ad6a3John McCall Canon = getQualifiedType(Canon, canonSplit.Quals); 1859715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor } 1860715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor 18616b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall VariableArrayType *New = new(*this, TypeAlignment) 186263e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara VariableArrayType(EltTy, Canon, NumElts, ASM, IndexTypeQuals, Brackets); 1863c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1864c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman VariableArrayTypes.push_back(New); 1865c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman Types.push_back(New); 1866c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman return QualType(New, 0); 1867c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman} 1868c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1869898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// getDependentSizedArrayType - Returns a non-unique reference to 1870898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// the type for a dependently-sized array of the specified element 187104d4beee4b86af20a9e4457023d3925cab8f9908Douglas Gregor/// type. 18723b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getDependentSizedArrayType(QualType elementType, 18733b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Expr *numElements, 1874898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor ArrayType::ArraySizeModifier ASM, 18753b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall unsigned elementTypeQuals, 18763b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SourceRange brackets) const { 18773b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert((!numElements || numElements->isTypeDependent() || 18783b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall numElements->isValueDependent()) && 1879898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor "Size must be type- or value-dependent!"); 1880898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 18813b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Dependently-sized array types that do not have a specified number 18823b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // of elements will have their sizes deduced from a dependent 18833b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // initializer. We do no canonicalization here at all, which is okay 18843b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // because they can't be used in most locations. 18853b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!numElements) { 18863b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType *newType 18873b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall = new (*this, TypeAlignment) 18883b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType(*this, elementType, QualType(), 18893b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall numElements, ASM, elementTypeQuals, 18903b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall brackets); 18913b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(newType); 18923b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(newType, 0); 1893cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor } 1894cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor 18953b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Otherwise, we actually build a new type every time, but we 18963b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // also build a canonical type. 18971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 18983b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonElementType = getCanonicalType(elementType).split(); 1899898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 19003b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall void *insertPos = 0; 19013b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall llvm::FoldingSetNodeID ID; 19023b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType::Profile(ID, *this, 1903200fa53fd420aa8369586f569dbece04930ad6a3John McCall QualType(canonElementType.Ty, 0), 19043b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ASM, elementTypeQuals, numElements); 19053b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19063b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Look for an existing type with these properties. 19073b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType *canonTy = 19083b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos); 19093b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19103b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If we don't have one, build one. 19113b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!canonTy) { 19123b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall canonTy = new (*this, TypeAlignment) 1913200fa53fd420aa8369586f569dbece04930ad6a3John McCall DependentSizedArrayType(*this, QualType(canonElementType.Ty, 0), 19143b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType(), numElements, ASM, elementTypeQuals, 19153b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall brackets); 19163b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayTypes.InsertNode(canonTy, insertPos); 19173b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(canonTy); 19183b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall } 19193b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19203b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Apply qualifiers from the element type to the array. 19213b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType canon = getQualifiedType(QualType(canonTy,0), 1922200fa53fd420aa8369586f569dbece04930ad6a3John McCall canonElementType.Quals); 19233b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19243b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If we didn't need extra canonicalization for the element type, 19253b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // then just use that as our result. 1926200fa53fd420aa8369586f569dbece04930ad6a3John McCall if (QualType(canonElementType.Ty, 0) == elementType) 19273b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return canon; 19283b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19293b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Otherwise, we need to build a type which follows the spelling 19303b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // of the element type. 19313b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType *sugaredType 19323b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall = new (*this, TypeAlignment) 19333b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType(*this, elementType, canon, numElements, 19343b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ASM, elementTypeQuals, brackets); 19353b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(sugaredType); 19363b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(sugaredType, 0); 19373b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall} 19383b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19393b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getIncompleteArrayType(QualType elementType, 1940c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman ArrayType::ArraySizeModifier ASM, 19413b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall unsigned elementTypeQuals) const { 1942c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman llvm::FoldingSetNodeID ID; 19433b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType::Profile(ID, elementType, ASM, elementTypeQuals); 1944c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19453b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall void *insertPos = 0; 19463b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (IncompleteArrayType *iat = 19473b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos)) 19483b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(iat, 0); 1949c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1950c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // If the element type isn't canonical, this won't be a canonical type 19513b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // either, so fill in the canonical type field. We also have to pull 19523b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // qualifiers off the element type. 19533b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType canon; 1954c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19553b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!elementType.isCanonical() || elementType.hasLocalQualifiers()) { 19563b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = getCanonicalType(elementType).split(); 1957200fa53fd420aa8369586f569dbece04930ad6a3John McCall canon = getIncompleteArrayType(QualType(canonSplit.Ty, 0), 19583b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ASM, elementTypeQuals); 1959200fa53fd420aa8369586f569dbece04930ad6a3John McCall canon = getQualifiedType(canon, canonSplit.Quals); 1960c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1961c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // Get the new insert position for the node we care about. 19623b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType *existing = 19633b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos); 19643b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert(!existing && "Shouldn't be in the map!"); (void) existing; 19652bd24ba6d10f8c811c8e2a57c8397e07082ba497Ted Kremenek } 1966c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19673b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType *newType = new (*this, TypeAlignment) 19683b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType(elementType, canon, ASM, elementTypeQuals); 1969c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19703b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayTypes.InsertNode(newType, insertPos); 19713b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(newType); 19723b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(newType, 0); 1973fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff} 1974fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff 197573322924127c873c13101b705dd823f5539ffa5fSteve Naroff/// getVectorType - Return the unique reference to a vector type of 197673322924127c873c13101b705dd823f5539ffa5fSteve Naroff/// the specified element type and size. VectorType must be a built-in type. 197782287d19ded35248c4ce6a425ce74116a13ce44eJohn ThompsonQualType ASTContext::getVectorType(QualType vecType, unsigned NumElts, 19784ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad VectorType::VectorKind VecKind) const { 19793b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert(vecType->isBuiltinType()); 19801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 19815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Check if we've already instantiated a vector of this type. 19825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 1983e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType::Profile(ID, vecType, NumElts, Type::Vector, VecKind); 1984788b0fd67e1992f23555454efcdb16a19dfefac3Chris Lattner 19855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 19865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 19875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(VTP, 0); 19885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 19895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the element type isn't canonical, this won't be a canonical type either, 19905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // so fill in the canonical type field. 19915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 1992255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor if (!vecType.isCanonical()) { 1993231da7eb3dd13007e5e40fffe48998e5ef284e06Bob Wilson Canonical = getVectorType(getCanonicalType(vecType), NumElts, VecKind); 19941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 19955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 19965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 1997c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 19985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 19996b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall VectorType *New = new (*this, TypeAlignment) 2000e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType(vecType, NumElts, Canonical, VecKind); 20015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer VectorTypes.InsertNode(New, InsertPos); 20025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 20035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 20045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 20055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2006213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman/// getExtVectorType - Return the unique reference to an extended vector type of 200773322924127c873c13101b705dd823f5539ffa5fSteve Naroff/// the specified element type and size. VectorType must be a built-in type. 20084ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 20094ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getExtVectorType(QualType vecType, unsigned NumElts) const { 20104ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor assert(vecType->isBuiltinType() || vecType->isDependentType()); 20111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 201273322924127c873c13101b705dd823f5539ffa5fSteve Naroff // Check if we've already instantiated a vector of this type. 201373322924127c873c13101b705dd823f5539ffa5fSteve Naroff llvm::FoldingSetNodeID ID; 2014788b0fd67e1992f23555454efcdb16a19dfefac3Chris Lattner VectorType::Profile(ID, vecType, NumElts, Type::ExtVector, 2015e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType::GenericVector); 201673322924127c873c13101b705dd823f5539ffa5fSteve Naroff void *InsertPos = 0; 201773322924127c873c13101b705dd823f5539ffa5fSteve Naroff if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 201873322924127c873c13101b705dd823f5539ffa5fSteve Naroff return QualType(VTP, 0); 201973322924127c873c13101b705dd823f5539ffa5fSteve Naroff 202073322924127c873c13101b705dd823f5539ffa5fSteve Naroff // If the element type isn't canonical, this won't be a canonical type either, 202173322924127c873c13101b705dd823f5539ffa5fSteve Naroff // so fill in the canonical type field. 202273322924127c873c13101b705dd823f5539ffa5fSteve Naroff QualType Canonical; 2023467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!vecType.isCanonical()) { 2024213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman Canonical = getExtVectorType(getCanonicalType(vecType), NumElts); 20251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 202673322924127c873c13101b705dd823f5539ffa5fSteve Naroff // Get the new insert position for the node we care about. 202773322924127c873c13101b705dd823f5539ffa5fSteve Naroff VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2028c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 202973322924127c873c13101b705dd823f5539ffa5fSteve Naroff } 20306b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ExtVectorType *New = new (*this, TypeAlignment) 20316b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ExtVectorType(vecType, NumElts, Canonical); 203273322924127c873c13101b705dd823f5539ffa5fSteve Naroff VectorTypes.InsertNode(New, InsertPos); 203373322924127c873c13101b705dd823f5539ffa5fSteve Naroff Types.push_back(New); 203473322924127c873c13101b705dd823f5539ffa5fSteve Naroff return QualType(New, 0); 203573322924127c873c13101b705dd823f5539ffa5fSteve Naroff} 203673322924127c873c13101b705dd823f5539ffa5fSteve Naroff 20374ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 20384ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getDependentSizedExtVectorType(QualType vecType, 20394ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Expr *SizeExpr, 20404ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad SourceLocation AttrLoc) const { 20412ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor llvm::FoldingSetNodeID ID; 20421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump DependentSizedExtVectorType::Profile(ID, *this, getCanonicalType(vecType), 20432ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor SizeExpr); 20441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20452ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor void *InsertPos = 0; 20462ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor DependentSizedExtVectorType *Canon 20472ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos); 20482ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor DependentSizedExtVectorType *New; 20492ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor if (Canon) { 20502ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor // We already have a canonical version of this array type; use it as 20512ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor // the canonical type for a newly-built type. 20526b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall New = new (*this, TypeAlignment) 20536b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall DependentSizedExtVectorType(*this, vecType, QualType(Canon, 0), 20546b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall SizeExpr, AttrLoc); 20552ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } else { 20562ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor QualType CanonVecTy = getCanonicalType(vecType); 20572ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor if (CanonVecTy == vecType) { 20586b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall New = new (*this, TypeAlignment) 20596b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall DependentSizedExtVectorType(*this, vecType, QualType(), SizeExpr, 20606b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall AttrLoc); 2061789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2062789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentSizedExtVectorType *CanonCheck 2063789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2064789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!CanonCheck && "Dependent-sized ext_vector canonical type broken"); 2065789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CanonCheck; 20662ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor DependentSizedExtVectorTypes.InsertNode(New, InsertPos); 20672ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } else { 20682ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr, 20692ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor SourceLocation()); 20706b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall New = new (*this, TypeAlignment) 20716b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall DependentSizedExtVectorType(*this, vecType, Canon, SizeExpr, AttrLoc); 20722ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } 20732ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } 20741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20759cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor Types.push_back(New); 20769cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor return QualType(New, 0); 20779cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor} 20789cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor 207972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'. 20805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 20814ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 20824ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getFunctionNoProtoType(QualType ResultTy, 20834ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const FunctionType::ExtInfo &Info) const { 2084cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv DefaultCC = Info.getCC(); 2085cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv CallConv = (LangOpts.MRTD && DefaultCC == CC_Default) ? 2086cfe9af250f466e7e38becea4428990448ae07737Roman Divacky CC_X86StdCall : DefaultCC; 20875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique functions, to guarantee there is only one function of a particular 20885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 20895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 2090264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionNoProtoType::Profile(ID, ResultTy, Info); 20911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 20931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (FunctionNoProtoType *FT = 209472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) 20955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(FT, 0); 20961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 2098ab8bbf4ebd3e3e6eab913cb044772a62b7581941Douglas Gregor if (!ResultTy.isCanonical() || 209904a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall getCanonicalCallConv(CallConv) != CallConv) { 2100264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola Canonical = 2101264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola getFunctionNoProtoType(getCanonicalType(ResultTy), 2102264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola Info.withCallingConv(getCanonicalCallConv(CallConv))); 21031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 21045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 210572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoType *NewIP = 210672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos); 2107c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 21085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 21091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2110cfe9af250f466e7e38becea4428990448ae07737Roman Divacky FunctionProtoType::ExtInfo newInfo = Info.withCallingConv(CallConv); 21116b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall FunctionNoProtoType *New = new (*this, TypeAlignment) 2112cfe9af250f466e7e38becea4428990448ae07737Roman Divacky FunctionNoProtoType(ResultTy, Canonical, newInfo); 21135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 211472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoTypes.InsertNode(New, InsertPos); 21155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 21165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 21175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 21185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getFunctionType - Return a normal function type with a typed argument 21195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// list. isVariadic indicates whether the argument list includes '...'. 21204ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 21214ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getFunctionType(QualType ResultTy, 21224ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const QualType *ArgArray, unsigned NumArgs, 21234ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const FunctionProtoType::ExtProtoInfo &EPI) const { 21245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique functions, to guarantee there is only one function of a particular 21255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 21265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 21278026f6d82f7fa544bc0453714fe94bca62a1196eSebastian Redl FunctionProtoType::Profile(ID, ResultTy, ArgArray, NumArgs, EPI, *this); 21285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 21295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 21301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (FunctionProtoType *FTP = 213172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) 21325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(FTP, 0); 2133465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 2134465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl // Determine whether the type being created is already canonical or not. 2135eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith bool isCanonical = 2136eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith EPI.ExceptionSpecType == EST_None && ResultTy.isCanonical() && 2137eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith !EPI.HasTrailingReturn; 21385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0; i != NumArgs && isCanonical; ++i) 213954e14c4db764c0636160d26c5bbf491637c83a76John McCall if (!ArgArray[i].isCanonicalAsParam()) 21405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer isCanonical = false; 21415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2142cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv DefaultCC = EPI.ExtInfo.getCC(); 2143cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv CallConv = (LangOpts.MRTD && DefaultCC == CC_Default) ? 2144cfe9af250f466e7e38becea4428990448ae07737Roman Divacky CC_X86StdCall : DefaultCC; 2145e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 21465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this type isn't canonical, get the canonical version of it. 2147465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl // The exception spec is not part of the canonical type. 21485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 214904a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall if (!isCanonical || getCanonicalCallConv(CallConv) != CallConv) { 21505f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 16> CanonicalArgs; 21515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer CanonicalArgs.reserve(NumArgs); 21525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0; i != NumArgs; ++i) 215354e14c4db764c0636160d26c5bbf491637c83a76John McCall CanonicalArgs.push_back(getCanonicalParamType(ArgArray[i])); 2154465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 2155e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo CanonicalEPI = EPI; 2156eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith CanonicalEPI.HasTrailingReturn = false; 21578b5b4099c61a136e9a1714c4d8a593febe942268Sebastian Redl CanonicalEPI.ExceptionSpecType = EST_None; 21588b5b4099c61a136e9a1714c4d8a593febe942268Sebastian Redl CanonicalEPI.NumExceptions = 0; 2159e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall CanonicalEPI.ExtInfo 2160e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall = CanonicalEPI.ExtInfo.withCallingConv(getCanonicalCallConv(CallConv)); 2161e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 2162f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner Canonical = getFunctionType(getCanonicalType(ResultTy), 2163beaaccd8e2a8748f77b66e2b330fb9136937e14cJay Foad CanonicalArgs.data(), NumArgs, 2164e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall CanonicalEPI); 2165465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 21665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 216772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoType *NewIP = 216872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos); 2169c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 21705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2171465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 2172f85e193739c953358c865005855253af4f68a497John McCall // FunctionProtoType objects are allocated with extra bytes after 2173f85e193739c953358c865005855253af4f68a497John McCall // them for three variable size arrays at the end: 2174f85e193739c953358c865005855253af4f68a497John McCall // - parameter types 2175f85e193739c953358c865005855253af4f68a497John McCall // - exception types 2176f85e193739c953358c865005855253af4f68a497John McCall // - consumed-arguments flags 2177f85e193739c953358c865005855253af4f68a497John McCall // Instead of the exception types, there could be a noexcept 2178f85e193739c953358c865005855253af4f68a497John McCall // expression. 2179e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall size_t Size = sizeof(FunctionProtoType) + 218060618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl NumArgs * sizeof(QualType); 218160618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl if (EPI.ExceptionSpecType == EST_Dynamic) 218260618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl Size += EPI.NumExceptions * sizeof(QualType); 218360618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl else if (EPI.ExceptionSpecType == EST_ComputedNoexcept) { 21848026f6d82f7fa544bc0453714fe94bca62a1196eSebastian Redl Size += sizeof(Expr*); 218560618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl } 2186f85e193739c953358c865005855253af4f68a497John McCall if (EPI.ConsumedArguments) 2187f85e193739c953358c865005855253af4f68a497John McCall Size += NumArgs * sizeof(bool); 2188f85e193739c953358c865005855253af4f68a497John McCall 2189e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType *FTP = (FunctionProtoType*) Allocate(Size, TypeAlignment); 2190cfe9af250f466e7e38becea4428990448ae07737Roman Divacky FunctionProtoType::ExtProtoInfo newEPI = EPI; 2191cfe9af250f466e7e38becea4428990448ae07737Roman Divacky newEPI.ExtInfo = EPI.ExtInfo.withCallingConv(CallConv); 21928026f6d82f7fa544bc0453714fe94bca62a1196eSebastian Redl new (FTP) FunctionProtoType(ResultTy, ArgArray, NumArgs, Canonical, newEPI); 21935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(FTP); 219472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoTypes.InsertNode(FTP, InsertPos); 21955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(FTP, 0); 21965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 21975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 21983cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall#ifndef NDEBUG 21993cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallstatic bool NeedsInjectedClassNameType(const RecordDecl *D) { 22003cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (!isa<CXXRecordDecl>(D)) return false; 22013cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall const CXXRecordDecl *RD = cast<CXXRecordDecl>(D); 22023cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (isa<ClassTemplatePartialSpecializationDecl>(RD)) 22033cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return true; 22043cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (RD->getDescribedClassTemplate() && 22053cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall !isa<ClassTemplateSpecializationDecl>(RD)) 22063cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return true; 22073cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return false; 22083cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall} 22093cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall#endif 22103cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 22113cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall/// getInjectedClassNameType - Return the unique reference to the 22123cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall/// injected class name type for the specified templated declaration. 22133cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallQualType ASTContext::getInjectedClassNameType(CXXRecordDecl *Decl, 22144ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType TST) const { 22153cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(NeedsInjectedClassNameType(Decl)); 22163cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (Decl->TypeForDecl) { 22173cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(isa<InjectedClassNameType>(Decl->TypeForDecl)); 2218ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor } else if (CXXRecordDecl *PrevDecl = Decl->getPreviousDecl()) { 22193cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(PrevDecl->TypeForDecl && "previous declaration has no type"); 22203cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall Decl->TypeForDecl = PrevDecl->TypeForDecl; 22213cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(isa<InjectedClassNameType>(Decl->TypeForDecl)); 22223cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } else { 2223f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Type *newType = 222431f17ecbef57b5679c017c375db330546b7b5145John McCall new (*this, TypeAlignment) InjectedClassNameType(Decl, TST); 2225f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2226f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 22273cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } 22283cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return QualType(Decl->TypeForDecl, 0); 22293cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall} 22303cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 22312ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor/// getTypeDeclType - Return the unique reference to the type for the 22322ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor/// specified type declaration. 22334ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTypeDeclTypeSlow(const TypeDecl *Decl) const { 22341e6759e9e33dcaa73ce14c8a908ac9f87ac16463Argyrios Kyrtzidis assert(Decl && "Passed null for Decl param"); 2235becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall assert(!Decl->TypeForDecl && "TypeForDecl present in slow case"); 22361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2237162e1c1b487352434552147967c3dd296ebee2f7Richard Smith if (const TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Decl)) 22382ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor return getTypedefType(Typedef); 2239becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall 2240becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall assert(!isa<TemplateTypeParmDecl>(Decl) && 2241becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall "Template type parameter types are always available."); 2242becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall 224319c8576b7328f4dc2d07682f5da552875c1912efJohn McCall if (const RecordDecl *Record = dyn_cast<RecordDecl>(Decl)) { 2244ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor assert(!Record->getPreviousDecl() && 2245becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall "struct/union has previous declaration"); 2246becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall assert(!NeedsInjectedClassNameType(Record)); 2247400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return getRecordType(Record); 224819c8576b7328f4dc2d07682f5da552875c1912efJohn McCall } else if (const EnumDecl *Enum = dyn_cast<EnumDecl>(Decl)) { 2249ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor assert(!Enum->getPreviousDecl() && 2250becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall "enum has previous declaration"); 2251400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return getEnumType(Enum); 225219c8576b7328f4dc2d07682f5da552875c1912efJohn McCall } else if (const UnresolvedUsingTypenameDecl *Using = 2253ed97649e9574b9d854fa4d6109c9333ae0993554John McCall dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) { 2254f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Type *newType = new (*this, TypeAlignment) UnresolvedUsingType(Using); 2255f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2256f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 22579fdbab3cbc2fc04bcaf5768023d83707f3151144Mike Stump } else 2258becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall llvm_unreachable("TypeDecl without a type?"); 225949aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidis 226049aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidis return QualType(Decl->TypeForDecl, 0); 22612ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor} 22622ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor 22635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getTypedefType - Return the unique reference to the type for the 2264162e1c1b487352434552147967c3dd296ebee2f7Richard Smith/// specified typedef name decl. 22659763e221e16026ddf487d2564ed349d2c874a1a1Argyrios KyrtzidisQualType 2266162e1c1b487352434552147967c3dd296ebee2f7Richard SmithASTContext::getTypedefType(const TypedefNameDecl *Decl, 2267162e1c1b487352434552147967c3dd296ebee2f7Richard Smith QualType Canonical) const { 22685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 22691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 22709763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis if (Canonical.isNull()) 22719763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis Canonical = getCanonicalType(Decl->getUnderlyingType()); 2272f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall TypedefType *newType = new(*this, TypeAlignment) 22736b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypedefType(Type::Typedef, Decl, Canonical); 2274f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2275f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 2276f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall return QualType(newType, 0); 22775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 22785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 22794ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getRecordType(const RecordDecl *Decl) const { 2280400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 2281400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2282ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor if (const RecordDecl *PrevDecl = Decl->getPreviousDecl()) 2283400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (PrevDecl->TypeForDecl) 2284400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0); 2285400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2286f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall RecordType *newType = new (*this, TypeAlignment) RecordType(Decl); 2287f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2288f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 2289f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall return QualType(newType, 0); 2290400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis} 2291400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 22924ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getEnumType(const EnumDecl *Decl) const { 2293400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 2294400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2295ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor if (const EnumDecl *PrevDecl = Decl->getPreviousDecl()) 2296400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (PrevDecl->TypeForDecl) 2297400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0); 2298400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2299f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall EnumType *newType = new (*this, TypeAlignment) EnumType(Decl); 2300f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2301f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 2302f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall return QualType(newType, 0); 2303400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis} 2304400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 23059d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCallQualType ASTContext::getAttributedType(AttributedType::Kind attrKind, 23069d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall QualType modifiedType, 23079d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall QualType equivalentType) { 23089d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall llvm::FoldingSetNodeID id; 23099d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedType::Profile(id, attrKind, modifiedType, equivalentType); 23109d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23119d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall void *insertPos = 0; 23129d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedType *type = AttributedTypes.FindNodeOrInsertPos(id, insertPos); 23139d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall if (type) return QualType(type, 0); 23149d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23159d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall QualType canon = getCanonicalType(equivalentType); 23169d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall type = new (*this, TypeAlignment) 23179d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedType(canon, attrKind, modifiedType, equivalentType); 23189d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23199d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall Types.push_back(type); 23209d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedTypes.InsertNode(type, insertPos); 23219d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23229d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall return QualType(type, 0); 23239d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall} 23249d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23259d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 232649a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall/// \brief Retrieve a substitution-result type. 232749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCallQualType 232849a832bd499d6f61c23655f1fac99f0dd229756eJohn McCallASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm, 23294ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType Replacement) const { 2330467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(Replacement.isCanonical() 233149a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall && "replacement types must always be canonical"); 233249a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 233349a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall llvm::FoldingSetNodeID ID; 233449a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmType::Profile(ID, Parm, Replacement); 233549a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall void *InsertPos = 0; 233649a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmType *SubstParm 233749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 233849a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 233949a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall if (!SubstParm) { 234049a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstParm = new (*this, TypeAlignment) 234149a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmType(Parm, Replacement); 234249a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall Types.push_back(SubstParm); 234349a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos); 234449a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall } 234549a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 234649a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall return QualType(SubstParm, 0); 234749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall} 234849a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 2349c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor/// \brief Retrieve a 2350c3069d618f4661d923cb1b5c4525b082fce73b04Douglas GregorQualType ASTContext::getSubstTemplateTypeParmPackType( 2351c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor const TemplateTypeParmType *Parm, 2352c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor const TemplateArgument &ArgPack) { 2353c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor#ifndef NDEBUG 2354c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor for (TemplateArgument::pack_iterator P = ArgPack.pack_begin(), 2355c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor PEnd = ArgPack.pack_end(); 2356c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor P != PEnd; ++P) { 2357c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor assert(P->getKind() == TemplateArgument::Type &&"Pack contains a non-type"); 2358c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor assert(P->getAsType().isCanonical() && "Pack contains non-canonical type"); 2359c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor } 2360c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor#endif 2361c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2362c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor llvm::FoldingSetNodeID ID; 2363c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmPackType::Profile(ID, Parm, ArgPack); 2364c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor void *InsertPos = 0; 2365c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor if (SubstTemplateTypeParmPackType *SubstParm 2366c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor = SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos)) 2367c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor return QualType(SubstParm, 0); 2368c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2369c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor QualType Canon; 2370c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor if (!Parm->isCanonicalUnqualified()) { 2371c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor Canon = getCanonicalType(QualType(Parm, 0)); 2372c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor Canon = getSubstTemplateTypeParmPackType(cast<TemplateTypeParmType>(Canon), 2373c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor ArgPack); 2374c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos); 2375c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor } 2376c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2377c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmPackType *SubstParm 2378c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor = new (*this, TypeAlignment) SubstTemplateTypeParmPackType(Parm, Canon, 2379c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor ArgPack); 2380c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor Types.push_back(SubstParm); 2381c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos); 2382c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor return QualType(SubstParm, 0); 2383c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor} 2384c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2385fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor/// \brief Retrieve the template type parameter type for a template 23861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// parameter or parameter pack with the given depth, index, and (optionally) 238776e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson/// name. 23881eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index, 238976e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson bool ParameterPack, 23904fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TemplateTypeParmDecl *TTPDecl) const { 2391fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor llvm::FoldingSetNodeID ID; 23924fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, TTPDecl); 2393fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor void *InsertPos = 0; 23941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateTypeParmType *TypeParm 2395fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 2396fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 2397fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor if (TypeParm) 2398fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor return QualType(TypeParm, 0); 23991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 24004fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth if (TTPDecl) { 240176e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack); 24024fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TypeParm = new (*this, TypeAlignment) TemplateTypeParmType(TTPDecl, Canon); 2403789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2404789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor TemplateTypeParmType *TypeCheck 2405789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 2406789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!TypeCheck && "Template type parameter canonical type broken"); 2407789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)TypeCheck; 240876e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson } else 24096b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypeParm = new (*this, TypeAlignment) 24106b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TemplateTypeParmType(Depth, Index, ParameterPack); 2411fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 2412fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor Types.push_back(TypeParm); 2413fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos); 2414fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 2415fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor return QualType(TypeParm, 0); 2416fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor} 2417fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 24183cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallTypeSourceInfo * 24193cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallASTContext::getTemplateSpecializationTypeInfo(TemplateName Name, 24203cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall SourceLocation NameLoc, 24213cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall const TemplateArgumentListInfo &Args, 24223e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType Underlying) const { 24237c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Name.getAsDependentTemplateName() && 24247c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 24253e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType TST = getTemplateSpecializationType(Name, Args, Underlying); 24263cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 24273cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TypeSourceInfo *DI = CreateTypeSourceInfo(TST); 24283cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TemplateSpecializationTypeLoc TL 24293cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall = cast<TemplateSpecializationTypeLoc>(DI->getTypeLoc()); 243055d23c925b058be29b792008ddb7d68f6c4fa9a0Abramo Bagnara TL.setTemplateKeywordLoc(SourceLocation()); 24313cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setTemplateNameLoc(NameLoc); 24323cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setLAngleLoc(Args.getLAngleLoc()); 24333cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setRAngleLoc(Args.getRAngleLoc()); 24343cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 24353cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setArgLocInfo(i, Args[i].getLocInfo()); 24363cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return DI; 24373cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall} 24383cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 24391eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType 24407532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas GregorASTContext::getTemplateSpecializationType(TemplateName Template, 2441d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall const TemplateArgumentListInfo &Args, 24423e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType Underlying) const { 24437c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Template.getAsDependentTemplateName() && 24447c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 24457c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor 2446d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall unsigned NumArgs = Args.size(); 2447d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall 24485f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> ArgVec; 2449833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall ArgVec.reserve(NumArgs); 2450833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall for (unsigned i = 0; i != NumArgs; ++i) 2451833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall ArgVec.push_back(Args[i].getArgument()); 2452833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 245331f17ecbef57b5679c017c375db330546b7b5145John McCall return getTemplateSpecializationType(Template, ArgVec.data(), NumArgs, 24543e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith Underlying); 2455833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall} 2456833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 2457b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor#ifndef NDEBUG 2458b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregorstatic bool hasAnyPackExpansions(const TemplateArgument *Args, 2459b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor unsigned NumArgs) { 2460b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor for (unsigned I = 0; I != NumArgs; ++I) 2461b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor if (Args[I].isPackExpansion()) 2462b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor return true; 2463b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor 2464b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor return true; 2465b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor} 2466b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor#endif 2467b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor 2468833ca991c1bfc967f0995974ca86f66ba1f666b5John McCallQualType 2469833ca991c1bfc967f0995974ca86f66ba1f666b5John McCallASTContext::getTemplateSpecializationType(TemplateName Template, 24707532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor const TemplateArgument *Args, 24717532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor unsigned NumArgs, 24723e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType Underlying) const { 24737c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Template.getAsDependentTemplateName() && 24747c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 24750f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor // Look through qualified template names. 24760f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 24770f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor Template = TemplateName(QTN->getTemplateDecl()); 24787c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor 2479b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor bool IsTypeAlias = 24803e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith Template.getAsTemplateDecl() && 24813e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith isa<TypeAliasTemplateDecl>(Template.getAsTemplateDecl()); 24823e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType CanonType; 24833e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith if (!Underlying.isNull()) 24843e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith CanonType = getCanonicalType(Underlying); 24853e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith else { 2486b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor // We can get here with an alias template when the specialization contains 2487b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor // a pack expansion that does not match up with a parameter pack. 2488b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor assert((!IsTypeAlias || hasAnyPackExpansions(Args, NumArgs)) && 2489b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor "Caller must compute aliased type"); 2490b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor IsTypeAlias = false; 24913e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith CanonType = getCanonicalTemplateSpecializationType(Template, Args, 24923e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith NumArgs); 24933e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith } 2494fc705b84347e6fb4746a1a7e26949f64c2f2f358Douglas Gregor 24951275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // Allocate the (non-canonical) template specialization type, but don't 24961275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // try to unique it: these types typically have location information that 24971275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // we don't unique and don't want to lose. 24983e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith void *Mem = Allocate(sizeof(TemplateSpecializationType) + 24993e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith sizeof(TemplateArgument) * NumArgs + 2500b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor (IsTypeAlias? sizeof(QualType) : 0), 25016b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypeAlignment); 25021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateSpecializationType *Spec 2503b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor = new (Mem) TemplateSpecializationType(Template, Args, NumArgs, CanonType, 2504b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor IsTypeAlias ? Underlying : QualType()); 25051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 250655f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor Types.push_back(Spec); 25071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return QualType(Spec, 0); 250855f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor} 250955f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 25101eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType 25119763e221e16026ddf487d2564ed349d2c874a1a1Argyrios KyrtzidisASTContext::getCanonicalTemplateSpecializationType(TemplateName Template, 25129763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis const TemplateArgument *Args, 25134ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned NumArgs) const { 25147c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Template.getAsDependentTemplateName() && 25157c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 25163e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith 25170f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor // Look through qualified template names. 25180f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 25190f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor Template = TemplateName(QTN->getTemplateDecl()); 25207c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor 25219763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Build the canonical template specialization type. 25229763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateName CanonTemplate = getCanonicalTemplateName(Template); 25235f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> CanonArgs; 25249763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.reserve(NumArgs); 25259763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis for (unsigned I = 0; I != NumArgs; ++I) 25269763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.push_back(getCanonicalTemplateArgument(Args[I])); 25279763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25289763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Determine whether this canonical template specialization type already 25299763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // exists. 25309763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis llvm::FoldingSetNodeID ID; 25319763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateSpecializationType::Profile(ID, CanonTemplate, 25329763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.data(), NumArgs, *this); 25339763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25349763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis void *InsertPos = 0; 25359763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateSpecializationType *Spec 25369763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 25379763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25389763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis if (!Spec) { 25399763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Allocate a new canonical template specialization type. 25409763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis void *Mem = Allocate((sizeof(TemplateSpecializationType) + 25419763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis sizeof(TemplateArgument) * NumArgs), 25429763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TypeAlignment); 25439763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis Spec = new (Mem) TemplateSpecializationType(CanonTemplate, 25449763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.data(), NumArgs, 25453e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType(), QualType()); 25469763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis Types.push_back(Spec); 25479763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateSpecializationTypes.InsertNode(Spec, InsertPos); 25489763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis } 25499763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25509763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis assert(Spec->isDependentType() && 25519763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis "Non-dependent template-id type must have a canonical type"); 25529763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis return QualType(Spec, 0); 25539763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis} 25549763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25559763e221e16026ddf487d2564ed349d2c874a1a1Argyrios KyrtzidisQualType 2556465d41b92b2c862f3062c412a0538db65c6a2661Abramo BagnaraASTContext::getElaboratedType(ElaboratedTypeKeyword Keyword, 2557465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara NestedNameSpecifier *NNS, 25584ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType NamedType) const { 2559e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor llvm::FoldingSetNodeID ID; 2560465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedType::Profile(ID, Keyword, NNS, NamedType); 2561e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor 2562e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor void *InsertPos = 0; 2563465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedType *T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos); 2564e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor if (T) 2565e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor return QualType(T, 0); 2566e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor 2567789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor QualType Canon = NamedType; 2568789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor if (!Canon.isCanonical()) { 2569789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor Canon = getCanonicalType(NamedType); 2570465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedType *CheckT = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos); 2571465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara assert(!CheckT && "Elaborated canonical type broken"); 2572789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CheckT; 2573789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor } 2574789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2575465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara T = new (*this) ElaboratedType(Keyword, NNS, NamedType, Canon); 2576e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor Types.push_back(T); 2577465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedTypes.InsertNode(T, InsertPos); 2578e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor return QualType(T, 0); 2579e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor} 2580e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor 2581075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo BagnaraQualType 25824ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getParenType(QualType InnerType) const { 2583075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara llvm::FoldingSetNodeID ID; 2584075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenType::Profile(ID, InnerType); 2585075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 2586075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara void *InsertPos = 0; 2587075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenType *T = ParenTypes.FindNodeOrInsertPos(ID, InsertPos); 2588075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara if (T) 2589075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return QualType(T, 0); 2590075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 2591075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara QualType Canon = InnerType; 2592075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara if (!Canon.isCanonical()) { 2593075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara Canon = getCanonicalType(InnerType); 2594075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos); 2595075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara assert(!CheckT && "Paren canonical type broken"); 2596075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara (void)CheckT; 2597075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara } 2598075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 2599075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara T = new (*this) ParenType(InnerType, Canon); 2600075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara Types.push_back(T); 2601075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenTypes.InsertNode(T, InsertPos); 2602075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return QualType(T, 0); 2603075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara} 2604075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 26054a2023f5014e82389d5980d307b89c545dbbac81Douglas GregorQualType ASTContext::getDependentNameType(ElaboratedTypeKeyword Keyword, 26064a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor NestedNameSpecifier *NNS, 26074a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor const IdentifierInfo *Name, 26084ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType Canon) const { 2609d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor assert(NNS->isDependent() && "nested-name-specifier must be dependent"); 2610d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2611d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor if (Canon.isNull()) { 2612d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 26134a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor ElaboratedTypeKeyword CanonKeyword = Keyword; 26144a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor if (Keyword == ETK_None) 26154a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor CanonKeyword = ETK_Typename; 26164a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor 26174a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor if (CanonNNS != NNS || CanonKeyword != Keyword) 26184a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor Canon = getDependentNameType(CanonKeyword, CanonNNS, Name); 2619d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor } 2620d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2621d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor llvm::FoldingSetNodeID ID; 26224a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor DependentNameType::Profile(ID, Keyword, NNS, Name); 2623d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2624d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor void *InsertPos = 0; 26254714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor DependentNameType *T 26264714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos); 2627d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor if (T) 2628d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor return QualType(T, 0); 2629d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 26304a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor T = new (*this) DependentNameType(Keyword, NNS, Name, Canon); 2631d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor Types.push_back(T); 26324714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor DependentNameTypes.InsertNode(T, InsertPos); 26331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return QualType(T, 0); 2634d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor} 2635d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 26361eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType 263733500955d731c73717af52088b7fc0e7a85681e7John McCallASTContext::getDependentTemplateSpecializationType( 263833500955d731c73717af52088b7fc0e7a85681e7John McCall ElaboratedTypeKeyword Keyword, 26394a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor NestedNameSpecifier *NNS, 264033500955d731c73717af52088b7fc0e7a85681e7John McCall const IdentifierInfo *Name, 26414ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const TemplateArgumentListInfo &Args) const { 264233500955d731c73717af52088b7fc0e7a85681e7John McCall // TODO: avoid this copy 26435f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 16> ArgCopy; 264433500955d731c73717af52088b7fc0e7a85681e7John McCall for (unsigned I = 0, E = Args.size(); I != E; ++I) 264533500955d731c73717af52088b7fc0e7a85681e7John McCall ArgCopy.push_back(Args[I].getArgument()); 264633500955d731c73717af52088b7fc0e7a85681e7John McCall return getDependentTemplateSpecializationType(Keyword, NNS, Name, 264733500955d731c73717af52088b7fc0e7a85681e7John McCall ArgCopy.size(), 264833500955d731c73717af52088b7fc0e7a85681e7John McCall ArgCopy.data()); 264933500955d731c73717af52088b7fc0e7a85681e7John McCall} 265033500955d731c73717af52088b7fc0e7a85681e7John McCall 265133500955d731c73717af52088b7fc0e7a85681e7John McCallQualType 265233500955d731c73717af52088b7fc0e7a85681e7John McCallASTContext::getDependentTemplateSpecializationType( 265333500955d731c73717af52088b7fc0e7a85681e7John McCall ElaboratedTypeKeyword Keyword, 265433500955d731c73717af52088b7fc0e7a85681e7John McCall NestedNameSpecifier *NNS, 265533500955d731c73717af52088b7fc0e7a85681e7John McCall const IdentifierInfo *Name, 265633500955d731c73717af52088b7fc0e7a85681e7John McCall unsigned NumArgs, 26574ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const TemplateArgument *Args) const { 2658aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor assert((!NNS || NNS->isDependent()) && 2659aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor "nested-name-specifier must be dependent"); 26601734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 2661789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor llvm::FoldingSetNodeID ID; 266233500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS, 266333500955d731c73717af52088b7fc0e7a85681e7John McCall Name, NumArgs, Args); 2664789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2665789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor void *InsertPos = 0; 266633500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationType *T 266733500955d731c73717af52088b7fc0e7a85681e7John McCall = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 2668789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor if (T) 2669789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor return QualType(T, 0); 2670789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 267133500955d731c73717af52088b7fc0e7a85681e7John McCall NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 267233500955d731c73717af52088b7fc0e7a85681e7John McCall 267333500955d731c73717af52088b7fc0e7a85681e7John McCall ElaboratedTypeKeyword CanonKeyword = Keyword; 267433500955d731c73717af52088b7fc0e7a85681e7John McCall if (Keyword == ETK_None) CanonKeyword = ETK_Typename; 26751734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 267633500955d731c73717af52088b7fc0e7a85681e7John McCall bool AnyNonCanonArgs = false; 26775f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 16> CanonArgs(NumArgs); 267833500955d731c73717af52088b7fc0e7a85681e7John McCall for (unsigned I = 0; I != NumArgs; ++I) { 267933500955d731c73717af52088b7fc0e7a85681e7John McCall CanonArgs[I] = getCanonicalTemplateArgument(Args[I]); 268033500955d731c73717af52088b7fc0e7a85681e7John McCall if (!CanonArgs[I].structurallyEquals(Args[I])) 268133500955d731c73717af52088b7fc0e7a85681e7John McCall AnyNonCanonArgs = true; 2682789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor } 26831734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 268433500955d731c73717af52088b7fc0e7a85681e7John McCall QualType Canon; 268533500955d731c73717af52088b7fc0e7a85681e7John McCall if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) { 268633500955d731c73717af52088b7fc0e7a85681e7John McCall Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS, 268733500955d731c73717af52088b7fc0e7a85681e7John McCall Name, NumArgs, 268833500955d731c73717af52088b7fc0e7a85681e7John McCall CanonArgs.data()); 268933500955d731c73717af52088b7fc0e7a85681e7John McCall 269033500955d731c73717af52088b7fc0e7a85681e7John McCall // Find the insert position again. 269133500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 269233500955d731c73717af52088b7fc0e7a85681e7John McCall } 269333500955d731c73717af52088b7fc0e7a85681e7John McCall 269433500955d731c73717af52088b7fc0e7a85681e7John McCall void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) + 269533500955d731c73717af52088b7fc0e7a85681e7John McCall sizeof(TemplateArgument) * NumArgs), 269633500955d731c73717af52088b7fc0e7a85681e7John McCall TypeAlignment); 2697ef99001908e799c388f1363b1e607dad5f5b57d3John McCall T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS, 269833500955d731c73717af52088b7fc0e7a85681e7John McCall Name, NumArgs, Args, Canon); 26991734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor Types.push_back(T); 270033500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationTypes.InsertNode(T, InsertPos); 27011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return QualType(T, 0); 27021734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor} 27031734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 2704cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas GregorQualType ASTContext::getPackExpansionType(QualType Pattern, 2705cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor llvm::Optional<unsigned> NumExpansions) { 27067536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor llvm::FoldingSetNodeID ID; 2707cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor PackExpansionType::Profile(ID, Pattern, NumExpansions); 27087536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 27097536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor assert(Pattern->containsUnexpandedParameterPack() && 27107536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor "Pack expansions must expand one or more parameter packs"); 27117536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor void *InsertPos = 0; 27127536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor PackExpansionType *T 27137536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor = PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos); 27147536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor if (T) 27157536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor return QualType(T, 0); 27167536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 27177536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor QualType Canon; 27187536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor if (!Pattern.isCanonical()) { 2719cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor Canon = getPackExpansionType(getCanonicalType(Pattern), NumExpansions); 27207536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 27217536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor // Find the insert position again. 27227536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos); 27237536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor } 27247536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 2725cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor T = new (*this) PackExpansionType(Pattern, Canon, NumExpansions); 27267536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor Types.push_back(T); 27277536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor PackExpansionTypes.InsertNode(T, InsertPos); 27287536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor return QualType(T, 0); 27297536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor} 27307536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 273188cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner/// CmpProtocolNames - Comparison predicate for sorting protocols 273288cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner/// alphabetically. 273388cb27a160adc305783a44f922ee4b216006ebf9Chris Lattnerstatic bool CmpProtocolNames(const ObjCProtocolDecl *LHS, 273488cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner const ObjCProtocolDecl *RHS) { 27352e1cd4264d363ca869bf37ef160902f211d21b8cDouglas Gregor return LHS->getDeclName() < RHS->getDeclName(); 273688cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner} 273788cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 2738c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCallstatic bool areSortedAndUniqued(ObjCProtocolDecl * const *Protocols, 273954e14c4db764c0636160d26c5bbf491637c83a76John McCall unsigned NumProtocols) { 274054e14c4db764c0636160d26c5bbf491637c83a76John McCall if (NumProtocols == 0) return true; 274154e14c4db764c0636160d26c5bbf491637c83a76John McCall 274261cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor if (Protocols[0]->getCanonicalDecl() != Protocols[0]) 274361cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor return false; 274461cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor 274554e14c4db764c0636160d26c5bbf491637c83a76John McCall for (unsigned i = 1; i != NumProtocols; ++i) 274661cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor if (!CmpProtocolNames(Protocols[i-1], Protocols[i]) || 274761cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor Protocols[i]->getCanonicalDecl() != Protocols[i]) 274854e14c4db764c0636160d26c5bbf491637c83a76John McCall return false; 274954e14c4db764c0636160d26c5bbf491637c83a76John McCall return true; 275054e14c4db764c0636160d26c5bbf491637c83a76John McCall} 275154e14c4db764c0636160d26c5bbf491637c83a76John McCall 275254e14c4db764c0636160d26c5bbf491637c83a76John McCallstatic void SortAndUniqueProtocols(ObjCProtocolDecl **Protocols, 275388cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner unsigned &NumProtocols) { 275488cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner ObjCProtocolDecl **ProtocolsEnd = Protocols+NumProtocols; 27551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 275688cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner // Sort protocols, keyed by name. 275788cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner std::sort(Protocols, Protocols+NumProtocols, CmpProtocolNames); 275888cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 275961cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor // Canonicalize. 276061cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor for (unsigned I = 0, N = NumProtocols; I != N; ++I) 276161cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor Protocols[I] = Protocols[I]->getCanonicalDecl(); 276261cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor 276388cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner // Remove duplicates. 276488cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner ProtocolsEnd = std::unique(Protocols, ProtocolsEnd); 276588cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner NumProtocols = ProtocolsEnd-Protocols; 276688cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner} 276788cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 2768c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCallQualType ASTContext::getObjCObjectType(QualType BaseType, 2769c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCProtocolDecl * const *Protocols, 27704ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned NumProtocols) const { 2771c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // If the base type is an interface and there aren't any protocols 2772c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // to add, then the interface type will do just fine. 2773c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!NumProtocols && isa<ObjCInterfaceType>(BaseType)) 2774c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return BaseType; 2775d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff 2776c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Look in the folding set for an existing type. 2777c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall llvm::FoldingSetNodeID ID; 2778c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypeImpl::Profile(ID, BaseType, Protocols, NumProtocols); 2779d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff void *InsertPos = 0; 2780c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos)) 2781c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return QualType(QT, 0); 2782d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff 2783c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Build the canonical type, which has the canonical base type and 2784c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // a sorted-and-uniqued list of protocols. 278554e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType Canonical; 2786c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall bool ProtocolsSorted = areSortedAndUniqued(Protocols, NumProtocols); 2787c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!ProtocolsSorted || !BaseType.isCanonical()) { 2788c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!ProtocolsSorted) { 27895f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<ObjCProtocolDecl*, 8> Sorted(Protocols, 27900237941e0beb0c929934b66ad29443b484d987feBenjamin Kramer Protocols + NumProtocols); 279154e14c4db764c0636160d26c5bbf491637c83a76John McCall unsigned UniqueCount = NumProtocols; 279254e14c4db764c0636160d26c5bbf491637c83a76John McCall 279354e14c4db764c0636160d26c5bbf491637c83a76John McCall SortAndUniqueProtocols(&Sorted[0], UniqueCount); 2794c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Canonical = getObjCObjectType(getCanonicalType(BaseType), 2795c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall &Sorted[0], UniqueCount); 279654e14c4db764c0636160d26c5bbf491637c83a76John McCall } else { 2797c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Canonical = getObjCObjectType(getCanonicalType(BaseType), 2798c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Protocols, NumProtocols); 279954e14c4db764c0636160d26c5bbf491637c83a76John McCall } 280054e14c4db764c0636160d26c5bbf491637c83a76John McCall 280154e14c4db764c0636160d26c5bbf491637c83a76John McCall // Regenerate InsertPos. 2802c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos); 280354e14c4db764c0636160d26c5bbf491637c83a76John McCall } 280454e14c4db764c0636160d26c5bbf491637c83a76John McCall 2805c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall unsigned Size = sizeof(ObjCObjectTypeImpl); 2806c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Size += NumProtocols * sizeof(ObjCProtocolDecl *); 2807fd6a0887a099256c35a5b23e9afd517ffe95fa0aDouglas Gregor void *Mem = Allocate(Size, TypeAlignment); 2808c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypeImpl *T = 2809c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall new (Mem) ObjCObjectTypeImpl(Canonical, BaseType, Protocols, NumProtocols); 28101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2811c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Types.push_back(T); 2812c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypes.InsertNode(T, InsertPos); 2813c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return QualType(T, 0); 2814d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff} 281588cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 2816c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall/// getObjCObjectPointerType - Return a ObjCObjectPointerType type for 2817c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall/// the given object type. 28184ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getObjCObjectPointerType(QualType ObjectT) const { 28194b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian llvm::FoldingSetNodeID ID; 2820c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerType::Profile(ID, ObjectT); 28211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 28224b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian void *InsertPos = 0; 2823c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (ObjCObjectPointerType *QT = 2824c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 28254b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian return QualType(QT, 0); 28261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2827c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Find the canonical object type. 282854e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType Canonical; 2829c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!ObjectT.isCanonical()) { 2830c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Canonical = getObjCObjectPointerType(getCanonicalType(ObjectT)); 283154e14c4db764c0636160d26c5bbf491637c83a76John McCall 2832c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Regenerate InsertPos. 2833c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 283454e14c4db764c0636160d26c5bbf491637c83a76John McCall } 283554e14c4db764c0636160d26c5bbf491637c83a76John McCall 2836c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // No match. 2837c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall void *Mem = Allocate(sizeof(ObjCObjectPointerType), TypeAlignment); 2838c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerType *QType = 2839c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall new (Mem) ObjCObjectPointerType(Canonical, ObjectT); 284024fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis 284124fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis Types.push_back(QType); 2842c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerTypes.InsertNode(QType, InsertPos); 284324fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis return QualType(QType, 0); 284424fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis} 284524fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis 2846deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor/// getObjCInterfaceType - Return the unique reference to the type for the 2847deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor/// specified ObjC interface decl. The list of protocols is optional. 28480af550115df1f57f17a4f125ff0e8b34820c65d1Douglas GregorQualType ASTContext::getObjCInterfaceType(const ObjCInterfaceDecl *Decl, 28490af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor ObjCInterfaceDecl *PrevDecl) const { 2850deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor if (Decl->TypeForDecl) 2851deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor return QualType(Decl->TypeForDecl, 0); 285274c730ad1f6818b676b0bad46d806a9176950328Sebastian Redl 28530af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor if (PrevDecl) { 28540af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor assert(PrevDecl->TypeForDecl && "previous decl has no TypeForDecl"); 28550af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor Decl->TypeForDecl = PrevDecl->TypeForDecl; 28560af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor return QualType(PrevDecl->TypeForDecl, 0); 28570af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor } 28580af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor 28598d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor // Prefer the definition, if there is one. 28608d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor if (const ObjCInterfaceDecl *Def = Decl->getDefinition()) 28618d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor Decl = Def; 28628d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor 2863deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor void *Mem = Allocate(sizeof(ObjCInterfaceType), TypeAlignment); 2864deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor ObjCInterfaceType *T = new (Mem) ObjCInterfaceType(Decl); 2865deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor Decl->TypeForDecl = T; 2866deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor Types.push_back(T); 2867deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor return QualType(T, 0); 2868c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall} 2869c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 287072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor/// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique 287172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor/// TypeOfExprType AST's (since expression's are never shared). For example, 28729752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// multiple declarations that refer to "typeof(x)" all contain different 28731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// DeclRefExpr's. This doesn't effect the type checker, since it operates 28749752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// on canonical type's (which are always unique). 28754ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTypeOfExprType(Expr *tofExpr) const { 2876dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor TypeOfExprType *toe; 2877b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor if (tofExpr->isTypeDependent()) { 2878b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor llvm::FoldingSetNodeID ID; 2879b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor DependentTypeOfExprType::Profile(ID, *this, tofExpr); 28801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2881b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor void *InsertPos = 0; 2882b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor DependentTypeOfExprType *Canon 2883b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos); 2884b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor if (Canon) { 2885b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor // We already have a "canonical" version of an identical, dependent 2886b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor // typeof(expr) type. Use that as our canonical type. 28876b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, 2888b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor QualType((TypeOfExprType*)Canon, 0)); 28893060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 2890b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor // Build a new, canonical typeof(expr) type. 28916b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall Canon 28926b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr); 2893b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor DependentTypeOfExprTypes.InsertNode(Canon, InsertPos); 2894b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor toe = Canon; 2895b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor } 2896b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor } else { 2897dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor QualType Canonical = getCanonicalType(tofExpr->getType()); 28986b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical); 2899dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor } 29009752f25748d954df99087d741ea35db37ff16beaSteve Naroff Types.push_back(toe); 29019752f25748d954df99087d741ea35db37ff16beaSteve Naroff return QualType(toe, 0); 2902d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff} 2903d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff 29049752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// getTypeOfType - Unlike many "get<Type>" functions, we don't unique 29059752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// TypeOfType AST's. The only motivation to unique these nodes would be 29069752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be 29071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// an issue. This doesn't effect the type checker, since it operates 29089752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// on canonical type's (which are always unique). 29094ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTypeOfType(QualType tofType) const { 2910f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner QualType Canonical = getCanonicalType(tofType); 29116b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypeOfType *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical); 29129752f25748d954df99087d741ea35db37ff16beaSteve Naroff Types.push_back(tot); 29139752f25748d954df99087d741ea35db37ff16beaSteve Naroff return QualType(tot, 0); 2914d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff} 2915d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff 291660a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson/// getDecltypeForExpr - Given an expr, will return the decltype for that 291760a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson/// expression, according to the rules in C++0x [dcl.type.simple]p4 29184ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadstatic QualType getDecltypeForExpr(const Expr *e, const ASTContext &Context) { 2919a07c33e64e1169e4261f7748c7f9191091a3ad2eAnders Carlsson if (e->isTypeDependent()) 2920a07c33e64e1169e4261f7748c7f9191091a3ad2eAnders Carlsson return Context.DependentTy; 29211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 292260a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson // If e is an id expression or a class member access, decltype(e) is defined 292360a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson // as the type of the entity named by e. 292460a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(e)) { 292560a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson if (const ValueDecl *VD = dyn_cast<ValueDecl>(DRE->getDecl())) 292660a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson return VD->getType(); 292760a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson } 292860a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson if (const MemberExpr *ME = dyn_cast<MemberExpr>(e)) { 292960a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson if (const FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) 293060a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson return FD->getType(); 293160a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson } 293260a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson // If e is a function call or an invocation of an overloaded operator, 293360a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson // (parentheses around e are ignored), decltype(e) is defined as the 293460a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson // return type of that function. 293560a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson if (const CallExpr *CE = dyn_cast<CallExpr>(e->IgnoreParens())) 293660a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson return CE->getCallReturnType(); 29371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 293860a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson QualType T = e->getType(); 29391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 29401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Otherwise, where T is the type of e, if e is an lvalue, decltype(e) is 294160a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson // defined as T&, otherwise decltype(e) is defined as T. 29427eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall if (e->isLValue()) 294360a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson T = Context.getLValueReferenceType(T); 29441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 294560a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson return T; 294660a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson} 294760a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson 2948395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson/// getDecltypeType - Unlike many "get<Type>" functions, we don't unique 2949395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson/// DecltypeType AST's. The only motivation to unique these nodes would be 2950395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson/// memory savings. Since decltype(t) is fairly uncommon, space shouldn't be 29511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// an issue. This doesn't effect the type checker, since it operates 295239e02032b01874a0d02ba85a4cd3922adda81376David Blaikie/// on canonical types (which are always unique). 29534ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getDecltypeType(Expr *e) const { 2954dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor DecltypeType *dt; 2955561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor 2956561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // C++0x [temp.type]p2: 2957561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // If an expression e involves a template parameter, decltype(e) denotes a 2958561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // unique dependent type. Two such decltype-specifiers refer to the same 2959561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // type only if their expressions are equivalent (14.5.6.1). 2960561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor if (e->isInstantiationDependent()) { 29619d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor llvm::FoldingSetNodeID ID; 29629d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor DependentDecltypeType::Profile(ID, *this, e); 29631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 29649d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor void *InsertPos = 0; 29659d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor DependentDecltypeType *Canon 29669d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos); 29679d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor if (Canon) { 29689d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor // We already have a "canonical" version of an equivalent, dependent 29699d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor // decltype type. Use that as our canonical type. 29706b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall dt = new (*this, TypeAlignment) DecltypeType(e, DependentTy, 29719d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor QualType((DecltypeType*)Canon, 0)); 29723060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 29739d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor // Build a new, canonical typeof(expr) type. 29746b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall Canon = new (*this, TypeAlignment) DependentDecltypeType(*this, e); 29759d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor DependentDecltypeTypes.InsertNode(Canon, InsertPos); 29769d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor dt = Canon; 29779d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor } 29789d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor } else { 2979dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor QualType T = getDecltypeForExpr(e, *this); 29806b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall dt = new (*this, TypeAlignment) DecltypeType(e, T, getCanonicalType(T)); 2981dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor } 2982395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson Types.push_back(dt); 2983395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson return QualType(dt, 0); 2984395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson} 2985395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson 2986ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt/// getUnaryTransformationType - We don't unique these, since the memory 2987ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt/// savings are minimal and these are rare. 2988ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean HuntQualType ASTContext::getUnaryTransformType(QualType BaseType, 2989ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt QualType UnderlyingType, 2990ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt UnaryTransformType::UTTKind Kind) 2991ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt const { 2992ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt UnaryTransformType *Ty = 299369d9775da47a4b9f165dbc33277f02982928a94eDouglas Gregor new (*this, TypeAlignment) UnaryTransformType (BaseType, UnderlyingType, 299469d9775da47a4b9f165dbc33277f02982928a94eDouglas Gregor Kind, 299569d9775da47a4b9f165dbc33277f02982928a94eDouglas Gregor UnderlyingType->isDependentType() ? 299669d9775da47a4b9f165dbc33277f02982928a94eDouglas Gregor QualType() : UnderlyingType); 2997ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt Types.push_back(Ty); 2998ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt return QualType(Ty, 0); 2999ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt} 3000ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt 3001483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith/// getAutoType - We only unique auto types after they've been deduced. 300234b41d939a1328f484511c6002ba2456db879a29Richard SmithQualType ASTContext::getAutoType(QualType DeducedType) const { 3003483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith void *InsertPos = 0; 3004483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith if (!DeducedType.isNull()) { 3005483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith // Look in the folding set for an existing type. 3006483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith llvm::FoldingSetNodeID ID; 3007483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith AutoType::Profile(ID, DeducedType); 3008483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith if (AutoType *AT = AutoTypes.FindNodeOrInsertPos(ID, InsertPos)) 3009483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith return QualType(AT, 0); 3010483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith } 3011483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith 3012483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith AutoType *AT = new (*this, TypeAlignment) AutoType(DeducedType); 3013483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith Types.push_back(AT); 3014483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith if (InsertPos) 3015483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith AutoTypes.InsertNode(AT, InsertPos); 3016483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith return QualType(AT, 0); 301734b41d939a1328f484511c6002ba2456db879a29Richard Smith} 301834b41d939a1328f484511c6002ba2456db879a29Richard Smith 3019b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman/// getAtomicType - Return the uniqued reference to the atomic type for 3020b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman/// the given value type. 3021b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli FriedmanQualType ASTContext::getAtomicType(QualType T) const { 3022b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // Unique pointers, to guarantee there is only one pointer of a particular 3023b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // structure. 3024b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman llvm::FoldingSetNodeID ID; 3025b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicType::Profile(ID, T); 3026b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 3027b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman void *InsertPos = 0; 3028b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos)) 3029b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return QualType(AT, 0); 3030b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 3031b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // If the atomic value type isn't canonical, this won't be a canonical type 3032b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // either, so fill in the canonical type field. 3033b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType Canonical; 3034b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (!T.isCanonical()) { 3035b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman Canonical = getAtomicType(getCanonicalType(T)); 3036b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 3037b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // Get the new insert position for the node we care about. 3038b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos); 3039b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 3040b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 3041b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicType *New = new (*this, TypeAlignment) AtomicType(T, Canonical); 3042b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman Types.push_back(New); 3043b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicTypes.InsertNode(New, InsertPos); 3044b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return QualType(New, 0); 3045b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman} 3046b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 3047ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// getAutoDeductType - Get type pattern for deducing against 'auto'. 3048ad762fcdc16b9e4705b12b09d92b8c026212b906Richard SmithQualType ASTContext::getAutoDeductType() const { 3049ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith if (AutoDeductTy.isNull()) 3050ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith AutoDeductTy = getAutoType(QualType()); 3051ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith assert(!AutoDeductTy.isNull() && "can't build 'auto' pattern"); 3052ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith return AutoDeductTy; 3053ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith} 3054ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith 3055ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// getAutoRRefDeductType - Get type pattern for deducing against 'auto &&'. 3056ad762fcdc16b9e4705b12b09d92b8c026212b906Richard SmithQualType ASTContext::getAutoRRefDeductType() const { 3057ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith if (AutoRRefDeductTy.isNull()) 3058ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith AutoRRefDeductTy = getRValueReferenceType(getAutoDeductType()); 3059ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith assert(!AutoRRefDeductTy.isNull() && "can't build 'auto &&' pattern"); 3060ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith return AutoRRefDeductTy; 3061ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith} 3062ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith 30635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getTagDeclType - Return the unique reference to the type for the 30645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// specified TagDecl (struct/union/class/enum) decl. 30654ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTagDeclType(const TagDecl *Decl) const { 3066d778f88d32b96a74c9edb7342c81357606a7cdc0Ted Kremenek assert (Decl); 3067e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump // FIXME: What is the design on getTagDeclType when it requires casting 3068e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump // away const? mutable? 3069e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump return getTypeDeclType(const_cast<TagDecl*>(Decl)); 30705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 30715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 30721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getSizeType - Return the unique type for "size_t" (C99 7.17), the result 30731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and 30741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// needs to agree with the definition in <stddef.h>. 3075a3ccda58913cc1a4b8564e349448b12acc462da7Anders CarlssonCanQualType ASTContext::getSizeType() const { 3076bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor return getFromTargetType(Target->getSizeType()); 30775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 30785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 307929e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg/// getIntMaxType - Return the unique type for "intmax_t" (C99 7.18.1.5). 308029e97cb35fab314388f62b68fefa78947e93c1dcHans WennborgCanQualType ASTContext::getIntMaxType() const { 308129e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg return getFromTargetType(Target->getIntMaxType()); 308229e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg} 308329e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg 308429e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg/// getUIntMaxType - Return the unique type for "uintmax_t" (C99 7.18.1.5). 308529e97cb35fab314388f62b68fefa78947e93c1dcHans WennborgCanQualType ASTContext::getUIntMaxType() const { 308629e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg return getFromTargetType(Target->getUIntMaxType()); 308729e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg} 308829e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg 308964c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// getSignedWCharType - Return the type of "signed wchar_t". 309064c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// Used when in C++, as a GCC extension. 309164c438a4be2a871fa43c78264663ba1e9788b94dArgyrios KyrtzidisQualType ASTContext::getSignedWCharType() const { 309264c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis // FIXME: derive from "Target" ? 309364c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis return WCharTy; 309464c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis} 309564c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 309664c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// getUnsignedWCharType - Return the type of "unsigned wchar_t". 309764c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// Used when in C++, as a GCC extension. 309864c438a4be2a871fa43c78264663ba1e9788b94dArgyrios KyrtzidisQualType ASTContext::getUnsignedWCharType() const { 309964c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis // FIXME: derive from "Target" ? 310064c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis return UnsignedIntTy; 310164c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis} 310264c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 310329e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg/// getPointerDiffType - Return the unique type for "ptrdiff_t" (C99 7.17) 31048b9023ba35a86838789e2c9034a6128728c547aaChris Lattner/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9). 31058b9023ba35a86838789e2c9034a6128728c547aaChris LattnerQualType ASTContext::getPointerDiffType() const { 3106bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor return getFromTargetType(Target->getPtrDiffType(0)); 31078b9023ba35a86838789e2c9034a6128728c547aaChris Lattner} 31088b9023ba35a86838789e2c9034a6128728c547aaChris Lattner 3109e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner//===----------------------------------------------------------------------===// 3110e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner// Type Operators 3111e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner//===----------------------------------------------------------------------===// 3112e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner 31134ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCanQualType ASTContext::getCanonicalParamType(QualType T) const { 311454e14c4db764c0636160d26c5bbf491637c83a76John McCall // Push qualifiers into arrays, and then discard any remaining 311554e14c4db764c0636160d26c5bbf491637c83a76John McCall // qualifiers. 311654e14c4db764c0636160d26c5bbf491637c83a76John McCall T = getCanonicalType(T); 3117745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian T = getVariableArrayDecayedType(T); 311854e14c4db764c0636160d26c5bbf491637c83a76John McCall const Type *Ty = T.getTypePtr(); 311954e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType Result; 312054e14c4db764c0636160d26c5bbf491637c83a76John McCall if (isa<ArrayType>(Ty)) { 312154e14c4db764c0636160d26c5bbf491637c83a76John McCall Result = getArrayDecayedType(QualType(Ty,0)); 312254e14c4db764c0636160d26c5bbf491637c83a76John McCall } else if (isa<FunctionType>(Ty)) { 312354e14c4db764c0636160d26c5bbf491637c83a76John McCall Result = getPointerType(QualType(Ty, 0)); 312454e14c4db764c0636160d26c5bbf491637c83a76John McCall } else { 312554e14c4db764c0636160d26c5bbf491637c83a76John McCall Result = QualType(Ty, 0); 312654e14c4db764c0636160d26c5bbf491637c83a76John McCall } 312754e14c4db764c0636160d26c5bbf491637c83a76John McCall 312854e14c4db764c0636160d26c5bbf491637c83a76John McCall return CanQualType::CreateUnsafe(Result); 312954e14c4db764c0636160d26c5bbf491637c83a76John McCall} 313054e14c4db764c0636160d26c5bbf491637c83a76John McCall 313162c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCallQualType ASTContext::getUnqualifiedArrayType(QualType type, 313262c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall Qualifiers &quals) { 313362c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall SplitQualType splitType = type.getSplitUnqualifiedType(); 313462c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 313562c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // FIXME: getSplitUnqualifiedType() actually walks all the way to 313662c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // the unqualified desugared type and then drops it on the floor. 313762c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // We then have to strip that sugar back off with 313862c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // getUnqualifiedDesugaredType(), which is silly. 313962c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall const ArrayType *AT = 3140200fa53fd420aa8369586f569dbece04930ad6a3John McCall dyn_cast<ArrayType>(splitType.Ty->getUnqualifiedDesugaredType()); 314162c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 314262c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // If we don't have an array, just use the results in splitType. 31439dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (!AT) { 3144200fa53fd420aa8369586f569dbece04930ad6a3John McCall quals = splitType.Quals; 3145200fa53fd420aa8369586f569dbece04930ad6a3John McCall return QualType(splitType.Ty, 0); 314628e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth } 314728e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 314862c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // Otherwise, recurse on the array's element type. 314962c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall QualType elementType = AT->getElementType(); 315062c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall QualType unqualElementType = getUnqualifiedArrayType(elementType, quals); 315162c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 315262c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // If that didn't change the element type, AT has no qualifiers, so we 315362c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // can just use the results in splitType. 315462c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall if (elementType == unqualElementType) { 315562c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall assert(quals.empty()); // from the recursive call 3156200fa53fd420aa8369586f569dbece04930ad6a3John McCall quals = splitType.Quals; 3157200fa53fd420aa8369586f569dbece04930ad6a3John McCall return QualType(splitType.Ty, 0); 315862c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall } 315962c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 316062c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // Otherwise, add in the qualifiers from the outermost type, then 316162c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // build the type back up. 3162200fa53fd420aa8369586f569dbece04930ad6a3John McCall quals.addConsistentQualifiers(splitType.Quals); 316328e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31649dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) { 316562c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getConstantArrayType(unqualElementType, CAT->getSize(), 316628e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth CAT->getSizeModifier(), 0); 316728e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth } 316828e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31699dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) { 317062c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getIncompleteArrayType(unqualElementType, IAT->getSizeModifier(), 0); 317128e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth } 317228e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31739dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(AT)) { 317462c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getVariableArrayType(unqualElementType, 31753fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall VAT->getSizeExpr(), 31769dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor VAT->getSizeModifier(), 31779dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor VAT->getIndexTypeCVRQualifiers(), 31789dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor VAT->getBracketsRange()); 31799dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor } 31809dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor 31819dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor const DependentSizedArrayType *DSAT = cast<DependentSizedArrayType>(AT); 318262c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getDependentSizedArrayType(unqualElementType, DSAT->getSizeExpr(), 318328e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth DSAT->getSizeModifier(), 0, 318428e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth SourceRange()); 318528e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth} 318628e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31875a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// UnwrapSimilarPointerTypes - If T1 and T2 are pointer types that 31885a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// may be similar (C++ 4.4), replaces T1 and T2 with the type that 31895a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// they point to and return true. If T1 and T2 aren't pointer types 31905a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// or pointer-to-member types, or if they are not similar at this 31915a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// level, returns false and leaves T1 and T2 unchanged. Top-level 31925a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// qualifiers on T1 and T2 are ignored. This function will typically 31935a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// be called in a loop that successively "unwraps" pointer and 31945a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// pointer-to-member types to compare them at each level. 31955a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregorbool ASTContext::UnwrapSimilarPointerTypes(QualType &T1, QualType &T2) { 31965a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor const PointerType *T1PtrType = T1->getAs<PointerType>(), 31975a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor *T2PtrType = T2->getAs<PointerType>(); 31985a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (T1PtrType && T2PtrType) { 31995a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T1 = T1PtrType->getPointeeType(); 32005a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T2 = T2PtrType->getPointeeType(); 32015a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return true; 32025a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 32035a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 32045a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor const MemberPointerType *T1MPType = T1->getAs<MemberPointerType>(), 32055a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor *T2MPType = T2->getAs<MemberPointerType>(); 32065a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (T1MPType && T2MPType && 32075a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0), 32085a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor QualType(T2MPType->getClass(), 0))) { 32095a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T1 = T1MPType->getPointeeType(); 32105a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T2 = T2MPType->getPointeeType(); 32115a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return true; 32125a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 32135a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 32145a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (getLangOptions().ObjC1) { 32155a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor const ObjCObjectPointerType *T1OPType = T1->getAs<ObjCObjectPointerType>(), 32165a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor *T2OPType = T2->getAs<ObjCObjectPointerType>(); 32175a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (T1OPType && T2OPType) { 32185a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T1 = T1OPType->getPointeeType(); 32195a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T2 = T2OPType->getPointeeType(); 32205a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return true; 32215a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 32225a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 32235a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 32245a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor // FIXME: Block pointers, too? 32255a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 32265a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return false; 32275a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor} 32285a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 32294ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadDeclarationNameInfo 32304ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getNameForTemplate(TemplateName Name, 32314ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad SourceLocation NameLoc) const { 3232146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall switch (Name.getKind()) { 3233146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::QualifiedTemplate: 3234146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::Template: 32352577743c5650c646fb705df01403707e94f2df04Abramo Bagnara // DNInfo work in progress: CHECKME: what about DNLoc? 3236146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo(Name.getAsTemplateDecl()->getDeclName(), 3237146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall NameLoc); 32382577743c5650c646fb705df01403707e94f2df04Abramo Bagnara 3239146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::OverloadedTemplate: { 3240146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall OverloadedTemplateStorage *Storage = Name.getAsOverloadedTemplate(); 3241146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall // DNInfo work in progress: CHECKME: what about DNLoc? 3242146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo((*Storage->begin())->getDeclName(), NameLoc); 3243146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3244146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3245146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::DependentTemplate: { 3246146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall DependentTemplateName *DTN = Name.getAsDependentTemplateName(); 32472577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DeclarationName DName; 324880ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall if (DTN->isIdentifier()) { 32492577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DName = DeclarationNames.getIdentifier(DTN->getIdentifier()); 32502577743c5650c646fb705df01403707e94f2df04Abramo Bagnara return DeclarationNameInfo(DName, NameLoc); 325180ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall } else { 32522577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DName = DeclarationNames.getCXXOperatorName(DTN->getOperator()); 32532577743c5650c646fb705df01403707e94f2df04Abramo Bagnara // DNInfo work in progress: FIXME: source locations? 32542577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DeclarationNameLoc DNLoc; 32552577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DNLoc.CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding(); 32562577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DNLoc.CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding(); 32572577743c5650c646fb705df01403707e94f2df04Abramo Bagnara return DeclarationNameInfo(DName, NameLoc, DNLoc); 325880ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall } 325980ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall } 326080ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall 3261146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParm: { 3262146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage *subst 3263146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParm(); 3264146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo(subst->getParameter()->getDeclName(), 3265146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall NameLoc); 3266146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3267146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3268146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParmPack: { 3269146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmPackStorage *subst 3270146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParmPack(); 3271146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo(subst->getParameterPack()->getDeclName(), 3272146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall NameLoc); 3273146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3274146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3275146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3276146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm_unreachable("bad template name kind!"); 327780ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall} 327880ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall 32794ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) const { 3280146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall switch (Name.getKind()) { 3281146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::QualifiedTemplate: 3282146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::Template: { 3283146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateDecl *Template = Name.getAsTemplateDecl(); 32843e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor if (TemplateTemplateParmDecl *TTP 3285146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = dyn_cast<TemplateTemplateParmDecl>(Template)) 32863e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor Template = getCanonicalTemplateTemplateParmDecl(TTP); 32873e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 32883e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // The canonical template name is the canonical template declaration. 328997fbaa2a38804268a024f1a104b43fcf8b4411b0Argyrios Kyrtzidis return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl())); 32903e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor } 329125a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor 3292146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::OverloadedTemplate: 3293146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm_unreachable("cannot canonicalize overloaded template"); 3294146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3295146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::DependentTemplate: { 3296146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall DependentTemplateName *DTN = Name.getAsDependentTemplateName(); 3297146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall assert(DTN && "Non-dependent template names must refer to template decls."); 3298146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DTN->CanonicalTemplateName; 3299146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3300146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3301146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParm: { 3302146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage *subst 3303146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParm(); 3304146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return getCanonicalTemplateName(subst->getReplacement()); 33051aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor } 33061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3307146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParmPack: { 3308146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmPackStorage *subst 3309146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParmPack(); 3310146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateTemplateParmDecl *canonParameter 3311146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = getCanonicalTemplateTemplateParmDecl(subst->getParameterPack()); 3312146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateArgument canonArgPack 3313146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = getCanonicalTemplateArgument(subst->getArgumentPack()); 3314146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return getSubstTemplateTemplateParmPack(canonParameter, canonArgPack); 3315146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3316146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3317146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3318146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm_unreachable("bad template name!"); 331925a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor} 332025a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor 3321db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregorbool ASTContext::hasSameTemplateName(TemplateName X, TemplateName Y) { 3322db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor X = getCanonicalTemplateName(X); 3323db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Y = getCanonicalTemplateName(Y); 3324db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return X.getAsVoidPointer() == Y.getAsVoidPointer(); 3325db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor} 3326db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor 33271eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpTemplateArgument 33284ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const { 33291275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor switch (Arg.getKind()) { 33301275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Null: 33311275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor return Arg; 33321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33331275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Expression: 33341275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor return Arg; 33351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33361275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Declaration: 3337833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall return TemplateArgument(Arg.getAsDecl()->getCanonicalDecl()); 33381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3339788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 3340788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate())); 3341a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 3342a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 3343a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return TemplateArgument(getCanonicalTemplateName( 3344a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Arg.getAsTemplateOrTemplatePattern()), 33452be29f423acad3bbe39099a78db2805acb5bdf17Douglas Gregor Arg.getNumTemplateExpansions()); 3346a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 33471275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Integral: 3348833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall return TemplateArgument(*Arg.getAsIntegral(), 33491275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor getCanonicalType(Arg.getIntegralType())); 33501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33511275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Type: 3352833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall return TemplateArgument(getCanonicalType(Arg.getAsType())); 33531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33541275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Pack: { 335587dd697dcc8ecb64df73ae64d61b8c80ff0c157cDouglas Gregor if (Arg.pack_size() == 0) 335687dd697dcc8ecb64df73ae64d61b8c80ff0c157cDouglas Gregor return Arg; 335787dd697dcc8ecb64df73ae64d61b8c80ff0c157cDouglas Gregor 3358910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgument *CanonArgs 3359910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor = new (*this) TemplateArgument[Arg.pack_size()]; 33601275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor unsigned Idx = 0; 33611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (TemplateArgument::pack_iterator A = Arg.pack_begin(), 33621275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor AEnd = Arg.pack_end(); 33631275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor A != AEnd; (void)++A, ++Idx) 33641275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor CanonArgs[Idx] = getCanonicalTemplateArgument(*A); 33651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3366910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor return TemplateArgument(CanonArgs, Arg.pack_size()); 33671275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor } 33681275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor } 33691275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor 33701275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // Silence GCC warning 3371b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unhandled template argument kind"); 33721275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor} 33731275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor 3374d57959af02b4af695276f4204443afe6e5d86bd8Douglas GregorNestedNameSpecifier * 33754ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const { 33761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (!NNS) 3377d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor return 0; 3378d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3379d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor switch (NNS->getKind()) { 3380d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::Identifier: 3381d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // Canonicalize the prefix but keep the identifier the same. 33821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return NestedNameSpecifier::Create(*this, 3383d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor getCanonicalNestedNameSpecifier(NNS->getPrefix()), 3384d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor NNS->getAsIdentifier()); 3385d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3386d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::Namespace: 3387d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // A namespace is canonical; build a nested-name-specifier with 3388d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // this namespace and no prefix. 338914aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor return NestedNameSpecifier::Create(*this, 0, 339014aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor NNS->getAsNamespace()->getOriginalNamespace()); 339114aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor 339214aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor case NestedNameSpecifier::NamespaceAlias: 339314aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor // A namespace is canonical; build a nested-name-specifier with 339414aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor // this namespace and no prefix. 339514aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor return NestedNameSpecifier::Create(*this, 0, 339614aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor NNS->getAsNamespaceAlias()->getNamespace() 339714aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor ->getOriginalNamespace()); 3398d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3399d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::TypeSpec: 3400d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::TypeSpecWithTemplate: { 3401d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor QualType T = getCanonicalType(QualType(NNS->getAsType(), 0)); 3402264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor 3403264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // If we have some kind of dependent-named type (e.g., "typename T::type"), 3404264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // break it apart into its prefix and identifier, then reconsititute those 3405264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // as the canonical nested-name-specifier. This is required to canonicalize 3406264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // a dependent nested-name-specifier involving typedefs of dependent-name 3407264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // types, e.g., 3408264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // typedef typename T::type T1; 3409264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // typedef typename T1::type T2; 3410264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor if (const DependentNameType *DNT = T->getAs<DependentNameType>()) { 3411264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor NestedNameSpecifier *Prefix 3412264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor = getCanonicalNestedNameSpecifier(DNT->getQualifier()); 3413264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor return NestedNameSpecifier::Create(*this, Prefix, 3414264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor const_cast<IdentifierInfo *>(DNT->getIdentifier())); 3415264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor } 3416264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor 3417643f84353b3b7bbf9b73bcbc7da0ef8a39a5ca99Douglas Gregor // Do the same thing as above, but with dependent-named specializations. 3418264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor if (const DependentTemplateSpecializationType *DTST 3419264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor = T->getAs<DependentTemplateSpecializationType>()) { 3420264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor NestedNameSpecifier *Prefix 3421264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor = getCanonicalNestedNameSpecifier(DTST->getQualifier()); 3422aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor 3423aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor T = getDependentTemplateSpecializationType(DTST->getKeyword(), 3424aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor Prefix, DTST->getIdentifier(), 3425aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor DTST->getNumArgs(), 3426aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor DTST->getArgs()); 3427264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor T = getCanonicalType(T); 3428264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor } 3429264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor 34303b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return NestedNameSpecifier::Create(*this, 0, false, 34313b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall const_cast<Type*>(T.getTypePtr())); 3432d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor } 3433d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3434d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::Global: 3435d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // The global specifier is canonical and unique. 3436d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor return NNS; 3437d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor } 3438d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 34397530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie llvm_unreachable("Invalid NestedNameSpecifier::Kind!"); 3440d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor} 3441d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3442c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 34434ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadconst ArrayType *ASTContext::getAsArrayType(QualType T) const { 3444c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Handle the non-qualified case efficiently. 3445a4923eb7c4b04d360cb2747641a5e92818edf804Douglas Gregor if (!T.hasLocalQualifiers()) { 3446c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Handle the common positive case fast. 3447c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const ArrayType *AT = dyn_cast<ArrayType>(T)) 3448c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return AT; 3449c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner } 34501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 34510953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Handle the common negative case fast. 34523b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!isa<ArrayType>(T.getCanonicalType())) 3453c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return 0; 34541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 34550953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Apply any qualifiers from the array type to the element type. This 3456c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // implements C99 6.7.3p8: "If the specification of an array type includes 3457c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // any type qualifiers, the element type is so qualified, not the array type." 34581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3459c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // If we get here, we either have type qualifiers on the type, or we have 3460c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // sugar such as a typedef in the way. If we have type qualifiers on the type 346150d62d1b4a98adbc83de8f8cd1379ea1c25656f7Douglas Gregor // we must propagate them down into the element type. 34620953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 34633b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType split = T.getSplitDesugaredType(); 3464200fa53fd420aa8369586f569dbece04930ad6a3John McCall Qualifiers qs = split.Quals; 34651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3466c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // If we have a simple case, just return now. 3467200fa53fd420aa8369586f569dbece04930ad6a3John McCall const ArrayType *ATy = dyn_cast<ArrayType>(split.Ty); 34683b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (ATy == 0 || qs.empty()) 3469c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return ATy; 34701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3471c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Otherwise, we have an array and we have qualifiers on it. Push the 3472c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // qualifiers into the array element type and return a new array type. 34733b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType NewEltTy = getQualifiedType(ATy->getElementType(), qs); 34741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3475c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(ATy)) 3476c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(), 3477c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner CAT->getSizeModifier(), 34780953e767ff7817f97b3ab20896b229891eeff45bJohn McCall CAT->getIndexTypeCVRQualifiers())); 3479c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(ATy)) 3480c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return cast<ArrayType>(getIncompleteArrayType(NewEltTy, 3481c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner IAT->getSizeModifier(), 34820953e767ff7817f97b3ab20896b229891eeff45bJohn McCall IAT->getIndexTypeCVRQualifiers())); 3483898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 34841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const DependentSizedArrayType *DSAT 3485898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor = dyn_cast<DependentSizedArrayType>(ATy)) 3486898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return cast<ArrayType>( 34871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getDependentSizedArrayType(NewEltTy, 34883fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall DSAT->getSizeExpr(), 3489898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor DSAT->getSizeModifier(), 34900953e767ff7817f97b3ab20896b229891eeff45bJohn McCall DSAT->getIndexTypeCVRQualifiers(), 34917e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor DSAT->getBracketsRange())); 34921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3493c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner const VariableArrayType *VAT = cast<VariableArrayType>(ATy); 34947e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor return cast<ArrayType>(getVariableArrayType(NewEltTy, 34953fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall VAT->getSizeExpr(), 3496c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner VAT->getSizeModifier(), 34970953e767ff7817f97b3ab20896b229891eeff45bJohn McCall VAT->getIndexTypeCVRQualifiers(), 34987e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor VAT->getBracketsRange())); 349977c9647cae939104c6cb2b6a4dd8ca859d2e5770Chris Lattner} 350077c9647cae939104c6cb2b6a4dd8ca859d2e5770Chris Lattner 350179e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas GregorQualType ASTContext::getAdjustedParameterType(QualType T) { 350279e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // C99 6.7.5.3p7: 350379e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // A declaration of a parameter as "array of type" shall be 350479e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // adjusted to "qualified pointer to type", where the type 350579e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // qualifiers (if any) are those specified within the [ and ] of 350679e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // the array type derivation. 350779e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor if (T->isArrayType()) 350879e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return getArrayDecayedType(T); 350979e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 351079e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // C99 6.7.5.3p8: 351179e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // A declaration of a parameter as "function returning type" 351279e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // shall be adjusted to "pointer to function returning type", as 351379e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // in 6.3.2.1. 351479e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor if (T->isFunctionType()) 351579e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return getPointerType(T); 351679e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 351779e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return T; 351879e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor} 351979e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 352079e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas GregorQualType ASTContext::getSignatureParameterType(QualType T) { 352179e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor T = getVariableArrayDecayedType(T); 352279e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor T = getAdjustedParameterType(T); 352379e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return T.getUnqualifiedType(); 352479e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor} 352579e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 3526e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// getArrayDecayedType - Return the properly qualified result of decaying the 3527e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// specified array type to a pointer. This operation is non-trivial when 3528e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// handling typedefs etc. The canonical type of "T" must be an array type, 3529e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// this returns a pointer to a properly qualified element of the array. 3530e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// 3531e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// See C99 6.7.5.3p7 and C99 6.3.2.1p3. 35324ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getArrayDecayedType(QualType Ty) const { 3533c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Get the element type with 'getAsArrayType' so that we don't lose any 3534c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // typedefs in the element type of the array. This also handles propagation 3535c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // of type qualifiers from the array type into the element type if present 3536c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // (C99 6.7.3p8). 3537c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner const ArrayType *PrettyArrayType = getAsArrayType(Ty); 3538c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner assert(PrettyArrayType && "Not an array type!"); 35391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3540c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner QualType PtrTy = getPointerType(PrettyArrayType->getElementType()); 3541e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner 3542e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner // int x[restrict 4] -> int *restrict 35430953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return getQualifiedType(PtrTy, PrettyArrayType->getIndexTypeQualifiers()); 3544e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner} 3545e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner 35463b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getBaseElementType(const ArrayType *array) const { 35473b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return getBaseElementType(array->getElementType()); 35485e03f9ea8174ae588c5e69ec6b5ef4c68f8fd766Douglas Gregor} 35495e03f9ea8174ae588c5e69ec6b5ef4c68f8fd766Douglas Gregor 35503b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getBaseElementType(QualType type) const { 35513b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Qualifiers qs; 35523b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall while (true) { 35533b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType split = type.getSplitDesugaredType(); 3554200fa53fd420aa8369586f569dbece04930ad6a3John McCall const ArrayType *array = split.Ty->getAsArrayTypeUnsafe(); 35553b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!array) break; 35561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 35573b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall type = array->getElementType(); 3558200fa53fd420aa8369586f569dbece04930ad6a3John McCall qs.addConsistentQualifiers(split.Quals); 35593b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall } 35601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 35613b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return getQualifiedType(type, qs); 35626183a99b064b397d98297904fbd6cf00fe1f453dAnders Carlsson} 35636183a99b064b397d98297904fbd6cf00fe1f453dAnders Carlsson 35640de78998e7bda473b408437053e48661b510d453Fariborz Jahanian/// getConstantArrayElementCount - Returns number of constant array elements. 35651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpuint64_t 35660de78998e7bda473b408437053e48661b510d453Fariborz JahanianASTContext::getConstantArrayElementCount(const ConstantArrayType *CA) const { 35670de78998e7bda473b408437053e48661b510d453Fariborz Jahanian uint64_t ElementCount = 1; 35680de78998e7bda473b408437053e48661b510d453Fariborz Jahanian do { 35690de78998e7bda473b408437053e48661b510d453Fariborz Jahanian ElementCount *= CA->getSize().getZExtValue(); 35700de78998e7bda473b408437053e48661b510d453Fariborz Jahanian CA = dyn_cast<ConstantArrayType>(CA->getElementType()); 35710de78998e7bda473b408437053e48661b510d453Fariborz Jahanian } while (CA); 35720de78998e7bda473b408437053e48661b510d453Fariborz Jahanian return ElementCount; 35730de78998e7bda473b408437053e48661b510d453Fariborz Jahanian} 35740de78998e7bda473b408437053e48661b510d453Fariborz Jahanian 35755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getFloatingRank - Return a relative rank for floating point types. 35765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// This routine will assert if passed a built-in type that isn't a float. 3577a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattnerstatic FloatingRank getFloatingRank(QualType T) { 3578183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ComplexType *CT = T->getAs<ComplexType>()) 35795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return getFloatingRank(CT->getElementType()); 3580a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner 3581183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall assert(T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type"); 3582183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall switch (T->getAs<BuiltinType>()->getKind()) { 3583b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("getFloatingRank(): not a floating type"); 3584aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov case BuiltinType::Half: return HalfRank; 35855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Float: return FloatRank; 35865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Double: return DoubleRank; 35875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::LongDouble: return LongDoubleRank; 35885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 35895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 35905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 35911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getFloatingTypeOfSizeWithinDomain - Returns a real floating 35921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// point or a complex type (based on typeDomain/typeSize). 3593716c7304ff5d27a95e1e7823acd1d09d5ec3e37fSteve Naroff/// 'typeDomain' is a real floating point or complex type. 3594716c7304ff5d27a95e1e7823acd1d09d5ec3e37fSteve Naroff/// 'typeSize' is a real floating point or complex type. 35951361b11066239ea15764a2a844405352d87296b3Chris LattnerQualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size, 35961361b11066239ea15764a2a844405352d87296b3Chris Lattner QualType Domain) const { 35971361b11066239ea15764a2a844405352d87296b3Chris Lattner FloatingRank EltRank = getFloatingRank(Size); 35981361b11066239ea15764a2a844405352d87296b3Chris Lattner if (Domain->isComplexType()) { 35991361b11066239ea15764a2a844405352d87296b3Chris Lattner switch (EltRank) { 3600561d3abc881033776ece385a01a510e1cbc1fa92David Blaikie case HalfRank: llvm_unreachable("Complex half is not supported"); 3601f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff case FloatRank: return FloatComplexTy; 3602f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff case DoubleRank: return DoubleComplexTy; 3603f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff case LongDoubleRank: return LongDoubleComplexTy; 3604f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff } 3605f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff } 36061361b11066239ea15764a2a844405352d87296b3Chris Lattner 36071361b11066239ea15764a2a844405352d87296b3Chris Lattner assert(Domain->isRealFloatingType() && "Unknown domain!"); 36081361b11066239ea15764a2a844405352d87296b3Chris Lattner switch (EltRank) { 3609561d3abc881033776ece385a01a510e1cbc1fa92David Blaikie case HalfRank: llvm_unreachable("Half ranks are not valid here"); 36101361b11066239ea15764a2a844405352d87296b3Chris Lattner case FloatRank: return FloatTy; 36111361b11066239ea15764a2a844405352d87296b3Chris Lattner case DoubleRank: return DoubleTy; 36121361b11066239ea15764a2a844405352d87296b3Chris Lattner case LongDoubleRank: return LongDoubleTy; 36135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3614561d3abc881033776ece385a01a510e1cbc1fa92David Blaikie llvm_unreachable("getFloatingRank(): illegal value for rank"); 36155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 36165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 36177cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// getFloatingTypeOrder - Compare the rank of the two specified floating 36187cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// point types, ignoring the domain of the type (i.e. 'double' == 36197cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If 36201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// LHS < RHS, return -1. 36214ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadint ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) const { 3622a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner FloatingRank LHSR = getFloatingRank(LHS); 3623a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner FloatingRank RHSR = getFloatingRank(RHS); 36241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3625a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner if (LHSR == RHSR) 3626fb0d49669aa370b4c0993c5cee60275ef9fd6518Steve Naroff return 0; 3627a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner if (LHSR > RHSR) 3628fb0d49669aa370b4c0993c5cee60275ef9fd6518Steve Naroff return 1; 3629fb0d49669aa370b4c0993c5cee60275ef9fd6518Steve Naroff return -1; 36305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 36315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3632f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This 3633f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner/// routine will assert if passed a built-in type that isn't an integer or enum, 3634f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner/// or if it is not canonicalized. 3635f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCallunsigned ASTContext::getIntegerRank(const Type *T) const { 3636467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(T->isCanonicalUnqualified() && "T should be canonicalized"); 3637f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith 3638f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner switch (cast<BuiltinType>(T)->getKind()) { 3639b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("getIntegerRank(): not a built-in integer"); 36407cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Bool: 3641f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 1 + (getIntWidth(BoolTy) << 3); 36427cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Char_S: 36437cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Char_U: 36447cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::SChar: 36457cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::UChar: 3646f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 2 + (getIntWidth(CharTy) << 3); 36477cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Short: 36487cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::UShort: 3649f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 3 + (getIntWidth(ShortTy) << 3); 36507cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Int: 36517cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::UInt: 3652f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 4 + (getIntWidth(IntTy) << 3); 36537cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Long: 36547cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::ULong: 3655f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 5 + (getIntWidth(LongTy) << 3); 36567cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::LongLong: 36577cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::ULongLong: 3658f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 6 + (getIntWidth(LongLongTy) << 3); 36592df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::Int128: 36602df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::UInt128: 36612df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner return 7 + (getIntWidth(Int128Ty) << 3); 3662f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner } 3663f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner} 3664f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner 366504e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// \brief Whether this is a promotable bitfield reference according 366604e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// to C99 6.3.1.1p2, bullet 2 (and GCC extensions). 366704e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// 366804e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// \returns the type this bit-field will promote to, or NULL if no 366904e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// promotion occurs. 36704ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::isPromotableBitField(Expr *E) const { 3671ceafbdeb93ecf323cca74e660bf54504c86f3b71Douglas Gregor if (E->isTypeDependent() || E->isValueDependent()) 3672ceafbdeb93ecf323cca74e660bf54504c86f3b71Douglas Gregor return QualType(); 3673ceafbdeb93ecf323cca74e660bf54504c86f3b71Douglas Gregor 367404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman FieldDecl *Field = E->getBitField(); 367504e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman if (!Field) 367604e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return QualType(); 367704e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 367804e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman QualType FT = Field->getType(); 367904e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 3680a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith uint64_t BitWidth = Field->getBitWidthValue(*this); 368104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman uint64_t IntSize = getTypeSize(IntTy); 368204e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // GCC extension compatibility: if the bit-field size is less than or equal 368304e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // to the size of int, it gets promoted no matter what its type is. 368404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // For instance, unsigned long bf : 4 gets promoted to signed int. 368504e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman if (BitWidth < IntSize) 368604e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return IntTy; 368704e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 368804e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman if (BitWidth == IntSize) 368904e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return FT->isSignedIntegerType() ? IntTy : UnsignedIntTy; 369004e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 369104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // Types bigger than int are not subject to promotions, and therefore act 369204e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // like the base type. 369304e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // FIXME: This doesn't quite match what gcc does, but what gcc does here 369404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // is ridiculous. 369504e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return QualType(); 369604e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman} 369704e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 3698a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman/// getPromotedIntegerType - Returns the type that Promotable will 3699a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman/// promote to: C99 6.3.1.1p2, assuming that Promotable is a promotable 3700a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman/// integer type. 37014ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getPromotedIntegerType(QualType Promotable) const { 3702a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman assert(!Promotable.isNull()); 3703a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman assert(Promotable->isPromotableIntegerType()); 3704842aef8d942a880eeb9535d40de31a86838264cbJohn McCall if (const EnumType *ET = Promotable->getAs<EnumType>()) 3705842aef8d942a880eeb9535d40de31a86838264cbJohn McCall return ET->getDecl()->getPromotionType(); 370668a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman 370768a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman if (const BuiltinType *BT = Promotable->getAs<BuiltinType>()) { 370868a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // C++ [conv.prom]: A prvalue of type char16_t, char32_t, or wchar_t 370968a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // (3.9.1) can be converted to a prvalue of the first of the following 371068a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // types that can represent all the values of its underlying type: 371168a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // int, unsigned int, long int, unsigned long int, long long int, or 371268a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // unsigned long long int [...] 371368a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // FIXME: Is there some better way to compute this? 371468a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman if (BT->getKind() == BuiltinType::WChar_S || 371568a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman BT->getKind() == BuiltinType::WChar_U || 371668a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman BT->getKind() == BuiltinType::Char16 || 371768a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman BT->getKind() == BuiltinType::Char32) { 371868a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman bool FromIsSigned = BT->getKind() == BuiltinType::WChar_S; 371968a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman uint64_t FromSize = getTypeSize(BT); 372068a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman QualType PromoteTypes[] = { IntTy, UnsignedIntTy, LongTy, UnsignedLongTy, 372168a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman LongLongTy, UnsignedLongLongTy }; 372268a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman for (size_t Idx = 0; Idx < llvm::array_lengthof(PromoteTypes); ++Idx) { 372368a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman uint64_t ToSize = getTypeSize(PromoteTypes[Idx]); 372468a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman if (FromSize < ToSize || 372568a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman (FromSize == ToSize && 372668a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) 372768a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman return PromoteTypes[Idx]; 372868a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman } 372968a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman llvm_unreachable("char type should fit into long long"); 373068a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman } 373168a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman } 373268a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman 373368a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // At this point, we should have a signed or unsigned integer type. 3734a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman if (Promotable->isSignedIntegerType()) 3735a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman return IntTy; 3736a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman uint64_t PromotableSize = getTypeSize(Promotable); 3737a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman uint64_t IntSize = getTypeSize(IntTy); 3738a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman assert(Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize); 3739a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman return (PromotableSize != IntSize) ? IntTy : UnsignedIntTy; 3740a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman} 3741a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman 374231862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis/// \brief Recurses in pointer/array types until it finds an objc retainable 374331862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis/// type and returns its ownership. 374431862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios KyrtzidisQualifiers::ObjCLifetime ASTContext::getInnerObjCOwnership(QualType T) const { 374531862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis while (!T.isNull()) { 374631862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis if (T.getObjCLifetime() != Qualifiers::OCL_None) 374731862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis return T.getObjCLifetime(); 374831862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis if (T->isArrayType()) 374931862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis T = getBaseElementType(T); 375031862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis else if (const PointerType *PT = T->getAs<PointerType>()) 375131862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis T = PT->getPointeeType(); 375231862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis else if (const ReferenceType *RT = T->getAs<ReferenceType>()) 375328445f0b62f6aed851ff87ce64d9b19200d3211fArgyrios Kyrtzidis T = RT->getPointeeType(); 375431862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis else 375531862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis break; 375631862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis } 375731862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis 375831862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis return Qualifiers::OCL_None; 375931862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis} 376031862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis 37611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getIntegerTypeOrder - Returns the highest ranked integer type: 37627cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If 37631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// LHS < RHS, return -1. 37644ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadint ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) const { 3765f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall const Type *LHSC = getCanonicalType(LHS).getTypePtr(); 3766f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall const Type *RHSC = getCanonicalType(RHS).getTypePtr(); 37677cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSC == RHSC) return 0; 37681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3769f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner bool LHSUnsigned = LHSC->isUnsignedIntegerType(); 3770f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner bool RHSUnsigned = RHSC->isUnsignedIntegerType(); 37711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37727cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner unsigned LHSRank = getIntegerRank(LHSC); 37737cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner unsigned RHSRank = getIntegerRank(RHSC); 37741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37757cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned. 37767cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSRank == RHSRank) return 0; 37777cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return LHSRank > RHSRank ? 1 : -1; 37787cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner } 37791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37807cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // Otherwise, the LHS is signed and the RHS is unsigned or visa versa. 37817cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSUnsigned) { 37827cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the unsigned [LHS] type is larger, return it. 37837cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSRank >= RHSRank) 37847cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return 1; 37851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37867cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the signed type can represent all values of the unsigned type, it 37877cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // wins. Because we are dealing with 2's complement and types that are 37881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // powers of two larger than each other, this is always safe. 37897cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return -1; 37907cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner } 37917cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner 37927cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the unsigned [RHS] type is larger, return it. 37937cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (RHSRank >= LHSRank) 37947cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return -1; 37951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37967cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the signed type can represent all values of the unsigned type, it 37977cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // wins. Because we are dealing with 2's complement and types that are 37981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // powers of two larger than each other, this is always safe. 37997cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return 1; 38005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 380171993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson 380279cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlssonstatic RecordDecl * 3803ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo BagnaraCreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK, 3804ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara DeclContext *DC, IdentifierInfo *Id) { 3805ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara SourceLocation Loc; 380679cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson if (Ctx.getLangOptions().CPlusPlus) 3807ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 380879cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson else 3809ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 381079cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson} 3811ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara 38121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump// getCFConstantStringType - Return the type used for constant CFStrings. 38134ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getCFConstantStringType() const { 381471993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson if (!CFConstantStringTypeDecl) { 38151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump CFConstantStringTypeDecl = 3816ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara CreateRecordDecl(*this, TTK_Struct, TUDecl, 381779cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson &Idents.get("NSConstantString")); 38185cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall CFConstantStringTypeDecl->startDefinition(); 381979cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson 3820f06273f8bbacb086a46bde456429c8d08f6d07eeAnders Carlsson QualType FieldTypes[4]; 38211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 382271993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson // const int *isa; 38230953e767ff7817f97b3ab20896b229891eeff45bJohn McCall FieldTypes[0] = getPointerType(IntTy.withConst()); 3824f06273f8bbacb086a46bde456429c8d08f6d07eeAnders Carlsson // int flags; 3825f06273f8bbacb086a46bde456429c8d08f6d07eeAnders Carlsson FieldTypes[1] = IntTy; 382671993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson // const char *str; 38270953e767ff7817f97b3ab20896b229891eeff45bJohn McCall FieldTypes[2] = getPointerType(CharTy.withConst()); 382871993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson // long length; 38291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump FieldTypes[3] = LongTy; 38301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 383144b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor // Create fields 383244b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor for (unsigned i = 0; i < 4; ++i) { 38331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump FieldDecl *Field = FieldDecl::Create(*this, CFConstantStringTypeDecl, 3834ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara SourceLocation(), 383544b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor SourceLocation(), 0, 3836a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 38371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump /*BitWidth=*/0, 38387a614d8380297fcd2bc23986241905d97222948cRichard Smith /*Mutable=*/false, 38397a614d8380297fcd2bc23986241905d97222948cRichard Smith /*HasInit=*/false); 38402888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 384117945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis CFConstantStringTypeDecl->addDecl(Field); 384244b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor } 384344b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor 3844838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor CFConstantStringTypeDecl->completeDefinition(); 384571993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson } 38461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 384771993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson return getTagDeclType(CFConstantStringTypeDecl); 38488467583c2704e7a9691ea56939a029015f0ade0aGabor Greif} 3849b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson 3850319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregorvoid ASTContext::setCFConstantStringType(QualType T) { 38516217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek const RecordType *Rec = T->getAs<RecordType>(); 3852319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor assert(Rec && "Invalid CFConstantStringType"); 3853319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor CFConstantStringTypeDecl = Rec->getDecl(); 3854319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor} 3855319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor 38564ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getBlockDescriptorType() const { 3857adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump if (BlockDescriptorType) 3858adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump return getTagDeclType(BlockDescriptorType); 3859adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3860adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump RecordDecl *T; 3861adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump // FIXME: Needs the FlagAppleBlock bit. 3862ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara T = CreateRecordDecl(*this, TTK_Struct, TUDecl, 386379cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson &Idents.get("__block_descriptor")); 38645cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall T->startDefinition(); 3865adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3866adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump QualType FieldTypes[] = { 3867adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump UnsignedLongTy, 3868adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump UnsignedLongTy, 3869adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump }; 3870adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3871adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump const char *FieldNames[] = { 3872adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump "reserved", 3873083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "Size" 3874adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump }; 3875adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3876adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump for (size_t i = 0; i < 2; ++i) { 3877ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 3878adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump SourceLocation(), 3879adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump &Idents.get(FieldNames[i]), 3880a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 3881adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump /*BitWidth=*/0, 38827a614d8380297fcd2bc23986241905d97222948cRichard Smith /*Mutable=*/false, 38837a614d8380297fcd2bc23986241905d97222948cRichard Smith /*HasInit=*/false); 38842888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 3885adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump T->addDecl(Field); 3886adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump } 3887adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3888838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor T->completeDefinition(); 3889adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3890adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump BlockDescriptorType = T; 3891adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3892adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump return getTagDeclType(BlockDescriptorType); 3893adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump} 3894adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 38954ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getBlockDescriptorExtendedType() const { 3896083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump if (BlockDescriptorExtendedType) 3897083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump return getTagDeclType(BlockDescriptorExtendedType); 3898083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3899083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump RecordDecl *T; 3900083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump // FIXME: Needs the FlagAppleBlock bit. 3901ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara T = CreateRecordDecl(*this, TTK_Struct, TUDecl, 390279cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson &Idents.get("__block_descriptor_withcopydispose")); 39035cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall T->startDefinition(); 3904083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3905083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump QualType FieldTypes[] = { 3906083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump UnsignedLongTy, 3907083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump UnsignedLongTy, 3908083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump getPointerType(VoidPtrTy), 3909083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump getPointerType(VoidPtrTy) 3910083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump }; 3911083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3912083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump const char *FieldNames[] = { 3913083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "reserved", 3914083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "Size", 3915083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "CopyFuncPtr", 3916083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "DestroyFuncPtr" 3917083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump }; 3918083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3919083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump for (size_t i = 0; i < 4; ++i) { 3920ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 3921083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump SourceLocation(), 3922083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump &Idents.get(FieldNames[i]), 3923a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 3924083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump /*BitWidth=*/0, 39257a614d8380297fcd2bc23986241905d97222948cRichard Smith /*Mutable=*/false, 39267a614d8380297fcd2bc23986241905d97222948cRichard Smith /*HasInit=*/false); 39272888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 3928083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump T->addDecl(Field); 3929083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump } 3930083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3931838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor T->completeDefinition(); 3932083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3933083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump BlockDescriptorExtendedType = T; 3934083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3935083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump return getTagDeclType(BlockDescriptorExtendedType); 3936083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump} 3937083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 39384ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadbool ASTContext::BlockRequiresCopying(QualType Ty) const { 3939f85e193739c953358c865005855253af4f68a497John McCall if (Ty->isObjCRetainableType()) 3940af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump return true; 3941e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian if (getLangOptions().CPlusPlus) { 3942e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian if (const RecordType *RT = Ty->getAs<RecordType>()) { 3943e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 3944ffe37fdda5b4b4f162a45155c30d9f60ce110c12Sean Hunt return RD->hasConstCopyConstructor(); 3945e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian 3946e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian } 3947e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian } 3948af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump return false; 3949af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump} 3950af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 39514ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 39525f9e272e632e951b1efe824cd16acb4d96077930Chris LattnerASTContext::BuildByRefType(StringRef DeclName, QualType Ty) const { 3953af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // type = struct __Block_byref_1_X { 3954ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // void *__isa; 3955af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // struct __Block_byref_1_X *__forwarding; 3956ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // unsigned int __flags; 3957ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // unsigned int __size; 3958a7e6845660f91ec611427e1db842780e1ec12bdbEli Friedman // void *__copy_helper; // as needed 3959a7e6845660f91ec611427e1db842780e1ec12bdbEli Friedman // void *__destroy_help // as needed 3960af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // int X; 3961ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // } * 3962ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump 3963af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump bool HasCopyAndDispose = BlockRequiresCopying(Ty); 3964af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3965af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // FIXME: Move up 3966f7ccbad5d9949e7ddd1cbef43d482553b811e026Dylan Noblesmith SmallString<36> Name; 3967f5942a44880be26878592eb052b737579349411eBenjamin Kramer llvm::raw_svector_ostream(Name) << "__Block_byref_" << 3968f5942a44880be26878592eb052b737579349411eBenjamin Kramer ++UniqueBlockByRefTypeID << '_' << DeclName; 3969af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump RecordDecl *T; 3970ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara T = CreateRecordDecl(*this, TTK_Struct, TUDecl, &Idents.get(Name.str())); 3971af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump T->startDefinition(); 3972af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump QualType Int32Ty = IntTy; 3973af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump assert(getIntWidth(IntTy) == 32 && "non-32bit int not supported"); 3974af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump QualType FieldTypes[] = { 3975af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(VoidPtrTy), 3976af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(getTagDeclType(T)), 3977af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump Int32Ty, 3978af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump Int32Ty, 3979af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(VoidPtrTy), 3980af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(VoidPtrTy), 3981af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump Ty 3982af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump }; 3983af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 39845f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner StringRef FieldNames[] = { 3985af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__isa", 3986af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__forwarding", 3987af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__flags", 3988af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__size", 3989af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__copy_helper", 3990af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__destroy_helper", 3991af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump DeclName, 3992af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump }; 3993af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3994af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump for (size_t i = 0; i < 7; ++i) { 3995af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump if (!HasCopyAndDispose && i >=4 && i <= 5) 3996af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump continue; 3997af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 3998ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara SourceLocation(), 3999af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump &Idents.get(FieldNames[i]), 4000a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 40017a614d8380297fcd2bc23986241905d97222948cRichard Smith /*BitWidth=*/0, /*Mutable=*/false, 40027a614d8380297fcd2bc23986241905d97222948cRichard Smith /*HasInit=*/false); 40032888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 4004af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump T->addDecl(Field); 4005af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump } 4006af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 4007838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor T->completeDefinition(); 4008af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 4009af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump return getPointerType(getTagDeclType(T)); 4010ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump} 4011ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump 4012e97179c675b341927807c718be215c8d1aab8acbDouglas GregorTypedefDecl *ASTContext::getObjCInstanceTypeDecl() { 4013e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor if (!ObjCInstanceTypeDecl) 4014e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor ObjCInstanceTypeDecl = TypedefDecl::Create(*this, 4015e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor getTranslationUnitDecl(), 4016e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor SourceLocation(), 4017e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor SourceLocation(), 4018e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor &Idents.get("instancetype"), 4019e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor getTrivialTypeSourceInfo(getObjCIdType())); 4020e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor return ObjCInstanceTypeDecl; 4021e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor} 4022e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor 4023e8c49533521c40643653f943d47229e62d277f88Anders Carlsson// This returns true if a type has been typedefed to BOOL: 4024e8c49533521c40643653f943d47229e62d277f88Anders Carlsson// typedef <type> BOOL; 40252d99833e8c956775f2183601cd120b65b569c867Chris Lattnerstatic bool isTypeTypedefedAsBOOL(QualType T) { 4026e8c49533521c40643653f943d47229e62d277f88Anders Carlsson if (const TypedefType *TT = dyn_cast<TypedefType>(T)) 4027bb49c3ee5d270485f4b273691fd14bc97403fa5dChris Lattner if (IdentifierInfo *II = TT->getDecl()->getIdentifier()) 4028bb49c3ee5d270485f4b273691fd14bc97403fa5dChris Lattner return II->isStr("BOOL"); 40291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 403085f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson return false; 403185f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson} 403285f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson 4033a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek/// getObjCEncodingTypeSize returns size of type for objective-c encoding 403433e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian/// purpose. 40354ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getObjCEncodingTypeSize(QualType type) const { 4036f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor if (!type->isIncompleteArrayType() && type->isIncompleteType()) 4037f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return CharUnits::Zero(); 4038f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4039199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits sz = getTypeSizeInChars(type); 40401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 404133e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Make all integer and enum types at least as large as an int 40422ade35e2cfd554e49d35a52047cea98a82787af9Douglas Gregor if (sz.isPositive() && type->isIntegralOrEnumerationType()) 4043199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck sz = std::max(sz, getTypeSizeInChars(IntTy)); 404433e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Treat arrays as pointers, since that's how they're passed in. 404533e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian else if (type->isArrayType()) 4046199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck sz = getTypeSizeInChars(VoidPtrTy); 4047aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck return sz; 4048199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck} 4049199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck 4050199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyckstatic inline 4051199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyckstd::string charUnitsToString(const CharUnits &CU) { 4052199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck return llvm::itostr(CU.getQuantity()); 405333e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian} 405433e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian 40556b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall/// getObjCEncodingForBlock - Return the encoded type for this block 40565e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall/// declaration. 40576b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCallstd::string ASTContext::getObjCEncodingForBlock(const BlockExpr *Expr) const { 40586b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall std::string S; 40596b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall 40605e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall const BlockDecl *Decl = Expr->getBlockDecl(); 40615e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall QualType BlockTy = 40625e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall Expr->getType()->getAs<BlockPointerType>()->getPointeeType(); 40635e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Encode result type. 4064c71a4915ca216847599d03cab4ed1c5086b0eb43John McCall getObjCEncodingForType(BlockTy->getAs<FunctionType>()->getResultType(), S); 40655e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Compute size of all parameters. 40665e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Start with computing size of a pointer in number of bytes. 40675e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // FIXME: There might(should) be a better way of doing this computation! 40685e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall SourceLocation Loc; 4069199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy); 4070199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits ParmOffset = PtrSize; 40716f46c2653c1545cc3fef0c0df996d18160160ce8Fariborz Jahanian for (BlockDecl::param_const_iterator PI = Decl->param_begin(), 40725e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall E = Decl->param_end(); PI != E; ++PI) { 40735e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall QualType PType = (*PI)->getType(); 4074aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck CharUnits sz = getObjCEncodingTypeSize(PType); 4075199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck assert (sz.isPositive() && "BlockExpr - Incomplete param type"); 40765e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall ParmOffset += sz; 40775e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall } 40785e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Size of the argument frame 4079199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 40805e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Block pointer and offset. 40815e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall S += "@?0"; 40825e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall 40835e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Argument types. 40845e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall ParmOffset = PtrSize; 40855e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall for (BlockDecl::param_const_iterator PI = Decl->param_begin(), E = 40865e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall Decl->param_end(); PI != E; ++PI) { 40875e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall ParmVarDecl *PVDecl = *PI; 40885e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall QualType PType = PVDecl->getOriginalType(); 40895e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall if (const ArrayType *AT = 40905e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 40915e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Use array's original type only if it has known number of 40925389f48b24937ad7b4093307128b3cbf25235654David Chisnall // elements. 40935389f48b24937ad7b4093307128b3cbf25235654David Chisnall if (!isa<ConstantArrayType>(AT)) 40945389f48b24937ad7b4093307128b3cbf25235654David Chisnall PType = PVDecl->getType(); 40955389f48b24937ad7b4093307128b3cbf25235654David Chisnall } else if (PType->isFunctionType()) 40965389f48b24937ad7b4093307128b3cbf25235654David Chisnall PType = PVDecl->getType(); 40975389f48b24937ad7b4093307128b3cbf25235654David Chisnall getObjCEncodingForType(PType, S); 40985389f48b24937ad7b4093307128b3cbf25235654David Chisnall S += charUnitsToString(ParmOffset); 40995389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmOffset += getObjCEncodingTypeSize(PType); 41005389f48b24937ad7b4093307128b3cbf25235654David Chisnall } 41016b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall 41026b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall return S; 41035389f48b24937ad7b4093307128b3cbf25235654David Chisnall} 41045389f48b24937ad7b4093307128b3cbf25235654David Chisnall 4105f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregorbool ASTContext::getObjCEncodingForFunctionDecl(const FunctionDecl *Decl, 41065389f48b24937ad7b4093307128b3cbf25235654David Chisnall std::string& S) { 41075389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Encode result type. 41085389f48b24937ad7b4093307128b3cbf25235654David Chisnall getObjCEncodingForType(Decl->getResultType(), S); 41095389f48b24937ad7b4093307128b3cbf25235654David Chisnall CharUnits ParmOffset; 41105389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Compute size of all parameters. 41115389f48b24937ad7b4093307128b3cbf25235654David Chisnall for (FunctionDecl::param_const_iterator PI = Decl->param_begin(), 41125389f48b24937ad7b4093307128b3cbf25235654David Chisnall E = Decl->param_end(); PI != E; ++PI) { 41135389f48b24937ad7b4093307128b3cbf25235654David Chisnall QualType PType = (*PI)->getType(); 41145389f48b24937ad7b4093307128b3cbf25235654David Chisnall CharUnits sz = getObjCEncodingTypeSize(PType); 4115f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor if (sz.isZero()) 4116f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return true; 4117f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 41185389f48b24937ad7b4093307128b3cbf25235654David Chisnall assert (sz.isPositive() && 4119f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor "getObjCEncodingForFunctionDecl - Incomplete param type"); 41205389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmOffset += sz; 41215389f48b24937ad7b4093307128b3cbf25235654David Chisnall } 41225389f48b24937ad7b4093307128b3cbf25235654David Chisnall S += charUnitsToString(ParmOffset); 41235389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmOffset = CharUnits::Zero(); 41245389f48b24937ad7b4093307128b3cbf25235654David Chisnall 41255389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Argument types. 41265389f48b24937ad7b4093307128b3cbf25235654David Chisnall for (FunctionDecl::param_const_iterator PI = Decl->param_begin(), 41275389f48b24937ad7b4093307128b3cbf25235654David Chisnall E = Decl->param_end(); PI != E; ++PI) { 41285389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmVarDecl *PVDecl = *PI; 41295389f48b24937ad7b4093307128b3cbf25235654David Chisnall QualType PType = PVDecl->getOriginalType(); 41305389f48b24937ad7b4093307128b3cbf25235654David Chisnall if (const ArrayType *AT = 41315389f48b24937ad7b4093307128b3cbf25235654David Chisnall dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 41325389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Use array's original type only if it has known number of 41335e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // elements. 41345e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall if (!isa<ConstantArrayType>(AT)) 41355e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall PType = PVDecl->getType(); 41365e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall } else if (PType->isFunctionType()) 41375e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall PType = PVDecl->getType(); 41385e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall getObjCEncodingForType(PType, S); 4139199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 4140aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck ParmOffset += getObjCEncodingTypeSize(PType); 41415e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall } 4142f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4143f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return false; 41445e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall} 41455e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall 4146dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson/// getObjCEncodingForMethodParameter - Return the encoded type for a single 4147dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson/// method parameter or return type. If Extended, include class names and 4148dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson/// block object types. 4149dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilsonvoid ASTContext::getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT, 4150dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson QualType T, std::string& S, 4151dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool Extended) const { 4152dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Encode type qualifer, 'in', 'inout', etc. for the parameter. 4153dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeQualifier(QT, S); 4154dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Encode parameter type. 4155dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeImpl(T, S, true, true, 0, 4156dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson true /*OutermostType*/, 4157dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /*EncodingProperty*/, 4158dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /*StructField*/, 4159dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson Extended /*EncodeBlockParameters*/, 4160dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson Extended /*EncodeClassNames*/); 4161dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson} 4162dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson 4163a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek/// getObjCEncodingForMethodDecl - Return the encoded type for this method 416433e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian/// declaration. 4165f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregorbool ASTContext::getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl, 4166dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson std::string& S, 4167dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool Extended) const { 4168c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: This is not very efficient. 4169dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Encode return type. 4170dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForMethodParameter(Decl->getObjCDeclQualifier(), 4171dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson Decl->getResultType(), S, Extended); 417233e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Compute size of all parameters. 417333e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Start with computing size of a pointer in number of bytes. 417433e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // FIXME: There might(should) be a better way of doing this computation! 417533e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian SourceLocation Loc; 4176199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy); 417733e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // The first two arguments (self and _cmd) are pointers; account for 417833e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // their size. 4179199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits ParmOffset = 2 * PtrSize; 4180491306a83c4f0f49f95a3bcbca8580cb98a91c7aArgyrios Kyrtzidis for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(), 41817732cc9c0fdc97a2f8cce4e5933d8103213d1aefFariborz Jahanian E = Decl->sel_param_end(); PI != E; ++PI) { 418289951a86b594513c2a013532ed45d197413b1087Chris Lattner QualType PType = (*PI)->getType(); 4183aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck CharUnits sz = getObjCEncodingTypeSize(PType); 4184f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor if (sz.isZero()) 4185f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return true; 4186f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4187199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck assert (sz.isPositive() && 4188199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck "getObjCEncodingForMethodDecl - Incomplete param type"); 418933e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian ParmOffset += sz; 419033e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian } 4191199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 419233e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian S += "@0:"; 4193199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(PtrSize); 41941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 419533e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Argument types. 419633e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian ParmOffset = 2 * PtrSize; 4197491306a83c4f0f49f95a3bcbca8580cb98a91c7aArgyrios Kyrtzidis for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(), 41987732cc9c0fdc97a2f8cce4e5933d8103213d1aefFariborz Jahanian E = Decl->sel_param_end(); PI != E; ++PI) { 4199491306a83c4f0f49f95a3bcbca8580cb98a91c7aArgyrios Kyrtzidis const ParmVarDecl *PVDecl = *PI; 42001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType PType = PVDecl->getOriginalType(); 42014306d3cb9116605728252e2738df24b9f6ab53c3Fariborz Jahanian if (const ArrayType *AT = 4202ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 4203ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff // Use array's original type only if it has known number of 4204ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff // elements. 4205bb3fde337fb712c0e6da8790d431621be4793048Steve Naroff if (!isa<ConstantArrayType>(AT)) 4206ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff PType = PVDecl->getType(); 4207ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff } else if (PType->isFunctionType()) 4208ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff PType = PVDecl->getType(); 4209dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForMethodParameter(PVDecl->getObjCDeclQualifier(), 4210dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson PType, S, Extended); 4211199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 4212aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck ParmOffset += getObjCEncodingTypeSize(PType); 421333e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian } 4214f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4215f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return false; 421633e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian} 421733e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian 4218c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar/// getObjCEncodingForPropertyDecl - Return the encoded type for this 421983bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// property declaration. If non-NULL, Container must be either an 4220c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar/// ObjCCategoryImplDecl or ObjCImplementationDecl; it should only be 4221c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar/// NULL when getting encodings for protocol properties. 42221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// Property attributes are stored as a comma-delimited C string. The simple 42231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// attributes readonly and bycopy are encoded as single characters. The 42241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// parametrized attributes, getter=name, setter=name, and ivar=name, are 42251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// encoded as single characters, followed by an identifier. Property types 42261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// are also encoded as a parametrized attribute. The characters used to encode 422783bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// these attributes are defined by the following enumeration: 422883bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// @code 422983bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// enum PropertyAttributes { 423083bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyReadOnly = 'R', // property is read-only. 423183bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyBycopy = 'C', // property is a copy of the value last assigned 423283bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyByref = '&', // property is a reference to the value last assigned 423383bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyDynamic = 'D', // property is dynamic 423483bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyGetter = 'G', // followed by getter selector name 423583bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertySetter = 'S', // followed by setter selector name 423683bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyInstanceVariable = 'V' // followed by instance variable name 423783bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyType = 't' // followed by old-style type encoding. 423883bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyWeak = 'W' // 'weak' property 423983bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyStrong = 'P' // property GC'able 424083bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyNonAtomic = 'N' // property non-atomic 424183bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// }; 424283bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// @endcode 42431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid ASTContext::getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD, 4244c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar const Decl *Container, 42454ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad std::string& S) const { 4246c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // Collect information from the property implementation decl(s). 4247c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar bool Dynamic = false; 4248c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar ObjCPropertyImplDecl *SynthesizePID = 0; 4249c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4250c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: Duplicated code due to poor abstraction. 4251c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (Container) { 42521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const ObjCCategoryImplDecl *CID = 4253c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar dyn_cast<ObjCCategoryImplDecl>(Container)) { 4254c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar for (ObjCCategoryImplDecl::propimpl_iterator 425517945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis i = CID->propimpl_begin(), e = CID->propimpl_end(); 4256653f1b1bf293a9bd96fd4dd6372e779cc7af1597Douglas Gregor i != e; ++i) { 4257c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar ObjCPropertyImplDecl *PID = *i; 4258c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyDecl() == PD) { 4259c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) { 4260c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar Dynamic = true; 4261c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 4262c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar SynthesizePID = PID; 4263c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4264c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4265c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4266c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 426761710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner const ObjCImplementationDecl *OID=cast<ObjCImplementationDecl>(Container); 4268c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar for (ObjCCategoryImplDecl::propimpl_iterator 426917945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis i = OID->propimpl_begin(), e = OID->propimpl_end(); 4270653f1b1bf293a9bd96fd4dd6372e779cc7af1597Douglas Gregor i != e; ++i) { 4271c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar ObjCPropertyImplDecl *PID = *i; 4272c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyDecl() == PD) { 4273c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) { 4274c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar Dynamic = true; 4275c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 4276c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar SynthesizePID = PID; 4277c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4278c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 42791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 4280c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4281c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4282c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4283c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: This is not very efficient. 4284c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S = "T"; 4285c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4286c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // Encode result type. 4287090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian // GCC has some special rules regarding encoding of properties which 4288090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian // closely resembles encoding of ivars. 42891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(PD->getType(), S, true, true, 0, 4290090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian true /* outermost type */, 4291090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian true /* encoding for property */); 4292c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4293c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PD->isReadOnly()) { 4294c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",R"; 4295c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 4296c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar switch (PD->getSetterKind()) { 4297c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case ObjCPropertyDecl::Assign: break; 4298c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case ObjCPropertyDecl::Copy: S += ",C"; break; 42991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case ObjCPropertyDecl::Retain: S += ",&"; break; 43003a02b44e3948f7762dbfba94b7961281ca29d022Fariborz Jahanian case ObjCPropertyDecl::Weak: S += ",W"; break; 4301c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4302c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4303c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4304c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // It really isn't clear at all what this means, since properties 4305c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // are "dynamic by default". 4306c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (Dynamic) 4307c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",D"; 4308c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4309090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic) 4310090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian S += ",N"; 43111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4312c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) { 4313c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",G"; 4314077bf5e2f48acfa9e7d69429b6e4ba86ea14896dChris Lattner S += PD->getGetterName().getAsString(); 4315c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4316c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4317c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) { 4318c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",S"; 4319077bf5e2f48acfa9e7d69429b6e4ba86ea14896dChris Lattner S += PD->getSetterName().getAsString(); 4320c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4321c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4322c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (SynthesizePID) { 4323c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar const ObjCIvarDecl *OID = SynthesizePID->getPropertyIvarDecl(); 4324c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",V"; 432539f34e97d6a468f0a7dfa5664c61217cffc65b74Chris Lattner S += OID->getNameAsString(); 4326c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4327c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4328c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: OBJCGC: weak & strong 4329c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar} 4330c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4331a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian/// getLegacyIntegralTypeEncoding - 43321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// Another legacy compatibility encoding: 32-bit longs are encoded as 43331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// 'l' or 'L' , but not always. For typedefs, we need to use 4334a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian/// 'i' or 'I' instead if encoding a struct field, or a pointer! 4335a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian/// 4336a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanianvoid ASTContext::getLegacyIntegralTypeEncoding (QualType &PointeeTy) const { 43378e1fab243ab8023b7ee3899745386b3b3a4258f8Mike Stump if (isa<TypedefType>(PointeeTy.getTypePtr())) { 4338183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const BuiltinType *BT = PointeeTy->getAs<BuiltinType>()) { 43394ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (BT->getKind() == BuiltinType::ULong && getIntWidth(PointeeTy) == 32) 4340a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian PointeeTy = UnsignedIntTy; 43411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump else 43424ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (BT->getKind() == BuiltinType::Long && getIntWidth(PointeeTy) == 32) 4343a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian PointeeTy = IntTy; 4344a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4345a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4346a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian} 4347a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian 43487d6b46d9a9d75dea8ef9f6973dd50633c1f37963Fariborz Jahanianvoid ASTContext::getObjCEncodingForType(QualType T, std::string& S, 43494ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const FieldDecl *Field) const { 435082a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // We follow the behavior of gcc, expanding structures which are 435182a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // directly pointed to, and expanding embedded structures. Note that 435282a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // these rules are sufficient to prevent recursive encoding of the 435382a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // same type. 43541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(T, S, true, true, Field, 43555b8c7d9fb620ba3a71e996d61e7b9bdf763b5c09Fariborz Jahanian true /* outermost type */); 435682a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar} 435782a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar 435864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnallstatic char ObjCEncodingForPrimitiveKind(const ASTContext *C, QualType T) { 435964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall switch (T->getAs<BuiltinType>()->getKind()) { 4360b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Unhandled builtin type kind"); 436164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Void: return 'v'; 436264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Bool: return 'B'; 436364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Char_U: 436464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UChar: return 'C'; 436564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UShort: return 'S'; 436664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UInt: return 'I'; 436764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::ULong: 43684ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad return C->getIntWidth(T) == 32 ? 'L' : 'Q'; 436964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UInt128: return 'T'; 437064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::ULongLong: return 'Q'; 437164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Char_S: 437264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::SChar: return 'c'; 437364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Short: return 's'; 43743f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_S: 43753f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_U: 437664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Int: return 'i'; 437764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Long: 43784ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad return C->getIntWidth(T) == 32 ? 'l' : 'q'; 437964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::LongLong: return 'q'; 438064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Int128: return 't'; 438164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Float: return 'f'; 438264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Double: return 'd'; 43833a0be84b2aed8563150cdbd976a98838afa261ebDaniel Dunbar case BuiltinType::LongDouble: return 'D'; 438464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall } 438564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall} 438664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall 43875471bc85b69912e3b448de004498a80c0de32296Douglas Gregorstatic char ObjCEncodingForEnumType(const ASTContext *C, const EnumType *ET) { 43885471bc85b69912e3b448de004498a80c0de32296Douglas Gregor EnumDecl *Enum = ET->getDecl(); 43895471bc85b69912e3b448de004498a80c0de32296Douglas Gregor 43905471bc85b69912e3b448de004498a80c0de32296Douglas Gregor // The encoding of an non-fixed enum type is always 'i', regardless of size. 43915471bc85b69912e3b448de004498a80c0de32296Douglas Gregor if (!Enum->isFixed()) 43925471bc85b69912e3b448de004498a80c0de32296Douglas Gregor return 'i'; 43935471bc85b69912e3b448de004498a80c0de32296Douglas Gregor 43945471bc85b69912e3b448de004498a80c0de32296Douglas Gregor // The encoding of a fixed enum type matches its fixed underlying type. 43955471bc85b69912e3b448de004498a80c0de32296Douglas Gregor return ObjCEncodingForPrimitiveKind(C, Enum->getIntegerType()); 43965471bc85b69912e3b448de004498a80c0de32296Douglas Gregor} 43975471bc85b69912e3b448de004498a80c0de32296Douglas Gregor 43984ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadstatic void EncodeBitField(const ASTContext *Ctx, std::string& S, 439964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall QualType T, const FieldDecl *FD) { 4400a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith assert(FD->isBitField() && "not a bitfield - getObjCEncodingForTypeImpl"); 44018b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian S += 'b'; 440264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // The NeXT runtime encodes bit fields as b followed by the number of bits. 440364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // The GNU runtime requires more information; bitfields are encoded as b, 440464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // then the offset (in bits) of the first element, then the type of the 440564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // bitfield, then the size in bits. For example, in this structure: 440664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // 440764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // struct 440864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // { 440964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // int integer; 441064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // int flags:2; 441164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // }; 441264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // On a 32-bit system, the encoding for flags would be b2 for the NeXT 441364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // runtime, but b32i2 for the GNU runtime. The reason for this extra 441464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // information is not especially sensible, but we're stuck with it for 441564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // compatibility with GCC, although providing it breaks anything that 441664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // actually uses runtime introspection and wants to work on both runtimes... 441764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall if (!Ctx->getLangOptions().NeXTRuntime) { 441864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall const RecordDecl *RD = FD->getParent(); 441964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall const ASTRecordLayout &RL = Ctx->getASTRecordLayout(RD); 442082905749d5c8d8b4edec11de754a73349cb96603Eli Friedman S += llvm::utostr(RL.getFieldOffset(FD->getFieldIndex())); 44215471bc85b69912e3b448de004498a80c0de32296Douglas Gregor if (const EnumType *ET = T->getAs<EnumType>()) 44225471bc85b69912e3b448de004498a80c0de32296Douglas Gregor S += ObjCEncodingForEnumType(Ctx, ET); 4423c7ff82c2040f45eaad2eddea0e4461dddc972cd1David Chisnall else 44244ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad S += ObjCEncodingForPrimitiveKind(Ctx, T); 442564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall } 4426a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith S += llvm::utostr(FD->getBitWidthValue(*Ctx)); 44278b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian} 44288b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian 442901eb9b9683535d8a65c704ad2c545903409e2d36Daniel Dunbar// FIXME: Use SmallString for accumulating string. 443082a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbarvoid ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S, 443182a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar bool ExpandPointedToStructures, 443282a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar bool ExpandStructures, 4433153bfe5795e2c1a5a738e73d3784964e082237fcDaniel Dunbar const FieldDecl *FD, 4434090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian bool OutermostType, 44352636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis bool EncodingProperty, 4436dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool StructField, 4437dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool EncodeBlockParameters, 4438dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool EncodeClassNames) const { 443964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall if (T->getAs<BuiltinType>()) { 4440ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (FD && FD->isBitField()) 444164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall return EncodeBitField(this, S, T, FD); 444264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall S += ObjCEncodingForPrimitiveKind(this, T); 4443ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4444ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 44451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4446183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ComplexType *CT = T->getAs<ComplexType>()) { 4447c612f7bc9a6379cd7e7c2dd306d05938e890051bAnders Carlsson S += 'j'; 44481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(CT->getElementType(), S, false, false, 0, false, 4449c612f7bc9a6379cd7e7c2dd306d05938e890051bAnders Carlsson false); 4450ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4451ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 445260bce3ef20a4c9684e3825cdd739fefb9810327dFariborz Jahanian 4453aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian // encoding for pointer or r3eference types. 4454aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian QualType PointeeTy; 44556217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const PointerType *PT = T->getAs<PointerType>()) { 44568d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian if (PT->isObjCSelType()) { 44578d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian S += ':'; 44588d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian return; 44598d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian } 4460aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian PointeeTy = PT->getPointeeType(); 4461aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian } 4462aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian else if (const ReferenceType *RT = T->getAs<ReferenceType>()) 4463aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian PointeeTy = RT->getPointeeType(); 4464aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian if (!PointeeTy.isNull()) { 4465a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian bool isReadOnly = false; 4466a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // For historical/compatibility reasons, the read-only qualifier of the 4467a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // pointee gets emitted _before_ the '^'. The read-only qualifier of 4468a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // the pointer itself gets ignored, _unless_ we are looking at a typedef! 44691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Also, do not emit the 'r' for anything but the outermost type! 44708e1fab243ab8023b7ee3899745386b3b3a4258f8Mike Stump if (isa<TypedefType>(T.getTypePtr())) { 4471a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian if (OutermostType && T.isConstQualified()) { 4472a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian isReadOnly = true; 4473a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian S += 'r'; 4474a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 44759fdbab3cbc2fc04bcaf5768023d83707f3151144Mike Stump } else if (OutermostType) { 4476a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian QualType P = PointeeTy; 44776217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek while (P->getAs<PointerType>()) 44786217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek P = P->getAs<PointerType>()->getPointeeType(); 4479a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian if (P.isConstQualified()) { 4480a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian isReadOnly = true; 4481a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian S += 'r'; 4482a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4483a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4484a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian if (isReadOnly) { 4485a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // Another legacy compatibility encoding. Some ObjC qualifier and type 4486a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // combinations need to be rearranged. 4487a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // Rewrite "in const" from "nr" to "rn" 44885f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner if (StringRef(S).endswith("nr")) 44890237941e0beb0c929934b66ad29443b484d987feBenjamin Kramer S.replace(S.end()-2, S.end(), "rn"); 4490a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 44911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 449285f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson if (PointeeTy->isCharType()) { 449385f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson // char pointer types should be encoded as '*' unless it is a 449485f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson // type that has been typedef'd to 'BOOL'. 4495e8c49533521c40643653f943d47229e62d277f88Anders Carlsson if (!isTypeTypedefedAsBOOL(PointeeTy)) { 449685f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson S += '*'; 449785f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson return; 449885f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson } 44996217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek } else if (const RecordType *RTy = PointeeTy->getAs<RecordType>()) { 45009533a7fdb8397421f3be52e879442460a87389f6Steve Naroff // GCC binary compat: Need to convert "struct objc_class *" to "#". 45019533a7fdb8397421f3be52e879442460a87389f6Steve Naroff if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_class")) { 45029533a7fdb8397421f3be52e879442460a87389f6Steve Naroff S += '#'; 45039533a7fdb8397421f3be52e879442460a87389f6Steve Naroff return; 45049533a7fdb8397421f3be52e879442460a87389f6Steve Naroff } 45059533a7fdb8397421f3be52e879442460a87389f6Steve Naroff // GCC binary compat: Need to convert "struct objc_object *" to "@". 45069533a7fdb8397421f3be52e879442460a87389f6Steve Naroff if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_object")) { 45079533a7fdb8397421f3be52e879442460a87389f6Steve Naroff S += '@'; 45089533a7fdb8397421f3be52e879442460a87389f6Steve Naroff return; 45099533a7fdb8397421f3be52e879442460a87389f6Steve Naroff } 45109533a7fdb8397421f3be52e879442460a87389f6Steve Naroff // fall through... 451185f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson } 451285f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson S += '^'; 4513a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian getLegacyIntegralTypeEncoding(PointeeTy); 4514a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian 45151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(PointeeTy, S, false, ExpandPointedToStructures, 451643822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian NULL); 4517ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4518ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 4519aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian 4520ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (const ArrayType *AT = 4521ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner // Ignore type qualifiers etc. 4522ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner dyn_cast<ArrayType>(T->getCanonicalTypeInternal())) { 45232636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (isa<IncompleteArrayType>(AT) && !StructField) { 4524559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson // Incomplete arrays are encoded as a pointer to the array element. 4525559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += '^'; 4526559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson 45271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(AT->getElementType(), S, 4528559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson false, ExpandStructures, FD); 4529559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson } else { 4530559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += '['; 45311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45322636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) { 45332636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (getTypeSize(CAT->getElementType()) == 0) 45342636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '0'; 45352636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis else 45362636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += llvm::utostr(CAT->getSize().getZExtValue()); 45372636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 4538559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson //Variable length arrays are encoded as a regular array with 0 elements. 45392636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert((isa<VariableArrayType>(AT) || isa<IncompleteArrayType>(AT)) && 45402636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis "Unknown array type!"); 4541559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += '0'; 4542559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson } 45431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(AT->getElementType(), S, 4545559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson false, ExpandStructures, FD); 4546559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += ']'; 4547559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson } 4548ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4549ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 45501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4551183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (T->getAs<FunctionType>()) { 4552c0a87b7db06643178ad2cbce0767548c139ea387Anders Carlsson S += '?'; 4553ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4554ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 45551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45566217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const RecordType *RTy = T->getAs<RecordType>()) { 455782a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar RecordDecl *RDecl = RTy->getDecl(); 4558d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar S += RDecl->isUnion() ? '(' : '{'; 4559502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar // Anonymous structures print as '?' 4560502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar if (const IdentifierInfo *II = RDecl->getIdentifier()) { 4561502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar S += II->getName(); 45626fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian if (ClassTemplateSpecializationDecl *Spec 45636fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian = dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) { 45646fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 45656fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian std::string TemplateArgsStr 45666fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian = TemplateSpecializationType::PrintTemplateArgumentList( 4567910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgs.data(), 4568910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgs.size(), 456930c42404202d2e2512e51efc6066bd614cfdb5a4Douglas Gregor (*this).getPrintingPolicy()); 45706fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian 45716fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian S += TemplateArgsStr; 45726fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian } 4573502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar } else { 4574502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar S += '?'; 4575502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar } 45760d504c1da852e58ff802545c823ecff3b6c654b8Daniel Dunbar if (ExpandStructures) { 45777d6b46d9a9d75dea8ef9f6973dd50633c1f37963Fariborz Jahanian S += '='; 45782636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!RDecl->isUnion()) { 45792636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForStructureImpl(RDecl, S, FD); 45802636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 45812636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (RecordDecl::field_iterator Field = RDecl->field_begin(), 45822636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldEnd = RDecl->field_end(); 45832636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis Field != FieldEnd; ++Field) { 45842636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (FD) { 45852636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 45862636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += Field->getNameAsString(); 45872636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 45882636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 45891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45902636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // Special case bit-fields. 45912636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (Field->isBitField()) { 45922636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForTypeImpl(Field->getType(), S, false, true, 45932636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis (*Field)); 45942636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 45952636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis QualType qt = Field->getType(); 45962636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getLegacyIntegralTypeEncoding(qt); 45972636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForTypeImpl(qt, S, false, true, 45982636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FD, /*OutermostType*/false, 45992636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*EncodingProperty*/false, 46002636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*StructField*/true); 46012636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 4602d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar } 46037d6b46d9a9d75dea8ef9f6973dd50633c1f37963Fariborz Jahanian } 46046de88a873a4cbe06d72602eef57d68006730a80bFariborz Jahanian } 4605d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar S += RDecl->isUnion() ? ')' : '}'; 4606ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4607ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 4608e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian 46095471bc85b69912e3b448de004498a80c0de32296Douglas Gregor if (const EnumType *ET = T->getAs<EnumType>()) { 46108b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian if (FD && FD->isBitField()) 461164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall EncodeBitField(this, S, T, FD); 46128b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian else 46135471bc85b69912e3b448de004498a80c0de32296Douglas Gregor S += ObjCEncodingForEnumType(this, ET); 4614ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4615ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4617dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (const BlockPointerType *BT = T->getAs<BlockPointerType>()) { 461821a98b188857d690aa4510c52ac4317ffa0908a8Steve Naroff S += "@?"; // Unlike a pointer-to-function, which is "^?". 4619dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (EncodeBlockParameters) { 4620dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson const FunctionType *FT = BT->getPointeeType()->getAs<FunctionType>(); 4621dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson 4622dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson S += '<'; 4623dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Block return type 4624dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeImpl(FT->getResultType(), S, 4625dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson ExpandPointedToStructures, ExpandStructures, 4626dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson FD, 4627dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* OutermostType */, 4628dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodingProperty, 4629dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* StructField */, 4630dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeBlockParameters, 4631dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeClassNames); 4632dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Block self 4633dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson S += "@?"; 4634dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Block parameters 4635dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FT)) { 4636dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson for (FunctionProtoType::arg_type_iterator I = FPT->arg_type_begin(), 4637dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson E = FPT->arg_type_end(); I && (I != E); ++I) { 4638dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeImpl(*I, S, 4639dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson ExpandPointedToStructures, 4640dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson ExpandStructures, 4641dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson FD, 4642dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* OutermostType */, 4643dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodingProperty, 4644dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* StructField */, 4645dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeBlockParameters, 4646dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeClassNames); 4647dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson } 4648dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson } 4649dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson S += '>'; 4650dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson } 4651ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4652ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4654c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Ignore protocol qualifiers when mangling at this level. 4655c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OT = T->getAs<ObjCObjectType>()) 4656c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall T = OT->getBaseType(); 4657c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 46580953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (const ObjCInterfaceType *OIT = T->getAs<ObjCInterfaceType>()) { 465943822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian // @encode(class_name) 46600953e767ff7817f97b3ab20896b229891eeff45bJohn McCall ObjCInterfaceDecl *OI = OIT->getDecl(); 466143822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += '{'; 466243822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian const IdentifierInfo *II = OI->getIdentifier(); 466343822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += II->getName(); 466443822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += '='; 4665db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose SmallVector<const ObjCIvarDecl*, 32> Ivars; 46662c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian DeepCollectObjCIvars(OI, true, Ivars); 46672c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian for (unsigned i = 0, e = Ivars.size(); i != e; ++i) { 4668db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose const FieldDecl *Field = cast<FieldDecl>(Ivars[i]); 46692c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian if (Field->isBitField()) 46702c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian getObjCEncodingForTypeImpl(Field->getType(), S, false, true, Field); 467143822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian else 46722c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian getObjCEncodingForTypeImpl(Field->getType(), S, false, true, FD); 467343822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian } 467443822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += '}'; 4675ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 467643822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian } 46771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4678183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ObjCObjectPointerType *OPT = T->getAs<ObjCObjectPointerType>()) { 467914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (OPT->isObjCIdType()) { 468014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '@'; 468114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 4682ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 468427d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) { 468527d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff // FIXME: Consider if we need to output qualifiers for 'Class<p>'. 468627d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff // Since this is a binary compatibility issue, need to consult with runtime 468727d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff // folks. Fortunately, this is a *very* obsure construct. 468814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '#'; 468914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 4690ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4692ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (OPT->isObjCQualifiedIdType()) { 46931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(getObjCIdType(), S, 469414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff ExpandPointedToStructures, 469514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff ExpandStructures, FD); 4696dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (FD || EncodingProperty || EncodeClassNames) { 469714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff // Note that we do extended encoding of protocol qualifer list 469814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff // Only when doing ivar or property encoding. 469914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '"'; 470067ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(), 470167ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff E = OPT->qual_end(); I != E; ++I) { 470214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '<'; 470314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += (*I)->getNameAsString(); 470414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '>'; 470514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 470614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '"'; 470714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 470814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 4709ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 47101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4711ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner QualType PointeeTy = OPT->getPointeeType(); 4712ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (!EncodingProperty && 4713ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner isa<TypedefType>(PointeeTy.getTypePtr())) { 4714ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner // Another historical/compatibility reason. 47151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // We encode the underlying type which comes out as 4716ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner // {...}; 4717ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '^'; 47181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(PointeeTy, S, 47191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump false, ExpandPointedToStructures, 4720ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner NULL); 472114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 472214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 4723ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner 4724ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '@'; 4725dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (OPT->getInterfaceDecl() && 4726dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson (FD || EncodingProperty || EncodeClassNames)) { 4727ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '"'; 472827d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff S += OPT->getInterfaceDecl()->getIdentifier()->getName(); 472967ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(), 473067ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff E = OPT->qual_end(); I != E; ++I) { 4731ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '<'; 4732ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += (*I)->getNameAsString(); 4733ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '>'; 47341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 4735ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '"'; 4736ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 4737ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4738ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 47391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4740532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall // gcc just blithely ignores member pointers. 4741532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall // TODO: maybe there should be a mangling for these 4742532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall if (T->getAs<MemberPointerType>()) 4743532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall return; 4744e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian 4745e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian if (T->isVectorType()) { 4746e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian // This matches gcc's encoding, even though technically it is 4747e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian // insufficient. 4748e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian // FIXME. We should do a better job than gcc. 4749e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian return; 4750e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian } 4751e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian 4752b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("@encode for type not implemented!"); 475385f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson} 475485f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson 47552636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidisvoid ASTContext::getObjCEncodingForStructureImpl(RecordDecl *RDecl, 47562636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::string &S, 47572636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis const FieldDecl *FD, 47582636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis bool includeVBases) const { 47592636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert(RDecl && "Expected non-null RecordDecl"); 47602636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert(!RDecl->isUnion() && "Should not be called for unions"); 47612636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!RDecl->getDefinition()) 47622636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis return; 47632636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47642636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CXXRecordDecl *CXXRec = dyn_cast<CXXRecordDecl>(RDecl); 47652636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::multimap<uint64_t, NamedDecl *> FieldOrBaseOffsets; 47662636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis const ASTRecordLayout &layout = getASTRecordLayout(RDecl); 47672636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47682636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRec) { 47692636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (CXXRecordDecl::base_class_iterator 47702636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BI = CXXRec->bases_begin(), 47712636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BE = CXXRec->bases_end(); BI != BE; ++BI) { 47722636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!BI->isVirtual()) { 47732636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CXXRecordDecl *base = BI->getType()->getAsCXXRecordDecl(); 4774829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis if (base->isEmpty()) 4775829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis continue; 47762636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = layout.getBaseClassOffsetInBits(base); 47772636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs), 47782636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::make_pair(offs, base)); 47792636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47802636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47812636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47822636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47832636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis unsigned i = 0; 47842636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (RecordDecl::field_iterator Field = RDecl->field_begin(), 47852636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldEnd = RDecl->field_end(); 47862636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis Field != FieldEnd; ++Field, ++i) { 47872636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = layout.getFieldOffset(i); 47882636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs), 47892636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::make_pair(offs, *Field)); 47902636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47912636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47922636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRec && includeVBases) { 47932636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (CXXRecordDecl::base_class_iterator 47942636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BI = CXXRec->vbases_begin(), 47952636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BE = CXXRec->vbases_end(); BI != BE; ++BI) { 47962636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CXXRecordDecl *base = BI->getType()->getAsCXXRecordDecl(); 4797829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis if (base->isEmpty()) 4798829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis continue; 47992636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = layout.getVBaseClassOffsetInBits(base); 480019aa8609a5d04eed9b81aa1c4608e8a4f3df6ccdArgyrios Kyrtzidis if (FieldOrBaseOffsets.find(offs) == FieldOrBaseOffsets.end()) 480119aa8609a5d04eed9b81aa1c4608e8a4f3df6ccdArgyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.end(), 480219aa8609a5d04eed9b81aa1c4608e8a4f3df6ccdArgyrios Kyrtzidis std::make_pair(offs, base)); 48032636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48042636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48052636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48062636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CharUnits size; 48072636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRec) { 48082636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis size = includeVBases ? layout.getSize() : layout.getNonVirtualSize(); 48092636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 48102636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis size = layout.getSize(); 48112636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48122636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48132636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t CurOffs = 0; 48142636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::multimap<uint64_t, NamedDecl *>::iterator 48152636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurLayObj = FieldOrBaseOffsets.begin(); 48162636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 4817cb8061e321bc6f46f154529885028256c7ae1fb2Argyrios Kyrtzidis if ((CurLayObj != FieldOrBaseOffsets.end() && CurLayObj->first != 0) || 4818cb8061e321bc6f46f154529885028256c7ae1fb2Argyrios Kyrtzidis (CurLayObj == FieldOrBaseOffsets.end() && 4819cb8061e321bc6f46f154529885028256c7ae1fb2Argyrios Kyrtzidis CXXRec && CXXRec->isDynamicClass())) { 48202636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert(CXXRec && CXXRec->isDynamicClass() && 48212636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis "Offset 0 was empty but no VTable ?"); 48222636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (FD) { 48232636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += "\"_vptr$"; 48242636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::string recname = CXXRec->getNameAsString(); 48252636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (recname.empty()) recname = "?"; 48262636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += recname; 48272636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 48282636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48292636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += "^^?"; 48302636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurOffs += getTypeSize(VoidPtrTy); 48312636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48322636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48332636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!RDecl->hasFlexibleArrayMember()) { 48342636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // Mark the end of the structure. 48352636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = toBits(size); 48362636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs), 48372636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::make_pair(offs, (NamedDecl*)0)); 48382636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48392636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48402636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (; CurLayObj != FieldOrBaseOffsets.end(); ++CurLayObj) { 48412636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert(CurOffs <= CurLayObj->first); 48422636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48432636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CurOffs < CurLayObj->first) { 48442636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t padding = CurLayObj->first - CurOffs; 48452636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // FIXME: There doesn't seem to be a way to indicate in the encoding that 48462636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // packing/alignment of members is different that normal, in which case 48472636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // the encoding will be out-of-sync with the real layout. 48482636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // If the runtime switches to just consider the size of types without 48492636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // taking into account alignment, we could make padding explicit in the 48502636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // encoding (e.g. using arrays of chars). The encoding strings would be 48512636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // longer then though. 48522636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurOffs += padding; 48532636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48542636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48552636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis NamedDecl *dcl = CurLayObj->second; 48562636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (dcl == 0) 48572636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis break; // reached end of structure. 48582636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48592636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRecordDecl *base = dyn_cast<CXXRecordDecl>(dcl)) { 48602636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // We expand the bases without their virtual bases since those are going 48612636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // in the initial structure. Note that this differs from gcc which 48622636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // expands virtual bases each time one is encountered in the hierarchy, 48632636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // making the encoding type bigger than it really is. 48642636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForStructureImpl(base, S, FD, /*includeVBases*/false); 4865829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis assert(!base->isEmpty()); 4866829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis CurOffs += toBits(getASTRecordLayout(base).getNonVirtualSize()); 48672636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 48682636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldDecl *field = cast<FieldDecl>(dcl); 48692636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (FD) { 48702636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 48712636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += field->getNameAsString(); 48722636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 48732636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48742636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48752636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (field->isBitField()) { 48762636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis EncodeBitField(this, S, field->getType(), field); 4877a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith CurOffs += field->getBitWidthValue(*this); 48782636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 48792636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis QualType qt = field->getType(); 48802636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getLegacyIntegralTypeEncoding(qt); 48812636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForTypeImpl(qt, S, false, true, FD, 48822636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*OutermostType*/false, 48832636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*EncodingProperty*/false, 48842636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*StructField*/true); 48852636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurOffs += getTypeSize(field->getType()); 48862636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48872636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48882636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48892636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis} 48902636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT, 4892ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian std::string& S) const { 4893ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_In) 4894ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'n'; 4895ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Inout) 4896ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'N'; 4897ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Out) 4898ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'o'; 4899ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Bycopy) 4900ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'O'; 4901ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Byref) 4902ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'R'; 4903ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Oneway) 4904ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'V'; 4905ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian} 4906ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian 4907ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattnervoid ASTContext::setBuiltinVaListType(QualType T) { 4908b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson assert(BuiltinVaListType.isNull() && "__builtin_va_list type already set!"); 49091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4910b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson BuiltinVaListType = T; 4911b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson} 4912b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson 49134dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas GregorTypedefDecl *ASTContext::getObjCIdDecl() const { 49144dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor if (!ObjCIdDecl) { 49154dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor QualType T = getObjCObjectType(ObjCBuiltinIdTy, 0, 0); 49164dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor T = getObjCObjectPointerType(T); 49174dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor TypeSourceInfo *IdInfo = getTrivialTypeSourceInfo(T); 49184dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor ObjCIdDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 49194dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor getTranslationUnitDecl(), 49204dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor SourceLocation(), SourceLocation(), 49214dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor &Idents.get("id"), IdInfo); 49224dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor } 49234dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor 49244dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor return ObjCIdDecl; 49257e219e47de26346885d667131977bd9ca2d7662aSteve Naroff} 49267e219e47de26346885d667131977bd9ca2d7662aSteve Naroff 49277a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas GregorTypedefDecl *ASTContext::getObjCSelDecl() const { 49287a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor if (!ObjCSelDecl) { 49297a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor QualType SelT = getPointerType(ObjCBuiltinSelTy); 49307a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor TypeSourceInfo *SelInfo = getTrivialTypeSourceInfo(SelT); 49317a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor ObjCSelDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 49327a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor getTranslationUnitDecl(), 49337a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor SourceLocation(), SourceLocation(), 49347a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor &Idents.get("SEL"), SelInfo); 49357a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor } 49367a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor return ObjCSelDecl; 4937b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian} 4938b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian 493979d6726921897811232554ed94c5d77b5b7b3fc0Douglas GregorTypedefDecl *ASTContext::getObjCClassDecl() const { 494079d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor if (!ObjCClassDecl) { 494179d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor QualType T = getObjCObjectType(ObjCBuiltinClassTy, 0, 0); 494279d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor T = getObjCObjectPointerType(T); 494379d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor TypeSourceInfo *ClassInfo = getTrivialTypeSourceInfo(T); 494479d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor ObjCClassDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 494579d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor getTranslationUnitDecl(), 494679d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor SourceLocation(), SourceLocation(), 494779d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor &Idents.get("Class"), ClassInfo); 494879d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor } 494979d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor 495079d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor return ObjCClassDecl; 4951a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor} 4952a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor 4953a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas GregorObjCInterfaceDecl *ASTContext::getObjCProtocolDecl() const { 4954a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor if (!ObjCProtocolClassDecl) { 4955a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor ObjCProtocolClassDecl 4956a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor = ObjCInterfaceDecl::Create(*this, getTranslationUnitDecl(), 4957a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor SourceLocation(), 4958a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor &Idents.get("Protocol"), 4959a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor /*PrevDecl=*/0, 4960a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor SourceLocation(), true); 4961a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor } 4962a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor 4963a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor return ObjCProtocolClassDecl; 49648baaca50f07d0c10bba69c8d88c1b9078c92d06dAnders Carlsson} 49658baaca50f07d0c10bba69c8d88c1b9078c92d06dAnders Carlsson 4966a526c5c67e5a0473c340903ee542ce570119665fTed Kremenekvoid ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) { 49671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(ObjCConstantStringType.isNull() && 49682198891824c38d45b2279de5d5e3ef9394eb457cSteve Naroff "'NSConstantString' type already set!"); 49691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4970a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCConstantStringType = getObjCInterfaceType(Decl); 49712198891824c38d45b2279de5d5e3ef9394eb457cSteve Naroff} 49722198891824c38d45b2279de5d5e3ef9394eb457cSteve Naroff 49730bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall/// \brief Retrieve the template name that corresponds to a non-empty 49740bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall/// lookup. 49754ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName 49764ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getOverloadedTemplateName(UnresolvedSetIterator Begin, 49774ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad UnresolvedSetIterator End) const { 49780bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall unsigned size = End - Begin; 49790bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall assert(size > 1 && "set is not overloaded!"); 49807532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 49810bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall void *memory = Allocate(sizeof(OverloadedTemplateStorage) + 49820bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall size * sizeof(FunctionTemplateDecl*)); 49830bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall OverloadedTemplateStorage *OT = new(memory) OverloadedTemplateStorage(size); 49840bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall 49850bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall NamedDecl **Storage = OT->getStorage(); 4986eec51cf1ba5f0e62c9cdb81b5c63babdd6e649abJohn McCall for (UnresolvedSetIterator I = Begin; I != End; ++I) { 49870bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall NamedDecl *D = *I; 49880bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall assert(isa<FunctionTemplateDecl>(D) || 49890bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall (isa<UsingShadowDecl>(D) && 49900bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall isa<FunctionTemplateDecl>(D->getUnderlyingDecl()))); 49910bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall *Storage++ = D; 49927532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor } 49937532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 49940bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall return TemplateName(OT); 49957532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor} 49967532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 4997d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor/// \brief Retrieve the template name that represents a qualified 4998d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor/// template name such as \c std::vector. 49994ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName 50004ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS, 50014ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad bool TemplateKeyword, 50024ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad TemplateDecl *Template) const { 50030f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor assert(NNS && "Missing nested-name-specifier in qualified template name"); 50040f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor 5005789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor // FIXME: Canonicalization? 5006d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor llvm::FoldingSetNodeID ID; 5007d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template); 50081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5009d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor void *InsertPos = 0; 5010d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QualifiedTemplateName *QTN = 50110bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 5012d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor if (!QTN) { 5013d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QTN = new (*this,4) QualifiedTemplateName(NNS, TemplateKeyword, Template); 5014d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QualifiedTemplateNames.InsertNode(QTN, InsertPos); 5015d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor } 50161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5017d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor return TemplateName(QTN); 5018d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor} 5019d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor 50207532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor/// \brief Retrieve the template name that represents a dependent 50217532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor/// template name such as \c MetaFun::template apply. 50224ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName 50234ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getDependentTemplateName(NestedNameSpecifier *NNS, 50244ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const IdentifierInfo *Name) const { 50251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert((!NNS || NNS->isDependent()) && 50263b6afbb99a1c44b4076f8e15fb7311405941b306Douglas Gregor "Nested name specifier must be dependent"); 50277532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 50287532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor llvm::FoldingSetNodeID ID; 50297532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateName::Profile(ID, NNS, Name); 50307532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 50317532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor void *InsertPos = 0; 50327532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateName *QTN = 50337532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 50347532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 50357532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor if (QTN) 50367532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor return TemplateName(QTN); 50377532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 50387532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 50397532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor if (CanonNNS == NNS) { 50407532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Name); 50417532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor } else { 50427532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor TemplateName Canon = getDependentTemplateName(CanonNNS, Name); 50437532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Name, Canon); 5044789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateName *CheckQTN = 5045789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 5046789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!CheckQTN && "Dependent type name canonicalization broken"); 5047789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CheckQTN; 50487532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor } 50497532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 50507532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateNames.InsertNode(QTN, InsertPos); 50517532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor return TemplateName(QTN); 50527532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor} 50537532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 5054ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor/// \brief Retrieve the template name that represents a dependent 5055ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor/// template name such as \c MetaFun::template operator+. 5056ca1bdd7c269a2390d43c040a60511edd017ee130Douglas GregorTemplateName 5057ca1bdd7c269a2390d43c040a60511edd017ee130Douglas GregorASTContext::getDependentTemplateName(NestedNameSpecifier *NNS, 50584ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad OverloadedOperatorKind Operator) const { 5059ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor assert((!NNS || NNS->isDependent()) && 5060ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor "Nested name specifier must be dependent"); 5061ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5062ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor llvm::FoldingSetNodeID ID; 5063ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor DependentTemplateName::Profile(ID, NNS, Operator); 5064ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5065ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor void *InsertPos = 0; 5066789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateName *QTN 5067789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 5068ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5069ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor if (QTN) 5070ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor return TemplateName(QTN); 5071ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5072ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 5073ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor if (CanonNNS == NNS) { 5074ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Operator); 5075ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor } else { 5076ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor TemplateName Canon = getDependentTemplateName(CanonNNS, Operator); 5077ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Operator, Canon); 5078789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 5079789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateName *CheckQTN 5080789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 5081789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!CheckQTN && "Dependent template name canonicalization broken"); 5082789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CheckQTN; 5083ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor } 5084ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5085ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor DependentTemplateNames.InsertNode(QTN, InsertPos); 5086ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor return TemplateName(QTN); 5087ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor} 5088ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 50891aee05d08b2184acadeb36de300e216390780d6cDouglas GregorTemplateName 5090146060435c3efce95c95a092c7a1eb651cfb9ae0John McCallASTContext::getSubstTemplateTemplateParm(TemplateTemplateParmDecl *param, 5091146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateName replacement) const { 5092146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm::FoldingSetNodeID ID; 5093146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage::Profile(ID, param, replacement); 5094146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5095146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall void *insertPos = 0; 5096146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage *subst 5097146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = SubstTemplateTemplateParms.FindNodeOrInsertPos(ID, insertPos); 5098146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5099146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall if (!subst) { 5100146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall subst = new (*this) SubstTemplateTemplateParmStorage(param, replacement); 5101146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParms.InsertNode(subst, insertPos); 5102146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 5103146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5104146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return TemplateName(subst); 5105146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall} 5106146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5107146060435c3efce95c95a092c7a1eb651cfb9ae0John McCallTemplateName 51081aee05d08b2184acadeb36de300e216390780d6cDouglas GregorASTContext::getSubstTemplateTemplateParmPack(TemplateTemplateParmDecl *Param, 51091aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor const TemplateArgument &ArgPack) const { 51101aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor ASTContext &Self = const_cast<ASTContext &>(*this); 51111aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor llvm::FoldingSetNodeID ID; 51121aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor SubstTemplateTemplateParmPackStorage::Profile(ID, Self, Param, ArgPack); 51131aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 51141aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor void *InsertPos = 0; 51151aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor SubstTemplateTemplateParmPackStorage *Subst 51161aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor = SubstTemplateTemplateParmPacks.FindNodeOrInsertPos(ID, InsertPos); 51171aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 51181aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor if (!Subst) { 5119146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall Subst = new (*this) SubstTemplateTemplateParmPackStorage(Param, 51201aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor ArgPack.pack_size(), 51211aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor ArgPack.pack_begin()); 51221aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor SubstTemplateTemplateParmPacks.InsertNode(Subst, InsertPos); 51231aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor } 51241aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 51251aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor return TemplateName(Subst); 51261aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor} 51271aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 5128b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor/// getFromTargetType - Given one of the integer types provided by 5129d934112e6170b0fd940d8e40db6936cea2cdcf62Douglas Gregor/// TargetInfo, produce the corresponding type. The unsigned @p Type 5130d934112e6170b0fd940d8e40db6936cea2cdcf62Douglas Gregor/// is actually a value of type @c TargetInfo::IntType. 5131e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCallCanQualType ASTContext::getFromTargetType(unsigned Type) const { 5132b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor switch (Type) { 5133e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCall case TargetInfo::NoInt: return CanQualType(); 5134b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedShort: return ShortTy; 5135b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedShort: return UnsignedShortTy; 5136b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedInt: return IntTy; 5137b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedInt: return UnsignedIntTy; 5138b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedLong: return LongTy; 5139b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedLong: return UnsignedLongTy; 5140b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedLongLong: return LongLongTy; 5141b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedLongLong: return UnsignedLongLongTy; 5142b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor } 5143b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor 5144b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unhandled TargetInfo::IntType value"); 5145b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor} 5146b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek 5147b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek//===----------------------------------------------------------------------===// 5148b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek// Type Predicates. 5149b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek//===----------------------------------------------------------------------===// 5150b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek 51514fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian/// getObjCGCAttr - Returns one of GCNone, Weak or Strong objc's 51524fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian/// garbage collection attribute. 51534fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian/// 5154ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCallQualifiers::GC ASTContext::getObjCGCAttrKind(QualType Ty) const { 5155e289d81369914678db386f6aa86faf8f178e245dDouglas Gregor if (getLangOptions().getGC() == LangOptions::NonGC) 5156ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall return Qualifiers::GCNone; 5157ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall 5158ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall assert(getLangOptions().ObjC1); 5159ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall Qualifiers::GC GCAttrs = Ty.getObjCGCAttr(); 5160ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall 5161ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // Default behaviour under objective-C's gc is for ObjC pointers 5162ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // (or pointers to them) be treated as though they were declared 5163ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // as __strong. 5164ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall if (GCAttrs == Qualifiers::GCNone) { 5165ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType()) 5166ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall return Qualifiers::Strong; 5167ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall else if (Ty->isPointerType()) 5168ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall return getObjCGCAttrKind(Ty->getAs<PointerType>()->getPointeeType()); 5169ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall } else { 5170ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // It's not valid to set GC attributes on anything that isn't a 5171ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // pointer. 5172ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall#ifndef NDEBUG 5173ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall QualType CT = Ty->getCanonicalTypeInternal(); 5174ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall while (const ArrayType *AT = dyn_cast<ArrayType>(CT)) 5175ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall CT = AT->getElementType(); 5176ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall assert(CT->isAnyPointerType() || CT->isBlockPointerType()); 5177ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall#endif 51784fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian } 5179b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris Lattner return GCAttrs; 51804fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian} 51814fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian 51826ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner//===----------------------------------------------------------------------===// 51836ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner// Type Compatibility Testing 51846ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner//===----------------------------------------------------------------------===// 5185770951b5bb6028a8d326ddb4a13cef7d4a128162Chris Lattner 51861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// areCompatVectorTypes - Return true if the two specified vector types are 51876ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner/// compatible. 51886ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattnerstatic bool areCompatVectorTypes(const VectorType *LHS, 51896ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner const VectorType *RHS) { 5190467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified()); 51916ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner return LHS->getElementType() == RHS->getElementType() && 519261710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner LHS->getNumElements() == RHS->getNumElements(); 51936ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner} 51946ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner 5195255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregorbool ASTContext::areCompatibleVectorTypes(QualType FirstVec, 5196255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor QualType SecondVec) { 5197255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor assert(FirstVec->isVectorType() && "FirstVec should be a vector type"); 5198255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor assert(SecondVec->isVectorType() && "SecondVec should be a vector type"); 5199255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 5200255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor if (hasSameUnqualifiedType(FirstVec, SecondVec)) 5201255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor return true; 5202255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 5203f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson // Treat Neon vector types and most AltiVec vector types as if they are the 5204f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson // equivalent GCC vector types. 5205255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor const VectorType *First = FirstVec->getAs<VectorType>(); 5206255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor const VectorType *Second = SecondVec->getAs<VectorType>(); 5207f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson if (First->getNumElements() == Second->getNumElements() && 5208255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor hasSameType(First->getElementType(), Second->getElementType()) && 5209f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson First->getVectorKind() != VectorType::AltiVecPixel && 5210f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson First->getVectorKind() != VectorType::AltiVecBool && 5211f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson Second->getVectorKind() != VectorType::AltiVecPixel && 5212f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson Second->getVectorKind() != VectorType::AltiVecBool) 5213255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor return true; 5214255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 5215255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor return false; 5216255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor} 5217255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 52184084c306635b70f37029dca938444e6013f08684Steve Naroff//===----------------------------------------------------------------------===// 52194084c306635b70f37029dca938444e6013f08684Steve Naroff// ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's. 52204084c306635b70f37029dca938444e6013f08684Steve Naroff//===----------------------------------------------------------------------===// 52214084c306635b70f37029dca938444e6013f08684Steve Naroff 52224084c306635b70f37029dca938444e6013f08684Steve Naroff/// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the 52234084c306635b70f37029dca938444e6013f08684Steve Naroff/// inheritance hierarchy of 'rProto'. 52244ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadbool 52254ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto, 52264ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad ObjCProtocolDecl *rProto) const { 52273fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor if (declaresSameEntity(lProto, rProto)) 522814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return true; 52294084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCProtocolDecl::protocol_iterator PI = rProto->protocol_begin(), 52304084c306635b70f37029dca938444e6013f08684Steve Naroff E = rProto->protocol_end(); PI != E; ++PI) 52314084c306635b70f37029dca938444e6013f08684Steve Naroff if (ProtocolCompatibleWithProtocol(lProto, *PI)) 52324084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 52334084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 52344084c306635b70f37029dca938444e6013f08684Steve Naroff} 523514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 52364084c306635b70f37029dca938444e6013f08684Steve Naroff/// QualifiedIdConformsQualifiedId - compare id<p,...> with id<p1,...> 52374084c306635b70f37029dca938444e6013f08684Steve Naroff/// return true if lhs's protocols conform to rhs's protocol; false 52384084c306635b70f37029dca938444e6013f08684Steve Naroff/// otherwise. 52394084c306635b70f37029dca938444e6013f08684Steve Naroffbool ASTContext::QualifiedIdConformsQualifiedId(QualType lhs, QualType rhs) { 52404084c306635b70f37029dca938444e6013f08684Steve Naroff if (lhs->isObjCQualifiedIdType() && rhs->isObjCQualifiedIdType()) 52414084c306635b70f37029dca938444e6013f08684Steve Naroff return ObjCQualifiedIdTypesAreCompatible(lhs, rhs, false); 52424084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 52434084c306635b70f37029dca938444e6013f08684Steve Naroff} 52444084c306635b70f37029dca938444e6013f08684Steve Naroff 5245a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian/// ObjCQualifiedClassTypesAreCompatible - compare Class<p,...> and 5246a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian/// Class<p1, ...>. 5247a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanianbool ASTContext::ObjCQualifiedClassTypesAreCompatible(QualType lhs, 5248a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian QualType rhs) { 5249a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian const ObjCObjectPointerType *lhsQID = lhs->getAs<ObjCObjectPointerType>(); 5250a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>(); 5251a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian assert ((lhsQID && rhsOPT) && "ObjCQualifiedClassTypesAreCompatible"); 5252a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 5253a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 5254a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian E = lhsQID->qual_end(); I != E; ++I) { 5255a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian bool match = false; 5256a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian ObjCProtocolDecl *lhsProto = *I; 5257a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(), 5258a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian E = rhsOPT->qual_end(); J != E; ++J) { 5259a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian ObjCProtocolDecl *rhsProto = *J; 5260a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto)) { 5261a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian match = true; 5262a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian break; 5263a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian } 5264a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian } 5265a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian if (!match) 5266a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian return false; 5267a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian } 5268a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian return true; 5269a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian} 5270a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 52714084c306635b70f37029dca938444e6013f08684Steve Naroff/// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an 52724084c306635b70f37029dca938444e6013f08684Steve Naroff/// ObjCQualifiedIDType. 52734084c306635b70f37029dca938444e6013f08684Steve Naroffbool ASTContext::ObjCQualifiedIdTypesAreCompatible(QualType lhs, QualType rhs, 52744084c306635b70f37029dca938444e6013f08684Steve Naroff bool compare) { 52754084c306635b70f37029dca938444e6013f08684Steve Naroff // Allow id<P..> and an 'id' or void* type in all cases. 52761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (lhs->isVoidPointerType() || 52774084c306635b70f37029dca938444e6013f08684Steve Naroff lhs->isObjCIdType() || lhs->isObjCClassType()) 52784084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 52791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump else if (rhs->isVoidPointerType() || 52804084c306635b70f37029dca938444e6013f08684Steve Naroff rhs->isObjCIdType() || rhs->isObjCClassType()) 52814084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 52824084c306635b70f37029dca938444e6013f08684Steve Naroff 52834084c306635b70f37029dca938444e6013f08684Steve Naroff if (const ObjCObjectPointerType *lhsQID = lhs->getAsObjCQualifiedIdType()) { 5284183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>(); 52851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 52864084c306635b70f37029dca938444e6013f08684Steve Naroff if (!rhsOPT) return false; 52871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 52884084c306635b70f37029dca938444e6013f08684Steve Naroff if (rhsOPT->qual_empty()) { 52891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the RHS is a unqualified interface pointer "NSString*", 52904084c306635b70f37029dca938444e6013f08684Steve Naroff // make sure we check the class hierarchy. 52914084c306635b70f37029dca938444e6013f08684Steve Naroff if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) { 52924084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 52934084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsQID->qual_end(); I != E; ++I) { 52944084c306635b70f37029dca938444e6013f08684Steve Naroff // when comparing an id<P> on lhs with a static type on rhs, 52954084c306635b70f37029dca938444e6013f08684Steve Naroff // see if static class implements all of id's protocols, directly or 52964084c306635b70f37029dca938444e6013f08684Steve Naroff // through its super class and categories. 52970fd8904c5f71a11d29f67716c3ebdf7ad1c855fbFariborz Jahanian if (!rhsID->ClassImplementsProtocol(*I, true)) 52984084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 52994084c306635b70f37029dca938444e6013f08684Steve Naroff } 53004084c306635b70f37029dca938444e6013f08684Steve Naroff } 53014084c306635b70f37029dca938444e6013f08684Steve Naroff // If there are no qualifiers and no interface, we have an 'id'. 53024084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 53034084c306635b70f37029dca938444e6013f08684Steve Naroff } 53041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Both the right and left sides have qualifiers. 53054084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 53064084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsQID->qual_end(); I != E; ++I) { 53074084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *lhsProto = *I; 53084084c306635b70f37029dca938444e6013f08684Steve Naroff bool match = false; 5309de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff 5310de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff // when comparing an id<P> on lhs with a static type on rhs, 5311de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff // see if static class implements all of id's protocols, directly or 5312de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff // through its super class and categories. 53134084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(), 53144084c306635b70f37029dca938444e6013f08684Steve Naroff E = rhsOPT->qual_end(); J != E; ++J) { 53154084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *rhsProto = *J; 53164084c306635b70f37029dca938444e6013f08684Steve Naroff if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 53174084c306635b70f37029dca938444e6013f08684Steve Naroff (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 53184084c306635b70f37029dca938444e6013f08684Steve Naroff match = true; 53198f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff break; 53208f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff } 5321de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff } 53221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the RHS is a qualified interface pointer "NSString<P>*", 53234084c306635b70f37029dca938444e6013f08684Steve Naroff // make sure we check the class hierarchy. 53244084c306635b70f37029dca938444e6013f08684Steve Naroff if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) { 53254084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 53264084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsQID->qual_end(); I != E; ++I) { 53274084c306635b70f37029dca938444e6013f08684Steve Naroff // when comparing an id<P> on lhs with a static type on rhs, 53284084c306635b70f37029dca938444e6013f08684Steve Naroff // see if static class implements all of id's protocols, directly or 53294084c306635b70f37029dca938444e6013f08684Steve Naroff // through its super class and categories. 53300fd8904c5f71a11d29f67716c3ebdf7ad1c855fbFariborz Jahanian if (rhsID->ClassImplementsProtocol(*I, true)) { 53314084c306635b70f37029dca938444e6013f08684Steve Naroff match = true; 53324084c306635b70f37029dca938444e6013f08684Steve Naroff break; 53334084c306635b70f37029dca938444e6013f08684Steve Naroff } 53344084c306635b70f37029dca938444e6013f08684Steve Naroff } 53354084c306635b70f37029dca938444e6013f08684Steve Naroff } 53364084c306635b70f37029dca938444e6013f08684Steve Naroff if (!match) 5337de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff return false; 5338de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff } 53391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5340de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff return true; 5341de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff } 53421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 53434084c306635b70f37029dca938444e6013f08684Steve Naroff const ObjCObjectPointerType *rhsQID = rhs->getAsObjCQualifiedIdType(); 53444084c306635b70f37029dca938444e6013f08684Steve Naroff assert(rhsQID && "One of the LHS/RHS should be id<x>"); 53454084c306635b70f37029dca938444e6013f08684Steve Naroff 53461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const ObjCObjectPointerType *lhsOPT = 53474084c306635b70f37029dca938444e6013f08684Steve Naroff lhs->getAsObjCInterfacePointerType()) { 5348de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // If both the right and left sides have qualifiers. 53494084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsOPT->qual_begin(), 53504084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsOPT->qual_end(); I != E; ++I) { 53514084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *lhsProto = *I; 53524084c306635b70f37029dca938444e6013f08684Steve Naroff bool match = false; 53534084c306635b70f37029dca938444e6013f08684Steve Naroff 5354de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // when comparing an id<P> on rhs with a static type on lhs, 53554084c306635b70f37029dca938444e6013f08684Steve Naroff // see if static class implements all of id's protocols, directly or 53564084c306635b70f37029dca938444e6013f08684Steve Naroff // through its super class and categories. 5357de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // First, lhs protocols in the qualifier list must be found, direct 5358de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // or indirect in rhs's qualifier list or it is a mismatch. 53594084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(), 53604084c306635b70f37029dca938444e6013f08684Steve Naroff E = rhsQID->qual_end(); J != E; ++J) { 53614084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *rhsProto = *J; 53624084c306635b70f37029dca938444e6013f08684Steve Naroff if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 53634084c306635b70f37029dca938444e6013f08684Steve Naroff (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 53644084c306635b70f37029dca938444e6013f08684Steve Naroff match = true; 53654084c306635b70f37029dca938444e6013f08684Steve Naroff break; 53664084c306635b70f37029dca938444e6013f08684Steve Naroff } 53674084c306635b70f37029dca938444e6013f08684Steve Naroff } 53684084c306635b70f37029dca938444e6013f08684Steve Naroff if (!match) 53694084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 53704084c306635b70f37029dca938444e6013f08684Steve Naroff } 5371de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian 5372de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // Static class's protocols, or its super class or category protocols 5373de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // must be found, direct or indirect in rhs's qualifier list or it is a mismatch. 5374de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (ObjCInterfaceDecl *lhsID = lhsOPT->getInterfaceDecl()) { 5375de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols; 5376de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian CollectInheritedProtocols(lhsID, LHSInheritedProtocols); 5377de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // This is rather dubious but matches gcc's behavior. If lhs has 5378de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // no type qualifier and its class has no static protocol(s) 5379de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // assume that it is mismatch. 5380de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (LHSInheritedProtocols.empty() && lhsOPT->qual_empty()) 5381de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian return false; 5382de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 5383de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian LHSInheritedProtocols.begin(), 5384de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian E = LHSInheritedProtocols.end(); I != E; ++I) { 5385de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian bool match = false; 5386de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian ObjCProtocolDecl *lhsProto = (*I); 5387de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(), 5388de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian E = rhsQID->qual_end(); J != E; ++J) { 5389de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian ObjCProtocolDecl *rhsProto = *J; 5390de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 5391de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 5392de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian match = true; 5393de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian break; 5394de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 5395de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 5396de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (!match) 5397de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian return false; 5398de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 5399de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 54004084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 54014084c306635b70f37029dca938444e6013f08684Steve Naroff } 54024084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 54034084c306635b70f37029dca938444e6013f08684Steve Naroff} 54044084c306635b70f37029dca938444e6013f08684Steve Naroff 54054084c306635b70f37029dca938444e6013f08684Steve Naroff/// canAssignObjCInterfaces - Return true if the two interface types are 54064084c306635b70f37029dca938444e6013f08684Steve Naroff/// compatible for assignment from RHS to LHS. This handles validation of any 54074084c306635b70f37029dca938444e6013f08684Steve Naroff/// protocol qualifiers on the LHS or RHS. 54084084c306635b70f37029dca938444e6013f08684Steve Naroff/// 54094084c306635b70f37029dca938444e6013f08684Steve Naroffbool ASTContext::canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, 54104084c306635b70f37029dca938444e6013f08684Steve Naroff const ObjCObjectPointerType *RHSOPT) { 5411c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* LHS = LHSOPT->getObjectType(); 5412c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* RHS = RHSOPT->getObjectType(); 5413c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 54144084c306635b70f37029dca938444e6013f08684Steve Naroff // If either type represents the built-in 'id' or 'Class' types, return true. 5415c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHS->isObjCUnqualifiedIdOrClass() || 5416c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall RHS->isObjCUnqualifiedIdOrClass()) 54174084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 54184084c306635b70f37029dca938444e6013f08684Steve Naroff 5419c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHS->isObjCQualifiedId() || RHS->isObjCQualifiedId()) 54201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0), 54211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType(RHSOPT,0), 54224084c306635b70f37029dca938444e6013f08684Steve Naroff false); 5423a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 5424a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian if (LHS->isObjCQualifiedClass() && RHS->isObjCQualifiedClass()) 5425a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian return ObjCQualifiedClassTypesAreCompatible(QualType(LHSOPT,0), 5426a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian QualType(RHSOPT,0)); 5427a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 5428c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // If we have 2 user-defined types, fall into that path. 5429c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHS->getInterface() && RHS->getInterface()) 54304084c306635b70f37029dca938444e6013f08684Steve Naroff return canAssignObjCInterfaces(LHS, RHS); 54311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 54324084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 543314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff} 543414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 5435132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// canAssignObjCInterfacesInBlockPointer - This routine is specifically written 5436fc8f0e14ad142ed811e90fbd9a30e419e301c717Chris Lattner/// for providing type-safety for objective-c pointers used to pass/return 5437132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// arguments in block literals. When passed as arguments, passing 'A*' where 5438132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// 'id' is expected is not OK. Passing 'Sub *" where 'Super *" is expected is 5439132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// not OK. For the return type, the opposite is not OK. 5440132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanianbool ASTContext::canAssignObjCInterfacesInBlockPointer( 5441132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian const ObjCObjectPointerType *LHSOPT, 5442a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian const ObjCObjectPointerType *RHSOPT, 5443a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian bool BlockReturnType) { 5444a98344869c278295f38e106583906377520079b8Fariborz Jahanian if (RHSOPT->isObjCBuiltinType() || LHSOPT->isObjCIdType()) 5445132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return true; 5446132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5447132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHSOPT->isObjCBuiltinType()) { 5448132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return RHSOPT->isObjCBuiltinType() || RHSOPT->isObjCQualifiedIdType(); 5449132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 5450132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5451a98344869c278295f38e106583906377520079b8Fariborz Jahanian if (LHSOPT->isObjCQualifiedIdType() || RHSOPT->isObjCQualifiedIdType()) 5452132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0), 5453132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian QualType(RHSOPT,0), 5454132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian false); 5455132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5456132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType(); 5457132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType(); 5458132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHS && RHS) { // We have 2 user-defined types. 5459132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHS != RHS) { 5460132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHS->getDecl()->isSuperClassOf(RHS->getDecl())) 5461a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian return BlockReturnType; 5462132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (RHS->getDecl()->isSuperClassOf(LHS->getDecl())) 5463a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian return !BlockReturnType; 5464132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 5465132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian else 5466132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return true; 5467132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 5468132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return false; 5469132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian} 5470132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5471e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// getIntersectionOfProtocols - This routine finds the intersection of set 5472e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// of protocols inherited from two distinct objective-c pointer objects. 5473e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// It is used to build composite qualifier list of the composite type of 5474e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// the conditional expression involving two objective-c pointer objects. 5475e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanianstatic 5476e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanianvoid getIntersectionOfProtocols(ASTContext &Context, 5477e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian const ObjCObjectPointerType *LHSOPT, 5478e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian const ObjCObjectPointerType *RHSOPT, 54795f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<ObjCProtocolDecl *> &IntersectionOfProtocols) { 5480e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5481c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* LHS = LHSOPT->getObjectType(); 5482c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* RHS = RHSOPT->getObjectType(); 5483c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(LHS->getInterface() && "LHS must have an interface base"); 5484c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(RHS->getInterface() && "RHS must have an interface base"); 5485e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5486e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocolSet; 5487e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian unsigned LHSNumProtocols = LHS->getNumProtocols(); 5488e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (LHSNumProtocols > 0) 5489e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian InheritedProtocolSet.insert(LHS->qual_begin(), LHS->qual_end()); 5490e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian else { 5491432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols; 5492c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Context.CollectInheritedProtocols(LHS->getInterface(), 5493c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall LHSInheritedProtocols); 5494e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian InheritedProtocolSet.insert(LHSInheritedProtocols.begin(), 5495e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian LHSInheritedProtocols.end()); 5496e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 5497e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5498e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian unsigned RHSNumProtocols = RHS->getNumProtocols(); 5499e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (RHSNumProtocols > 0) { 5500cb421fa690da545b58a720abe5f1c49b166dbde7Dan Gohman ObjCProtocolDecl **RHSProtocols = 5501cb421fa690da545b58a720abe5f1c49b166dbde7Dan Gohman const_cast<ObjCProtocolDecl **>(RHS->qual_begin()); 5502e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (unsigned i = 0; i < RHSNumProtocols; ++i) 5503e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (InheritedProtocolSet.count(RHSProtocols[i])) 5504e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian IntersectionOfProtocols.push_back(RHSProtocols[i]); 55053060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 5506432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> RHSInheritedProtocols; 5507c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Context.CollectInheritedProtocols(RHS->getInterface(), 5508c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall RHSInheritedProtocols); 5509432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 5510432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian RHSInheritedProtocols.begin(), 5511432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian E = RHSInheritedProtocols.end(); I != E; ++I) 5512432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian if (InheritedProtocolSet.count((*I))) 5513432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian IntersectionOfProtocols.push_back((*I)); 5514e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 5515e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian} 5516e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5517db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// areCommonBaseCompatible - Returns common base class of the two classes if 5518db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// one found. Note that this is O'2 algorithm. But it will be called as the 5519db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// last type comparison in a ?-exp of ObjC pointer types before a 5520db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// warning is issued. So, its invokation is extremely rare. 5521db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz JahanianQualType ASTContext::areCommonBaseCompatible( 5522c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectPointerType *Lptr, 5523c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectPointerType *Rptr) { 5524c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType *LHS = Lptr->getObjectType(); 5525c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType *RHS = Rptr->getObjectType(); 5526c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCInterfaceDecl* LDecl = LHS->getInterface(); 5527c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCInterfaceDecl* RDecl = RHS->getInterface(); 552860ef308e51c71b760d7f598c1b763ceb7b768148Douglas Gregor if (!LDecl || !RDecl || (declaresSameEntity(LDecl, RDecl))) 5529db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian return QualType(); 5530db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian 55317c2bdcb4d30f2d370b4367664e6a11b075ce2cb3Fariborz Jahanian do { 5532c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall LHS = cast<ObjCInterfaceType>(getObjCInterfaceType(LDecl)); 5533e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (canAssignObjCInterfaces(LHS, RHS)) { 55345f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<ObjCProtocolDecl *, 8> Protocols; 5535c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall getIntersectionOfProtocols(*this, Lptr, Rptr, Protocols); 5536c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 5537c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall QualType Result = QualType(LHS, 0); 5538c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!Protocols.empty()) 5539c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Result = getObjCObjectType(Result, Protocols.data(), Protocols.size()); 5540c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Result = getObjCObjectPointerType(Result); 5541c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return Result; 5542e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 55437c2bdcb4d30f2d370b4367664e6a11b075ce2cb3Fariborz Jahanian } while ((LDecl = LDecl->getSuperClass())); 5544db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian 5545db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian return QualType(); 5546db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian} 5547db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian 5548c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCallbool ASTContext::canAssignObjCInterfaces(const ObjCObjectType *LHS, 5549c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType *RHS) { 5550c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(LHS->getInterface() && "LHS is not an interface type"); 5551c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(RHS->getInterface() && "RHS is not an interface type"); 5552c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 55536ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // Verify that the base decls are compatible: the RHS must be a subclass of 55546ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // the LHS. 5555c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!LHS->getInterface()->isSuperClassOf(RHS->getInterface())) 55566ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner return false; 55571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 55586ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // RHS must have a superset of the protocols in the LHS. If the LHS is not 55596ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // protocol qualified at all, then we are good. 5560c15cb2af27514ecc879daba9aa01389c5203685dSteve Naroff if (LHS->getNumProtocols() == 0) 55616ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner return true; 55621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5563b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // Okay, we know the LHS has protocol qualifiers. If the RHS doesn't, 5564b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // more detailed analysis is required. 5565b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (RHS->getNumProtocols() == 0) { 5566b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // OK, if LHS is a superclass of RHS *and* 5567b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // this superclass is assignment compatible with LHS. 5568b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // false otherwise. 5569627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian bool IsSuperClass = 5570627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian LHS->getInterface()->isSuperClassOf(RHS->getInterface()); 5571627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian if (IsSuperClass) { 5572b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // OK if conversion of LHS to SuperClass results in narrowing of types 5573b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // ; i.e., SuperClass may implement at least one of the protocols 5574b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // in LHS's protocol list. Example, SuperObj<P1> = lhs<P1,P2> is ok. 5575b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // But not SuperObj<P1,P2,P3> = lhs<P1,P2>. 5576b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> SuperClassInheritedProtocols; 5577627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian CollectInheritedProtocols(RHS->getInterface(), SuperClassInheritedProtocols); 5578b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // If super class has no protocols, it is not a match. 5579b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (SuperClassInheritedProtocols.empty()) 5580b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return false; 5581b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian 5582b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian for (ObjCObjectType::qual_iterator LHSPI = LHS->qual_begin(), 5583b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian LHSPE = LHS->qual_end(); 5584b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian LHSPI != LHSPE; LHSPI++) { 5585b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian bool SuperImplementsProtocol = false; 5586b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian ObjCProtocolDecl *LHSProto = (*LHSPI); 5587b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian 5588b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 5589b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian SuperClassInheritedProtocols.begin(), 5590b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian E = SuperClassInheritedProtocols.end(); I != E; ++I) { 5591b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian ObjCProtocolDecl *SuperClassProto = (*I); 5592b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (SuperClassProto->lookupProtocolNamed(LHSProto->getIdentifier())) { 5593b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian SuperImplementsProtocol = true; 5594b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian break; 5595b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5596b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5597b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (!SuperImplementsProtocol) 5598b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return false; 5599b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5600b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return true; 5601b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5602b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return false; 5603b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 56041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5605c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall for (ObjCObjectType::qual_iterator LHSPI = LHS->qual_begin(), 5606c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall LHSPE = LHS->qual_end(); 560791b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff LHSPI != LHSPE; LHSPI++) { 560891b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff bool RHSImplementsProtocol = false; 560991b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff 561091b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // If the RHS doesn't implement the protocol on the left, the types 561191b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // are incompatible. 5612c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall for (ObjCObjectType::qual_iterator RHSPI = RHS->qual_begin(), 5613c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall RHSPE = RHS->qual_end(); 56148f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff RHSPI != RHSPE; RHSPI++) { 56158f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff if ((*RHSPI)->lookupProtocolNamed((*LHSPI)->getIdentifier())) { 561691b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff RHSImplementsProtocol = true; 56178f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff break; 56188f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff } 561991b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff } 562091b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // FIXME: For better diagnostics, consider passing back the protocol name. 562191b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff if (!RHSImplementsProtocol) 562291b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff return false; 562391b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff } 562491b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // The RHS implements all protocols listed on the LHS. 562591b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff return true; 56266ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner} 56276ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner 5628389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroffbool ASTContext::areComparableObjCPointerTypes(QualType LHS, QualType RHS) { 5629389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff // get the "pointed to" types 5630183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const ObjCObjectPointerType *LHSOPT = LHS->getAs<ObjCObjectPointerType>(); 5631183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const ObjCObjectPointerType *RHSOPT = RHS->getAs<ObjCObjectPointerType>(); 56321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 563314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (!LHSOPT || !RHSOPT) 5634389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff return false; 563514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 563614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return canAssignObjCInterfaces(LHSOPT, RHSOPT) || 563714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff canAssignObjCInterfaces(RHSOPT, LHSOPT); 5638389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff} 5639389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff 5640569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregorbool ASTContext::canBindObjCObjectType(QualType To, QualType From) { 5641569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor return canAssignObjCInterfaces( 5642569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor getObjCObjectPointerType(To)->getAs<ObjCObjectPointerType>(), 5643569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor getObjCObjectPointerType(From)->getAs<ObjCObjectPointerType>()); 5644569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor} 5645569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor 56461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible, 5647ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff/// both shall have the identically qualified version of a compatible type. 56481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// C99 6.2.7p1: Two types have compatible types if their types are the 5649ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff/// same. See 6.7.[2,3,5] for additional rules. 5650447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregorbool ASTContext::typesAreCompatible(QualType LHS, QualType RHS, 5651447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool CompareUnqualified) { 56520e709abafbd939326850501f795cc7a92c88a354Douglas Gregor if (getLangOptions().CPlusPlus) 56530e709abafbd939326850501f795cc7a92c88a354Douglas Gregor return hasSameType(LHS, RHS); 56540e709abafbd939326850501f795cc7a92c88a354Douglas Gregor 5655447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor return !mergeTypes(LHS, RHS, false, CompareUnqualified).isNull(); 56563d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman} 56573d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 5658c286f3835eb6001c61664cef5d610dfaf80a6e9bFariborz Jahanianbool ASTContext::propertyTypesAreCompatible(QualType LHS, QualType RHS) { 565982378391dfc3b2fc22f63dbf1552bd9aed39dc42Fariborz Jahanian return typesAreCompatible(LHS, RHS); 5660c286f3835eb6001c61664cef5d610dfaf80a6e9bFariborz Jahanian} 5661c286f3835eb6001c61664cef5d610dfaf80a6e9bFariborz Jahanian 5662132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanianbool ASTContext::typesAreBlockPointerCompatible(QualType LHS, QualType RHS) { 5663132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return !mergeTypes(LHS, RHS, true).isNull(); 5664132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian} 5665132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 56664846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// mergeTransparentUnionType - if T is a transparent union type and a member 56674846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// of T is compatible with SubType, return the merged type, else return 56684846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// QualType() 56694846675e0e42d1802b0ffd8972a45e72aeb3758dPeter CollingbourneQualType ASTContext::mergeTransparentUnionType(QualType T, QualType SubType, 56704846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool OfBlockPointer, 56714846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool Unqualified) { 56724846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (const RecordType *UT = T->getAsUnionType()) { 56734846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne RecordDecl *UD = UT->getDecl(); 56744846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (UD->hasAttr<TransparentUnionAttr>()) { 56754846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne for (RecordDecl::field_iterator it = UD->field_begin(), 56764846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne itend = UD->field_end(); it != itend; ++it) { 5677f91d7572ee7fa6f2926c8e7e816039a1154a59f8Peter Collingbourne QualType ET = it->getType().getUnqualifiedType(); 56784846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType MT = mergeTypes(ET, SubType, OfBlockPointer, Unqualified); 56794846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (!MT.isNull()) 56804846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return MT; 56814846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne } 56824846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne } 56834846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne } 56844846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 56854846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return QualType(); 56864846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne} 56874846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 56884846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// mergeFunctionArgumentTypes - merge two types which appear as function 56894846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// argument types 56904846675e0e42d1802b0ffd8972a45e72aeb3758dPeter CollingbourneQualType ASTContext::mergeFunctionArgumentTypes(QualType lhs, QualType rhs, 56914846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool OfBlockPointer, 56924846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool Unqualified) { 56934846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne // GNU extension: two types are compatible if they appear as a function 56944846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne // argument, one of the types is a transparent union type and the other 56954846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne // type is compatible with a union member 56964846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType lmerge = mergeTransparentUnionType(lhs, rhs, OfBlockPointer, 56974846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne Unqualified); 56984846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (!lmerge.isNull()) 56994846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return lmerge; 57004846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 57014846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType rmerge = mergeTransparentUnionType(rhs, lhs, OfBlockPointer, 57024846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne Unqualified); 57034846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (!rmerge.isNull()) 57044846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return rmerge; 57054846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 57064846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return mergeTypes(lhs, rhs, OfBlockPointer, Unqualified); 57074846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne} 57084846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 5709132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz JahanianQualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs, 5710447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool OfBlockPointer, 5711447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool Unqualified) { 5712183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const FunctionType *lbase = lhs->getAs<FunctionType>(); 5713183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const FunctionType *rbase = rhs->getAs<FunctionType>(); 571472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase); 571572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase); 57163d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman bool allLTypes = true; 57173d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman bool allRTypes = true; 57183d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 57193d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Check return type 5720132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian QualType retType; 5721d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian if (OfBlockPointer) { 5722d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian QualType RHS = rbase->getResultType(); 5723d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian QualType LHS = lbase->getResultType(); 5724d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian bool UnqualifiedResult = Unqualified; 5725d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian if (!UnqualifiedResult) 5726d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian UnqualifiedResult = (!RHS.hasQualifiers() && LHS.hasQualifiers()); 5727a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian retType = mergeTypes(LHS, RHS, true, UnqualifiedResult, true); 5728d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian } 5729132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian else 57308cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall retType = mergeTypes(lbase->getResultType(), rbase->getResultType(), false, 57318cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall Unqualified); 57323d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (retType.isNull()) return QualType(); 5733447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5734447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) 5735447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor retType = retType.getUnqualifiedType(); 5736447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5737447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor CanQualType LRetType = getCanonicalType(lbase->getResultType()); 5738447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor CanQualType RRetType = getCanonicalType(rbase->getResultType()); 5739447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5740447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LRetType = LRetType.getUnqualifiedType(); 5741447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RRetType = RRetType.getUnqualifiedType(); 5742447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 5743447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5744447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (getCanonicalType(retType) != LRetType) 574561710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allLTypes = false; 5746447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (getCanonicalType(retType) != RRetType) 574761710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allRTypes = false; 57488cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 57496a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // FIXME: double check this 57506a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // FIXME: should we error if lbase->getRegParmAttr() != 0 && 57516a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // rbase->getRegParmAttr() != 0 && 57526a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // lbase->getRegParmAttr() != rbase->getRegParmAttr()? 5753264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo lbaseInfo = lbase->getExtInfo(); 5754264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo rbaseInfo = rbase->getExtInfo(); 57558cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 57568cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall // Compatible functions must have compatible calling conventions 57578cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall if (!isSameCallConv(lbaseInfo.getCC(), rbaseInfo.getCC())) 57588cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall return QualType(); 57598cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 57608cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall // Regparm is part of the calling convention. 5761a49218e17bcbb1acde0245773173e2c0c42f4f19Eli Friedman if (lbaseInfo.getHasRegParm() != rbaseInfo.getHasRegParm()) 5762a49218e17bcbb1acde0245773173e2c0c42f4f19Eli Friedman return QualType(); 57638cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall if (lbaseInfo.getRegParm() != rbaseInfo.getRegParm()) 57648cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall return QualType(); 57658cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 5766f85e193739c953358c865005855253af4f68a497John McCall if (lbaseInfo.getProducesResult() != rbaseInfo.getProducesResult()) 5767f85e193739c953358c865005855253af4f68a497John McCall return QualType(); 5768f85e193739c953358c865005855253af4f68a497John McCall 576953c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian // functypes which return are preferred over those that do not. 577053c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian if (lbaseInfo.getNoReturn() && !rbaseInfo.getNoReturn()) 57716a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar allLTypes = false; 577253c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian else if (!lbaseInfo.getNoReturn() && rbaseInfo.getNoReturn()) 57736a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar allRTypes = false; 577453c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian // FIXME: some uses, e.g. conditional exprs, really want this to be 'both'. 577553c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian bool NoReturn = lbaseInfo.getNoReturn() || rbaseInfo.getNoReturn(); 57761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5777f85e193739c953358c865005855253af4f68a497John McCall FunctionType::ExtInfo einfo = lbaseInfo.withNoReturn(NoReturn); 5778e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 57793d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto && rproto) { // two C99 style function prototypes 5780465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl assert(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() && 5781465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl "C++ shouldn't be here"); 57823d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman unsigned lproto_nargs = lproto->getNumArgs(); 57833d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman unsigned rproto_nargs = rproto->getNumArgs(); 57843d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 57853d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Compatible functions must have the same number of arguments 57863d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto_nargs != rproto_nargs) 57873d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 57883d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 57893d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Variadic and non-variadic functions aren't compatible 57903d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto->isVariadic() != rproto->isVariadic()) 57913d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 57923d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 57937fb5e4888221cd36652d078c6b171ac55e7f406dArgyrios Kyrtzidis if (lproto->getTypeQuals() != rproto->getTypeQuals()) 57947fb5e4888221cd36652d078c6b171ac55e7f406dArgyrios Kyrtzidis return QualType(); 57957fb5e4888221cd36652d078c6b171ac55e7f406dArgyrios Kyrtzidis 579678213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (LangOpts.ObjCAutoRefCount && 579778213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian !FunctionTypesMatchOnNSConsumedAttrs(rproto, lproto)) 579878213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return QualType(); 579978213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian 58003d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Check argument compatibility 58015f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 10> types; 58023d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman for (unsigned i = 0; i < lproto_nargs; i++) { 58033d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType largtype = lproto->getArgType(i).getUnqualifiedType(); 58043d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType rargtype = rproto->getArgType(i).getUnqualifiedType(); 58054846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType argtype = mergeFunctionArgumentTypes(largtype, rargtype, 58064846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne OfBlockPointer, 58074846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne Unqualified); 58083d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (argtype.isNull()) return QualType(); 5809447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5810447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) 5811447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor argtype = argtype.getUnqualifiedType(); 5812447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 58133d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman types.push_back(argtype); 5814447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5815447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor largtype = largtype.getUnqualifiedType(); 5816447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor rargtype = rargtype.getUnqualifiedType(); 5817447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 5818447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 581961710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (getCanonicalType(argtype) != getCanonicalType(largtype)) 582061710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allLTypes = false; 582161710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (getCanonicalType(argtype) != getCanonicalType(rargtype)) 582261710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allRTypes = false; 58233d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 582478213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian 58253d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allLTypes) return lhs; 58263d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allRTypes) return rhs; 5827e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 5828e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI = lproto->getExtProtoInfo(); 5829e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall EPI.ExtInfo = einfo; 5830e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall return getFunctionType(retType, types.begin(), types.size(), EPI); 58313d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 58323d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 58333d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto) allRTypes = false; 58343d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (rproto) allLTypes = false; 58353d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 583672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor const FunctionProtoType *proto = lproto ? lproto : rproto; 58373d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (proto) { 5838465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl assert(!proto->hasExceptionSpec() && "C++ shouldn't be here"); 58393d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (proto->isVariadic()) return QualType(); 58403d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Check that the types are compatible with the types that 58413d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // would result from default argument promotions (C99 6.7.5.3p15). 58423d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // The only types actually affected are promotable integer 58433d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // types and floats, which would be passed as a different 58443d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // type depending on whether the prototype is visible. 58453d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman unsigned proto_nargs = proto->getNumArgs(); 58463d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman for (unsigned i = 0; i < proto_nargs; ++i) { 58473d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType argTy = proto->getArgType(i); 5848b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor 5849b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor // Look at the promotion type of enum types, since that is the type used 5850b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor // to pass enum values. 5851b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor if (const EnumType *Enum = argTy->getAs<EnumType>()) 5852b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor argTy = Enum->getDecl()->getPromotionType(); 5853b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor 58543d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (argTy->isPromotableIntegerType() || 58553d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman getCanonicalType(argTy).getUnqualifiedType() == FloatTy) 58563d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 58573d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 58583d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 58593d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allLTypes) return lhs; 58603d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allRTypes) return rhs; 5861e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 5862e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI = proto->getExtProtoInfo(); 5863e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall EPI.ExtInfo = einfo; 58643d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return getFunctionType(retType, proto->arg_type_begin(), 5865e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall proto->getNumArgs(), EPI); 58663d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 58673d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 58683d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allLTypes) return lhs; 58693d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allRTypes) return rhs; 58708cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall return getFunctionNoProtoType(retType, einfo); 58713d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman} 58723d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 5873132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz JahanianQualType ASTContext::mergeTypes(QualType LHS, QualType RHS, 5874447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool OfBlockPointer, 5875a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian bool Unqualified, bool BlockReturnType) { 587643d69750e7f7b26076e7474dec8839bb777b260fBill Wendling // C++ [expr]: If an expression initially has the type "reference to T", the 587743d69750e7f7b26076e7474dec8839bb777b260fBill Wendling // type is adjusted to "T" prior to any further analysis, the expression 587843d69750e7f7b26076e7474dec8839bb777b260fBill Wendling // designates the object or function denoted by the reference, and the 58797c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // expression is an lvalue unless the reference is an rvalue reference and 58807c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // the expression is a function call (possibly inside parentheses). 58810e709abafbd939326850501f795cc7a92c88a354Douglas Gregor assert(!LHS->getAs<ReferenceType>() && "LHS is a reference type?"); 58820e709abafbd939326850501f795cc7a92c88a354Douglas Gregor assert(!RHS->getAs<ReferenceType>() && "RHS is a reference type?"); 5883447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5884447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5885447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHS = LHS.getUnqualifiedType(); 5886447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHS = RHS.getUnqualifiedType(); 5887447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 58880e709abafbd939326850501f795cc7a92c88a354Douglas Gregor 58893d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType LHSCan = getCanonicalType(LHS), 58903d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman RHSCan = getCanonicalType(RHS); 58913d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 5892f3692dc4a47dc48d10cec0415c6e9e39b7a39707Chris Lattner // If two types are identical, they are compatible. 58933d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (LHSCan == RHSCan) 58943d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 58953d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 58960953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If the qualifiers are different, the types aren't compatible... mostly. 5897a4923eb7c4b04d360cb2747641a5e92818edf804Douglas Gregor Qualifiers LQuals = LHSCan.getLocalQualifiers(); 5898a4923eb7c4b04d360cb2747641a5e92818edf804Douglas Gregor Qualifiers RQuals = RHSCan.getLocalQualifiers(); 58990953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (LQuals != RQuals) { 59000953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If any of these qualifiers are different, we have a type 59010953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // mismatch. 59020953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() || 5903f85e193739c953358c865005855253af4f68a497John McCall LQuals.getAddressSpace() != RQuals.getAddressSpace() || 5904f85e193739c953358c865005855253af4f68a497John McCall LQuals.getObjCLifetime() != RQuals.getObjCLifetime()) 59050953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return QualType(); 59060953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 59070953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Exactly one GC qualifier difference is allowed: __strong is 59080953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // okay if the other type has no GC qualifier but is an Objective 59090953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // C object pointer (i.e. implicitly strong by default). We fix 59100953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // this by pretending that the unqualified type was actually 59110953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // qualified __strong. 59120953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers::GC GC_L = LQuals.getObjCGCAttr(); 59130953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers::GC GC_R = RQuals.getObjCGCAttr(); 59140953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements"); 59150953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 59160953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak) 59170953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return QualType(); 59180953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 59190953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (GC_L == Qualifiers::Strong && RHSCan->isObjCObjectPointerType()) { 59200953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return mergeTypes(LHS, getObjCGCQualType(RHS, Qualifiers::Strong)); 59210953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 59220953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (GC_R == Qualifiers::Strong && LHSCan->isObjCObjectPointerType()) { 59230953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return mergeTypes(getObjCGCQualType(LHS, Qualifiers::Strong), RHS); 59240953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 59253d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 59260953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 59270953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 59280953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Okay, qualifiers are equal. 59293d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 5930852d63b806c5cbd730c6b9d696e2e27d02546b49Eli Friedman Type::TypeClass LHSClass = LHSCan->getTypeClass(); 5931852d63b806c5cbd730c6b9d696e2e27d02546b49Eli Friedman Type::TypeClass RHSClass = RHSCan->getTypeClass(); 5932f3692dc4a47dc48d10cec0415c6e9e39b7a39707Chris Lattner 59331adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner // We want to consider the two function types to be the same for these 59341adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner // comparisons, just force one to the other. 59351adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto; 59361adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto; 59374c721d381fb279899337d120edd4a24d405e56b2Eli Friedman 59384c721d381fb279899337d120edd4a24d405e56b2Eli Friedman // Same as above for arrays 5939a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray) 5940a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner LHSClass = Type::ConstantArray; 5941a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray) 5942a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner RHSClass = Type::ConstantArray; 59431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5944c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // ObjCInterfaces are just specialized ObjCObjects. 5945c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject; 5946c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject; 5947c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 5948213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // Canonicalize ExtVector -> Vector. 5949213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (LHSClass == Type::ExtVector) LHSClass = Type::Vector; 5950213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (RHSClass == Type::ExtVector) RHSClass = Type::Vector; 59511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 59524e78fd0a960eaa7e97467f2e8f390f3a57da279bSteve Naroff // If the canonical type classes don't match. 59534e78fd0a960eaa7e97467f2e8f390f3a57da279bSteve Naroff if (LHSClass != RHSClass) { 59541adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner // C99 6.7.2.2p4: Each enumerated type shall be compatible with char, 59551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // a signed integer type, or an unsigned integer type. 5956842aef8d942a880eeb9535d40de31a86838264cbJohn McCall // Compatibility is based on the underlying type, not the promotion 5957842aef8d942a880eeb9535d40de31a86838264cbJohn McCall // type. 5958183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const EnumType* ETy = LHS->getAs<EnumType>()) { 5959b918d6b1f794266e126e5445d69233462087d764Fariborz Jahanian QualType TINT = ETy->getDecl()->getIntegerType(); 5960b918d6b1f794266e126e5445d69233462087d764Fariborz Jahanian if (!TINT.isNull() && hasSameType(TINT, RHSCan.getUnqualifiedType())) 59613d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return RHS; 5962bab96968886f4b77083f4e26a28986ddb1e42d67Eli Friedman } 5963183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const EnumType* ETy = RHS->getAs<EnumType>()) { 5964b918d6b1f794266e126e5445d69233462087d764Fariborz Jahanian QualType TINT = ETy->getDecl()->getIntegerType(); 5965b918d6b1f794266e126e5445d69233462087d764Fariborz Jahanian if (!TINT.isNull() && hasSameType(TINT, LHSCan.getUnqualifiedType())) 59663d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 5967bab96968886f4b77083f4e26a28986ddb1e42d67Eli Friedman } 5968e7cff2c00c3d74e38984a4db5c48d7e303d3ab8eFariborz Jahanian // allow block pointer type to match an 'id' type. 5969419636316c04d570c183b4797fc811932c588358Fariborz Jahanian if (OfBlockPointer && !BlockReturnType) { 5970419636316c04d570c183b4797fc811932c588358Fariborz Jahanian if (LHS->isObjCIdType() && RHS->isBlockPointerType()) 5971419636316c04d570c183b4797fc811932c588358Fariborz Jahanian return LHS; 5972419636316c04d570c183b4797fc811932c588358Fariborz Jahanian if (RHS->isObjCIdType() && LHS->isBlockPointerType()) 5973419636316c04d570c183b4797fc811932c588358Fariborz Jahanian return RHS; 5974419636316c04d570c183b4797fc811932c588358Fariborz Jahanian } 5975e7cff2c00c3d74e38984a4db5c48d7e303d3ab8eFariborz Jahanian 59763d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 5977ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff } 59783d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 59794a74678ed6c3dedac05d02b1ee341f1db869f049Steve Naroff // The canonical type classes match. 59801adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner switch (LHSClass) { 598172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define TYPE(Class, Base) 598272564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define ABSTRACT_TYPE(Class, Base) 5983ad5e73887052193afda72db8efcb812bd083a4a8John McCall#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class: 598472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 598572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define DEPENDENT_TYPE(Class, Base) case Type::Class: 598672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#include "clang/AST/TypeNodes.def" 5987b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Non-canonical and dependent types shouldn't get here"); 598872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 59897c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl case Type::LValueReference: 59907c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl case Type::RValueReference: 599172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::MemberPointer: 5992b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("C++ should never be in mergeTypes"); 599372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 5994c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCInterface: 599572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::IncompleteArray: 599672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::VariableArray: 599772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::FunctionProto: 599872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::ExtVector: 5999b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Types are eliminated above"); 600072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 60011adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::Pointer: 60023d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman { 60033d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Merge two pointer types, while trying to preserve typedef info 60046217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType LHSPointee = LHS->getAs<PointerType>()->getPointeeType(); 60056217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType RHSPointee = RHS->getAs<PointerType>()->getPointeeType(); 6006447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 6007447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHSPointee = LHSPointee.getUnqualifiedType(); 6008447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHSPointee = RHSPointee.getUnqualifiedType(); 6009447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 6010447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor QualType ResultType = mergeTypes(LHSPointee, RHSPointee, false, 6011447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor Unqualified); 60123d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (ResultType.isNull()) return QualType(); 601307d258756dc856c6987c394a0972884e6ed46765Eli Friedman if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType)) 601461710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return LHS; 601507d258756dc856c6987c394a0972884e6ed46765Eli Friedman if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType)) 601661710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return RHS; 60173d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return getPointerType(ResultType); 60183d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 6019c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff case Type::BlockPointer: 6020c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff { 6021c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff // Merge two block pointer types, while trying to preserve typedef info 60226217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType LHSPointee = LHS->getAs<BlockPointerType>()->getPointeeType(); 60236217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType RHSPointee = RHS->getAs<BlockPointerType>()->getPointeeType(); 6024447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 6025447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHSPointee = LHSPointee.getUnqualifiedType(); 6026447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHSPointee = RHSPointee.getUnqualifiedType(); 6027447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 6028447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor QualType ResultType = mergeTypes(LHSPointee, RHSPointee, OfBlockPointer, 6029447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor Unqualified); 6030c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff if (ResultType.isNull()) return QualType(); 6031c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType)) 6032c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff return LHS; 6033c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType)) 6034c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff return RHS; 6035c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff return getBlockPointerType(ResultType); 6036c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff } 6037b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: 6038b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman { 6039b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // Merge two pointer types, while trying to preserve typedef info 6040b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType LHSValue = LHS->getAs<AtomicType>()->getValueType(); 6041b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType RHSValue = RHS->getAs<AtomicType>()->getValueType(); 6042b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (Unqualified) { 6043b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman LHSValue = LHSValue.getUnqualifiedType(); 6044b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman RHSValue = RHSValue.getUnqualifiedType(); 6045b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 6046b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType ResultType = mergeTypes(LHSValue, RHSValue, false, 6047b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman Unqualified); 6048b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (ResultType.isNull()) return QualType(); 6049b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (getCanonicalType(LHSValue) == getCanonicalType(ResultType)) 6050b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return LHS; 6051b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (getCanonicalType(RHSValue) == getCanonicalType(ResultType)) 6052b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return RHS; 6053b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return getAtomicType(ResultType); 6054b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 60551adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::ConstantArray: 60563d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman { 60573d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const ConstantArrayType* LCAT = getAsConstantArrayType(LHS); 60583d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const ConstantArrayType* RCAT = getAsConstantArrayType(RHS); 60593d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (LCAT && RCAT && RCAT->getSize() != LCAT->getSize()) 60603d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 60613d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 60623d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType LHSElem = getAsArrayType(LHS)->getElementType(); 60633d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType RHSElem = getAsArrayType(RHS)->getElementType(); 6064447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 6065447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHSElem = LHSElem.getUnqualifiedType(); 6066447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHSElem = RHSElem.getUnqualifiedType(); 6067447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 6068447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 6069447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor QualType ResultType = mergeTypes(LHSElem, RHSElem, false, Unqualified); 60703d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (ResultType.isNull()) return QualType(); 607161710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (LCAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType)) 607261710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return LHS; 607361710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (RCAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType)) 607461710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return RHS; 60753bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (LCAT) return getConstantArrayType(ResultType, LCAT->getSize(), 60763bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman ArrayType::ArraySizeModifier(), 0); 60773bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (RCAT) return getConstantArrayType(ResultType, RCAT->getSize(), 60783bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman ArrayType::ArraySizeModifier(), 0); 60793d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const VariableArrayType* LVAT = getAsVariableArrayType(LHS); 60803d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const VariableArrayType* RVAT = getAsVariableArrayType(RHS); 608161710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (LVAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType)) 608261710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return LHS; 608361710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (RVAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType)) 608461710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return RHS; 60853d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (LVAT) { 60863d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // FIXME: This isn't correct! But tricky to implement because 60873d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // the array's size has to be the size of LHS, but the type 60883d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // has to be different. 60893d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 60903d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 60913d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (RVAT) { 60923d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // FIXME: This isn't correct! But tricky to implement because 60933d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // the array's size has to be the size of RHS, but the type 60943d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // has to be different. 60953d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return RHS; 60963d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 60973bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (getCanonicalType(LHSElem) == getCanonicalType(ResultType)) return LHS; 60983bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (getCanonicalType(RHSElem) == getCanonicalType(ResultType)) return RHS; 60997e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor return getIncompleteArrayType(ResultType, 61007e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor ArrayType::ArraySizeModifier(), 0); 61013d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 61021adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::FunctionNoProto: 6103447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor return mergeFunctionTypes(LHS, RHS, OfBlockPointer, Unqualified); 610472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Record: 610572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Enum: 61063d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 61071adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::Builtin: 61083cc4c0c3058a788689b8fc73c0ac139544435c97Chris Lattner // Only exactly equal builtin types are compatible, which is tested above. 61093d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 611064cfdb7da3cb744642fe8a99ad5c851ad3c930b2Daniel Dunbar case Type::Complex: 611164cfdb7da3cb744642fe8a99ad5c851ad3c930b2Daniel Dunbar // Distinct complex types are incompatible. 611264cfdb7da3cb744642fe8a99ad5c851ad3c930b2Daniel Dunbar return QualType(); 61133cc4c0c3058a788689b8fc73c0ac139544435c97Chris Lattner case Type::Vector: 61145a61f0e5c5aaecd5713c3fa4b78be7167a7eeff2Eli Friedman // FIXME: The merged type should be an ExtVector! 61151c471f3e1c0ec8cbc82447bb35908dfc55463e46John McCall if (areCompatVectorTypes(LHSCan->getAs<VectorType>(), 61161c471f3e1c0ec8cbc82447bb35908dfc55463e46John McCall RHSCan->getAs<VectorType>())) 61173d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 611861710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return QualType(); 6119c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCObject: { 6120c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Check if the types are assignment compatible. 61215a61f0e5c5aaecd5713c3fa4b78be7167a7eeff2Eli Friedman // FIXME: This should be type compatibility, e.g. whether 61225a61f0e5c5aaecd5713c3fa4b78be7167a7eeff2Eli Friedman // "LHS x; RHS x;" at global scope is legal. 6123c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* LHSIface = LHS->getAs<ObjCObjectType>(); 6124c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* RHSIface = RHS->getAs<ObjCObjectType>(); 6125c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (canAssignObjCInterfaces(LHSIface, RHSIface)) 61265fd659db11922fc12a58e478f7b745f9656b15a7Steve Naroff return LHS; 61275fd659db11922fc12a58e478f7b745f9656b15a7Steve Naroff 61283d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 612961490e9a965cfee8a78c12c6802138844f04250dCedric Venet } 613014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff case Type::ObjCObjectPointer: { 6131132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (OfBlockPointer) { 6132132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (canAssignObjCInterfacesInBlockPointer( 6133132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian LHS->getAs<ObjCObjectPointerType>(), 6134a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian RHS->getAs<ObjCObjectPointerType>(), 6135a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian BlockReturnType)) 61367530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie return LHS; 6137132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return QualType(); 6138132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 6139183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (canAssignObjCInterfaces(LHS->getAs<ObjCObjectPointerType>(), 6140183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall RHS->getAs<ObjCObjectPointerType>())) 614114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return LHS; 614214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 6143bc76dd06eb881c70c9775b74bab8b88cd747f173Steve Naroff return QualType(); 61447530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie } 6145ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff } 614672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 61477530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie llvm_unreachable("Invalid Type::Class!"); 6148ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff} 61497192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek 615078213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanianbool ASTContext::FunctionTypesMatchOnNSConsumedAttrs( 615178213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian const FunctionProtoType *FromFunctionType, 615278213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian const FunctionProtoType *ToFunctionType) { 615378213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (FromFunctionType->hasAnyConsumedArgs() != 615478213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ToFunctionType->hasAnyConsumedArgs()) 615578213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return false; 615678213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian FunctionProtoType::ExtProtoInfo FromEPI = 615778213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian FromFunctionType->getExtProtoInfo(); 615878213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian FunctionProtoType::ExtProtoInfo ToEPI = 615978213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ToFunctionType->getExtProtoInfo(); 616078213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (FromEPI.ConsumedArguments && ToEPI.ConsumedArguments) 616178213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumArgs(); 616278213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ArgIdx != NumArgs; ++ArgIdx) { 616378213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (FromEPI.ConsumedArguments[ArgIdx] != 616478213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ToEPI.ConsumedArguments[ArgIdx]) 616578213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return false; 616678213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian } 616778213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return true; 616878213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian} 616978213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian 61702390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian/// mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and 61712390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian/// 'RHS' attributes and returns the merged version; including for function 61722390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian/// return types. 61732390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz JahanianQualType ASTContext::mergeObjCGCQualifiers(QualType LHS, QualType RHS) { 61742390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType LHSCan = getCanonicalType(LHS), 61752390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian RHSCan = getCanonicalType(RHS); 61762390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // If two types are identical, they are compatible. 61772390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LHSCan == RHSCan) 61782390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return LHS; 61792390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (RHSCan->isFunctionType()) { 61802390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (!LHSCan->isFunctionType()) 61812390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61822390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType OldReturnType = 61832390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian cast<FunctionType>(RHSCan.getTypePtr())->getResultType(); 61842390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType NewReturnType = 61852390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian cast<FunctionType>(LHSCan.getTypePtr())->getResultType(); 61862390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType ResReturnType = 61872390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian mergeObjCGCQualifiers(NewReturnType, OldReturnType); 61882390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResReturnType.isNull()) 61892390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61902390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResReturnType == NewReturnType || ResReturnType == OldReturnType) { 61912390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // id foo(); ... __strong id foo(); or: __strong id foo(); ... id foo(); 61922390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // In either case, use OldReturnType to build the new function type. 61932390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian const FunctionType *F = LHS->getAs<FunctionType>(); 61942390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (const FunctionProtoType *FPT = cast<FunctionProtoType>(F)) { 6195e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 6196e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall EPI.ExtInfo = getFunctionExtInfo(LHS); 61972390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType ResultType 61982390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian = getFunctionType(OldReturnType, FPT->arg_type_begin(), 6199e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FPT->getNumArgs(), EPI); 62002390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return ResultType; 62012390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 62022390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 62032390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 62042390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 62052390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 62062390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // If the qualifiers are different, the types can still be merged. 62072390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers LQuals = LHSCan.getLocalQualifiers(); 62082390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers RQuals = RHSCan.getLocalQualifiers(); 62092390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LQuals != RQuals) { 62102390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // If any of these qualifiers are different, we have a type mismatch. 62112390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() || 62122390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian LQuals.getAddressSpace() != RQuals.getAddressSpace()) 62132390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 62142390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 62152390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // Exactly one GC qualifier difference is allowed: __strong is 62162390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // okay if the other type has no GC qualifier but is an Objective 62172390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // C object pointer (i.e. implicitly strong by default). We fix 62182390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // this by pretending that the unqualified type was actually 62192390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // qualified __strong. 62202390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers::GC GC_L = LQuals.getObjCGCAttr(); 62212390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers::GC GC_R = RQuals.getObjCGCAttr(); 62222390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements"); 62232390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 62242390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak) 62252390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 62262390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 62272390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (GC_L == Qualifiers::Strong) 62282390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return LHS; 62292390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (GC_R == Qualifiers::Strong) 62302390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return RHS; 62312390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 62322390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 62332390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 62342390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LHSCan->isObjCObjectPointerType() && RHSCan->isObjCObjectPointerType()) { 62352390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType LHSBaseQT = LHS->getAs<ObjCObjectPointerType>()->getPointeeType(); 62362390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType RHSBaseQT = RHS->getAs<ObjCObjectPointerType>()->getPointeeType(); 62372390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType ResQT = mergeObjCGCQualifiers(LHSBaseQT, RHSBaseQT); 62382390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResQT == LHSBaseQT) 62392390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return LHS; 62402390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResQT == RHSBaseQT) 62412390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return RHS; 62422390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 62432390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 62442390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian} 62452390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 62465426bf6456a5aeac416a9150de157904d101c819Chris Lattner//===----------------------------------------------------------------------===// 6247ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman// Integer Predicates 6248ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman//===----------------------------------------------------------------------===// 624988054dee0402e4d3c1f64e6b697acc47195c0d72Chris Lattner 62504ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadunsigned ASTContext::getIntWidth(QualType T) const { 6251f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall if (const EnumType *ET = dyn_cast<EnumType>(T)) 625229a7f3342c3c6dd15d914c61ae22246c36d51ce7Eli Friedman T = ET->getDecl()->getIntegerType(); 62531274ccd90aec0b205fc838c3d504821ccfb55482Douglas Gregor if (T->isBooleanType()) 62541274ccd90aec0b205fc838c3d504821ccfb55482Douglas Gregor return 1; 6255f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman // For builtin types, just use the standard type sizing method 6256ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return (unsigned)getTypeSize(T); 6257ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman} 6258ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman 6259ad74a758189180b8ab8faea648e4766c3bfd7fcbEli FriedmanQualType ASTContext::getCorrespondingUnsignedType(QualType T) { 6260f60946222721d9ba3c059563935c17b84703187aDouglas Gregor assert(T->hasSignedIntegerRepresentation() && "Unexpected type"); 62616a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner 62626a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner // Turn <4 x signed int> -> <4 x unsigned int> 62636a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner if (const VectorType *VTy = T->getAs<VectorType>()) 62646a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner return getVectorType(getCorrespondingUnsignedType(VTy->getElementType()), 6265e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VTy->getNumElements(), VTy->getVectorKind()); 62666a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner 62676a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner // For enums, we return the unsigned version of the base type. 62686a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner if (const EnumType *ETy = T->getAs<EnumType>()) 6269ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman T = ETy->getDecl()->getIntegerType(); 62706a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner 62716a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner const BuiltinType *BTy = T->getAs<BuiltinType>(); 62726a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner assert(BTy && "Unexpected signed integer type"); 6273ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman switch (BTy->getKind()) { 6274ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Char_S: 6275ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::SChar: 6276ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedCharTy; 6277ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Short: 6278ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedShortTy; 6279ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Int: 6280ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedIntTy; 6281ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Long: 6282ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedLongTy; 6283ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::LongLong: 6284ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedLongLongTy; 62852df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::Int128: 62862df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner return UnsignedInt128Ty; 6287ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman default: 6288b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unexpected signed integer type"); 6289ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman } 6290ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman} 6291ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman 62927b90340c9c7d07aef4e301e72b5e8a30d5f4f0c8Argyrios KyrtzidisASTMutationListener::~ASTMutationListener() { } 62937b90340c9c7d07aef4e301e72b5e8a30d5f4f0c8Argyrios Kyrtzidis 629486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 629586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner//===----------------------------------------------------------------------===// 629686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner// Builtin Type Computation 629786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner//===----------------------------------------------------------------------===// 629886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 629986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner/// DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the 630033daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// pointer over the consumed characters. This returns the resultant type. If 630133daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// AllowTypeModifiers is false then modifier like * are not parsed, just basic 630233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// types. This allows "v2i*" to be parsed as a pointer to a v2i instead of 630333daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// a vector of "i*". 630414e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner/// 630514e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner/// RequiresICE is filled in on return to indicate whether the value is required 630614e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner/// to be an Integer Constant Expression. 63074ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadstatic QualType DecodeTypeFromStr(const char *&Str, const ASTContext &Context, 630886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner ASTContext::GetBuiltinTypeError &Error, 630914e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner bool &RequiresICE, 631033daae66462e8f51ee153463b32bdefd60c801aaChris Lattner bool AllowTypeModifiers) { 631186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // Modifiers. 631286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner int HowLong = 0; 631386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner bool Signed = false, Unsigned = false; 631414e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE = false; 6315393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner 631633daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // Read the prefixed modifiers first. 631786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner bool Done = false; 631886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner while (!Done) { 631986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner switch (*Str++) { 63201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump default: Done = true; --Str; break; 6321393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner case 'I': 632214e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE = true; 6323393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner break; 632486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'S': 632586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Unsigned && "Can't use both 'S' and 'U' modifiers!"); 632686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Signed && "Can't use 'S' modifier multiple times!"); 632786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Signed = true; 632886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 632986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'U': 633086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Signed && "Can't use both 'S' and 'U' modifiers!"); 633186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Unsigned && "Can't use 'S' modifier multiple times!"); 633286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Unsigned = true; 633386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 633486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'L': 633586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong <= 2 && "Can't have LLLL modifier"); 633686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner ++HowLong; 633786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 633886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 633986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 634086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 634186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner QualType Type; 63421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 634386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // Read the base type. 634486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner switch (*Str++) { 6345b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Unknown builtin type letter!"); 634686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'v': 634786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && 634886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "Bad modifiers used with 'v'!"); 634986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.VoidTy; 635086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 635186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'f': 635286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && 635386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "Bad modifiers used with 'f'!"); 635486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.FloatTy; 635586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 635686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'd': 635786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong < 2 && !Signed && !Unsigned && 635886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "Bad modifiers used with 'd'!"); 635986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (HowLong) 636086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.LongDoubleTy; 636186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 636286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.DoubleTy; 636386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 636486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 's': 636586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && "Bad modifiers used with 's'!"); 636686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Unsigned) 636786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.UnsignedShortTy; 636886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 636986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.ShortTy; 637086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 637186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'i': 637286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (HowLong == 3) 637386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty; 637486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else if (HowLong == 2) 637586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy; 637686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else if (HowLong == 1) 637786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedLongTy : Context.LongTy; 637886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 637986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedIntTy : Context.IntTy; 638086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 638186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'c': 638286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && "Bad modifiers used with 'c'!"); 638386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Signed) 638486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.SignedCharTy; 638586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else if (Unsigned) 638686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.UnsignedCharTy; 638786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 638886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.CharTy; 638986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 639086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'b': // boolean 639186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'b'!"); 639286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.BoolTy; 639386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 639486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'z': // size_t. 639586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'z'!"); 639686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getSizeType(); 639786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 639886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'F': 639986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getCFConstantStringType(); 640086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 6401ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian case 'G': 6402ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian Type = Context.getObjCIdType(); 6403ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian break; 6404ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian case 'H': 6405ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian Type = Context.getObjCSelType(); 6406ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian break; 640786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'a': 640886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getBuiltinVaListType(); 640986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Type.isNull() && "builtin va list type not initialized!"); 641086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 641186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'A': 641286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // This is a "reference" to a va_list; however, what exactly 641386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // this means depends on how va_list is defined. There are two 641486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // different kinds of va_list: ones passed by value, and ones 641586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // passed by reference. An example of a by-value va_list is 641686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // x86, where va_list is a char*. An example of by-ref va_list 641786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // is x86-64, where va_list is a __va_list_tag[1]. For x86, 641886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // we want this argument to be a char*&; for x86-64, we want 641986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // it to be a __va_list_tag*. 642086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getBuiltinVaListType(); 642186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Type.isNull() && "builtin va list type not initialized!"); 642214e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner if (Type->isArrayType()) 642386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getArrayDecayedType(Type); 642414e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner else 642586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getLValueReferenceType(Type); 642686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 642786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'V': { 642886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner char *End; 642986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner unsigned NumElements = strtoul(Str, &End, 10); 643086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(End != Str && "Missing vector size"); 643186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Str = End; 64321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 643314e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType ElementType = DecodeTypeFromStr(Str, Context, Error, 643414e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE, false); 643514e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert(!RequiresICE && "Can't require vector ICE"); 643633daae66462e8f51ee153463b32bdefd60c801aaChris Lattner 643733daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // TODO: No way to make AltiVec vectors in builtins yet. 6438788b0fd67e1992f23555454efcdb16a19dfefac3Chris Lattner Type = Context.getVectorType(ElementType, NumElements, 6439e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType::GenericVector); 644086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 644186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 6442d3a23b238a2b2c0f11e6ac4951c7410a8c5717bfDouglas Gregor case 'X': { 644314e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE, 644414e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner false); 644514e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert(!RequiresICE && "Can't require complex ICE"); 6446d3a23b238a2b2c0f11e6ac4951c7410a8c5717bfDouglas Gregor Type = Context.getComplexType(ElementType); 6447d3a23b238a2b2c0f11e6ac4951c7410a8c5717bfDouglas Gregor break; 6448cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian } 6449cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian case 'Y' : { 6450cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian Type = Context.getPointerDiffType(); 6451cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian break; 6452cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian } 64539a5a7e7351f78345a72c4956af25590f6d40ebcdChris Lattner case 'P': 6454c29f77b769bcc5b6dc85e72c8e3cc2e348e5cf25Douglas Gregor Type = Context.getFILEType(); 6455c29f77b769bcc5b6dc85e72c8e3cc2e348e5cf25Douglas Gregor if (Type.isNull()) { 6456f711c41dd9412a8182793259d355c4f6979ed5edMike Stump Error = ASTContext::GE_Missing_stdio; 645786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return QualType(); 645886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 6459fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump break; 64609a5a7e7351f78345a72c4956af25590f6d40ebcdChris Lattner case 'J': 6461f711c41dd9412a8182793259d355c4f6979ed5edMike Stump if (Signed) 6462782fa308a765aeac2acb39c4e697c937ec21185bMike Stump Type = Context.getsigjmp_bufType(); 6463f711c41dd9412a8182793259d355c4f6979ed5edMike Stump else 6464f711c41dd9412a8182793259d355c4f6979ed5edMike Stump Type = Context.getjmp_bufType(); 6465f711c41dd9412a8182793259d355c4f6979ed5edMike Stump 6466fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump if (Type.isNull()) { 6467f711c41dd9412a8182793259d355c4f6979ed5edMike Stump Error = ASTContext::GE_Missing_setjmp; 6468fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump return QualType(); 6469fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump } 6470fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump break; 6471e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola case 'K': 6472e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'K'!"); 6473e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola Type = Context.getucontext_tType(); 6474e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola 6475e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola if (Type.isNull()) { 6476e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola Error = ASTContext::GE_Missing_ucontext; 6477e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola return QualType(); 6478e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola } 6479e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola break; 6480782fa308a765aeac2acb39c4e697c937ec21185bMike Stump } 64811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 648233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // If there are modifiers and if we're allowed to parse them, go for it. 648333daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Done = !AllowTypeModifiers; 648486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner while (!Done) { 6485187ab37a05b8f7015b9f39cc8cd9129a0c6d0b48John McCall switch (char c = *Str++) { 648633daae66462e8f51ee153463b32bdefd60c801aaChris Lattner default: Done = true; --Str; break; 648733daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case '*': 648833daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case '&': { 648933daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // Both pointers and references can have their pointee types 649033daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // qualified with an address space. 649133daae66462e8f51ee153463b32bdefd60c801aaChris Lattner char *End; 649233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner unsigned AddrSpace = strtoul(Str, &End, 10); 649333daae66462e8f51ee153463b32bdefd60c801aaChris Lattner if (End != Str && AddrSpace != 0) { 649433daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getAddrSpaceQualType(Type, AddrSpace); 649533daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Str = End; 649633daae66462e8f51ee153463b32bdefd60c801aaChris Lattner } 649733daae66462e8f51ee153463b32bdefd60c801aaChris Lattner if (c == '*') 649833daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getPointerType(Type); 649933daae66462e8f51ee153463b32bdefd60c801aaChris Lattner else 650033daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getLValueReferenceType(Type); 650133daae66462e8f51ee153463b32bdefd60c801aaChris Lattner break; 650233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner } 650333daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // FIXME: There's no way to have a built-in with an rvalue ref arg. 650433daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case 'C': 650533daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Type.withConst(); 650633daae66462e8f51ee153463b32bdefd60c801aaChris Lattner break; 650733daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case 'D': 650833daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getVolatileType(Type); 650933daae66462e8f51ee153463b32bdefd60c801aaChris Lattner break; 651018932a0f2a94a7813ec461d1118c39ecf8aa936fTed Kremenek case 'R': 651118932a0f2a94a7813ec461d1118c39ecf8aa936fTed Kremenek Type = Type.withRestrict(); 651218932a0f2a94a7813ec461d1118c39ecf8aa936fTed Kremenek break; 651386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 651486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 6515393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner 651614e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert((!RequiresICE || Type->isIntegralOrEnumerationType()) && 6517393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner "Integer constant 'I' type must be an integer"); 65181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 651986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return Type; 652086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner} 652186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 652286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner/// GetBuiltinType - Return the type for the specified builtin. 652333daae66462e8f51ee153463b32bdefd60c801aaChris LattnerQualType ASTContext::GetBuiltinType(unsigned Id, 652414e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner GetBuiltinTypeError &Error, 65254ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned *IntegerConstantArgs) const { 652633daae66462e8f51ee153463b32bdefd60c801aaChris Lattner const char *TypeStr = BuiltinInfo.GetTypeString(Id); 65271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 65285f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 8> ArgTypes; 65291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 653014e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner bool RequiresICE = false; 653186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Error = GE_None; 653214e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType ResType = DecodeTypeFromStr(TypeStr, *this, Error, 653314e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE, true); 653486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Error != GE_None) 653586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return QualType(); 653614e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner 653714e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert(!RequiresICE && "Result of intrinsic cannot be required to be an ICE"); 653814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner 653986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner while (TypeStr[0] && TypeStr[0] != '.') { 654014e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType Ty = DecodeTypeFromStr(TypeStr, *this, Error, RequiresICE, true); 654186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Error != GE_None) 654286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return QualType(); 654386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 654414e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner // If this argument is required to be an IntegerConstantExpression and the 654514e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner // caller cares, fill in the bitmask we return. 654614e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner if (RequiresICE && IntegerConstantArgs) 654714e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner *IntegerConstantArgs |= 1 << ArgTypes.size(); 654814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner 654986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // Do array -> pointer decay. The builtin should use the decayed type. 655086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Ty->isArrayType()) 655186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Ty = getArrayDecayedType(Ty); 65521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 655386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner ArgTypes.push_back(Ty); 655486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 655586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 655686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert((TypeStr[0] != '.' || TypeStr[1] == 0) && 655786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "'.' should only occur at end of builtin type list!"); 655886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 655900ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall FunctionType::ExtInfo EI; 656000ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall if (BuiltinInfo.isNoReturn(Id)) EI = EI.withNoReturn(true); 656100ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall 656200ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall bool Variadic = (TypeStr[0] == '.'); 656300ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall 656400ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall // We really shouldn't be making a no-proto type here, especially in C++. 656500ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall if (ArgTypes.empty() && Variadic) 656600ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall return getFunctionNoProtoType(ResType, EI); 6567ce056bcaa1c97b89a4b2de2112c62d060863be2bDouglas Gregor 6568e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI; 656900ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall EPI.ExtInfo = EI; 657000ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall EPI.Variadic = Variadic; 6571e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 6572e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall return getFunctionType(ResType, ArgTypes.data(), ArgTypes.size(), EPI); 657386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner} 6574a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman 657590e99a84ddd020e8fda79643748243725a2ed071Argyrios KyrtzidisGVALinkage ASTContext::GetGVALinkageForFunction(const FunctionDecl *FD) { 657690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis GVALinkage External = GVA_StrongExternal; 657790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 657890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis Linkage L = FD->getLinkage(); 657990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (L) { 658090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case NoLinkage: 658190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case InternalLinkage: 658290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case UniqueExternalLinkage: 658390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_Internal; 658490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 658590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case ExternalLinkage: 658690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (FD->getTemplateSpecializationKind()) { 658790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_Undeclared: 658890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitSpecialization: 658990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis External = GVA_StrongExternal; 659090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis break; 659190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 659290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDefinition: 659390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_ExplicitTemplateInstantiation; 659490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 659590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDeclaration: 659690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ImplicitInstantiation: 659790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis External = GVA_TemplateInstantiation; 659890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis break; 659990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 660090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 660190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 660290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (!FD->isInlined()) 660390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return External; 660490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 660590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (!getLangOptions().CPlusPlus || FD->hasAttr<GNUInlineAttr>()) { 660690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // GNU or C99 inline semantics. Determine whether this symbol should be 660790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // externally visible. 660890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (FD->isInlineDefinitionExternallyVisible()) 660990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return External; 661090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 661190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // C99 inline semantics, where the symbol is not externally visible. 661290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_C99Inline; 661390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 661490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 661590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // C++0x [temp.explicit]p9: 661690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // [ Note: The intent is that an inline function that is the subject of 661790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // an explicit instantiation declaration will still be implicitly 661890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // instantiated when used so that the body can be considered for 661990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // inlining, but that no out-of-line copy of the inline function would be 662090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // generated in the translation unit. -- end note ] 662190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (FD->getTemplateSpecializationKind() 662290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis == TSK_ExplicitInstantiationDeclaration) 662390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_C99Inline; 662490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 662590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_CXXInline; 662690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis} 662790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 662890e99a84ddd020e8fda79643748243725a2ed071Argyrios KyrtzidisGVALinkage ASTContext::GetGVALinkageForVariable(const VarDecl *VD) { 662990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // If this is a static data member, compute the kind of template 663090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // specialization. Otherwise, this variable is not part of a 663190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // template. 663290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis TemplateSpecializationKind TSK = TSK_Undeclared; 663390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (VD->isStaticDataMember()) 663490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis TSK = VD->getTemplateSpecializationKind(); 663590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 663690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis Linkage L = VD->getLinkage(); 663790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (L == ExternalLinkage && getLangOptions().CPlusPlus && 663890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis VD->getType()->getLinkage() == UniqueExternalLinkage) 663990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis L = UniqueExternalLinkage; 664090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 664190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (L) { 664290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case NoLinkage: 664390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case InternalLinkage: 664490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case UniqueExternalLinkage: 664590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_Internal; 664690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 664790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case ExternalLinkage: 664890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (TSK) { 664990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_Undeclared: 665090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitSpecialization: 665190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_StrongExternal; 665290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 665390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDeclaration: 665490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis llvm_unreachable("Variable should not be instantiated"); 665590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Fall through to treat this like any other instantiation. 665690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 665790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDefinition: 665890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_ExplicitTemplateInstantiation; 665990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 666090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ImplicitInstantiation: 666190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_TemplateInstantiation; 666290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 666390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 666490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 66657530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie llvm_unreachable("Invalid Linkage!"); 666690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis} 666790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 66684ac7c0bb39696e92fd220118fedc484c09a69870Argyrios Kyrtzidisbool ASTContext::DeclMustBeEmitted(const Decl *D) { 666990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 667090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (!VD->isFileVarDecl()) 667190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 6672144b38a7995cbe0928e34fbcc865bb2d2be4f7a3Argyrios Kyrtzidis } else if (!isa<FunctionDecl>(D)) 667390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 667490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 6675ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis // Weak references don't produce any output by themselves. 6676ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis if (D->hasAttr<WeakRefAttr>()) 6677ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis return false; 6678ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis 667990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Aliases and used decls are required. 668090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (D->hasAttr<AliasAttr>() || D->hasAttr<UsedAttr>()) 668190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 668290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 668390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 668490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Forward declarations aren't required. 668510620eb5164e31208fcbf0437cd79ae535ed0559Sean Hunt if (!FD->doesThisDeclarationHaveABody()) 6686dce67a70a86db8758c926a76fdd980f5369d5746Nick Lewycky return FD->doesDeclarationForceExternallyVisibleDefinition(); 668790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 668890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Constructors and destructors are required. 668990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (FD->hasAttr<ConstructorAttr>() || FD->hasAttr<DestructorAttr>()) 669090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 669190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 669290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // The key function for a class is required. 669390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 669490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis const CXXRecordDecl *RD = MD->getParent(); 669590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (MD->isOutOfLine() && RD->isDynamicClass()) { 669690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis const CXXMethodDecl *KeyFunc = getKeyFunction(RD); 669790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (KeyFunc && KeyFunc->getCanonicalDecl() == MD->getCanonicalDecl()) 669890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 669990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 670090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 670190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 670290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis GVALinkage Linkage = GetGVALinkageForFunction(FD); 670390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 670490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // static, static inline, always_inline, and extern inline functions can 670590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // always be deferred. Normal inline functions can be deferred in C99/C++. 670690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Implicit template instantiations can also be deferred in C++. 670790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (Linkage == GVA_Internal || Linkage == GVA_C99Inline || 67083a5aca8112e03814f78906dc5d032287adb272b5Anton Yartsev Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) 670990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 671090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 671190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 671294da1587f7d584fc61df793229d197969f204cd9Douglas Gregor 671390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis const VarDecl *VD = cast<VarDecl>(D); 671490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis assert(VD->isFileVarDecl() && "Expected file scoped var"); 671590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 6716ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly) 6717ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis return false; 6718ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis 671990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Structs that have non-trivial constructors or destructors are required. 672090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 672190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // FIXME: Handle references. 6722023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt // FIXME: Be more selective about which constructors we care about. 672390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const RecordType *RT = VD->getType()->getAs<RecordType>()) { 672490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 6725023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt if (RD->hasDefinition() && !(RD->hasTrivialDefaultConstructor() && 6726023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt RD->hasTrivialCopyConstructor() && 6727023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt RD->hasTrivialMoveConstructor() && 6728023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt RD->hasTrivialDestructor())) 672990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 673090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 673190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 673290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 673390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis GVALinkage L = GetGVALinkageForVariable(VD); 673490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (L == GVA_Internal || L == GVA_TemplateInstantiation) { 673590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (!(VD->getInit() && VD->getInit()->HasSideEffects(*this))) 673690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 673790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 673890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 673990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 674090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis} 6741071cc7deffad608165b1ddd5263e8bf181861520Charles Davis 6742ee743f903858e337434ac0335f147f4de4ecae05Charles DavisCallingConv ASTContext::getDefaultMethodCallConv() { 6743ee743f903858e337434ac0335f147f4de4ecae05Charles Davis // Pass through to the C++ ABI object 6744ee743f903858e337434ac0335f147f4de4ecae05Charles Davis return ABI->getDefaultMethodCallConv(); 6745ee743f903858e337434ac0335f147f4de4ecae05Charles Davis} 6746ee743f903858e337434ac0335f147f4de4ecae05Charles Davis 67474ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadbool ASTContext::isNearlyEmpty(const CXXRecordDecl *RD) const { 6748dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson // Pass through to the C++ ABI object 6749dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson return ABI->isNearlyEmpty(RD); 6750dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson} 6751dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson 675214110477887e3dc168ffc6c191e72d705051f99ePeter CollingbourneMangleContext *ASTContext::createMangleContext() { 6753bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor switch (Target->getCXXABI()) { 675414110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne case CXXABI_ARM: 675514110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne case CXXABI_Itanium: 675614110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne return createItaniumMangleContext(*this, getDiagnostics()); 675714110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne case CXXABI_Microsoft: 675814110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne return createMicrosoftMangleContext(*this, getDiagnostics()); 675914110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne } 6760b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unsupported ABI"); 676114110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne} 676214110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne 6763071cc7deffad608165b1ddd5263e8bf181861520Charles DavisCXXABI::~CXXABI() {} 6764ba29bd25515fbd99e98ba0fedb9d93617b27609eTed Kremenek 6765ba29bd25515fbd99e98ba0fedb9d93617b27609eTed Kremeneksize_t ASTContext::getSideTableAllocatedMemory() const { 67660c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek return ASTRecordLayouts.getMemorySize() 67670c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(ObjCLayouts) 67680c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(KeyFunctions) 67690c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(ObjCImpls) 67700c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(BlockVarCopyInits) 67710c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(DeclAttrs) 67720c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromStaticDataMember) 67730c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromUsingDecl) 67740c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromUsingShadowDecl) 67750c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromUnnamedFieldDecl) 67760c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(OverriddenMethods) 67770c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(Types) 6778af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet + llvm::capacity_in_bytes(VariableArrayTypes) 67790d95f0d7b81110f77e99e833f766d19be7b7e072Francois Pichet + llvm::capacity_in_bytes(ClassScopeSpecializationPattern); 6780ba29bd25515fbd99e98ba0fedb9d93617b27609eTed Kremenek} 6781d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek 6782d211cb709510fbe7e75167b9feee0050851d001aTed Kremenekvoid ASTContext::setParameterIndex(const ParmVarDecl *D, unsigned int index) { 6783d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek ParamIndices[D] = index; 6784d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek} 6785d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek 6786d211cb709510fbe7e75167b9feee0050851d001aTed Kremenekunsigned ASTContext::getParameterIndex(const ParmVarDecl *D) const { 6787d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek ParameterIndexTable::const_iterator I = ParamIndices.find(D); 6788d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek assert(I != ParamIndices.end() && 6789d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek "ParmIndices lacks entry set by ParmVarDecl"); 6790d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek return I->second; 6791d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek} 6792