ASTContext.cpp revision 392da48160bd92ceb486792780467cbfdb2d0e8c
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()); 779e9c454b12671a624f666fc6fbf132fdf183effcEli Friedman ID.AddPointer(NTTP->getType().getCanonicalType().getAsOpaquePtr()); 786952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor if (NTTP->isExpandedParameterPack()) { 796952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ID.AddBoolean(true); 806952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ID.AddInteger(NTTP->getNumExpansionTypes()); 819e9c454b12671a624f666fc6fbf132fdf183effcEli Friedman for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) { 829e9c454b12671a624f666fc6fbf132fdf183effcEli Friedman QualType T = NTTP->getExpansionType(I); 839e9c454b12671a624f666fc6fbf132fdf183effcEli Friedman ID.AddPointer(T.getCanonicalType().getAsOpaquePtr()); 849e9c454b12671a624f666fc6fbf132fdf183effcEli Friedman } 856952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor } else 866952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ID.AddBoolean(false); 873e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor continue; 883e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor } 893e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 903e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P); 913e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor ID.AddInteger(2); 923e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor Profile(ID, TTP); 933e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor } 943e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor} 953e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 963e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas GregorTemplateTemplateParmDecl * 973e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas GregorASTContext::getCanonicalTemplateTemplateParmDecl( 984ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad TemplateTemplateParmDecl *TTP) const { 993e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // Check if we already have a canonical template template parameter. 1003e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor llvm::FoldingSetNodeID ID; 1013e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor CanonicalTemplateTemplateParm::Profile(ID, TTP); 1023e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor void *InsertPos = 0; 1033e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor CanonicalTemplateTemplateParm *Canonical 1043e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos); 1053e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor if (Canonical) 1063e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor return Canonical->getParam(); 1073e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 1083e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // Build a canonical template parameter list. 1093e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor TemplateParameterList *Params = TTP->getTemplateParameters(); 1105f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<NamedDecl *, 4> CanonParams; 1113e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor CanonParams.reserve(Params->size()); 1123e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor for (TemplateParameterList::const_iterator P = Params->begin(), 1133e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PEnd = Params->end(); 1143e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor P != PEnd; ++P) { 1153e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) 1163e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor CanonParams.push_back( 1173e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor TemplateTypeParmDecl::Create(*this, getTranslationUnitDecl(), 118344577e6b58f42d18dc8118c8903b49a85dc005eAbramo Bagnara SourceLocation(), 119344577e6b58f42d18dc8118c8903b49a85dc005eAbramo Bagnara SourceLocation(), 120344577e6b58f42d18dc8118c8903b49a85dc005eAbramo Bagnara TTP->getDepth(), 1213e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor TTP->getIndex(), 0, false, 1223e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor TTP->isParameterPack())); 1233e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor else if (NonTypeTemplateParmDecl *NTTP 1246952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(*P)) { 1256952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor QualType T = getCanonicalType(NTTP->getType()); 1266952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(T); 1276952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor NonTypeTemplateParmDecl *Param; 1286952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor if (NTTP->isExpandedParameterPack()) { 1295f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 2> ExpandedTypes; 1305f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TypeSourceInfo *, 2> ExpandedTInfos; 1316952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) { 1326952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ExpandedTypes.push_back(getCanonicalType(NTTP->getExpansionType(I))); 1336952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ExpandedTInfos.push_back( 1346952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor getTrivialTypeSourceInfo(ExpandedTypes.back())); 1356952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor } 1366952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor 1376952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(), 138ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara SourceLocation(), 139ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara SourceLocation(), 1406952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor NTTP->getDepth(), 1416952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor NTTP->getPosition(), 0, 1426952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor T, 1436952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor TInfo, 1446952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ExpandedTypes.data(), 1456952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ExpandedTypes.size(), 1466952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor ExpandedTInfos.data()); 1476952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor } else { 1486952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(), 149ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara SourceLocation(), 150ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara SourceLocation(), 1516952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor NTTP->getDepth(), 1526952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor NTTP->getPosition(), 0, 1536952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor T, 1546952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor NTTP->isParameterPack(), 1556952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor TInfo); 1566952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor } 1576952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor CanonParams.push_back(Param); 1586952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor 1596952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor } else 1603e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor CanonParams.push_back(getCanonicalTemplateTemplateParmDecl( 1613e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor cast<TemplateTemplateParmDecl>(*P))); 1623e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor } 1633e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 1643e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor TemplateTemplateParmDecl *CanonTTP 1653e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor = TemplateTemplateParmDecl::Create(*this, getTranslationUnitDecl(), 1663e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor SourceLocation(), TTP->getDepth(), 16761c4d28e36cd3f1be392cb77f07436d1fa6b0f9fDouglas Gregor TTP->getPosition(), 16861c4d28e36cd3f1be392cb77f07436d1fa6b0f9fDouglas Gregor TTP->isParameterPack(), 16961c4d28e36cd3f1be392cb77f07436d1fa6b0f9fDouglas Gregor 0, 1703e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor TemplateParameterList::Create(*this, SourceLocation(), 1713e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor SourceLocation(), 1723e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor CanonParams.data(), 1733e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor CanonParams.size(), 1743e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor SourceLocation())); 1753e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 1763e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // Get the new insert position for the node we care about. 1773e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos); 1783e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor assert(Canonical == 0 && "Shouldn't be in the map!"); 1793e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor (void)Canonical; 1803e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 1813e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // Create the canonical template template parameter entry. 1823e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor Canonical = new (*this) CanonicalTemplateTemplateParm(CanonTTP); 1833e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos); 1843e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor return CanonTTP; 1853e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor} 1863e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 187071cc7deffad608165b1ddd5263e8bf181861520Charles DavisCXXABI *ASTContext::createCXXABI(const TargetInfo &T) { 188ee79a4c30e5d1c5285551c9a25b8ec6d45d46aa7John McCall if (!LangOpts.CPlusPlus) return 0; 189ee79a4c30e5d1c5285551c9a25b8ec6d45d46aa7John McCall 19020cf717034ba1f20fc47c025ecb72ed9b631ad13Charles Davis switch (T.getCXXABI()) { 191ee79a4c30e5d1c5285551c9a25b8ec6d45d46aa7John McCall case CXXABI_ARM: 192ee79a4c30e5d1c5285551c9a25b8ec6d45d46aa7John McCall return CreateARMCXXABI(*this); 193ee79a4c30e5d1c5285551c9a25b8ec6d45d46aa7John McCall case CXXABI_Itanium: 194071cc7deffad608165b1ddd5263e8bf181861520Charles Davis return CreateItaniumCXXABI(*this); 19520cf717034ba1f20fc47c025ecb72ed9b631ad13Charles Davis case CXXABI_Microsoft: 19620cf717034ba1f20fc47c025ecb72ed9b631ad13Charles Davis return CreateMicrosoftCXXABI(*this); 19720cf717034ba1f20fc47c025ecb72ed9b631ad13Charles Davis } 1987530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie llvm_unreachable("Invalid CXXABI type!"); 199071cc7deffad608165b1ddd5263e8bf181861520Charles Davis} 200071cc7deffad608165b1ddd5263e8bf181861520Charles Davis 201bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregorstatic const LangAS::Map *getAddressSpaceMap(const TargetInfo &T, 202207f4d8543529221932af82836016a2ef066c917Peter Collingbourne const LangOptions &LOpts) { 203207f4d8543529221932af82836016a2ef066c917Peter Collingbourne if (LOpts.FakeAddressSpaceMap) { 204207f4d8543529221932af82836016a2ef066c917Peter Collingbourne // The fake address space map must have a distinct entry for each 205207f4d8543529221932af82836016a2ef066c917Peter Collingbourne // language-specific address space. 206207f4d8543529221932af82836016a2ef066c917Peter Collingbourne static const unsigned FakeAddrSpaceMap[] = { 207207f4d8543529221932af82836016a2ef066c917Peter Collingbourne 1, // opencl_global 208207f4d8543529221932af82836016a2ef066c917Peter Collingbourne 2, // opencl_local 209207f4d8543529221932af82836016a2ef066c917Peter Collingbourne 3 // opencl_constant 210207f4d8543529221932af82836016a2ef066c917Peter Collingbourne }; 211bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor return &FakeAddrSpaceMap; 212207f4d8543529221932af82836016a2ef066c917Peter Collingbourne } else { 213bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor return &T.getAddressSpaceMap(); 214207f4d8543529221932af82836016a2ef066c917Peter Collingbourne } 215207f4d8543529221932af82836016a2ef066c917Peter Collingbourne} 216207f4d8543529221932af82836016a2ef066c917Peter Collingbourne 2173e3cd93b2fd9644e970c389e715c13883faf68b6Douglas GregorASTContext::ASTContext(LangOptions& LOpts, SourceManager &SM, 218bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor const TargetInfo *t, 219e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar IdentifierTable &idents, SelectorTable &sels, 2201b63e4f732dbc73d90abf886b4d21f8e3a165f6dChris Lattner Builtin::Context &builtins, 221bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor unsigned size_reserve, 222bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor bool DelayInitialization) 223bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor : FunctionProtoTypes(this_()), 224bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor TemplateSpecializationTypes(this_()), 225bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor DependentTemplateSpecializationTypes(this_()), 226bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor SubstTemplateTemplateParmPacks(this_()), 227bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor GlobalNestedNameSpecifier(0), 228bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Int128Decl(0), UInt128Decl(0), 229a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor ObjCIdDecl(0), ObjCSelDecl(0), ObjCClassDecl(0), ObjCProtocolClassDecl(0), 230e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor CFConstantStringTypeDecl(0), ObjCInstanceTypeDecl(0), 231bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor FILEDecl(0), 232e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola jmp_bufDecl(0), sigjmp_bufDecl(0), ucontext_tDecl(0), 233e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola BlockDescriptorType(0), BlockDescriptorExtendedType(0), 234e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola cudaConfigureCallDecl(0), 235e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor NullTypeSourceInfo(QualType()), 236e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor FirstLocalImport(), LastLocalImport(), 237bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor SourceMgr(SM), LangOpts(LOpts), 23830c42404202d2e2512e51efc6066bd614cfdb5a4Douglas Gregor AddrSpaceMap(0), Target(t), PrintingPolicy(LOpts), 239bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Idents(idents), Selectors(sels), 240bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor BuiltinInfo(builtins), 241bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor DeclarationNames(*this), 24230c42404202d2e2512e51efc6066bd614cfdb5a4Douglas Gregor ExternalSource(0), Listener(0), 243bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor LastSDM(0, 0), 244bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor UniqueBlockByRefTypeID(0) 245bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor{ 2461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (size_reserve > 0) Types.reserve(size_reserve); 247e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar TUDecl = TranslationUnitDecl::Create(*this); 248bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor 249bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor if (!DelayInitialization) { 250bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor assert(t && "No target supplied for ASTContext initialization"); 251bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor InitBuiltinTypes(*t); 252bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor } 253e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar} 254e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar 2555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerASTContext::~ASTContext() { 2563478eb6872d836600caf45b0f81c2065d685d6e0Ted Kremenek // Release the DenseMaps associated with DeclContext objects. 2573478eb6872d836600caf45b0f81c2065d685d6e0Ted Kremenek // FIXME: Is this the ideal solution? 2583478eb6872d836600caf45b0f81c2065d685d6e0Ted Kremenek ReleaseDeclContextMaps(); 2597d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 26063fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor // Call all of the deallocation functions. 26163fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor for (unsigned I = 0, N = Deallocations.size(); I != N; ++I) 26263fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor Deallocations[I].first(Deallocations[I].second); 2630054531488928a424666ac11fcdc6bcc5112de52Douglas Gregor 264dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek // ASTRecordLayout objects in ASTRecordLayouts must always be destroyed 26563fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor // because they can contain DenseMaps. 26663fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor for (llvm::DenseMap<const ObjCContainerDecl*, 26763fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor const ASTRecordLayout*>::iterator 26863fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor I = ObjCLayouts.begin(), E = ObjCLayouts.end(); I != E; ) 26963fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor // Increment in loop to prevent using deallocated memory. 27063fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor if (ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second)) 27163fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor R->Destroy(*this); 27263fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor 273dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator 274dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) { 275dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek // Increment in loop to prevent using deallocated memory. 276dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek if (ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second)) 277dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek R->Destroy(*this); 278dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek } 2796320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 2806320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(), 2816320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor AEnd = DeclAttrs.end(); 2826320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor A != AEnd; ++A) 2836320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor A->second->~AttrVec(); 2846320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor} 285ab452ba8323d1985e08bade2bced588cddf2cc28Douglas Gregor 2860054531488928a424666ac11fcdc6bcc5112de52Douglas Gregorvoid ASTContext::AddDeallocation(void (*Callback)(void*), void *Data) { 2870054531488928a424666ac11fcdc6bcc5112de52Douglas Gregor Deallocations.push_back(std::make_pair(Callback, Data)); 2880054531488928a424666ac11fcdc6bcc5112de52Douglas Gregor} 2890054531488928a424666ac11fcdc6bcc5112de52Douglas Gregor 2901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid 2916f42b62b6194f53bcbc349f5d17388e1936535d7Dylan NoblesmithASTContext::setExternalSource(OwningPtr<ExternalASTSource> &Source) { 2922cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor ExternalSource.reset(Source.take()); 2932cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor} 2942cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor 2955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid ASTContext::PrintStats() const { 296cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << "\n*** AST Context Stats:\n"; 297cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << " " << Types.size() << " types total.\n"; 2987c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 299dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor unsigned counts[] = { 3001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump#define TYPE(Name, Parent) 0, 301dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor#define ABSTRACT_TYPE(Name, Parent) 302dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor#include "clang/AST/TypeNodes.def" 303dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor 0 // Extra 304dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor }; 305c2ee10d79f70036af652a395ac1f8273f3d04e12Douglas Gregor 3065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0, e = Types.size(); i != e; ++i) { 3075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Type *T = Types[i]; 308dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor counts[(unsigned)T->getTypeClass()]++; 3095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 311dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor unsigned Idx = 0; 312dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor unsigned TotalBytes = 0; 313dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor#define TYPE(Name, Parent) \ 314dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor if (counts[Idx]) \ 315cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << " " << counts[Idx] << " " << #Name \ 316cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " types\n"; \ 317dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor TotalBytes += counts[Idx] * sizeof(Name##Type); \ 318dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor ++Idx; 319dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor#define ABSTRACT_TYPE(Name, Parent) 320dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor#include "clang/AST/TypeNodes.def" 3211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 322cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << "Total bytes = " << TotalBytes << "\n"; 323cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth 3244923aa25eb39d64106a5817c02d560a3aecf8b2cDouglas Gregor // Implicit special member functions. 325cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << NumImplicitDefaultConstructorsDeclared << "/" 326cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << NumImplicitDefaultConstructors 327cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " implicit default constructors created\n"; 328cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << NumImplicitCopyConstructorsDeclared << "/" 329cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << NumImplicitCopyConstructors 330cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " implicit copy constructors created\n"; 3314e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (getLangOpts().CPlusPlus) 332cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << NumImplicitMoveConstructorsDeclared << "/" 333cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << NumImplicitMoveConstructors 334cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " implicit move constructors created\n"; 335cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << NumImplicitCopyAssignmentOperatorsDeclared << "/" 336cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << NumImplicitCopyAssignmentOperators 337cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " implicit copy assignment operators created\n"; 3384e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (getLangOpts().CPlusPlus) 339cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << NumImplicitMoveAssignmentOperatorsDeclared << "/" 340cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << NumImplicitMoveAssignmentOperators 341cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " implicit move assignment operators created\n"; 342cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << NumImplicitDestructorsDeclared << "/" 343cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << NumImplicitDestructors 344cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " implicit destructors created\n"; 345cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth 3462cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor if (ExternalSource.get()) { 347cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << "\n"; 3482cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor ExternalSource->PrintStats(); 3492cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor } 350cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth 35163fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor BumpAlloc.PrintStats(); 3525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 354772eeaefef2c883aabe35caf4543e7e32d290183Douglas GregorTypedefDecl *ASTContext::getInt128Decl() const { 355772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor if (!Int128Decl) { 356772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(Int128Ty); 357772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor Int128Decl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 358772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor getTranslationUnitDecl(), 359772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor SourceLocation(), 360772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor SourceLocation(), 361772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor &Idents.get("__int128_t"), 362772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor TInfo); 363772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor } 364772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor 365772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor return Int128Decl; 366772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor} 367772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor 368772eeaefef2c883aabe35caf4543e7e32d290183Douglas GregorTypedefDecl *ASTContext::getUInt128Decl() const { 369772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor if (!UInt128Decl) { 370772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(UnsignedInt128Ty); 371772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor UInt128Decl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 372772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor getTranslationUnitDecl(), 373772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor SourceLocation(), 374772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor SourceLocation(), 375772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor &Idents.get("__uint128_t"), 376772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor TInfo); 377772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor } 378772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor 379772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor return UInt128Decl; 380772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor} 3815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 382e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCallvoid ASTContext::InitBuiltinType(CanQualType &R, BuiltinType::Kind K) { 3836b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall BuiltinType *Ty = new (*this, TypeAlignment) BuiltinType(K); 384e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCall R = CanQualType::CreateUnsafe(QualType(Ty, 0)); 3856b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall Types.push_back(Ty); 3865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 388bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregorvoid ASTContext::InitBuiltinTypes(const TargetInfo &Target) { 389bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor assert((!this->Target || this->Target == &Target) && 390bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor "Incorrect target reinitialization"); 3915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(VoidTy.isNull() && "Context reinitialized?"); 3921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 393bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor this->Target = &Target; 394bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor 395bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor ABI.reset(createCXXABI(Target)); 396bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor AddrSpaceMap = getAddressSpaceMap(Target, LangOpts); 397bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor 3985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p19. 3995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(VoidTy, BuiltinType::Void); 4001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p2. 4025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(BoolTy, BuiltinType::Bool); 4035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p3. 40415b91764d08e886391c865c4a444d7b51141c284Eli Friedman if (LangOpts.CharIsSigned) 4055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(CharTy, BuiltinType::Char_S); 4065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer else 4075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(CharTy, BuiltinType::Char_U); 4085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p4. 4095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(SignedCharTy, BuiltinType::SChar); 4105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(ShortTy, BuiltinType::Short); 4115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(IntTy, BuiltinType::Int); 4125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(LongTy, BuiltinType::Long); 4135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(LongLongTy, BuiltinType::LongLong); 4141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p6. 4165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(UnsignedCharTy, BuiltinType::UChar); 4175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(UnsignedShortTy, BuiltinType::UShort); 4185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(UnsignedIntTy, BuiltinType::UInt); 4195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(UnsignedLongTy, BuiltinType::ULong); 4205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(UnsignedLongLongTy, BuiltinType::ULongLong); 4211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p10. 4235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(FloatTy, BuiltinType::Float); 4245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(DoubleTy, BuiltinType::Double); 4255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(LongDoubleTy, BuiltinType::LongDouble); 42664c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 4272df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner // GNU extension, 128-bit integers. 4282df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner InitBuiltinType(Int128Ty, BuiltinType::Int128); 4292df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner InitBuiltinType(UnsignedInt128Ty, BuiltinType::UInt128); 4302df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner 4313f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner if (LangOpts.CPlusPlus) { // C++ 3.9.1p5 432d3d77cd138f8e830f6547b6f83fcd5721ccf5f5dEli Friedman if (TargetInfo::isTypeSigned(Target.getWCharType())) 4333f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner InitBuiltinType(WCharTy, BuiltinType::WChar_S); 4343f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner else // -fshort-wchar makes wchar_t be unsigned. 4353f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner InitBuiltinType(WCharTy, BuiltinType::WChar_U); 4363f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner } else // C99 4373a2503227c3db04a3619735127483263c1075ef7Chris Lattner WCharTy = getFromTargetType(Target.getWCharType()); 43864c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 439392da48160bd92ceb486792780467cbfdb2d0e8cJames Molloy WIntTy = getFromTargetType(Target.getWIntType()); 440392da48160bd92ceb486792780467cbfdb2d0e8cJames Molloy 441f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++ 442f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith InitBuiltinType(Char16Ty, BuiltinType::Char16); 443f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith else // C99 444f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith Char16Ty = getFromTargetType(Target.getChar16Type()); 445f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith 446f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++ 447f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith InitBuiltinType(Char32Ty, BuiltinType::Char32); 448f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith else // C99 449f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith Char32Ty = getFromTargetType(Target.getChar32Type()); 450f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith 451898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // Placeholder type for type-dependent expressions whose type is 452898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // completely unknown. No code should ever check a type against 453898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // DependentTy and users should never see it; however, it is here to 454898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // help diagnose failures to properly check for type-dependent 455898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // expressions. 456898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor InitBuiltinType(DependentTy, BuiltinType::Dependent); 4578e9bebdea69c590dedfbf27374114cb76fe12fbdDouglas Gregor 4582a984cad5ac3fdceeff2bd99daa7b90979313475John McCall // Placeholder type for functions. 4592a984cad5ac3fdceeff2bd99daa7b90979313475John McCall InitBuiltinType(OverloadTy, BuiltinType::Overload); 4602a984cad5ac3fdceeff2bd99daa7b90979313475John McCall 461864c041e118155c2b1ce0ba36942a3da5a4a055eJohn McCall // Placeholder type for bound members. 462864c041e118155c2b1ce0ba36942a3da5a4a055eJohn McCall InitBuiltinType(BoundMemberTy, BuiltinType::BoundMember); 463864c041e118155c2b1ce0ba36942a3da5a4a055eJohn McCall 4643c3b7f90a863af43fa63043d396553ecf205351cJohn McCall // Placeholder type for pseudo-objects. 4653c3b7f90a863af43fa63043d396553ecf205351cJohn McCall InitBuiltinType(PseudoObjectTy, BuiltinType::PseudoObject); 4663c3b7f90a863af43fa63043d396553ecf205351cJohn McCall 4671de4d4e8cb2e9c88809fea8092bc6e835a5473d2John McCall // "any" type; useful for debugger-like clients. 4681de4d4e8cb2e9c88809fea8092bc6e835a5473d2John McCall InitBuiltinType(UnknownAnyTy, BuiltinType::UnknownAny); 4691de4d4e8cb2e9c88809fea8092bc6e835a5473d2John McCall 4700ddaeb9b031070ec64afe92d9892875ac44df427John McCall // Placeholder type for unbridged ARC casts. 4710ddaeb9b031070ec64afe92d9892875ac44df427John McCall InitBuiltinType(ARCUnbridgedCastTy, BuiltinType::ARCUnbridgedCast); 4720ddaeb9b031070ec64afe92d9892875ac44df427John McCall 4735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p11. 4745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer FloatComplexTy = getComplexType(FloatTy); 4755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer DoubleComplexTy = getComplexType(DoubleTy); 4765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer LongDoubleComplexTy = getComplexType(LongDoubleTy); 4778e9bebdea69c590dedfbf27374114cb76fe12fbdDouglas Gregor 4787e219e47de26346885d667131977bd9ca2d7662aSteve Naroff BuiltinVaListType = QualType(); 4791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 48013dcd00615de5c4279d97bdf63cd5f0a14fd9dccFariborz Jahanian // Builtin types for 'id', 'Class', and 'SEL'. 481de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId); 482de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff InitBuiltinType(ObjCBuiltinClassTy, BuiltinType::ObjCClass); 48313dcd00615de5c4279d97bdf63cd5f0a14fd9dccFariborz Jahanian InitBuiltinType(ObjCBuiltinSelTy, BuiltinType::ObjCSel); 484ebcb57a8d298862c65043e88b2429591ab3c58d3Ted Kremenek 485ebcb57a8d298862c65043e88b2429591ab3c58d3Ted Kremenek // Builtin type for __objc_yes and __objc_no 48693a49944e0e68e32bc22d45d44ee136b34beffb3Fariborz Jahanian ObjCBuiltinBoolTy = (Target.useSignedCharForObjCBool() ? 48793a49944e0e68e32bc22d45d44ee136b34beffb3Fariborz Jahanian SignedCharTy : BoolTy); 488ebcb57a8d298862c65043e88b2429591ab3c58d3Ted Kremenek 489a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCConstantStringType = QualType(); 4901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 49133e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // void * type 49233e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian VoidPtrTy = getPointerType(VoidTy); 4936e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl 4946e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl // nullptr type (C++0x 2.14.7) 4956e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl InitBuiltinType(NullPtrTy, BuiltinType::NullPtr); 496aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov 497aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov // half type (OpenCL 6.1.1.1) / ARM NEON __fp16 498aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov InitBuiltinType(HalfTy, BuiltinType::Half); 4995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 5005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 501d6471f7c1921c7802804ce3ff6fe9768310f72b9David BlaikieDiagnosticsEngine &ASTContext::getDiagnostics() const { 50278a916ec5ff5b66adec3c499e1b9af7b87668309Argyrios Kyrtzidis return SourceMgr.getDiagnostics(); 50378a916ec5ff5b66adec3c499e1b9af7b87668309Argyrios Kyrtzidis} 50478a916ec5ff5b66adec3c499e1b9af7b87668309Argyrios Kyrtzidis 5056320064d0c60fa8683f5623881c9394fd4aa7689Douglas GregorAttrVec& ASTContext::getDeclAttrs(const Decl *D) { 5066320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor AttrVec *&Result = DeclAttrs[D]; 5076320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor if (!Result) { 5086320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor void *Mem = Allocate(sizeof(AttrVec)); 5096320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor Result = new (Mem) AttrVec; 5106320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor } 5116320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 5126320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor return *Result; 5136320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor} 5146320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 5156320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor/// \brief Erase the attributes corresponding to the given declaration. 5166320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregorvoid ASTContext::eraseDeclAttrs(const Decl *D) { 5176320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D); 5186320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor if (Pos != DeclAttrs.end()) { 5196320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor Pos->second->~AttrVec(); 5206320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor DeclAttrs.erase(Pos); 5216320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor } 5226320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor} 5236320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 524251b4ff2578e26959a4c036140ccd61c5e9292f2Douglas GregorMemberSpecializationInfo * 525663b5a0be7261c29bc4c526a71cffcfa02d4153eDouglas GregorASTContext::getInstantiatedFromStaticDataMember(const VarDecl *Var) { 5267caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor assert(Var->isStaticDataMember() && "Not a static data member"); 527663b5a0be7261c29bc4c526a71cffcfa02d4153eDouglas Gregor llvm::DenseMap<const VarDecl *, MemberSpecializationInfo *>::iterator Pos 5287caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor = InstantiatedFromStaticDataMember.find(Var); 5297caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor if (Pos == InstantiatedFromStaticDataMember.end()) 5307caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor return 0; 5311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5327caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor return Pos->second; 5337caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor} 5347caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor 5351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid 536251b4ff2578e26959a4c036140ccd61c5e9292f2Douglas GregorASTContext::setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl, 5379421adc43891e272156fab640e5d5ee5054b779cArgyrios Kyrtzidis TemplateSpecializationKind TSK, 5389421adc43891e272156fab640e5d5ee5054b779cArgyrios Kyrtzidis SourceLocation PointOfInstantiation) { 5397caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor assert(Inst->isStaticDataMember() && "Not a static data member"); 5407caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor assert(Tmpl->isStaticDataMember() && "Not a static data member"); 5417caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor assert(!InstantiatedFromStaticDataMember[Inst] && 5427caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor "Already noted what static data member was instantiated from"); 543251b4ff2578e26959a4c036140ccd61c5e9292f2Douglas Gregor InstantiatedFromStaticDataMember[Inst] 5449421adc43891e272156fab640e5d5ee5054b779cArgyrios Kyrtzidis = new (*this) MemberSpecializationInfo(Tmpl, TSK, PointOfInstantiation); 5457caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor} 5467caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor 547af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois PichetFunctionDecl *ASTContext::getClassScopeSpecializationPattern( 548af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet const FunctionDecl *FD){ 549af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet assert(FD && "Specialization is 0"); 550af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet llvm::DenseMap<const FunctionDecl*, FunctionDecl *>::const_iterator Pos 5510d95f0d7b81110f77e99e833f766d19be7b7e072Francois Pichet = ClassScopeSpecializationPattern.find(FD); 5520d95f0d7b81110f77e99e833f766d19be7b7e072Francois Pichet if (Pos == ClassScopeSpecializationPattern.end()) 553af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet return 0; 554af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet 555af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet return Pos->second; 556af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet} 557af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet 558af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichetvoid ASTContext::setClassScopeSpecializationPattern(FunctionDecl *FD, 559af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet FunctionDecl *Pattern) { 560af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet assert(FD && "Specialization is 0"); 561af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet assert(Pattern && "Class scope specialization pattern is 0"); 5620d95f0d7b81110f77e99e833f766d19be7b7e072Francois Pichet ClassScopeSpecializationPattern[FD] = Pattern; 563af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet} 564af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet 5657ba107a1863ddfa1664555854f0d7bdb3c491c92John McCallNamedDecl * 566ed97649e9574b9d854fa4d6109c9333ae0993554John McCallASTContext::getInstantiatedFromUsingDecl(UsingDecl *UUD) { 5677ba107a1863ddfa1664555854f0d7bdb3c491c92John McCall llvm::DenseMap<UsingDecl *, NamedDecl *>::const_iterator Pos 568ed97649e9574b9d854fa4d6109c9333ae0993554John McCall = InstantiatedFromUsingDecl.find(UUD); 569ed97649e9574b9d854fa4d6109c9333ae0993554John McCall if (Pos == InstantiatedFromUsingDecl.end()) 5700d8df780aef1acda5962347a32591efc629b6748Anders Carlsson return 0; 5711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5720d8df780aef1acda5962347a32591efc629b6748Anders Carlsson return Pos->second; 5730d8df780aef1acda5962347a32591efc629b6748Anders Carlsson} 5740d8df780aef1acda5962347a32591efc629b6748Anders Carlsson 5750d8df780aef1acda5962347a32591efc629b6748Anders Carlssonvoid 576ed97649e9574b9d854fa4d6109c9333ae0993554John McCallASTContext::setInstantiatedFromUsingDecl(UsingDecl *Inst, NamedDecl *Pattern) { 577ed97649e9574b9d854fa4d6109c9333ae0993554John McCall assert((isa<UsingDecl>(Pattern) || 578ed97649e9574b9d854fa4d6109c9333ae0993554John McCall isa<UnresolvedUsingValueDecl>(Pattern) || 579ed97649e9574b9d854fa4d6109c9333ae0993554John McCall isa<UnresolvedUsingTypenameDecl>(Pattern)) && 580ed97649e9574b9d854fa4d6109c9333ae0993554John McCall "pattern decl is not a using decl"); 581ed97649e9574b9d854fa4d6109c9333ae0993554John McCall assert(!InstantiatedFromUsingDecl[Inst] && "pattern already exists"); 582ed97649e9574b9d854fa4d6109c9333ae0993554John McCall InstantiatedFromUsingDecl[Inst] = Pattern; 583ed97649e9574b9d854fa4d6109c9333ae0993554John McCall} 584ed97649e9574b9d854fa4d6109c9333ae0993554John McCall 585ed97649e9574b9d854fa4d6109c9333ae0993554John McCallUsingShadowDecl * 586ed97649e9574b9d854fa4d6109c9333ae0993554John McCallASTContext::getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst) { 587ed97649e9574b9d854fa4d6109c9333ae0993554John McCall llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos 588ed97649e9574b9d854fa4d6109c9333ae0993554John McCall = InstantiatedFromUsingShadowDecl.find(Inst); 589ed97649e9574b9d854fa4d6109c9333ae0993554John McCall if (Pos == InstantiatedFromUsingShadowDecl.end()) 590ed97649e9574b9d854fa4d6109c9333ae0993554John McCall return 0; 591ed97649e9574b9d854fa4d6109c9333ae0993554John McCall 592ed97649e9574b9d854fa4d6109c9333ae0993554John McCall return Pos->second; 593ed97649e9574b9d854fa4d6109c9333ae0993554John McCall} 594ed97649e9574b9d854fa4d6109c9333ae0993554John McCall 595ed97649e9574b9d854fa4d6109c9333ae0993554John McCallvoid 596ed97649e9574b9d854fa4d6109c9333ae0993554John McCallASTContext::setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, 597ed97649e9574b9d854fa4d6109c9333ae0993554John McCall UsingShadowDecl *Pattern) { 598ed97649e9574b9d854fa4d6109c9333ae0993554John McCall assert(!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists"); 599ed97649e9574b9d854fa4d6109c9333ae0993554John McCall InstantiatedFromUsingShadowDecl[Inst] = Pattern; 6000d8df780aef1acda5962347a32591efc629b6748Anders Carlsson} 6010d8df780aef1acda5962347a32591efc629b6748Anders Carlsson 602d8b285fee4471f393da8ee30f552ceacdc362afaAnders CarlssonFieldDecl *ASTContext::getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) { 603d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos 604d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson = InstantiatedFromUnnamedFieldDecl.find(Field); 605d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson if (Pos == InstantiatedFromUnnamedFieldDecl.end()) 606d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson return 0; 6071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 608d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson return Pos->second; 609d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson} 610d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson 611d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlssonvoid ASTContext::setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, 612d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson FieldDecl *Tmpl) { 613d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson assert(!Inst->getDeclName() && "Instantiated field decl is not unnamed"); 614d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson assert(!Tmpl->getDeclName() && "Template field decl is not unnamed"); 615d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson assert(!InstantiatedFromUnnamedFieldDecl[Inst] && 616d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson "Already noted what unnamed field was instantiated from"); 6171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 618d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl; 619d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson} 620d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson 62114d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanianbool ASTContext::ZeroBitfieldFollowsNonBitfield(const FieldDecl *FD, 62214d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanian const FieldDecl *LastFD) const { 62314d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanian return (FD->isBitField() && LastFD && !LastFD->isBitField() && 624a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith FD->getBitWidthValue(*this) == 0); 62514d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanian} 62614d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanian 627340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanianbool ASTContext::ZeroBitfieldFollowsBitfield(const FieldDecl *FD, 628340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanian const FieldDecl *LastFD) const { 629340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanian return (FD->isBitField() && LastFD && LastFD->isBitField() && 630a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith FD->getBitWidthValue(*this) == 0 && 631a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith LastFD->getBitWidthValue(*this) != 0); 632340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanian} 633340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanian 6349b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanianbool ASTContext::BitfieldFollowsBitfield(const FieldDecl *FD, 6359b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanian const FieldDecl *LastFD) const { 6369b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanian return (FD->isBitField() && LastFD && LastFD->isBitField() && 637a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith FD->getBitWidthValue(*this) && 638a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith LastFD->getBitWidthValue(*this)); 6399b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanian} 6409b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanian 641dd7fddb5b6883326e52b278a9b7e9cefea29aae0Chad Rosierbool ASTContext::NonBitfieldFollowsBitfield(const FieldDecl *FD, 64252bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian const FieldDecl *LastFD) const { 64352bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian return (!FD->isBitField() && LastFD && LastFD->isBitField() && 644a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith LastFD->getBitWidthValue(*this)); 64552bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian} 64652bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian 647dd7fddb5b6883326e52b278a9b7e9cefea29aae0Chad Rosierbool ASTContext::BitfieldFollowsNonBitfield(const FieldDecl *FD, 64852bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian const FieldDecl *LastFD) const { 64952bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian return (FD->isBitField() && LastFD && !LastFD->isBitField() && 650a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith FD->getBitWidthValue(*this)); 65152bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian} 65252bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian 6537d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas GregorASTContext::overridden_cxx_method_iterator 6547d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas GregorASTContext::overridden_methods_begin(const CXXMethodDecl *Method) const { 6557d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 6567d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor = OverriddenMethods.find(Method); 6577d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor if (Pos == OverriddenMethods.end()) 6587d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor return 0; 6597d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 6607d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor return Pos->second.begin(); 6617d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor} 6627d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 6637d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas GregorASTContext::overridden_cxx_method_iterator 6647d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas GregorASTContext::overridden_methods_end(const CXXMethodDecl *Method) const { 6657d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 6667d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor = OverriddenMethods.find(Method); 6677d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor if (Pos == OverriddenMethods.end()) 6687d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor return 0; 6697d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 6707d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor return Pos->second.end(); 6717d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor} 6727d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 673c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidisunsigned 674c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios KyrtzidisASTContext::overridden_methods_size(const CXXMethodDecl *Method) const { 675c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 676c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis = OverriddenMethods.find(Method); 677c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis if (Pos == OverriddenMethods.end()) 678c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis return 0; 679c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis 680c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis return Pos->second.size(); 681c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis} 682c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis 6837d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregorvoid ASTContext::addOverriddenMethod(const CXXMethodDecl *Method, 6847d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor const CXXMethodDecl *Overridden) { 6857d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor OverriddenMethods[Method].push_back(Overridden); 6867d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor} 6877d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 688e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregorvoid ASTContext::addedLocalImportDecl(ImportDecl *Import) { 689e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor assert(!Import->NextLocalImport && "Import declaration already in the chain"); 690e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor assert(!Import->isFromASTFile() && "Non-local import declaration"); 691e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor if (!FirstLocalImport) { 692e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor FirstLocalImport = Import; 693e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor LastLocalImport = Import; 694e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor return; 695e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor } 696e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor 697e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor LastLocalImport->NextLocalImport = Import; 698e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor LastLocalImport = Import; 699e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor} 700e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor 701464175bba1318bef7905122e9fda20cff926df78Chris Lattner//===----------------------------------------------------------------------===// 702464175bba1318bef7905122e9fda20cff926df78Chris Lattner// Type Sizing and Analysis 703464175bba1318bef7905122e9fda20cff926df78Chris Lattner//===----------------------------------------------------------------------===// 704a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 705b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner/// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified 706b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner/// scalar floating point type. 707b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattnerconst llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const { 708183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const BuiltinType *BT = T->getAs<BuiltinType>(); 709b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner assert(BT && "Not a floating point type!"); 710b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner switch (BT->getKind()) { 711b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Not a floating point type!"); 712aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov case BuiltinType::Half: return Target->getHalfFormat(); 713bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor case BuiltinType::Float: return Target->getFloatFormat(); 714bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor case BuiltinType::Double: return Target->getDoubleFormat(); 715bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor case BuiltinType::LongDouble: return Target->getLongDoubleFormat(); 716b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner } 717b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner} 718b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner 7198b752f10c394b140f9ef89e049cbad1a7676fc25Ken Dyck/// getDeclAlign - Return a conservative estimate of the alignment of the 720af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner/// specified decl. Note that bitfields do not have a valid alignment, so 721af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner/// this method will assert on them. 7225d484e8cf710207010720589d89602233de61d01Sebastian Redl/// If @p RefAsPointee, references are treated like their underlying type 7235d484e8cf710207010720589d89602233de61d01Sebastian Redl/// (for alignof), else they're treated like pointers (for CodeGen). 7244ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getDeclAlign(const Decl *D, bool RefAsPointee) const { 725bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor unsigned Align = Target->getCharWidth(); 726dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman 7274081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall bool UseAlignAttrOnly = false; 7284081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall if (unsigned AlignFromAttr = D->getMaxAlignment()) { 7294081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall Align = AlignFromAttr; 7304081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall 7314081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // __attribute__((aligned)) can increase or decrease alignment 7324081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // *except* on a struct or struct member, where it only increases 7334081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // alignment unless 'packed' is also specified. 7344081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // 73582d0b0aab9088e977c2a44c4a5a90479c63149fePeter Collingbourne // It is an error for alignas to decrease alignment, so we can 7364081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // ignore that possibility; Sema should diagnose it. 7374081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall if (isa<FieldDecl>(D)) { 7384081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall UseAlignAttrOnly = D->hasAttr<PackedAttr>() || 7394081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>(); 7404081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall } else { 7414081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall UseAlignAttrOnly = true; 7424081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall } 7434081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall } 74478a7d7d79964119a3f35b262eb154b5cbf1001edFariborz Jahanian else if (isa<FieldDecl>(D)) 74578a7d7d79964119a3f35b262eb154b5cbf1001edFariborz Jahanian UseAlignAttrOnly = 74678a7d7d79964119a3f35b262eb154b5cbf1001edFariborz Jahanian D->hasAttr<PackedAttr>() || 74778a7d7d79964119a3f35b262eb154b5cbf1001edFariborz Jahanian cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>(); 748dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman 749ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // If we're using the align attribute only, just ignore everything 750ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // else about the declaration and its type. 7514081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall if (UseAlignAttrOnly) { 752ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // do nothing 753ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 7544081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall } else if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) { 755af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner QualType T = VD->getType(); 7566217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const ReferenceType* RT = T->getAs<ReferenceType>()) { 7575d484e8cf710207010720589d89602233de61d01Sebastian Redl if (RefAsPointee) 7585d484e8cf710207010720589d89602233de61d01Sebastian Redl T = RT->getPointeeType(); 7595d484e8cf710207010720589d89602233de61d01Sebastian Redl else 7605d484e8cf710207010720589d89602233de61d01Sebastian Redl T = getPointerType(RT->getPointeeType()); 7615d484e8cf710207010720589d89602233de61d01Sebastian Redl } 7625d484e8cf710207010720589d89602233de61d01Sebastian Redl if (!T->isIncompleteType() && !T->isFunctionType()) { 7633b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Adjust alignments of declarations with array type by the 7643b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // large-array alignment on the target. 765bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor unsigned MinWidth = Target->getLargeArrayMinWidth(); 7663b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall const ArrayType *arrayType; 7673b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (MinWidth && (arrayType = getAsArrayType(T))) { 7683b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (isa<VariableArrayType>(arrayType)) 769bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = std::max(Align, Target->getLargeArrayAlign()); 7703b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall else if (isa<ConstantArrayType>(arrayType) && 7713b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall MinWidth <= getTypeSize(cast<ConstantArrayType>(arrayType))) 772bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = std::max(Align, Target->getLargeArrayAlign()); 7733b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 7743b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Walk through any array types while we're at it. 7753b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall T = getBaseElementType(arrayType); 7766deecb0d46bcfd048e651d2db7c4fb0d6407da96Rafael Espindola } 7779f1210c3280104417a4ad30f0a00825ac8fa718aChad Rosier Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr())); 778dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman } 779ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 780ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // Fields can be subject to extra alignment constraints, like if 781ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // the field is packed, the struct is packed, or the struct has a 782ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // a max-field-alignment constraint (#pragma pack). So calculate 783ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // the actual alignment of the field within the struct, and then 784ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // (as we're expected to) constrain that by the alignment of the type. 785ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall if (const FieldDecl *field = dyn_cast<FieldDecl>(VD)) { 786ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // So calculate the alignment of the field. 787ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall const ASTRecordLayout &layout = getASTRecordLayout(field->getParent()); 788ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 789ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // Start with the record's overall alignment. 790dac54c124e302d6f028ea5723c425b7f66fc7c71Ken Dyck unsigned fieldAlign = toBits(layout.getAlignment()); 791ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 792ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // Use the GCD of that and the offset within the record. 793ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall uint64_t offset = layout.getFieldOffset(field->getFieldIndex()); 794ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall if (offset > 0) { 795ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // Alignment is always a power of 2, so the GCD will be a power of 2, 796ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // which means we get to do this crazy thing instead of Euclid's. 797ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall uint64_t lowBitOfOffset = offset & (~offset + 1); 798ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall if (lowBitOfOffset < fieldAlign) 799ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall fieldAlign = static_cast<unsigned>(lowBitOfOffset); 800ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall } 801ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 802ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall Align = std::min(Align, fieldAlign); 80305f62474dd2b0f1cb69adbe0787f2868788aa949Charles Davis } 804af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner } 805dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman 806eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(Align); 807af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner} 808b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner 809ea1471e0e967548c596a71469702f8846dbaf3c0John McCallstd::pair<CharUnits, CharUnits> 810bee5a79fc95e3003d755031e3d2bb4410a71e1c1Ken DyckASTContext::getTypeInfoInChars(const Type *T) const { 811ea1471e0e967548c596a71469702f8846dbaf3c0John McCall std::pair<uint64_t, unsigned> Info = getTypeInfo(T); 812eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return std::make_pair(toCharUnitsFromBits(Info.first), 813eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck toCharUnitsFromBits(Info.second)); 814ea1471e0e967548c596a71469702f8846dbaf3c0John McCall} 815ea1471e0e967548c596a71469702f8846dbaf3c0John McCall 816ea1471e0e967548c596a71469702f8846dbaf3c0John McCallstd::pair<CharUnits, CharUnits> 817bee5a79fc95e3003d755031e3d2bb4410a71e1c1Ken DyckASTContext::getTypeInfoInChars(QualType T) const { 818ea1471e0e967548c596a71469702f8846dbaf3c0John McCall return getTypeInfoInChars(T.getTypePtr()); 819ea1471e0e967548c596a71469702f8846dbaf3c0John McCall} 820ea1471e0e967548c596a71469702f8846dbaf3c0John McCall 821bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbarstd::pair<uint64_t, unsigned> ASTContext::getTypeInfo(const Type *T) const { 822bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar TypeInfoMap::iterator it = MemoizedTypeInfo.find(T); 823bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar if (it != MemoizedTypeInfo.end()) 824bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar return it->second; 825bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar 826bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar std::pair<uint64_t, unsigned> Info = getTypeInfoImpl(T); 827bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar MemoizedTypeInfo.insert(std::make_pair(T, Info)); 828bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar return Info; 829bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar} 830bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar 831bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar/// getTypeInfoImpl - Return the size of the specified type, in bits. This 832bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar/// method does not work on incomplete types. 8330953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// 8340953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// FIXME: Pointers into different addr spaces could have different sizes and 8350953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// alignment requirements: getPointerInfo should take an AddrSpace, this 8360953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// should take a QualType, &c. 837d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattnerstd::pair<uint64_t, unsigned> 838bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel DunbarASTContext::getTypeInfoImpl(const Type *T) const { 8395e301007e31e14c8ff647288e1b8bd8dbf8a5fe4Mike Stump uint64_t Width=0; 8405e301007e31e14c8ff647288e1b8bd8dbf8a5fe4Mike Stump unsigned Align=8; 841a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner switch (T->getTypeClass()) { 84272564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define TYPE(Class, Base) 84372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define ABSTRACT_TYPE(Class, Base) 84418857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor#define NON_CANONICAL_TYPE(Class, Base) 84572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define DEPENDENT_TYPE(Class, Base) case Type::Class: 84672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#include "clang/AST/TypeNodes.def" 847d3d49bb27c7ffd9accc0a6c00e887111c0348845John McCall llvm_unreachable("Should not see dependent types"); 84872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 8495d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner case Type::FunctionNoProto: 8505d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner case Type::FunctionProto: 85118857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor // GCC extension: alignof(function) = 32 bits 85218857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Width = 0; 85318857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Align = 32; 85418857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor break; 85518857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 85672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::IncompleteArray: 857fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case Type::VariableArray: 85818857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Width = 0; 85918857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Align = getTypeAlign(cast<ArrayType>(T)->getElementType()); 86018857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor break; 86118857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 862fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case Type::ConstantArray: { 8631d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const ConstantArrayType *CAT = cast<ConstantArrayType>(T); 8641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 86598be4943e8dc4f3905629a7102668960873cf863Chris Lattner std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(CAT->getElementType()); 866fea966a4103ed9c018d1494b95e9d09b161f5a70Abramo Bagnara uint64_t Size = CAT->getSize().getZExtValue(); 867bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar assert((Size == 0 || EltInfo.first <= (uint64_t)(-1)/Size) && 868bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar "Overflow in array type bit size evaluation"); 869fea966a4103ed9c018d1494b95e9d09b161f5a70Abramo Bagnara Width = EltInfo.first*Size; 870030d8846c7e520330007087e949f621989876e3aChris Lattner Align = EltInfo.second; 871cd88b4171753dcb2bc0a21d78f1597c796bb8a20Argyrios Kyrtzidis Width = llvm::RoundUpToAlignment(Width, Align); 872030d8846c7e520330007087e949f621989876e3aChris Lattner break; 8735c09a02a5db85e08a432b6eeced9aa656349710dChristopher Lamb } 874213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman case Type::ExtVector: 875030d8846c7e520330007087e949f621989876e3aChris Lattner case Type::Vector: { 8769fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner const VectorType *VT = cast<VectorType>(T); 8779fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(VT->getElementType()); 8789fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner Width = EltInfo.first*VT->getNumElements(); 8794bd998bbc228915d2b9cae5b67879de48940d05eEli Friedman Align = Width; 8806fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // If the alignment is not a power of 2, round up to the next power of 2. 8816fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // This happens for non-power-of-2 length vectors. 8828eefcd353c1d06a10104f69e5079ebab3183f9a3Dan Gohman if (Align & (Align-1)) { 8839fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner Align = llvm::NextPowerOf2(Align); 8849fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner Width = llvm::RoundUpToAlignment(Width, Align); 8859fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner } 886030d8846c7e520330007087e949f621989876e3aChris Lattner break; 887030d8846c7e520330007087e949f621989876e3aChris Lattner } 8885d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner 8899e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner case Type::Builtin: 890a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner switch (cast<BuiltinType>(T)->getKind()) { 891b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Unknown builtin type!"); 892d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::Void: 89318857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor // GCC extension: alignof(void) = 8 bits. 89418857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Width = 0; 89518857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Align = 8; 89618857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor break; 89718857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 8986f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Bool: 899bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getBoolWidth(); 900bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getBoolAlign(); 9016f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 902692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::Char_S: 903692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::Char_U: 904692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::UChar: 9056f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::SChar: 906bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getCharWidth(); 907bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getCharAlign(); 9086f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 9093f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_S: 9103f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_U: 911bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getWCharWidth(); 912bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getWCharAlign(); 91364c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis break; 914f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case BuiltinType::Char16: 915bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getChar16Width(); 916bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getChar16Align(); 917f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith break; 918f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case BuiltinType::Char32: 919bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getChar32Width(); 920bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getChar32Align(); 921f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith break; 922692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::UShort: 9236f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Short: 924bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getShortWidth(); 925bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getShortAlign(); 9266f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 927692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::UInt: 9286f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Int: 929bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getIntWidth(); 930bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getIntAlign(); 9316f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 932692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::ULong: 9336f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Long: 934bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getLongWidth(); 935bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getLongAlign(); 9366f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 937692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::ULongLong: 9386f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::LongLong: 939bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getLongLongWidth(); 940bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getLongLongAlign(); 9416f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 942ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner case BuiltinType::Int128: 943ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner case BuiltinType::UInt128: 944ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner Width = 128; 945ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner Align = 128; // int128_t is 128-bit aligned on all targets. 946ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner break; 947aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov case BuiltinType::Half: 948aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Width = Target->getHalfWidth(); 949aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Align = Target->getHalfAlign(); 950aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov break; 9516f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Float: 952bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getFloatWidth(); 953bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getFloatAlign(); 9546f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 9556f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Double: 956bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getDoubleWidth(); 957bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getDoubleAlign(); 9586f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 9596f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::LongDouble: 960bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getLongDoubleWidth(); 961bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getLongDoubleAlign(); 9626f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 9636e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl case BuiltinType::NullPtr: 964bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t) 965bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(0); // == sizeof(void*) 9661590d9c0fec4c710c2962e4bb71f76979b5163d3Sebastian Redl break; 967e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian case BuiltinType::ObjCId: 968e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian case BuiltinType::ObjCClass: 969e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian case BuiltinType::ObjCSel: 970bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(0); 971bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(0); 972e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian break; 973a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner } 974bfef6d7c67831a135d6ab79931f010f750a730adChris Lattner break; 975d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff case Type::ObjCObjectPointer: 976bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(0); 977bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(0); 9786f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 979485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff case Type::BlockPointer: { 980207f4d8543529221932af82836016a2ef066c917Peter Collingbourne unsigned AS = getTargetAddressSpace( 981207f4d8543529221932af82836016a2ef066c917Peter Collingbourne cast<BlockPointerType>(T)->getPointeeType()); 982bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(AS); 983bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(AS); 984485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff break; 985485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff } 9865d484e8cf710207010720589d89602233de61d01Sebastian Redl case Type::LValueReference: 9875d484e8cf710207010720589d89602233de61d01Sebastian Redl case Type::RValueReference: { 9885d484e8cf710207010720589d89602233de61d01Sebastian Redl // alignof and sizeof should never enter this code path here, so we go 9895d484e8cf710207010720589d89602233de61d01Sebastian Redl // the pointer route. 990207f4d8543529221932af82836016a2ef066c917Peter Collingbourne unsigned AS = getTargetAddressSpace( 991207f4d8543529221932af82836016a2ef066c917Peter Collingbourne cast<ReferenceType>(T)->getPointeeType()); 992bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(AS); 993bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(AS); 9945d484e8cf710207010720589d89602233de61d01Sebastian Redl break; 9955d484e8cf710207010720589d89602233de61d01Sebastian Redl } 996f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner case Type::Pointer: { 997207f4d8543529221932af82836016a2ef066c917Peter Collingbourne unsigned AS = getTargetAddressSpace(cast<PointerType>(T)->getPointeeType()); 998bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(AS); 999bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(AS); 1000f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner break; 1001f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner } 1002f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl case Type::MemberPointer: { 1003071cc7deffad608165b1ddd5263e8bf181861520Charles Davis const MemberPointerType *MPT = cast<MemberPointerType>(T); 10041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump std::pair<uint64_t, unsigned> PtrDiffInfo = 10051cca74ef3627a3a0ab14501d23e336548f6611b2Anders Carlsson getTypeInfo(getPointerDiffType()); 1006071cc7deffad608165b1ddd5263e8bf181861520Charles Davis Width = PtrDiffInfo.first * ABI->getMemberPointerSize(MPT); 10071cca74ef3627a3a0ab14501d23e336548f6611b2Anders Carlsson Align = PtrDiffInfo.second; 10081cca74ef3627a3a0ab14501d23e336548f6611b2Anders Carlsson break; 1009f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl } 10105d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner case Type::Complex: { 10115d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner // Complex types have the same alignment as their elements, but twice the 10125d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner // size. 10131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump std::pair<uint64_t, unsigned> EltInfo = 101498be4943e8dc4f3905629a7102668960873cf863Chris Lattner getTypeInfo(cast<ComplexType>(T)->getElementType()); 10159e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner Width = EltInfo.first*2; 10165d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner Align = EltInfo.second; 10175d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner break; 10185d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner } 1019c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCObject: 1020c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return getTypeInfo(cast<ObjCObjectType>(T)->getBaseType().getTypePtr()); 102144a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel case Type::ObjCInterface: { 10221d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const ObjCInterfaceType *ObjCI = cast<ObjCInterfaceType>(T); 102344a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl()); 1024dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck Width = toBits(Layout.getSize()); 1025dac54c124e302d6f028ea5723c425b7f66fc7c71Ken Dyck Align = toBits(Layout.getAlignment()); 102644a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel break; 102744a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel } 102872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Record: 102972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Enum: { 10301d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const TagType *TT = cast<TagType>(T); 10311d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar 10321d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar if (TT->getDecl()->isInvalidDecl()) { 103322ce41d9fc8509da65858c75bf5b3c4dae2d8c04Douglas Gregor Width = 8; 103422ce41d9fc8509da65858c75bf5b3c4dae2d8c04Douglas Gregor Align = 8; 10358389eab190afef3462f6418b8d8fb70fb01c4005Chris Lattner break; 10368389eab190afef3462f6418b8d8fb70fb01c4005Chris Lattner } 10371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10381d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar if (const EnumType *ET = dyn_cast<EnumType>(TT)) 10397176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner return getTypeInfo(ET->getDecl()->getIntegerType()); 10407176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner 10411d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const RecordType *RT = cast<RecordType>(TT); 10427176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner const ASTRecordLayout &Layout = getASTRecordLayout(RT->getDecl()); 1043dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck Width = toBits(Layout.getSize()); 1044dac54c124e302d6f028ea5723c425b7f66fc7c71Ken Dyck Align = toBits(Layout.getAlignment()); 1045dc0d73e6495404418acf8548875aeaff07791a74Chris Lattner break; 1046a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner } 10477532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 10489fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner case Type::SubstTemplateTypeParm: 104949a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall return getTypeInfo(cast<SubstTemplateTypeParmType>(T)-> 105049a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall getReplacementType().getTypePtr()); 105149a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 105234b41d939a1328f484511c6002ba2456db879a29Richard Smith case Type::Auto: { 105334b41d939a1328f484511c6002ba2456db879a29Richard Smith const AutoType *A = cast<AutoType>(T); 105434b41d939a1328f484511c6002ba2456db879a29Richard Smith assert(A->isDeduced() && "Cannot request the size of a dependent type"); 1055dc856aff4428380baa9afb5577ea04f8fb6beb13Matt Beaumont-Gay return getTypeInfo(A->getDeducedType().getTypePtr()); 105634b41d939a1328f484511c6002ba2456db879a29Richard Smith } 105734b41d939a1328f484511c6002ba2456db879a29Richard Smith 1058075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara case Type::Paren: 1059075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return getTypeInfo(cast<ParenType>(T)->getInnerType().getTypePtr()); 1060075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 106118857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor case Type::Typedef: { 1062162e1c1b487352434552147967c3dd296ebee2f7Richard Smith const TypedefNameDecl *Typedef = cast<TypedefType>(T)->getDecl(); 1063df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor std::pair<uint64_t, unsigned> Info 1064df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor = getTypeInfo(Typedef->getUnderlyingType().getTypePtr()); 1065c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner // If the typedef has an aligned attribute on it, it overrides any computed 1066c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner // alignment we have. This violates the GCC documentation (which says that 1067c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner // attribute(aligned) can only round up) but matches its implementation. 1068c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner if (unsigned AttrAlign = Typedef->getMaxAlignment()) 1069c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner Align = AttrAlign; 1070c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner else 1071c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner Align = Info.second; 1072df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor Width = Info.first; 10737532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor break; 10747176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner } 107518857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 107618857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor case Type::TypeOfExpr: 107718857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor return getTypeInfo(cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType() 107818857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor .getTypePtr()); 107918857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 108018857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor case Type::TypeOf: 108118857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor return getTypeInfo(cast<TypeOfType>(T)->getUnderlyingType().getTypePtr()); 108218857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 1083395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson case Type::Decltype: 1084395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson return getTypeInfo(cast<DecltypeType>(T)->getUnderlyingExpr()->getType() 1085395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson .getTypePtr()); 1086395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson 1087ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt case Type::UnaryTransform: 1088ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt return getTypeInfo(cast<UnaryTransformType>(T)->getUnderlyingType()); 1089ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt 1090465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara case Type::Elaborated: 1091465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr()); 10921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10939d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall case Type::Attributed: 10949d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall return getTypeInfo( 10959d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall cast<AttributedType>(T)->getEquivalentType().getTypePtr()); 10969d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 10973e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith case Type::TemplateSpecialization: { 10981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(getCanonicalType(T) != T && 109918857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor "Cannot request the size of a dependent type"); 11003e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith const TemplateSpecializationType *TST = cast<TemplateSpecializationType>(T); 11013e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith // A type alias template specialization may refer to a typedef with the 11023e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith // aligned attribute on it. 11033e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith if (TST->isTypeAlias()) 11043e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith return getTypeInfo(TST->getAliasedType().getTypePtr()); 11053e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith else 11063e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith return getTypeInfo(getCanonicalType(T)); 11073e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith } 11083e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith 1109b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: { 11102be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman std::pair<uint64_t, unsigned> Info 11112be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman = getTypeInfo(cast<AtomicType>(T)->getValueType()); 11122be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman Width = Info.first; 11132be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman Align = Info.second; 11142be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman if (Width != 0 && Width <= Target->getMaxAtomicPromoteWidth() && 11152be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman llvm::isPowerOf2_64(Width)) { 11162be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // We can potentially perform lock-free atomic operations for this 11172be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // type; promote the alignment appropriately. 11182be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // FIXME: We could potentially promote the width here as well... 11192be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // is that worthwhile? (Non-struct atomic types generally have 11202be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // power-of-two size anyway, but structs might not. Requires a bit 11212be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // of implementation work to make sure we zero out the extra bits.) 11222be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman Align = static_cast<unsigned>(Width); 11232be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman } 1124b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 1125b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 112618857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor } 11271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11282be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman assert(llvm::isPowerOf2_32(Align) && "Alignment must be power of 2"); 11299e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner return std::make_pair(Width, Align); 1130a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner} 1131a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 1132eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck/// toCharUnitsFromBits - Convert a size in bits to a size in characters. 1133eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen DyckCharUnits ASTContext::toCharUnitsFromBits(int64_t BitSize) const { 1134eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return CharUnits::fromQuantity(BitSize / getCharWidth()); 1135eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck} 1136eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck 1137dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck/// toBits - Convert a size in characters to a size in characters. 1138dd76a9ab9ea675671200f94b18ce95766841952bKen Dyckint64_t ASTContext::toBits(CharUnits CharSize) const { 1139dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck return CharSize.getQuantity() * getCharWidth(); 1140dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck} 1141dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck 1142bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck/// getTypeSizeInChars - Return the size of the specified type, in characters. 1143bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck/// This method does not work on incomplete types. 11444ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeSizeInChars(QualType T) const { 1145eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeSize(T)); 1146bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck} 11474ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeSizeInChars(const Type *T) const { 1148eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeSize(T)); 1149bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck} 1150bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck 115116e20cce43385001f33f8e3f90ee345609c805d1Ken Dyck/// getTypeAlignInChars - Return the ABI-specified alignment of a type, in 115286fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck/// characters. This method does not work on incomplete types. 11534ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeAlignInChars(QualType T) const { 1154eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeAlign(T)); 115586fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck} 11564ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeAlignInChars(const Type *T) const { 1157eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeAlign(T)); 115886fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck} 115986fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck 116034ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// getPreferredTypeAlign - Return the "preferred" alignment of the specified 116134ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// type for the current target in bits. This can be different than the ABI 116234ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// alignment in cases where it is beneficial for performance to overalign 116334ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// a data type. 11644ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadunsigned ASTContext::getPreferredTypeAlign(const Type *T) const { 116534ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner unsigned ABIAlign = getTypeAlign(T); 11661eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman 11671eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman // Double and long long should be naturally aligned if possible. 1168183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ComplexType* CT = T->getAs<ComplexType>()) 11691eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman T = CT->getElementType().getTypePtr(); 11701eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman if (T->isSpecificBuiltinType(BuiltinType::Double) || 1171cde7a1dc68af2eb063a039b5a31c3b7dd92b1aa9Chad Rosier T->isSpecificBuiltinType(BuiltinType::LongLong) || 1172cde7a1dc68af2eb063a039b5a31c3b7dd92b1aa9Chad Rosier T->isSpecificBuiltinType(BuiltinType::ULongLong)) 11731eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman return std::max(ABIAlign, (unsigned)getTypeSize(T)); 11741eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman 117534ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner return ABIAlign; 117634ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner} 117734ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner 11782c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// DeepCollectObjCIvars - 11792c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// This routine first collects all declared, but not synthesized, ivars in 11802c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// super class and then collects all ivars, including those synthesized for 11812c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// current class. This routine is used for implementation of current class 11822c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// when all ivars, declared and synthesized are known. 11839820074dd47d37681085e964cd3392ac0b3e67b9Fariborz Jahanian/// 11842c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanianvoid ASTContext::DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, 11852c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian bool leafClass, 1186db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const { 11872c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass()) 11882c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian DeepCollectObjCIvars(SuperClass, false, Ivars); 11892c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian if (!leafClass) { 11902c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(), 11912c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian E = OI->ivar_end(); I != E; ++I) 1192262bc18e32500558af7cb0afa205b34bd37bafedDavid Blaikie Ivars.push_back(&*I); 11933060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 1194bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian ObjCInterfaceDecl *IDecl = const_cast<ObjCInterfaceDecl *>(OI); 1195db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose for (const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv; 1196bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian Iv= Iv->getNextIvar()) 1197bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian Ivars.push_back(Iv); 1198bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian } 11999820074dd47d37681085e964cd3392ac0b3e67b9Fariborz Jahanian} 12009820074dd47d37681085e964cd3392ac0b3e67b9Fariborz Jahanian 1201e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// CollectInheritedProtocols - Collect all protocols in current class and 1202e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// those inherited by it. 1203e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanianvoid ASTContext::CollectInheritedProtocols(const Decl *CDecl, 1204432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) { 1205e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (const ObjCInterfaceDecl *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) { 120653b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek // We can use protocol_iterator here instead of 120753b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek // all_referenced_protocol_iterator since we are walking all categories. 120853b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek for (ObjCInterfaceDecl::all_protocol_iterator P = OI->all_referenced_protocol_begin(), 120953b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek PE = OI->all_referenced_protocol_end(); P != PE; ++P) { 1210e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian ObjCProtocolDecl *Proto = (*P); 12113fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert(Proto->getCanonicalDecl()); 1212e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 1213b2f812165676230bce5d0215e49a4749c451ca9cFariborz Jahanian PE = Proto->protocol_end(); P != PE; ++P) { 12143fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert((*P)->getCanonicalDecl()); 1215e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(*P, Protocols); 1216e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1217b2f812165676230bce5d0215e49a4749c451ca9cFariborz Jahanian } 1218e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 1219e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian // Categories of this Interface. 1220e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (const ObjCCategoryDecl *CDeclChain = OI->getCategoryList(); 1221e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CDeclChain; CDeclChain = CDeclChain->getNextClassCategory()) 1222e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(CDeclChain, Protocols); 1223e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (ObjCInterfaceDecl *SD = OI->getSuperClass()) 1224e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian while (SD) { 1225e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(SD, Protocols); 1226e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian SD = SD->getSuperClass(); 1227e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1228b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer } else if (const ObjCCategoryDecl *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) { 122953b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek for (ObjCCategoryDecl::protocol_iterator P = OC->protocol_begin(), 1230e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = OC->protocol_end(); P != PE; ++P) { 1231e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian ObjCProtocolDecl *Proto = (*P); 12323fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert(Proto->getCanonicalDecl()); 1233e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 1234e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = Proto->protocol_end(); P != PE; ++P) 1235e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(*P, Protocols); 1236e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1237b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer } else if (const ObjCProtocolDecl *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) { 1238e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = OP->protocol_begin(), 1239e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = OP->protocol_end(); P != PE; ++P) { 1240e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian ObjCProtocolDecl *Proto = (*P); 12413fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert(Proto->getCanonicalDecl()); 1242e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 1243e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = Proto->protocol_end(); P != PE; ++P) 1244e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(*P, Protocols); 1245e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1246e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1247e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian} 1248e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 12494ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadunsigned ASTContext::CountNonClassIvars(const ObjCInterfaceDecl *OI) const { 12503bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian unsigned count = 0; 12513bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian // Count ivars declared in class extension. 125280aa1cd7973561889e51c1c152c8990a8de9c953Fariborz Jahanian for (const ObjCCategoryDecl *CDecl = OI->getFirstClassExtension(); CDecl; 125380aa1cd7973561889e51c1c152c8990a8de9c953Fariborz Jahanian CDecl = CDecl->getNextClassExtension()) 1254b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer count += CDecl->ivar_size(); 1255b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer 12563bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian // Count ivar defined in this class's implementation. This 12573bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian // includes synthesized ivars. 12583bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian if (ObjCImplementationDecl *ImplDecl = OI->getImplementation()) 1259b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer count += ImplDecl->ivar_size(); 1260b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer 12618e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian return count; 12628e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian} 12638e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian 12648deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidisbool ASTContext::isSentinelNullExpr(const Expr *E) { 12658deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis if (!E) 12668deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis return false; 12678deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12688deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis // nullptr_t is always treated as null. 12698deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis if (E->getType()->isNullPtrType()) return true; 12708deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12718deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis if (E->getType()->isAnyPointerType() && 12728deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis E->IgnoreParenCasts()->isNullPointerConstant(*this, 12738deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis Expr::NPC_ValueDependentIsNull)) 12748deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis return true; 12758deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12768deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis // Unfortunately, __null has type 'int'. 12778deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis if (isa<GNUNullExpr>(E)) return true; 12788deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12798deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis return false; 12808deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis} 12818deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12828a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Get the implementation of ObjCInterfaceDecl,or NULL if none exists. 12838a1d722f13df383600f36d77f842957c8adb5f1bArgyrios KyrtzidisObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) { 12848a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator 12858a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis I = ObjCImpls.find(D); 12868a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis if (I != ObjCImpls.end()) 12878a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return cast<ObjCImplementationDecl>(I->second); 12888a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return 0; 12898a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 12908a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Get the implementation of ObjCCategoryDecl, or NULL if none exists. 12918a1d722f13df383600f36d77f842957c8adb5f1bArgyrios KyrtzidisObjCCategoryImplDecl *ASTContext::getObjCImplementation(ObjCCategoryDecl *D) { 12928a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator 12938a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis I = ObjCImpls.find(D); 12948a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis if (I != ObjCImpls.end()) 12958a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return cast<ObjCCategoryImplDecl>(I->second); 12968a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return 0; 12978a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 12988a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis 12998a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Set the implementation of ObjCInterfaceDecl. 13008a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidisvoid ASTContext::setObjCImplementation(ObjCInterfaceDecl *IFaceD, 13018a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCImplementationDecl *ImplD) { 13028a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis assert(IFaceD && ImplD && "Passed null params"); 13038a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCImpls[IFaceD] = ImplD; 13048a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 13058a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Set the implementation of ObjCCategoryDecl. 13068a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidisvoid ASTContext::setObjCImplementation(ObjCCategoryDecl *CatD, 13078a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCCategoryImplDecl *ImplD) { 13088a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis assert(CatD && ImplD && "Passed null params"); 13098a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCImpls[CatD] = ImplD; 13108a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 13118a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis 131287ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios KyrtzidisObjCInterfaceDecl *ASTContext::getObjContainingInterface(NamedDecl *ND) const { 131387ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(ND->getDeclContext())) 131487ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return ID; 131587ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(ND->getDeclContext())) 131687ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return CD->getClassInterface(); 131787ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis if (ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(ND->getDeclContext())) 131887ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return IMD->getClassInterface(); 131987ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis 132087ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return 0; 132187ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis} 132287ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis 13231ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian/// \brief Get the copy initialization expression of VarDecl,or NULL if 13241ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian/// none exists. 1325830937bc1100fba7682f7c32c40512085870f50cFariborz JahanianExpr *ASTContext::getBlockVarCopyInits(const VarDecl*VD) { 1326d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian assert(VD && "Passed null params"); 1327d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian assert(VD->hasAttr<BlocksAttr>() && 1328d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian "getBlockVarCopyInits - not __block var"); 1329830937bc1100fba7682f7c32c40512085870f50cFariborz Jahanian llvm::DenseMap<const VarDecl*, Expr*>::iterator 1330d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian I = BlockVarCopyInits.find(VD); 13311ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian return (I != BlockVarCopyInits.end()) ? cast<Expr>(I->second) : 0; 13321ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian} 13331ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian 13341ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian/// \brief Set the copy inialization expression of a block var decl. 13351ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanianvoid ASTContext::setBlockVarCopyInits(VarDecl*VD, Expr* Init) { 13361ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian assert(VD && Init && "Passed null params"); 1337d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian assert(VD->hasAttr<BlocksAttr>() && 1338d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian "setBlockVarCopyInits - not __block var"); 13391ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian BlockVarCopyInits[VD] = Init; 13401ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian} 13411ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian 1342a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall/// \brief Allocate an uninitialized TypeSourceInfo. 1343b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// 1344a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall/// The caller should initialize the memory held by TypeSourceInfo using 1345b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// the TypeLoc wrappers. 1346b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// 1347b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// \param T the type that will be the basis for type source info. This type 1348b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// should refer to how the declarator was written in source code, not to 1349b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// what type semantic analysis resolved the declarator to. 1350a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCallTypeSourceInfo *ASTContext::CreateTypeSourceInfo(QualType T, 13514ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned DataSize) const { 1352109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall if (!DataSize) 1353109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall DataSize = TypeLoc::getFullDataSizeForType(T); 1354109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall else 1355109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall assert(DataSize == TypeLoc::getFullDataSizeForType(T) && 1356a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall "incorrect data size provided to CreateTypeSourceInfo!"); 1357109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall 1358a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall TypeSourceInfo *TInfo = 1359a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall (TypeSourceInfo*)BumpAlloc.Allocate(sizeof(TypeSourceInfo) + DataSize, 8); 1360a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall new (TInfo) TypeSourceInfo(T); 1361a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall return TInfo; 1362b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis} 1363b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis 1364a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCallTypeSourceInfo *ASTContext::getTrivialTypeSourceInfo(QualType T, 13656952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor SourceLocation L) const { 1366a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall TypeSourceInfo *DI = CreateTypeSourceInfo(T); 1367c21c7e9c2cded68f91be15be6847c9649242dc17Douglas Gregor DI->getTypeLoc().initialize(const_cast<ASTContext &>(*this), L); 1368a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall return DI; 1369a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall} 1370a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall 1371b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbarconst ASTRecordLayout & 13724ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const { 1373b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar return getObjCLayout(D, 0); 1374b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar} 1375b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar 1376b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbarconst ASTRecordLayout & 13774ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getASTObjCImplementationLayout( 13784ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const ObjCImplementationDecl *D) const { 1379b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar return getObjCLayout(D->getClassInterface(), D); 1380b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar} 1381b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar 1382a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner//===----------------------------------------------------------------------===// 1383a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner// Type creation/memoization methods 1384a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner//===----------------------------------------------------------------------===// 1385a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 13864ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 13873b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallASTContext::getExtQualType(const Type *baseType, Qualifiers quals) const { 13883b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall unsigned fastQuals = quals.getFastQualifiers(); 13893b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall quals.removeFastQualifiers(); 13900953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 13910953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Check if we've already instantiated this type. 13920953e767ff7817f97b3ab20896b229891eeff45bJohn McCall llvm::FoldingSetNodeID ID; 13933b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ExtQuals::Profile(ID, baseType, quals); 13943b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall void *insertPos = 0; 13953b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (ExtQuals *eq = ExtQualNodes.FindNodeOrInsertPos(ID, insertPos)) { 13963b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert(eq->getQualifiers() == quals); 13973b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(eq, fastQuals); 13980953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 13990953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 14003b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If the base type is not canonical, make the appropriate canonical type. 14013b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType canon; 14023b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!baseType->isCanonicalUnqualified()) { 14033b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = baseType->getCanonicalTypeInternal().split(); 1404200fa53fd420aa8369586f569dbece04930ad6a3John McCall canonSplit.Quals.addConsistentQualifiers(quals); 1405200fa53fd420aa8369586f569dbece04930ad6a3John McCall canon = getExtQualType(canonSplit.Ty, canonSplit.Quals); 14063b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 14073b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Re-find the insert position. 14083b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos); 14093b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall } 14103b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 14113b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ExtQuals *eq = new (*this, TypeAlignment) ExtQuals(baseType, canon, quals); 14123b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ExtQualNodes.InsertNode(eq, insertPos); 14133b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(eq, fastQuals); 14140953e767ff7817f97b3ab20896b229891eeff45bJohn McCall} 14150953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 14164ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 14174ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getAddrSpaceQualType(QualType T, unsigned AddressSpace) const { 1418f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner QualType CanT = getCanonicalType(T); 1419f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner if (CanT.getAddressSpace() == AddressSpace) 1420f46699ce225811d8d9dbab9d00189a0e54469457Chris Lattner return T; 1421b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris Lattner 14220953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If we are composing extended qualifiers together, merge together 14230953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // into one ExtQuals node. 14240953e767ff7817f97b3ab20896b229891eeff45bJohn McCall QualifierCollector Quals; 14250953e767ff7817f97b3ab20896b229891eeff45bJohn McCall const Type *TypeNode = Quals.strip(T); 14261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14270953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If this type already has an address space specified, it cannot get 14280953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // another one. 14290953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert(!Quals.hasAddressSpace() && 14300953e767ff7817f97b3ab20896b229891eeff45bJohn McCall "Type cannot be in multiple addr spaces!"); 14310953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Quals.addAddressSpace(AddressSpace); 14321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14330953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return getExtQualType(TypeNode, Quals); 1434ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb} 1435ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb 1436b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris LattnerQualType ASTContext::getObjCGCQualType(QualType T, 14374ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Qualifiers::GC GCAttr) const { 1438d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian QualType CanT = getCanonicalType(T); 1439b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris Lattner if (CanT.getObjCGCAttr() == GCAttr) 1440d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian return T; 14411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14427f040a9d817cd1c72b565e92abff473510bf9e1dJohn McCall if (const PointerType *ptr = T->getAs<PointerType>()) { 14437f040a9d817cd1c72b565e92abff473510bf9e1dJohn McCall QualType Pointee = ptr->getPointeeType(); 144458f9f2c884af6b72d036b746a016d8031d31cb7aSteve Naroff if (Pointee->isAnyPointerType()) { 14454027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian QualType ResultType = getObjCGCQualType(Pointee, GCAttr); 14464027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian return getPointerType(ResultType); 14474027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian } 14484027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian } 14491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14500953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If we are composing extended qualifiers together, merge together 14510953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // into one ExtQuals node. 14520953e767ff7817f97b3ab20896b229891eeff45bJohn McCall QualifierCollector Quals; 14530953e767ff7817f97b3ab20896b229891eeff45bJohn McCall const Type *TypeNode = Quals.strip(T); 14541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14550953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If this type already has an ObjCGC specified, it cannot get 14560953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // another one. 14570953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert(!Quals.hasObjCGCAttr() && 14580953e767ff7817f97b3ab20896b229891eeff45bJohn McCall "Type cannot have multiple ObjCGCs!"); 14590953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Quals.addObjCGCAttr(GCAttr); 14601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14610953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return getExtQualType(TypeNode, Quals); 1462d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian} 1463a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 1464e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCallconst FunctionType *ASTContext::adjustFunctionType(const FunctionType *T, 1465e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall FunctionType::ExtInfo Info) { 1466e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall if (T->getExtInfo() == Info) 1467e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall return T; 1468e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 1469e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall QualType Result; 1470e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall if (const FunctionNoProtoType *FNPT = dyn_cast<FunctionNoProtoType>(T)) { 1471e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall Result = getFunctionNoProtoType(FNPT->getResultType(), Info); 1472e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall } else { 1473e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall const FunctionProtoType *FPT = cast<FunctionProtoType>(T); 1474e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 1475e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall EPI.ExtInfo = Info; 1476e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall Result = getFunctionType(FPT->getResultType(), FPT->arg_type_begin(), 1477e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall FPT->getNumArgs(), EPI); 1478e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall } 1479e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 1480e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall return cast<FunctionType>(Result.getTypePtr()); 1481e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall} 1482e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 14835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getComplexType - Return the uniqued reference to the type for a complex 14845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// number with the specified element type. 14854ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getComplexType(QualType T) const { 14865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique pointers, to guarantee there is only one pointer of a particular 14875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 14885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 14895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ComplexType::Profile(ID, T); 14901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 14925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos)) 14935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(CT, 0); 14941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the pointee type isn't canonical, this won't be a canonical type either, 14965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // so fill in the canonical type field. 14975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 1498467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!T.isCanonical()) { 1499f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner Canonical = getComplexType(getCanonicalType(T)); 15001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 15025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos); 1503c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 15045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 15056b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ComplexType *New = new (*this, TypeAlignment) ComplexType(T, Canonical); 15065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 15075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ComplexTypes.InsertNode(New, InsertPos); 15085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 15095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 15105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 15115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getPointerType - Return the uniqued reference to the type for a pointer to 15125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// the specified type. 15134ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getPointerType(QualType T) const { 15145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique pointers, to guarantee there is only one pointer of a particular 15155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 15165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 15175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PointerType::Profile(ID, T); 15181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 15205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 15215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(PT, 0); 15221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the pointee type isn't canonical, this won't be a canonical type either, 15245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // so fill in the canonical type field. 15255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 1526467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!T.isCanonical()) { 1527f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner Canonical = getPointerType(getCanonicalType(T)); 15281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 15305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1531c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 15325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 15336b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall PointerType *New = new (*this, TypeAlignment) PointerType(T, Canonical); 15345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 15355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PointerTypes.InsertNode(New, InsertPos); 15365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 15375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 15385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 15391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getBlockPointerType - Return the uniqued reference to the type for 15405618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff/// a pointer to the specified block. 15414ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getBlockPointerType(QualType T) const { 1542296e8d5fdcf9946f51e866adc8d281379e51efe9Steve Naroff assert(T->isFunctionType() && "block of function types only"); 1543296e8d5fdcf9946f51e866adc8d281379e51efe9Steve Naroff // Unique pointers, to guarantee there is only one block of a particular 15445618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // structure. 15455618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff llvm::FoldingSetNodeID ID; 15465618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerType::Profile(ID, T); 15471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15485618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff void *InsertPos = 0; 15495618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff if (BlockPointerType *PT = 15505618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 15515618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff return QualType(PT, 0); 15521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the block pointee type isn't canonical, this won't be a canonical 15545618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // type either so fill in the canonical type field. 15555618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff QualType Canonical; 1556467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!T.isCanonical()) { 15575618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff Canonical = getBlockPointerType(getCanonicalType(T)); 15581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15595618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // Get the new insert position for the node we care about. 15605618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerType *NewIP = 15615618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1562c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 15635618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff } 15646b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall BlockPointerType *New 15656b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) BlockPointerType(T, Canonical); 15665618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff Types.push_back(New); 15675618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerTypes.InsertNode(New, InsertPos); 15685618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff return QualType(New, 0); 15695618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff} 15705618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff 15717c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// getLValueReferenceType - Return the uniqued reference to the type for an 15727c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// lvalue reference to the specified type. 15734ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 15744ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getLValueReferenceType(QualType T, bool SpelledAsLValue) const { 15759625e44c0252485277a340746ed8ac950686156fDouglas Gregor assert(getCanonicalType(T) != OverloadTy && 15769625e44c0252485277a340746ed8ac950686156fDouglas Gregor "Unresolved overloaded function type"); 15779625e44c0252485277a340746ed8ac950686156fDouglas Gregor 15785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique pointers, to guarantee there is only one pointer of a particular 15795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 15805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 158154e14c4db764c0636160d26c5bbf491637c83a76John McCall ReferenceType::Profile(ID, T, SpelledAsLValue); 15825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 15835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 15847c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl if (LValueReferenceType *RT = 15857c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 15865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(RT, 0); 15877c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 158854e14c4db764c0636160d26c5bbf491637c83a76John McCall const ReferenceType *InnerRef = T->getAs<ReferenceType>(); 158954e14c4db764c0636160d26c5bbf491637c83a76John McCall 15905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the referencee type isn't canonical, this won't be a canonical type 15915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // either, so fill in the canonical type field. 15925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 159354e14c4db764c0636160d26c5bbf491637c83a76John McCall if (!SpelledAsLValue || InnerRef || !T.isCanonical()) { 159454e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T); 159554e14c4db764c0636160d26c5bbf491637c83a76John McCall Canonical = getLValueReferenceType(getCanonicalType(PointeeType)); 15967c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 15977c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // Get the new insert position for the node we care about. 15987c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceType *NewIP = 15997c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 1600c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 16017c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl } 16027c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 16036b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall LValueReferenceType *New 160454e14c4db764c0636160d26c5bbf491637c83a76John McCall = new (*this, TypeAlignment) LValueReferenceType(T, Canonical, 160554e14c4db764c0636160d26c5bbf491637c83a76John McCall SpelledAsLValue); 16067c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl Types.push_back(New); 16077c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceTypes.InsertNode(New, InsertPos); 160854e14c4db764c0636160d26c5bbf491637c83a76John McCall 16097c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl return QualType(New, 0); 16107c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl} 16117c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 16127c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// getRValueReferenceType - Return the uniqued reference to the type for an 16137c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// rvalue reference to the specified type. 16144ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getRValueReferenceType(QualType T) const { 16157c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // Unique pointers, to guarantee there is only one pointer of a particular 16167c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // structure. 16177c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl llvm::FoldingSetNodeID ID; 161854e14c4db764c0636160d26c5bbf491637c83a76John McCall ReferenceType::Profile(ID, T, false); 16197c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 16207c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl void *InsertPos = 0; 16217c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl if (RValueReferenceType *RT = 16227c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 16237c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl return QualType(RT, 0); 16247c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 162554e14c4db764c0636160d26c5bbf491637c83a76John McCall const ReferenceType *InnerRef = T->getAs<ReferenceType>(); 162654e14c4db764c0636160d26c5bbf491637c83a76John McCall 16277c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // If the referencee type isn't canonical, this won't be a canonical type 16287c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // either, so fill in the canonical type field. 16297c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl QualType Canonical; 163054e14c4db764c0636160d26c5bbf491637c83a76John McCall if (InnerRef || !T.isCanonical()) { 163154e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T); 163254e14c4db764c0636160d26c5bbf491637c83a76John McCall Canonical = getRValueReferenceType(getCanonicalType(PointeeType)); 16337c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 16345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 16357c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceType *NewIP = 16367c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 1637c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 16385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 16395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 16406b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall RValueReferenceType *New 16416b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) RValueReferenceType(T, Canonical); 16425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 16437c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceTypes.InsertNode(New, InsertPos); 16445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 16455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 16465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1647f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl/// getMemberPointerType - Return the uniqued reference to the type for a 1648f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl/// member pointer to the specified type, in the specified class. 16494ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) const { 1650f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // Unique pointers, to guarantee there is only one pointer of a particular 1651f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // structure. 1652f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl llvm::FoldingSetNodeID ID; 1653f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerType::Profile(ID, T, Cls); 1654f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1655f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl void *InsertPos = 0; 1656f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl if (MemberPointerType *PT = 1657f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 1658f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl return QualType(PT, 0); 1659f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1660f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // If the pointee or class type isn't canonical, this won't be a canonical 1661f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // type either, so fill in the canonical type field. 1662f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl QualType Canonical; 166387c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) { 1664f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls)); 1665f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1666f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // Get the new insert position for the node we care about. 1667f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerType *NewIP = 1668f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1669c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 1670f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl } 16716b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall MemberPointerType *New 16726b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical); 1673f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl Types.push_back(New); 1674f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerTypes.InsertNode(New, InsertPos); 1675f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl return QualType(New, 0); 1676f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl} 1677f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 16781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getConstantArrayType - Return the unique reference to the type for an 1679fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff/// array of the specified element type. 16801eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType ASTContext::getConstantArrayType(QualType EltTy, 168138aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner const llvm::APInt &ArySizeIn, 1682c9406125e2cac9208098655ac8058c095c2c3a65Steve Naroff ArrayType::ArraySizeModifier ASM, 168363e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara unsigned IndexTypeQuals) const { 1684923d56d436f750bc1f29db50e641078725558a1bSebastian Redl assert((EltTy->isDependentType() || 1685923d56d436f750bc1f29db50e641078725558a1bSebastian Redl EltTy->isIncompleteType() || EltTy->isConstantSizeType()) && 1686587cbdfd95f4b0aaccc14b31f5debe85d5daf7edEli Friedman "Constant array of VLAs is illegal!"); 1687587cbdfd95f4b0aaccc14b31f5debe85d5daf7edEli Friedman 168838aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner // Convert the array size into a canonical width matching the pointer size for 168938aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner // the target. 169038aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner llvm::APInt ArySize(ArySizeIn); 16919f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad ArySize = 1692bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor ArySize.zextOrTrunc(Target->getPointerWidth(getTargetAddressSpace(EltTy))); 16931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 169563e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, IndexTypeQuals); 16961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 16981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (ConstantArrayType *ATP = 16997192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos)) 17005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(ATP, 0); 17011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 17023b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If the element type isn't canonical or has qualifiers, this won't 17033b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // be a canonical type either, so fill in the canonical type field. 17043b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType Canon; 17053b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) { 17063b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = getCanonicalType(EltTy).split(); 1707200fa53fd420aa8369586f569dbece04930ad6a3John McCall Canon = getConstantArrayType(QualType(canonSplit.Ty, 0), ArySize, 170863e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara ASM, IndexTypeQuals); 1709200fa53fd420aa8369586f569dbece04930ad6a3John McCall Canon = getQualifiedType(Canon, canonSplit.Quals); 17103b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 17115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 17121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ConstantArrayType *NewIP = 17137192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos); 1714c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 17155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 17161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 17176b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ConstantArrayType *New = new(*this,TypeAlignment) 171863e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara ConstantArrayType(EltTy, Canon, ArySize, ASM, IndexTypeQuals); 17197192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek ConstantArrayTypes.InsertNode(New, InsertPos); 17205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 17215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 17225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 17235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1724ce8890371fcdb983ae487c87fa40606a34896ff7John McCall/// getVariableArrayDecayedType - Turns the given type, which may be 1725ce8890371fcdb983ae487c87fa40606a34896ff7John McCall/// variably-modified, into the corresponding type with all the known 1726ce8890371fcdb983ae487c87fa40606a34896ff7John McCall/// sizes replaced with [*]. 1727ce8890371fcdb983ae487c87fa40606a34896ff7John McCallQualType ASTContext::getVariableArrayDecayedType(QualType type) const { 1728ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Vastly most common case. 1729ce8890371fcdb983ae487c87fa40606a34896ff7John McCall if (!type->isVariablyModifiedType()) return type; 1730ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1731ce8890371fcdb983ae487c87fa40606a34896ff7John McCall QualType result; 1732ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1733ce8890371fcdb983ae487c87fa40606a34896ff7John McCall SplitQualType split = type.getSplitDesugaredType(); 1734200fa53fd420aa8369586f569dbece04930ad6a3John McCall const Type *ty = split.Ty; 1735ce8890371fcdb983ae487c87fa40606a34896ff7John McCall switch (ty->getTypeClass()) { 1736ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#define TYPE(Class, Base) 1737ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#define ABSTRACT_TYPE(Class, Base) 1738ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 1739ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#include "clang/AST/TypeNodes.def" 1740ce8890371fcdb983ae487c87fa40606a34896ff7John McCall llvm_unreachable("didn't desugar past all non-canonical types?"); 1741ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1742ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // These types should never be variably-modified. 1743ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Builtin: 1744ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Complex: 1745ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Vector: 1746ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ExtVector: 1747ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentSizedExtVector: 1748ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ObjCObject: 1749ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ObjCInterface: 1750ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ObjCObjectPointer: 1751ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Record: 1752ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Enum: 1753ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::UnresolvedUsing: 1754ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TypeOfExpr: 1755ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TypeOf: 1756ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Decltype: 1757ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt case Type::UnaryTransform: 1758ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentName: 1759ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::InjectedClassName: 1760ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TemplateSpecialization: 1761ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentTemplateSpecialization: 1762ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TemplateTypeParm: 1763ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::SubstTemplateTypeParmPack: 176434b41d939a1328f484511c6002ba2456db879a29Richard Smith case Type::Auto: 1765ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::PackExpansion: 1766ce8890371fcdb983ae487c87fa40606a34896ff7John McCall llvm_unreachable("type should never be variably-modified"); 1767ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1768ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // These types can be variably-modified but should never need to 1769ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // further decay. 1770ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::FunctionNoProto: 1771ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::FunctionProto: 1772ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::BlockPointer: 1773ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::MemberPointer: 1774ce8890371fcdb983ae487c87fa40606a34896ff7John McCall return type; 1775ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1776ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // These types can be variably-modified. All these modifications 1777ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // preserve structure except as noted by comments. 1778ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // TODO: if we ever care about optimizing VLAs, there are no-op 1779ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // optimizations available here. 1780ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Pointer: 1781ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getPointerType(getVariableArrayDecayedType( 1782ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cast<PointerType>(ty)->getPointeeType())); 1783ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1784ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1785ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::LValueReference: { 1786ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const LValueReferenceType *lv = cast<LValueReferenceType>(ty); 1787ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getLValueReferenceType( 1788ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(lv->getPointeeType()), 1789ce8890371fcdb983ae487c87fa40606a34896ff7John McCall lv->isSpelledAsLValue()); 1790ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1791745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 1792ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1793ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::RValueReference: { 1794ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const RValueReferenceType *lv = cast<RValueReferenceType>(ty); 1795ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getRValueReferenceType( 1796ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(lv->getPointeeType())); 1797ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1798745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 1799745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1800b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: { 1801b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman const AtomicType *at = cast<AtomicType>(ty); 1802b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman result = getAtomicType(getVariableArrayDecayedType(at->getValueType())); 1803b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman break; 1804b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 1805b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 1806ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ConstantArray: { 1807ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const ConstantArrayType *cat = cast<ConstantArrayType>(ty); 1808ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getConstantArrayType( 1809ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(cat->getElementType()), 1810ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cat->getSize(), 1811ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cat->getSizeModifier(), 1812ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cat->getIndexTypeCVRQualifiers()); 1813ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1814745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 1815745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1816ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentSizedArray: { 1817ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const DependentSizedArrayType *dat = cast<DependentSizedArrayType>(ty); 1818ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getDependentSizedArrayType( 1819ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(dat->getElementType()), 1820ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getSizeExpr(), 1821ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getSizeModifier(), 1822ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getIndexTypeCVRQualifiers(), 1823ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getBracketsRange()); 1824ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1825ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1826ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1827ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Turn incomplete types into [*] types. 1828ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::IncompleteArray: { 1829ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const IncompleteArrayType *iat = cast<IncompleteArrayType>(ty); 1830ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getVariableArrayType( 1831ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(iat->getElementType()), 1832ce8890371fcdb983ae487c87fa40606a34896ff7John McCall /*size*/ 0, 1833ce8890371fcdb983ae487c87fa40606a34896ff7John McCall ArrayType::Normal, 1834ce8890371fcdb983ae487c87fa40606a34896ff7John McCall iat->getIndexTypeCVRQualifiers(), 1835ce8890371fcdb983ae487c87fa40606a34896ff7John McCall SourceRange()); 1836ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1837ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1838ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1839ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Turn VLA types into [*] types. 1840ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::VariableArray: { 1841ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const VariableArrayType *vat = cast<VariableArrayType>(ty); 1842ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getVariableArrayType( 1843ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(vat->getElementType()), 1844ce8890371fcdb983ae487c87fa40606a34896ff7John McCall /*size*/ 0, 1845ce8890371fcdb983ae487c87fa40606a34896ff7John McCall ArrayType::Star, 1846ce8890371fcdb983ae487c87fa40606a34896ff7John McCall vat->getIndexTypeCVRQualifiers(), 1847ce8890371fcdb983ae487c87fa40606a34896ff7John McCall vat->getBracketsRange()); 1848ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1849ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1850ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1851ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1852ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Apply the top-level qualifiers from the original. 1853200fa53fd420aa8369586f569dbece04930ad6a3John McCall return getQualifiedType(result, split.Quals); 1854ce8890371fcdb983ae487c87fa40606a34896ff7John McCall} 1855745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1856bdbf7b030a3e0ddb95240076683830e6f78c79a5Steve Naroff/// getVariableArrayType - Returns a non-unique reference to the type for a 1857bdbf7b030a3e0ddb95240076683830e6f78c79a5Steve Naroff/// variable array of the specified element type. 18587e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas GregorQualType ASTContext::getVariableArrayType(QualType EltTy, 18597e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor Expr *NumElts, 1860c9406125e2cac9208098655ac8058c095c2c3a65Steve Naroff ArrayType::ArraySizeModifier ASM, 186163e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara unsigned IndexTypeQuals, 18624ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad SourceRange Brackets) const { 1863c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // Since we don't unique expressions, it isn't possible to unique VLA's 1864c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // that have an expression provided for their size. 18653b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType Canon; 1866715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor 18673b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Be sure to pull qualifiers off the element type. 18683b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) { 18693b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = getCanonicalType(EltTy).split(); 1870200fa53fd420aa8369586f569dbece04930ad6a3John McCall Canon = getVariableArrayType(QualType(canonSplit.Ty, 0), NumElts, ASM, 187163e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara IndexTypeQuals, Brackets); 1872200fa53fd420aa8369586f569dbece04930ad6a3John McCall Canon = getQualifiedType(Canon, canonSplit.Quals); 1873715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor } 1874715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor 18756b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall VariableArrayType *New = new(*this, TypeAlignment) 187663e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara VariableArrayType(EltTy, Canon, NumElts, ASM, IndexTypeQuals, Brackets); 1877c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1878c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman VariableArrayTypes.push_back(New); 1879c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman Types.push_back(New); 1880c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman return QualType(New, 0); 1881c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman} 1882c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1883898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// getDependentSizedArrayType - Returns a non-unique reference to 1884898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// the type for a dependently-sized array of the specified element 188504d4beee4b86af20a9e4457023d3925cab8f9908Douglas Gregor/// type. 18863b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getDependentSizedArrayType(QualType elementType, 18873b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Expr *numElements, 1888898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor ArrayType::ArraySizeModifier ASM, 18893b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall unsigned elementTypeQuals, 18903b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SourceRange brackets) const { 18913b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert((!numElements || numElements->isTypeDependent() || 18923b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall numElements->isValueDependent()) && 1893898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor "Size must be type- or value-dependent!"); 1894898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 18953b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Dependently-sized array types that do not have a specified number 18963b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // of elements will have their sizes deduced from a dependent 18973b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // initializer. We do no canonicalization here at all, which is okay 18983b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // because they can't be used in most locations. 18993b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!numElements) { 19003b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType *newType 19013b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall = new (*this, TypeAlignment) 19023b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType(*this, elementType, QualType(), 19033b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall numElements, ASM, elementTypeQuals, 19043b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall brackets); 19053b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(newType); 19063b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(newType, 0); 1907cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor } 1908cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor 19093b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Otherwise, we actually build a new type every time, but we 19103b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // also build a canonical type. 19111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 19123b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonElementType = getCanonicalType(elementType).split(); 1913898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 19143b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall void *insertPos = 0; 19153b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall llvm::FoldingSetNodeID ID; 19163b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType::Profile(ID, *this, 1917200fa53fd420aa8369586f569dbece04930ad6a3John McCall QualType(canonElementType.Ty, 0), 19183b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ASM, elementTypeQuals, numElements); 19193b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19203b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Look for an existing type with these properties. 19213b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType *canonTy = 19223b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos); 19233b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19243b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If we don't have one, build one. 19253b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!canonTy) { 19263b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall canonTy = new (*this, TypeAlignment) 1927200fa53fd420aa8369586f569dbece04930ad6a3John McCall DependentSizedArrayType(*this, QualType(canonElementType.Ty, 0), 19283b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType(), numElements, ASM, elementTypeQuals, 19293b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall brackets); 19303b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayTypes.InsertNode(canonTy, insertPos); 19313b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(canonTy); 19323b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall } 19333b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19343b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Apply qualifiers from the element type to the array. 19353b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType canon = getQualifiedType(QualType(canonTy,0), 1936200fa53fd420aa8369586f569dbece04930ad6a3John McCall canonElementType.Quals); 19373b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19383b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If we didn't need extra canonicalization for the element type, 19393b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // then just use that as our result. 1940200fa53fd420aa8369586f569dbece04930ad6a3John McCall if (QualType(canonElementType.Ty, 0) == elementType) 19413b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return canon; 19423b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19433b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Otherwise, we need to build a type which follows the spelling 19443b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // of the element type. 19453b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType *sugaredType 19463b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall = new (*this, TypeAlignment) 19473b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType(*this, elementType, canon, numElements, 19483b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ASM, elementTypeQuals, brackets); 19493b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(sugaredType); 19503b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(sugaredType, 0); 19513b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall} 19523b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19533b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getIncompleteArrayType(QualType elementType, 1954c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman ArrayType::ArraySizeModifier ASM, 19553b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall unsigned elementTypeQuals) const { 1956c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman llvm::FoldingSetNodeID ID; 19573b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType::Profile(ID, elementType, ASM, elementTypeQuals); 1958c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19593b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall void *insertPos = 0; 19603b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (IncompleteArrayType *iat = 19613b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos)) 19623b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(iat, 0); 1963c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1964c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // If the element type isn't canonical, this won't be a canonical type 19653b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // either, so fill in the canonical type field. We also have to pull 19663b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // qualifiers off the element type. 19673b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType canon; 1968c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19693b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!elementType.isCanonical() || elementType.hasLocalQualifiers()) { 19703b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = getCanonicalType(elementType).split(); 1971200fa53fd420aa8369586f569dbece04930ad6a3John McCall canon = getIncompleteArrayType(QualType(canonSplit.Ty, 0), 19723b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ASM, elementTypeQuals); 1973200fa53fd420aa8369586f569dbece04930ad6a3John McCall canon = getQualifiedType(canon, canonSplit.Quals); 1974c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1975c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // Get the new insert position for the node we care about. 19763b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType *existing = 19773b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos); 19783b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert(!existing && "Shouldn't be in the map!"); (void) existing; 19792bd24ba6d10f8c811c8e2a57c8397e07082ba497Ted Kremenek } 1980c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19813b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType *newType = new (*this, TypeAlignment) 19823b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType(elementType, canon, ASM, elementTypeQuals); 1983c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19843b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayTypes.InsertNode(newType, insertPos); 19853b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(newType); 19863b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(newType, 0); 1987fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff} 1988fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff 198973322924127c873c13101b705dd823f5539ffa5fSteve Naroff/// getVectorType - Return the unique reference to a vector type of 199073322924127c873c13101b705dd823f5539ffa5fSteve Naroff/// the specified element type and size. VectorType must be a built-in type. 199182287d19ded35248c4ce6a425ce74116a13ce44eJohn ThompsonQualType ASTContext::getVectorType(QualType vecType, unsigned NumElts, 19924ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad VectorType::VectorKind VecKind) const { 19933b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert(vecType->isBuiltinType()); 19941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 19955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Check if we've already instantiated a vector of this type. 19965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 1997e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType::Profile(ID, vecType, NumElts, Type::Vector, VecKind); 1998788b0fd67e1992f23555454efcdb16a19dfefac3Chris Lattner 19995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 20005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 20015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(VTP, 0); 20025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 20035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the element type isn't canonical, this won't be a canonical type either, 20045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // so fill in the canonical type field. 20055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 2006255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor if (!vecType.isCanonical()) { 2007231da7eb3dd13007e5e40fffe48998e5ef284e06Bob Wilson Canonical = getVectorType(getCanonicalType(vecType), NumElts, VecKind); 20081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 20105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2011c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 20125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 20136b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall VectorType *New = new (*this, TypeAlignment) 2014e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType(vecType, NumElts, Canonical, VecKind); 20155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer VectorTypes.InsertNode(New, InsertPos); 20165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 20175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 20185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 20195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2020213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman/// getExtVectorType - Return the unique reference to an extended vector type of 202173322924127c873c13101b705dd823f5539ffa5fSteve Naroff/// the specified element type and size. VectorType must be a built-in type. 20224ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 20234ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getExtVectorType(QualType vecType, unsigned NumElts) const { 20244ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor assert(vecType->isBuiltinType() || vecType->isDependentType()); 20251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 202673322924127c873c13101b705dd823f5539ffa5fSteve Naroff // Check if we've already instantiated a vector of this type. 202773322924127c873c13101b705dd823f5539ffa5fSteve Naroff llvm::FoldingSetNodeID ID; 2028788b0fd67e1992f23555454efcdb16a19dfefac3Chris Lattner VectorType::Profile(ID, vecType, NumElts, Type::ExtVector, 2029e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType::GenericVector); 203073322924127c873c13101b705dd823f5539ffa5fSteve Naroff void *InsertPos = 0; 203173322924127c873c13101b705dd823f5539ffa5fSteve Naroff if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 203273322924127c873c13101b705dd823f5539ffa5fSteve Naroff return QualType(VTP, 0); 203373322924127c873c13101b705dd823f5539ffa5fSteve Naroff 203473322924127c873c13101b705dd823f5539ffa5fSteve Naroff // If the element type isn't canonical, this won't be a canonical type either, 203573322924127c873c13101b705dd823f5539ffa5fSteve Naroff // so fill in the canonical type field. 203673322924127c873c13101b705dd823f5539ffa5fSteve Naroff QualType Canonical; 2037467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!vecType.isCanonical()) { 2038213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman Canonical = getExtVectorType(getCanonicalType(vecType), NumElts); 20391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 204073322924127c873c13101b705dd823f5539ffa5fSteve Naroff // Get the new insert position for the node we care about. 204173322924127c873c13101b705dd823f5539ffa5fSteve Naroff VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2042c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 204373322924127c873c13101b705dd823f5539ffa5fSteve Naroff } 20446b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ExtVectorType *New = new (*this, TypeAlignment) 20456b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ExtVectorType(vecType, NumElts, Canonical); 204673322924127c873c13101b705dd823f5539ffa5fSteve Naroff VectorTypes.InsertNode(New, InsertPos); 204773322924127c873c13101b705dd823f5539ffa5fSteve Naroff Types.push_back(New); 204873322924127c873c13101b705dd823f5539ffa5fSteve Naroff return QualType(New, 0); 204973322924127c873c13101b705dd823f5539ffa5fSteve Naroff} 205073322924127c873c13101b705dd823f5539ffa5fSteve Naroff 20514ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 20524ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getDependentSizedExtVectorType(QualType vecType, 20534ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Expr *SizeExpr, 20544ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad SourceLocation AttrLoc) const { 20552ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor llvm::FoldingSetNodeID ID; 20561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump DependentSizedExtVectorType::Profile(ID, *this, getCanonicalType(vecType), 20572ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor SizeExpr); 20581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20592ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor void *InsertPos = 0; 20602ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor DependentSizedExtVectorType *Canon 20612ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos); 20622ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor DependentSizedExtVectorType *New; 20632ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor if (Canon) { 20642ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor // We already have a canonical version of this array type; use it as 20652ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor // the canonical type for a newly-built type. 20666b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall New = new (*this, TypeAlignment) 20676b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall DependentSizedExtVectorType(*this, vecType, QualType(Canon, 0), 20686b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall SizeExpr, AttrLoc); 20692ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } else { 20702ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor QualType CanonVecTy = getCanonicalType(vecType); 20712ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor if (CanonVecTy == vecType) { 20726b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall New = new (*this, TypeAlignment) 20736b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall DependentSizedExtVectorType(*this, vecType, QualType(), SizeExpr, 20746b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall AttrLoc); 2075789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2076789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentSizedExtVectorType *CanonCheck 2077789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2078789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!CanonCheck && "Dependent-sized ext_vector canonical type broken"); 2079789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CanonCheck; 20802ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor DependentSizedExtVectorTypes.InsertNode(New, InsertPos); 20812ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } else { 20822ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr, 20832ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor SourceLocation()); 20846b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall New = new (*this, TypeAlignment) 20856b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall DependentSizedExtVectorType(*this, vecType, Canon, SizeExpr, AttrLoc); 20862ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } 20872ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } 20881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20899cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor Types.push_back(New); 20909cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor return QualType(New, 0); 20919cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor} 20929cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor 209372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'. 20945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 20954ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 20964ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getFunctionNoProtoType(QualType ResultTy, 20974ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const FunctionType::ExtInfo &Info) const { 2098cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv DefaultCC = Info.getCC(); 2099cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv CallConv = (LangOpts.MRTD && DefaultCC == CC_Default) ? 2100cfe9af250f466e7e38becea4428990448ae07737Roman Divacky CC_X86StdCall : DefaultCC; 21015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique functions, to guarantee there is only one function of a particular 21025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 21035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 2104264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionNoProtoType::Profile(ID, ResultTy, Info); 21051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 21065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 21071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (FunctionNoProtoType *FT = 210872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) 21095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(FT, 0); 21101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 21115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 2112ab8bbf4ebd3e3e6eab913cb044772a62b7581941Douglas Gregor if (!ResultTy.isCanonical() || 211304a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall getCanonicalCallConv(CallConv) != CallConv) { 2114264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola Canonical = 2115264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola getFunctionNoProtoType(getCanonicalType(ResultTy), 2116264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola Info.withCallingConv(getCanonicalCallConv(CallConv))); 21171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 21185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 211972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoType *NewIP = 212072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos); 2121c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 21225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 21231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2124cfe9af250f466e7e38becea4428990448ae07737Roman Divacky FunctionProtoType::ExtInfo newInfo = Info.withCallingConv(CallConv); 21256b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall FunctionNoProtoType *New = new (*this, TypeAlignment) 2126cfe9af250f466e7e38becea4428990448ae07737Roman Divacky FunctionNoProtoType(ResultTy, Canonical, newInfo); 21275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 212872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoTypes.InsertNode(New, InsertPos); 21295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 21305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 21315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 21325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getFunctionType - Return a normal function type with a typed argument 21335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// list. isVariadic indicates whether the argument list includes '...'. 21344ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 21354ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getFunctionType(QualType ResultTy, 21364ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const QualType *ArgArray, unsigned NumArgs, 21374ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const FunctionProtoType::ExtProtoInfo &EPI) const { 21385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique functions, to guarantee there is only one function of a particular 21395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 21405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 21418026f6d82f7fa544bc0453714fe94bca62a1196eSebastian Redl FunctionProtoType::Profile(ID, ResultTy, ArgArray, NumArgs, EPI, *this); 21425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 21435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 21441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (FunctionProtoType *FTP = 214572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) 21465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(FTP, 0); 2147465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 2148465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl // Determine whether the type being created is already canonical or not. 2149eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith bool isCanonical = 2150eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith EPI.ExceptionSpecType == EST_None && ResultTy.isCanonical() && 2151eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith !EPI.HasTrailingReturn; 21525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0; i != NumArgs && isCanonical; ++i) 215354e14c4db764c0636160d26c5bbf491637c83a76John McCall if (!ArgArray[i].isCanonicalAsParam()) 21545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer isCanonical = false; 21555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2156cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv DefaultCC = EPI.ExtInfo.getCC(); 2157cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv CallConv = (LangOpts.MRTD && DefaultCC == CC_Default) ? 2158cfe9af250f466e7e38becea4428990448ae07737Roman Divacky CC_X86StdCall : DefaultCC; 2159e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 21605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this type isn't canonical, get the canonical version of it. 2161465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl // The exception spec is not part of the canonical type. 21625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 216304a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall if (!isCanonical || getCanonicalCallConv(CallConv) != CallConv) { 21645f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 16> CanonicalArgs; 21655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer CanonicalArgs.reserve(NumArgs); 21665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0; i != NumArgs; ++i) 216754e14c4db764c0636160d26c5bbf491637c83a76John McCall CanonicalArgs.push_back(getCanonicalParamType(ArgArray[i])); 2168465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 2169e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo CanonicalEPI = EPI; 2170eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith CanonicalEPI.HasTrailingReturn = false; 21718b5b4099c61a136e9a1714c4d8a593febe942268Sebastian Redl CanonicalEPI.ExceptionSpecType = EST_None; 21728b5b4099c61a136e9a1714c4d8a593febe942268Sebastian Redl CanonicalEPI.NumExceptions = 0; 2173e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall CanonicalEPI.ExtInfo 2174e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall = CanonicalEPI.ExtInfo.withCallingConv(getCanonicalCallConv(CallConv)); 2175e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 2176f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner Canonical = getFunctionType(getCanonicalType(ResultTy), 2177beaaccd8e2a8748f77b66e2b330fb9136937e14cJay Foad CanonicalArgs.data(), NumArgs, 2178e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall CanonicalEPI); 2179465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 21805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 218172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoType *NewIP = 218272564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos); 2183c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 21845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2185465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 2186f85e193739c953358c865005855253af4f68a497John McCall // FunctionProtoType objects are allocated with extra bytes after 2187f85e193739c953358c865005855253af4f68a497John McCall // them for three variable size arrays at the end: 2188f85e193739c953358c865005855253af4f68a497John McCall // - parameter types 2189f85e193739c953358c865005855253af4f68a497John McCall // - exception types 2190f85e193739c953358c865005855253af4f68a497John McCall // - consumed-arguments flags 2191f85e193739c953358c865005855253af4f68a497John McCall // Instead of the exception types, there could be a noexcept 2192f85e193739c953358c865005855253af4f68a497John McCall // expression. 2193e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall size_t Size = sizeof(FunctionProtoType) + 219460618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl NumArgs * sizeof(QualType); 219560618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl if (EPI.ExceptionSpecType == EST_Dynamic) 219660618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl Size += EPI.NumExceptions * sizeof(QualType); 219760618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl else if (EPI.ExceptionSpecType == EST_ComputedNoexcept) { 21988026f6d82f7fa544bc0453714fe94bca62a1196eSebastian Redl Size += sizeof(Expr*); 2199e6975e9b0985ad7f7ff9187e38d95bfe9ac4181bRichard Smith } else if (EPI.ExceptionSpecType == EST_Uninstantiated) { 220013bffc532bafd45d4a77867993c1afb83c7661beRichard Smith Size += 2 * sizeof(FunctionDecl*); 220160618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl } 2202f85e193739c953358c865005855253af4f68a497John McCall if (EPI.ConsumedArguments) 2203f85e193739c953358c865005855253af4f68a497John McCall Size += NumArgs * sizeof(bool); 2204f85e193739c953358c865005855253af4f68a497John McCall 2205e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType *FTP = (FunctionProtoType*) Allocate(Size, TypeAlignment); 2206cfe9af250f466e7e38becea4428990448ae07737Roman Divacky FunctionProtoType::ExtProtoInfo newEPI = EPI; 2207cfe9af250f466e7e38becea4428990448ae07737Roman Divacky newEPI.ExtInfo = EPI.ExtInfo.withCallingConv(CallConv); 22088026f6d82f7fa544bc0453714fe94bca62a1196eSebastian Redl new (FTP) FunctionProtoType(ResultTy, ArgArray, NumArgs, Canonical, newEPI); 22095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(FTP); 221072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoTypes.InsertNode(FTP, InsertPos); 22115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(FTP, 0); 22125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 22135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 22143cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall#ifndef NDEBUG 22153cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallstatic bool NeedsInjectedClassNameType(const RecordDecl *D) { 22163cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (!isa<CXXRecordDecl>(D)) return false; 22173cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall const CXXRecordDecl *RD = cast<CXXRecordDecl>(D); 22183cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (isa<ClassTemplatePartialSpecializationDecl>(RD)) 22193cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return true; 22203cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (RD->getDescribedClassTemplate() && 22213cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall !isa<ClassTemplateSpecializationDecl>(RD)) 22223cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return true; 22233cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return false; 22243cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall} 22253cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall#endif 22263cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 22273cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall/// getInjectedClassNameType - Return the unique reference to the 22283cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall/// injected class name type for the specified templated declaration. 22293cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallQualType ASTContext::getInjectedClassNameType(CXXRecordDecl *Decl, 22304ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType TST) const { 22313cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(NeedsInjectedClassNameType(Decl)); 22323cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (Decl->TypeForDecl) { 22333cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(isa<InjectedClassNameType>(Decl->TypeForDecl)); 2234ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor } else if (CXXRecordDecl *PrevDecl = Decl->getPreviousDecl()) { 22353cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(PrevDecl->TypeForDecl && "previous declaration has no type"); 22363cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall Decl->TypeForDecl = PrevDecl->TypeForDecl; 22373cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(isa<InjectedClassNameType>(Decl->TypeForDecl)); 22383cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } else { 2239f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Type *newType = 224031f17ecbef57b5679c017c375db330546b7b5145John McCall new (*this, TypeAlignment) InjectedClassNameType(Decl, TST); 2241f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2242f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 22433cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } 22443cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return QualType(Decl->TypeForDecl, 0); 22453cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall} 22463cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 22472ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor/// getTypeDeclType - Return the unique reference to the type for the 22482ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor/// specified type declaration. 22494ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTypeDeclTypeSlow(const TypeDecl *Decl) const { 22501e6759e9e33dcaa73ce14c8a908ac9f87ac16463Argyrios Kyrtzidis assert(Decl && "Passed null for Decl param"); 2251becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall assert(!Decl->TypeForDecl && "TypeForDecl present in slow case"); 22521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2253162e1c1b487352434552147967c3dd296ebee2f7Richard Smith if (const TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Decl)) 22542ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor return getTypedefType(Typedef); 2255becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall 2256becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall assert(!isa<TemplateTypeParmDecl>(Decl) && 2257becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall "Template type parameter types are always available."); 2258becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall 225919c8576b7328f4dc2d07682f5da552875c1912efJohn McCall if (const RecordDecl *Record = dyn_cast<RecordDecl>(Decl)) { 2260ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor assert(!Record->getPreviousDecl() && 2261becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall "struct/union has previous declaration"); 2262becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall assert(!NeedsInjectedClassNameType(Record)); 2263400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return getRecordType(Record); 226419c8576b7328f4dc2d07682f5da552875c1912efJohn McCall } else if (const EnumDecl *Enum = dyn_cast<EnumDecl>(Decl)) { 2265ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor assert(!Enum->getPreviousDecl() && 2266becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall "enum has previous declaration"); 2267400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return getEnumType(Enum); 226819c8576b7328f4dc2d07682f5da552875c1912efJohn McCall } else if (const UnresolvedUsingTypenameDecl *Using = 2269ed97649e9574b9d854fa4d6109c9333ae0993554John McCall dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) { 2270f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Type *newType = new (*this, TypeAlignment) UnresolvedUsingType(Using); 2271f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2272f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 22739fdbab3cbc2fc04bcaf5768023d83707f3151144Mike Stump } else 2274becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall llvm_unreachable("TypeDecl without a type?"); 227549aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidis 227649aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidis return QualType(Decl->TypeForDecl, 0); 22772ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor} 22782ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor 22795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getTypedefType - Return the unique reference to the type for the 2280162e1c1b487352434552147967c3dd296ebee2f7Richard Smith/// specified typedef name decl. 22819763e221e16026ddf487d2564ed349d2c874a1a1Argyrios KyrtzidisQualType 2282162e1c1b487352434552147967c3dd296ebee2f7Richard SmithASTContext::getTypedefType(const TypedefNameDecl *Decl, 2283162e1c1b487352434552147967c3dd296ebee2f7Richard Smith QualType Canonical) const { 22845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 22851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 22869763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis if (Canonical.isNull()) 22879763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis Canonical = getCanonicalType(Decl->getUnderlyingType()); 2288f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall TypedefType *newType = new(*this, TypeAlignment) 22896b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypedefType(Type::Typedef, Decl, Canonical); 2290f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2291f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 2292f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall return QualType(newType, 0); 22935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 22945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 22954ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getRecordType(const RecordDecl *Decl) const { 2296400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 2297400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2298ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor if (const RecordDecl *PrevDecl = Decl->getPreviousDecl()) 2299400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (PrevDecl->TypeForDecl) 2300400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0); 2301400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2302f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall RecordType *newType = new (*this, TypeAlignment) RecordType(Decl); 2303f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2304f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 2305f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall return QualType(newType, 0); 2306400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis} 2307400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 23084ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getEnumType(const EnumDecl *Decl) const { 2309400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 2310400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2311ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor if (const EnumDecl *PrevDecl = Decl->getPreviousDecl()) 2312400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (PrevDecl->TypeForDecl) 2313400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0); 2314400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2315f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall EnumType *newType = new (*this, TypeAlignment) EnumType(Decl); 2316f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2317f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 2318f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall return QualType(newType, 0); 2319400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis} 2320400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 23219d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCallQualType ASTContext::getAttributedType(AttributedType::Kind attrKind, 23229d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall QualType modifiedType, 23239d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall QualType equivalentType) { 23249d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall llvm::FoldingSetNodeID id; 23259d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedType::Profile(id, attrKind, modifiedType, equivalentType); 23269d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23279d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall void *insertPos = 0; 23289d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedType *type = AttributedTypes.FindNodeOrInsertPos(id, insertPos); 23299d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall if (type) return QualType(type, 0); 23309d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23319d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall QualType canon = getCanonicalType(equivalentType); 23329d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall type = new (*this, TypeAlignment) 23339d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedType(canon, attrKind, modifiedType, equivalentType); 23349d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23359d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall Types.push_back(type); 23369d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedTypes.InsertNode(type, insertPos); 23379d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23389d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall return QualType(type, 0); 23399d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall} 23409d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23419d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 234249a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall/// \brief Retrieve a substitution-result type. 234349a832bd499d6f61c23655f1fac99f0dd229756eJohn McCallQualType 234449a832bd499d6f61c23655f1fac99f0dd229756eJohn McCallASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm, 23454ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType Replacement) const { 2346467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(Replacement.isCanonical() 234749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall && "replacement types must always be canonical"); 234849a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 234949a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall llvm::FoldingSetNodeID ID; 235049a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmType::Profile(ID, Parm, Replacement); 235149a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall void *InsertPos = 0; 235249a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmType *SubstParm 235349a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 235449a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 235549a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall if (!SubstParm) { 235649a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstParm = new (*this, TypeAlignment) 235749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmType(Parm, Replacement); 235849a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall Types.push_back(SubstParm); 235949a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos); 236049a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall } 236149a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 236249a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall return QualType(SubstParm, 0); 236349a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall} 236449a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 2365c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor/// \brief Retrieve a 2366c3069d618f4661d923cb1b5c4525b082fce73b04Douglas GregorQualType ASTContext::getSubstTemplateTypeParmPackType( 2367c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor const TemplateTypeParmType *Parm, 2368c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor const TemplateArgument &ArgPack) { 2369c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor#ifndef NDEBUG 2370c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor for (TemplateArgument::pack_iterator P = ArgPack.pack_begin(), 2371c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor PEnd = ArgPack.pack_end(); 2372c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor P != PEnd; ++P) { 2373c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor assert(P->getKind() == TemplateArgument::Type &&"Pack contains a non-type"); 2374c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor assert(P->getAsType().isCanonical() && "Pack contains non-canonical type"); 2375c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor } 2376c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor#endif 2377c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2378c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor llvm::FoldingSetNodeID ID; 2379c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmPackType::Profile(ID, Parm, ArgPack); 2380c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor void *InsertPos = 0; 2381c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor if (SubstTemplateTypeParmPackType *SubstParm 2382c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor = SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos)) 2383c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor return QualType(SubstParm, 0); 2384c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2385c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor QualType Canon; 2386c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor if (!Parm->isCanonicalUnqualified()) { 2387c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor Canon = getCanonicalType(QualType(Parm, 0)); 2388c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor Canon = getSubstTemplateTypeParmPackType(cast<TemplateTypeParmType>(Canon), 2389c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor ArgPack); 2390c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos); 2391c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor } 2392c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2393c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmPackType *SubstParm 2394c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor = new (*this, TypeAlignment) SubstTemplateTypeParmPackType(Parm, Canon, 2395c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor ArgPack); 2396c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor Types.push_back(SubstParm); 2397c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos); 2398c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor return QualType(SubstParm, 0); 2399c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor} 2400c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2401fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor/// \brief Retrieve the template type parameter type for a template 24021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// parameter or parameter pack with the given depth, index, and (optionally) 240376e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson/// name. 24041eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index, 240576e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson bool ParameterPack, 24064fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TemplateTypeParmDecl *TTPDecl) const { 2407fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor llvm::FoldingSetNodeID ID; 24084fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, TTPDecl); 2409fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor void *InsertPos = 0; 24101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateTypeParmType *TypeParm 2411fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 2412fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 2413fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor if (TypeParm) 2414fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor return QualType(TypeParm, 0); 24151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 24164fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth if (TTPDecl) { 241776e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack); 24184fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TypeParm = new (*this, TypeAlignment) TemplateTypeParmType(TTPDecl, Canon); 2419789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2420789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor TemplateTypeParmType *TypeCheck 2421789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 2422789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!TypeCheck && "Template type parameter canonical type broken"); 2423789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)TypeCheck; 242476e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson } else 24256b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypeParm = new (*this, TypeAlignment) 24266b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TemplateTypeParmType(Depth, Index, ParameterPack); 2427fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 2428fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor Types.push_back(TypeParm); 2429fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos); 2430fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 2431fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor return QualType(TypeParm, 0); 2432fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor} 2433fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 24343cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallTypeSourceInfo * 24353cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallASTContext::getTemplateSpecializationTypeInfo(TemplateName Name, 24363cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall SourceLocation NameLoc, 24373cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall const TemplateArgumentListInfo &Args, 24383e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType Underlying) const { 24397c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Name.getAsDependentTemplateName() && 24407c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 24413e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType TST = getTemplateSpecializationType(Name, Args, Underlying); 24423cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 24433cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TypeSourceInfo *DI = CreateTypeSourceInfo(TST); 24443cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TemplateSpecializationTypeLoc TL 24453cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall = cast<TemplateSpecializationTypeLoc>(DI->getTypeLoc()); 244655d23c925b058be29b792008ddb7d68f6c4fa9a0Abramo Bagnara TL.setTemplateKeywordLoc(SourceLocation()); 24473cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setTemplateNameLoc(NameLoc); 24483cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setLAngleLoc(Args.getLAngleLoc()); 24493cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setRAngleLoc(Args.getRAngleLoc()); 24503cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 24513cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setArgLocInfo(i, Args[i].getLocInfo()); 24523cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return DI; 24533cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall} 24543cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 24551eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType 24567532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas GregorASTContext::getTemplateSpecializationType(TemplateName Template, 2457d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall const TemplateArgumentListInfo &Args, 24583e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType Underlying) const { 24597c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Template.getAsDependentTemplateName() && 24607c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 24617c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor 2462d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall unsigned NumArgs = Args.size(); 2463d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall 24645f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> ArgVec; 2465833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall ArgVec.reserve(NumArgs); 2466833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall for (unsigned i = 0; i != NumArgs; ++i) 2467833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall ArgVec.push_back(Args[i].getArgument()); 2468833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 246931f17ecbef57b5679c017c375db330546b7b5145John McCall return getTemplateSpecializationType(Template, ArgVec.data(), NumArgs, 24703e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith Underlying); 2471833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall} 2472833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 2473b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor#ifndef NDEBUG 2474b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregorstatic bool hasAnyPackExpansions(const TemplateArgument *Args, 2475b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor unsigned NumArgs) { 2476b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor for (unsigned I = 0; I != NumArgs; ++I) 2477b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor if (Args[I].isPackExpansion()) 2478b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor return true; 2479b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor 2480b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor return true; 2481b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor} 2482b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor#endif 2483b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor 2484833ca991c1bfc967f0995974ca86f66ba1f666b5John McCallQualType 2485833ca991c1bfc967f0995974ca86f66ba1f666b5John McCallASTContext::getTemplateSpecializationType(TemplateName Template, 24867532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor const TemplateArgument *Args, 24877532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor unsigned NumArgs, 24883e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType Underlying) const { 24897c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Template.getAsDependentTemplateName() && 24907c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 24910f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor // Look through qualified template names. 24920f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 24930f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor Template = TemplateName(QTN->getTemplateDecl()); 24947c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor 2495b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor bool IsTypeAlias = 24963e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith Template.getAsTemplateDecl() && 24973e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith isa<TypeAliasTemplateDecl>(Template.getAsTemplateDecl()); 24983e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType CanonType; 24993e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith if (!Underlying.isNull()) 25003e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith CanonType = getCanonicalType(Underlying); 25013e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith else { 2502b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor // We can get here with an alias template when the specialization contains 2503b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor // a pack expansion that does not match up with a parameter pack. 2504b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor assert((!IsTypeAlias || hasAnyPackExpansions(Args, NumArgs)) && 2505b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor "Caller must compute aliased type"); 2506b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor IsTypeAlias = false; 25073e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith CanonType = getCanonicalTemplateSpecializationType(Template, Args, 25083e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith NumArgs); 25093e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith } 2510fc705b84347e6fb4746a1a7e26949f64c2f2f358Douglas Gregor 25111275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // Allocate the (non-canonical) template specialization type, but don't 25121275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // try to unique it: these types typically have location information that 25131275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // we don't unique and don't want to lose. 25143e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith void *Mem = Allocate(sizeof(TemplateSpecializationType) + 25153e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith sizeof(TemplateArgument) * NumArgs + 2516b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor (IsTypeAlias? sizeof(QualType) : 0), 25176b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypeAlignment); 25181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateSpecializationType *Spec 2519b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor = new (Mem) TemplateSpecializationType(Template, Args, NumArgs, CanonType, 2520b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor IsTypeAlias ? Underlying : QualType()); 25211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 252255f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor Types.push_back(Spec); 25231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return QualType(Spec, 0); 252455f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor} 252555f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 25261eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType 25279763e221e16026ddf487d2564ed349d2c874a1a1Argyrios KyrtzidisASTContext::getCanonicalTemplateSpecializationType(TemplateName Template, 25289763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis const TemplateArgument *Args, 25294ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned NumArgs) const { 25307c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Template.getAsDependentTemplateName() && 25317c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 25323e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith 25330f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor // Look through qualified template names. 25340f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 25350f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor Template = TemplateName(QTN->getTemplateDecl()); 25367c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor 25379763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Build the canonical template specialization type. 25389763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateName CanonTemplate = getCanonicalTemplateName(Template); 25395f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> CanonArgs; 25409763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.reserve(NumArgs); 25419763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis for (unsigned I = 0; I != NumArgs; ++I) 25429763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.push_back(getCanonicalTemplateArgument(Args[I])); 25439763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25449763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Determine whether this canonical template specialization type already 25459763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // exists. 25469763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis llvm::FoldingSetNodeID ID; 25479763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateSpecializationType::Profile(ID, CanonTemplate, 25489763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.data(), NumArgs, *this); 25499763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25509763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis void *InsertPos = 0; 25519763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateSpecializationType *Spec 25529763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 25539763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25549763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis if (!Spec) { 25559763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Allocate a new canonical template specialization type. 25569763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis void *Mem = Allocate((sizeof(TemplateSpecializationType) + 25579763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis sizeof(TemplateArgument) * NumArgs), 25589763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TypeAlignment); 25599763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis Spec = new (Mem) TemplateSpecializationType(CanonTemplate, 25609763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.data(), NumArgs, 25613e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType(), QualType()); 25629763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis Types.push_back(Spec); 25639763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateSpecializationTypes.InsertNode(Spec, InsertPos); 25649763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis } 25659763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25669763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis assert(Spec->isDependentType() && 25679763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis "Non-dependent template-id type must have a canonical type"); 25689763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis return QualType(Spec, 0); 25699763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis} 25709763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25719763e221e16026ddf487d2564ed349d2c874a1a1Argyrios KyrtzidisQualType 2572465d41b92b2c862f3062c412a0538db65c6a2661Abramo BagnaraASTContext::getElaboratedType(ElaboratedTypeKeyword Keyword, 2573465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara NestedNameSpecifier *NNS, 25744ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType NamedType) const { 2575e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor llvm::FoldingSetNodeID ID; 2576465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedType::Profile(ID, Keyword, NNS, NamedType); 2577e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor 2578e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor void *InsertPos = 0; 2579465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedType *T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos); 2580e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor if (T) 2581e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor return QualType(T, 0); 2582e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor 2583789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor QualType Canon = NamedType; 2584789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor if (!Canon.isCanonical()) { 2585789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor Canon = getCanonicalType(NamedType); 2586465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedType *CheckT = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos); 2587465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara assert(!CheckT && "Elaborated canonical type broken"); 2588789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CheckT; 2589789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor } 2590789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2591465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara T = new (*this) ElaboratedType(Keyword, NNS, NamedType, Canon); 2592e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor Types.push_back(T); 2593465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedTypes.InsertNode(T, InsertPos); 2594e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor return QualType(T, 0); 2595e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor} 2596e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor 2597075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo BagnaraQualType 25984ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getParenType(QualType InnerType) const { 2599075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara llvm::FoldingSetNodeID ID; 2600075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenType::Profile(ID, InnerType); 2601075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 2602075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara void *InsertPos = 0; 2603075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenType *T = ParenTypes.FindNodeOrInsertPos(ID, InsertPos); 2604075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara if (T) 2605075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return QualType(T, 0); 2606075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 2607075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara QualType Canon = InnerType; 2608075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara if (!Canon.isCanonical()) { 2609075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara Canon = getCanonicalType(InnerType); 2610075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos); 2611075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara assert(!CheckT && "Paren canonical type broken"); 2612075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara (void)CheckT; 2613075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara } 2614075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 2615075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara T = new (*this) ParenType(InnerType, Canon); 2616075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara Types.push_back(T); 2617075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenTypes.InsertNode(T, InsertPos); 2618075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return QualType(T, 0); 2619075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara} 2620075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 26214a2023f5014e82389d5980d307b89c545dbbac81Douglas GregorQualType ASTContext::getDependentNameType(ElaboratedTypeKeyword Keyword, 26224a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor NestedNameSpecifier *NNS, 26234a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor const IdentifierInfo *Name, 26244ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType Canon) const { 2625d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor assert(NNS->isDependent() && "nested-name-specifier must be dependent"); 2626d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2627d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor if (Canon.isNull()) { 2628d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 26294a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor ElaboratedTypeKeyword CanonKeyword = Keyword; 26304a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor if (Keyword == ETK_None) 26314a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor CanonKeyword = ETK_Typename; 26324a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor 26334a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor if (CanonNNS != NNS || CanonKeyword != Keyword) 26344a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor Canon = getDependentNameType(CanonKeyword, CanonNNS, Name); 2635d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor } 2636d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2637d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor llvm::FoldingSetNodeID ID; 26384a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor DependentNameType::Profile(ID, Keyword, NNS, Name); 2639d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2640d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor void *InsertPos = 0; 26414714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor DependentNameType *T 26424714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos); 2643d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor if (T) 2644d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor return QualType(T, 0); 2645d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 26464a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor T = new (*this) DependentNameType(Keyword, NNS, Name, Canon); 2647d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor Types.push_back(T); 26484714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor DependentNameTypes.InsertNode(T, InsertPos); 26491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return QualType(T, 0); 2650d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor} 2651d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 26521eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType 265333500955d731c73717af52088b7fc0e7a85681e7John McCallASTContext::getDependentTemplateSpecializationType( 265433500955d731c73717af52088b7fc0e7a85681e7John McCall ElaboratedTypeKeyword Keyword, 26554a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor NestedNameSpecifier *NNS, 265633500955d731c73717af52088b7fc0e7a85681e7John McCall const IdentifierInfo *Name, 26574ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const TemplateArgumentListInfo &Args) const { 265833500955d731c73717af52088b7fc0e7a85681e7John McCall // TODO: avoid this copy 26595f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 16> ArgCopy; 266033500955d731c73717af52088b7fc0e7a85681e7John McCall for (unsigned I = 0, E = Args.size(); I != E; ++I) 266133500955d731c73717af52088b7fc0e7a85681e7John McCall ArgCopy.push_back(Args[I].getArgument()); 266233500955d731c73717af52088b7fc0e7a85681e7John McCall return getDependentTemplateSpecializationType(Keyword, NNS, Name, 266333500955d731c73717af52088b7fc0e7a85681e7John McCall ArgCopy.size(), 266433500955d731c73717af52088b7fc0e7a85681e7John McCall ArgCopy.data()); 266533500955d731c73717af52088b7fc0e7a85681e7John McCall} 266633500955d731c73717af52088b7fc0e7a85681e7John McCall 266733500955d731c73717af52088b7fc0e7a85681e7John McCallQualType 266833500955d731c73717af52088b7fc0e7a85681e7John McCallASTContext::getDependentTemplateSpecializationType( 266933500955d731c73717af52088b7fc0e7a85681e7John McCall ElaboratedTypeKeyword Keyword, 267033500955d731c73717af52088b7fc0e7a85681e7John McCall NestedNameSpecifier *NNS, 267133500955d731c73717af52088b7fc0e7a85681e7John McCall const IdentifierInfo *Name, 267233500955d731c73717af52088b7fc0e7a85681e7John McCall unsigned NumArgs, 26734ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const TemplateArgument *Args) const { 2674aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor assert((!NNS || NNS->isDependent()) && 2675aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor "nested-name-specifier must be dependent"); 26761734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 2677789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor llvm::FoldingSetNodeID ID; 267833500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS, 267933500955d731c73717af52088b7fc0e7a85681e7John McCall Name, NumArgs, Args); 2680789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2681789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor void *InsertPos = 0; 268233500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationType *T 268333500955d731c73717af52088b7fc0e7a85681e7John McCall = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 2684789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor if (T) 2685789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor return QualType(T, 0); 2686789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 268733500955d731c73717af52088b7fc0e7a85681e7John McCall NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 268833500955d731c73717af52088b7fc0e7a85681e7John McCall 268933500955d731c73717af52088b7fc0e7a85681e7John McCall ElaboratedTypeKeyword CanonKeyword = Keyword; 269033500955d731c73717af52088b7fc0e7a85681e7John McCall if (Keyword == ETK_None) CanonKeyword = ETK_Typename; 26911734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 269233500955d731c73717af52088b7fc0e7a85681e7John McCall bool AnyNonCanonArgs = false; 26935f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 16> CanonArgs(NumArgs); 269433500955d731c73717af52088b7fc0e7a85681e7John McCall for (unsigned I = 0; I != NumArgs; ++I) { 269533500955d731c73717af52088b7fc0e7a85681e7John McCall CanonArgs[I] = getCanonicalTemplateArgument(Args[I]); 269633500955d731c73717af52088b7fc0e7a85681e7John McCall if (!CanonArgs[I].structurallyEquals(Args[I])) 269733500955d731c73717af52088b7fc0e7a85681e7John McCall AnyNonCanonArgs = true; 2698789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor } 26991734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 270033500955d731c73717af52088b7fc0e7a85681e7John McCall QualType Canon; 270133500955d731c73717af52088b7fc0e7a85681e7John McCall if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) { 270233500955d731c73717af52088b7fc0e7a85681e7John McCall Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS, 270333500955d731c73717af52088b7fc0e7a85681e7John McCall Name, NumArgs, 270433500955d731c73717af52088b7fc0e7a85681e7John McCall CanonArgs.data()); 270533500955d731c73717af52088b7fc0e7a85681e7John McCall 270633500955d731c73717af52088b7fc0e7a85681e7John McCall // Find the insert position again. 270733500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 270833500955d731c73717af52088b7fc0e7a85681e7John McCall } 270933500955d731c73717af52088b7fc0e7a85681e7John McCall 271033500955d731c73717af52088b7fc0e7a85681e7John McCall void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) + 271133500955d731c73717af52088b7fc0e7a85681e7John McCall sizeof(TemplateArgument) * NumArgs), 271233500955d731c73717af52088b7fc0e7a85681e7John McCall TypeAlignment); 2713ef99001908e799c388f1363b1e607dad5f5b57d3John McCall T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS, 271433500955d731c73717af52088b7fc0e7a85681e7John McCall Name, NumArgs, Args, Canon); 27151734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor Types.push_back(T); 271633500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationTypes.InsertNode(T, InsertPos); 27171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return QualType(T, 0); 27181734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor} 27191734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 2720cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas GregorQualType ASTContext::getPackExpansionType(QualType Pattern, 2721cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor llvm::Optional<unsigned> NumExpansions) { 27227536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor llvm::FoldingSetNodeID ID; 2723cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor PackExpansionType::Profile(ID, Pattern, NumExpansions); 27247536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 27257536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor assert(Pattern->containsUnexpandedParameterPack() && 27267536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor "Pack expansions must expand one or more parameter packs"); 27277536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor void *InsertPos = 0; 27287536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor PackExpansionType *T 27297536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor = PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos); 27307536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor if (T) 27317536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor return QualType(T, 0); 27327536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 27337536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor QualType Canon; 27347536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor if (!Pattern.isCanonical()) { 2735cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor Canon = getPackExpansionType(getCanonicalType(Pattern), NumExpansions); 27367536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 27377536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor // Find the insert position again. 27387536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos); 27397536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor } 27407536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 2741cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor T = new (*this) PackExpansionType(Pattern, Canon, NumExpansions); 27427536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor Types.push_back(T); 27437536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor PackExpansionTypes.InsertNode(T, InsertPos); 27447536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor return QualType(T, 0); 27457536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor} 27467536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 274788cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner/// CmpProtocolNames - Comparison predicate for sorting protocols 274888cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner/// alphabetically. 274988cb27a160adc305783a44f922ee4b216006ebf9Chris Lattnerstatic bool CmpProtocolNames(const ObjCProtocolDecl *LHS, 275088cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner const ObjCProtocolDecl *RHS) { 27512e1cd4264d363ca869bf37ef160902f211d21b8cDouglas Gregor return LHS->getDeclName() < RHS->getDeclName(); 275288cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner} 275388cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 2754c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCallstatic bool areSortedAndUniqued(ObjCProtocolDecl * const *Protocols, 275554e14c4db764c0636160d26c5bbf491637c83a76John McCall unsigned NumProtocols) { 275654e14c4db764c0636160d26c5bbf491637c83a76John McCall if (NumProtocols == 0) return true; 275754e14c4db764c0636160d26c5bbf491637c83a76John McCall 275861cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor if (Protocols[0]->getCanonicalDecl() != Protocols[0]) 275961cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor return false; 276061cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor 276154e14c4db764c0636160d26c5bbf491637c83a76John McCall for (unsigned i = 1; i != NumProtocols; ++i) 276261cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor if (!CmpProtocolNames(Protocols[i-1], Protocols[i]) || 276361cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor Protocols[i]->getCanonicalDecl() != Protocols[i]) 276454e14c4db764c0636160d26c5bbf491637c83a76John McCall return false; 276554e14c4db764c0636160d26c5bbf491637c83a76John McCall return true; 276654e14c4db764c0636160d26c5bbf491637c83a76John McCall} 276754e14c4db764c0636160d26c5bbf491637c83a76John McCall 276854e14c4db764c0636160d26c5bbf491637c83a76John McCallstatic void SortAndUniqueProtocols(ObjCProtocolDecl **Protocols, 276988cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner unsigned &NumProtocols) { 277088cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner ObjCProtocolDecl **ProtocolsEnd = Protocols+NumProtocols; 27711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 277288cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner // Sort protocols, keyed by name. 277388cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner std::sort(Protocols, Protocols+NumProtocols, CmpProtocolNames); 277488cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 277561cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor // Canonicalize. 277661cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor for (unsigned I = 0, N = NumProtocols; I != N; ++I) 277761cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor Protocols[I] = Protocols[I]->getCanonicalDecl(); 277861cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor 277988cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner // Remove duplicates. 278088cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner ProtocolsEnd = std::unique(Protocols, ProtocolsEnd); 278188cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner NumProtocols = ProtocolsEnd-Protocols; 278288cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner} 278388cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 2784c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCallQualType ASTContext::getObjCObjectType(QualType BaseType, 2785c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCProtocolDecl * const *Protocols, 27864ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned NumProtocols) const { 2787c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // If the base type is an interface and there aren't any protocols 2788c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // to add, then the interface type will do just fine. 2789c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!NumProtocols && isa<ObjCInterfaceType>(BaseType)) 2790c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return BaseType; 2791d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff 2792c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Look in the folding set for an existing type. 2793c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall llvm::FoldingSetNodeID ID; 2794c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypeImpl::Profile(ID, BaseType, Protocols, NumProtocols); 2795d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff void *InsertPos = 0; 2796c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos)) 2797c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return QualType(QT, 0); 2798d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff 2799c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Build the canonical type, which has the canonical base type and 2800c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // a sorted-and-uniqued list of protocols. 280154e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType Canonical; 2802c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall bool ProtocolsSorted = areSortedAndUniqued(Protocols, NumProtocols); 2803c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!ProtocolsSorted || !BaseType.isCanonical()) { 2804c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!ProtocolsSorted) { 28055f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<ObjCProtocolDecl*, 8> Sorted(Protocols, 28060237941e0beb0c929934b66ad29443b484d987feBenjamin Kramer Protocols + NumProtocols); 280754e14c4db764c0636160d26c5bbf491637c83a76John McCall unsigned UniqueCount = NumProtocols; 280854e14c4db764c0636160d26c5bbf491637c83a76John McCall 280954e14c4db764c0636160d26c5bbf491637c83a76John McCall SortAndUniqueProtocols(&Sorted[0], UniqueCount); 2810c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Canonical = getObjCObjectType(getCanonicalType(BaseType), 2811c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall &Sorted[0], UniqueCount); 281254e14c4db764c0636160d26c5bbf491637c83a76John McCall } else { 2813c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Canonical = getObjCObjectType(getCanonicalType(BaseType), 2814c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Protocols, NumProtocols); 281554e14c4db764c0636160d26c5bbf491637c83a76John McCall } 281654e14c4db764c0636160d26c5bbf491637c83a76John McCall 281754e14c4db764c0636160d26c5bbf491637c83a76John McCall // Regenerate InsertPos. 2818c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos); 281954e14c4db764c0636160d26c5bbf491637c83a76John McCall } 282054e14c4db764c0636160d26c5bbf491637c83a76John McCall 2821c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall unsigned Size = sizeof(ObjCObjectTypeImpl); 2822c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Size += NumProtocols * sizeof(ObjCProtocolDecl *); 2823fd6a0887a099256c35a5b23e9afd517ffe95fa0aDouglas Gregor void *Mem = Allocate(Size, TypeAlignment); 2824c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypeImpl *T = 2825c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall new (Mem) ObjCObjectTypeImpl(Canonical, BaseType, Protocols, NumProtocols); 28261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2827c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Types.push_back(T); 2828c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypes.InsertNode(T, InsertPos); 2829c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return QualType(T, 0); 2830d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff} 283188cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 2832c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall/// getObjCObjectPointerType - Return a ObjCObjectPointerType type for 2833c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall/// the given object type. 28344ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getObjCObjectPointerType(QualType ObjectT) const { 28354b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian llvm::FoldingSetNodeID ID; 2836c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerType::Profile(ID, ObjectT); 28371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 28384b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian void *InsertPos = 0; 2839c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (ObjCObjectPointerType *QT = 2840c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 28414b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian return QualType(QT, 0); 28421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2843c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Find the canonical object type. 284454e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType Canonical; 2845c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!ObjectT.isCanonical()) { 2846c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Canonical = getObjCObjectPointerType(getCanonicalType(ObjectT)); 284754e14c4db764c0636160d26c5bbf491637c83a76John McCall 2848c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Regenerate InsertPos. 2849c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 285054e14c4db764c0636160d26c5bbf491637c83a76John McCall } 285154e14c4db764c0636160d26c5bbf491637c83a76John McCall 2852c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // No match. 2853c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall void *Mem = Allocate(sizeof(ObjCObjectPointerType), TypeAlignment); 2854c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerType *QType = 2855c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall new (Mem) ObjCObjectPointerType(Canonical, ObjectT); 285624fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis 285724fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis Types.push_back(QType); 2858c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerTypes.InsertNode(QType, InsertPos); 285924fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis return QualType(QType, 0); 286024fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis} 286124fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis 2862deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor/// getObjCInterfaceType - Return the unique reference to the type for the 2863deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor/// specified ObjC interface decl. The list of protocols is optional. 28640af550115df1f57f17a4f125ff0e8b34820c65d1Douglas GregorQualType ASTContext::getObjCInterfaceType(const ObjCInterfaceDecl *Decl, 28650af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor ObjCInterfaceDecl *PrevDecl) const { 2866deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor if (Decl->TypeForDecl) 2867deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor return QualType(Decl->TypeForDecl, 0); 286874c730ad1f6818b676b0bad46d806a9176950328Sebastian Redl 28690af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor if (PrevDecl) { 28700af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor assert(PrevDecl->TypeForDecl && "previous decl has no TypeForDecl"); 28710af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor Decl->TypeForDecl = PrevDecl->TypeForDecl; 28720af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor return QualType(PrevDecl->TypeForDecl, 0); 28730af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor } 28740af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor 28758d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor // Prefer the definition, if there is one. 28768d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor if (const ObjCInterfaceDecl *Def = Decl->getDefinition()) 28778d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor Decl = Def; 28788d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor 2879deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor void *Mem = Allocate(sizeof(ObjCInterfaceType), TypeAlignment); 2880deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor ObjCInterfaceType *T = new (Mem) ObjCInterfaceType(Decl); 2881deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor Decl->TypeForDecl = T; 2882deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor Types.push_back(T); 2883deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor return QualType(T, 0); 2884c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall} 2885c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 288672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor/// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique 288772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor/// TypeOfExprType AST's (since expression's are never shared). For example, 28889752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// multiple declarations that refer to "typeof(x)" all contain different 28891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// DeclRefExpr's. This doesn't effect the type checker, since it operates 28909752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// on canonical type's (which are always unique). 28914ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTypeOfExprType(Expr *tofExpr) const { 2892dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor TypeOfExprType *toe; 2893b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor if (tofExpr->isTypeDependent()) { 2894b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor llvm::FoldingSetNodeID ID; 2895b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor DependentTypeOfExprType::Profile(ID, *this, tofExpr); 28961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2897b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor void *InsertPos = 0; 2898b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor DependentTypeOfExprType *Canon 2899b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos); 2900b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor if (Canon) { 2901b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor // We already have a "canonical" version of an identical, dependent 2902b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor // typeof(expr) type. Use that as our canonical type. 29036b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, 2904b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor QualType((TypeOfExprType*)Canon, 0)); 29053060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 2906b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor // Build a new, canonical typeof(expr) type. 29076b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall Canon 29086b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr); 2909b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor DependentTypeOfExprTypes.InsertNode(Canon, InsertPos); 2910b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor toe = Canon; 2911b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor } 2912b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor } else { 2913dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor QualType Canonical = getCanonicalType(tofExpr->getType()); 29146b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical); 2915dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor } 29169752f25748d954df99087d741ea35db37ff16beaSteve Naroff Types.push_back(toe); 29179752f25748d954df99087d741ea35db37ff16beaSteve Naroff return QualType(toe, 0); 2918d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff} 2919d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff 29209752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// getTypeOfType - Unlike many "get<Type>" functions, we don't unique 29219752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// TypeOfType AST's. The only motivation to unique these nodes would be 29229752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be 29231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// an issue. This doesn't effect the type checker, since it operates 29249752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// on canonical type's (which are always unique). 29254ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTypeOfType(QualType tofType) const { 2926f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner QualType Canonical = getCanonicalType(tofType); 29276b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypeOfType *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical); 29289752f25748d954df99087d741ea35db37ff16beaSteve Naroff Types.push_back(tot); 29299752f25748d954df99087d741ea35db37ff16beaSteve Naroff return QualType(tot, 0); 2930d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff} 2931d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff 293260a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson 2933395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson/// getDecltypeType - Unlike many "get<Type>" functions, we don't unique 2934395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson/// DecltypeType AST's. The only motivation to unique these nodes would be 2935395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson/// memory savings. Since decltype(t) is fairly uncommon, space shouldn't be 29361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// an issue. This doesn't effect the type checker, since it operates 293739e02032b01874a0d02ba85a4cd3922adda81376David Blaikie/// on canonical types (which are always unique). 2938f8af98286022f72157d84951b48fde5fb369ab29Douglas GregorQualType ASTContext::getDecltypeType(Expr *e, QualType UnderlyingType) const { 2939dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor DecltypeType *dt; 2940561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor 2941561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // C++0x [temp.type]p2: 2942561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // If an expression e involves a template parameter, decltype(e) denotes a 2943561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // unique dependent type. Two such decltype-specifiers refer to the same 2944561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // type only if their expressions are equivalent (14.5.6.1). 2945561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor if (e->isInstantiationDependent()) { 29469d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor llvm::FoldingSetNodeID ID; 29479d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor DependentDecltypeType::Profile(ID, *this, e); 29481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 29499d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor void *InsertPos = 0; 29509d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor DependentDecltypeType *Canon 29519d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos); 29529d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor if (Canon) { 29539d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor // We already have a "canonical" version of an equivalent, dependent 29549d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor // decltype type. Use that as our canonical type. 29556b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall dt = new (*this, TypeAlignment) DecltypeType(e, DependentTy, 29569d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor QualType((DecltypeType*)Canon, 0)); 29573060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 29589d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor // Build a new, canonical typeof(expr) type. 29596b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall Canon = new (*this, TypeAlignment) DependentDecltypeType(*this, e); 29609d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor DependentDecltypeTypes.InsertNode(Canon, InsertPos); 29619d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor dt = Canon; 29629d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor } 29639d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor } else { 2964f8af98286022f72157d84951b48fde5fb369ab29Douglas Gregor dt = new (*this, TypeAlignment) DecltypeType(e, UnderlyingType, 2965f8af98286022f72157d84951b48fde5fb369ab29Douglas Gregor getCanonicalType(UnderlyingType)); 2966dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor } 2967395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson Types.push_back(dt); 2968395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson return QualType(dt, 0); 2969395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson} 2970395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson 2971ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt/// getUnaryTransformationType - We don't unique these, since the memory 2972ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt/// savings are minimal and these are rare. 2973ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean HuntQualType ASTContext::getUnaryTransformType(QualType BaseType, 2974ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt QualType UnderlyingType, 2975ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt UnaryTransformType::UTTKind Kind) 2976ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt const { 2977ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt UnaryTransformType *Ty = 297869d9775da47a4b9f165dbc33277f02982928a94eDouglas Gregor new (*this, TypeAlignment) UnaryTransformType (BaseType, UnderlyingType, 297969d9775da47a4b9f165dbc33277f02982928a94eDouglas Gregor Kind, 298069d9775da47a4b9f165dbc33277f02982928a94eDouglas Gregor UnderlyingType->isDependentType() ? 298112fc4b0624706b474fa10308631fa8daf92f340fPeter Collingbourne QualType() : getCanonicalType(UnderlyingType)); 2982ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt Types.push_back(Ty); 2983ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt return QualType(Ty, 0); 2984ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt} 2985ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt 2986483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith/// getAutoType - We only unique auto types after they've been deduced. 298734b41d939a1328f484511c6002ba2456db879a29Richard SmithQualType ASTContext::getAutoType(QualType DeducedType) const { 2988483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith void *InsertPos = 0; 2989483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith if (!DeducedType.isNull()) { 2990483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith // Look in the folding set for an existing type. 2991483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith llvm::FoldingSetNodeID ID; 2992483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith AutoType::Profile(ID, DeducedType); 2993483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith if (AutoType *AT = AutoTypes.FindNodeOrInsertPos(ID, InsertPos)) 2994483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith return QualType(AT, 0); 2995483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith } 2996483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith 2997483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith AutoType *AT = new (*this, TypeAlignment) AutoType(DeducedType); 2998483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith Types.push_back(AT); 2999483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith if (InsertPos) 3000483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith AutoTypes.InsertNode(AT, InsertPos); 3001483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith return QualType(AT, 0); 300234b41d939a1328f484511c6002ba2456db879a29Richard Smith} 300334b41d939a1328f484511c6002ba2456db879a29Richard Smith 3004b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman/// getAtomicType - Return the uniqued reference to the atomic type for 3005b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman/// the given value type. 3006b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli FriedmanQualType ASTContext::getAtomicType(QualType T) const { 3007b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // Unique pointers, to guarantee there is only one pointer of a particular 3008b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // structure. 3009b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman llvm::FoldingSetNodeID ID; 3010b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicType::Profile(ID, T); 3011b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 3012b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman void *InsertPos = 0; 3013b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos)) 3014b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return QualType(AT, 0); 3015b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 3016b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // If the atomic value type isn't canonical, this won't be a canonical type 3017b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // either, so fill in the canonical type field. 3018b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType Canonical; 3019b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (!T.isCanonical()) { 3020b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman Canonical = getAtomicType(getCanonicalType(T)); 3021b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 3022b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // Get the new insert position for the node we care about. 3023b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos); 3024b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 3025b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 3026b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicType *New = new (*this, TypeAlignment) AtomicType(T, Canonical); 3027b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman Types.push_back(New); 3028b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicTypes.InsertNode(New, InsertPos); 3029b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return QualType(New, 0); 3030b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman} 3031b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 3032ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// getAutoDeductType - Get type pattern for deducing against 'auto'. 3033ad762fcdc16b9e4705b12b09d92b8c026212b906Richard SmithQualType ASTContext::getAutoDeductType() const { 3034ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith if (AutoDeductTy.isNull()) 3035ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith AutoDeductTy = getAutoType(QualType()); 3036ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith assert(!AutoDeductTy.isNull() && "can't build 'auto' pattern"); 3037ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith return AutoDeductTy; 3038ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith} 3039ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith 3040ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// getAutoRRefDeductType - Get type pattern for deducing against 'auto &&'. 3041ad762fcdc16b9e4705b12b09d92b8c026212b906Richard SmithQualType ASTContext::getAutoRRefDeductType() const { 3042ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith if (AutoRRefDeductTy.isNull()) 3043ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith AutoRRefDeductTy = getRValueReferenceType(getAutoDeductType()); 3044ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith assert(!AutoRRefDeductTy.isNull() && "can't build 'auto &&' pattern"); 3045ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith return AutoRRefDeductTy; 3046ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith} 3047ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith 30485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getTagDeclType - Return the unique reference to the type for the 30495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// specified TagDecl (struct/union/class/enum) decl. 30504ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTagDeclType(const TagDecl *Decl) const { 3051d778f88d32b96a74c9edb7342c81357606a7cdc0Ted Kremenek assert (Decl); 3052e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump // FIXME: What is the design on getTagDeclType when it requires casting 3053e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump // away const? mutable? 3054e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump return getTypeDeclType(const_cast<TagDecl*>(Decl)); 30555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 30565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 30571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getSizeType - Return the unique type for "size_t" (C99 7.17), the result 30581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and 30591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// needs to agree with the definition in <stddef.h>. 3060a3ccda58913cc1a4b8564e349448b12acc462da7Anders CarlssonCanQualType ASTContext::getSizeType() const { 3061bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor return getFromTargetType(Target->getSizeType()); 30625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 30635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 306429e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg/// getIntMaxType - Return the unique type for "intmax_t" (C99 7.18.1.5). 306529e97cb35fab314388f62b68fefa78947e93c1dcHans WennborgCanQualType ASTContext::getIntMaxType() const { 306629e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg return getFromTargetType(Target->getIntMaxType()); 306729e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg} 306829e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg 306929e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg/// getUIntMaxType - Return the unique type for "uintmax_t" (C99 7.18.1.5). 307029e97cb35fab314388f62b68fefa78947e93c1dcHans WennborgCanQualType ASTContext::getUIntMaxType() const { 307129e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg return getFromTargetType(Target->getUIntMaxType()); 307229e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg} 307329e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg 307464c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// getSignedWCharType - Return the type of "signed wchar_t". 307564c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// Used when in C++, as a GCC extension. 307664c438a4be2a871fa43c78264663ba1e9788b94dArgyrios KyrtzidisQualType ASTContext::getSignedWCharType() const { 307764c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis // FIXME: derive from "Target" ? 307864c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis return WCharTy; 307964c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis} 308064c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 308164c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// getUnsignedWCharType - Return the type of "unsigned wchar_t". 308264c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// Used when in C++, as a GCC extension. 308364c438a4be2a871fa43c78264663ba1e9788b94dArgyrios KyrtzidisQualType ASTContext::getUnsignedWCharType() const { 308464c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis // FIXME: derive from "Target" ? 308564c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis return UnsignedIntTy; 308664c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis} 308764c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 308829e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg/// getPointerDiffType - Return the unique type for "ptrdiff_t" (C99 7.17) 30898b9023ba35a86838789e2c9034a6128728c547aaChris Lattner/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9). 30908b9023ba35a86838789e2c9034a6128728c547aaChris LattnerQualType ASTContext::getPointerDiffType() const { 3091bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor return getFromTargetType(Target->getPtrDiffType(0)); 30928b9023ba35a86838789e2c9034a6128728c547aaChris Lattner} 30938b9023ba35a86838789e2c9034a6128728c547aaChris Lattner 3094e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner//===----------------------------------------------------------------------===// 3095e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner// Type Operators 3096e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner//===----------------------------------------------------------------------===// 3097e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner 30984ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCanQualType ASTContext::getCanonicalParamType(QualType T) const { 309954e14c4db764c0636160d26c5bbf491637c83a76John McCall // Push qualifiers into arrays, and then discard any remaining 310054e14c4db764c0636160d26c5bbf491637c83a76John McCall // qualifiers. 310154e14c4db764c0636160d26c5bbf491637c83a76John McCall T = getCanonicalType(T); 3102745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian T = getVariableArrayDecayedType(T); 310354e14c4db764c0636160d26c5bbf491637c83a76John McCall const Type *Ty = T.getTypePtr(); 310454e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType Result; 310554e14c4db764c0636160d26c5bbf491637c83a76John McCall if (isa<ArrayType>(Ty)) { 310654e14c4db764c0636160d26c5bbf491637c83a76John McCall Result = getArrayDecayedType(QualType(Ty,0)); 310754e14c4db764c0636160d26c5bbf491637c83a76John McCall } else if (isa<FunctionType>(Ty)) { 310854e14c4db764c0636160d26c5bbf491637c83a76John McCall Result = getPointerType(QualType(Ty, 0)); 310954e14c4db764c0636160d26c5bbf491637c83a76John McCall } else { 311054e14c4db764c0636160d26c5bbf491637c83a76John McCall Result = QualType(Ty, 0); 311154e14c4db764c0636160d26c5bbf491637c83a76John McCall } 311254e14c4db764c0636160d26c5bbf491637c83a76John McCall 311354e14c4db764c0636160d26c5bbf491637c83a76John McCall return CanQualType::CreateUnsafe(Result); 311454e14c4db764c0636160d26c5bbf491637c83a76John McCall} 311554e14c4db764c0636160d26c5bbf491637c83a76John McCall 311662c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCallQualType ASTContext::getUnqualifiedArrayType(QualType type, 311762c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall Qualifiers &quals) { 311862c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall SplitQualType splitType = type.getSplitUnqualifiedType(); 311962c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 312062c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // FIXME: getSplitUnqualifiedType() actually walks all the way to 312162c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // the unqualified desugared type and then drops it on the floor. 312262c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // We then have to strip that sugar back off with 312362c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // getUnqualifiedDesugaredType(), which is silly. 312462c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall const ArrayType *AT = 3125200fa53fd420aa8369586f569dbece04930ad6a3John McCall dyn_cast<ArrayType>(splitType.Ty->getUnqualifiedDesugaredType()); 312662c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 312762c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // If we don't have an array, just use the results in splitType. 31289dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (!AT) { 3129200fa53fd420aa8369586f569dbece04930ad6a3John McCall quals = splitType.Quals; 3130200fa53fd420aa8369586f569dbece04930ad6a3John McCall return QualType(splitType.Ty, 0); 313128e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth } 313228e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 313362c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // Otherwise, recurse on the array's element type. 313462c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall QualType elementType = AT->getElementType(); 313562c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall QualType unqualElementType = getUnqualifiedArrayType(elementType, quals); 313662c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 313762c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // If that didn't change the element type, AT has no qualifiers, so we 313862c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // can just use the results in splitType. 313962c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall if (elementType == unqualElementType) { 314062c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall assert(quals.empty()); // from the recursive call 3141200fa53fd420aa8369586f569dbece04930ad6a3John McCall quals = splitType.Quals; 3142200fa53fd420aa8369586f569dbece04930ad6a3John McCall return QualType(splitType.Ty, 0); 314362c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall } 314462c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 314562c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // Otherwise, add in the qualifiers from the outermost type, then 314662c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // build the type back up. 3147200fa53fd420aa8369586f569dbece04930ad6a3John McCall quals.addConsistentQualifiers(splitType.Quals); 314828e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31499dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) { 315062c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getConstantArrayType(unqualElementType, CAT->getSize(), 315128e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth CAT->getSizeModifier(), 0); 315228e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth } 315328e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31549dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) { 315562c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getIncompleteArrayType(unqualElementType, IAT->getSizeModifier(), 0); 315628e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth } 315728e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31589dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(AT)) { 315962c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getVariableArrayType(unqualElementType, 31603fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall VAT->getSizeExpr(), 31619dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor VAT->getSizeModifier(), 31629dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor VAT->getIndexTypeCVRQualifiers(), 31639dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor VAT->getBracketsRange()); 31649dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor } 31659dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor 31669dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor const DependentSizedArrayType *DSAT = cast<DependentSizedArrayType>(AT); 316762c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getDependentSizedArrayType(unqualElementType, DSAT->getSizeExpr(), 316828e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth DSAT->getSizeModifier(), 0, 316928e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth SourceRange()); 317028e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth} 317128e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31725a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// UnwrapSimilarPointerTypes - If T1 and T2 are pointer types that 31735a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// may be similar (C++ 4.4), replaces T1 and T2 with the type that 31745a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// they point to and return true. If T1 and T2 aren't pointer types 31755a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// or pointer-to-member types, or if they are not similar at this 31765a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// level, returns false and leaves T1 and T2 unchanged. Top-level 31775a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// qualifiers on T1 and T2 are ignored. This function will typically 31785a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// be called in a loop that successively "unwraps" pointer and 31795a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// pointer-to-member types to compare them at each level. 31805a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregorbool ASTContext::UnwrapSimilarPointerTypes(QualType &T1, QualType &T2) { 31815a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor const PointerType *T1PtrType = T1->getAs<PointerType>(), 31825a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor *T2PtrType = T2->getAs<PointerType>(); 31835a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (T1PtrType && T2PtrType) { 31845a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T1 = T1PtrType->getPointeeType(); 31855a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T2 = T2PtrType->getPointeeType(); 31865a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return true; 31875a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 31885a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 31895a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor const MemberPointerType *T1MPType = T1->getAs<MemberPointerType>(), 31905a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor *T2MPType = T2->getAs<MemberPointerType>(); 31915a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (T1MPType && T2MPType && 31925a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0), 31935a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor QualType(T2MPType->getClass(), 0))) { 31945a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T1 = T1MPType->getPointeeType(); 31955a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T2 = T2MPType->getPointeeType(); 31965a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return true; 31975a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 31985a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 31994e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (getLangOpts().ObjC1) { 32005a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor const ObjCObjectPointerType *T1OPType = T1->getAs<ObjCObjectPointerType>(), 32015a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor *T2OPType = T2->getAs<ObjCObjectPointerType>(); 32025a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (T1OPType && T2OPType) { 32035a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T1 = T1OPType->getPointeeType(); 32045a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T2 = T2OPType->getPointeeType(); 32055a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return true; 32065a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 32075a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 32085a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 32095a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor // FIXME: Block pointers, too? 32105a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 32115a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return false; 32125a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor} 32135a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 32144ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadDeclarationNameInfo 32154ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getNameForTemplate(TemplateName Name, 32164ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad SourceLocation NameLoc) const { 3217146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall switch (Name.getKind()) { 3218146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::QualifiedTemplate: 3219146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::Template: 32202577743c5650c646fb705df01403707e94f2df04Abramo Bagnara // DNInfo work in progress: CHECKME: what about DNLoc? 3221146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo(Name.getAsTemplateDecl()->getDeclName(), 3222146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall NameLoc); 32232577743c5650c646fb705df01403707e94f2df04Abramo Bagnara 3224146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::OverloadedTemplate: { 3225146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall OverloadedTemplateStorage *Storage = Name.getAsOverloadedTemplate(); 3226146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall // DNInfo work in progress: CHECKME: what about DNLoc? 3227146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo((*Storage->begin())->getDeclName(), NameLoc); 3228146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3229146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3230146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::DependentTemplate: { 3231146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall DependentTemplateName *DTN = Name.getAsDependentTemplateName(); 32322577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DeclarationName DName; 323380ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall if (DTN->isIdentifier()) { 32342577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DName = DeclarationNames.getIdentifier(DTN->getIdentifier()); 32352577743c5650c646fb705df01403707e94f2df04Abramo Bagnara return DeclarationNameInfo(DName, NameLoc); 323680ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall } else { 32372577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DName = DeclarationNames.getCXXOperatorName(DTN->getOperator()); 32382577743c5650c646fb705df01403707e94f2df04Abramo Bagnara // DNInfo work in progress: FIXME: source locations? 32392577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DeclarationNameLoc DNLoc; 32402577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DNLoc.CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding(); 32412577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DNLoc.CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding(); 32422577743c5650c646fb705df01403707e94f2df04Abramo Bagnara return DeclarationNameInfo(DName, NameLoc, DNLoc); 324380ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall } 324480ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall } 324580ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall 3246146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParm: { 3247146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage *subst 3248146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParm(); 3249146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo(subst->getParameter()->getDeclName(), 3250146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall NameLoc); 3251146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3252146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3253146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParmPack: { 3254146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmPackStorage *subst 3255146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParmPack(); 3256146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo(subst->getParameterPack()->getDeclName(), 3257146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall NameLoc); 3258146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3259146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3260146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3261146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm_unreachable("bad template name kind!"); 326280ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall} 326380ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall 32644ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) const { 3265146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall switch (Name.getKind()) { 3266146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::QualifiedTemplate: 3267146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::Template: { 3268146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateDecl *Template = Name.getAsTemplateDecl(); 32693e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor if (TemplateTemplateParmDecl *TTP 3270146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = dyn_cast<TemplateTemplateParmDecl>(Template)) 32713e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor Template = getCanonicalTemplateTemplateParmDecl(TTP); 32723e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 32733e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // The canonical template name is the canonical template declaration. 327497fbaa2a38804268a024f1a104b43fcf8b4411b0Argyrios Kyrtzidis return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl())); 32753e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor } 327625a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor 3277146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::OverloadedTemplate: 3278146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm_unreachable("cannot canonicalize overloaded template"); 3279146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3280146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::DependentTemplate: { 3281146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall DependentTemplateName *DTN = Name.getAsDependentTemplateName(); 3282146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall assert(DTN && "Non-dependent template names must refer to template decls."); 3283146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DTN->CanonicalTemplateName; 3284146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3285146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3286146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParm: { 3287146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage *subst 3288146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParm(); 3289146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return getCanonicalTemplateName(subst->getReplacement()); 32901aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor } 32911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3292146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParmPack: { 3293146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmPackStorage *subst 3294146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParmPack(); 3295146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateTemplateParmDecl *canonParameter 3296146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = getCanonicalTemplateTemplateParmDecl(subst->getParameterPack()); 3297146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateArgument canonArgPack 3298146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = getCanonicalTemplateArgument(subst->getArgumentPack()); 3299146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return getSubstTemplateTemplateParmPack(canonParameter, canonArgPack); 3300146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3301146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3302146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3303146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm_unreachable("bad template name!"); 330425a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor} 330525a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor 3306db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregorbool ASTContext::hasSameTemplateName(TemplateName X, TemplateName Y) { 3307db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor X = getCanonicalTemplateName(X); 3308db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Y = getCanonicalTemplateName(Y); 3309db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return X.getAsVoidPointer() == Y.getAsVoidPointer(); 3310db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor} 3311db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor 33121eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpTemplateArgument 33134ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const { 33141275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor switch (Arg.getKind()) { 33151275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Null: 33161275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor return Arg; 33171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33181275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Expression: 33191275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor return Arg; 33201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3321d2008e2c80d6c9282044ec873a937a17a0f33579Douglas Gregor case TemplateArgument::Declaration: { 3322d2008e2c80d6c9282044ec873a937a17a0f33579Douglas Gregor if (Decl *D = Arg.getAsDecl()) 3323d2008e2c80d6c9282044ec873a937a17a0f33579Douglas Gregor return TemplateArgument(D->getCanonicalDecl()); 3324d2008e2c80d6c9282044ec873a937a17a0f33579Douglas Gregor return TemplateArgument((Decl*)0); 3325d2008e2c80d6c9282044ec873a937a17a0f33579Douglas Gregor } 33261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3327788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 3328788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate())); 3329a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 3330a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 3331a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return TemplateArgument(getCanonicalTemplateName( 3332a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Arg.getAsTemplateOrTemplatePattern()), 33332be29f423acad3bbe39099a78db2805acb5bdf17Douglas Gregor Arg.getNumTemplateExpansions()); 3334a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 33351275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Integral: 3336833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall return TemplateArgument(*Arg.getAsIntegral(), 33371275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor getCanonicalType(Arg.getIntegralType())); 33381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33391275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Type: 3340833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall return TemplateArgument(getCanonicalType(Arg.getAsType())); 33411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33421275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Pack: { 334387dd697dcc8ecb64df73ae64d61b8c80ff0c157cDouglas Gregor if (Arg.pack_size() == 0) 334487dd697dcc8ecb64df73ae64d61b8c80ff0c157cDouglas Gregor return Arg; 334587dd697dcc8ecb64df73ae64d61b8c80ff0c157cDouglas Gregor 3346910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgument *CanonArgs 3347910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor = new (*this) TemplateArgument[Arg.pack_size()]; 33481275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor unsigned Idx = 0; 33491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (TemplateArgument::pack_iterator A = Arg.pack_begin(), 33501275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor AEnd = Arg.pack_end(); 33511275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor A != AEnd; (void)++A, ++Idx) 33521275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor CanonArgs[Idx] = getCanonicalTemplateArgument(*A); 33531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3354910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor return TemplateArgument(CanonArgs, Arg.pack_size()); 33551275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor } 33561275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor } 33571275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor 33581275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // Silence GCC warning 3359b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unhandled template argument kind"); 33601275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor} 33611275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor 3362d57959af02b4af695276f4204443afe6e5d86bd8Douglas GregorNestedNameSpecifier * 33634ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const { 33641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (!NNS) 3365d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor return 0; 3366d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3367d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor switch (NNS->getKind()) { 3368d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::Identifier: 3369d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // Canonicalize the prefix but keep the identifier the same. 33701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return NestedNameSpecifier::Create(*this, 3371d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor getCanonicalNestedNameSpecifier(NNS->getPrefix()), 3372d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor NNS->getAsIdentifier()); 3373d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3374d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::Namespace: 3375d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // A namespace is canonical; build a nested-name-specifier with 3376d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // this namespace and no prefix. 337714aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor return NestedNameSpecifier::Create(*this, 0, 337814aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor NNS->getAsNamespace()->getOriginalNamespace()); 337914aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor 338014aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor case NestedNameSpecifier::NamespaceAlias: 338114aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor // A namespace is canonical; build a nested-name-specifier with 338214aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor // this namespace and no prefix. 338314aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor return NestedNameSpecifier::Create(*this, 0, 338414aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor NNS->getAsNamespaceAlias()->getNamespace() 338514aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor ->getOriginalNamespace()); 3386d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3387d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::TypeSpec: 3388d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::TypeSpecWithTemplate: { 3389d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor QualType T = getCanonicalType(QualType(NNS->getAsType(), 0)); 3390264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor 3391264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // If we have some kind of dependent-named type (e.g., "typename T::type"), 3392264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // break it apart into its prefix and identifier, then reconsititute those 3393264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // as the canonical nested-name-specifier. This is required to canonicalize 3394264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // a dependent nested-name-specifier involving typedefs of dependent-name 3395264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // types, e.g., 3396264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // typedef typename T::type T1; 3397264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // typedef typename T1::type T2; 339816412ef25a2203b7066d0db2b41f944631e5cf79Eli Friedman if (const DependentNameType *DNT = T->getAs<DependentNameType>()) 339916412ef25a2203b7066d0db2b41f944631e5cf79Eli Friedman return NestedNameSpecifier::Create(*this, DNT->getQualifier(), 3400264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor const_cast<IdentifierInfo *>(DNT->getIdentifier())); 3401264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor 340216412ef25a2203b7066d0db2b41f944631e5cf79Eli Friedman // Otherwise, just canonicalize the type, and force it to be a TypeSpec. 340316412ef25a2203b7066d0db2b41f944631e5cf79Eli Friedman // FIXME: Why are TypeSpec and TypeSpecWithTemplate distinct in the 340416412ef25a2203b7066d0db2b41f944631e5cf79Eli Friedman // first place? 34053b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return NestedNameSpecifier::Create(*this, 0, false, 34063b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall const_cast<Type*>(T.getTypePtr())); 3407d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor } 3408d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3409d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::Global: 3410d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // The global specifier is canonical and unique. 3411d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor return NNS; 3412d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor } 3413d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 34147530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie llvm_unreachable("Invalid NestedNameSpecifier::Kind!"); 3415d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor} 3416d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3417c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 34184ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadconst ArrayType *ASTContext::getAsArrayType(QualType T) const { 3419c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Handle the non-qualified case efficiently. 3420a4923eb7c4b04d360cb2747641a5e92818edf804Douglas Gregor if (!T.hasLocalQualifiers()) { 3421c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Handle the common positive case fast. 3422c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const ArrayType *AT = dyn_cast<ArrayType>(T)) 3423c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return AT; 3424c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner } 34251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 34260953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Handle the common negative case fast. 34273b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!isa<ArrayType>(T.getCanonicalType())) 3428c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return 0; 34291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 34300953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Apply any qualifiers from the array type to the element type. This 3431c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // implements C99 6.7.3p8: "If the specification of an array type includes 3432c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // any type qualifiers, the element type is so qualified, not the array type." 34331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3434c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // If we get here, we either have type qualifiers on the type, or we have 3435c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // sugar such as a typedef in the way. If we have type qualifiers on the type 343650d62d1b4a98adbc83de8f8cd1379ea1c25656f7Douglas Gregor // we must propagate them down into the element type. 34370953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 34383b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType split = T.getSplitDesugaredType(); 3439200fa53fd420aa8369586f569dbece04930ad6a3John McCall Qualifiers qs = split.Quals; 34401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3441c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // If we have a simple case, just return now. 3442200fa53fd420aa8369586f569dbece04930ad6a3John McCall const ArrayType *ATy = dyn_cast<ArrayType>(split.Ty); 34433b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (ATy == 0 || qs.empty()) 3444c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return ATy; 34451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3446c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Otherwise, we have an array and we have qualifiers on it. Push the 3447c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // qualifiers into the array element type and return a new array type. 34483b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType NewEltTy = getQualifiedType(ATy->getElementType(), qs); 34491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3450c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(ATy)) 3451c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(), 3452c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner CAT->getSizeModifier(), 34530953e767ff7817f97b3ab20896b229891eeff45bJohn McCall CAT->getIndexTypeCVRQualifiers())); 3454c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(ATy)) 3455c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return cast<ArrayType>(getIncompleteArrayType(NewEltTy, 3456c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner IAT->getSizeModifier(), 34570953e767ff7817f97b3ab20896b229891eeff45bJohn McCall IAT->getIndexTypeCVRQualifiers())); 3458898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 34591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const DependentSizedArrayType *DSAT 3460898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor = dyn_cast<DependentSizedArrayType>(ATy)) 3461898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return cast<ArrayType>( 34621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getDependentSizedArrayType(NewEltTy, 34633fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall DSAT->getSizeExpr(), 3464898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor DSAT->getSizeModifier(), 34650953e767ff7817f97b3ab20896b229891eeff45bJohn McCall DSAT->getIndexTypeCVRQualifiers(), 34667e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor DSAT->getBracketsRange())); 34671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3468c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner const VariableArrayType *VAT = cast<VariableArrayType>(ATy); 34697e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor return cast<ArrayType>(getVariableArrayType(NewEltTy, 34703fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall VAT->getSizeExpr(), 3471c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner VAT->getSizeModifier(), 34720953e767ff7817f97b3ab20896b229891eeff45bJohn McCall VAT->getIndexTypeCVRQualifiers(), 34737e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor VAT->getBracketsRange())); 347477c9647cae939104c6cb2b6a4dd8ca859d2e5770Chris Lattner} 347577c9647cae939104c6cb2b6a4dd8ca859d2e5770Chris Lattner 347679e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas GregorQualType ASTContext::getAdjustedParameterType(QualType T) { 347779e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // C99 6.7.5.3p7: 347879e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // A declaration of a parameter as "array of type" shall be 347979e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // adjusted to "qualified pointer to type", where the type 348079e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // qualifiers (if any) are those specified within the [ and ] of 348179e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // the array type derivation. 348279e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor if (T->isArrayType()) 348379e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return getArrayDecayedType(T); 348479e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 348579e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // C99 6.7.5.3p8: 348679e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // A declaration of a parameter as "function returning type" 348779e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // shall be adjusted to "pointer to function returning type", as 348879e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // in 6.3.2.1. 348979e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor if (T->isFunctionType()) 349079e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return getPointerType(T); 349179e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 349279e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return T; 349379e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor} 349479e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 349579e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas GregorQualType ASTContext::getSignatureParameterType(QualType T) { 349679e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor T = getVariableArrayDecayedType(T); 349779e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor T = getAdjustedParameterType(T); 349879e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return T.getUnqualifiedType(); 349979e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor} 350079e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 3501e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// getArrayDecayedType - Return the properly qualified result of decaying the 3502e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// specified array type to a pointer. This operation is non-trivial when 3503e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// handling typedefs etc. The canonical type of "T" must be an array type, 3504e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// this returns a pointer to a properly qualified element of the array. 3505e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// 3506e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// See C99 6.7.5.3p7 and C99 6.3.2.1p3. 35074ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getArrayDecayedType(QualType Ty) const { 3508c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Get the element type with 'getAsArrayType' so that we don't lose any 3509c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // typedefs in the element type of the array. This also handles propagation 3510c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // of type qualifiers from the array type into the element type if present 3511c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // (C99 6.7.3p8). 3512c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner const ArrayType *PrettyArrayType = getAsArrayType(Ty); 3513c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner assert(PrettyArrayType && "Not an array type!"); 35141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3515c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner QualType PtrTy = getPointerType(PrettyArrayType->getElementType()); 3516e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner 3517e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner // int x[restrict 4] -> int *restrict 35180953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return getQualifiedType(PtrTy, PrettyArrayType->getIndexTypeQualifiers()); 3519e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner} 3520e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner 35213b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getBaseElementType(const ArrayType *array) const { 35223b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return getBaseElementType(array->getElementType()); 35235e03f9ea8174ae588c5e69ec6b5ef4c68f8fd766Douglas Gregor} 35245e03f9ea8174ae588c5e69ec6b5ef4c68f8fd766Douglas Gregor 35253b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getBaseElementType(QualType type) const { 35263b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Qualifiers qs; 35273b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall while (true) { 35283b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType split = type.getSplitDesugaredType(); 3529200fa53fd420aa8369586f569dbece04930ad6a3John McCall const ArrayType *array = split.Ty->getAsArrayTypeUnsafe(); 35303b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!array) break; 35311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 35323b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall type = array->getElementType(); 3533200fa53fd420aa8369586f569dbece04930ad6a3John McCall qs.addConsistentQualifiers(split.Quals); 35343b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall } 35351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 35363b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return getQualifiedType(type, qs); 35376183a99b064b397d98297904fbd6cf00fe1f453dAnders Carlsson} 35386183a99b064b397d98297904fbd6cf00fe1f453dAnders Carlsson 35390de78998e7bda473b408437053e48661b510d453Fariborz Jahanian/// getConstantArrayElementCount - Returns number of constant array elements. 35401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpuint64_t 35410de78998e7bda473b408437053e48661b510d453Fariborz JahanianASTContext::getConstantArrayElementCount(const ConstantArrayType *CA) const { 35420de78998e7bda473b408437053e48661b510d453Fariborz Jahanian uint64_t ElementCount = 1; 35430de78998e7bda473b408437053e48661b510d453Fariborz Jahanian do { 35440de78998e7bda473b408437053e48661b510d453Fariborz Jahanian ElementCount *= CA->getSize().getZExtValue(); 35450de78998e7bda473b408437053e48661b510d453Fariborz Jahanian CA = dyn_cast<ConstantArrayType>(CA->getElementType()); 35460de78998e7bda473b408437053e48661b510d453Fariborz Jahanian } while (CA); 35470de78998e7bda473b408437053e48661b510d453Fariborz Jahanian return ElementCount; 35480de78998e7bda473b408437053e48661b510d453Fariborz Jahanian} 35490de78998e7bda473b408437053e48661b510d453Fariborz Jahanian 35505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getFloatingRank - Return a relative rank for floating point types. 35515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// This routine will assert if passed a built-in type that isn't a float. 3552a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattnerstatic FloatingRank getFloatingRank(QualType T) { 3553183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ComplexType *CT = T->getAs<ComplexType>()) 35545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return getFloatingRank(CT->getElementType()); 3555a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner 3556183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall assert(T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type"); 3557183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall switch (T->getAs<BuiltinType>()->getKind()) { 3558b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("getFloatingRank(): not a floating type"); 3559aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov case BuiltinType::Half: return HalfRank; 35605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Float: return FloatRank; 35615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Double: return DoubleRank; 35625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::LongDouble: return LongDoubleRank; 35635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 35645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 35655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 35661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getFloatingTypeOfSizeWithinDomain - Returns a real floating 35671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// point or a complex type (based on typeDomain/typeSize). 3568716c7304ff5d27a95e1e7823acd1d09d5ec3e37fSteve Naroff/// 'typeDomain' is a real floating point or complex type. 3569716c7304ff5d27a95e1e7823acd1d09d5ec3e37fSteve Naroff/// 'typeSize' is a real floating point or complex type. 35701361b11066239ea15764a2a844405352d87296b3Chris LattnerQualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size, 35711361b11066239ea15764a2a844405352d87296b3Chris Lattner QualType Domain) const { 35721361b11066239ea15764a2a844405352d87296b3Chris Lattner FloatingRank EltRank = getFloatingRank(Size); 35731361b11066239ea15764a2a844405352d87296b3Chris Lattner if (Domain->isComplexType()) { 35741361b11066239ea15764a2a844405352d87296b3Chris Lattner switch (EltRank) { 3575561d3abc881033776ece385a01a510e1cbc1fa92David Blaikie case HalfRank: llvm_unreachable("Complex half is not supported"); 3576f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff case FloatRank: return FloatComplexTy; 3577f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff case DoubleRank: return DoubleComplexTy; 3578f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff case LongDoubleRank: return LongDoubleComplexTy; 3579f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff } 3580f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff } 35811361b11066239ea15764a2a844405352d87296b3Chris Lattner 35821361b11066239ea15764a2a844405352d87296b3Chris Lattner assert(Domain->isRealFloatingType() && "Unknown domain!"); 35831361b11066239ea15764a2a844405352d87296b3Chris Lattner switch (EltRank) { 3584561d3abc881033776ece385a01a510e1cbc1fa92David Blaikie case HalfRank: llvm_unreachable("Half ranks are not valid here"); 35851361b11066239ea15764a2a844405352d87296b3Chris Lattner case FloatRank: return FloatTy; 35861361b11066239ea15764a2a844405352d87296b3Chris Lattner case DoubleRank: return DoubleTy; 35871361b11066239ea15764a2a844405352d87296b3Chris Lattner case LongDoubleRank: return LongDoubleTy; 35885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3589561d3abc881033776ece385a01a510e1cbc1fa92David Blaikie llvm_unreachable("getFloatingRank(): illegal value for rank"); 35905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 35915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 35927cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// getFloatingTypeOrder - Compare the rank of the two specified floating 35937cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// point types, ignoring the domain of the type (i.e. 'double' == 35947cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If 35951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// LHS < RHS, return -1. 35964ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadint ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) const { 3597a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner FloatingRank LHSR = getFloatingRank(LHS); 3598a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner FloatingRank RHSR = getFloatingRank(RHS); 35991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3600a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner if (LHSR == RHSR) 3601fb0d49669aa370b4c0993c5cee60275ef9fd6518Steve Naroff return 0; 3602a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner if (LHSR > RHSR) 3603fb0d49669aa370b4c0993c5cee60275ef9fd6518Steve Naroff return 1; 3604fb0d49669aa370b4c0993c5cee60275ef9fd6518Steve Naroff return -1; 36055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 36065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3607f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This 3608f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner/// routine will assert if passed a built-in type that isn't an integer or enum, 3609f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner/// or if it is not canonicalized. 3610f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCallunsigned ASTContext::getIntegerRank(const Type *T) const { 3611467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(T->isCanonicalUnqualified() && "T should be canonicalized"); 3612f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith 3613f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner switch (cast<BuiltinType>(T)->getKind()) { 3614b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("getIntegerRank(): not a built-in integer"); 36157cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Bool: 3616f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 1 + (getIntWidth(BoolTy) << 3); 36177cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Char_S: 36187cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Char_U: 36197cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::SChar: 36207cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::UChar: 3621f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 2 + (getIntWidth(CharTy) << 3); 36227cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Short: 36237cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::UShort: 3624f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 3 + (getIntWidth(ShortTy) << 3); 36257cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Int: 36267cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::UInt: 3627f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 4 + (getIntWidth(IntTy) << 3); 36287cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Long: 36297cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::ULong: 3630f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 5 + (getIntWidth(LongTy) << 3); 36317cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::LongLong: 36327cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::ULongLong: 3633f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 6 + (getIntWidth(LongLongTy) << 3); 36342df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::Int128: 36352df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::UInt128: 36362df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner return 7 + (getIntWidth(Int128Ty) << 3); 3637f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner } 3638f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner} 3639f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner 364004e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// \brief Whether this is a promotable bitfield reference according 364104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// to C99 6.3.1.1p2, bullet 2 (and GCC extensions). 364204e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// 364304e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// \returns the type this bit-field will promote to, or NULL if no 364404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// promotion occurs. 36454ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::isPromotableBitField(Expr *E) const { 3646ceafbdeb93ecf323cca74e660bf54504c86f3b71Douglas Gregor if (E->isTypeDependent() || E->isValueDependent()) 3647ceafbdeb93ecf323cca74e660bf54504c86f3b71Douglas Gregor return QualType(); 3648ceafbdeb93ecf323cca74e660bf54504c86f3b71Douglas Gregor 364904e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman FieldDecl *Field = E->getBitField(); 365004e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman if (!Field) 365104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return QualType(); 365204e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 365304e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman QualType FT = Field->getType(); 365404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 3655a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith uint64_t BitWidth = Field->getBitWidthValue(*this); 365604e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman uint64_t IntSize = getTypeSize(IntTy); 365704e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // GCC extension compatibility: if the bit-field size is less than or equal 365804e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // to the size of int, it gets promoted no matter what its type is. 365904e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // For instance, unsigned long bf : 4 gets promoted to signed int. 366004e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman if (BitWidth < IntSize) 366104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return IntTy; 366204e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 366304e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman if (BitWidth == IntSize) 366404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return FT->isSignedIntegerType() ? IntTy : UnsignedIntTy; 366504e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 366604e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // Types bigger than int are not subject to promotions, and therefore act 366704e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // like the base type. 366804e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // FIXME: This doesn't quite match what gcc does, but what gcc does here 366904e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // is ridiculous. 367004e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return QualType(); 367104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman} 367204e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 3673a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman/// getPromotedIntegerType - Returns the type that Promotable will 3674a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman/// promote to: C99 6.3.1.1p2, assuming that Promotable is a promotable 3675a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman/// integer type. 36764ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getPromotedIntegerType(QualType Promotable) const { 3677a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman assert(!Promotable.isNull()); 3678a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman assert(Promotable->isPromotableIntegerType()); 3679842aef8d942a880eeb9535d40de31a86838264cbJohn McCall if (const EnumType *ET = Promotable->getAs<EnumType>()) 3680842aef8d942a880eeb9535d40de31a86838264cbJohn McCall return ET->getDecl()->getPromotionType(); 368168a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman 368268a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman if (const BuiltinType *BT = Promotable->getAs<BuiltinType>()) { 368368a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // C++ [conv.prom]: A prvalue of type char16_t, char32_t, or wchar_t 368468a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // (3.9.1) can be converted to a prvalue of the first of the following 368568a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // types that can represent all the values of its underlying type: 368668a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // int, unsigned int, long int, unsigned long int, long long int, or 368768a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // unsigned long long int [...] 368868a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // FIXME: Is there some better way to compute this? 368968a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman if (BT->getKind() == BuiltinType::WChar_S || 369068a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman BT->getKind() == BuiltinType::WChar_U || 369168a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman BT->getKind() == BuiltinType::Char16 || 369268a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman BT->getKind() == BuiltinType::Char32) { 369368a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman bool FromIsSigned = BT->getKind() == BuiltinType::WChar_S; 369468a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman uint64_t FromSize = getTypeSize(BT); 369568a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman QualType PromoteTypes[] = { IntTy, UnsignedIntTy, LongTy, UnsignedLongTy, 369668a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman LongLongTy, UnsignedLongLongTy }; 369768a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman for (size_t Idx = 0; Idx < llvm::array_lengthof(PromoteTypes); ++Idx) { 369868a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman uint64_t ToSize = getTypeSize(PromoteTypes[Idx]); 369968a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman if (FromSize < ToSize || 370068a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman (FromSize == ToSize && 370168a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) 370268a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman return PromoteTypes[Idx]; 370368a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman } 370468a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman llvm_unreachable("char type should fit into long long"); 370568a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman } 370668a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman } 370768a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman 370868a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // At this point, we should have a signed or unsigned integer type. 3709a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman if (Promotable->isSignedIntegerType()) 3710a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman return IntTy; 3711a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman uint64_t PromotableSize = getTypeSize(Promotable); 3712a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman uint64_t IntSize = getTypeSize(IntTy); 3713a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman assert(Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize); 3714a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman return (PromotableSize != IntSize) ? IntTy : UnsignedIntTy; 3715a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman} 3716a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman 371731862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis/// \brief Recurses in pointer/array types until it finds an objc retainable 371831862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis/// type and returns its ownership. 371931862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios KyrtzidisQualifiers::ObjCLifetime ASTContext::getInnerObjCOwnership(QualType T) const { 372031862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis while (!T.isNull()) { 372131862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis if (T.getObjCLifetime() != Qualifiers::OCL_None) 372231862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis return T.getObjCLifetime(); 372331862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis if (T->isArrayType()) 372431862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis T = getBaseElementType(T); 372531862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis else if (const PointerType *PT = T->getAs<PointerType>()) 372631862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis T = PT->getPointeeType(); 372731862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis else if (const ReferenceType *RT = T->getAs<ReferenceType>()) 372828445f0b62f6aed851ff87ce64d9b19200d3211fArgyrios Kyrtzidis T = RT->getPointeeType(); 372931862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis else 373031862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis break; 373131862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis } 373231862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis 373331862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis return Qualifiers::OCL_None; 373431862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis} 373531862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis 37361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getIntegerTypeOrder - Returns the highest ranked integer type: 37377cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If 37381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// LHS < RHS, return -1. 37394ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadint ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) const { 3740f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall const Type *LHSC = getCanonicalType(LHS).getTypePtr(); 3741f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall const Type *RHSC = getCanonicalType(RHS).getTypePtr(); 37427cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSC == RHSC) return 0; 37431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3744f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner bool LHSUnsigned = LHSC->isUnsignedIntegerType(); 3745f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner bool RHSUnsigned = RHSC->isUnsignedIntegerType(); 37461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37477cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner unsigned LHSRank = getIntegerRank(LHSC); 37487cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner unsigned RHSRank = getIntegerRank(RHSC); 37491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37507cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned. 37517cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSRank == RHSRank) return 0; 37527cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return LHSRank > RHSRank ? 1 : -1; 37537cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner } 37541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37557cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // Otherwise, the LHS is signed and the RHS is unsigned or visa versa. 37567cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSUnsigned) { 37577cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the unsigned [LHS] type is larger, return it. 37587cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSRank >= RHSRank) 37597cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return 1; 37601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37617cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the signed type can represent all values of the unsigned type, it 37627cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // wins. Because we are dealing with 2's complement and types that are 37631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // powers of two larger than each other, this is always safe. 37647cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return -1; 37657cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner } 37667cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner 37677cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the unsigned [RHS] type is larger, return it. 37687cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (RHSRank >= LHSRank) 37697cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return -1; 37701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37717cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the signed type can represent all values of the unsigned type, it 37727cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // wins. Because we are dealing with 2's complement and types that are 37731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // powers of two larger than each other, this is always safe. 37747cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return 1; 37755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 377671993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson 377779cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlssonstatic RecordDecl * 3778ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo BagnaraCreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK, 3779ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara DeclContext *DC, IdentifierInfo *Id) { 3780ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara SourceLocation Loc; 37814e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (Ctx.getLangOpts().CPlusPlus) 3782ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 378379cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson else 3784ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 378579cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson} 3786ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara 37871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump// getCFConstantStringType - Return the type used for constant CFStrings. 37884ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getCFConstantStringType() const { 378971993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson if (!CFConstantStringTypeDecl) { 37901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump CFConstantStringTypeDecl = 3791ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara CreateRecordDecl(*this, TTK_Struct, TUDecl, 379279cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson &Idents.get("NSConstantString")); 37935cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall CFConstantStringTypeDecl->startDefinition(); 379479cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson 3795f06273f8bbacb086a46bde456429c8d08f6d07eeAnders Carlsson QualType FieldTypes[4]; 37961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 379771993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson // const int *isa; 37980953e767ff7817f97b3ab20896b229891eeff45bJohn McCall FieldTypes[0] = getPointerType(IntTy.withConst()); 3799f06273f8bbacb086a46bde456429c8d08f6d07eeAnders Carlsson // int flags; 3800f06273f8bbacb086a46bde456429c8d08f6d07eeAnders Carlsson FieldTypes[1] = IntTy; 380171993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson // const char *str; 38020953e767ff7817f97b3ab20896b229891eeff45bJohn McCall FieldTypes[2] = getPointerType(CharTy.withConst()); 380371993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson // long length; 38041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump FieldTypes[3] = LongTy; 38051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 380644b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor // Create fields 380744b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor for (unsigned i = 0; i < 4; ++i) { 38081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump FieldDecl *Field = FieldDecl::Create(*this, CFConstantStringTypeDecl, 3809ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara SourceLocation(), 381044b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor SourceLocation(), 0, 3811a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 38121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump /*BitWidth=*/0, 38137a614d8380297fcd2bc23986241905d97222948cRichard Smith /*Mutable=*/false, 38147a614d8380297fcd2bc23986241905d97222948cRichard Smith /*HasInit=*/false); 38152888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 381617945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis CFConstantStringTypeDecl->addDecl(Field); 381744b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor } 381844b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor 3819838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor CFConstantStringTypeDecl->completeDefinition(); 382071993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson } 38211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 382271993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson return getTagDeclType(CFConstantStringTypeDecl); 38238467583c2704e7a9691ea56939a029015f0ade0aGabor Greif} 3824b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson 3825319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregorvoid ASTContext::setCFConstantStringType(QualType T) { 38266217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek const RecordType *Rec = T->getAs<RecordType>(); 3827319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor assert(Rec && "Invalid CFConstantStringType"); 3828319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor CFConstantStringTypeDecl = Rec->getDecl(); 3829319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor} 3830319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor 38314ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getBlockDescriptorType() const { 3832adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump if (BlockDescriptorType) 3833adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump return getTagDeclType(BlockDescriptorType); 3834adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3835adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump RecordDecl *T; 3836adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump // FIXME: Needs the FlagAppleBlock bit. 3837ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara T = CreateRecordDecl(*this, TTK_Struct, TUDecl, 383879cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson &Idents.get("__block_descriptor")); 38395cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall T->startDefinition(); 3840adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3841adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump QualType FieldTypes[] = { 3842adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump UnsignedLongTy, 3843adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump UnsignedLongTy, 3844adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump }; 3845adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3846adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump const char *FieldNames[] = { 3847adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump "reserved", 3848083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "Size" 3849adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump }; 3850adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3851adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump for (size_t i = 0; i < 2; ++i) { 3852ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 3853adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump SourceLocation(), 3854adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump &Idents.get(FieldNames[i]), 3855a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 3856adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump /*BitWidth=*/0, 38577a614d8380297fcd2bc23986241905d97222948cRichard Smith /*Mutable=*/false, 38587a614d8380297fcd2bc23986241905d97222948cRichard Smith /*HasInit=*/false); 38592888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 3860adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump T->addDecl(Field); 3861adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump } 3862adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3863838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor T->completeDefinition(); 3864adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3865adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump BlockDescriptorType = T; 3866adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3867adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump return getTagDeclType(BlockDescriptorType); 3868adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump} 3869adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 38704ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getBlockDescriptorExtendedType() const { 3871083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump if (BlockDescriptorExtendedType) 3872083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump return getTagDeclType(BlockDescriptorExtendedType); 3873083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3874083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump RecordDecl *T; 3875083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump // FIXME: Needs the FlagAppleBlock bit. 3876ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara T = CreateRecordDecl(*this, TTK_Struct, TUDecl, 387779cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson &Idents.get("__block_descriptor_withcopydispose")); 38785cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall T->startDefinition(); 3879083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3880083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump QualType FieldTypes[] = { 3881083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump UnsignedLongTy, 3882083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump UnsignedLongTy, 3883083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump getPointerType(VoidPtrTy), 3884083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump getPointerType(VoidPtrTy) 3885083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump }; 3886083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3887083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump const char *FieldNames[] = { 3888083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "reserved", 3889083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "Size", 3890083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "CopyFuncPtr", 3891083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "DestroyFuncPtr" 3892083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump }; 3893083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3894083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump for (size_t i = 0; i < 4; ++i) { 3895ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 3896083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump SourceLocation(), 3897083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump &Idents.get(FieldNames[i]), 3898a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 3899083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump /*BitWidth=*/0, 39007a614d8380297fcd2bc23986241905d97222948cRichard Smith /*Mutable=*/false, 39017a614d8380297fcd2bc23986241905d97222948cRichard Smith /*HasInit=*/false); 39022888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 3903083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump T->addDecl(Field); 3904083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump } 3905083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3906838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor T->completeDefinition(); 3907083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3908083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump BlockDescriptorExtendedType = T; 3909083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3910083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump return getTagDeclType(BlockDescriptorExtendedType); 3911083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump} 3912083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 39134ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadbool ASTContext::BlockRequiresCopying(QualType Ty) const { 3914f85e193739c953358c865005855253af4f68a497John McCall if (Ty->isObjCRetainableType()) 3915af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump return true; 39164e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (getLangOpts().CPlusPlus) { 3917e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian if (const RecordType *RT = Ty->getAs<RecordType>()) { 3918e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 3919ffe37fdda5b4b4f162a45155c30d9f60ce110c12Sean Hunt return RD->hasConstCopyConstructor(); 3920e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian 3921e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian } 3922e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian } 3923af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump return false; 3924af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump} 3925af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 39264ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 39275f9e272e632e951b1efe824cd16acb4d96077930Chris LattnerASTContext::BuildByRefType(StringRef DeclName, QualType Ty) const { 3928af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // type = struct __Block_byref_1_X { 3929ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // void *__isa; 3930af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // struct __Block_byref_1_X *__forwarding; 3931ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // unsigned int __flags; 3932ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // unsigned int __size; 3933a7e6845660f91ec611427e1db842780e1ec12bdbEli Friedman // void *__copy_helper; // as needed 3934a7e6845660f91ec611427e1db842780e1ec12bdbEli Friedman // void *__destroy_help // as needed 3935af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // int X; 3936ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // } * 3937ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump 3938af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump bool HasCopyAndDispose = BlockRequiresCopying(Ty); 3939af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3940af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // FIXME: Move up 3941f7ccbad5d9949e7ddd1cbef43d482553b811e026Dylan Noblesmith SmallString<36> Name; 3942f5942a44880be26878592eb052b737579349411eBenjamin Kramer llvm::raw_svector_ostream(Name) << "__Block_byref_" << 3943f5942a44880be26878592eb052b737579349411eBenjamin Kramer ++UniqueBlockByRefTypeID << '_' << DeclName; 3944af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump RecordDecl *T; 3945ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara T = CreateRecordDecl(*this, TTK_Struct, TUDecl, &Idents.get(Name.str())); 3946af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump T->startDefinition(); 3947af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump QualType Int32Ty = IntTy; 3948af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump assert(getIntWidth(IntTy) == 32 && "non-32bit int not supported"); 3949af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump QualType FieldTypes[] = { 3950af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(VoidPtrTy), 3951af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(getTagDeclType(T)), 3952af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump Int32Ty, 3953af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump Int32Ty, 3954af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(VoidPtrTy), 3955af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(VoidPtrTy), 3956af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump Ty 3957af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump }; 3958af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 39595f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner StringRef FieldNames[] = { 3960af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__isa", 3961af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__forwarding", 3962af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__flags", 3963af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__size", 3964af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__copy_helper", 3965af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__destroy_helper", 3966af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump DeclName, 3967af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump }; 3968af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3969af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump for (size_t i = 0; i < 7; ++i) { 3970af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump if (!HasCopyAndDispose && i >=4 && i <= 5) 3971af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump continue; 3972af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 3973ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara SourceLocation(), 3974af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump &Idents.get(FieldNames[i]), 3975a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 39767a614d8380297fcd2bc23986241905d97222948cRichard Smith /*BitWidth=*/0, /*Mutable=*/false, 39777a614d8380297fcd2bc23986241905d97222948cRichard Smith /*HasInit=*/false); 39782888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 3979af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump T->addDecl(Field); 3980af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump } 3981af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3982838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor T->completeDefinition(); 3983af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3984af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump return getPointerType(getTagDeclType(T)); 3985ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump} 3986ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump 3987e97179c675b341927807c718be215c8d1aab8acbDouglas GregorTypedefDecl *ASTContext::getObjCInstanceTypeDecl() { 3988e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor if (!ObjCInstanceTypeDecl) 3989e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor ObjCInstanceTypeDecl = TypedefDecl::Create(*this, 3990e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor getTranslationUnitDecl(), 3991e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor SourceLocation(), 3992e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor SourceLocation(), 3993e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor &Idents.get("instancetype"), 3994e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor getTrivialTypeSourceInfo(getObjCIdType())); 3995e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor return ObjCInstanceTypeDecl; 3996e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor} 3997e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor 3998e8c49533521c40643653f943d47229e62d277f88Anders Carlsson// This returns true if a type has been typedefed to BOOL: 3999e8c49533521c40643653f943d47229e62d277f88Anders Carlsson// typedef <type> BOOL; 40002d99833e8c956775f2183601cd120b65b569c867Chris Lattnerstatic bool isTypeTypedefedAsBOOL(QualType T) { 4001e8c49533521c40643653f943d47229e62d277f88Anders Carlsson if (const TypedefType *TT = dyn_cast<TypedefType>(T)) 4002bb49c3ee5d270485f4b273691fd14bc97403fa5dChris Lattner if (IdentifierInfo *II = TT->getDecl()->getIdentifier()) 4003bb49c3ee5d270485f4b273691fd14bc97403fa5dChris Lattner return II->isStr("BOOL"); 40041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 400585f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson return false; 400685f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson} 400785f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson 4008a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek/// getObjCEncodingTypeSize returns size of type for objective-c encoding 400933e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian/// purpose. 40104ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getObjCEncodingTypeSize(QualType type) const { 4011f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor if (!type->isIncompleteArrayType() && type->isIncompleteType()) 4012f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return CharUnits::Zero(); 4013f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4014199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits sz = getTypeSizeInChars(type); 40151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 401633e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Make all integer and enum types at least as large as an int 40172ade35e2cfd554e49d35a52047cea98a82787af9Douglas Gregor if (sz.isPositive() && type->isIntegralOrEnumerationType()) 4018199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck sz = std::max(sz, getTypeSizeInChars(IntTy)); 401933e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Treat arrays as pointers, since that's how they're passed in. 402033e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian else if (type->isArrayType()) 4021199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck sz = getTypeSizeInChars(VoidPtrTy); 4022aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck return sz; 4023199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck} 4024199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck 4025199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyckstatic inline 4026199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyckstd::string charUnitsToString(const CharUnits &CU) { 4027199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck return llvm::itostr(CU.getQuantity()); 402833e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian} 402933e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian 40306b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall/// getObjCEncodingForBlock - Return the encoded type for this block 40315e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall/// declaration. 40326b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCallstd::string ASTContext::getObjCEncodingForBlock(const BlockExpr *Expr) const { 40336b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall std::string S; 40346b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall 40355e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall const BlockDecl *Decl = Expr->getBlockDecl(); 40365e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall QualType BlockTy = 40375e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall Expr->getType()->getAs<BlockPointerType>()->getPointeeType(); 40385e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Encode result type. 4039c71a4915ca216847599d03cab4ed1c5086b0eb43John McCall getObjCEncodingForType(BlockTy->getAs<FunctionType>()->getResultType(), S); 40405e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Compute size of all parameters. 40415e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Start with computing size of a pointer in number of bytes. 40425e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // FIXME: There might(should) be a better way of doing this computation! 40435e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall SourceLocation Loc; 4044199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy); 4045199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits ParmOffset = PtrSize; 40466f46c2653c1545cc3fef0c0df996d18160160ce8Fariborz Jahanian for (BlockDecl::param_const_iterator PI = Decl->param_begin(), 40475e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall E = Decl->param_end(); PI != E; ++PI) { 40485e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall QualType PType = (*PI)->getType(); 4049aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck CharUnits sz = getObjCEncodingTypeSize(PType); 4050199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck assert (sz.isPositive() && "BlockExpr - Incomplete param type"); 40515e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall ParmOffset += sz; 40525e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall } 40535e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Size of the argument frame 4054199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 40555e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Block pointer and offset. 40565e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall S += "@?0"; 40575e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall 40585e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Argument types. 40595e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall ParmOffset = PtrSize; 40605e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall for (BlockDecl::param_const_iterator PI = Decl->param_begin(), E = 40615e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall Decl->param_end(); PI != E; ++PI) { 40625e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall ParmVarDecl *PVDecl = *PI; 40635e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall QualType PType = PVDecl->getOriginalType(); 40645e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall if (const ArrayType *AT = 40655e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 40665e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Use array's original type only if it has known number of 40675389f48b24937ad7b4093307128b3cbf25235654David Chisnall // elements. 40685389f48b24937ad7b4093307128b3cbf25235654David Chisnall if (!isa<ConstantArrayType>(AT)) 40695389f48b24937ad7b4093307128b3cbf25235654David Chisnall PType = PVDecl->getType(); 40705389f48b24937ad7b4093307128b3cbf25235654David Chisnall } else if (PType->isFunctionType()) 40715389f48b24937ad7b4093307128b3cbf25235654David Chisnall PType = PVDecl->getType(); 40725389f48b24937ad7b4093307128b3cbf25235654David Chisnall getObjCEncodingForType(PType, S); 40735389f48b24937ad7b4093307128b3cbf25235654David Chisnall S += charUnitsToString(ParmOffset); 40745389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmOffset += getObjCEncodingTypeSize(PType); 40755389f48b24937ad7b4093307128b3cbf25235654David Chisnall } 40766b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall 40776b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall return S; 40785389f48b24937ad7b4093307128b3cbf25235654David Chisnall} 40795389f48b24937ad7b4093307128b3cbf25235654David Chisnall 4080f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregorbool ASTContext::getObjCEncodingForFunctionDecl(const FunctionDecl *Decl, 40815389f48b24937ad7b4093307128b3cbf25235654David Chisnall std::string& S) { 40825389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Encode result type. 40835389f48b24937ad7b4093307128b3cbf25235654David Chisnall getObjCEncodingForType(Decl->getResultType(), S); 40845389f48b24937ad7b4093307128b3cbf25235654David Chisnall CharUnits ParmOffset; 40855389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Compute size of all parameters. 40865389f48b24937ad7b4093307128b3cbf25235654David Chisnall for (FunctionDecl::param_const_iterator PI = Decl->param_begin(), 40875389f48b24937ad7b4093307128b3cbf25235654David Chisnall E = Decl->param_end(); PI != E; ++PI) { 40885389f48b24937ad7b4093307128b3cbf25235654David Chisnall QualType PType = (*PI)->getType(); 40895389f48b24937ad7b4093307128b3cbf25235654David Chisnall CharUnits sz = getObjCEncodingTypeSize(PType); 4090f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor if (sz.isZero()) 4091f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return true; 4092f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 40935389f48b24937ad7b4093307128b3cbf25235654David Chisnall assert (sz.isPositive() && 4094f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor "getObjCEncodingForFunctionDecl - Incomplete param type"); 40955389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmOffset += sz; 40965389f48b24937ad7b4093307128b3cbf25235654David Chisnall } 40975389f48b24937ad7b4093307128b3cbf25235654David Chisnall S += charUnitsToString(ParmOffset); 40985389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmOffset = CharUnits::Zero(); 40995389f48b24937ad7b4093307128b3cbf25235654David Chisnall 41005389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Argument types. 41015389f48b24937ad7b4093307128b3cbf25235654David Chisnall for (FunctionDecl::param_const_iterator PI = Decl->param_begin(), 41025389f48b24937ad7b4093307128b3cbf25235654David Chisnall E = Decl->param_end(); PI != E; ++PI) { 41035389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmVarDecl *PVDecl = *PI; 41045389f48b24937ad7b4093307128b3cbf25235654David Chisnall QualType PType = PVDecl->getOriginalType(); 41055389f48b24937ad7b4093307128b3cbf25235654David Chisnall if (const ArrayType *AT = 41065389f48b24937ad7b4093307128b3cbf25235654David Chisnall dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 41075389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Use array's original type only if it has known number of 41085e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // elements. 41095e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall if (!isa<ConstantArrayType>(AT)) 41105e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall PType = PVDecl->getType(); 41115e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall } else if (PType->isFunctionType()) 41125e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall PType = PVDecl->getType(); 41135e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall getObjCEncodingForType(PType, S); 4114199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 4115aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck ParmOffset += getObjCEncodingTypeSize(PType); 41165e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall } 4117f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4118f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return false; 41195e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall} 41205e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall 4121dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson/// getObjCEncodingForMethodParameter - Return the encoded type for a single 4122dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson/// method parameter or return type. If Extended, include class names and 4123dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson/// block object types. 4124dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilsonvoid ASTContext::getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT, 4125dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson QualType T, std::string& S, 4126dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool Extended) const { 4127dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Encode type qualifer, 'in', 'inout', etc. for the parameter. 4128dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeQualifier(QT, S); 4129dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Encode parameter type. 4130dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeImpl(T, S, true, true, 0, 4131dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson true /*OutermostType*/, 4132dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /*EncodingProperty*/, 4133dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /*StructField*/, 4134dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson Extended /*EncodeBlockParameters*/, 4135dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson Extended /*EncodeClassNames*/); 4136dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson} 4137dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson 4138a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek/// getObjCEncodingForMethodDecl - Return the encoded type for this method 413933e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian/// declaration. 4140f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregorbool ASTContext::getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl, 4141dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson std::string& S, 4142dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool Extended) const { 4143c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: This is not very efficient. 4144dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Encode return type. 4145dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForMethodParameter(Decl->getObjCDeclQualifier(), 4146dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson Decl->getResultType(), S, Extended); 414733e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Compute size of all parameters. 414833e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Start with computing size of a pointer in number of bytes. 414933e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // FIXME: There might(should) be a better way of doing this computation! 415033e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian SourceLocation Loc; 4151199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy); 415233e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // The first two arguments (self and _cmd) are pointers; account for 415333e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // their size. 4154199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits ParmOffset = 2 * PtrSize; 4155491306a83c4f0f49f95a3bcbca8580cb98a91c7aArgyrios Kyrtzidis for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(), 41567732cc9c0fdc97a2f8cce4e5933d8103213d1aefFariborz Jahanian E = Decl->sel_param_end(); PI != E; ++PI) { 415789951a86b594513c2a013532ed45d197413b1087Chris Lattner QualType PType = (*PI)->getType(); 4158aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck CharUnits sz = getObjCEncodingTypeSize(PType); 4159f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor if (sz.isZero()) 4160f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return true; 4161f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4162199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck assert (sz.isPositive() && 4163199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck "getObjCEncodingForMethodDecl - Incomplete param type"); 416433e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian ParmOffset += sz; 416533e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian } 4166199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 416733e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian S += "@0:"; 4168199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(PtrSize); 41691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 417033e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Argument types. 417133e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian ParmOffset = 2 * PtrSize; 4172491306a83c4f0f49f95a3bcbca8580cb98a91c7aArgyrios Kyrtzidis for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(), 41737732cc9c0fdc97a2f8cce4e5933d8103213d1aefFariborz Jahanian E = Decl->sel_param_end(); PI != E; ++PI) { 4174491306a83c4f0f49f95a3bcbca8580cb98a91c7aArgyrios Kyrtzidis const ParmVarDecl *PVDecl = *PI; 41751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType PType = PVDecl->getOriginalType(); 41764306d3cb9116605728252e2738df24b9f6ab53c3Fariborz Jahanian if (const ArrayType *AT = 4177ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 4178ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff // Use array's original type only if it has known number of 4179ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff // elements. 4180bb3fde337fb712c0e6da8790d431621be4793048Steve Naroff if (!isa<ConstantArrayType>(AT)) 4181ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff PType = PVDecl->getType(); 4182ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff } else if (PType->isFunctionType()) 4183ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff PType = PVDecl->getType(); 4184dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForMethodParameter(PVDecl->getObjCDeclQualifier(), 4185dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson PType, S, Extended); 4186199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 4187aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck ParmOffset += getObjCEncodingTypeSize(PType); 418833e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian } 4189f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4190f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return false; 419133e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian} 419233e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian 4193c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar/// getObjCEncodingForPropertyDecl - Return the encoded type for this 419483bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// property declaration. If non-NULL, Container must be either an 4195c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar/// ObjCCategoryImplDecl or ObjCImplementationDecl; it should only be 4196c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar/// NULL when getting encodings for protocol properties. 41971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// Property attributes are stored as a comma-delimited C string. The simple 41981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// attributes readonly and bycopy are encoded as single characters. The 41991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// parametrized attributes, getter=name, setter=name, and ivar=name, are 42001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// encoded as single characters, followed by an identifier. Property types 42011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// are also encoded as a parametrized attribute. The characters used to encode 420283bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// these attributes are defined by the following enumeration: 420383bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// @code 420483bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// enum PropertyAttributes { 420583bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyReadOnly = 'R', // property is read-only. 420683bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyBycopy = 'C', // property is a copy of the value last assigned 420783bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyByref = '&', // property is a reference to the value last assigned 420883bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyDynamic = 'D', // property is dynamic 420983bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyGetter = 'G', // followed by getter selector name 421083bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertySetter = 'S', // followed by setter selector name 421183bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyInstanceVariable = 'V' // followed by instance variable name 42120d4cb85130d91da61c45aecb9fd31c7097a7cfccBob Wilson/// kPropertyType = 'T' // followed by old-style type encoding. 421383bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyWeak = 'W' // 'weak' property 421483bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyStrong = 'P' // property GC'able 421583bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyNonAtomic = 'N' // property non-atomic 421683bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// }; 421783bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// @endcode 42181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid ASTContext::getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD, 4219c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar const Decl *Container, 42204ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad std::string& S) const { 4221c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // Collect information from the property implementation decl(s). 4222c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar bool Dynamic = false; 4223c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar ObjCPropertyImplDecl *SynthesizePID = 0; 4224c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4225c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: Duplicated code due to poor abstraction. 4226c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (Container) { 42271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const ObjCCategoryImplDecl *CID = 4228c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar dyn_cast<ObjCCategoryImplDecl>(Container)) { 4229c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar for (ObjCCategoryImplDecl::propimpl_iterator 423017945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis i = CID->propimpl_begin(), e = CID->propimpl_end(); 4231653f1b1bf293a9bd96fd4dd6372e779cc7af1597Douglas Gregor i != e; ++i) { 4232262bc18e32500558af7cb0afa205b34bd37bafedDavid Blaikie ObjCPropertyImplDecl *PID = &*i; 4233c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyDecl() == PD) { 4234c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) { 4235c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar Dynamic = true; 4236c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 4237c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar SynthesizePID = PID; 4238c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4239c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4240c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4241c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 424261710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner const ObjCImplementationDecl *OID=cast<ObjCImplementationDecl>(Container); 4243c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar for (ObjCCategoryImplDecl::propimpl_iterator 424417945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis i = OID->propimpl_begin(), e = OID->propimpl_end(); 4245653f1b1bf293a9bd96fd4dd6372e779cc7af1597Douglas Gregor i != e; ++i) { 4246262bc18e32500558af7cb0afa205b34bd37bafedDavid Blaikie ObjCPropertyImplDecl *PID = &*i; 4247c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyDecl() == PD) { 4248c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) { 4249c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar Dynamic = true; 4250c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 4251c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar SynthesizePID = PID; 4252c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4253c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 42541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 4255c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4256c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4257c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4258c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: This is not very efficient. 4259c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S = "T"; 4260c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4261c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // Encode result type. 4262090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian // GCC has some special rules regarding encoding of properties which 4263090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian // closely resembles encoding of ivars. 42641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(PD->getType(), S, true, true, 0, 4265090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian true /* outermost type */, 4266090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian true /* encoding for property */); 4267c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4268c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PD->isReadOnly()) { 4269c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",R"; 4270c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 4271c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar switch (PD->getSetterKind()) { 4272c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case ObjCPropertyDecl::Assign: break; 4273c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case ObjCPropertyDecl::Copy: S += ",C"; break; 42741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case ObjCPropertyDecl::Retain: S += ",&"; break; 42753a02b44e3948f7762dbfba94b7961281ca29d022Fariborz Jahanian case ObjCPropertyDecl::Weak: S += ",W"; break; 4276c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4277c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4278c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4279c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // It really isn't clear at all what this means, since properties 4280c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // are "dynamic by default". 4281c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (Dynamic) 4282c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",D"; 4283c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4284090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic) 4285090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian S += ",N"; 42861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4287c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) { 4288c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",G"; 4289077bf5e2f48acfa9e7d69429b6e4ba86ea14896dChris Lattner S += PD->getGetterName().getAsString(); 4290c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4291c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4292c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) { 4293c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",S"; 4294077bf5e2f48acfa9e7d69429b6e4ba86ea14896dChris Lattner S += PD->getSetterName().getAsString(); 4295c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4296c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4297c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (SynthesizePID) { 4298c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar const ObjCIvarDecl *OID = SynthesizePID->getPropertyIvarDecl(); 4299c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",V"; 430039f34e97d6a468f0a7dfa5664c61217cffc65b74Chris Lattner S += OID->getNameAsString(); 4301c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4302c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4303c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: OBJCGC: weak & strong 4304c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar} 4305c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4306a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian/// getLegacyIntegralTypeEncoding - 43071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// Another legacy compatibility encoding: 32-bit longs are encoded as 43081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// 'l' or 'L' , but not always. For typedefs, we need to use 4309a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian/// 'i' or 'I' instead if encoding a struct field, or a pointer! 4310a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian/// 4311a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanianvoid ASTContext::getLegacyIntegralTypeEncoding (QualType &PointeeTy) const { 43128e1fab243ab8023b7ee3899745386b3b3a4258f8Mike Stump if (isa<TypedefType>(PointeeTy.getTypePtr())) { 4313183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const BuiltinType *BT = PointeeTy->getAs<BuiltinType>()) { 43144ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (BT->getKind() == BuiltinType::ULong && getIntWidth(PointeeTy) == 32) 4315a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian PointeeTy = UnsignedIntTy; 43161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump else 43174ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (BT->getKind() == BuiltinType::Long && getIntWidth(PointeeTy) == 32) 4318a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian PointeeTy = IntTy; 4319a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4320a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4321a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian} 4322a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian 43237d6b46d9a9d75dea8ef9f6973dd50633c1f37963Fariborz Jahanianvoid ASTContext::getObjCEncodingForType(QualType T, std::string& S, 43244ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const FieldDecl *Field) const { 432582a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // We follow the behavior of gcc, expanding structures which are 432682a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // directly pointed to, and expanding embedded structures. Note that 432782a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // these rules are sufficient to prevent recursive encoding of the 432882a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // same type. 43291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(T, S, true, true, Field, 43305b8c7d9fb620ba3a71e996d61e7b9bdf763b5c09Fariborz Jahanian true /* outermost type */); 433182a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar} 433282a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar 433364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnallstatic char ObjCEncodingForPrimitiveKind(const ASTContext *C, QualType T) { 433464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall switch (T->getAs<BuiltinType>()->getKind()) { 4335b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Unhandled builtin type kind"); 433664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Void: return 'v'; 433764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Bool: return 'B'; 433864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Char_U: 433964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UChar: return 'C'; 434064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UShort: return 'S'; 434164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UInt: return 'I'; 434264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::ULong: 43434ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad return C->getIntWidth(T) == 32 ? 'L' : 'Q'; 434464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UInt128: return 'T'; 434564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::ULongLong: return 'Q'; 434664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Char_S: 434764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::SChar: return 'c'; 434864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Short: return 's'; 43493f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_S: 43503f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_U: 435164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Int: return 'i'; 435264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Long: 43534ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad return C->getIntWidth(T) == 32 ? 'l' : 'q'; 435464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::LongLong: return 'q'; 435564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Int128: return 't'; 435664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Float: return 'f'; 435764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Double: return 'd'; 43583a0be84b2aed8563150cdbd976a98838afa261ebDaniel Dunbar case BuiltinType::LongDouble: return 'D'; 435964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall } 436064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall} 436164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall 43625471bc85b69912e3b448de004498a80c0de32296Douglas Gregorstatic char ObjCEncodingForEnumType(const ASTContext *C, const EnumType *ET) { 43635471bc85b69912e3b448de004498a80c0de32296Douglas Gregor EnumDecl *Enum = ET->getDecl(); 43645471bc85b69912e3b448de004498a80c0de32296Douglas Gregor 43655471bc85b69912e3b448de004498a80c0de32296Douglas Gregor // The encoding of an non-fixed enum type is always 'i', regardless of size. 43665471bc85b69912e3b448de004498a80c0de32296Douglas Gregor if (!Enum->isFixed()) 43675471bc85b69912e3b448de004498a80c0de32296Douglas Gregor return 'i'; 43685471bc85b69912e3b448de004498a80c0de32296Douglas Gregor 43695471bc85b69912e3b448de004498a80c0de32296Douglas Gregor // The encoding of a fixed enum type matches its fixed underlying type. 43705471bc85b69912e3b448de004498a80c0de32296Douglas Gregor return ObjCEncodingForPrimitiveKind(C, Enum->getIntegerType()); 43715471bc85b69912e3b448de004498a80c0de32296Douglas Gregor} 43725471bc85b69912e3b448de004498a80c0de32296Douglas Gregor 43734ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadstatic void EncodeBitField(const ASTContext *Ctx, std::string& S, 437464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall QualType T, const FieldDecl *FD) { 4375a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith assert(FD->isBitField() && "not a bitfield - getObjCEncodingForTypeImpl"); 43768b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian S += 'b'; 437764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // The NeXT runtime encodes bit fields as b followed by the number of bits. 437864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // The GNU runtime requires more information; bitfields are encoded as b, 437964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // then the offset (in bits) of the first element, then the type of the 438064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // bitfield, then the size in bits. For example, in this structure: 438164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // 438264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // struct 438364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // { 438464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // int integer; 438564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // int flags:2; 438664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // }; 438764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // On a 32-bit system, the encoding for flags would be b2 for the NeXT 438864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // runtime, but b32i2 for the GNU runtime. The reason for this extra 438964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // information is not especially sensible, but we're stuck with it for 439064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // compatibility with GCC, although providing it breaks anything that 439164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // actually uses runtime introspection and wants to work on both runtimes... 43924e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (!Ctx->getLangOpts().NeXTRuntime) { 439364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall const RecordDecl *RD = FD->getParent(); 439464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall const ASTRecordLayout &RL = Ctx->getASTRecordLayout(RD); 439582905749d5c8d8b4edec11de754a73349cb96603Eli Friedman S += llvm::utostr(RL.getFieldOffset(FD->getFieldIndex())); 43965471bc85b69912e3b448de004498a80c0de32296Douglas Gregor if (const EnumType *ET = T->getAs<EnumType>()) 43975471bc85b69912e3b448de004498a80c0de32296Douglas Gregor S += ObjCEncodingForEnumType(Ctx, ET); 4398c7ff82c2040f45eaad2eddea0e4461dddc972cd1David Chisnall else 43994ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad S += ObjCEncodingForPrimitiveKind(Ctx, T); 440064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall } 4401a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith S += llvm::utostr(FD->getBitWidthValue(*Ctx)); 44028b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian} 44038b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian 440401eb9b9683535d8a65c704ad2c545903409e2d36Daniel Dunbar// FIXME: Use SmallString for accumulating string. 440582a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbarvoid ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S, 440682a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar bool ExpandPointedToStructures, 440782a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar bool ExpandStructures, 4408153bfe5795e2c1a5a738e73d3784964e082237fcDaniel Dunbar const FieldDecl *FD, 4409090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian bool OutermostType, 44102636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis bool EncodingProperty, 4411dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool StructField, 4412dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool EncodeBlockParameters, 4413dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool EncodeClassNames) const { 441464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall if (T->getAs<BuiltinType>()) { 4415ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (FD && FD->isBitField()) 441664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall return EncodeBitField(this, S, T, FD); 441764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall S += ObjCEncodingForPrimitiveKind(this, T); 4418ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4419ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 44201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4421183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ComplexType *CT = T->getAs<ComplexType>()) { 4422c612f7bc9a6379cd7e7c2dd306d05938e890051bAnders Carlsson S += 'j'; 44231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(CT->getElementType(), S, false, false, 0, false, 4424c612f7bc9a6379cd7e7c2dd306d05938e890051bAnders Carlsson false); 4425ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4426ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 442760bce3ef20a4c9684e3825cdd739fefb9810327dFariborz Jahanian 4428aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian // encoding for pointer or r3eference types. 4429aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian QualType PointeeTy; 44306217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const PointerType *PT = T->getAs<PointerType>()) { 44318d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian if (PT->isObjCSelType()) { 44328d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian S += ':'; 44338d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian return; 44348d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian } 4435aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian PointeeTy = PT->getPointeeType(); 4436aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian } 4437aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian else if (const ReferenceType *RT = T->getAs<ReferenceType>()) 4438aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian PointeeTy = RT->getPointeeType(); 4439aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian if (!PointeeTy.isNull()) { 4440a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian bool isReadOnly = false; 4441a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // For historical/compatibility reasons, the read-only qualifier of the 4442a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // pointee gets emitted _before_ the '^'. The read-only qualifier of 4443a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // the pointer itself gets ignored, _unless_ we are looking at a typedef! 44441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Also, do not emit the 'r' for anything but the outermost type! 44458e1fab243ab8023b7ee3899745386b3b3a4258f8Mike Stump if (isa<TypedefType>(T.getTypePtr())) { 4446a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian if (OutermostType && T.isConstQualified()) { 4447a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian isReadOnly = true; 4448a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian S += 'r'; 4449a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 44509fdbab3cbc2fc04bcaf5768023d83707f3151144Mike Stump } else if (OutermostType) { 4451a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian QualType P = PointeeTy; 44526217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek while (P->getAs<PointerType>()) 44536217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek P = P->getAs<PointerType>()->getPointeeType(); 4454a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian if (P.isConstQualified()) { 4455a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian isReadOnly = true; 4456a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian S += 'r'; 4457a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4458a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4459a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian if (isReadOnly) { 4460a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // Another legacy compatibility encoding. Some ObjC qualifier and type 4461a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // combinations need to be rearranged. 4462a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // Rewrite "in const" from "nr" to "rn" 44635f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner if (StringRef(S).endswith("nr")) 44640237941e0beb0c929934b66ad29443b484d987feBenjamin Kramer S.replace(S.end()-2, S.end(), "rn"); 4465a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 44661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 446785f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson if (PointeeTy->isCharType()) { 446885f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson // char pointer types should be encoded as '*' unless it is a 446985f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson // type that has been typedef'd to 'BOOL'. 4470e8c49533521c40643653f943d47229e62d277f88Anders Carlsson if (!isTypeTypedefedAsBOOL(PointeeTy)) { 447185f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson S += '*'; 447285f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson return; 447385f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson } 44746217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek } else if (const RecordType *RTy = PointeeTy->getAs<RecordType>()) { 44759533a7fdb8397421f3be52e879442460a87389f6Steve Naroff // GCC binary compat: Need to convert "struct objc_class *" to "#". 44769533a7fdb8397421f3be52e879442460a87389f6Steve Naroff if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_class")) { 44779533a7fdb8397421f3be52e879442460a87389f6Steve Naroff S += '#'; 44789533a7fdb8397421f3be52e879442460a87389f6Steve Naroff return; 44799533a7fdb8397421f3be52e879442460a87389f6Steve Naroff } 44809533a7fdb8397421f3be52e879442460a87389f6Steve Naroff // GCC binary compat: Need to convert "struct objc_object *" to "@". 44819533a7fdb8397421f3be52e879442460a87389f6Steve Naroff if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_object")) { 44829533a7fdb8397421f3be52e879442460a87389f6Steve Naroff S += '@'; 44839533a7fdb8397421f3be52e879442460a87389f6Steve Naroff return; 44849533a7fdb8397421f3be52e879442460a87389f6Steve Naroff } 44859533a7fdb8397421f3be52e879442460a87389f6Steve Naroff // fall through... 448685f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson } 448785f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson S += '^'; 4488a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian getLegacyIntegralTypeEncoding(PointeeTy); 4489a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian 44901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(PointeeTy, S, false, ExpandPointedToStructures, 449143822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian NULL); 4492ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4493ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 4494aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian 4495ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (const ArrayType *AT = 4496ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner // Ignore type qualifiers etc. 4497ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner dyn_cast<ArrayType>(T->getCanonicalTypeInternal())) { 44982636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (isa<IncompleteArrayType>(AT) && !StructField) { 4499559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson // Incomplete arrays are encoded as a pointer to the array element. 4500559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += '^'; 4501559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson 45021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(AT->getElementType(), S, 4503559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson false, ExpandStructures, FD); 4504559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson } else { 4505559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += '['; 45061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45072636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) { 45082636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (getTypeSize(CAT->getElementType()) == 0) 45092636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '0'; 45102636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis else 45112636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += llvm::utostr(CAT->getSize().getZExtValue()); 45122636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 4513559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson //Variable length arrays are encoded as a regular array with 0 elements. 45142636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert((isa<VariableArrayType>(AT) || isa<IncompleteArrayType>(AT)) && 45152636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis "Unknown array type!"); 4516559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += '0'; 4517559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson } 45181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(AT->getElementType(), S, 4520559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson false, ExpandStructures, FD); 4521559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += ']'; 4522559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson } 4523ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4524ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 45251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4526183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (T->getAs<FunctionType>()) { 4527c0a87b7db06643178ad2cbce0767548c139ea387Anders Carlsson S += '?'; 4528ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4529ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 45301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45316217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const RecordType *RTy = T->getAs<RecordType>()) { 453282a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar RecordDecl *RDecl = RTy->getDecl(); 4533d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar S += RDecl->isUnion() ? '(' : '{'; 4534502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar // Anonymous structures print as '?' 4535502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar if (const IdentifierInfo *II = RDecl->getIdentifier()) { 4536502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar S += II->getName(); 45376fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian if (ClassTemplateSpecializationDecl *Spec 45386fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian = dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) { 45396fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 45406fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian std::string TemplateArgsStr 45416fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian = TemplateSpecializationType::PrintTemplateArgumentList( 4542910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgs.data(), 4543910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgs.size(), 454430c42404202d2e2512e51efc6066bd614cfdb5a4Douglas Gregor (*this).getPrintingPolicy()); 45456fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian 45466fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian S += TemplateArgsStr; 45476fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian } 4548502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar } else { 4549502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar S += '?'; 4550502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar } 45510d504c1da852e58ff802545c823ecff3b6c654b8Daniel Dunbar if (ExpandStructures) { 45527d6b46d9a9d75dea8ef9f6973dd50633c1f37963Fariborz Jahanian S += '='; 45532636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!RDecl->isUnion()) { 45542636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForStructureImpl(RDecl, S, FD); 45552636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 45562636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (RecordDecl::field_iterator Field = RDecl->field_begin(), 45572636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldEnd = RDecl->field_end(); 45582636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis Field != FieldEnd; ++Field) { 45592636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (FD) { 45602636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 45612636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += Field->getNameAsString(); 45622636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 45632636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 45641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45652636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // Special case bit-fields. 45662636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (Field->isBitField()) { 45672636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForTypeImpl(Field->getType(), S, false, true, 4568262bc18e32500558af7cb0afa205b34bd37bafedDavid Blaikie &*Field); 45692636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 45702636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis QualType qt = Field->getType(); 45712636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getLegacyIntegralTypeEncoding(qt); 45722636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForTypeImpl(qt, S, false, true, 45732636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FD, /*OutermostType*/false, 45742636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*EncodingProperty*/false, 45752636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*StructField*/true); 45762636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 4577d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar } 45787d6b46d9a9d75dea8ef9f6973dd50633c1f37963Fariborz Jahanian } 45796de88a873a4cbe06d72602eef57d68006730a80bFariborz Jahanian } 4580d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar S += RDecl->isUnion() ? ')' : '}'; 4581ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4582ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 4583e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian 45845471bc85b69912e3b448de004498a80c0de32296Douglas Gregor if (const EnumType *ET = T->getAs<EnumType>()) { 45858b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian if (FD && FD->isBitField()) 458664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall EncodeBitField(this, S, T, FD); 45878b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian else 45885471bc85b69912e3b448de004498a80c0de32296Douglas Gregor S += ObjCEncodingForEnumType(this, ET); 4589ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4590ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 45911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4592dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (const BlockPointerType *BT = T->getAs<BlockPointerType>()) { 459321a98b188857d690aa4510c52ac4317ffa0908a8Steve Naroff S += "@?"; // Unlike a pointer-to-function, which is "^?". 4594dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (EncodeBlockParameters) { 4595dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson const FunctionType *FT = BT->getPointeeType()->getAs<FunctionType>(); 4596dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson 4597dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson S += '<'; 4598dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Block return type 4599dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeImpl(FT->getResultType(), S, 4600dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson ExpandPointedToStructures, ExpandStructures, 4601dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson FD, 4602dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* OutermostType */, 4603dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodingProperty, 4604dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* StructField */, 4605dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeBlockParameters, 4606dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeClassNames); 4607dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Block self 4608dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson S += "@?"; 4609dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Block parameters 4610dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FT)) { 4611dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson for (FunctionProtoType::arg_type_iterator I = FPT->arg_type_begin(), 4612dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson E = FPT->arg_type_end(); I && (I != E); ++I) { 4613dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeImpl(*I, S, 4614dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson ExpandPointedToStructures, 4615dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson ExpandStructures, 4616dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson FD, 4617dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* OutermostType */, 4618dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodingProperty, 4619dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* StructField */, 4620dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeBlockParameters, 4621dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeClassNames); 4622dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson } 4623dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson } 4624dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson S += '>'; 4625dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson } 4626ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4627ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4629c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Ignore protocol qualifiers when mangling at this level. 4630c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OT = T->getAs<ObjCObjectType>()) 4631c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall T = OT->getBaseType(); 4632c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 46330953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (const ObjCInterfaceType *OIT = T->getAs<ObjCInterfaceType>()) { 463443822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian // @encode(class_name) 46350953e767ff7817f97b3ab20896b229891eeff45bJohn McCall ObjCInterfaceDecl *OI = OIT->getDecl(); 463643822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += '{'; 463743822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian const IdentifierInfo *II = OI->getIdentifier(); 463843822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += II->getName(); 463943822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += '='; 4640db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose SmallVector<const ObjCIvarDecl*, 32> Ivars; 46412c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian DeepCollectObjCIvars(OI, true, Ivars); 46422c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian for (unsigned i = 0, e = Ivars.size(); i != e; ++i) { 4643db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose const FieldDecl *Field = cast<FieldDecl>(Ivars[i]); 46442c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian if (Field->isBitField()) 46452c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian getObjCEncodingForTypeImpl(Field->getType(), S, false, true, Field); 464643822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian else 46472c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian getObjCEncodingForTypeImpl(Field->getType(), S, false, true, FD); 464843822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian } 464943822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += '}'; 4650ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 465143822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian } 46521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4653183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ObjCObjectPointerType *OPT = T->getAs<ObjCObjectPointerType>()) { 465414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (OPT->isObjCIdType()) { 465514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '@'; 465614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 4657ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 465927d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) { 466027d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff // FIXME: Consider if we need to output qualifiers for 'Class<p>'. 466127d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff // Since this is a binary compatibility issue, need to consult with runtime 466227d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff // folks. Fortunately, this is a *very* obsure construct. 466314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '#'; 466414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 4665ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4667ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (OPT->isObjCQualifiedIdType()) { 46681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(getObjCIdType(), S, 466914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff ExpandPointedToStructures, 467014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff ExpandStructures, FD); 4671dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (FD || EncodingProperty || EncodeClassNames) { 467214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff // Note that we do extended encoding of protocol qualifer list 467314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff // Only when doing ivar or property encoding. 467414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '"'; 467567ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(), 467667ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff E = OPT->qual_end(); I != E; ++I) { 467714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '<'; 467814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += (*I)->getNameAsString(); 467914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '>'; 468014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 468114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '"'; 468214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 468314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 4684ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4686ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner QualType PointeeTy = OPT->getPointeeType(); 4687ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (!EncodingProperty && 4688ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner isa<TypedefType>(PointeeTy.getTypePtr())) { 4689ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner // Another historical/compatibility reason. 46901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // We encode the underlying type which comes out as 4691ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner // {...}; 4692ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '^'; 46931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(PointeeTy, S, 46941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump false, ExpandPointedToStructures, 4695ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner NULL); 469614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 469714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 4698ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner 4699ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '@'; 4700dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (OPT->getInterfaceDecl() && 4701dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson (FD || EncodingProperty || EncodeClassNames)) { 4702ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '"'; 470327d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff S += OPT->getInterfaceDecl()->getIdentifier()->getName(); 470467ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(), 470567ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff E = OPT->qual_end(); I != E; ++I) { 4706ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '<'; 4707ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += (*I)->getNameAsString(); 4708ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '>'; 47091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 4710ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '"'; 4711ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 4712ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4713ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 47141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4715532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall // gcc just blithely ignores member pointers. 4716532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall // TODO: maybe there should be a mangling for these 4717532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall if (T->getAs<MemberPointerType>()) 4718532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall return; 4719e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian 4720e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian if (T->isVectorType()) { 4721e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian // This matches gcc's encoding, even though technically it is 4722e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian // insufficient. 4723e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian // FIXME. We should do a better job than gcc. 4724e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian return; 4725e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian } 4726e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian 4727b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("@encode for type not implemented!"); 472885f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson} 472985f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson 47302636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidisvoid ASTContext::getObjCEncodingForStructureImpl(RecordDecl *RDecl, 47312636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::string &S, 47322636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis const FieldDecl *FD, 47332636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis bool includeVBases) const { 47342636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert(RDecl && "Expected non-null RecordDecl"); 47352636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert(!RDecl->isUnion() && "Should not be called for unions"); 47362636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!RDecl->getDefinition()) 47372636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis return; 47382636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47392636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CXXRecordDecl *CXXRec = dyn_cast<CXXRecordDecl>(RDecl); 47402636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::multimap<uint64_t, NamedDecl *> FieldOrBaseOffsets; 47412636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis const ASTRecordLayout &layout = getASTRecordLayout(RDecl); 47422636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47432636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRec) { 47442636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (CXXRecordDecl::base_class_iterator 47452636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BI = CXXRec->bases_begin(), 47462636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BE = CXXRec->bases_end(); BI != BE; ++BI) { 47472636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!BI->isVirtual()) { 47482636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CXXRecordDecl *base = BI->getType()->getAsCXXRecordDecl(); 4749829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis if (base->isEmpty()) 4750829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis continue; 47512636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = layout.getBaseClassOffsetInBits(base); 47522636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs), 47532636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::make_pair(offs, base)); 47542636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47552636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47562636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47572636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47582636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis unsigned i = 0; 47592636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (RecordDecl::field_iterator Field = RDecl->field_begin(), 47602636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldEnd = RDecl->field_end(); 47612636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis Field != FieldEnd; ++Field, ++i) { 47622636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = layout.getFieldOffset(i); 47632636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs), 4764262bc18e32500558af7cb0afa205b34bd37bafedDavid Blaikie std::make_pair(offs, &*Field)); 47652636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47662636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47672636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRec && includeVBases) { 47682636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (CXXRecordDecl::base_class_iterator 47692636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BI = CXXRec->vbases_begin(), 47702636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BE = CXXRec->vbases_end(); BI != BE; ++BI) { 47712636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CXXRecordDecl *base = BI->getType()->getAsCXXRecordDecl(); 4772829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis if (base->isEmpty()) 4773829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis continue; 47742636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = layout.getVBaseClassOffsetInBits(base); 477519aa8609a5d04eed9b81aa1c4608e8a4f3df6ccdArgyrios Kyrtzidis if (FieldOrBaseOffsets.find(offs) == FieldOrBaseOffsets.end()) 477619aa8609a5d04eed9b81aa1c4608e8a4f3df6ccdArgyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.end(), 477719aa8609a5d04eed9b81aa1c4608e8a4f3df6ccdArgyrios Kyrtzidis std::make_pair(offs, base)); 47782636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47792636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47802636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47812636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CharUnits size; 47822636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRec) { 47832636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis size = includeVBases ? layout.getSize() : layout.getNonVirtualSize(); 47842636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 47852636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis size = layout.getSize(); 47862636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47872636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47882636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t CurOffs = 0; 47892636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::multimap<uint64_t, NamedDecl *>::iterator 47902636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurLayObj = FieldOrBaseOffsets.begin(); 47912636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 479258db7a575efc9a2f35266fe240feac3cf317753dDouglas Gregor if (CXXRec && CXXRec->isDynamicClass() && 479358db7a575efc9a2f35266fe240feac3cf317753dDouglas Gregor (CurLayObj == FieldOrBaseOffsets.end() || CurLayObj->first != 0)) { 47942636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (FD) { 47952636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += "\"_vptr$"; 47962636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::string recname = CXXRec->getNameAsString(); 47972636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (recname.empty()) recname = "?"; 47982636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += recname; 47992636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 48002636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48012636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += "^^?"; 48022636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurOffs += getTypeSize(VoidPtrTy); 48032636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48042636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48052636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!RDecl->hasFlexibleArrayMember()) { 48062636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // Mark the end of the structure. 48072636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = toBits(size); 48082636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs), 48092636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::make_pair(offs, (NamedDecl*)0)); 48102636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48112636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48122636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (; CurLayObj != FieldOrBaseOffsets.end(); ++CurLayObj) { 48132636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert(CurOffs <= CurLayObj->first); 48142636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48152636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CurOffs < CurLayObj->first) { 48162636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t padding = CurLayObj->first - CurOffs; 48172636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // FIXME: There doesn't seem to be a way to indicate in the encoding that 48182636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // packing/alignment of members is different that normal, in which case 48192636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // the encoding will be out-of-sync with the real layout. 48202636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // If the runtime switches to just consider the size of types without 48212636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // taking into account alignment, we could make padding explicit in the 48222636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // encoding (e.g. using arrays of chars). The encoding strings would be 48232636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // longer then though. 48242636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurOffs += padding; 48252636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48262636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48272636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis NamedDecl *dcl = CurLayObj->second; 48282636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (dcl == 0) 48292636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis break; // reached end of structure. 48302636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48312636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRecordDecl *base = dyn_cast<CXXRecordDecl>(dcl)) { 48322636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // We expand the bases without their virtual bases since those are going 48332636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // in the initial structure. Note that this differs from gcc which 48342636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // expands virtual bases each time one is encountered in the hierarchy, 48352636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // making the encoding type bigger than it really is. 48362636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForStructureImpl(base, S, FD, /*includeVBases*/false); 4837829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis assert(!base->isEmpty()); 4838829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis CurOffs += toBits(getASTRecordLayout(base).getNonVirtualSize()); 48392636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 48402636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldDecl *field = cast<FieldDecl>(dcl); 48412636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (FD) { 48422636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 48432636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += field->getNameAsString(); 48442636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 48452636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48462636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48472636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (field->isBitField()) { 48482636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis EncodeBitField(this, S, field->getType(), field); 4849a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith CurOffs += field->getBitWidthValue(*this); 48502636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 48512636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis QualType qt = field->getType(); 48522636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getLegacyIntegralTypeEncoding(qt); 48532636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForTypeImpl(qt, S, false, true, FD, 48542636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*OutermostType*/false, 48552636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*EncodingProperty*/false, 48562636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*StructField*/true); 48572636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurOffs += getTypeSize(field->getType()); 48582636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48592636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48602636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48612636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis} 48622636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT, 4864ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian std::string& S) const { 4865ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_In) 4866ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'n'; 4867ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Inout) 4868ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'N'; 4869ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Out) 4870ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'o'; 4871ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Bycopy) 4872ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'O'; 4873ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Byref) 4874ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'R'; 4875ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Oneway) 4876ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'V'; 4877ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian} 4878ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian 4879ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattnervoid ASTContext::setBuiltinVaListType(QualType T) { 4880b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson assert(BuiltinVaListType.isNull() && "__builtin_va_list type already set!"); 48811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4882b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson BuiltinVaListType = T; 4883b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson} 4884b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson 48854dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas GregorTypedefDecl *ASTContext::getObjCIdDecl() const { 48864dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor if (!ObjCIdDecl) { 48874dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor QualType T = getObjCObjectType(ObjCBuiltinIdTy, 0, 0); 48884dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor T = getObjCObjectPointerType(T); 48894dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor TypeSourceInfo *IdInfo = getTrivialTypeSourceInfo(T); 48904dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor ObjCIdDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 48914dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor getTranslationUnitDecl(), 48924dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor SourceLocation(), SourceLocation(), 48934dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor &Idents.get("id"), IdInfo); 48944dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor } 48954dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor 48964dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor return ObjCIdDecl; 48977e219e47de26346885d667131977bd9ca2d7662aSteve Naroff} 48987e219e47de26346885d667131977bd9ca2d7662aSteve Naroff 48997a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas GregorTypedefDecl *ASTContext::getObjCSelDecl() const { 49007a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor if (!ObjCSelDecl) { 49017a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor QualType SelT = getPointerType(ObjCBuiltinSelTy); 49027a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor TypeSourceInfo *SelInfo = getTrivialTypeSourceInfo(SelT); 49037a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor ObjCSelDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 49047a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor getTranslationUnitDecl(), 49057a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor SourceLocation(), SourceLocation(), 49067a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor &Idents.get("SEL"), SelInfo); 49077a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor } 49087a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor return ObjCSelDecl; 4909b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian} 4910b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian 491179d6726921897811232554ed94c5d77b5b7b3fc0Douglas GregorTypedefDecl *ASTContext::getObjCClassDecl() const { 491279d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor if (!ObjCClassDecl) { 491379d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor QualType T = getObjCObjectType(ObjCBuiltinClassTy, 0, 0); 491479d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor T = getObjCObjectPointerType(T); 491579d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor TypeSourceInfo *ClassInfo = getTrivialTypeSourceInfo(T); 491679d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor ObjCClassDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 491779d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor getTranslationUnitDecl(), 491879d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor SourceLocation(), SourceLocation(), 491979d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor &Idents.get("Class"), ClassInfo); 492079d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor } 492179d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor 492279d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor return ObjCClassDecl; 4923a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor} 4924a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor 4925a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas GregorObjCInterfaceDecl *ASTContext::getObjCProtocolDecl() const { 4926a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor if (!ObjCProtocolClassDecl) { 4927a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor ObjCProtocolClassDecl 4928a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor = ObjCInterfaceDecl::Create(*this, getTranslationUnitDecl(), 4929a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor SourceLocation(), 4930a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor &Idents.get("Protocol"), 4931a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor /*PrevDecl=*/0, 4932a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor SourceLocation(), true); 4933a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor } 4934a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor 4935a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor return ObjCProtocolClassDecl; 49368baaca50f07d0c10bba69c8d88c1b9078c92d06dAnders Carlsson} 49378baaca50f07d0c10bba69c8d88c1b9078c92d06dAnders Carlsson 4938a526c5c67e5a0473c340903ee542ce570119665fTed Kremenekvoid ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) { 49391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(ObjCConstantStringType.isNull() && 49402198891824c38d45b2279de5d5e3ef9394eb457cSteve Naroff "'NSConstantString' type already set!"); 49411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4942a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCConstantStringType = getObjCInterfaceType(Decl); 49432198891824c38d45b2279de5d5e3ef9394eb457cSteve Naroff} 49442198891824c38d45b2279de5d5e3ef9394eb457cSteve Naroff 49450bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall/// \brief Retrieve the template name that corresponds to a non-empty 49460bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall/// lookup. 49474ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName 49484ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getOverloadedTemplateName(UnresolvedSetIterator Begin, 49494ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad UnresolvedSetIterator End) const { 49500bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall unsigned size = End - Begin; 49510bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall assert(size > 1 && "set is not overloaded!"); 49527532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 49530bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall void *memory = Allocate(sizeof(OverloadedTemplateStorage) + 49540bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall size * sizeof(FunctionTemplateDecl*)); 49550bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall OverloadedTemplateStorage *OT = new(memory) OverloadedTemplateStorage(size); 49560bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall 49570bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall NamedDecl **Storage = OT->getStorage(); 4958eec51cf1ba5f0e62c9cdb81b5c63babdd6e649abJohn McCall for (UnresolvedSetIterator I = Begin; I != End; ++I) { 49590bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall NamedDecl *D = *I; 49600bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall assert(isa<FunctionTemplateDecl>(D) || 49610bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall (isa<UsingShadowDecl>(D) && 49620bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall isa<FunctionTemplateDecl>(D->getUnderlyingDecl()))); 49630bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall *Storage++ = D; 49647532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor } 49657532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 49660bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall return TemplateName(OT); 49677532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor} 49687532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 4969d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor/// \brief Retrieve the template name that represents a qualified 4970d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor/// template name such as \c std::vector. 49714ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName 49724ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS, 49734ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad bool TemplateKeyword, 49744ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad TemplateDecl *Template) const { 49750f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor assert(NNS && "Missing nested-name-specifier in qualified template name"); 49760f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor 4977789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor // FIXME: Canonicalization? 4978d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor llvm::FoldingSetNodeID ID; 4979d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template); 49801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4981d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor void *InsertPos = 0; 4982d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QualifiedTemplateName *QTN = 49830bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 4984d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor if (!QTN) { 4985d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QTN = new (*this,4) QualifiedTemplateName(NNS, TemplateKeyword, Template); 4986d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QualifiedTemplateNames.InsertNode(QTN, InsertPos); 4987d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor } 49881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4989d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor return TemplateName(QTN); 4990d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor} 4991d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor 49927532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor/// \brief Retrieve the template name that represents a dependent 49937532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor/// template name such as \c MetaFun::template apply. 49944ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName 49954ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getDependentTemplateName(NestedNameSpecifier *NNS, 49964ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const IdentifierInfo *Name) const { 49971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert((!NNS || NNS->isDependent()) && 49983b6afbb99a1c44b4076f8e15fb7311405941b306Douglas Gregor "Nested name specifier must be dependent"); 49997532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 50007532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor llvm::FoldingSetNodeID ID; 50017532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateName::Profile(ID, NNS, Name); 50027532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 50037532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor void *InsertPos = 0; 50047532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateName *QTN = 50057532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 50067532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 50077532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor if (QTN) 50087532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor return TemplateName(QTN); 50097532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 50107532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 50117532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor if (CanonNNS == NNS) { 50127532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Name); 50137532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor } else { 50147532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor TemplateName Canon = getDependentTemplateName(CanonNNS, Name); 50157532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Name, Canon); 5016789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateName *CheckQTN = 5017789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 5018789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!CheckQTN && "Dependent type name canonicalization broken"); 5019789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CheckQTN; 50207532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor } 50217532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 50227532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateNames.InsertNode(QTN, InsertPos); 50237532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor return TemplateName(QTN); 50247532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor} 50257532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 5026ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor/// \brief Retrieve the template name that represents a dependent 5027ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor/// template name such as \c MetaFun::template operator+. 5028ca1bdd7c269a2390d43c040a60511edd017ee130Douglas GregorTemplateName 5029ca1bdd7c269a2390d43c040a60511edd017ee130Douglas GregorASTContext::getDependentTemplateName(NestedNameSpecifier *NNS, 50304ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad OverloadedOperatorKind Operator) const { 5031ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor assert((!NNS || NNS->isDependent()) && 5032ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor "Nested name specifier must be dependent"); 5033ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5034ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor llvm::FoldingSetNodeID ID; 5035ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor DependentTemplateName::Profile(ID, NNS, Operator); 5036ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5037ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor void *InsertPos = 0; 5038789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateName *QTN 5039789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 5040ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5041ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor if (QTN) 5042ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor return TemplateName(QTN); 5043ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5044ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 5045ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor if (CanonNNS == NNS) { 5046ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Operator); 5047ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor } else { 5048ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor TemplateName Canon = getDependentTemplateName(CanonNNS, Operator); 5049ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Operator, Canon); 5050789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 5051789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateName *CheckQTN 5052789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 5053789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!CheckQTN && "Dependent template name canonicalization broken"); 5054789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CheckQTN; 5055ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor } 5056ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5057ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor DependentTemplateNames.InsertNode(QTN, InsertPos); 5058ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor return TemplateName(QTN); 5059ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor} 5060ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 50611aee05d08b2184acadeb36de300e216390780d6cDouglas GregorTemplateName 5062146060435c3efce95c95a092c7a1eb651cfb9ae0John McCallASTContext::getSubstTemplateTemplateParm(TemplateTemplateParmDecl *param, 5063146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateName replacement) const { 5064146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm::FoldingSetNodeID ID; 5065146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage::Profile(ID, param, replacement); 5066146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5067146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall void *insertPos = 0; 5068146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage *subst 5069146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = SubstTemplateTemplateParms.FindNodeOrInsertPos(ID, insertPos); 5070146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5071146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall if (!subst) { 5072146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall subst = new (*this) SubstTemplateTemplateParmStorage(param, replacement); 5073146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParms.InsertNode(subst, insertPos); 5074146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 5075146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5076146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return TemplateName(subst); 5077146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall} 5078146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5079146060435c3efce95c95a092c7a1eb651cfb9ae0John McCallTemplateName 50801aee05d08b2184acadeb36de300e216390780d6cDouglas GregorASTContext::getSubstTemplateTemplateParmPack(TemplateTemplateParmDecl *Param, 50811aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor const TemplateArgument &ArgPack) const { 50821aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor ASTContext &Self = const_cast<ASTContext &>(*this); 50831aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor llvm::FoldingSetNodeID ID; 50841aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor SubstTemplateTemplateParmPackStorage::Profile(ID, Self, Param, ArgPack); 50851aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 50861aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor void *InsertPos = 0; 50871aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor SubstTemplateTemplateParmPackStorage *Subst 50881aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor = SubstTemplateTemplateParmPacks.FindNodeOrInsertPos(ID, InsertPos); 50891aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 50901aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor if (!Subst) { 5091146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall Subst = new (*this) SubstTemplateTemplateParmPackStorage(Param, 50921aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor ArgPack.pack_size(), 50931aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor ArgPack.pack_begin()); 50941aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor SubstTemplateTemplateParmPacks.InsertNode(Subst, InsertPos); 50951aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor } 50961aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 50971aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor return TemplateName(Subst); 50981aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor} 50991aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 5100b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor/// getFromTargetType - Given one of the integer types provided by 5101d934112e6170b0fd940d8e40db6936cea2cdcf62Douglas Gregor/// TargetInfo, produce the corresponding type. The unsigned @p Type 5102d934112e6170b0fd940d8e40db6936cea2cdcf62Douglas Gregor/// is actually a value of type @c TargetInfo::IntType. 5103e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCallCanQualType ASTContext::getFromTargetType(unsigned Type) const { 5104b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor switch (Type) { 5105e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCall case TargetInfo::NoInt: return CanQualType(); 5106b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedShort: return ShortTy; 5107b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedShort: return UnsignedShortTy; 5108b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedInt: return IntTy; 5109b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedInt: return UnsignedIntTy; 5110b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedLong: return LongTy; 5111b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedLong: return UnsignedLongTy; 5112b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedLongLong: return LongLongTy; 5113b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedLongLong: return UnsignedLongLongTy; 5114b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor } 5115b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor 5116b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unhandled TargetInfo::IntType value"); 5117b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor} 5118b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek 5119b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek//===----------------------------------------------------------------------===// 5120b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek// Type Predicates. 5121b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek//===----------------------------------------------------------------------===// 5122b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek 51234fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian/// getObjCGCAttr - Returns one of GCNone, Weak or Strong objc's 51244fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian/// garbage collection attribute. 51254fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian/// 5126ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCallQualifiers::GC ASTContext::getObjCGCAttrKind(QualType Ty) const { 51274e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (getLangOpts().getGC() == LangOptions::NonGC) 5128ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall return Qualifiers::GCNone; 5129ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall 51304e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie assert(getLangOpts().ObjC1); 5131ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall Qualifiers::GC GCAttrs = Ty.getObjCGCAttr(); 5132ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall 5133ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // Default behaviour under objective-C's gc is for ObjC pointers 5134ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // (or pointers to them) be treated as though they were declared 5135ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // as __strong. 5136ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall if (GCAttrs == Qualifiers::GCNone) { 5137ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType()) 5138ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall return Qualifiers::Strong; 5139ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall else if (Ty->isPointerType()) 5140ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall return getObjCGCAttrKind(Ty->getAs<PointerType>()->getPointeeType()); 5141ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall } else { 5142ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // It's not valid to set GC attributes on anything that isn't a 5143ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // pointer. 5144ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall#ifndef NDEBUG 5145ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall QualType CT = Ty->getCanonicalTypeInternal(); 5146ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall while (const ArrayType *AT = dyn_cast<ArrayType>(CT)) 5147ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall CT = AT->getElementType(); 5148ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall assert(CT->isAnyPointerType() || CT->isBlockPointerType()); 5149ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall#endif 51504fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian } 5151b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris Lattner return GCAttrs; 51524fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian} 51534fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian 51546ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner//===----------------------------------------------------------------------===// 51556ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner// Type Compatibility Testing 51566ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner//===----------------------------------------------------------------------===// 5157770951b5bb6028a8d326ddb4a13cef7d4a128162Chris Lattner 51581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// areCompatVectorTypes - Return true if the two specified vector types are 51596ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner/// compatible. 51606ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattnerstatic bool areCompatVectorTypes(const VectorType *LHS, 51616ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner const VectorType *RHS) { 5162467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified()); 51636ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner return LHS->getElementType() == RHS->getElementType() && 516461710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner LHS->getNumElements() == RHS->getNumElements(); 51656ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner} 51666ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner 5167255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregorbool ASTContext::areCompatibleVectorTypes(QualType FirstVec, 5168255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor QualType SecondVec) { 5169255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor assert(FirstVec->isVectorType() && "FirstVec should be a vector type"); 5170255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor assert(SecondVec->isVectorType() && "SecondVec should be a vector type"); 5171255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 5172255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor if (hasSameUnqualifiedType(FirstVec, SecondVec)) 5173255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor return true; 5174255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 5175f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson // Treat Neon vector types and most AltiVec vector types as if they are the 5176f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson // equivalent GCC vector types. 5177255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor const VectorType *First = FirstVec->getAs<VectorType>(); 5178255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor const VectorType *Second = SecondVec->getAs<VectorType>(); 5179f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson if (First->getNumElements() == Second->getNumElements() && 5180255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor hasSameType(First->getElementType(), Second->getElementType()) && 5181f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson First->getVectorKind() != VectorType::AltiVecPixel && 5182f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson First->getVectorKind() != VectorType::AltiVecBool && 5183f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson Second->getVectorKind() != VectorType::AltiVecPixel && 5184f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson Second->getVectorKind() != VectorType::AltiVecBool) 5185255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor return true; 5186255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 5187255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor return false; 5188255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor} 5189255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 51904084c306635b70f37029dca938444e6013f08684Steve Naroff//===----------------------------------------------------------------------===// 51914084c306635b70f37029dca938444e6013f08684Steve Naroff// ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's. 51924084c306635b70f37029dca938444e6013f08684Steve Naroff//===----------------------------------------------------------------------===// 51934084c306635b70f37029dca938444e6013f08684Steve Naroff 51944084c306635b70f37029dca938444e6013f08684Steve Naroff/// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the 51954084c306635b70f37029dca938444e6013f08684Steve Naroff/// inheritance hierarchy of 'rProto'. 51964ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadbool 51974ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto, 51984ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad ObjCProtocolDecl *rProto) const { 51993fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor if (declaresSameEntity(lProto, rProto)) 520014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return true; 52014084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCProtocolDecl::protocol_iterator PI = rProto->protocol_begin(), 52024084c306635b70f37029dca938444e6013f08684Steve Naroff E = rProto->protocol_end(); PI != E; ++PI) 52034084c306635b70f37029dca938444e6013f08684Steve Naroff if (ProtocolCompatibleWithProtocol(lProto, *PI)) 52044084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 52054084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 52064084c306635b70f37029dca938444e6013f08684Steve Naroff} 520714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 52084084c306635b70f37029dca938444e6013f08684Steve Naroff/// QualifiedIdConformsQualifiedId - compare id<p,...> with id<p1,...> 52094084c306635b70f37029dca938444e6013f08684Steve Naroff/// return true if lhs's protocols conform to rhs's protocol; false 52104084c306635b70f37029dca938444e6013f08684Steve Naroff/// otherwise. 52114084c306635b70f37029dca938444e6013f08684Steve Naroffbool ASTContext::QualifiedIdConformsQualifiedId(QualType lhs, QualType rhs) { 52124084c306635b70f37029dca938444e6013f08684Steve Naroff if (lhs->isObjCQualifiedIdType() && rhs->isObjCQualifiedIdType()) 52134084c306635b70f37029dca938444e6013f08684Steve Naroff return ObjCQualifiedIdTypesAreCompatible(lhs, rhs, false); 52144084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 52154084c306635b70f37029dca938444e6013f08684Steve Naroff} 52164084c306635b70f37029dca938444e6013f08684Steve Naroff 5217a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian/// ObjCQualifiedClassTypesAreCompatible - compare Class<p,...> and 5218a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian/// Class<p1, ...>. 5219a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanianbool ASTContext::ObjCQualifiedClassTypesAreCompatible(QualType lhs, 5220a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian QualType rhs) { 5221a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian const ObjCObjectPointerType *lhsQID = lhs->getAs<ObjCObjectPointerType>(); 5222a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>(); 5223a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian assert ((lhsQID && rhsOPT) && "ObjCQualifiedClassTypesAreCompatible"); 5224a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 5225a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 5226a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian E = lhsQID->qual_end(); I != E; ++I) { 5227a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian bool match = false; 5228a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian ObjCProtocolDecl *lhsProto = *I; 5229a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(), 5230a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian E = rhsOPT->qual_end(); J != E; ++J) { 5231a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian ObjCProtocolDecl *rhsProto = *J; 5232a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto)) { 5233a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian match = true; 5234a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian break; 5235a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian } 5236a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian } 5237a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian if (!match) 5238a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian return false; 5239a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian } 5240a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian return true; 5241a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian} 5242a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 52434084c306635b70f37029dca938444e6013f08684Steve Naroff/// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an 52444084c306635b70f37029dca938444e6013f08684Steve Naroff/// ObjCQualifiedIDType. 52454084c306635b70f37029dca938444e6013f08684Steve Naroffbool ASTContext::ObjCQualifiedIdTypesAreCompatible(QualType lhs, QualType rhs, 52464084c306635b70f37029dca938444e6013f08684Steve Naroff bool compare) { 52474084c306635b70f37029dca938444e6013f08684Steve Naroff // Allow id<P..> and an 'id' or void* type in all cases. 52481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (lhs->isVoidPointerType() || 52494084c306635b70f37029dca938444e6013f08684Steve Naroff lhs->isObjCIdType() || lhs->isObjCClassType()) 52504084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 52511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump else if (rhs->isVoidPointerType() || 52524084c306635b70f37029dca938444e6013f08684Steve Naroff rhs->isObjCIdType() || rhs->isObjCClassType()) 52534084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 52544084c306635b70f37029dca938444e6013f08684Steve Naroff 52554084c306635b70f37029dca938444e6013f08684Steve Naroff if (const ObjCObjectPointerType *lhsQID = lhs->getAsObjCQualifiedIdType()) { 5256183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>(); 52571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 52584084c306635b70f37029dca938444e6013f08684Steve Naroff if (!rhsOPT) return false; 52591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 52604084c306635b70f37029dca938444e6013f08684Steve Naroff if (rhsOPT->qual_empty()) { 52611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the RHS is a unqualified interface pointer "NSString*", 52624084c306635b70f37029dca938444e6013f08684Steve Naroff // make sure we check the class hierarchy. 52634084c306635b70f37029dca938444e6013f08684Steve Naroff if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) { 52644084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 52654084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsQID->qual_end(); I != E; ++I) { 52664084c306635b70f37029dca938444e6013f08684Steve Naroff // when comparing an id<P> on lhs with a static type on rhs, 52674084c306635b70f37029dca938444e6013f08684Steve Naroff // see if static class implements all of id's protocols, directly or 52684084c306635b70f37029dca938444e6013f08684Steve Naroff // through its super class and categories. 52690fd8904c5f71a11d29f67716c3ebdf7ad1c855fbFariborz Jahanian if (!rhsID->ClassImplementsProtocol(*I, true)) 52704084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 52714084c306635b70f37029dca938444e6013f08684Steve Naroff } 52724084c306635b70f37029dca938444e6013f08684Steve Naroff } 52734084c306635b70f37029dca938444e6013f08684Steve Naroff // If there are no qualifiers and no interface, we have an 'id'. 52744084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 52754084c306635b70f37029dca938444e6013f08684Steve Naroff } 52761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Both the right and left sides have qualifiers. 52774084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 52784084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsQID->qual_end(); I != E; ++I) { 52794084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *lhsProto = *I; 52804084c306635b70f37029dca938444e6013f08684Steve Naroff bool match = false; 5281de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff 5282de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff // when comparing an id<P> on lhs with a static type on rhs, 5283de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff // see if static class implements all of id's protocols, directly or 5284de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff // through its super class and categories. 52854084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(), 52864084c306635b70f37029dca938444e6013f08684Steve Naroff E = rhsOPT->qual_end(); J != E; ++J) { 52874084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *rhsProto = *J; 52884084c306635b70f37029dca938444e6013f08684Steve Naroff if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 52894084c306635b70f37029dca938444e6013f08684Steve Naroff (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 52904084c306635b70f37029dca938444e6013f08684Steve Naroff match = true; 52918f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff break; 52928f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff } 5293de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff } 52941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the RHS is a qualified interface pointer "NSString<P>*", 52954084c306635b70f37029dca938444e6013f08684Steve Naroff // make sure we check the class hierarchy. 52964084c306635b70f37029dca938444e6013f08684Steve Naroff if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) { 52974084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 52984084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsQID->qual_end(); I != E; ++I) { 52994084c306635b70f37029dca938444e6013f08684Steve Naroff // when comparing an id<P> on lhs with a static type on rhs, 53004084c306635b70f37029dca938444e6013f08684Steve Naroff // see if static class implements all of id's protocols, directly or 53014084c306635b70f37029dca938444e6013f08684Steve Naroff // through its super class and categories. 53020fd8904c5f71a11d29f67716c3ebdf7ad1c855fbFariborz Jahanian if (rhsID->ClassImplementsProtocol(*I, true)) { 53034084c306635b70f37029dca938444e6013f08684Steve Naroff match = true; 53044084c306635b70f37029dca938444e6013f08684Steve Naroff break; 53054084c306635b70f37029dca938444e6013f08684Steve Naroff } 53064084c306635b70f37029dca938444e6013f08684Steve Naroff } 53074084c306635b70f37029dca938444e6013f08684Steve Naroff } 53084084c306635b70f37029dca938444e6013f08684Steve Naroff if (!match) 5309de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff return false; 5310de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff } 53111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5312de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff return true; 5313de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff } 53141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 53154084c306635b70f37029dca938444e6013f08684Steve Naroff const ObjCObjectPointerType *rhsQID = rhs->getAsObjCQualifiedIdType(); 53164084c306635b70f37029dca938444e6013f08684Steve Naroff assert(rhsQID && "One of the LHS/RHS should be id<x>"); 53174084c306635b70f37029dca938444e6013f08684Steve Naroff 53181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const ObjCObjectPointerType *lhsOPT = 53194084c306635b70f37029dca938444e6013f08684Steve Naroff lhs->getAsObjCInterfacePointerType()) { 5320de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // If both the right and left sides have qualifiers. 53214084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsOPT->qual_begin(), 53224084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsOPT->qual_end(); I != E; ++I) { 53234084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *lhsProto = *I; 53244084c306635b70f37029dca938444e6013f08684Steve Naroff bool match = false; 53254084c306635b70f37029dca938444e6013f08684Steve Naroff 5326de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // when comparing an id<P> on rhs with a static type on lhs, 53274084c306635b70f37029dca938444e6013f08684Steve Naroff // see if static class implements all of id's protocols, directly or 53284084c306635b70f37029dca938444e6013f08684Steve Naroff // through its super class and categories. 5329de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // First, lhs protocols in the qualifier list must be found, direct 5330de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // or indirect in rhs's qualifier list or it is a mismatch. 53314084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(), 53324084c306635b70f37029dca938444e6013f08684Steve Naroff E = rhsQID->qual_end(); J != E; ++J) { 53334084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *rhsProto = *J; 53344084c306635b70f37029dca938444e6013f08684Steve Naroff if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 53354084c306635b70f37029dca938444e6013f08684Steve Naroff (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 53364084c306635b70f37029dca938444e6013f08684Steve Naroff match = true; 53374084c306635b70f37029dca938444e6013f08684Steve Naroff break; 53384084c306635b70f37029dca938444e6013f08684Steve Naroff } 53394084c306635b70f37029dca938444e6013f08684Steve Naroff } 53404084c306635b70f37029dca938444e6013f08684Steve Naroff if (!match) 53414084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 53424084c306635b70f37029dca938444e6013f08684Steve Naroff } 5343de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian 5344de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // Static class's protocols, or its super class or category protocols 5345de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // must be found, direct or indirect in rhs's qualifier list or it is a mismatch. 5346de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (ObjCInterfaceDecl *lhsID = lhsOPT->getInterfaceDecl()) { 5347de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols; 5348de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian CollectInheritedProtocols(lhsID, LHSInheritedProtocols); 5349de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // This is rather dubious but matches gcc's behavior. If lhs has 5350de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // no type qualifier and its class has no static protocol(s) 5351de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // assume that it is mismatch. 5352de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (LHSInheritedProtocols.empty() && lhsOPT->qual_empty()) 5353de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian return false; 5354de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 5355de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian LHSInheritedProtocols.begin(), 5356de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian E = LHSInheritedProtocols.end(); I != E; ++I) { 5357de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian bool match = false; 5358de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian ObjCProtocolDecl *lhsProto = (*I); 5359de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(), 5360de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian E = rhsQID->qual_end(); J != E; ++J) { 5361de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian ObjCProtocolDecl *rhsProto = *J; 5362de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 5363de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 5364de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian match = true; 5365de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian break; 5366de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 5367de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 5368de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (!match) 5369de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian return false; 5370de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 5371de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 53724084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 53734084c306635b70f37029dca938444e6013f08684Steve Naroff } 53744084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 53754084c306635b70f37029dca938444e6013f08684Steve Naroff} 53764084c306635b70f37029dca938444e6013f08684Steve Naroff 53774084c306635b70f37029dca938444e6013f08684Steve Naroff/// canAssignObjCInterfaces - Return true if the two interface types are 53784084c306635b70f37029dca938444e6013f08684Steve Naroff/// compatible for assignment from RHS to LHS. This handles validation of any 53794084c306635b70f37029dca938444e6013f08684Steve Naroff/// protocol qualifiers on the LHS or RHS. 53804084c306635b70f37029dca938444e6013f08684Steve Naroff/// 53814084c306635b70f37029dca938444e6013f08684Steve Naroffbool ASTContext::canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, 53824084c306635b70f37029dca938444e6013f08684Steve Naroff const ObjCObjectPointerType *RHSOPT) { 5383c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* LHS = LHSOPT->getObjectType(); 5384c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* RHS = RHSOPT->getObjectType(); 5385c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 53864084c306635b70f37029dca938444e6013f08684Steve Naroff // If either type represents the built-in 'id' or 'Class' types, return true. 5387c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHS->isObjCUnqualifiedIdOrClass() || 5388c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall RHS->isObjCUnqualifiedIdOrClass()) 53894084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 53904084c306635b70f37029dca938444e6013f08684Steve Naroff 5391c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHS->isObjCQualifiedId() || RHS->isObjCQualifiedId()) 53921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0), 53931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType(RHSOPT,0), 53944084c306635b70f37029dca938444e6013f08684Steve Naroff false); 5395a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 5396a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian if (LHS->isObjCQualifiedClass() && RHS->isObjCQualifiedClass()) 5397a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian return ObjCQualifiedClassTypesAreCompatible(QualType(LHSOPT,0), 5398a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian QualType(RHSOPT,0)); 5399a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 5400c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // If we have 2 user-defined types, fall into that path. 5401c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHS->getInterface() && RHS->getInterface()) 54024084c306635b70f37029dca938444e6013f08684Steve Naroff return canAssignObjCInterfaces(LHS, RHS); 54031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 54044084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 540514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff} 540614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 5407132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// canAssignObjCInterfacesInBlockPointer - This routine is specifically written 5408fc8f0e14ad142ed811e90fbd9a30e419e301c717Chris Lattner/// for providing type-safety for objective-c pointers used to pass/return 5409132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// arguments in block literals. When passed as arguments, passing 'A*' where 5410132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// 'id' is expected is not OK. Passing 'Sub *" where 'Super *" is expected is 5411132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// not OK. For the return type, the opposite is not OK. 5412132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanianbool ASTContext::canAssignObjCInterfacesInBlockPointer( 5413132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian const ObjCObjectPointerType *LHSOPT, 5414a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian const ObjCObjectPointerType *RHSOPT, 5415a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian bool BlockReturnType) { 5416a98344869c278295f38e106583906377520079b8Fariborz Jahanian if (RHSOPT->isObjCBuiltinType() || LHSOPT->isObjCIdType()) 5417132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return true; 5418132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5419132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHSOPT->isObjCBuiltinType()) { 5420132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return RHSOPT->isObjCBuiltinType() || RHSOPT->isObjCQualifiedIdType(); 5421132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 5422132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5423a98344869c278295f38e106583906377520079b8Fariborz Jahanian if (LHSOPT->isObjCQualifiedIdType() || RHSOPT->isObjCQualifiedIdType()) 5424132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0), 5425132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian QualType(RHSOPT,0), 5426132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian false); 5427132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5428132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType(); 5429132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType(); 5430132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHS && RHS) { // We have 2 user-defined types. 5431132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHS != RHS) { 5432132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHS->getDecl()->isSuperClassOf(RHS->getDecl())) 5433a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian return BlockReturnType; 5434132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (RHS->getDecl()->isSuperClassOf(LHS->getDecl())) 5435a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian return !BlockReturnType; 5436132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 5437132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian else 5438132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return true; 5439132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 5440132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return false; 5441132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian} 5442132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5443e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// getIntersectionOfProtocols - This routine finds the intersection of set 5444e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// of protocols inherited from two distinct objective-c pointer objects. 5445e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// It is used to build composite qualifier list of the composite type of 5446e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// the conditional expression involving two objective-c pointer objects. 5447e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanianstatic 5448e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanianvoid getIntersectionOfProtocols(ASTContext &Context, 5449e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian const ObjCObjectPointerType *LHSOPT, 5450e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian const ObjCObjectPointerType *RHSOPT, 54515f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<ObjCProtocolDecl *> &IntersectionOfProtocols) { 5452e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5453c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* LHS = LHSOPT->getObjectType(); 5454c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* RHS = RHSOPT->getObjectType(); 5455c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(LHS->getInterface() && "LHS must have an interface base"); 5456c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(RHS->getInterface() && "RHS must have an interface base"); 5457e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5458e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocolSet; 5459e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian unsigned LHSNumProtocols = LHS->getNumProtocols(); 5460e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (LHSNumProtocols > 0) 5461e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian InheritedProtocolSet.insert(LHS->qual_begin(), LHS->qual_end()); 5462e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian else { 5463432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols; 5464c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Context.CollectInheritedProtocols(LHS->getInterface(), 5465c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall LHSInheritedProtocols); 5466e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian InheritedProtocolSet.insert(LHSInheritedProtocols.begin(), 5467e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian LHSInheritedProtocols.end()); 5468e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 5469e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5470e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian unsigned RHSNumProtocols = RHS->getNumProtocols(); 5471e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (RHSNumProtocols > 0) { 5472cb421fa690da545b58a720abe5f1c49b166dbde7Dan Gohman ObjCProtocolDecl **RHSProtocols = 5473cb421fa690da545b58a720abe5f1c49b166dbde7Dan Gohman const_cast<ObjCProtocolDecl **>(RHS->qual_begin()); 5474e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (unsigned i = 0; i < RHSNumProtocols; ++i) 5475e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (InheritedProtocolSet.count(RHSProtocols[i])) 5476e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian IntersectionOfProtocols.push_back(RHSProtocols[i]); 54773060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 5478432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> RHSInheritedProtocols; 5479c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Context.CollectInheritedProtocols(RHS->getInterface(), 5480c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall RHSInheritedProtocols); 5481432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 5482432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian RHSInheritedProtocols.begin(), 5483432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian E = RHSInheritedProtocols.end(); I != E; ++I) 5484432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian if (InheritedProtocolSet.count((*I))) 5485432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian IntersectionOfProtocols.push_back((*I)); 5486e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 5487e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian} 5488e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5489db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// areCommonBaseCompatible - Returns common base class of the two classes if 5490db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// one found. Note that this is O'2 algorithm. But it will be called as the 5491db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// last type comparison in a ?-exp of ObjC pointer types before a 5492db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// warning is issued. So, its invokation is extremely rare. 5493db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz JahanianQualType ASTContext::areCommonBaseCompatible( 5494c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectPointerType *Lptr, 5495c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectPointerType *Rptr) { 5496c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType *LHS = Lptr->getObjectType(); 5497c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType *RHS = Rptr->getObjectType(); 5498c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCInterfaceDecl* LDecl = LHS->getInterface(); 5499c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCInterfaceDecl* RDecl = RHS->getInterface(); 550060ef308e51c71b760d7f598c1b763ceb7b768148Douglas Gregor if (!LDecl || !RDecl || (declaresSameEntity(LDecl, RDecl))) 5501db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian return QualType(); 5502db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian 55037c2bdcb4d30f2d370b4367664e6a11b075ce2cb3Fariborz Jahanian do { 5504c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall LHS = cast<ObjCInterfaceType>(getObjCInterfaceType(LDecl)); 5505e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (canAssignObjCInterfaces(LHS, RHS)) { 55065f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<ObjCProtocolDecl *, 8> Protocols; 5507c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall getIntersectionOfProtocols(*this, Lptr, Rptr, Protocols); 5508c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 5509c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall QualType Result = QualType(LHS, 0); 5510c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!Protocols.empty()) 5511c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Result = getObjCObjectType(Result, Protocols.data(), Protocols.size()); 5512c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Result = getObjCObjectPointerType(Result); 5513c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return Result; 5514e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 55157c2bdcb4d30f2d370b4367664e6a11b075ce2cb3Fariborz Jahanian } while ((LDecl = LDecl->getSuperClass())); 5516db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian 5517db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian return QualType(); 5518db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian} 5519db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian 5520c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCallbool ASTContext::canAssignObjCInterfaces(const ObjCObjectType *LHS, 5521c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType *RHS) { 5522c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(LHS->getInterface() && "LHS is not an interface type"); 5523c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(RHS->getInterface() && "RHS is not an interface type"); 5524c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 55256ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // Verify that the base decls are compatible: the RHS must be a subclass of 55266ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // the LHS. 5527c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!LHS->getInterface()->isSuperClassOf(RHS->getInterface())) 55286ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner return false; 55291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 55306ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // RHS must have a superset of the protocols in the LHS. If the LHS is not 55316ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // protocol qualified at all, then we are good. 5532c15cb2af27514ecc879daba9aa01389c5203685dSteve Naroff if (LHS->getNumProtocols() == 0) 55336ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner return true; 55341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5535b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // Okay, we know the LHS has protocol qualifiers. If the RHS doesn't, 5536b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // more detailed analysis is required. 5537b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (RHS->getNumProtocols() == 0) { 5538b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // OK, if LHS is a superclass of RHS *and* 5539b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // this superclass is assignment compatible with LHS. 5540b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // false otherwise. 5541627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian bool IsSuperClass = 5542627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian LHS->getInterface()->isSuperClassOf(RHS->getInterface()); 5543627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian if (IsSuperClass) { 5544b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // OK if conversion of LHS to SuperClass results in narrowing of types 5545b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // ; i.e., SuperClass may implement at least one of the protocols 5546b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // in LHS's protocol list. Example, SuperObj<P1> = lhs<P1,P2> is ok. 5547b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // But not SuperObj<P1,P2,P3> = lhs<P1,P2>. 5548b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> SuperClassInheritedProtocols; 5549627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian CollectInheritedProtocols(RHS->getInterface(), SuperClassInheritedProtocols); 5550b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // If super class has no protocols, it is not a match. 5551b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (SuperClassInheritedProtocols.empty()) 5552b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return false; 5553b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian 5554b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian for (ObjCObjectType::qual_iterator LHSPI = LHS->qual_begin(), 5555b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian LHSPE = LHS->qual_end(); 5556b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian LHSPI != LHSPE; LHSPI++) { 5557b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian bool SuperImplementsProtocol = false; 5558b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian ObjCProtocolDecl *LHSProto = (*LHSPI); 5559b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian 5560b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 5561b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian SuperClassInheritedProtocols.begin(), 5562b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian E = SuperClassInheritedProtocols.end(); I != E; ++I) { 5563b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian ObjCProtocolDecl *SuperClassProto = (*I); 5564b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (SuperClassProto->lookupProtocolNamed(LHSProto->getIdentifier())) { 5565b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian SuperImplementsProtocol = true; 5566b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian break; 5567b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5568b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5569b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (!SuperImplementsProtocol) 5570b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return false; 5571b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5572b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return true; 5573b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5574b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return false; 5575b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 55761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5577c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall for (ObjCObjectType::qual_iterator LHSPI = LHS->qual_begin(), 5578c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall LHSPE = LHS->qual_end(); 557991b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff LHSPI != LHSPE; LHSPI++) { 558091b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff bool RHSImplementsProtocol = false; 558191b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff 558291b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // If the RHS doesn't implement the protocol on the left, the types 558391b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // are incompatible. 5584c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall for (ObjCObjectType::qual_iterator RHSPI = RHS->qual_begin(), 5585c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall RHSPE = RHS->qual_end(); 55868f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff RHSPI != RHSPE; RHSPI++) { 55878f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff if ((*RHSPI)->lookupProtocolNamed((*LHSPI)->getIdentifier())) { 558891b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff RHSImplementsProtocol = true; 55898f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff break; 55908f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff } 559191b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff } 559291b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // FIXME: For better diagnostics, consider passing back the protocol name. 559391b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff if (!RHSImplementsProtocol) 559491b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff return false; 559591b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff } 559691b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // The RHS implements all protocols listed on the LHS. 559791b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff return true; 55986ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner} 55996ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner 5600389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroffbool ASTContext::areComparableObjCPointerTypes(QualType LHS, QualType RHS) { 5601389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff // get the "pointed to" types 5602183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const ObjCObjectPointerType *LHSOPT = LHS->getAs<ObjCObjectPointerType>(); 5603183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const ObjCObjectPointerType *RHSOPT = RHS->getAs<ObjCObjectPointerType>(); 56041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 560514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (!LHSOPT || !RHSOPT) 5606389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff return false; 560714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 560814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return canAssignObjCInterfaces(LHSOPT, RHSOPT) || 560914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff canAssignObjCInterfaces(RHSOPT, LHSOPT); 5610389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff} 5611389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff 5612569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregorbool ASTContext::canBindObjCObjectType(QualType To, QualType From) { 5613569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor return canAssignObjCInterfaces( 5614569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor getObjCObjectPointerType(To)->getAs<ObjCObjectPointerType>(), 5615569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor getObjCObjectPointerType(From)->getAs<ObjCObjectPointerType>()); 5616569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor} 5617569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor 56181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible, 5619ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff/// both shall have the identically qualified version of a compatible type. 56201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// C99 6.2.7p1: Two types have compatible types if their types are the 5621ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff/// same. See 6.7.[2,3,5] for additional rules. 5622447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregorbool ASTContext::typesAreCompatible(QualType LHS, QualType RHS, 5623447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool CompareUnqualified) { 56244e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (getLangOpts().CPlusPlus) 56250e709abafbd939326850501f795cc7a92c88a354Douglas Gregor return hasSameType(LHS, RHS); 56260e709abafbd939326850501f795cc7a92c88a354Douglas Gregor 5627447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor return !mergeTypes(LHS, RHS, false, CompareUnqualified).isNull(); 56283d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman} 56293d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 5630c286f3835eb6001c61664cef5d610dfaf80a6e9bFariborz Jahanianbool ASTContext::propertyTypesAreCompatible(QualType LHS, QualType RHS) { 563182378391dfc3b2fc22f63dbf1552bd9aed39dc42Fariborz Jahanian return typesAreCompatible(LHS, RHS); 5632c286f3835eb6001c61664cef5d610dfaf80a6e9bFariborz Jahanian} 5633c286f3835eb6001c61664cef5d610dfaf80a6e9bFariborz Jahanian 5634132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanianbool ASTContext::typesAreBlockPointerCompatible(QualType LHS, QualType RHS) { 5635132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return !mergeTypes(LHS, RHS, true).isNull(); 5636132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian} 5637132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 56384846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// mergeTransparentUnionType - if T is a transparent union type and a member 56394846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// of T is compatible with SubType, return the merged type, else return 56404846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// QualType() 56414846675e0e42d1802b0ffd8972a45e72aeb3758dPeter CollingbourneQualType ASTContext::mergeTransparentUnionType(QualType T, QualType SubType, 56424846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool OfBlockPointer, 56434846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool Unqualified) { 56444846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (const RecordType *UT = T->getAsUnionType()) { 56454846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne RecordDecl *UD = UT->getDecl(); 56464846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (UD->hasAttr<TransparentUnionAttr>()) { 56474846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne for (RecordDecl::field_iterator it = UD->field_begin(), 56484846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne itend = UD->field_end(); it != itend; ++it) { 5649f91d7572ee7fa6f2926c8e7e816039a1154a59f8Peter Collingbourne QualType ET = it->getType().getUnqualifiedType(); 56504846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType MT = mergeTypes(ET, SubType, OfBlockPointer, Unqualified); 56514846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (!MT.isNull()) 56524846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return MT; 56534846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne } 56544846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne } 56554846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne } 56564846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 56574846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return QualType(); 56584846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne} 56594846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 56604846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// mergeFunctionArgumentTypes - merge two types which appear as function 56614846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// argument types 56624846675e0e42d1802b0ffd8972a45e72aeb3758dPeter CollingbourneQualType ASTContext::mergeFunctionArgumentTypes(QualType lhs, QualType rhs, 56634846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool OfBlockPointer, 56644846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool Unqualified) { 56654846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne // GNU extension: two types are compatible if they appear as a function 56664846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne // argument, one of the types is a transparent union type and the other 56674846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne // type is compatible with a union member 56684846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType lmerge = mergeTransparentUnionType(lhs, rhs, OfBlockPointer, 56694846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne Unqualified); 56704846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (!lmerge.isNull()) 56714846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return lmerge; 56724846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 56734846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType rmerge = mergeTransparentUnionType(rhs, lhs, OfBlockPointer, 56744846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne Unqualified); 56754846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (!rmerge.isNull()) 56764846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return rmerge; 56774846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 56784846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return mergeTypes(lhs, rhs, OfBlockPointer, Unqualified); 56794846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne} 56804846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 5681132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz JahanianQualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs, 5682447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool OfBlockPointer, 5683447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool Unqualified) { 5684183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const FunctionType *lbase = lhs->getAs<FunctionType>(); 5685183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const FunctionType *rbase = rhs->getAs<FunctionType>(); 568672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase); 568772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase); 56883d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman bool allLTypes = true; 56893d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman bool allRTypes = true; 56903d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 56913d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Check return type 5692132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian QualType retType; 5693d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian if (OfBlockPointer) { 5694d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian QualType RHS = rbase->getResultType(); 5695d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian QualType LHS = lbase->getResultType(); 5696d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian bool UnqualifiedResult = Unqualified; 5697d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian if (!UnqualifiedResult) 5698d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian UnqualifiedResult = (!RHS.hasQualifiers() && LHS.hasQualifiers()); 5699a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian retType = mergeTypes(LHS, RHS, true, UnqualifiedResult, true); 5700d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian } 5701132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian else 57028cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall retType = mergeTypes(lbase->getResultType(), rbase->getResultType(), false, 57038cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall Unqualified); 57043d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (retType.isNull()) return QualType(); 5705447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5706447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) 5707447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor retType = retType.getUnqualifiedType(); 5708447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5709447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor CanQualType LRetType = getCanonicalType(lbase->getResultType()); 5710447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor CanQualType RRetType = getCanonicalType(rbase->getResultType()); 5711447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5712447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LRetType = LRetType.getUnqualifiedType(); 5713447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RRetType = RRetType.getUnqualifiedType(); 5714447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 5715447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5716447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (getCanonicalType(retType) != LRetType) 571761710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allLTypes = false; 5718447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (getCanonicalType(retType) != RRetType) 571961710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allRTypes = false; 57208cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 57216a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // FIXME: double check this 57226a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // FIXME: should we error if lbase->getRegParmAttr() != 0 && 57236a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // rbase->getRegParmAttr() != 0 && 57246a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // lbase->getRegParmAttr() != rbase->getRegParmAttr()? 5725264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo lbaseInfo = lbase->getExtInfo(); 5726264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo rbaseInfo = rbase->getExtInfo(); 57278cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 57288cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall // Compatible functions must have compatible calling conventions 57298cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall if (!isSameCallConv(lbaseInfo.getCC(), rbaseInfo.getCC())) 57308cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall return QualType(); 57318cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 57328cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall // Regparm is part of the calling convention. 5733a49218e17bcbb1acde0245773173e2c0c42f4f19Eli Friedman if (lbaseInfo.getHasRegParm() != rbaseInfo.getHasRegParm()) 5734a49218e17bcbb1acde0245773173e2c0c42f4f19Eli Friedman return QualType(); 57358cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall if (lbaseInfo.getRegParm() != rbaseInfo.getRegParm()) 57368cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall return QualType(); 57378cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 5738f85e193739c953358c865005855253af4f68a497John McCall if (lbaseInfo.getProducesResult() != rbaseInfo.getProducesResult()) 5739f85e193739c953358c865005855253af4f68a497John McCall return QualType(); 5740f85e193739c953358c865005855253af4f68a497John McCall 574153c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian // functypes which return are preferred over those that do not. 574253c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian if (lbaseInfo.getNoReturn() && !rbaseInfo.getNoReturn()) 57436a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar allLTypes = false; 574453c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian else if (!lbaseInfo.getNoReturn() && rbaseInfo.getNoReturn()) 57456a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar allRTypes = false; 574653c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian // FIXME: some uses, e.g. conditional exprs, really want this to be 'both'. 574753c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian bool NoReturn = lbaseInfo.getNoReturn() || rbaseInfo.getNoReturn(); 57481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5749f85e193739c953358c865005855253af4f68a497John McCall FunctionType::ExtInfo einfo = lbaseInfo.withNoReturn(NoReturn); 5750e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 57513d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto && rproto) { // two C99 style function prototypes 5752465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl assert(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() && 5753465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl "C++ shouldn't be here"); 57543d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman unsigned lproto_nargs = lproto->getNumArgs(); 57553d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman unsigned rproto_nargs = rproto->getNumArgs(); 57563d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 57573d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Compatible functions must have the same number of arguments 57583d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto_nargs != rproto_nargs) 57593d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 57603d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 57613d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Variadic and non-variadic functions aren't compatible 57623d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto->isVariadic() != rproto->isVariadic()) 57633d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 57643d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 57657fb5e4888221cd36652d078c6b171ac55e7f406dArgyrios Kyrtzidis if (lproto->getTypeQuals() != rproto->getTypeQuals()) 57667fb5e4888221cd36652d078c6b171ac55e7f406dArgyrios Kyrtzidis return QualType(); 57677fb5e4888221cd36652d078c6b171ac55e7f406dArgyrios Kyrtzidis 576878213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (LangOpts.ObjCAutoRefCount && 576978213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian !FunctionTypesMatchOnNSConsumedAttrs(rproto, lproto)) 577078213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return QualType(); 577178213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian 57723d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Check argument compatibility 57735f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 10> types; 57743d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman for (unsigned i = 0; i < lproto_nargs; i++) { 57753d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType largtype = lproto->getArgType(i).getUnqualifiedType(); 57763d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType rargtype = rproto->getArgType(i).getUnqualifiedType(); 57774846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType argtype = mergeFunctionArgumentTypes(largtype, rargtype, 57784846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne OfBlockPointer, 57794846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne Unqualified); 57803d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (argtype.isNull()) return QualType(); 5781447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5782447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) 5783447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor argtype = argtype.getUnqualifiedType(); 5784447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 57853d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman types.push_back(argtype); 5786447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5787447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor largtype = largtype.getUnqualifiedType(); 5788447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor rargtype = rargtype.getUnqualifiedType(); 5789447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 5790447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 579161710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (getCanonicalType(argtype) != getCanonicalType(largtype)) 579261710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allLTypes = false; 579361710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (getCanonicalType(argtype) != getCanonicalType(rargtype)) 579461710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allRTypes = false; 57953d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 579678213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian 57973d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allLTypes) return lhs; 57983d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allRTypes) return rhs; 5799e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 5800e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI = lproto->getExtProtoInfo(); 5801e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall EPI.ExtInfo = einfo; 5802e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall return getFunctionType(retType, types.begin(), types.size(), EPI); 58033d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 58043d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 58053d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto) allRTypes = false; 58063d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (rproto) allLTypes = false; 58073d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 580872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor const FunctionProtoType *proto = lproto ? lproto : rproto; 58093d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (proto) { 5810465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl assert(!proto->hasExceptionSpec() && "C++ shouldn't be here"); 58113d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (proto->isVariadic()) return QualType(); 58123d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Check that the types are compatible with the types that 58133d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // would result from default argument promotions (C99 6.7.5.3p15). 58143d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // The only types actually affected are promotable integer 58153d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // types and floats, which would be passed as a different 58163d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // type depending on whether the prototype is visible. 58173d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman unsigned proto_nargs = proto->getNumArgs(); 58183d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman for (unsigned i = 0; i < proto_nargs; ++i) { 58193d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType argTy = proto->getArgType(i); 5820b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor 5821b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor // Look at the promotion type of enum types, since that is the type used 5822b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor // to pass enum values. 5823b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor if (const EnumType *Enum = argTy->getAs<EnumType>()) 5824b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor argTy = Enum->getDecl()->getPromotionType(); 5825b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor 58263d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (argTy->isPromotableIntegerType() || 58273d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman getCanonicalType(argTy).getUnqualifiedType() == FloatTy) 58283d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 58293d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 58303d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 58313d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allLTypes) return lhs; 58323d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allRTypes) return rhs; 5833e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 5834e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI = proto->getExtProtoInfo(); 5835e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall EPI.ExtInfo = einfo; 58363d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return getFunctionType(retType, proto->arg_type_begin(), 5837e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall proto->getNumArgs(), EPI); 58383d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 58393d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 58403d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allLTypes) return lhs; 58413d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allRTypes) return rhs; 58428cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall return getFunctionNoProtoType(retType, einfo); 58433d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman} 58443d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 5845132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz JahanianQualType ASTContext::mergeTypes(QualType LHS, QualType RHS, 5846447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool OfBlockPointer, 5847a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian bool Unqualified, bool BlockReturnType) { 584843d69750e7f7b26076e7474dec8839bb777b260fBill Wendling // C++ [expr]: If an expression initially has the type "reference to T", the 584943d69750e7f7b26076e7474dec8839bb777b260fBill Wendling // type is adjusted to "T" prior to any further analysis, the expression 585043d69750e7f7b26076e7474dec8839bb777b260fBill Wendling // designates the object or function denoted by the reference, and the 58517c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // expression is an lvalue unless the reference is an rvalue reference and 58527c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // the expression is a function call (possibly inside parentheses). 58530e709abafbd939326850501f795cc7a92c88a354Douglas Gregor assert(!LHS->getAs<ReferenceType>() && "LHS is a reference type?"); 58540e709abafbd939326850501f795cc7a92c88a354Douglas Gregor assert(!RHS->getAs<ReferenceType>() && "RHS is a reference type?"); 5855447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5856447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5857447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHS = LHS.getUnqualifiedType(); 5858447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHS = RHS.getUnqualifiedType(); 5859447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 58600e709abafbd939326850501f795cc7a92c88a354Douglas Gregor 58613d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType LHSCan = getCanonicalType(LHS), 58623d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman RHSCan = getCanonicalType(RHS); 58633d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 5864f3692dc4a47dc48d10cec0415c6e9e39b7a39707Chris Lattner // If two types are identical, they are compatible. 58653d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (LHSCan == RHSCan) 58663d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 58673d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 58680953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If the qualifiers are different, the types aren't compatible... mostly. 5869a4923eb7c4b04d360cb2747641a5e92818edf804Douglas Gregor Qualifiers LQuals = LHSCan.getLocalQualifiers(); 5870a4923eb7c4b04d360cb2747641a5e92818edf804Douglas Gregor Qualifiers RQuals = RHSCan.getLocalQualifiers(); 58710953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (LQuals != RQuals) { 58720953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If any of these qualifiers are different, we have a type 58730953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // mismatch. 58740953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() || 5875f85e193739c953358c865005855253af4f68a497John McCall LQuals.getAddressSpace() != RQuals.getAddressSpace() || 5876f85e193739c953358c865005855253af4f68a497John McCall LQuals.getObjCLifetime() != RQuals.getObjCLifetime()) 58770953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return QualType(); 58780953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 58790953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Exactly one GC qualifier difference is allowed: __strong is 58800953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // okay if the other type has no GC qualifier but is an Objective 58810953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // C object pointer (i.e. implicitly strong by default). We fix 58820953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // this by pretending that the unqualified type was actually 58830953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // qualified __strong. 58840953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers::GC GC_L = LQuals.getObjCGCAttr(); 58850953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers::GC GC_R = RQuals.getObjCGCAttr(); 58860953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements"); 58870953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 58880953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak) 58890953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return QualType(); 58900953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 58910953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (GC_L == Qualifiers::Strong && RHSCan->isObjCObjectPointerType()) { 58920953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return mergeTypes(LHS, getObjCGCQualType(RHS, Qualifiers::Strong)); 58930953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 58940953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (GC_R == Qualifiers::Strong && LHSCan->isObjCObjectPointerType()) { 58950953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return mergeTypes(getObjCGCQualType(LHS, Qualifiers::Strong), RHS); 58960953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 58973d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 58980953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 58990953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 59000953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Okay, qualifiers are equal. 59013d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 5902852d63b806c5cbd730c6b9d696e2e27d02546b49Eli Friedman Type::TypeClass LHSClass = LHSCan->getTypeClass(); 5903852d63b806c5cbd730c6b9d696e2e27d02546b49Eli Friedman Type::TypeClass RHSClass = RHSCan->getTypeClass(); 5904f3692dc4a47dc48d10cec0415c6e9e39b7a39707Chris Lattner 59051adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner // We want to consider the two function types to be the same for these 59061adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner // comparisons, just force one to the other. 59071adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto; 59081adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto; 59094c721d381fb279899337d120edd4a24d405e56b2Eli Friedman 59104c721d381fb279899337d120edd4a24d405e56b2Eli Friedman // Same as above for arrays 5911a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray) 5912a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner LHSClass = Type::ConstantArray; 5913a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray) 5914a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner RHSClass = Type::ConstantArray; 59151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5916c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // ObjCInterfaces are just specialized ObjCObjects. 5917c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject; 5918c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject; 5919c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 5920213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // Canonicalize ExtVector -> Vector. 5921213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (LHSClass == Type::ExtVector) LHSClass = Type::Vector; 5922213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (RHSClass == Type::ExtVector) RHSClass = Type::Vector; 59231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 59244e78fd0a960eaa7e97467f2e8f390f3a57da279bSteve Naroff // If the canonical type classes don't match. 59254e78fd0a960eaa7e97467f2e8f390f3a57da279bSteve Naroff if (LHSClass != RHSClass) { 59261adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner // C99 6.7.2.2p4: Each enumerated type shall be compatible with char, 59271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // a signed integer type, or an unsigned integer type. 5928842aef8d942a880eeb9535d40de31a86838264cbJohn McCall // Compatibility is based on the underlying type, not the promotion 5929842aef8d942a880eeb9535d40de31a86838264cbJohn McCall // type. 5930183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const EnumType* ETy = LHS->getAs<EnumType>()) { 5931b918d6b1f794266e126e5445d69233462087d764Fariborz Jahanian QualType TINT = ETy->getDecl()->getIntegerType(); 5932b918d6b1f794266e126e5445d69233462087d764Fariborz Jahanian if (!TINT.isNull() && hasSameType(TINT, RHSCan.getUnqualifiedType())) 59333d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return RHS; 5934bab96968886f4b77083f4e26a28986ddb1e42d67Eli Friedman } 5935183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const EnumType* ETy = RHS->getAs<EnumType>()) { 5936b918d6b1f794266e126e5445d69233462087d764Fariborz Jahanian QualType TINT = ETy->getDecl()->getIntegerType(); 5937b918d6b1f794266e126e5445d69233462087d764Fariborz Jahanian if (!TINT.isNull() && hasSameType(TINT, LHSCan.getUnqualifiedType())) 59383d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 5939bab96968886f4b77083f4e26a28986ddb1e42d67Eli Friedman } 5940e7cff2c00c3d74e38984a4db5c48d7e303d3ab8eFariborz Jahanian // allow block pointer type to match an 'id' type. 5941419636316c04d570c183b4797fc811932c588358Fariborz Jahanian if (OfBlockPointer && !BlockReturnType) { 5942419636316c04d570c183b4797fc811932c588358Fariborz Jahanian if (LHS->isObjCIdType() && RHS->isBlockPointerType()) 5943419636316c04d570c183b4797fc811932c588358Fariborz Jahanian return LHS; 5944419636316c04d570c183b4797fc811932c588358Fariborz Jahanian if (RHS->isObjCIdType() && LHS->isBlockPointerType()) 5945419636316c04d570c183b4797fc811932c588358Fariborz Jahanian return RHS; 5946419636316c04d570c183b4797fc811932c588358Fariborz Jahanian } 5947e7cff2c00c3d74e38984a4db5c48d7e303d3ab8eFariborz Jahanian 59483d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 5949ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff } 59503d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 59514a74678ed6c3dedac05d02b1ee341f1db869f049Steve Naroff // The canonical type classes match. 59521adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner switch (LHSClass) { 595372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define TYPE(Class, Base) 595472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define ABSTRACT_TYPE(Class, Base) 5955ad5e73887052193afda72db8efcb812bd083a4a8John McCall#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class: 595672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 595772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define DEPENDENT_TYPE(Class, Base) case Type::Class: 595872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#include "clang/AST/TypeNodes.def" 5959b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Non-canonical and dependent types shouldn't get here"); 596072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 59617c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl case Type::LValueReference: 59627c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl case Type::RValueReference: 596372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::MemberPointer: 5964b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("C++ should never be in mergeTypes"); 596572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 5966c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCInterface: 596772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::IncompleteArray: 596872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::VariableArray: 596972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::FunctionProto: 597072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::ExtVector: 5971b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Types are eliminated above"); 597272564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 59731adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::Pointer: 59743d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman { 59753d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Merge two pointer types, while trying to preserve typedef info 59766217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType LHSPointee = LHS->getAs<PointerType>()->getPointeeType(); 59776217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType RHSPointee = RHS->getAs<PointerType>()->getPointeeType(); 5978447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5979447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHSPointee = LHSPointee.getUnqualifiedType(); 5980447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHSPointee = RHSPointee.getUnqualifiedType(); 5981447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 5982447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor QualType ResultType = mergeTypes(LHSPointee, RHSPointee, false, 5983447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor Unqualified); 59843d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (ResultType.isNull()) return QualType(); 598507d258756dc856c6987c394a0972884e6ed46765Eli Friedman if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType)) 598661710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return LHS; 598707d258756dc856c6987c394a0972884e6ed46765Eli Friedman if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType)) 598861710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return RHS; 59893d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return getPointerType(ResultType); 59903d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 5991c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff case Type::BlockPointer: 5992c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff { 5993c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff // Merge two block pointer types, while trying to preserve typedef info 59946217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType LHSPointee = LHS->getAs<BlockPointerType>()->getPointeeType(); 59956217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType RHSPointee = RHS->getAs<BlockPointerType>()->getPointeeType(); 5996447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5997447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHSPointee = LHSPointee.getUnqualifiedType(); 5998447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHSPointee = RHSPointee.getUnqualifiedType(); 5999447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 6000447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor QualType ResultType = mergeTypes(LHSPointee, RHSPointee, OfBlockPointer, 6001447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor Unqualified); 6002c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff if (ResultType.isNull()) return QualType(); 6003c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType)) 6004c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff return LHS; 6005c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType)) 6006c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff return RHS; 6007c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff return getBlockPointerType(ResultType); 6008c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff } 6009b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: 6010b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman { 6011b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // Merge two pointer types, while trying to preserve typedef info 6012b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType LHSValue = LHS->getAs<AtomicType>()->getValueType(); 6013b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType RHSValue = RHS->getAs<AtomicType>()->getValueType(); 6014b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (Unqualified) { 6015b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman LHSValue = LHSValue.getUnqualifiedType(); 6016b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman RHSValue = RHSValue.getUnqualifiedType(); 6017b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 6018b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType ResultType = mergeTypes(LHSValue, RHSValue, false, 6019b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman Unqualified); 6020b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (ResultType.isNull()) return QualType(); 6021b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (getCanonicalType(LHSValue) == getCanonicalType(ResultType)) 6022b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return LHS; 6023b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (getCanonicalType(RHSValue) == getCanonicalType(ResultType)) 6024b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return RHS; 6025b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return getAtomicType(ResultType); 6026b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 60271adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::ConstantArray: 60283d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman { 60293d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const ConstantArrayType* LCAT = getAsConstantArrayType(LHS); 60303d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const ConstantArrayType* RCAT = getAsConstantArrayType(RHS); 60313d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (LCAT && RCAT && RCAT->getSize() != LCAT->getSize()) 60323d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 60333d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 60343d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType LHSElem = getAsArrayType(LHS)->getElementType(); 60353d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType RHSElem = getAsArrayType(RHS)->getElementType(); 6036447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 6037447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHSElem = LHSElem.getUnqualifiedType(); 6038447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHSElem = RHSElem.getUnqualifiedType(); 6039447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 6040447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 6041447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor QualType ResultType = mergeTypes(LHSElem, RHSElem, false, Unqualified); 60423d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (ResultType.isNull()) return QualType(); 604361710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (LCAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType)) 604461710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return LHS; 604561710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (RCAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType)) 604661710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return RHS; 60473bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (LCAT) return getConstantArrayType(ResultType, LCAT->getSize(), 60483bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman ArrayType::ArraySizeModifier(), 0); 60493bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (RCAT) return getConstantArrayType(ResultType, RCAT->getSize(), 60503bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman ArrayType::ArraySizeModifier(), 0); 60513d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const VariableArrayType* LVAT = getAsVariableArrayType(LHS); 60523d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const VariableArrayType* RVAT = getAsVariableArrayType(RHS); 605361710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (LVAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType)) 605461710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return LHS; 605561710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (RVAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType)) 605661710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return RHS; 60573d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (LVAT) { 60583d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // FIXME: This isn't correct! But tricky to implement because 60593d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // the array's size has to be the size of LHS, but the type 60603d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // has to be different. 60613d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 60623d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 60633d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (RVAT) { 60643d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // FIXME: This isn't correct! But tricky to implement because 60653d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // the array's size has to be the size of RHS, but the type 60663d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // has to be different. 60673d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return RHS; 60683d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 60693bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (getCanonicalType(LHSElem) == getCanonicalType(ResultType)) return LHS; 60703bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (getCanonicalType(RHSElem) == getCanonicalType(ResultType)) return RHS; 60717e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor return getIncompleteArrayType(ResultType, 60727e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor ArrayType::ArraySizeModifier(), 0); 60733d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 60741adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::FunctionNoProto: 6075447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor return mergeFunctionTypes(LHS, RHS, OfBlockPointer, Unqualified); 607672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Record: 607772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Enum: 60783d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 60791adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::Builtin: 60803cc4c0c3058a788689b8fc73c0ac139544435c97Chris Lattner // Only exactly equal builtin types are compatible, which is tested above. 60813d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 608264cfdb7da3cb744642fe8a99ad5c851ad3c930b2Daniel Dunbar case Type::Complex: 608364cfdb7da3cb744642fe8a99ad5c851ad3c930b2Daniel Dunbar // Distinct complex types are incompatible. 608464cfdb7da3cb744642fe8a99ad5c851ad3c930b2Daniel Dunbar return QualType(); 60853cc4c0c3058a788689b8fc73c0ac139544435c97Chris Lattner case Type::Vector: 60865a61f0e5c5aaecd5713c3fa4b78be7167a7eeff2Eli Friedman // FIXME: The merged type should be an ExtVector! 60871c471f3e1c0ec8cbc82447bb35908dfc55463e46John McCall if (areCompatVectorTypes(LHSCan->getAs<VectorType>(), 60881c471f3e1c0ec8cbc82447bb35908dfc55463e46John McCall RHSCan->getAs<VectorType>())) 60893d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 609061710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return QualType(); 6091c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCObject: { 6092c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Check if the types are assignment compatible. 60935a61f0e5c5aaecd5713c3fa4b78be7167a7eeff2Eli Friedman // FIXME: This should be type compatibility, e.g. whether 60945a61f0e5c5aaecd5713c3fa4b78be7167a7eeff2Eli Friedman // "LHS x; RHS x;" at global scope is legal. 6095c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* LHSIface = LHS->getAs<ObjCObjectType>(); 6096c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* RHSIface = RHS->getAs<ObjCObjectType>(); 6097c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (canAssignObjCInterfaces(LHSIface, RHSIface)) 60985fd659db11922fc12a58e478f7b745f9656b15a7Steve Naroff return LHS; 60995fd659db11922fc12a58e478f7b745f9656b15a7Steve Naroff 61003d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 610161490e9a965cfee8a78c12c6802138844f04250dCedric Venet } 610214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff case Type::ObjCObjectPointer: { 6103132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (OfBlockPointer) { 6104132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (canAssignObjCInterfacesInBlockPointer( 6105132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian LHS->getAs<ObjCObjectPointerType>(), 6106a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian RHS->getAs<ObjCObjectPointerType>(), 6107a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian BlockReturnType)) 61087530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie return LHS; 6109132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return QualType(); 6110132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 6111183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (canAssignObjCInterfaces(LHS->getAs<ObjCObjectPointerType>(), 6112183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall RHS->getAs<ObjCObjectPointerType>())) 611314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return LHS; 611414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 6115bc76dd06eb881c70c9775b74bab8b88cd747f173Steve Naroff return QualType(); 61167530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie } 6117ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff } 611872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 61197530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie llvm_unreachable("Invalid Type::Class!"); 6120ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff} 61217192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek 612278213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanianbool ASTContext::FunctionTypesMatchOnNSConsumedAttrs( 612378213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian const FunctionProtoType *FromFunctionType, 612478213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian const FunctionProtoType *ToFunctionType) { 612578213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (FromFunctionType->hasAnyConsumedArgs() != 612678213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ToFunctionType->hasAnyConsumedArgs()) 612778213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return false; 612878213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian FunctionProtoType::ExtProtoInfo FromEPI = 612978213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian FromFunctionType->getExtProtoInfo(); 613078213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian FunctionProtoType::ExtProtoInfo ToEPI = 613178213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ToFunctionType->getExtProtoInfo(); 613278213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (FromEPI.ConsumedArguments && ToEPI.ConsumedArguments) 613378213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumArgs(); 613478213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ArgIdx != NumArgs; ++ArgIdx) { 613578213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (FromEPI.ConsumedArguments[ArgIdx] != 613678213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ToEPI.ConsumedArguments[ArgIdx]) 613778213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return false; 613878213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian } 613978213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return true; 614078213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian} 614178213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian 61422390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian/// mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and 61432390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian/// 'RHS' attributes and returns the merged version; including for function 61442390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian/// return types. 61452390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz JahanianQualType ASTContext::mergeObjCGCQualifiers(QualType LHS, QualType RHS) { 61462390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType LHSCan = getCanonicalType(LHS), 61472390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian RHSCan = getCanonicalType(RHS); 61482390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // If two types are identical, they are compatible. 61492390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LHSCan == RHSCan) 61502390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return LHS; 61512390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (RHSCan->isFunctionType()) { 61522390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (!LHSCan->isFunctionType()) 61532390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61542390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType OldReturnType = 61552390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian cast<FunctionType>(RHSCan.getTypePtr())->getResultType(); 61562390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType NewReturnType = 61572390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian cast<FunctionType>(LHSCan.getTypePtr())->getResultType(); 61582390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType ResReturnType = 61592390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian mergeObjCGCQualifiers(NewReturnType, OldReturnType); 61602390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResReturnType.isNull()) 61612390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61622390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResReturnType == NewReturnType || ResReturnType == OldReturnType) { 61632390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // id foo(); ... __strong id foo(); or: __strong id foo(); ... id foo(); 61642390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // In either case, use OldReturnType to build the new function type. 61652390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian const FunctionType *F = LHS->getAs<FunctionType>(); 61662390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (const FunctionProtoType *FPT = cast<FunctionProtoType>(F)) { 6167e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 6168e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall EPI.ExtInfo = getFunctionExtInfo(LHS); 61692390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType ResultType 61702390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian = getFunctionType(OldReturnType, FPT->arg_type_begin(), 6171e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FPT->getNumArgs(), EPI); 61722390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return ResultType; 61732390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 61742390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 61752390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61762390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 61772390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 61782390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // If the qualifiers are different, the types can still be merged. 61792390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers LQuals = LHSCan.getLocalQualifiers(); 61802390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers RQuals = RHSCan.getLocalQualifiers(); 61812390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LQuals != RQuals) { 61822390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // If any of these qualifiers are different, we have a type mismatch. 61832390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() || 61842390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian LQuals.getAddressSpace() != RQuals.getAddressSpace()) 61852390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61862390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 61872390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // Exactly one GC qualifier difference is allowed: __strong is 61882390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // okay if the other type has no GC qualifier but is an Objective 61892390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // C object pointer (i.e. implicitly strong by default). We fix 61902390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // this by pretending that the unqualified type was actually 61912390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // qualified __strong. 61922390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers::GC GC_L = LQuals.getObjCGCAttr(); 61932390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers::GC GC_R = RQuals.getObjCGCAttr(); 61942390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements"); 61952390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 61962390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak) 61972390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61982390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 61992390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (GC_L == Qualifiers::Strong) 62002390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return LHS; 62012390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (GC_R == Qualifiers::Strong) 62022390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return RHS; 62032390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 62042390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 62052390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 62062390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LHSCan->isObjCObjectPointerType() && RHSCan->isObjCObjectPointerType()) { 62072390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType LHSBaseQT = LHS->getAs<ObjCObjectPointerType>()->getPointeeType(); 62082390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType RHSBaseQT = RHS->getAs<ObjCObjectPointerType>()->getPointeeType(); 62092390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType ResQT = mergeObjCGCQualifiers(LHSBaseQT, RHSBaseQT); 62102390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResQT == LHSBaseQT) 62112390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return LHS; 62122390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResQT == RHSBaseQT) 62132390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return RHS; 62142390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 62152390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 62162390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian} 62172390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 62185426bf6456a5aeac416a9150de157904d101c819Chris Lattner//===----------------------------------------------------------------------===// 6219ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman// Integer Predicates 6220ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman//===----------------------------------------------------------------------===// 622188054dee0402e4d3c1f64e6b697acc47195c0d72Chris Lattner 62224ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadunsigned ASTContext::getIntWidth(QualType T) const { 6223f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall if (const EnumType *ET = dyn_cast<EnumType>(T)) 622429a7f3342c3c6dd15d914c61ae22246c36d51ce7Eli Friedman T = ET->getDecl()->getIntegerType(); 62251274ccd90aec0b205fc838c3d504821ccfb55482Douglas Gregor if (T->isBooleanType()) 62261274ccd90aec0b205fc838c3d504821ccfb55482Douglas Gregor return 1; 6227f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman // For builtin types, just use the standard type sizing method 6228ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return (unsigned)getTypeSize(T); 6229ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman} 6230ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman 6231ad74a758189180b8ab8faea648e4766c3bfd7fcbEli FriedmanQualType ASTContext::getCorrespondingUnsignedType(QualType T) { 6232f60946222721d9ba3c059563935c17b84703187aDouglas Gregor assert(T->hasSignedIntegerRepresentation() && "Unexpected type"); 62336a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner 62346a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner // Turn <4 x signed int> -> <4 x unsigned int> 62356a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner if (const VectorType *VTy = T->getAs<VectorType>()) 62366a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner return getVectorType(getCorrespondingUnsignedType(VTy->getElementType()), 6237e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VTy->getNumElements(), VTy->getVectorKind()); 62386a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner 62396a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner // For enums, we return the unsigned version of the base type. 62406a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner if (const EnumType *ETy = T->getAs<EnumType>()) 6241ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman T = ETy->getDecl()->getIntegerType(); 62426a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner 62436a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner const BuiltinType *BTy = T->getAs<BuiltinType>(); 62446a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner assert(BTy && "Unexpected signed integer type"); 6245ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman switch (BTy->getKind()) { 6246ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Char_S: 6247ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::SChar: 6248ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedCharTy; 6249ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Short: 6250ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedShortTy; 6251ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Int: 6252ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedIntTy; 6253ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Long: 6254ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedLongTy; 6255ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::LongLong: 6256ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedLongLongTy; 62572df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::Int128: 62582df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner return UnsignedInt128Ty; 6259ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman default: 6260b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unexpected signed integer type"); 6261ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman } 6262ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman} 6263ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman 62647b90340c9c7d07aef4e301e72b5e8a30d5f4f0c8Argyrios KyrtzidisASTMutationListener::~ASTMutationListener() { } 62657b90340c9c7d07aef4e301e72b5e8a30d5f4f0c8Argyrios Kyrtzidis 626686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 626786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner//===----------------------------------------------------------------------===// 626886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner// Builtin Type Computation 626986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner//===----------------------------------------------------------------------===// 627086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 627186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner/// DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the 627233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// pointer over the consumed characters. This returns the resultant type. If 627333daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// AllowTypeModifiers is false then modifier like * are not parsed, just basic 627433daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// types. This allows "v2i*" to be parsed as a pointer to a v2i instead of 627533daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// a vector of "i*". 627614e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner/// 627714e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner/// RequiresICE is filled in on return to indicate whether the value is required 627814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner/// to be an Integer Constant Expression. 62794ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadstatic QualType DecodeTypeFromStr(const char *&Str, const ASTContext &Context, 628086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner ASTContext::GetBuiltinTypeError &Error, 628114e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner bool &RequiresICE, 628233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner bool AllowTypeModifiers) { 628386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // Modifiers. 628486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner int HowLong = 0; 628586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner bool Signed = false, Unsigned = false; 628614e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE = false; 6287393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner 628833daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // Read the prefixed modifiers first. 628986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner bool Done = false; 629086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner while (!Done) { 629186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner switch (*Str++) { 62921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump default: Done = true; --Str; break; 6293393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner case 'I': 629414e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE = true; 6295393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner break; 629686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'S': 629786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Unsigned && "Can't use both 'S' and 'U' modifiers!"); 629886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Signed && "Can't use 'S' modifier multiple times!"); 629986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Signed = true; 630086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 630186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'U': 630286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Signed && "Can't use both 'S' and 'U' modifiers!"); 630386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Unsigned && "Can't use 'S' modifier multiple times!"); 630486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Unsigned = true; 630586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 630686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'L': 630786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong <= 2 && "Can't have LLLL modifier"); 630886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner ++HowLong; 630986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 631086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 631186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 631286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 631386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner QualType Type; 63141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 631586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // Read the base type. 631686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner switch (*Str++) { 6317b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Unknown builtin type letter!"); 631886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'v': 631986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && 632086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "Bad modifiers used with 'v'!"); 632186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.VoidTy; 632286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 632386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'f': 632486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && 632586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "Bad modifiers used with 'f'!"); 632686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.FloatTy; 632786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 632886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'd': 632986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong < 2 && !Signed && !Unsigned && 633086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "Bad modifiers used with 'd'!"); 633186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (HowLong) 633286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.LongDoubleTy; 633386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 633486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.DoubleTy; 633586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 633686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 's': 633786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && "Bad modifiers used with 's'!"); 633886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Unsigned) 633986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.UnsignedShortTy; 634086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 634186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.ShortTy; 634286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 634386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'i': 634486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (HowLong == 3) 634586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty; 634686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else if (HowLong == 2) 634786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy; 634886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else if (HowLong == 1) 634986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedLongTy : Context.LongTy; 635086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 635186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedIntTy : Context.IntTy; 635286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 635386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'c': 635486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && "Bad modifiers used with 'c'!"); 635586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Signed) 635686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.SignedCharTy; 635786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else if (Unsigned) 635886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.UnsignedCharTy; 635986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 636086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.CharTy; 636186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 636286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'b': // boolean 636386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'b'!"); 636486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.BoolTy; 636586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 636686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'z': // size_t. 636786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'z'!"); 636886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getSizeType(); 636986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 637086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'F': 637186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getCFConstantStringType(); 637286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 6373ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian case 'G': 6374ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian Type = Context.getObjCIdType(); 6375ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian break; 6376ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian case 'H': 6377ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian Type = Context.getObjCSelType(); 6378ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian break; 637986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'a': 638086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getBuiltinVaListType(); 638186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Type.isNull() && "builtin va list type not initialized!"); 638286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 638386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'A': 638486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // This is a "reference" to a va_list; however, what exactly 638586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // this means depends on how va_list is defined. There are two 638686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // different kinds of va_list: ones passed by value, and ones 638786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // passed by reference. An example of a by-value va_list is 638886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // x86, where va_list is a char*. An example of by-ref va_list 638986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // is x86-64, where va_list is a __va_list_tag[1]. For x86, 639086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // we want this argument to be a char*&; for x86-64, we want 639186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // it to be a __va_list_tag*. 639286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getBuiltinVaListType(); 639386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Type.isNull() && "builtin va list type not initialized!"); 639414e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner if (Type->isArrayType()) 639586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getArrayDecayedType(Type); 639614e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner else 639786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getLValueReferenceType(Type); 639886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 639986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'V': { 640086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner char *End; 640186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner unsigned NumElements = strtoul(Str, &End, 10); 640286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(End != Str && "Missing vector size"); 640386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Str = End; 64041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 640514e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType ElementType = DecodeTypeFromStr(Str, Context, Error, 640614e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE, false); 640714e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert(!RequiresICE && "Can't require vector ICE"); 640833daae66462e8f51ee153463b32bdefd60c801aaChris Lattner 640933daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // TODO: No way to make AltiVec vectors in builtins yet. 6410788b0fd67e1992f23555454efcdb16a19dfefac3Chris Lattner Type = Context.getVectorType(ElementType, NumElements, 6411e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType::GenericVector); 641286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 641386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 6414d3a23b238a2b2c0f11e6ac4951c7410a8c5717bfDouglas Gregor case 'X': { 641514e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE, 641614e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner false); 641714e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert(!RequiresICE && "Can't require complex ICE"); 6418d3a23b238a2b2c0f11e6ac4951c7410a8c5717bfDouglas Gregor Type = Context.getComplexType(ElementType); 6419d3a23b238a2b2c0f11e6ac4951c7410a8c5717bfDouglas Gregor break; 6420cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian } 6421cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian case 'Y' : { 6422cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian Type = Context.getPointerDiffType(); 6423cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian break; 6424cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian } 64259a5a7e7351f78345a72c4956af25590f6d40ebcdChris Lattner case 'P': 6426c29f77b769bcc5b6dc85e72c8e3cc2e348e5cf25Douglas Gregor Type = Context.getFILEType(); 6427c29f77b769bcc5b6dc85e72c8e3cc2e348e5cf25Douglas Gregor if (Type.isNull()) { 6428f711c41dd9412a8182793259d355c4f6979ed5edMike Stump Error = ASTContext::GE_Missing_stdio; 642986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return QualType(); 643086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 6431fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump break; 64329a5a7e7351f78345a72c4956af25590f6d40ebcdChris Lattner case 'J': 6433f711c41dd9412a8182793259d355c4f6979ed5edMike Stump if (Signed) 6434782fa308a765aeac2acb39c4e697c937ec21185bMike Stump Type = Context.getsigjmp_bufType(); 6435f711c41dd9412a8182793259d355c4f6979ed5edMike Stump else 6436f711c41dd9412a8182793259d355c4f6979ed5edMike Stump Type = Context.getjmp_bufType(); 6437f711c41dd9412a8182793259d355c4f6979ed5edMike Stump 6438fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump if (Type.isNull()) { 6439f711c41dd9412a8182793259d355c4f6979ed5edMike Stump Error = ASTContext::GE_Missing_setjmp; 6440fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump return QualType(); 6441fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump } 6442fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump break; 6443e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola case 'K': 6444e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'K'!"); 6445e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola Type = Context.getucontext_tType(); 6446e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola 6447e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola if (Type.isNull()) { 6448e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola Error = ASTContext::GE_Missing_ucontext; 6449e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola return QualType(); 6450e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola } 6451e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola break; 6452782fa308a765aeac2acb39c4e697c937ec21185bMike Stump } 64531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 645433daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // If there are modifiers and if we're allowed to parse them, go for it. 645533daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Done = !AllowTypeModifiers; 645686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner while (!Done) { 6457187ab37a05b8f7015b9f39cc8cd9129a0c6d0b48John McCall switch (char c = *Str++) { 645833daae66462e8f51ee153463b32bdefd60c801aaChris Lattner default: Done = true; --Str; break; 645933daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case '*': 646033daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case '&': { 646133daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // Both pointers and references can have their pointee types 646233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // qualified with an address space. 646333daae66462e8f51ee153463b32bdefd60c801aaChris Lattner char *End; 646433daae66462e8f51ee153463b32bdefd60c801aaChris Lattner unsigned AddrSpace = strtoul(Str, &End, 10); 646533daae66462e8f51ee153463b32bdefd60c801aaChris Lattner if (End != Str && AddrSpace != 0) { 646633daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getAddrSpaceQualType(Type, AddrSpace); 646733daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Str = End; 646833daae66462e8f51ee153463b32bdefd60c801aaChris Lattner } 646933daae66462e8f51ee153463b32bdefd60c801aaChris Lattner if (c == '*') 647033daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getPointerType(Type); 647133daae66462e8f51ee153463b32bdefd60c801aaChris Lattner else 647233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getLValueReferenceType(Type); 647333daae66462e8f51ee153463b32bdefd60c801aaChris Lattner break; 647433daae66462e8f51ee153463b32bdefd60c801aaChris Lattner } 647533daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // FIXME: There's no way to have a built-in with an rvalue ref arg. 647633daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case 'C': 647733daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Type.withConst(); 647833daae66462e8f51ee153463b32bdefd60c801aaChris Lattner break; 647933daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case 'D': 648033daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getVolatileType(Type); 648133daae66462e8f51ee153463b32bdefd60c801aaChris Lattner break; 648218932a0f2a94a7813ec461d1118c39ecf8aa936fTed Kremenek case 'R': 648318932a0f2a94a7813ec461d1118c39ecf8aa936fTed Kremenek Type = Type.withRestrict(); 648418932a0f2a94a7813ec461d1118c39ecf8aa936fTed Kremenek break; 648586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 648686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 6487393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner 648814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert((!RequiresICE || Type->isIntegralOrEnumerationType()) && 6489393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner "Integer constant 'I' type must be an integer"); 64901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 649186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return Type; 649286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner} 649386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 649486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner/// GetBuiltinType - Return the type for the specified builtin. 649533daae66462e8f51ee153463b32bdefd60c801aaChris LattnerQualType ASTContext::GetBuiltinType(unsigned Id, 649614e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner GetBuiltinTypeError &Error, 64974ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned *IntegerConstantArgs) const { 649833daae66462e8f51ee153463b32bdefd60c801aaChris Lattner const char *TypeStr = BuiltinInfo.GetTypeString(Id); 64991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 65005f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 8> ArgTypes; 65011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 650214e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner bool RequiresICE = false; 650386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Error = GE_None; 650414e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType ResType = DecodeTypeFromStr(TypeStr, *this, Error, 650514e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE, true); 650686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Error != GE_None) 650786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return QualType(); 650814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner 650914e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert(!RequiresICE && "Result of intrinsic cannot be required to be an ICE"); 651014e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner 651186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner while (TypeStr[0] && TypeStr[0] != '.') { 651214e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType Ty = DecodeTypeFromStr(TypeStr, *this, Error, RequiresICE, true); 651386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Error != GE_None) 651486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return QualType(); 651586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 651614e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner // If this argument is required to be an IntegerConstantExpression and the 651714e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner // caller cares, fill in the bitmask we return. 651814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner if (RequiresICE && IntegerConstantArgs) 651914e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner *IntegerConstantArgs |= 1 << ArgTypes.size(); 652014e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner 652186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // Do array -> pointer decay. The builtin should use the decayed type. 652286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Ty->isArrayType()) 652386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Ty = getArrayDecayedType(Ty); 65241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 652586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner ArgTypes.push_back(Ty); 652686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 652786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 652886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert((TypeStr[0] != '.' || TypeStr[1] == 0) && 652986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "'.' should only occur at end of builtin type list!"); 653086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 653100ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall FunctionType::ExtInfo EI; 653200ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall if (BuiltinInfo.isNoReturn(Id)) EI = EI.withNoReturn(true); 653300ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall 653400ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall bool Variadic = (TypeStr[0] == '.'); 653500ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall 653600ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall // We really shouldn't be making a no-proto type here, especially in C++. 653700ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall if (ArgTypes.empty() && Variadic) 653800ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall return getFunctionNoProtoType(ResType, EI); 6539ce056bcaa1c97b89a4b2de2112c62d060863be2bDouglas Gregor 6540e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI; 654100ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall EPI.ExtInfo = EI; 654200ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall EPI.Variadic = Variadic; 6543e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 6544e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall return getFunctionType(ResType, ArgTypes.data(), ArgTypes.size(), EPI); 654586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner} 6546a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman 654790e99a84ddd020e8fda79643748243725a2ed071Argyrios KyrtzidisGVALinkage ASTContext::GetGVALinkageForFunction(const FunctionDecl *FD) { 654890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis GVALinkage External = GVA_StrongExternal; 654990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 655090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis Linkage L = FD->getLinkage(); 655190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (L) { 655290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case NoLinkage: 655390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case InternalLinkage: 655490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case UniqueExternalLinkage: 655590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_Internal; 655690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 655790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case ExternalLinkage: 655890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (FD->getTemplateSpecializationKind()) { 655990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_Undeclared: 656090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitSpecialization: 656190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis External = GVA_StrongExternal; 656290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis break; 656390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 656490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDefinition: 656590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_ExplicitTemplateInstantiation; 656690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 656790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDeclaration: 656890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ImplicitInstantiation: 656990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis External = GVA_TemplateInstantiation; 657090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis break; 657190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 657290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 657390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 657490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (!FD->isInlined()) 657590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return External; 657690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 65774e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (!getLangOpts().CPlusPlus || FD->hasAttr<GNUInlineAttr>()) { 657890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // GNU or C99 inline semantics. Determine whether this symbol should be 657990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // externally visible. 658090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (FD->isInlineDefinitionExternallyVisible()) 658190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return External; 658290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 658390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // C99 inline semantics, where the symbol is not externally visible. 658490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_C99Inline; 658590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 658690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 658790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // C++0x [temp.explicit]p9: 658890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // [ Note: The intent is that an inline function that is the subject of 658990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // an explicit instantiation declaration will still be implicitly 659090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // instantiated when used so that the body can be considered for 659190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // inlining, but that no out-of-line copy of the inline function would be 659290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // generated in the translation unit. -- end note ] 659390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (FD->getTemplateSpecializationKind() 659490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis == TSK_ExplicitInstantiationDeclaration) 659590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_C99Inline; 659690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 659790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_CXXInline; 659890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis} 659990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 660090e99a84ddd020e8fda79643748243725a2ed071Argyrios KyrtzidisGVALinkage ASTContext::GetGVALinkageForVariable(const VarDecl *VD) { 660190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // If this is a static data member, compute the kind of template 660290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // specialization. Otherwise, this variable is not part of a 660390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // template. 660490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis TemplateSpecializationKind TSK = TSK_Undeclared; 660590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (VD->isStaticDataMember()) 660690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis TSK = VD->getTemplateSpecializationKind(); 660790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 660890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis Linkage L = VD->getLinkage(); 66094e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (L == ExternalLinkage && getLangOpts().CPlusPlus && 661090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis VD->getType()->getLinkage() == UniqueExternalLinkage) 661190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis L = UniqueExternalLinkage; 661290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 661390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (L) { 661490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case NoLinkage: 661590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case InternalLinkage: 661690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case UniqueExternalLinkage: 661790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_Internal; 661890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 661990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case ExternalLinkage: 662090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (TSK) { 662190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_Undeclared: 662290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitSpecialization: 662390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_StrongExternal; 662490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 662590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDeclaration: 662690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis llvm_unreachable("Variable should not be instantiated"); 662790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Fall through to treat this like any other instantiation. 662890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 662990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDefinition: 663090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_ExplicitTemplateInstantiation; 663190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 663290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ImplicitInstantiation: 663390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_TemplateInstantiation; 663490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 663590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 663690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 66377530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie llvm_unreachable("Invalid Linkage!"); 663890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis} 663990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 66404ac7c0bb39696e92fd220118fedc484c09a69870Argyrios Kyrtzidisbool ASTContext::DeclMustBeEmitted(const Decl *D) { 664190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 664290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (!VD->isFileVarDecl()) 664390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 6644144b38a7995cbe0928e34fbcc865bb2d2be4f7a3Argyrios Kyrtzidis } else if (!isa<FunctionDecl>(D)) 664590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 664690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 6647ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis // Weak references don't produce any output by themselves. 6648ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis if (D->hasAttr<WeakRefAttr>()) 6649ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis return false; 6650ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis 665190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Aliases and used decls are required. 665290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (D->hasAttr<AliasAttr>() || D->hasAttr<UsedAttr>()) 665390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 665490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 665590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 665690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Forward declarations aren't required. 665710620eb5164e31208fcbf0437cd79ae535ed0559Sean Hunt if (!FD->doesThisDeclarationHaveABody()) 6658dce67a70a86db8758c926a76fdd980f5369d5746Nick Lewycky return FD->doesDeclarationForceExternallyVisibleDefinition(); 665990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 666090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Constructors and destructors are required. 666190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (FD->hasAttr<ConstructorAttr>() || FD->hasAttr<DestructorAttr>()) 666290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 666390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 666490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // The key function for a class is required. 666590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 666690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis const CXXRecordDecl *RD = MD->getParent(); 666790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (MD->isOutOfLine() && RD->isDynamicClass()) { 666890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis const CXXMethodDecl *KeyFunc = getKeyFunction(RD); 666990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (KeyFunc && KeyFunc->getCanonicalDecl() == MD->getCanonicalDecl()) 667090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 667190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 667290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 667390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 667490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis GVALinkage Linkage = GetGVALinkageForFunction(FD); 667590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 667690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // static, static inline, always_inline, and extern inline functions can 667790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // always be deferred. Normal inline functions can be deferred in C99/C++. 667890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Implicit template instantiations can also be deferred in C++. 667990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (Linkage == GVA_Internal || Linkage == GVA_C99Inline || 66803a5aca8112e03814f78906dc5d032287adb272b5Anton Yartsev Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) 668190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 668290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 668390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 668494da1587f7d584fc61df793229d197969f204cd9Douglas Gregor 668590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis const VarDecl *VD = cast<VarDecl>(D); 668690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis assert(VD->isFileVarDecl() && "Expected file scoped var"); 668790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 6688ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly) 6689ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis return false; 6690ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis 669190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Structs that have non-trivial constructors or destructors are required. 669290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 669390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // FIXME: Handle references. 6694023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt // FIXME: Be more selective about which constructors we care about. 669590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const RecordType *RT = VD->getType()->getAs<RecordType>()) { 669690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 6697023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt if (RD->hasDefinition() && !(RD->hasTrivialDefaultConstructor() && 6698023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt RD->hasTrivialCopyConstructor() && 6699023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt RD->hasTrivialMoveConstructor() && 6700023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt RD->hasTrivialDestructor())) 670190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 670290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 670390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 670490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 670590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis GVALinkage L = GetGVALinkageForVariable(VD); 670690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (L == GVA_Internal || L == GVA_TemplateInstantiation) { 670790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (!(VD->getInit() && VD->getInit()->HasSideEffects(*this))) 670890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 670990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 671090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 671190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 671290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis} 6713071cc7deffad608165b1ddd5263e8bf181861520Charles Davis 6714ee743f903858e337434ac0335f147f4de4ecae05Charles DavisCallingConv ASTContext::getDefaultMethodCallConv() { 6715ee743f903858e337434ac0335f147f4de4ecae05Charles Davis // Pass through to the C++ ABI object 6716ee743f903858e337434ac0335f147f4de4ecae05Charles Davis return ABI->getDefaultMethodCallConv(); 6717ee743f903858e337434ac0335f147f4de4ecae05Charles Davis} 6718ee743f903858e337434ac0335f147f4de4ecae05Charles Davis 67194ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadbool ASTContext::isNearlyEmpty(const CXXRecordDecl *RD) const { 6720dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson // Pass through to the C++ ABI object 6721dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson return ABI->isNearlyEmpty(RD); 6722dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson} 6723dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson 672414110477887e3dc168ffc6c191e72d705051f99ePeter CollingbourneMangleContext *ASTContext::createMangleContext() { 6725bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor switch (Target->getCXXABI()) { 672614110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne case CXXABI_ARM: 672714110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne case CXXABI_Itanium: 672814110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne return createItaniumMangleContext(*this, getDiagnostics()); 672914110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne case CXXABI_Microsoft: 673014110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne return createMicrosoftMangleContext(*this, getDiagnostics()); 673114110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne } 6732b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unsupported ABI"); 673314110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne} 673414110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne 6735071cc7deffad608165b1ddd5263e8bf181861520Charles DavisCXXABI::~CXXABI() {} 6736ba29bd25515fbd99e98ba0fedb9d93617b27609eTed Kremenek 6737ba29bd25515fbd99e98ba0fedb9d93617b27609eTed Kremeneksize_t ASTContext::getSideTableAllocatedMemory() const { 67380c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek return ASTRecordLayouts.getMemorySize() 67390c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(ObjCLayouts) 67400c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(KeyFunctions) 67410c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(ObjCImpls) 67420c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(BlockVarCopyInits) 67430c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(DeclAttrs) 67440c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromStaticDataMember) 67450c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromUsingDecl) 67460c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromUsingShadowDecl) 67470c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromUnnamedFieldDecl) 67480c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(OverriddenMethods) 67490c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(Types) 6750af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet + llvm::capacity_in_bytes(VariableArrayTypes) 67510d95f0d7b81110f77e99e833f766d19be7b7e072Francois Pichet + llvm::capacity_in_bytes(ClassScopeSpecializationPattern); 6752ba29bd25515fbd99e98ba0fedb9d93617b27609eTed Kremenek} 6753d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek 67549e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregorunsigned ASTContext::getLambdaManglingNumber(CXXMethodDecl *CallOperator) { 67559e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregor CXXRecordDecl *Lambda = CallOperator->getParent(); 67569e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregor return LambdaMangleContexts[Lambda->getDeclContext()] 67579e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregor .getManglingNumber(CallOperator); 67589e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregor} 67599e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregor 67609e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregor 6761d211cb709510fbe7e75167b9feee0050851d001aTed Kremenekvoid ASTContext::setParameterIndex(const ParmVarDecl *D, unsigned int index) { 6762d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek ParamIndices[D] = index; 6763d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek} 6764d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek 6765d211cb709510fbe7e75167b9feee0050851d001aTed Kremenekunsigned ASTContext::getParameterIndex(const ParmVarDecl *D) const { 6766d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek ParameterIndexTable::const_iterator I = ParamIndices.find(D); 6767d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek assert(I != ParamIndices.end() && 6768d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek "ParmIndices lacks entry set by ParmVarDecl"); 6769d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek return I->second; 6770d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek} 6771