ASTContext.cpp revision 9e9c454b12671a624f666fc6fbf132fdf183effc
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"; 331ffe37fdda5b4b4f162a45155c30d9f60ce110c12Sean Hunt if (getLangOptions().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"; 338ffe37fdda5b4b4f162a45155c30d9f60ce110c12Sean Hunt if (getLangOptions().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 439f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++ 440f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith InitBuiltinType(Char16Ty, BuiltinType::Char16); 441f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith else // C99 442f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith Char16Ty = getFromTargetType(Target.getChar16Type()); 443f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith 444f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++ 445f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith InitBuiltinType(Char32Ty, BuiltinType::Char32); 446f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith else // C99 447f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith Char32Ty = getFromTargetType(Target.getChar32Type()); 448f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith 449898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // Placeholder type for type-dependent expressions whose type is 450898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // completely unknown. No code should ever check a type against 451898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // DependentTy and users should never see it; however, it is here to 452898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // help diagnose failures to properly check for type-dependent 453898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // expressions. 454898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor InitBuiltinType(DependentTy, BuiltinType::Dependent); 4558e9bebdea69c590dedfbf27374114cb76fe12fbdDouglas Gregor 4562a984cad5ac3fdceeff2bd99daa7b90979313475John McCall // Placeholder type for functions. 4572a984cad5ac3fdceeff2bd99daa7b90979313475John McCall InitBuiltinType(OverloadTy, BuiltinType::Overload); 4582a984cad5ac3fdceeff2bd99daa7b90979313475John McCall 459864c041e118155c2b1ce0ba36942a3da5a4a055eJohn McCall // Placeholder type for bound members. 460864c041e118155c2b1ce0ba36942a3da5a4a055eJohn McCall InitBuiltinType(BoundMemberTy, BuiltinType::BoundMember); 461864c041e118155c2b1ce0ba36942a3da5a4a055eJohn McCall 4623c3b7f90a863af43fa63043d396553ecf205351cJohn McCall // Placeholder type for pseudo-objects. 4633c3b7f90a863af43fa63043d396553ecf205351cJohn McCall InitBuiltinType(PseudoObjectTy, BuiltinType::PseudoObject); 4643c3b7f90a863af43fa63043d396553ecf205351cJohn McCall 4651de4d4e8cb2e9c88809fea8092bc6e835a5473d2John McCall // "any" type; useful for debugger-like clients. 4661de4d4e8cb2e9c88809fea8092bc6e835a5473d2John McCall InitBuiltinType(UnknownAnyTy, BuiltinType::UnknownAny); 4671de4d4e8cb2e9c88809fea8092bc6e835a5473d2John McCall 4680ddaeb9b031070ec64afe92d9892875ac44df427John McCall // Placeholder type for unbridged ARC casts. 4690ddaeb9b031070ec64afe92d9892875ac44df427John McCall InitBuiltinType(ARCUnbridgedCastTy, BuiltinType::ARCUnbridgedCast); 4700ddaeb9b031070ec64afe92d9892875ac44df427John McCall 4715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p11. 4725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer FloatComplexTy = getComplexType(FloatTy); 4735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer DoubleComplexTy = getComplexType(DoubleTy); 4745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer LongDoubleComplexTy = getComplexType(LongDoubleTy); 4758e9bebdea69c590dedfbf27374114cb76fe12fbdDouglas Gregor 4767e219e47de26346885d667131977bd9ca2d7662aSteve Naroff BuiltinVaListType = QualType(); 4771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 47813dcd00615de5c4279d97bdf63cd5f0a14fd9dccFariborz Jahanian // Builtin types for 'id', 'Class', and 'SEL'. 479de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId); 480de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff InitBuiltinType(ObjCBuiltinClassTy, BuiltinType::ObjCClass); 48113dcd00615de5c4279d97bdf63cd5f0a14fd9dccFariborz Jahanian InitBuiltinType(ObjCBuiltinSelTy, BuiltinType::ObjCSel); 482ebcb57a8d298862c65043e88b2429591ab3c58d3Ted Kremenek 483ebcb57a8d298862c65043e88b2429591ab3c58d3Ted Kremenek // Builtin type for __objc_yes and __objc_no 484ebcb57a8d298862c65043e88b2429591ab3c58d3Ted Kremenek ObjCBuiltinBoolTy = SignedCharTy; 485ebcb57a8d298862c65043e88b2429591ab3c58d3Ted Kremenek 486a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCConstantStringType = QualType(); 4871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 48833e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // void * type 48933e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian VoidPtrTy = getPointerType(VoidTy); 4906e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl 4916e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl // nullptr type (C++0x 2.14.7) 4926e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl InitBuiltinType(NullPtrTy, BuiltinType::NullPtr); 493aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov 494aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov // half type (OpenCL 6.1.1.1) / ARM NEON __fp16 495aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov InitBuiltinType(HalfTy, BuiltinType::Half); 4965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 4975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 498d6471f7c1921c7802804ce3ff6fe9768310f72b9David BlaikieDiagnosticsEngine &ASTContext::getDiagnostics() const { 49978a916ec5ff5b66adec3c499e1b9af7b87668309Argyrios Kyrtzidis return SourceMgr.getDiagnostics(); 50078a916ec5ff5b66adec3c499e1b9af7b87668309Argyrios Kyrtzidis} 50178a916ec5ff5b66adec3c499e1b9af7b87668309Argyrios Kyrtzidis 5026320064d0c60fa8683f5623881c9394fd4aa7689Douglas GregorAttrVec& ASTContext::getDeclAttrs(const Decl *D) { 5036320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor AttrVec *&Result = DeclAttrs[D]; 5046320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor if (!Result) { 5056320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor void *Mem = Allocate(sizeof(AttrVec)); 5066320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor Result = new (Mem) AttrVec; 5076320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor } 5086320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 5096320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor return *Result; 5106320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor} 5116320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 5126320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor/// \brief Erase the attributes corresponding to the given declaration. 5136320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregorvoid ASTContext::eraseDeclAttrs(const Decl *D) { 5146320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D); 5156320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor if (Pos != DeclAttrs.end()) { 5166320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor Pos->second->~AttrVec(); 5176320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor DeclAttrs.erase(Pos); 5186320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor } 5196320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor} 5206320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 521251b4ff2578e26959a4c036140ccd61c5e9292f2Douglas GregorMemberSpecializationInfo * 522663b5a0be7261c29bc4c526a71cffcfa02d4153eDouglas GregorASTContext::getInstantiatedFromStaticDataMember(const VarDecl *Var) { 5237caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor assert(Var->isStaticDataMember() && "Not a static data member"); 524663b5a0be7261c29bc4c526a71cffcfa02d4153eDouglas Gregor llvm::DenseMap<const VarDecl *, MemberSpecializationInfo *>::iterator Pos 5257caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor = InstantiatedFromStaticDataMember.find(Var); 5267caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor if (Pos == InstantiatedFromStaticDataMember.end()) 5277caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor return 0; 5281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5297caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor return Pos->second; 5307caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor} 5317caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor 5321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid 533251b4ff2578e26959a4c036140ccd61c5e9292f2Douglas GregorASTContext::setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl, 5349421adc43891e272156fab640e5d5ee5054b779cArgyrios Kyrtzidis TemplateSpecializationKind TSK, 5359421adc43891e272156fab640e5d5ee5054b779cArgyrios Kyrtzidis SourceLocation PointOfInstantiation) { 5367caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor assert(Inst->isStaticDataMember() && "Not a static data member"); 5377caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor assert(Tmpl->isStaticDataMember() && "Not a static data member"); 5387caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor assert(!InstantiatedFromStaticDataMember[Inst] && 5397caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor "Already noted what static data member was instantiated from"); 540251b4ff2578e26959a4c036140ccd61c5e9292f2Douglas Gregor InstantiatedFromStaticDataMember[Inst] 5419421adc43891e272156fab640e5d5ee5054b779cArgyrios Kyrtzidis = new (*this) MemberSpecializationInfo(Tmpl, TSK, PointOfInstantiation); 5427caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor} 5437caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor 544af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois PichetFunctionDecl *ASTContext::getClassScopeSpecializationPattern( 545af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet const FunctionDecl *FD){ 546af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet assert(FD && "Specialization is 0"); 547af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet llvm::DenseMap<const FunctionDecl*, FunctionDecl *>::const_iterator Pos 5480d95f0d7b81110f77e99e833f766d19be7b7e072Francois Pichet = ClassScopeSpecializationPattern.find(FD); 5490d95f0d7b81110f77e99e833f766d19be7b7e072Francois Pichet if (Pos == ClassScopeSpecializationPattern.end()) 550af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet return 0; 551af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet 552af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet return Pos->second; 553af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet} 554af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet 555af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichetvoid ASTContext::setClassScopeSpecializationPattern(FunctionDecl *FD, 556af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet FunctionDecl *Pattern) { 557af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet assert(FD && "Specialization is 0"); 558af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet assert(Pattern && "Class scope specialization pattern is 0"); 5590d95f0d7b81110f77e99e833f766d19be7b7e072Francois Pichet ClassScopeSpecializationPattern[FD] = Pattern; 560af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet} 561af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet 5627ba107a1863ddfa1664555854f0d7bdb3c491c92John McCallNamedDecl * 563ed97649e9574b9d854fa4d6109c9333ae0993554John McCallASTContext::getInstantiatedFromUsingDecl(UsingDecl *UUD) { 5647ba107a1863ddfa1664555854f0d7bdb3c491c92John McCall llvm::DenseMap<UsingDecl *, NamedDecl *>::const_iterator Pos 565ed97649e9574b9d854fa4d6109c9333ae0993554John McCall = InstantiatedFromUsingDecl.find(UUD); 566ed97649e9574b9d854fa4d6109c9333ae0993554John McCall if (Pos == InstantiatedFromUsingDecl.end()) 5670d8df780aef1acda5962347a32591efc629b6748Anders Carlsson return 0; 5681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5690d8df780aef1acda5962347a32591efc629b6748Anders Carlsson return Pos->second; 5700d8df780aef1acda5962347a32591efc629b6748Anders Carlsson} 5710d8df780aef1acda5962347a32591efc629b6748Anders Carlsson 5720d8df780aef1acda5962347a32591efc629b6748Anders Carlssonvoid 573ed97649e9574b9d854fa4d6109c9333ae0993554John McCallASTContext::setInstantiatedFromUsingDecl(UsingDecl *Inst, NamedDecl *Pattern) { 574ed97649e9574b9d854fa4d6109c9333ae0993554John McCall assert((isa<UsingDecl>(Pattern) || 575ed97649e9574b9d854fa4d6109c9333ae0993554John McCall isa<UnresolvedUsingValueDecl>(Pattern) || 576ed97649e9574b9d854fa4d6109c9333ae0993554John McCall isa<UnresolvedUsingTypenameDecl>(Pattern)) && 577ed97649e9574b9d854fa4d6109c9333ae0993554John McCall "pattern decl is not a using decl"); 578ed97649e9574b9d854fa4d6109c9333ae0993554John McCall assert(!InstantiatedFromUsingDecl[Inst] && "pattern already exists"); 579ed97649e9574b9d854fa4d6109c9333ae0993554John McCall InstantiatedFromUsingDecl[Inst] = Pattern; 580ed97649e9574b9d854fa4d6109c9333ae0993554John McCall} 581ed97649e9574b9d854fa4d6109c9333ae0993554John McCall 582ed97649e9574b9d854fa4d6109c9333ae0993554John McCallUsingShadowDecl * 583ed97649e9574b9d854fa4d6109c9333ae0993554John McCallASTContext::getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst) { 584ed97649e9574b9d854fa4d6109c9333ae0993554John McCall llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos 585ed97649e9574b9d854fa4d6109c9333ae0993554John McCall = InstantiatedFromUsingShadowDecl.find(Inst); 586ed97649e9574b9d854fa4d6109c9333ae0993554John McCall if (Pos == InstantiatedFromUsingShadowDecl.end()) 587ed97649e9574b9d854fa4d6109c9333ae0993554John McCall return 0; 588ed97649e9574b9d854fa4d6109c9333ae0993554John McCall 589ed97649e9574b9d854fa4d6109c9333ae0993554John McCall return Pos->second; 590ed97649e9574b9d854fa4d6109c9333ae0993554John McCall} 591ed97649e9574b9d854fa4d6109c9333ae0993554John McCall 592ed97649e9574b9d854fa4d6109c9333ae0993554John McCallvoid 593ed97649e9574b9d854fa4d6109c9333ae0993554John McCallASTContext::setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, 594ed97649e9574b9d854fa4d6109c9333ae0993554John McCall UsingShadowDecl *Pattern) { 595ed97649e9574b9d854fa4d6109c9333ae0993554John McCall assert(!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists"); 596ed97649e9574b9d854fa4d6109c9333ae0993554John McCall InstantiatedFromUsingShadowDecl[Inst] = Pattern; 5970d8df780aef1acda5962347a32591efc629b6748Anders Carlsson} 5980d8df780aef1acda5962347a32591efc629b6748Anders Carlsson 599d8b285fee4471f393da8ee30f552ceacdc362afaAnders CarlssonFieldDecl *ASTContext::getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) { 600d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos 601d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson = InstantiatedFromUnnamedFieldDecl.find(Field); 602d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson if (Pos == InstantiatedFromUnnamedFieldDecl.end()) 603d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson return 0; 6041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 605d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson return Pos->second; 606d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson} 607d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson 608d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlssonvoid ASTContext::setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, 609d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson FieldDecl *Tmpl) { 610d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson assert(!Inst->getDeclName() && "Instantiated field decl is not unnamed"); 611d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson assert(!Tmpl->getDeclName() && "Template field decl is not unnamed"); 612d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson assert(!InstantiatedFromUnnamedFieldDecl[Inst] && 613d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson "Already noted what unnamed field was instantiated from"); 6141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 615d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl; 616d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson} 617d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson 61814d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanianbool ASTContext::ZeroBitfieldFollowsNonBitfield(const FieldDecl *FD, 61914d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanian const FieldDecl *LastFD) const { 62014d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanian return (FD->isBitField() && LastFD && !LastFD->isBitField() && 621a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith FD->getBitWidthValue(*this) == 0); 62214d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanian} 62314d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanian 624340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanianbool ASTContext::ZeroBitfieldFollowsBitfield(const FieldDecl *FD, 625340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanian const FieldDecl *LastFD) const { 626340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanian return (FD->isBitField() && LastFD && LastFD->isBitField() && 627a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith FD->getBitWidthValue(*this) == 0 && 628a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith LastFD->getBitWidthValue(*this) != 0); 629340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanian} 630340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanian 6319b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanianbool ASTContext::BitfieldFollowsBitfield(const FieldDecl *FD, 6329b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanian const FieldDecl *LastFD) const { 6339b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanian return (FD->isBitField() && LastFD && LastFD->isBitField() && 634a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith FD->getBitWidthValue(*this) && 635a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith LastFD->getBitWidthValue(*this)); 6369b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanian} 6379b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanian 638dd7fddb5b6883326e52b278a9b7e9cefea29aae0Chad Rosierbool ASTContext::NonBitfieldFollowsBitfield(const FieldDecl *FD, 63952bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian const FieldDecl *LastFD) const { 64052bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian return (!FD->isBitField() && LastFD && LastFD->isBitField() && 641a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith LastFD->getBitWidthValue(*this)); 64252bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian} 64352bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian 644dd7fddb5b6883326e52b278a9b7e9cefea29aae0Chad Rosierbool ASTContext::BitfieldFollowsNonBitfield(const FieldDecl *FD, 64552bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian const FieldDecl *LastFD) const { 64652bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian return (FD->isBitField() && LastFD && !LastFD->isBitField() && 647a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith FD->getBitWidthValue(*this)); 64852bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian} 64952bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian 6507d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas GregorASTContext::overridden_cxx_method_iterator 6517d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas GregorASTContext::overridden_methods_begin(const CXXMethodDecl *Method) const { 6527d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 6537d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor = OverriddenMethods.find(Method); 6547d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor if (Pos == OverriddenMethods.end()) 6557d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor return 0; 6567d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 6577d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor return Pos->second.begin(); 6587d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor} 6597d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 6607d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas GregorASTContext::overridden_cxx_method_iterator 6617d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas GregorASTContext::overridden_methods_end(const CXXMethodDecl *Method) const { 6627d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 6637d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor = OverriddenMethods.find(Method); 6647d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor if (Pos == OverriddenMethods.end()) 6657d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor return 0; 6667d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 6677d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor return Pos->second.end(); 6687d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor} 6697d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 670c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidisunsigned 671c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios KyrtzidisASTContext::overridden_methods_size(const CXXMethodDecl *Method) const { 672c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 673c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis = OverriddenMethods.find(Method); 674c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis if (Pos == OverriddenMethods.end()) 675c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis return 0; 676c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis 677c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis return Pos->second.size(); 678c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis} 679c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis 6807d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregorvoid ASTContext::addOverriddenMethod(const CXXMethodDecl *Method, 6817d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor const CXXMethodDecl *Overridden) { 6827d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor OverriddenMethods[Method].push_back(Overridden); 6837d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor} 6847d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 685e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregorvoid ASTContext::addedLocalImportDecl(ImportDecl *Import) { 686e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor assert(!Import->NextLocalImport && "Import declaration already in the chain"); 687e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor assert(!Import->isFromASTFile() && "Non-local import declaration"); 688e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor if (!FirstLocalImport) { 689e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor FirstLocalImport = Import; 690e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor LastLocalImport = Import; 691e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor return; 692e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor } 693e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor 694e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor LastLocalImport->NextLocalImport = Import; 695e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor LastLocalImport = Import; 696e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor} 697e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor 698464175bba1318bef7905122e9fda20cff926df78Chris Lattner//===----------------------------------------------------------------------===// 699464175bba1318bef7905122e9fda20cff926df78Chris Lattner// Type Sizing and Analysis 700464175bba1318bef7905122e9fda20cff926df78Chris Lattner//===----------------------------------------------------------------------===// 701a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 702b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner/// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified 703b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner/// scalar floating point type. 704b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattnerconst llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const { 705183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const BuiltinType *BT = T->getAs<BuiltinType>(); 706b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner assert(BT && "Not a floating point type!"); 707b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner switch (BT->getKind()) { 708b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Not a floating point type!"); 709aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov case BuiltinType::Half: return Target->getHalfFormat(); 710bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor case BuiltinType::Float: return Target->getFloatFormat(); 711bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor case BuiltinType::Double: return Target->getDoubleFormat(); 712bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor case BuiltinType::LongDouble: return Target->getLongDoubleFormat(); 713b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner } 714b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner} 715b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner 7168b752f10c394b140f9ef89e049cbad1a7676fc25Ken Dyck/// getDeclAlign - Return a conservative estimate of the alignment of the 717af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner/// specified decl. Note that bitfields do not have a valid alignment, so 718af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner/// this method will assert on them. 7195d484e8cf710207010720589d89602233de61d01Sebastian Redl/// If @p RefAsPointee, references are treated like their underlying type 7205d484e8cf710207010720589d89602233de61d01Sebastian Redl/// (for alignof), else they're treated like pointers (for CodeGen). 7214ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getDeclAlign(const Decl *D, bool RefAsPointee) const { 722bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor unsigned Align = Target->getCharWidth(); 723dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman 7244081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall bool UseAlignAttrOnly = false; 7254081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall if (unsigned AlignFromAttr = D->getMaxAlignment()) { 7264081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall Align = AlignFromAttr; 7274081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall 7284081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // __attribute__((aligned)) can increase or decrease alignment 7294081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // *except* on a struct or struct member, where it only increases 7304081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // alignment unless 'packed' is also specified. 7314081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // 73282d0b0aab9088e977c2a44c4a5a90479c63149fePeter Collingbourne // It is an error for alignas to decrease alignment, so we can 7334081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // ignore that possibility; Sema should diagnose it. 7344081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall if (isa<FieldDecl>(D)) { 7354081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall UseAlignAttrOnly = D->hasAttr<PackedAttr>() || 7364081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>(); 7374081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall } else { 7384081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall UseAlignAttrOnly = true; 7394081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall } 7404081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall } 74178a7d7d79964119a3f35b262eb154b5cbf1001edFariborz Jahanian else if (isa<FieldDecl>(D)) 74278a7d7d79964119a3f35b262eb154b5cbf1001edFariborz Jahanian UseAlignAttrOnly = 74378a7d7d79964119a3f35b262eb154b5cbf1001edFariborz Jahanian D->hasAttr<PackedAttr>() || 74478a7d7d79964119a3f35b262eb154b5cbf1001edFariborz Jahanian cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>(); 745dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman 746ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // If we're using the align attribute only, just ignore everything 747ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // else about the declaration and its type. 7484081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall if (UseAlignAttrOnly) { 749ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // do nothing 750ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 7514081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall } else if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) { 752af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner QualType T = VD->getType(); 7536217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const ReferenceType* RT = T->getAs<ReferenceType>()) { 7545d484e8cf710207010720589d89602233de61d01Sebastian Redl if (RefAsPointee) 7555d484e8cf710207010720589d89602233de61d01Sebastian Redl T = RT->getPointeeType(); 7565d484e8cf710207010720589d89602233de61d01Sebastian Redl else 7575d484e8cf710207010720589d89602233de61d01Sebastian Redl T = getPointerType(RT->getPointeeType()); 7585d484e8cf710207010720589d89602233de61d01Sebastian Redl } 7595d484e8cf710207010720589d89602233de61d01Sebastian Redl if (!T->isIncompleteType() && !T->isFunctionType()) { 7603b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Adjust alignments of declarations with array type by the 7613b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // large-array alignment on the target. 762bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor unsigned MinWidth = Target->getLargeArrayMinWidth(); 7633b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall const ArrayType *arrayType; 7643b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (MinWidth && (arrayType = getAsArrayType(T))) { 7653b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (isa<VariableArrayType>(arrayType)) 766bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = std::max(Align, Target->getLargeArrayAlign()); 7673b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall else if (isa<ConstantArrayType>(arrayType) && 7683b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall MinWidth <= getTypeSize(cast<ConstantArrayType>(arrayType))) 769bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = std::max(Align, Target->getLargeArrayAlign()); 7703b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 7713b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Walk through any array types while we're at it. 7723b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall T = getBaseElementType(arrayType); 7736deecb0d46bcfd048e651d2db7c4fb0d6407da96Rafael Espindola } 7749f1210c3280104417a4ad30f0a00825ac8fa718aChad Rosier Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr())); 775dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman } 776ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 777ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // Fields can be subject to extra alignment constraints, like if 778ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // the field is packed, the struct is packed, or the struct has a 779ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // a max-field-alignment constraint (#pragma pack). So calculate 780ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // the actual alignment of the field within the struct, and then 781ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // (as we're expected to) constrain that by the alignment of the type. 782ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall if (const FieldDecl *field = dyn_cast<FieldDecl>(VD)) { 783ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // So calculate the alignment of the field. 784ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall const ASTRecordLayout &layout = getASTRecordLayout(field->getParent()); 785ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 786ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // Start with the record's overall alignment. 787dac54c124e302d6f028ea5723c425b7f66fc7c71Ken Dyck unsigned fieldAlign = toBits(layout.getAlignment()); 788ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 789ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // Use the GCD of that and the offset within the record. 790ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall uint64_t offset = layout.getFieldOffset(field->getFieldIndex()); 791ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall if (offset > 0) { 792ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // Alignment is always a power of 2, so the GCD will be a power of 2, 793ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // which means we get to do this crazy thing instead of Euclid's. 794ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall uint64_t lowBitOfOffset = offset & (~offset + 1); 795ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall if (lowBitOfOffset < fieldAlign) 796ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall fieldAlign = static_cast<unsigned>(lowBitOfOffset); 797ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall } 798ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 799ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall Align = std::min(Align, fieldAlign); 80005f62474dd2b0f1cb69adbe0787f2868788aa949Charles Davis } 801af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner } 802dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman 803eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(Align); 804af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner} 805b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner 806ea1471e0e967548c596a71469702f8846dbaf3c0John McCallstd::pair<CharUnits, CharUnits> 807bee5a79fc95e3003d755031e3d2bb4410a71e1c1Ken DyckASTContext::getTypeInfoInChars(const Type *T) const { 808ea1471e0e967548c596a71469702f8846dbaf3c0John McCall std::pair<uint64_t, unsigned> Info = getTypeInfo(T); 809eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return std::make_pair(toCharUnitsFromBits(Info.first), 810eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck toCharUnitsFromBits(Info.second)); 811ea1471e0e967548c596a71469702f8846dbaf3c0John McCall} 812ea1471e0e967548c596a71469702f8846dbaf3c0John McCall 813ea1471e0e967548c596a71469702f8846dbaf3c0John McCallstd::pair<CharUnits, CharUnits> 814bee5a79fc95e3003d755031e3d2bb4410a71e1c1Ken DyckASTContext::getTypeInfoInChars(QualType T) const { 815ea1471e0e967548c596a71469702f8846dbaf3c0John McCall return getTypeInfoInChars(T.getTypePtr()); 816ea1471e0e967548c596a71469702f8846dbaf3c0John McCall} 817ea1471e0e967548c596a71469702f8846dbaf3c0John McCall 818a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner/// getTypeSize - Return the size of the specified type, in bits. This method 819a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner/// does not work on incomplete types. 8200953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// 8210953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// FIXME: Pointers into different addr spaces could have different sizes and 8220953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// alignment requirements: getPointerInfo should take an AddrSpace, this 8230953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// should take a QualType, &c. 824d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattnerstd::pair<uint64_t, unsigned> 8254ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getTypeInfo(const Type *T) const { 8265e301007e31e14c8ff647288e1b8bd8dbf8a5fe4Mike Stump uint64_t Width=0; 8275e301007e31e14c8ff647288e1b8bd8dbf8a5fe4Mike Stump unsigned Align=8; 828a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner switch (T->getTypeClass()) { 82972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define TYPE(Class, Base) 83072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define ABSTRACT_TYPE(Class, Base) 83118857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor#define NON_CANONICAL_TYPE(Class, Base) 83272564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define DEPENDENT_TYPE(Class, Base) case Type::Class: 83372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#include "clang/AST/TypeNodes.def" 834d3d49bb27c7ffd9accc0a6c00e887111c0348845John McCall llvm_unreachable("Should not see dependent types"); 83572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 8365d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner case Type::FunctionNoProto: 8375d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner case Type::FunctionProto: 83818857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor // GCC extension: alignof(function) = 32 bits 83918857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Width = 0; 84018857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Align = 32; 84118857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor break; 84218857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 84372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::IncompleteArray: 844fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case Type::VariableArray: 84518857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Width = 0; 84618857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Align = getTypeAlign(cast<ArrayType>(T)->getElementType()); 84718857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor break; 84818857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 849fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case Type::ConstantArray: { 8501d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const ConstantArrayType *CAT = cast<ConstantArrayType>(T); 8511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 85298be4943e8dc4f3905629a7102668960873cf863Chris Lattner std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(CAT->getElementType()); 853fea966a4103ed9c018d1494b95e9d09b161f5a70Abramo Bagnara uint64_t Size = CAT->getSize().getZExtValue(); 854fea966a4103ed9c018d1494b95e9d09b161f5a70Abramo Bagnara assert((Size == 0 || EltInfo.first <= (uint64_t)(-1)/Size) && "Overflow in array type bit size evaluation"); 855fea966a4103ed9c018d1494b95e9d09b161f5a70Abramo Bagnara Width = EltInfo.first*Size; 856030d8846c7e520330007087e949f621989876e3aChris Lattner Align = EltInfo.second; 857cd88b4171753dcb2bc0a21d78f1597c796bb8a20Argyrios Kyrtzidis Width = llvm::RoundUpToAlignment(Width, Align); 858030d8846c7e520330007087e949f621989876e3aChris Lattner break; 8595c09a02a5db85e08a432b6eeced9aa656349710dChristopher Lamb } 860213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman case Type::ExtVector: 861030d8846c7e520330007087e949f621989876e3aChris Lattner case Type::Vector: { 8629fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner const VectorType *VT = cast<VectorType>(T); 8639fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(VT->getElementType()); 8649fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner Width = EltInfo.first*VT->getNumElements(); 8654bd998bbc228915d2b9cae5b67879de48940d05eEli Friedman Align = Width; 8666fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // If the alignment is not a power of 2, round up to the next power of 2. 8676fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // This happens for non-power-of-2 length vectors. 8688eefcd353c1d06a10104f69e5079ebab3183f9a3Dan Gohman if (Align & (Align-1)) { 8699fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner Align = llvm::NextPowerOf2(Align); 8709fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner Width = llvm::RoundUpToAlignment(Width, Align); 8719fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner } 872030d8846c7e520330007087e949f621989876e3aChris Lattner break; 873030d8846c7e520330007087e949f621989876e3aChris Lattner } 8745d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner 8759e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner case Type::Builtin: 876a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner switch (cast<BuiltinType>(T)->getKind()) { 877b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Unknown builtin type!"); 878d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::Void: 87918857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor // GCC extension: alignof(void) = 8 bits. 88018857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Width = 0; 88118857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Align = 8; 88218857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor break; 88318857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 8846f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Bool: 885bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getBoolWidth(); 886bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getBoolAlign(); 8876f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 888692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::Char_S: 889692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::Char_U: 890692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::UChar: 8916f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::SChar: 892bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getCharWidth(); 893bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getCharAlign(); 8946f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 8953f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_S: 8963f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_U: 897bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getWCharWidth(); 898bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getWCharAlign(); 89964c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis break; 900f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case BuiltinType::Char16: 901bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getChar16Width(); 902bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getChar16Align(); 903f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith break; 904f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case BuiltinType::Char32: 905bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getChar32Width(); 906bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getChar32Align(); 907f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith break; 908692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::UShort: 9096f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Short: 910bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getShortWidth(); 911bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getShortAlign(); 9126f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 913692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::UInt: 9146f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Int: 915bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getIntWidth(); 916bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getIntAlign(); 9176f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 918692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::ULong: 9196f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Long: 920bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getLongWidth(); 921bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getLongAlign(); 9226f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 923692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::ULongLong: 9246f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::LongLong: 925bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getLongLongWidth(); 926bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getLongLongAlign(); 9276f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 928ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner case BuiltinType::Int128: 929ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner case BuiltinType::UInt128: 930ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner Width = 128; 931ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner Align = 128; // int128_t is 128-bit aligned on all targets. 932ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner break; 933aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov case BuiltinType::Half: 934aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Width = Target->getHalfWidth(); 935aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Align = Target->getHalfAlign(); 936aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov break; 9376f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Float: 938bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getFloatWidth(); 939bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getFloatAlign(); 9406f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 9416f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Double: 942bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getDoubleWidth(); 943bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getDoubleAlign(); 9446f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 9456f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::LongDouble: 946bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getLongDoubleWidth(); 947bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getLongDoubleAlign(); 9486f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 9496e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl case BuiltinType::NullPtr: 950bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t) 951bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(0); // == sizeof(void*) 9521590d9c0fec4c710c2962e4bb71f76979b5163d3Sebastian Redl break; 953e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian case BuiltinType::ObjCId: 954e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian case BuiltinType::ObjCClass: 955e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian case BuiltinType::ObjCSel: 956bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(0); 957bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(0); 958e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian break; 959a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner } 960bfef6d7c67831a135d6ab79931f010f750a730adChris Lattner break; 961d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff case Type::ObjCObjectPointer: 962bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(0); 963bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(0); 9646f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 965485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff case Type::BlockPointer: { 966207f4d8543529221932af82836016a2ef066c917Peter Collingbourne unsigned AS = getTargetAddressSpace( 967207f4d8543529221932af82836016a2ef066c917Peter Collingbourne cast<BlockPointerType>(T)->getPointeeType()); 968bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(AS); 969bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(AS); 970485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff break; 971485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff } 9725d484e8cf710207010720589d89602233de61d01Sebastian Redl case Type::LValueReference: 9735d484e8cf710207010720589d89602233de61d01Sebastian Redl case Type::RValueReference: { 9745d484e8cf710207010720589d89602233de61d01Sebastian Redl // alignof and sizeof should never enter this code path here, so we go 9755d484e8cf710207010720589d89602233de61d01Sebastian Redl // the pointer route. 976207f4d8543529221932af82836016a2ef066c917Peter Collingbourne unsigned AS = getTargetAddressSpace( 977207f4d8543529221932af82836016a2ef066c917Peter Collingbourne cast<ReferenceType>(T)->getPointeeType()); 978bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(AS); 979bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(AS); 9805d484e8cf710207010720589d89602233de61d01Sebastian Redl break; 9815d484e8cf710207010720589d89602233de61d01Sebastian Redl } 982f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner case Type::Pointer: { 983207f4d8543529221932af82836016a2ef066c917Peter Collingbourne unsigned AS = getTargetAddressSpace(cast<PointerType>(T)->getPointeeType()); 984bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(AS); 985bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(AS); 986f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner break; 987f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner } 988f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl case Type::MemberPointer: { 989071cc7deffad608165b1ddd5263e8bf181861520Charles Davis const MemberPointerType *MPT = cast<MemberPointerType>(T); 9901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump std::pair<uint64_t, unsigned> PtrDiffInfo = 9911cca74ef3627a3a0ab14501d23e336548f6611b2Anders Carlsson getTypeInfo(getPointerDiffType()); 992071cc7deffad608165b1ddd5263e8bf181861520Charles Davis Width = PtrDiffInfo.first * ABI->getMemberPointerSize(MPT); 9931cca74ef3627a3a0ab14501d23e336548f6611b2Anders Carlsson Align = PtrDiffInfo.second; 9941cca74ef3627a3a0ab14501d23e336548f6611b2Anders Carlsson break; 995f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl } 9965d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner case Type::Complex: { 9975d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner // Complex types have the same alignment as their elements, but twice the 9985d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner // size. 9991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump std::pair<uint64_t, unsigned> EltInfo = 100098be4943e8dc4f3905629a7102668960873cf863Chris Lattner getTypeInfo(cast<ComplexType>(T)->getElementType()); 10019e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner Width = EltInfo.first*2; 10025d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner Align = EltInfo.second; 10035d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner break; 10045d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner } 1005c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCObject: 1006c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return getTypeInfo(cast<ObjCObjectType>(T)->getBaseType().getTypePtr()); 100744a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel case Type::ObjCInterface: { 10081d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const ObjCInterfaceType *ObjCI = cast<ObjCInterfaceType>(T); 100944a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl()); 1010dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck Width = toBits(Layout.getSize()); 1011dac54c124e302d6f028ea5723c425b7f66fc7c71Ken Dyck Align = toBits(Layout.getAlignment()); 101244a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel break; 101344a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel } 101472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Record: 101572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Enum: { 10161d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const TagType *TT = cast<TagType>(T); 10171d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar 10181d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar if (TT->getDecl()->isInvalidDecl()) { 101922ce41d9fc8509da65858c75bf5b3c4dae2d8c04Douglas Gregor Width = 8; 102022ce41d9fc8509da65858c75bf5b3c4dae2d8c04Douglas Gregor Align = 8; 10218389eab190afef3462f6418b8d8fb70fb01c4005Chris Lattner break; 10228389eab190afef3462f6418b8d8fb70fb01c4005Chris Lattner } 10231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10241d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar if (const EnumType *ET = dyn_cast<EnumType>(TT)) 10257176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner return getTypeInfo(ET->getDecl()->getIntegerType()); 10267176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner 10271d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const RecordType *RT = cast<RecordType>(TT); 10287176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner const ASTRecordLayout &Layout = getASTRecordLayout(RT->getDecl()); 1029dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck Width = toBits(Layout.getSize()); 1030dac54c124e302d6f028ea5723c425b7f66fc7c71Ken Dyck Align = toBits(Layout.getAlignment()); 1031dc0d73e6495404418acf8548875aeaff07791a74Chris Lattner break; 1032a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner } 10337532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 10349fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner case Type::SubstTemplateTypeParm: 103549a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall return getTypeInfo(cast<SubstTemplateTypeParmType>(T)-> 103649a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall getReplacementType().getTypePtr()); 103749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 103834b41d939a1328f484511c6002ba2456db879a29Richard Smith case Type::Auto: { 103934b41d939a1328f484511c6002ba2456db879a29Richard Smith const AutoType *A = cast<AutoType>(T); 104034b41d939a1328f484511c6002ba2456db879a29Richard Smith assert(A->isDeduced() && "Cannot request the size of a dependent type"); 1041dc856aff4428380baa9afb5577ea04f8fb6beb13Matt Beaumont-Gay return getTypeInfo(A->getDeducedType().getTypePtr()); 104234b41d939a1328f484511c6002ba2456db879a29Richard Smith } 104334b41d939a1328f484511c6002ba2456db879a29Richard Smith 1044075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara case Type::Paren: 1045075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return getTypeInfo(cast<ParenType>(T)->getInnerType().getTypePtr()); 1046075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 104718857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor case Type::Typedef: { 1048162e1c1b487352434552147967c3dd296ebee2f7Richard Smith const TypedefNameDecl *Typedef = cast<TypedefType>(T)->getDecl(); 1049df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor std::pair<uint64_t, unsigned> Info 1050df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor = getTypeInfo(Typedef->getUnderlyingType().getTypePtr()); 1051c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner // If the typedef has an aligned attribute on it, it overrides any computed 1052c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner // alignment we have. This violates the GCC documentation (which says that 1053c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner // attribute(aligned) can only round up) but matches its implementation. 1054c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner if (unsigned AttrAlign = Typedef->getMaxAlignment()) 1055c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner Align = AttrAlign; 1056c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner else 1057c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner Align = Info.second; 1058df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor Width = Info.first; 10597532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor break; 10607176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner } 106118857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 106218857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor case Type::TypeOfExpr: 106318857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor return getTypeInfo(cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType() 106418857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor .getTypePtr()); 106518857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 106618857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor case Type::TypeOf: 106718857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor return getTypeInfo(cast<TypeOfType>(T)->getUnderlyingType().getTypePtr()); 106818857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 1069395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson case Type::Decltype: 1070395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson return getTypeInfo(cast<DecltypeType>(T)->getUnderlyingExpr()->getType() 1071395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson .getTypePtr()); 1072395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson 1073ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt case Type::UnaryTransform: 1074ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt return getTypeInfo(cast<UnaryTransformType>(T)->getUnderlyingType()); 1075ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt 1076465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara case Type::Elaborated: 1077465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr()); 10781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10799d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall case Type::Attributed: 10809d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall return getTypeInfo( 10819d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall cast<AttributedType>(T)->getEquivalentType().getTypePtr()); 10829d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 10833e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith case Type::TemplateSpecialization: { 10841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(getCanonicalType(T) != T && 108518857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor "Cannot request the size of a dependent type"); 10863e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith const TemplateSpecializationType *TST = cast<TemplateSpecializationType>(T); 10873e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith // A type alias template specialization may refer to a typedef with the 10883e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith // aligned attribute on it. 10893e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith if (TST->isTypeAlias()) 10903e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith return getTypeInfo(TST->getAliasedType().getTypePtr()); 10913e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith else 10923e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith return getTypeInfo(getCanonicalType(T)); 10933e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith } 10943e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith 1095b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: { 10962be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman std::pair<uint64_t, unsigned> Info 10972be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman = getTypeInfo(cast<AtomicType>(T)->getValueType()); 10982be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman Width = Info.first; 10992be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman Align = Info.second; 11002be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman if (Width != 0 && Width <= Target->getMaxAtomicPromoteWidth() && 11012be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman llvm::isPowerOf2_64(Width)) { 11022be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // We can potentially perform lock-free atomic operations for this 11032be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // type; promote the alignment appropriately. 11042be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // FIXME: We could potentially promote the width here as well... 11052be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // is that worthwhile? (Non-struct atomic types generally have 11062be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // power-of-two size anyway, but structs might not. Requires a bit 11072be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // of implementation work to make sure we zero out the extra bits.) 11082be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman Align = static_cast<unsigned>(Width); 11092be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman } 1110b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 1111b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 111218857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor } 11131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11142be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman assert(llvm::isPowerOf2_32(Align) && "Alignment must be power of 2"); 11159e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner return std::make_pair(Width, Align); 1116a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner} 1117a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 1118eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck/// toCharUnitsFromBits - Convert a size in bits to a size in characters. 1119eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen DyckCharUnits ASTContext::toCharUnitsFromBits(int64_t BitSize) const { 1120eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return CharUnits::fromQuantity(BitSize / getCharWidth()); 1121eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck} 1122eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck 1123dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck/// toBits - Convert a size in characters to a size in characters. 1124dd76a9ab9ea675671200f94b18ce95766841952bKen Dyckint64_t ASTContext::toBits(CharUnits CharSize) const { 1125dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck return CharSize.getQuantity() * getCharWidth(); 1126dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck} 1127dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck 1128bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck/// getTypeSizeInChars - Return the size of the specified type, in characters. 1129bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck/// This method does not work on incomplete types. 11304ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeSizeInChars(QualType T) const { 1131eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeSize(T)); 1132bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck} 11334ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeSizeInChars(const Type *T) const { 1134eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeSize(T)); 1135bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck} 1136bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck 113716e20cce43385001f33f8e3f90ee345609c805d1Ken Dyck/// getTypeAlignInChars - Return the ABI-specified alignment of a type, in 113886fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck/// characters. This method does not work on incomplete types. 11394ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeAlignInChars(QualType T) const { 1140eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeAlign(T)); 114186fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck} 11424ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeAlignInChars(const Type *T) const { 1143eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeAlign(T)); 114486fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck} 114586fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck 114634ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// getPreferredTypeAlign - Return the "preferred" alignment of the specified 114734ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// type for the current target in bits. This can be different than the ABI 114834ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// alignment in cases where it is beneficial for performance to overalign 114934ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// a data type. 11504ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadunsigned ASTContext::getPreferredTypeAlign(const Type *T) const { 115134ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner unsigned ABIAlign = getTypeAlign(T); 11521eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman 11531eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman // Double and long long should be naturally aligned if possible. 1154183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ComplexType* CT = T->getAs<ComplexType>()) 11551eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman T = CT->getElementType().getTypePtr(); 11561eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman if (T->isSpecificBuiltinType(BuiltinType::Double) || 11571eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman T->isSpecificBuiltinType(BuiltinType::LongLong)) 11581eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman return std::max(ABIAlign, (unsigned)getTypeSize(T)); 11591eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman 116034ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner return ABIAlign; 116134ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner} 116234ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner 11632c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// DeepCollectObjCIvars - 11642c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// This routine first collects all declared, but not synthesized, ivars in 11652c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// super class and then collects all ivars, including those synthesized for 11662c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// current class. This routine is used for implementation of current class 11672c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// when all ivars, declared and synthesized are known. 11689820074dd47d37681085e964cd3392ac0b3e67b9Fariborz Jahanian/// 11692c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanianvoid ASTContext::DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, 11702c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian bool leafClass, 1171db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const { 11722c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass()) 11732c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian DeepCollectObjCIvars(SuperClass, false, Ivars); 11742c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian if (!leafClass) { 11752c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(), 11762c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian E = OI->ivar_end(); I != E; ++I) 117711062e11236b7bc689dad150e8b490fd6b063ec3Fariborz Jahanian Ivars.push_back(*I); 11783060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 1179bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian ObjCInterfaceDecl *IDecl = const_cast<ObjCInterfaceDecl *>(OI); 1180db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose for (const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv; 1181bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian Iv= Iv->getNextIvar()) 1182bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian Ivars.push_back(Iv); 1183bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian } 11849820074dd47d37681085e964cd3392ac0b3e67b9Fariborz Jahanian} 11859820074dd47d37681085e964cd3392ac0b3e67b9Fariborz Jahanian 1186e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// CollectInheritedProtocols - Collect all protocols in current class and 1187e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// those inherited by it. 1188e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanianvoid ASTContext::CollectInheritedProtocols(const Decl *CDecl, 1189432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) { 1190e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (const ObjCInterfaceDecl *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) { 119153b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek // We can use protocol_iterator here instead of 119253b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek // all_referenced_protocol_iterator since we are walking all categories. 119353b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek for (ObjCInterfaceDecl::all_protocol_iterator P = OI->all_referenced_protocol_begin(), 119453b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek PE = OI->all_referenced_protocol_end(); P != PE; ++P) { 1195e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian ObjCProtocolDecl *Proto = (*P); 11963fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert(Proto->getCanonicalDecl()); 1197e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 1198b2f812165676230bce5d0215e49a4749c451ca9cFariborz Jahanian PE = Proto->protocol_end(); P != PE; ++P) { 11993fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert((*P)->getCanonicalDecl()); 1200e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(*P, Protocols); 1201e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1202b2f812165676230bce5d0215e49a4749c451ca9cFariborz Jahanian } 1203e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 1204e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian // Categories of this Interface. 1205e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (const ObjCCategoryDecl *CDeclChain = OI->getCategoryList(); 1206e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CDeclChain; CDeclChain = CDeclChain->getNextClassCategory()) 1207e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(CDeclChain, Protocols); 1208e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (ObjCInterfaceDecl *SD = OI->getSuperClass()) 1209e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian while (SD) { 1210e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(SD, Protocols); 1211e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian SD = SD->getSuperClass(); 1212e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1213b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer } else if (const ObjCCategoryDecl *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) { 121453b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek for (ObjCCategoryDecl::protocol_iterator P = OC->protocol_begin(), 1215e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = OC->protocol_end(); P != PE; ++P) { 1216e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian ObjCProtocolDecl *Proto = (*P); 12173fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert(Proto->getCanonicalDecl()); 1218e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 1219e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = Proto->protocol_end(); P != PE; ++P) 1220e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(*P, Protocols); 1221e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1222b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer } else if (const ObjCProtocolDecl *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) { 1223e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = OP->protocol_begin(), 1224e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = OP->protocol_end(); P != PE; ++P) { 1225e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian ObjCProtocolDecl *Proto = (*P); 12263fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert(Proto->getCanonicalDecl()); 1227e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 1228e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = Proto->protocol_end(); P != PE; ++P) 1229e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(*P, Protocols); 1230e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1231e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1232e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian} 1233e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 12344ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadunsigned ASTContext::CountNonClassIvars(const ObjCInterfaceDecl *OI) const { 12353bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian unsigned count = 0; 12363bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian // Count ivars declared in class extension. 123780aa1cd7973561889e51c1c152c8990a8de9c953Fariborz Jahanian for (const ObjCCategoryDecl *CDecl = OI->getFirstClassExtension(); CDecl; 123880aa1cd7973561889e51c1c152c8990a8de9c953Fariborz Jahanian CDecl = CDecl->getNextClassExtension()) 1239b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer count += CDecl->ivar_size(); 1240b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer 12413bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian // Count ivar defined in this class's implementation. This 12423bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian // includes synthesized ivars. 12433bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian if (ObjCImplementationDecl *ImplDecl = OI->getImplementation()) 1244b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer count += ImplDecl->ivar_size(); 1245b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer 12468e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian return count; 12478e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian} 12488e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian 12498deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidisbool ASTContext::isSentinelNullExpr(const Expr *E) { 12508deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis if (!E) 12518deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis return false; 12528deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12538deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis // nullptr_t is always treated as null. 12548deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis if (E->getType()->isNullPtrType()) return true; 12558deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12568deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis if (E->getType()->isAnyPointerType() && 12578deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis E->IgnoreParenCasts()->isNullPointerConstant(*this, 12588deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis Expr::NPC_ValueDependentIsNull)) 12598deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis return true; 12608deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12618deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis // Unfortunately, __null has type 'int'. 12628deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis if (isa<GNUNullExpr>(E)) return true; 12638deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12648deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis return false; 12658deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis} 12668deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12678a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Get the implementation of ObjCInterfaceDecl,or NULL if none exists. 12688a1d722f13df383600f36d77f842957c8adb5f1bArgyrios KyrtzidisObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) { 12698a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator 12708a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis I = ObjCImpls.find(D); 12718a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis if (I != ObjCImpls.end()) 12728a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return cast<ObjCImplementationDecl>(I->second); 12738a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return 0; 12748a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 12758a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Get the implementation of ObjCCategoryDecl, or NULL if none exists. 12768a1d722f13df383600f36d77f842957c8adb5f1bArgyrios KyrtzidisObjCCategoryImplDecl *ASTContext::getObjCImplementation(ObjCCategoryDecl *D) { 12778a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator 12788a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis I = ObjCImpls.find(D); 12798a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis if (I != ObjCImpls.end()) 12808a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return cast<ObjCCategoryImplDecl>(I->second); 12818a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return 0; 12828a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 12838a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis 12848a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Set the implementation of ObjCInterfaceDecl. 12858a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidisvoid ASTContext::setObjCImplementation(ObjCInterfaceDecl *IFaceD, 12868a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCImplementationDecl *ImplD) { 12878a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis assert(IFaceD && ImplD && "Passed null params"); 12888a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCImpls[IFaceD] = ImplD; 12898a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 12908a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Set the implementation of ObjCCategoryDecl. 12918a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidisvoid ASTContext::setObjCImplementation(ObjCCategoryDecl *CatD, 12928a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCCategoryImplDecl *ImplD) { 12938a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis assert(CatD && ImplD && "Passed null params"); 12948a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCImpls[CatD] = ImplD; 12958a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 12968a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis 129787ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios KyrtzidisObjCInterfaceDecl *ASTContext::getObjContainingInterface(NamedDecl *ND) const { 129887ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(ND->getDeclContext())) 129987ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return ID; 130087ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(ND->getDeclContext())) 130187ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return CD->getClassInterface(); 130287ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis if (ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(ND->getDeclContext())) 130387ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return IMD->getClassInterface(); 130487ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis 130587ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return 0; 130687ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis} 130787ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis 13081ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian/// \brief Get the copy initialization expression of VarDecl,or NULL if 13091ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian/// none exists. 1310830937bc1100fba7682f7c32c40512085870f50cFariborz JahanianExpr *ASTContext::getBlockVarCopyInits(const VarDecl*VD) { 1311d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian assert(VD && "Passed null params"); 1312d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian assert(VD->hasAttr<BlocksAttr>() && 1313d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian "getBlockVarCopyInits - not __block var"); 1314830937bc1100fba7682f7c32c40512085870f50cFariborz Jahanian llvm::DenseMap<const VarDecl*, Expr*>::iterator 1315d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian I = BlockVarCopyInits.find(VD); 13161ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian return (I != BlockVarCopyInits.end()) ? cast<Expr>(I->second) : 0; 13171ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian} 13181ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian 13191ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian/// \brief Set the copy inialization expression of a block var decl. 13201ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanianvoid ASTContext::setBlockVarCopyInits(VarDecl*VD, Expr* Init) { 13211ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian assert(VD && Init && "Passed null params"); 1322d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian assert(VD->hasAttr<BlocksAttr>() && 1323d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian "setBlockVarCopyInits - not __block var"); 13241ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian BlockVarCopyInits[VD] = Init; 13251ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian} 13261ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian 1327a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall/// \brief Allocate an uninitialized TypeSourceInfo. 1328b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// 1329a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall/// The caller should initialize the memory held by TypeSourceInfo using 1330b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// the TypeLoc wrappers. 1331b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// 1332b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// \param T the type that will be the basis for type source info. This type 1333b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// should refer to how the declarator was written in source code, not to 1334b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis/// what type semantic analysis resolved the declarator to. 1335a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCallTypeSourceInfo *ASTContext::CreateTypeSourceInfo(QualType T, 13364ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned DataSize) const { 1337109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall if (!DataSize) 1338109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall DataSize = TypeLoc::getFullDataSizeForType(T); 1339109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall else 1340109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall assert(DataSize == TypeLoc::getFullDataSizeForType(T) && 1341a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall "incorrect data size provided to CreateTypeSourceInfo!"); 1342109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall 1343a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall TypeSourceInfo *TInfo = 1344a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall (TypeSourceInfo*)BumpAlloc.Allocate(sizeof(TypeSourceInfo) + DataSize, 8); 1345a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall new (TInfo) TypeSourceInfo(T); 1346a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall return TInfo; 1347b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis} 1348b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis 1349a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCallTypeSourceInfo *ASTContext::getTrivialTypeSourceInfo(QualType T, 13506952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor SourceLocation L) const { 1351a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall TypeSourceInfo *DI = CreateTypeSourceInfo(T); 1352c21c7e9c2cded68f91be15be6847c9649242dc17Douglas Gregor DI->getTypeLoc().initialize(const_cast<ASTContext &>(*this), L); 1353a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall return DI; 1354a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall} 1355a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall 1356b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbarconst ASTRecordLayout & 13574ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const { 1358b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar return getObjCLayout(D, 0); 1359b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar} 1360b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar 1361b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbarconst ASTRecordLayout & 13624ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getASTObjCImplementationLayout( 13634ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const ObjCImplementationDecl *D) const { 1364b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar return getObjCLayout(D->getClassInterface(), D); 1365b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar} 1366b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar 1367a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner//===----------------------------------------------------------------------===// 1368a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner// Type creation/memoization methods 1369a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner//===----------------------------------------------------------------------===// 1370a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 13714ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 13723b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallASTContext::getExtQualType(const Type *baseType, Qualifiers quals) const { 13733b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall unsigned fastQuals = quals.getFastQualifiers(); 13743b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall quals.removeFastQualifiers(); 13750953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 13760953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Check if we've already instantiated this type. 13770953e767ff7817f97b3ab20896b229891eeff45bJohn McCall llvm::FoldingSetNodeID ID; 13783b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ExtQuals::Profile(ID, baseType, quals); 13793b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall void *insertPos = 0; 13803b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (ExtQuals *eq = ExtQualNodes.FindNodeOrInsertPos(ID, insertPos)) { 13813b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert(eq->getQualifiers() == quals); 13823b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(eq, fastQuals); 13830953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 13840953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 13853b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If the base type is not canonical, make the appropriate canonical type. 13863b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType canon; 13873b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!baseType->isCanonicalUnqualified()) { 13883b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = baseType->getCanonicalTypeInternal().split(); 1389200fa53fd420aa8369586f569dbece04930ad6a3John McCall canonSplit.Quals.addConsistentQualifiers(quals); 1390200fa53fd420aa8369586f569dbece04930ad6a3John McCall canon = getExtQualType(canonSplit.Ty, canonSplit.Quals); 13913b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 13923b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Re-find the insert position. 13933b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos); 13943b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall } 13953b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 13963b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ExtQuals *eq = new (*this, TypeAlignment) ExtQuals(baseType, canon, quals); 13973b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ExtQualNodes.InsertNode(eq, insertPos); 13983b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(eq, fastQuals); 13990953e767ff7817f97b3ab20896b229891eeff45bJohn McCall} 14000953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 14014ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 14024ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getAddrSpaceQualType(QualType T, unsigned AddressSpace) const { 1403f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner QualType CanT = getCanonicalType(T); 1404f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner if (CanT.getAddressSpace() == AddressSpace) 1405f46699ce225811d8d9dbab9d00189a0e54469457Chris Lattner return T; 1406b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris Lattner 14070953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If we are composing extended qualifiers together, merge together 14080953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // into one ExtQuals node. 14090953e767ff7817f97b3ab20896b229891eeff45bJohn McCall QualifierCollector Quals; 14100953e767ff7817f97b3ab20896b229891eeff45bJohn McCall const Type *TypeNode = Quals.strip(T); 14111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14120953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If this type already has an address space specified, it cannot get 14130953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // another one. 14140953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert(!Quals.hasAddressSpace() && 14150953e767ff7817f97b3ab20896b229891eeff45bJohn McCall "Type cannot be in multiple addr spaces!"); 14160953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Quals.addAddressSpace(AddressSpace); 14171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14180953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return getExtQualType(TypeNode, Quals); 1419ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb} 1420ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb 1421b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris LattnerQualType ASTContext::getObjCGCQualType(QualType T, 14224ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Qualifiers::GC GCAttr) const { 1423d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian QualType CanT = getCanonicalType(T); 1424b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris Lattner if (CanT.getObjCGCAttr() == GCAttr) 1425d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian return T; 14261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14277f040a9d817cd1c72b565e92abff473510bf9e1dJohn McCall if (const PointerType *ptr = T->getAs<PointerType>()) { 14287f040a9d817cd1c72b565e92abff473510bf9e1dJohn McCall QualType Pointee = ptr->getPointeeType(); 142958f9f2c884af6b72d036b746a016d8031d31cb7aSteve Naroff if (Pointee->isAnyPointerType()) { 14304027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian QualType ResultType = getObjCGCQualType(Pointee, GCAttr); 14314027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian return getPointerType(ResultType); 14324027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian } 14334027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian } 14341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14350953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If we are composing extended qualifiers together, merge together 14360953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // into one ExtQuals node. 14370953e767ff7817f97b3ab20896b229891eeff45bJohn McCall QualifierCollector Quals; 14380953e767ff7817f97b3ab20896b229891eeff45bJohn McCall const Type *TypeNode = Quals.strip(T); 14391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14400953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If this type already has an ObjCGC specified, it cannot get 14410953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // another one. 14420953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert(!Quals.hasObjCGCAttr() && 14430953e767ff7817f97b3ab20896b229891eeff45bJohn McCall "Type cannot have multiple ObjCGCs!"); 14440953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Quals.addObjCGCAttr(GCAttr); 14451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14460953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return getExtQualType(TypeNode, Quals); 1447d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian} 1448a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 1449e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCallconst FunctionType *ASTContext::adjustFunctionType(const FunctionType *T, 1450e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall FunctionType::ExtInfo Info) { 1451e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall if (T->getExtInfo() == Info) 1452e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall return T; 1453e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 1454e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall QualType Result; 1455e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall if (const FunctionNoProtoType *FNPT = dyn_cast<FunctionNoProtoType>(T)) { 1456e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall Result = getFunctionNoProtoType(FNPT->getResultType(), Info); 1457e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall } else { 1458e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall const FunctionProtoType *FPT = cast<FunctionProtoType>(T); 1459e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 1460e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall EPI.ExtInfo = Info; 1461e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall Result = getFunctionType(FPT->getResultType(), FPT->arg_type_begin(), 1462e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall FPT->getNumArgs(), EPI); 1463e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall } 1464e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 1465e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall return cast<FunctionType>(Result.getTypePtr()); 1466e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall} 1467e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 14685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getComplexType - Return the uniqued reference to the type for a complex 14695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// number with the specified element type. 14704ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getComplexType(QualType T) const { 14715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique pointers, to guarantee there is only one pointer of a particular 14725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 14735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 14745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ComplexType::Profile(ID, T); 14751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 14775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos)) 14785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(CT, 0); 14791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the pointee type isn't canonical, this won't be a canonical type either, 14815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // so fill in the canonical type field. 14825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 1483467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!T.isCanonical()) { 1484f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner Canonical = getComplexType(getCanonicalType(T)); 14851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 14875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos); 1488c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 14895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 14906b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ComplexType *New = new (*this, TypeAlignment) ComplexType(T, Canonical); 14915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 14925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ComplexTypes.InsertNode(New, InsertPos); 14935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 14945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 14955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 14965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getPointerType - Return the uniqued reference to the type for a pointer to 14975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// the specified type. 14984ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getPointerType(QualType T) const { 14995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique pointers, to guarantee there is only one pointer of a particular 15005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 15015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 15025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PointerType::Profile(ID, T); 15031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 15055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 15065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(PT, 0); 15071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the pointee type isn't canonical, this won't be a canonical type either, 15095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // so fill in the canonical type field. 15105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 1511467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!T.isCanonical()) { 1512f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner Canonical = getPointerType(getCanonicalType(T)); 15131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 15155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1516c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 15175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 15186b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall PointerType *New = new (*this, TypeAlignment) PointerType(T, Canonical); 15195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 15205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PointerTypes.InsertNode(New, InsertPos); 15215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 15225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 15235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 15241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getBlockPointerType - Return the uniqued reference to the type for 15255618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff/// a pointer to the specified block. 15264ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getBlockPointerType(QualType T) const { 1527296e8d5fdcf9946f51e866adc8d281379e51efe9Steve Naroff assert(T->isFunctionType() && "block of function types only"); 1528296e8d5fdcf9946f51e866adc8d281379e51efe9Steve Naroff // Unique pointers, to guarantee there is only one block of a particular 15295618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // structure. 15305618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff llvm::FoldingSetNodeID ID; 15315618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerType::Profile(ID, T); 15321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15335618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff void *InsertPos = 0; 15345618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff if (BlockPointerType *PT = 15355618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 15365618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff return QualType(PT, 0); 15371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the block pointee type isn't canonical, this won't be a canonical 15395618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // type either so fill in the canonical type field. 15405618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff QualType Canonical; 1541467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!T.isCanonical()) { 15425618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff Canonical = getBlockPointerType(getCanonicalType(T)); 15431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15445618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // Get the new insert position for the node we care about. 15455618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerType *NewIP = 15465618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1547c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 15485618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff } 15496b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall BlockPointerType *New 15506b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) BlockPointerType(T, Canonical); 15515618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff Types.push_back(New); 15525618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerTypes.InsertNode(New, InsertPos); 15535618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff return QualType(New, 0); 15545618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff} 15555618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff 15567c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// getLValueReferenceType - Return the uniqued reference to the type for an 15577c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// lvalue reference to the specified type. 15584ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 15594ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getLValueReferenceType(QualType T, bool SpelledAsLValue) const { 15609625e44c0252485277a340746ed8ac950686156fDouglas Gregor assert(getCanonicalType(T) != OverloadTy && 15619625e44c0252485277a340746ed8ac950686156fDouglas Gregor "Unresolved overloaded function type"); 15629625e44c0252485277a340746ed8ac950686156fDouglas Gregor 15635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique pointers, to guarantee there is only one pointer of a particular 15645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 15655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 156654e14c4db764c0636160d26c5bbf491637c83a76John McCall ReferenceType::Profile(ID, T, SpelledAsLValue); 15675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 15685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 15697c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl if (LValueReferenceType *RT = 15707c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 15715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(RT, 0); 15727c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 157354e14c4db764c0636160d26c5bbf491637c83a76John McCall const ReferenceType *InnerRef = T->getAs<ReferenceType>(); 157454e14c4db764c0636160d26c5bbf491637c83a76John McCall 15755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the referencee type isn't canonical, this won't be a canonical type 15765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // either, so fill in the canonical type field. 15775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 157854e14c4db764c0636160d26c5bbf491637c83a76John McCall if (!SpelledAsLValue || InnerRef || !T.isCanonical()) { 157954e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T); 158054e14c4db764c0636160d26c5bbf491637c83a76John McCall Canonical = getLValueReferenceType(getCanonicalType(PointeeType)); 15817c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 15827c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // Get the new insert position for the node we care about. 15837c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceType *NewIP = 15847c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 1585c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 15867c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl } 15877c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 15886b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall LValueReferenceType *New 158954e14c4db764c0636160d26c5bbf491637c83a76John McCall = new (*this, TypeAlignment) LValueReferenceType(T, Canonical, 159054e14c4db764c0636160d26c5bbf491637c83a76John McCall SpelledAsLValue); 15917c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl Types.push_back(New); 15927c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceTypes.InsertNode(New, InsertPos); 159354e14c4db764c0636160d26c5bbf491637c83a76John McCall 15947c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl return QualType(New, 0); 15957c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl} 15967c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 15977c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// getRValueReferenceType - Return the uniqued reference to the type for an 15987c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// rvalue reference to the specified type. 15994ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getRValueReferenceType(QualType T) const { 16007c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // Unique pointers, to guarantee there is only one pointer of a particular 16017c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // structure. 16027c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl llvm::FoldingSetNodeID ID; 160354e14c4db764c0636160d26c5bbf491637c83a76John McCall ReferenceType::Profile(ID, T, false); 16047c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 16057c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl void *InsertPos = 0; 16067c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl if (RValueReferenceType *RT = 16077c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 16087c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl return QualType(RT, 0); 16097c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 161054e14c4db764c0636160d26c5bbf491637c83a76John McCall const ReferenceType *InnerRef = T->getAs<ReferenceType>(); 161154e14c4db764c0636160d26c5bbf491637c83a76John McCall 16127c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // If the referencee type isn't canonical, this won't be a canonical type 16137c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // either, so fill in the canonical type field. 16147c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl QualType Canonical; 161554e14c4db764c0636160d26c5bbf491637c83a76John McCall if (InnerRef || !T.isCanonical()) { 161654e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T); 161754e14c4db764c0636160d26c5bbf491637c83a76John McCall Canonical = getRValueReferenceType(getCanonicalType(PointeeType)); 16187c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 16195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 16207c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceType *NewIP = 16217c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 1622c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 16235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 16245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 16256b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall RValueReferenceType *New 16266b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) RValueReferenceType(T, Canonical); 16275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 16287c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceTypes.InsertNode(New, InsertPos); 16295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 16305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 16315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1632f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl/// getMemberPointerType - Return the uniqued reference to the type for a 1633f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl/// member pointer to the specified type, in the specified class. 16344ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) const { 1635f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // Unique pointers, to guarantee there is only one pointer of a particular 1636f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // structure. 1637f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl llvm::FoldingSetNodeID ID; 1638f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerType::Profile(ID, T, Cls); 1639f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1640f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl void *InsertPos = 0; 1641f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl if (MemberPointerType *PT = 1642f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 1643f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl return QualType(PT, 0); 1644f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1645f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // If the pointee or class type isn't canonical, this won't be a canonical 1646f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // type either, so fill in the canonical type field. 1647f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl QualType Canonical; 164887c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) { 1649f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls)); 1650f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1651f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // Get the new insert position for the node we care about. 1652f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerType *NewIP = 1653f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1654c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 1655f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl } 16566b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall MemberPointerType *New 16576b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical); 1658f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl Types.push_back(New); 1659f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerTypes.InsertNode(New, InsertPos); 1660f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl return QualType(New, 0); 1661f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl} 1662f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 16631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getConstantArrayType - Return the unique reference to the type for an 1664fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff/// array of the specified element type. 16651eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType ASTContext::getConstantArrayType(QualType EltTy, 166638aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner const llvm::APInt &ArySizeIn, 1667c9406125e2cac9208098655ac8058c095c2c3a65Steve Naroff ArrayType::ArraySizeModifier ASM, 166863e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara unsigned IndexTypeQuals) const { 1669923d56d436f750bc1f29db50e641078725558a1bSebastian Redl assert((EltTy->isDependentType() || 1670923d56d436f750bc1f29db50e641078725558a1bSebastian Redl EltTy->isIncompleteType() || EltTy->isConstantSizeType()) && 1671587cbdfd95f4b0aaccc14b31f5debe85d5daf7edEli Friedman "Constant array of VLAs is illegal!"); 1672587cbdfd95f4b0aaccc14b31f5debe85d5daf7edEli Friedman 167338aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner // Convert the array size into a canonical width matching the pointer size for 167438aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner // the target. 167538aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner llvm::APInt ArySize(ArySizeIn); 16769f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad ArySize = 1677bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor ArySize.zextOrTrunc(Target->getPointerWidth(getTargetAddressSpace(EltTy))); 16781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 168063e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, IndexTypeQuals); 16811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 16831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (ConstantArrayType *ATP = 16847192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos)) 16855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(ATP, 0); 16861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16873b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If the element type isn't canonical or has qualifiers, this won't 16883b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // be a canonical type either, so fill in the canonical type field. 16893b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType Canon; 16903b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) { 16913b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = getCanonicalType(EltTy).split(); 1692200fa53fd420aa8369586f569dbece04930ad6a3John McCall Canon = getConstantArrayType(QualType(canonSplit.Ty, 0), ArySize, 169363e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara ASM, IndexTypeQuals); 1694200fa53fd420aa8369586f569dbece04930ad6a3John McCall Canon = getQualifiedType(Canon, canonSplit.Quals); 16953b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 16965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 16971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ConstantArrayType *NewIP = 16987192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos); 1699c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 17005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 17011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 17026b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ConstantArrayType *New = new(*this,TypeAlignment) 170363e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara ConstantArrayType(EltTy, Canon, ArySize, ASM, IndexTypeQuals); 17047192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek ConstantArrayTypes.InsertNode(New, InsertPos); 17055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 17065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 17075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 17085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1709ce8890371fcdb983ae487c87fa40606a34896ff7John McCall/// getVariableArrayDecayedType - Turns the given type, which may be 1710ce8890371fcdb983ae487c87fa40606a34896ff7John McCall/// variably-modified, into the corresponding type with all the known 1711ce8890371fcdb983ae487c87fa40606a34896ff7John McCall/// sizes replaced with [*]. 1712ce8890371fcdb983ae487c87fa40606a34896ff7John McCallQualType ASTContext::getVariableArrayDecayedType(QualType type) const { 1713ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Vastly most common case. 1714ce8890371fcdb983ae487c87fa40606a34896ff7John McCall if (!type->isVariablyModifiedType()) return type; 1715ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1716ce8890371fcdb983ae487c87fa40606a34896ff7John McCall QualType result; 1717ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1718ce8890371fcdb983ae487c87fa40606a34896ff7John McCall SplitQualType split = type.getSplitDesugaredType(); 1719200fa53fd420aa8369586f569dbece04930ad6a3John McCall const Type *ty = split.Ty; 1720ce8890371fcdb983ae487c87fa40606a34896ff7John McCall switch (ty->getTypeClass()) { 1721ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#define TYPE(Class, Base) 1722ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#define ABSTRACT_TYPE(Class, Base) 1723ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 1724ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#include "clang/AST/TypeNodes.def" 1725ce8890371fcdb983ae487c87fa40606a34896ff7John McCall llvm_unreachable("didn't desugar past all non-canonical types?"); 1726ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1727ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // These types should never be variably-modified. 1728ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Builtin: 1729ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Complex: 1730ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Vector: 1731ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ExtVector: 1732ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentSizedExtVector: 1733ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ObjCObject: 1734ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ObjCInterface: 1735ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ObjCObjectPointer: 1736ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Record: 1737ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Enum: 1738ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::UnresolvedUsing: 1739ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TypeOfExpr: 1740ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TypeOf: 1741ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Decltype: 1742ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt case Type::UnaryTransform: 1743ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentName: 1744ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::InjectedClassName: 1745ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TemplateSpecialization: 1746ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentTemplateSpecialization: 1747ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TemplateTypeParm: 1748ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::SubstTemplateTypeParmPack: 174934b41d939a1328f484511c6002ba2456db879a29Richard Smith case Type::Auto: 1750ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::PackExpansion: 1751ce8890371fcdb983ae487c87fa40606a34896ff7John McCall llvm_unreachable("type should never be variably-modified"); 1752ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1753ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // These types can be variably-modified but should never need to 1754ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // further decay. 1755ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::FunctionNoProto: 1756ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::FunctionProto: 1757ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::BlockPointer: 1758ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::MemberPointer: 1759ce8890371fcdb983ae487c87fa40606a34896ff7John McCall return type; 1760ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1761ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // These types can be variably-modified. All these modifications 1762ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // preserve structure except as noted by comments. 1763ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // TODO: if we ever care about optimizing VLAs, there are no-op 1764ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // optimizations available here. 1765ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Pointer: 1766ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getPointerType(getVariableArrayDecayedType( 1767ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cast<PointerType>(ty)->getPointeeType())); 1768ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1769ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1770ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::LValueReference: { 1771ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const LValueReferenceType *lv = cast<LValueReferenceType>(ty); 1772ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getLValueReferenceType( 1773ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(lv->getPointeeType()), 1774ce8890371fcdb983ae487c87fa40606a34896ff7John McCall lv->isSpelledAsLValue()); 1775ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1776745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 1777ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1778ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::RValueReference: { 1779ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const RValueReferenceType *lv = cast<RValueReferenceType>(ty); 1780ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getRValueReferenceType( 1781ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(lv->getPointeeType())); 1782ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1783745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 1784745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1785b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: { 1786b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman const AtomicType *at = cast<AtomicType>(ty); 1787b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman result = getAtomicType(getVariableArrayDecayedType(at->getValueType())); 1788b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman break; 1789b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 1790b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 1791ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ConstantArray: { 1792ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const ConstantArrayType *cat = cast<ConstantArrayType>(ty); 1793ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getConstantArrayType( 1794ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(cat->getElementType()), 1795ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cat->getSize(), 1796ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cat->getSizeModifier(), 1797ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cat->getIndexTypeCVRQualifiers()); 1798ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1799745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 1800745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1801ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentSizedArray: { 1802ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const DependentSizedArrayType *dat = cast<DependentSizedArrayType>(ty); 1803ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getDependentSizedArrayType( 1804ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(dat->getElementType()), 1805ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getSizeExpr(), 1806ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getSizeModifier(), 1807ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getIndexTypeCVRQualifiers(), 1808ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getBracketsRange()); 1809ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1810ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1811ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1812ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Turn incomplete types into [*] types. 1813ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::IncompleteArray: { 1814ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const IncompleteArrayType *iat = cast<IncompleteArrayType>(ty); 1815ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getVariableArrayType( 1816ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(iat->getElementType()), 1817ce8890371fcdb983ae487c87fa40606a34896ff7John McCall /*size*/ 0, 1818ce8890371fcdb983ae487c87fa40606a34896ff7John McCall ArrayType::Normal, 1819ce8890371fcdb983ae487c87fa40606a34896ff7John McCall iat->getIndexTypeCVRQualifiers(), 1820ce8890371fcdb983ae487c87fa40606a34896ff7John McCall SourceRange()); 1821ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1822ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1823ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1824ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Turn VLA types into [*] types. 1825ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::VariableArray: { 1826ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const VariableArrayType *vat = cast<VariableArrayType>(ty); 1827ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getVariableArrayType( 1828ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(vat->getElementType()), 1829ce8890371fcdb983ae487c87fa40606a34896ff7John McCall /*size*/ 0, 1830ce8890371fcdb983ae487c87fa40606a34896ff7John McCall ArrayType::Star, 1831ce8890371fcdb983ae487c87fa40606a34896ff7John McCall vat->getIndexTypeCVRQualifiers(), 1832ce8890371fcdb983ae487c87fa40606a34896ff7John McCall vat->getBracketsRange()); 1833ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1834ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1835ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1836ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1837ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Apply the top-level qualifiers from the original. 1838200fa53fd420aa8369586f569dbece04930ad6a3John McCall return getQualifiedType(result, split.Quals); 1839ce8890371fcdb983ae487c87fa40606a34896ff7John McCall} 1840745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1841bdbf7b030a3e0ddb95240076683830e6f78c79a5Steve Naroff/// getVariableArrayType - Returns a non-unique reference to the type for a 1842bdbf7b030a3e0ddb95240076683830e6f78c79a5Steve Naroff/// variable array of the specified element type. 18437e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas GregorQualType ASTContext::getVariableArrayType(QualType EltTy, 18447e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor Expr *NumElts, 1845c9406125e2cac9208098655ac8058c095c2c3a65Steve Naroff ArrayType::ArraySizeModifier ASM, 184663e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara unsigned IndexTypeQuals, 18474ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad SourceRange Brackets) const { 1848c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // Since we don't unique expressions, it isn't possible to unique VLA's 1849c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // that have an expression provided for their size. 18503b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType Canon; 1851715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor 18523b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Be sure to pull qualifiers off the element type. 18533b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) { 18543b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = getCanonicalType(EltTy).split(); 1855200fa53fd420aa8369586f569dbece04930ad6a3John McCall Canon = getVariableArrayType(QualType(canonSplit.Ty, 0), NumElts, ASM, 185663e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara IndexTypeQuals, Brackets); 1857200fa53fd420aa8369586f569dbece04930ad6a3John McCall Canon = getQualifiedType(Canon, canonSplit.Quals); 1858715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor } 1859715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor 18606b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall VariableArrayType *New = new(*this, TypeAlignment) 186163e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara VariableArrayType(EltTy, Canon, NumElts, ASM, IndexTypeQuals, Brackets); 1862c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1863c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman VariableArrayTypes.push_back(New); 1864c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman Types.push_back(New); 1865c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman return QualType(New, 0); 1866c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman} 1867c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1868898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// getDependentSizedArrayType - Returns a non-unique reference to 1869898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// the type for a dependently-sized array of the specified element 187004d4beee4b86af20a9e4457023d3925cab8f9908Douglas Gregor/// type. 18713b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getDependentSizedArrayType(QualType elementType, 18723b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Expr *numElements, 1873898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor ArrayType::ArraySizeModifier ASM, 18743b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall unsigned elementTypeQuals, 18753b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SourceRange brackets) const { 18763b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert((!numElements || numElements->isTypeDependent() || 18773b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall numElements->isValueDependent()) && 1878898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor "Size must be type- or value-dependent!"); 1879898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 18803b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Dependently-sized array types that do not have a specified number 18813b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // of elements will have their sizes deduced from a dependent 18823b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // initializer. We do no canonicalization here at all, which is okay 18833b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // because they can't be used in most locations. 18843b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!numElements) { 18853b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType *newType 18863b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall = new (*this, TypeAlignment) 18873b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType(*this, elementType, QualType(), 18883b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall numElements, ASM, elementTypeQuals, 18893b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall brackets); 18903b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(newType); 18913b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(newType, 0); 1892cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor } 1893cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor 18943b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Otherwise, we actually build a new type every time, but we 18953b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // also build a canonical type. 18961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 18973b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonElementType = getCanonicalType(elementType).split(); 1898898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 18993b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall void *insertPos = 0; 19003b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall llvm::FoldingSetNodeID ID; 19013b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType::Profile(ID, *this, 1902200fa53fd420aa8369586f569dbece04930ad6a3John McCall QualType(canonElementType.Ty, 0), 19033b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ASM, elementTypeQuals, numElements); 19043b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19053b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Look for an existing type with these properties. 19063b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType *canonTy = 19073b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos); 19083b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19093b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If we don't have one, build one. 19103b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!canonTy) { 19113b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall canonTy = new (*this, TypeAlignment) 1912200fa53fd420aa8369586f569dbece04930ad6a3John McCall DependentSizedArrayType(*this, QualType(canonElementType.Ty, 0), 19133b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType(), numElements, ASM, elementTypeQuals, 19143b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall brackets); 19153b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayTypes.InsertNode(canonTy, insertPos); 19163b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(canonTy); 19173b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall } 19183b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19193b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Apply qualifiers from the element type to the array. 19203b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType canon = getQualifiedType(QualType(canonTy,0), 1921200fa53fd420aa8369586f569dbece04930ad6a3John McCall canonElementType.Quals); 19223b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19233b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If we didn't need extra canonicalization for the element type, 19243b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // then just use that as our result. 1925200fa53fd420aa8369586f569dbece04930ad6a3John McCall if (QualType(canonElementType.Ty, 0) == elementType) 19263b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return canon; 19273b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19283b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Otherwise, we need to build a type which follows the spelling 19293b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // of the element type. 19303b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType *sugaredType 19313b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall = new (*this, TypeAlignment) 19323b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType(*this, elementType, canon, numElements, 19333b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ASM, elementTypeQuals, brackets); 19343b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(sugaredType); 19353b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(sugaredType, 0); 19363b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall} 19373b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19383b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getIncompleteArrayType(QualType elementType, 1939c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman ArrayType::ArraySizeModifier ASM, 19403b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall unsigned elementTypeQuals) const { 1941c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman llvm::FoldingSetNodeID ID; 19423b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType::Profile(ID, elementType, ASM, elementTypeQuals); 1943c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19443b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall void *insertPos = 0; 19453b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (IncompleteArrayType *iat = 19463b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos)) 19473b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(iat, 0); 1948c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1949c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // If the element type isn't canonical, this won't be a canonical type 19503b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // either, so fill in the canonical type field. We also have to pull 19513b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // qualifiers off the element type. 19523b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType canon; 1953c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19543b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!elementType.isCanonical() || elementType.hasLocalQualifiers()) { 19553b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = getCanonicalType(elementType).split(); 1956200fa53fd420aa8369586f569dbece04930ad6a3John McCall canon = getIncompleteArrayType(QualType(canonSplit.Ty, 0), 19573b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ASM, elementTypeQuals); 1958200fa53fd420aa8369586f569dbece04930ad6a3John McCall canon = getQualifiedType(canon, canonSplit.Quals); 1959c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1960c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // Get the new insert position for the node we care about. 19613b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType *existing = 19623b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos); 19633b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert(!existing && "Shouldn't be in the map!"); (void) existing; 19642bd24ba6d10f8c811c8e2a57c8397e07082ba497Ted Kremenek } 1965c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19663b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType *newType = new (*this, TypeAlignment) 19673b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType(elementType, canon, ASM, elementTypeQuals); 1968c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19693b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayTypes.InsertNode(newType, insertPos); 19703b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(newType); 19713b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(newType, 0); 1972fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff} 1973fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff 197473322924127c873c13101b705dd823f5539ffa5fSteve Naroff/// getVectorType - Return the unique reference to a vector type of 197573322924127c873c13101b705dd823f5539ffa5fSteve Naroff/// the specified element type and size. VectorType must be a built-in type. 197682287d19ded35248c4ce6a425ce74116a13ce44eJohn ThompsonQualType ASTContext::getVectorType(QualType vecType, unsigned NumElts, 19774ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad VectorType::VectorKind VecKind) const { 19783b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert(vecType->isBuiltinType()); 19791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 19805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Check if we've already instantiated a vector of this type. 19815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 1982e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType::Profile(ID, vecType, NumElts, Type::Vector, VecKind); 1983788b0fd67e1992f23555454efcdb16a19dfefac3Chris Lattner 19845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 19855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 19865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(VTP, 0); 19875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 19885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the element type isn't canonical, this won't be a canonical type either, 19895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // so fill in the canonical type field. 19905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 1991255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor if (!vecType.isCanonical()) { 1992231da7eb3dd13007e5e40fffe48998e5ef284e06Bob Wilson Canonical = getVectorType(getCanonicalType(vecType), NumElts, VecKind); 19931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 19945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 19955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 1996c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 19975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 19986b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall VectorType *New = new (*this, TypeAlignment) 1999e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType(vecType, NumElts, Canonical, VecKind); 20005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer VectorTypes.InsertNode(New, InsertPos); 20015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 20025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 20035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 20045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2005213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman/// getExtVectorType - Return the unique reference to an extended vector type of 200673322924127c873c13101b705dd823f5539ffa5fSteve Naroff/// the specified element type and size. VectorType must be a built-in type. 20074ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 20084ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getExtVectorType(QualType vecType, unsigned NumElts) const { 20094ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor assert(vecType->isBuiltinType() || vecType->isDependentType()); 20101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 201173322924127c873c13101b705dd823f5539ffa5fSteve Naroff // Check if we've already instantiated a vector of this type. 201273322924127c873c13101b705dd823f5539ffa5fSteve Naroff llvm::FoldingSetNodeID ID; 2013788b0fd67e1992f23555454efcdb16a19dfefac3Chris Lattner VectorType::Profile(ID, vecType, NumElts, Type::ExtVector, 2014e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType::GenericVector); 201573322924127c873c13101b705dd823f5539ffa5fSteve Naroff void *InsertPos = 0; 201673322924127c873c13101b705dd823f5539ffa5fSteve Naroff if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 201773322924127c873c13101b705dd823f5539ffa5fSteve Naroff return QualType(VTP, 0); 201873322924127c873c13101b705dd823f5539ffa5fSteve Naroff 201973322924127c873c13101b705dd823f5539ffa5fSteve Naroff // If the element type isn't canonical, this won't be a canonical type either, 202073322924127c873c13101b705dd823f5539ffa5fSteve Naroff // so fill in the canonical type field. 202173322924127c873c13101b705dd823f5539ffa5fSteve Naroff QualType Canonical; 2022467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!vecType.isCanonical()) { 2023213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman Canonical = getExtVectorType(getCanonicalType(vecType), NumElts); 20241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 202573322924127c873c13101b705dd823f5539ffa5fSteve Naroff // Get the new insert position for the node we care about. 202673322924127c873c13101b705dd823f5539ffa5fSteve Naroff VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2027c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 202873322924127c873c13101b705dd823f5539ffa5fSteve Naroff } 20296b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ExtVectorType *New = new (*this, TypeAlignment) 20306b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ExtVectorType(vecType, NumElts, Canonical); 203173322924127c873c13101b705dd823f5539ffa5fSteve Naroff VectorTypes.InsertNode(New, InsertPos); 203273322924127c873c13101b705dd823f5539ffa5fSteve Naroff Types.push_back(New); 203373322924127c873c13101b705dd823f5539ffa5fSteve Naroff return QualType(New, 0); 203473322924127c873c13101b705dd823f5539ffa5fSteve Naroff} 203573322924127c873c13101b705dd823f5539ffa5fSteve Naroff 20364ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 20374ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getDependentSizedExtVectorType(QualType vecType, 20384ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Expr *SizeExpr, 20394ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad SourceLocation AttrLoc) const { 20402ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor llvm::FoldingSetNodeID ID; 20411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump DependentSizedExtVectorType::Profile(ID, *this, getCanonicalType(vecType), 20422ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor SizeExpr); 20431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20442ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor void *InsertPos = 0; 20452ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor DependentSizedExtVectorType *Canon 20462ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos); 20472ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor DependentSizedExtVectorType *New; 20482ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor if (Canon) { 20492ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor // We already have a canonical version of this array type; use it as 20502ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor // the canonical type for a newly-built type. 20516b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall New = new (*this, TypeAlignment) 20526b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall DependentSizedExtVectorType(*this, vecType, QualType(Canon, 0), 20536b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall SizeExpr, AttrLoc); 20542ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } else { 20552ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor QualType CanonVecTy = getCanonicalType(vecType); 20562ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor if (CanonVecTy == vecType) { 20576b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall New = new (*this, TypeAlignment) 20586b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall DependentSizedExtVectorType(*this, vecType, QualType(), SizeExpr, 20596b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall AttrLoc); 2060789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2061789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentSizedExtVectorType *CanonCheck 2062789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2063789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!CanonCheck && "Dependent-sized ext_vector canonical type broken"); 2064789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CanonCheck; 20652ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor DependentSizedExtVectorTypes.InsertNode(New, InsertPos); 20662ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } else { 20672ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr, 20682ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor SourceLocation()); 20696b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall New = new (*this, TypeAlignment) 20706b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall DependentSizedExtVectorType(*this, vecType, Canon, SizeExpr, AttrLoc); 20712ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } 20722ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } 20731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20749cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor Types.push_back(New); 20759cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor return QualType(New, 0); 20769cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor} 20779cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor 207872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'. 20795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 20804ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 20814ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getFunctionNoProtoType(QualType ResultTy, 20824ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const FunctionType::ExtInfo &Info) const { 2083cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv DefaultCC = Info.getCC(); 2084cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv CallConv = (LangOpts.MRTD && DefaultCC == CC_Default) ? 2085cfe9af250f466e7e38becea4428990448ae07737Roman Divacky CC_X86StdCall : DefaultCC; 20865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique functions, to guarantee there is only one function of a particular 20875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 20885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 2089264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionNoProtoType::Profile(ID, ResultTy, Info); 20901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 20921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (FunctionNoProtoType *FT = 209372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) 20945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(FT, 0); 20951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 2097ab8bbf4ebd3e3e6eab913cb044772a62b7581941Douglas Gregor if (!ResultTy.isCanonical() || 209804a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall getCanonicalCallConv(CallConv) != CallConv) { 2099264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola Canonical = 2100264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola getFunctionNoProtoType(getCanonicalType(ResultTy), 2101264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola Info.withCallingConv(getCanonicalCallConv(CallConv))); 21021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 21035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 210472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoType *NewIP = 210572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos); 2106c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 21075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 21081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2109cfe9af250f466e7e38becea4428990448ae07737Roman Divacky FunctionProtoType::ExtInfo newInfo = Info.withCallingConv(CallConv); 21106b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall FunctionNoProtoType *New = new (*this, TypeAlignment) 2111cfe9af250f466e7e38becea4428990448ae07737Roman Divacky FunctionNoProtoType(ResultTy, Canonical, newInfo); 21125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 211372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoTypes.InsertNode(New, InsertPos); 21145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 21155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 21165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 21175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getFunctionType - Return a normal function type with a typed argument 21185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// list. isVariadic indicates whether the argument list includes '...'. 21194ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 21204ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getFunctionType(QualType ResultTy, 21214ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const QualType *ArgArray, unsigned NumArgs, 21224ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const FunctionProtoType::ExtProtoInfo &EPI) const { 21235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique functions, to guarantee there is only one function of a particular 21245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 21255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 21268026f6d82f7fa544bc0453714fe94bca62a1196eSebastian Redl FunctionProtoType::Profile(ID, ResultTy, ArgArray, NumArgs, EPI, *this); 21275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 21285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 21291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (FunctionProtoType *FTP = 213072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) 21315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(FTP, 0); 2132465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 2133465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl // Determine whether the type being created is already canonical or not. 2134eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith bool isCanonical = 2135eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith EPI.ExceptionSpecType == EST_None && ResultTy.isCanonical() && 2136eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith !EPI.HasTrailingReturn; 21375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0; i != NumArgs && isCanonical; ++i) 213854e14c4db764c0636160d26c5bbf491637c83a76John McCall if (!ArgArray[i].isCanonicalAsParam()) 21395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer isCanonical = false; 21405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2141cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv DefaultCC = EPI.ExtInfo.getCC(); 2142cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv CallConv = (LangOpts.MRTD && DefaultCC == CC_Default) ? 2143cfe9af250f466e7e38becea4428990448ae07737Roman Divacky CC_X86StdCall : DefaultCC; 2144e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 21455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this type isn't canonical, get the canonical version of it. 2146465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl // The exception spec is not part of the canonical type. 21475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 214804a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall if (!isCanonical || getCanonicalCallConv(CallConv) != CallConv) { 21495f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 16> CanonicalArgs; 21505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer CanonicalArgs.reserve(NumArgs); 21515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0; i != NumArgs; ++i) 215254e14c4db764c0636160d26c5bbf491637c83a76John McCall CanonicalArgs.push_back(getCanonicalParamType(ArgArray[i])); 2153465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 2154e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo CanonicalEPI = EPI; 2155eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith CanonicalEPI.HasTrailingReturn = false; 21568b5b4099c61a136e9a1714c4d8a593febe942268Sebastian Redl CanonicalEPI.ExceptionSpecType = EST_None; 21578b5b4099c61a136e9a1714c4d8a593febe942268Sebastian Redl CanonicalEPI.NumExceptions = 0; 2158e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall CanonicalEPI.ExtInfo 2159e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall = CanonicalEPI.ExtInfo.withCallingConv(getCanonicalCallConv(CallConv)); 2160e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 2161f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner Canonical = getFunctionType(getCanonicalType(ResultTy), 2162beaaccd8e2a8748f77b66e2b330fb9136937e14cJay Foad CanonicalArgs.data(), NumArgs, 2163e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall CanonicalEPI); 2164465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 21655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 216672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoType *NewIP = 216772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos); 2168c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 21695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2170465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 2171f85e193739c953358c865005855253af4f68a497John McCall // FunctionProtoType objects are allocated with extra bytes after 2172f85e193739c953358c865005855253af4f68a497John McCall // them for three variable size arrays at the end: 2173f85e193739c953358c865005855253af4f68a497John McCall // - parameter types 2174f85e193739c953358c865005855253af4f68a497John McCall // - exception types 2175f85e193739c953358c865005855253af4f68a497John McCall // - consumed-arguments flags 2176f85e193739c953358c865005855253af4f68a497John McCall // Instead of the exception types, there could be a noexcept 2177f85e193739c953358c865005855253af4f68a497John McCall // expression. 2178e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall size_t Size = sizeof(FunctionProtoType) + 217960618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl NumArgs * sizeof(QualType); 218060618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl if (EPI.ExceptionSpecType == EST_Dynamic) 218160618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl Size += EPI.NumExceptions * sizeof(QualType); 218260618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl else if (EPI.ExceptionSpecType == EST_ComputedNoexcept) { 21838026f6d82f7fa544bc0453714fe94bca62a1196eSebastian Redl Size += sizeof(Expr*); 218460618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl } 2185f85e193739c953358c865005855253af4f68a497John McCall if (EPI.ConsumedArguments) 2186f85e193739c953358c865005855253af4f68a497John McCall Size += NumArgs * sizeof(bool); 2187f85e193739c953358c865005855253af4f68a497John McCall 2188e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType *FTP = (FunctionProtoType*) Allocate(Size, TypeAlignment); 2189cfe9af250f466e7e38becea4428990448ae07737Roman Divacky FunctionProtoType::ExtProtoInfo newEPI = EPI; 2190cfe9af250f466e7e38becea4428990448ae07737Roman Divacky newEPI.ExtInfo = EPI.ExtInfo.withCallingConv(CallConv); 21918026f6d82f7fa544bc0453714fe94bca62a1196eSebastian Redl new (FTP) FunctionProtoType(ResultTy, ArgArray, NumArgs, Canonical, newEPI); 21925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(FTP); 219372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoTypes.InsertNode(FTP, InsertPos); 21945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(FTP, 0); 21955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 21965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 21973cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall#ifndef NDEBUG 21983cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallstatic bool NeedsInjectedClassNameType(const RecordDecl *D) { 21993cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (!isa<CXXRecordDecl>(D)) return false; 22003cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall const CXXRecordDecl *RD = cast<CXXRecordDecl>(D); 22013cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (isa<ClassTemplatePartialSpecializationDecl>(RD)) 22023cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return true; 22033cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (RD->getDescribedClassTemplate() && 22043cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall !isa<ClassTemplateSpecializationDecl>(RD)) 22053cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return true; 22063cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return false; 22073cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall} 22083cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall#endif 22093cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 22103cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall/// getInjectedClassNameType - Return the unique reference to the 22113cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall/// injected class name type for the specified templated declaration. 22123cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallQualType ASTContext::getInjectedClassNameType(CXXRecordDecl *Decl, 22134ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType TST) const { 22143cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(NeedsInjectedClassNameType(Decl)); 22153cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (Decl->TypeForDecl) { 22163cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(isa<InjectedClassNameType>(Decl->TypeForDecl)); 2217ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor } else if (CXXRecordDecl *PrevDecl = Decl->getPreviousDecl()) { 22183cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(PrevDecl->TypeForDecl && "previous declaration has no type"); 22193cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall Decl->TypeForDecl = PrevDecl->TypeForDecl; 22203cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(isa<InjectedClassNameType>(Decl->TypeForDecl)); 22213cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } else { 2222f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Type *newType = 222331f17ecbef57b5679c017c375db330546b7b5145John McCall new (*this, TypeAlignment) InjectedClassNameType(Decl, TST); 2224f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2225f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 22263cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } 22273cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return QualType(Decl->TypeForDecl, 0); 22283cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall} 22293cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 22302ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor/// getTypeDeclType - Return the unique reference to the type for the 22312ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor/// specified type declaration. 22324ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTypeDeclTypeSlow(const TypeDecl *Decl) const { 22331e6759e9e33dcaa73ce14c8a908ac9f87ac16463Argyrios Kyrtzidis assert(Decl && "Passed null for Decl param"); 2234becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall assert(!Decl->TypeForDecl && "TypeForDecl present in slow case"); 22351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2236162e1c1b487352434552147967c3dd296ebee2f7Richard Smith if (const TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Decl)) 22372ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor return getTypedefType(Typedef); 2238becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall 2239becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall assert(!isa<TemplateTypeParmDecl>(Decl) && 2240becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall "Template type parameter types are always available."); 2241becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall 224219c8576b7328f4dc2d07682f5da552875c1912efJohn McCall if (const RecordDecl *Record = dyn_cast<RecordDecl>(Decl)) { 2243ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor assert(!Record->getPreviousDecl() && 2244becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall "struct/union has previous declaration"); 2245becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall assert(!NeedsInjectedClassNameType(Record)); 2246400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return getRecordType(Record); 224719c8576b7328f4dc2d07682f5da552875c1912efJohn McCall } else if (const EnumDecl *Enum = dyn_cast<EnumDecl>(Decl)) { 2248ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor assert(!Enum->getPreviousDecl() && 2249becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall "enum has previous declaration"); 2250400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return getEnumType(Enum); 225119c8576b7328f4dc2d07682f5da552875c1912efJohn McCall } else if (const UnresolvedUsingTypenameDecl *Using = 2252ed97649e9574b9d854fa4d6109c9333ae0993554John McCall dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) { 2253f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Type *newType = new (*this, TypeAlignment) UnresolvedUsingType(Using); 2254f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2255f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 22569fdbab3cbc2fc04bcaf5768023d83707f3151144Mike Stump } else 2257becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall llvm_unreachable("TypeDecl without a type?"); 225849aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidis 225949aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidis return QualType(Decl->TypeForDecl, 0); 22602ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor} 22612ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor 22625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getTypedefType - Return the unique reference to the type for the 2263162e1c1b487352434552147967c3dd296ebee2f7Richard Smith/// specified typedef name decl. 22649763e221e16026ddf487d2564ed349d2c874a1a1Argyrios KyrtzidisQualType 2265162e1c1b487352434552147967c3dd296ebee2f7Richard SmithASTContext::getTypedefType(const TypedefNameDecl *Decl, 2266162e1c1b487352434552147967c3dd296ebee2f7Richard Smith QualType Canonical) const { 22675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 22681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 22699763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis if (Canonical.isNull()) 22709763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis Canonical = getCanonicalType(Decl->getUnderlyingType()); 2271f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall TypedefType *newType = new(*this, TypeAlignment) 22726b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypedefType(Type::Typedef, Decl, Canonical); 2273f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2274f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 2275f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall return QualType(newType, 0); 22765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 22775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 22784ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getRecordType(const RecordDecl *Decl) const { 2279400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 2280400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2281ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor if (const RecordDecl *PrevDecl = Decl->getPreviousDecl()) 2282400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (PrevDecl->TypeForDecl) 2283400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0); 2284400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2285f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall RecordType *newType = new (*this, TypeAlignment) RecordType(Decl); 2286f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2287f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 2288f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall return QualType(newType, 0); 2289400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis} 2290400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 22914ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getEnumType(const EnumDecl *Decl) const { 2292400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 2293400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2294ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor if (const EnumDecl *PrevDecl = Decl->getPreviousDecl()) 2295400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (PrevDecl->TypeForDecl) 2296400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0); 2297400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2298f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall EnumType *newType = new (*this, TypeAlignment) EnumType(Decl); 2299f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2300f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 2301f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall return QualType(newType, 0); 2302400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis} 2303400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 23049d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCallQualType ASTContext::getAttributedType(AttributedType::Kind attrKind, 23059d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall QualType modifiedType, 23069d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall QualType equivalentType) { 23079d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall llvm::FoldingSetNodeID id; 23089d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedType::Profile(id, attrKind, modifiedType, equivalentType); 23099d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23109d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall void *insertPos = 0; 23119d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedType *type = AttributedTypes.FindNodeOrInsertPos(id, insertPos); 23129d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall if (type) return QualType(type, 0); 23139d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23149d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall QualType canon = getCanonicalType(equivalentType); 23159d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall type = new (*this, TypeAlignment) 23169d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedType(canon, attrKind, modifiedType, equivalentType); 23179d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23189d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall Types.push_back(type); 23199d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedTypes.InsertNode(type, insertPos); 23209d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23219d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall return QualType(type, 0); 23229d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall} 23239d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23249d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 232549a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall/// \brief Retrieve a substitution-result type. 232649a832bd499d6f61c23655f1fac99f0dd229756eJohn McCallQualType 232749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCallASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm, 23284ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType Replacement) const { 2329467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(Replacement.isCanonical() 233049a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall && "replacement types must always be canonical"); 233149a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 233249a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall llvm::FoldingSetNodeID ID; 233349a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmType::Profile(ID, Parm, Replacement); 233449a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall void *InsertPos = 0; 233549a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmType *SubstParm 233649a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 233749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 233849a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall if (!SubstParm) { 233949a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstParm = new (*this, TypeAlignment) 234049a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmType(Parm, Replacement); 234149a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall Types.push_back(SubstParm); 234249a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos); 234349a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall } 234449a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 234549a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall return QualType(SubstParm, 0); 234649a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall} 234749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 2348c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor/// \brief Retrieve a 2349c3069d618f4661d923cb1b5c4525b082fce73b04Douglas GregorQualType ASTContext::getSubstTemplateTypeParmPackType( 2350c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor const TemplateTypeParmType *Parm, 2351c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor const TemplateArgument &ArgPack) { 2352c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor#ifndef NDEBUG 2353c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor for (TemplateArgument::pack_iterator P = ArgPack.pack_begin(), 2354c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor PEnd = ArgPack.pack_end(); 2355c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor P != PEnd; ++P) { 2356c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor assert(P->getKind() == TemplateArgument::Type &&"Pack contains a non-type"); 2357c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor assert(P->getAsType().isCanonical() && "Pack contains non-canonical type"); 2358c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor } 2359c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor#endif 2360c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2361c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor llvm::FoldingSetNodeID ID; 2362c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmPackType::Profile(ID, Parm, ArgPack); 2363c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor void *InsertPos = 0; 2364c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor if (SubstTemplateTypeParmPackType *SubstParm 2365c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor = SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos)) 2366c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor return QualType(SubstParm, 0); 2367c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2368c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor QualType Canon; 2369c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor if (!Parm->isCanonicalUnqualified()) { 2370c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor Canon = getCanonicalType(QualType(Parm, 0)); 2371c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor Canon = getSubstTemplateTypeParmPackType(cast<TemplateTypeParmType>(Canon), 2372c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor ArgPack); 2373c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos); 2374c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor } 2375c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2376c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmPackType *SubstParm 2377c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor = new (*this, TypeAlignment) SubstTemplateTypeParmPackType(Parm, Canon, 2378c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor ArgPack); 2379c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor Types.push_back(SubstParm); 2380c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos); 2381c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor return QualType(SubstParm, 0); 2382c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor} 2383c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2384fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor/// \brief Retrieve the template type parameter type for a template 23851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// parameter or parameter pack with the given depth, index, and (optionally) 238676e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson/// name. 23871eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index, 238876e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson bool ParameterPack, 23894fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TemplateTypeParmDecl *TTPDecl) const { 2390fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor llvm::FoldingSetNodeID ID; 23914fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, TTPDecl); 2392fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor void *InsertPos = 0; 23931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateTypeParmType *TypeParm 2394fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 2395fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 2396fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor if (TypeParm) 2397fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor return QualType(TypeParm, 0); 23981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 23994fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth if (TTPDecl) { 240076e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack); 24014fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TypeParm = new (*this, TypeAlignment) TemplateTypeParmType(TTPDecl, Canon); 2402789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2403789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor TemplateTypeParmType *TypeCheck 2404789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 2405789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!TypeCheck && "Template type parameter canonical type broken"); 2406789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)TypeCheck; 240776e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson } else 24086b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypeParm = new (*this, TypeAlignment) 24096b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TemplateTypeParmType(Depth, Index, ParameterPack); 2410fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 2411fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor Types.push_back(TypeParm); 2412fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos); 2413fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 2414fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor return QualType(TypeParm, 0); 2415fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor} 2416fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 24173cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallTypeSourceInfo * 24183cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallASTContext::getTemplateSpecializationTypeInfo(TemplateName Name, 24193cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall SourceLocation NameLoc, 24203cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall const TemplateArgumentListInfo &Args, 24213e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType Underlying) const { 24227c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Name.getAsDependentTemplateName() && 24237c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 24243e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType TST = getTemplateSpecializationType(Name, Args, Underlying); 24253cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 24263cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TypeSourceInfo *DI = CreateTypeSourceInfo(TST); 24273cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TemplateSpecializationTypeLoc TL 24283cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall = cast<TemplateSpecializationTypeLoc>(DI->getTypeLoc()); 242955d23c925b058be29b792008ddb7d68f6c4fa9a0Abramo Bagnara TL.setTemplateKeywordLoc(SourceLocation()); 24303cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setTemplateNameLoc(NameLoc); 24313cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setLAngleLoc(Args.getLAngleLoc()); 24323cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setRAngleLoc(Args.getRAngleLoc()); 24333cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 24343cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setArgLocInfo(i, Args[i].getLocInfo()); 24353cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return DI; 24363cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall} 24373cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 24381eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType 24397532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas GregorASTContext::getTemplateSpecializationType(TemplateName Template, 2440d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall const TemplateArgumentListInfo &Args, 24413e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType Underlying) const { 24427c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Template.getAsDependentTemplateName() && 24437c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 24447c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor 2445d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall unsigned NumArgs = Args.size(); 2446d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall 24475f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> ArgVec; 2448833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall ArgVec.reserve(NumArgs); 2449833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall for (unsigned i = 0; i != NumArgs; ++i) 2450833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall ArgVec.push_back(Args[i].getArgument()); 2451833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 245231f17ecbef57b5679c017c375db330546b7b5145John McCall return getTemplateSpecializationType(Template, ArgVec.data(), NumArgs, 24533e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith Underlying); 2454833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall} 2455833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 2456b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor#ifndef NDEBUG 2457b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregorstatic bool hasAnyPackExpansions(const TemplateArgument *Args, 2458b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor unsigned NumArgs) { 2459b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor for (unsigned I = 0; I != NumArgs; ++I) 2460b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor if (Args[I].isPackExpansion()) 2461b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor return true; 2462b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor 2463b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor return true; 2464b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor} 2465b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor#endif 2466b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor 2467833ca991c1bfc967f0995974ca86f66ba1f666b5John McCallQualType 2468833ca991c1bfc967f0995974ca86f66ba1f666b5John McCallASTContext::getTemplateSpecializationType(TemplateName Template, 24697532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor const TemplateArgument *Args, 24707532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor unsigned NumArgs, 24713e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType Underlying) const { 24727c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Template.getAsDependentTemplateName() && 24737c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 24740f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor // Look through qualified template names. 24750f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 24760f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor Template = TemplateName(QTN->getTemplateDecl()); 24777c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor 2478b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor bool IsTypeAlias = 24793e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith Template.getAsTemplateDecl() && 24803e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith isa<TypeAliasTemplateDecl>(Template.getAsTemplateDecl()); 24813e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType CanonType; 24823e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith if (!Underlying.isNull()) 24833e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith CanonType = getCanonicalType(Underlying); 24843e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith else { 2485b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor // We can get here with an alias template when the specialization contains 2486b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor // a pack expansion that does not match up with a parameter pack. 2487b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor assert((!IsTypeAlias || hasAnyPackExpansions(Args, NumArgs)) && 2488b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor "Caller must compute aliased type"); 2489b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor IsTypeAlias = false; 24903e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith CanonType = getCanonicalTemplateSpecializationType(Template, Args, 24913e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith NumArgs); 24923e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith } 2493fc705b84347e6fb4746a1a7e26949f64c2f2f358Douglas Gregor 24941275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // Allocate the (non-canonical) template specialization type, but don't 24951275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // try to unique it: these types typically have location information that 24961275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // we don't unique and don't want to lose. 24973e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith void *Mem = Allocate(sizeof(TemplateSpecializationType) + 24983e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith sizeof(TemplateArgument) * NumArgs + 2499b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor (IsTypeAlias? sizeof(QualType) : 0), 25006b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypeAlignment); 25011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateSpecializationType *Spec 2502b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor = new (Mem) TemplateSpecializationType(Template, Args, NumArgs, CanonType, 2503b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor IsTypeAlias ? Underlying : QualType()); 25041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 250555f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor Types.push_back(Spec); 25061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return QualType(Spec, 0); 250755f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor} 250855f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 25091eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType 25109763e221e16026ddf487d2564ed349d2c874a1a1Argyrios KyrtzidisASTContext::getCanonicalTemplateSpecializationType(TemplateName Template, 25119763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis const TemplateArgument *Args, 25124ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned NumArgs) const { 25137c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Template.getAsDependentTemplateName() && 25147c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 25153e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith 25160f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor // Look through qualified template names. 25170f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 25180f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor Template = TemplateName(QTN->getTemplateDecl()); 25197c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor 25209763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Build the canonical template specialization type. 25219763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateName CanonTemplate = getCanonicalTemplateName(Template); 25225f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> CanonArgs; 25239763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.reserve(NumArgs); 25249763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis for (unsigned I = 0; I != NumArgs; ++I) 25259763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.push_back(getCanonicalTemplateArgument(Args[I])); 25269763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25279763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Determine whether this canonical template specialization type already 25289763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // exists. 25299763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis llvm::FoldingSetNodeID ID; 25309763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateSpecializationType::Profile(ID, CanonTemplate, 25319763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.data(), NumArgs, *this); 25329763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25339763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis void *InsertPos = 0; 25349763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateSpecializationType *Spec 25359763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 25369763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25379763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis if (!Spec) { 25389763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Allocate a new canonical template specialization type. 25399763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis void *Mem = Allocate((sizeof(TemplateSpecializationType) + 25409763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis sizeof(TemplateArgument) * NumArgs), 25419763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TypeAlignment); 25429763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis Spec = new (Mem) TemplateSpecializationType(CanonTemplate, 25439763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.data(), NumArgs, 25443e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType(), QualType()); 25459763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis Types.push_back(Spec); 25469763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateSpecializationTypes.InsertNode(Spec, InsertPos); 25479763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis } 25489763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25499763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis assert(Spec->isDependentType() && 25509763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis "Non-dependent template-id type must have a canonical type"); 25519763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis return QualType(Spec, 0); 25529763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis} 25539763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25549763e221e16026ddf487d2564ed349d2c874a1a1Argyrios KyrtzidisQualType 2555465d41b92b2c862f3062c412a0538db65c6a2661Abramo BagnaraASTContext::getElaboratedType(ElaboratedTypeKeyword Keyword, 2556465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara NestedNameSpecifier *NNS, 25574ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType NamedType) const { 2558e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor llvm::FoldingSetNodeID ID; 2559465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedType::Profile(ID, Keyword, NNS, NamedType); 2560e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor 2561e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor void *InsertPos = 0; 2562465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedType *T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos); 2563e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor if (T) 2564e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor return QualType(T, 0); 2565e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor 2566789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor QualType Canon = NamedType; 2567789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor if (!Canon.isCanonical()) { 2568789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor Canon = getCanonicalType(NamedType); 2569465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedType *CheckT = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos); 2570465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara assert(!CheckT && "Elaborated canonical type broken"); 2571789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CheckT; 2572789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor } 2573789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2574465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara T = new (*this) ElaboratedType(Keyword, NNS, NamedType, Canon); 2575e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor Types.push_back(T); 2576465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedTypes.InsertNode(T, InsertPos); 2577e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor return QualType(T, 0); 2578e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor} 2579e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor 2580075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo BagnaraQualType 25814ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getParenType(QualType InnerType) const { 2582075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara llvm::FoldingSetNodeID ID; 2583075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenType::Profile(ID, InnerType); 2584075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 2585075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara void *InsertPos = 0; 2586075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenType *T = ParenTypes.FindNodeOrInsertPos(ID, InsertPos); 2587075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara if (T) 2588075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return QualType(T, 0); 2589075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 2590075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara QualType Canon = InnerType; 2591075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara if (!Canon.isCanonical()) { 2592075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara Canon = getCanonicalType(InnerType); 2593075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos); 2594075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara assert(!CheckT && "Paren canonical type broken"); 2595075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara (void)CheckT; 2596075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara } 2597075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 2598075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara T = new (*this) ParenType(InnerType, Canon); 2599075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara Types.push_back(T); 2600075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenTypes.InsertNode(T, InsertPos); 2601075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return QualType(T, 0); 2602075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara} 2603075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 26044a2023f5014e82389d5980d307b89c545dbbac81Douglas GregorQualType ASTContext::getDependentNameType(ElaboratedTypeKeyword Keyword, 26054a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor NestedNameSpecifier *NNS, 26064a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor const IdentifierInfo *Name, 26074ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType Canon) const { 2608d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor assert(NNS->isDependent() && "nested-name-specifier must be dependent"); 2609d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2610d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor if (Canon.isNull()) { 2611d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 26124a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor ElaboratedTypeKeyword CanonKeyword = Keyword; 26134a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor if (Keyword == ETK_None) 26144a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor CanonKeyword = ETK_Typename; 26154a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor 26164a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor if (CanonNNS != NNS || CanonKeyword != Keyword) 26174a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor Canon = getDependentNameType(CanonKeyword, CanonNNS, Name); 2618d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor } 2619d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2620d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor llvm::FoldingSetNodeID ID; 26214a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor DependentNameType::Profile(ID, Keyword, NNS, Name); 2622d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2623d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor void *InsertPos = 0; 26244714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor DependentNameType *T 26254714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos); 2626d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor if (T) 2627d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor return QualType(T, 0); 2628d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 26294a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor T = new (*this) DependentNameType(Keyword, NNS, Name, Canon); 2630d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor Types.push_back(T); 26314714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor DependentNameTypes.InsertNode(T, InsertPos); 26321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return QualType(T, 0); 2633d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor} 2634d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 26351eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType 263633500955d731c73717af52088b7fc0e7a85681e7John McCallASTContext::getDependentTemplateSpecializationType( 263733500955d731c73717af52088b7fc0e7a85681e7John McCall ElaboratedTypeKeyword Keyword, 26384a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor NestedNameSpecifier *NNS, 263933500955d731c73717af52088b7fc0e7a85681e7John McCall const IdentifierInfo *Name, 26404ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const TemplateArgumentListInfo &Args) const { 264133500955d731c73717af52088b7fc0e7a85681e7John McCall // TODO: avoid this copy 26425f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 16> ArgCopy; 264333500955d731c73717af52088b7fc0e7a85681e7John McCall for (unsigned I = 0, E = Args.size(); I != E; ++I) 264433500955d731c73717af52088b7fc0e7a85681e7John McCall ArgCopy.push_back(Args[I].getArgument()); 264533500955d731c73717af52088b7fc0e7a85681e7John McCall return getDependentTemplateSpecializationType(Keyword, NNS, Name, 264633500955d731c73717af52088b7fc0e7a85681e7John McCall ArgCopy.size(), 264733500955d731c73717af52088b7fc0e7a85681e7John McCall ArgCopy.data()); 264833500955d731c73717af52088b7fc0e7a85681e7John McCall} 264933500955d731c73717af52088b7fc0e7a85681e7John McCall 265033500955d731c73717af52088b7fc0e7a85681e7John McCallQualType 265133500955d731c73717af52088b7fc0e7a85681e7John McCallASTContext::getDependentTemplateSpecializationType( 265233500955d731c73717af52088b7fc0e7a85681e7John McCall ElaboratedTypeKeyword Keyword, 265333500955d731c73717af52088b7fc0e7a85681e7John McCall NestedNameSpecifier *NNS, 265433500955d731c73717af52088b7fc0e7a85681e7John McCall const IdentifierInfo *Name, 265533500955d731c73717af52088b7fc0e7a85681e7John McCall unsigned NumArgs, 26564ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const TemplateArgument *Args) const { 2657aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor assert((!NNS || NNS->isDependent()) && 2658aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor "nested-name-specifier must be dependent"); 26591734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 2660789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor llvm::FoldingSetNodeID ID; 266133500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS, 266233500955d731c73717af52088b7fc0e7a85681e7John McCall Name, NumArgs, Args); 2663789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2664789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor void *InsertPos = 0; 266533500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationType *T 266633500955d731c73717af52088b7fc0e7a85681e7John McCall = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 2667789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor if (T) 2668789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor return QualType(T, 0); 2669789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 267033500955d731c73717af52088b7fc0e7a85681e7John McCall NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 267133500955d731c73717af52088b7fc0e7a85681e7John McCall 267233500955d731c73717af52088b7fc0e7a85681e7John McCall ElaboratedTypeKeyword CanonKeyword = Keyword; 267333500955d731c73717af52088b7fc0e7a85681e7John McCall if (Keyword == ETK_None) CanonKeyword = ETK_Typename; 26741734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 267533500955d731c73717af52088b7fc0e7a85681e7John McCall bool AnyNonCanonArgs = false; 26765f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 16> CanonArgs(NumArgs); 267733500955d731c73717af52088b7fc0e7a85681e7John McCall for (unsigned I = 0; I != NumArgs; ++I) { 267833500955d731c73717af52088b7fc0e7a85681e7John McCall CanonArgs[I] = getCanonicalTemplateArgument(Args[I]); 267933500955d731c73717af52088b7fc0e7a85681e7John McCall if (!CanonArgs[I].structurallyEquals(Args[I])) 268033500955d731c73717af52088b7fc0e7a85681e7John McCall AnyNonCanonArgs = true; 2681789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor } 26821734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 268333500955d731c73717af52088b7fc0e7a85681e7John McCall QualType Canon; 268433500955d731c73717af52088b7fc0e7a85681e7John McCall if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) { 268533500955d731c73717af52088b7fc0e7a85681e7John McCall Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS, 268633500955d731c73717af52088b7fc0e7a85681e7John McCall Name, NumArgs, 268733500955d731c73717af52088b7fc0e7a85681e7John McCall CanonArgs.data()); 268833500955d731c73717af52088b7fc0e7a85681e7John McCall 268933500955d731c73717af52088b7fc0e7a85681e7John McCall // Find the insert position again. 269033500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 269133500955d731c73717af52088b7fc0e7a85681e7John McCall } 269233500955d731c73717af52088b7fc0e7a85681e7John McCall 269333500955d731c73717af52088b7fc0e7a85681e7John McCall void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) + 269433500955d731c73717af52088b7fc0e7a85681e7John McCall sizeof(TemplateArgument) * NumArgs), 269533500955d731c73717af52088b7fc0e7a85681e7John McCall TypeAlignment); 2696ef99001908e799c388f1363b1e607dad5f5b57d3John McCall T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS, 269733500955d731c73717af52088b7fc0e7a85681e7John McCall Name, NumArgs, Args, Canon); 26981734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor Types.push_back(T); 269933500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationTypes.InsertNode(T, InsertPos); 27001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return QualType(T, 0); 27011734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor} 27021734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 2703cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas GregorQualType ASTContext::getPackExpansionType(QualType Pattern, 2704cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor llvm::Optional<unsigned> NumExpansions) { 27057536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor llvm::FoldingSetNodeID ID; 2706cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor PackExpansionType::Profile(ID, Pattern, NumExpansions); 27077536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 27087536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor assert(Pattern->containsUnexpandedParameterPack() && 27097536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor "Pack expansions must expand one or more parameter packs"); 27107536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor void *InsertPos = 0; 27117536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor PackExpansionType *T 27127536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor = PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos); 27137536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor if (T) 27147536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor return QualType(T, 0); 27157536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 27167536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor QualType Canon; 27177536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor if (!Pattern.isCanonical()) { 2718cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor Canon = getPackExpansionType(getCanonicalType(Pattern), NumExpansions); 27197536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 27207536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor // Find the insert position again. 27217536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos); 27227536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor } 27237536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 2724cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor T = new (*this) PackExpansionType(Pattern, Canon, NumExpansions); 27257536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor Types.push_back(T); 27267536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor PackExpansionTypes.InsertNode(T, InsertPos); 27277536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor return QualType(T, 0); 27287536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor} 27297536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 273088cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner/// CmpProtocolNames - Comparison predicate for sorting protocols 273188cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner/// alphabetically. 273288cb27a160adc305783a44f922ee4b216006ebf9Chris Lattnerstatic bool CmpProtocolNames(const ObjCProtocolDecl *LHS, 273388cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner const ObjCProtocolDecl *RHS) { 27342e1cd4264d363ca869bf37ef160902f211d21b8cDouglas Gregor return LHS->getDeclName() < RHS->getDeclName(); 273588cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner} 273688cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 2737c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCallstatic bool areSortedAndUniqued(ObjCProtocolDecl * const *Protocols, 273854e14c4db764c0636160d26c5bbf491637c83a76John McCall unsigned NumProtocols) { 273954e14c4db764c0636160d26c5bbf491637c83a76John McCall if (NumProtocols == 0) return true; 274054e14c4db764c0636160d26c5bbf491637c83a76John McCall 274161cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor if (Protocols[0]->getCanonicalDecl() != Protocols[0]) 274261cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor return false; 274361cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor 274454e14c4db764c0636160d26c5bbf491637c83a76John McCall for (unsigned i = 1; i != NumProtocols; ++i) 274561cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor if (!CmpProtocolNames(Protocols[i-1], Protocols[i]) || 274661cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor Protocols[i]->getCanonicalDecl() != Protocols[i]) 274754e14c4db764c0636160d26c5bbf491637c83a76John McCall return false; 274854e14c4db764c0636160d26c5bbf491637c83a76John McCall return true; 274954e14c4db764c0636160d26c5bbf491637c83a76John McCall} 275054e14c4db764c0636160d26c5bbf491637c83a76John McCall 275154e14c4db764c0636160d26c5bbf491637c83a76John McCallstatic void SortAndUniqueProtocols(ObjCProtocolDecl **Protocols, 275288cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner unsigned &NumProtocols) { 275388cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner ObjCProtocolDecl **ProtocolsEnd = Protocols+NumProtocols; 27541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 275588cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner // Sort protocols, keyed by name. 275688cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner std::sort(Protocols, Protocols+NumProtocols, CmpProtocolNames); 275788cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 275861cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor // Canonicalize. 275961cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor for (unsigned I = 0, N = NumProtocols; I != N; ++I) 276061cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor Protocols[I] = Protocols[I]->getCanonicalDecl(); 276161cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor 276288cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner // Remove duplicates. 276388cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner ProtocolsEnd = std::unique(Protocols, ProtocolsEnd); 276488cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner NumProtocols = ProtocolsEnd-Protocols; 276588cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner} 276688cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 2767c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCallQualType ASTContext::getObjCObjectType(QualType BaseType, 2768c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCProtocolDecl * const *Protocols, 27694ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned NumProtocols) const { 2770c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // If the base type is an interface and there aren't any protocols 2771c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // to add, then the interface type will do just fine. 2772c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!NumProtocols && isa<ObjCInterfaceType>(BaseType)) 2773c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return BaseType; 2774d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff 2775c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Look in the folding set for an existing type. 2776c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall llvm::FoldingSetNodeID ID; 2777c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypeImpl::Profile(ID, BaseType, Protocols, NumProtocols); 2778d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff void *InsertPos = 0; 2779c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos)) 2780c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return QualType(QT, 0); 2781d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff 2782c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Build the canonical type, which has the canonical base type and 2783c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // a sorted-and-uniqued list of protocols. 278454e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType Canonical; 2785c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall bool ProtocolsSorted = areSortedAndUniqued(Protocols, NumProtocols); 2786c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!ProtocolsSorted || !BaseType.isCanonical()) { 2787c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!ProtocolsSorted) { 27885f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<ObjCProtocolDecl*, 8> Sorted(Protocols, 27890237941e0beb0c929934b66ad29443b484d987feBenjamin Kramer Protocols + NumProtocols); 279054e14c4db764c0636160d26c5bbf491637c83a76John McCall unsigned UniqueCount = NumProtocols; 279154e14c4db764c0636160d26c5bbf491637c83a76John McCall 279254e14c4db764c0636160d26c5bbf491637c83a76John McCall SortAndUniqueProtocols(&Sorted[0], UniqueCount); 2793c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Canonical = getObjCObjectType(getCanonicalType(BaseType), 2794c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall &Sorted[0], UniqueCount); 279554e14c4db764c0636160d26c5bbf491637c83a76John McCall } else { 2796c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Canonical = getObjCObjectType(getCanonicalType(BaseType), 2797c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Protocols, NumProtocols); 279854e14c4db764c0636160d26c5bbf491637c83a76John McCall } 279954e14c4db764c0636160d26c5bbf491637c83a76John McCall 280054e14c4db764c0636160d26c5bbf491637c83a76John McCall // Regenerate InsertPos. 2801c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos); 280254e14c4db764c0636160d26c5bbf491637c83a76John McCall } 280354e14c4db764c0636160d26c5bbf491637c83a76John McCall 2804c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall unsigned Size = sizeof(ObjCObjectTypeImpl); 2805c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Size += NumProtocols * sizeof(ObjCProtocolDecl *); 2806fd6a0887a099256c35a5b23e9afd517ffe95fa0aDouglas Gregor void *Mem = Allocate(Size, TypeAlignment); 2807c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypeImpl *T = 2808c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall new (Mem) ObjCObjectTypeImpl(Canonical, BaseType, Protocols, NumProtocols); 28091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2810c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Types.push_back(T); 2811c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypes.InsertNode(T, InsertPos); 2812c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return QualType(T, 0); 2813d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff} 281488cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 2815c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall/// getObjCObjectPointerType - Return a ObjCObjectPointerType type for 2816c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall/// the given object type. 28174ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getObjCObjectPointerType(QualType ObjectT) const { 28184b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian llvm::FoldingSetNodeID ID; 2819c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerType::Profile(ID, ObjectT); 28201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 28214b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian void *InsertPos = 0; 2822c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (ObjCObjectPointerType *QT = 2823c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 28244b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian return QualType(QT, 0); 28251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2826c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Find the canonical object type. 282754e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType Canonical; 2828c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!ObjectT.isCanonical()) { 2829c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Canonical = getObjCObjectPointerType(getCanonicalType(ObjectT)); 283054e14c4db764c0636160d26c5bbf491637c83a76John McCall 2831c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Regenerate InsertPos. 2832c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 283354e14c4db764c0636160d26c5bbf491637c83a76John McCall } 283454e14c4db764c0636160d26c5bbf491637c83a76John McCall 2835c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // No match. 2836c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall void *Mem = Allocate(sizeof(ObjCObjectPointerType), TypeAlignment); 2837c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerType *QType = 2838c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall new (Mem) ObjCObjectPointerType(Canonical, ObjectT); 283924fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis 284024fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis Types.push_back(QType); 2841c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerTypes.InsertNode(QType, InsertPos); 284224fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis return QualType(QType, 0); 284324fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis} 284424fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis 2845deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor/// getObjCInterfaceType - Return the unique reference to the type for the 2846deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor/// specified ObjC interface decl. The list of protocols is optional. 28470af550115df1f57f17a4f125ff0e8b34820c65d1Douglas GregorQualType ASTContext::getObjCInterfaceType(const ObjCInterfaceDecl *Decl, 28480af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor ObjCInterfaceDecl *PrevDecl) const { 2849deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor if (Decl->TypeForDecl) 2850deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor return QualType(Decl->TypeForDecl, 0); 285174c730ad1f6818b676b0bad46d806a9176950328Sebastian Redl 28520af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor if (PrevDecl) { 28530af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor assert(PrevDecl->TypeForDecl && "previous decl has no TypeForDecl"); 28540af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor Decl->TypeForDecl = PrevDecl->TypeForDecl; 28550af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor return QualType(PrevDecl->TypeForDecl, 0); 28560af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor } 28570af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor 28588d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor // Prefer the definition, if there is one. 28598d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor if (const ObjCInterfaceDecl *Def = Decl->getDefinition()) 28608d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor Decl = Def; 28618d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor 2862deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor void *Mem = Allocate(sizeof(ObjCInterfaceType), TypeAlignment); 2863deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor ObjCInterfaceType *T = new (Mem) ObjCInterfaceType(Decl); 2864deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor Decl->TypeForDecl = T; 2865deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor Types.push_back(T); 2866deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor return QualType(T, 0); 2867c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall} 2868c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 286972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor/// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique 287072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor/// TypeOfExprType AST's (since expression's are never shared). For example, 28719752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// multiple declarations that refer to "typeof(x)" all contain different 28721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// DeclRefExpr's. This doesn't effect the type checker, since it operates 28739752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// on canonical type's (which are always unique). 28744ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTypeOfExprType(Expr *tofExpr) const { 2875dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor TypeOfExprType *toe; 2876b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor if (tofExpr->isTypeDependent()) { 2877b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor llvm::FoldingSetNodeID ID; 2878b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor DependentTypeOfExprType::Profile(ID, *this, tofExpr); 28791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2880b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor void *InsertPos = 0; 2881b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor DependentTypeOfExprType *Canon 2882b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos); 2883b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor if (Canon) { 2884b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor // We already have a "canonical" version of an identical, dependent 2885b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor // typeof(expr) type. Use that as our canonical type. 28866b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, 2887b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor QualType((TypeOfExprType*)Canon, 0)); 28883060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 2889b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor // Build a new, canonical typeof(expr) type. 28906b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall Canon 28916b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr); 2892b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor DependentTypeOfExprTypes.InsertNode(Canon, InsertPos); 2893b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor toe = Canon; 2894b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor } 2895b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor } else { 2896dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor QualType Canonical = getCanonicalType(tofExpr->getType()); 28976b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical); 2898dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor } 28999752f25748d954df99087d741ea35db37ff16beaSteve Naroff Types.push_back(toe); 29009752f25748d954df99087d741ea35db37ff16beaSteve Naroff return QualType(toe, 0); 2901d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff} 2902d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff 29039752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// getTypeOfType - Unlike many "get<Type>" functions, we don't unique 29049752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// TypeOfType AST's. The only motivation to unique these nodes would be 29059752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be 29061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// an issue. This doesn't effect the type checker, since it operates 29079752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// on canonical type's (which are always unique). 29084ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTypeOfType(QualType tofType) const { 2909f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner QualType Canonical = getCanonicalType(tofType); 29106b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypeOfType *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical); 29119752f25748d954df99087d741ea35db37ff16beaSteve Naroff Types.push_back(tot); 29129752f25748d954df99087d741ea35db37ff16beaSteve Naroff return QualType(tot, 0); 2913d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff} 2914d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff 291560a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson 2916395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson/// getDecltypeType - Unlike many "get<Type>" functions, we don't unique 2917395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson/// DecltypeType AST's. The only motivation to unique these nodes would be 2918395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson/// memory savings. Since decltype(t) is fairly uncommon, space shouldn't be 29191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// an issue. This doesn't effect the type checker, since it operates 292039e02032b01874a0d02ba85a4cd3922adda81376David Blaikie/// on canonical types (which are always unique). 2921f8af98286022f72157d84951b48fde5fb369ab29Douglas GregorQualType ASTContext::getDecltypeType(Expr *e, QualType UnderlyingType) const { 2922dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor DecltypeType *dt; 2923561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor 2924561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // C++0x [temp.type]p2: 2925561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // If an expression e involves a template parameter, decltype(e) denotes a 2926561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // unique dependent type. Two such decltype-specifiers refer to the same 2927561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // type only if their expressions are equivalent (14.5.6.1). 2928561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor if (e->isInstantiationDependent()) { 29299d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor llvm::FoldingSetNodeID ID; 29309d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor DependentDecltypeType::Profile(ID, *this, e); 29311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 29329d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor void *InsertPos = 0; 29339d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor DependentDecltypeType *Canon 29349d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos); 29359d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor if (Canon) { 29369d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor // We already have a "canonical" version of an equivalent, dependent 29379d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor // decltype type. Use that as our canonical type. 29386b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall dt = new (*this, TypeAlignment) DecltypeType(e, DependentTy, 29399d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor QualType((DecltypeType*)Canon, 0)); 29403060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 29419d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor // Build a new, canonical typeof(expr) type. 29426b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall Canon = new (*this, TypeAlignment) DependentDecltypeType(*this, e); 29439d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor DependentDecltypeTypes.InsertNode(Canon, InsertPos); 29449d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor dt = Canon; 29459d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor } 29469d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor } else { 2947f8af98286022f72157d84951b48fde5fb369ab29Douglas Gregor dt = new (*this, TypeAlignment) DecltypeType(e, UnderlyingType, 2948f8af98286022f72157d84951b48fde5fb369ab29Douglas Gregor getCanonicalType(UnderlyingType)); 2949dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor } 2950395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson Types.push_back(dt); 2951395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson return QualType(dt, 0); 2952395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson} 2953395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson 2954ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt/// getUnaryTransformationType - We don't unique these, since the memory 2955ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt/// savings are minimal and these are rare. 2956ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean HuntQualType ASTContext::getUnaryTransformType(QualType BaseType, 2957ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt QualType UnderlyingType, 2958ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt UnaryTransformType::UTTKind Kind) 2959ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt const { 2960ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt UnaryTransformType *Ty = 296169d9775da47a4b9f165dbc33277f02982928a94eDouglas Gregor new (*this, TypeAlignment) UnaryTransformType (BaseType, UnderlyingType, 296269d9775da47a4b9f165dbc33277f02982928a94eDouglas Gregor Kind, 296369d9775da47a4b9f165dbc33277f02982928a94eDouglas Gregor UnderlyingType->isDependentType() ? 296412fc4b0624706b474fa10308631fa8daf92f340fPeter Collingbourne QualType() : getCanonicalType(UnderlyingType)); 2965ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt Types.push_back(Ty); 2966ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt return QualType(Ty, 0); 2967ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt} 2968ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt 2969483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith/// getAutoType - We only unique auto types after they've been deduced. 297034b41d939a1328f484511c6002ba2456db879a29Richard SmithQualType ASTContext::getAutoType(QualType DeducedType) const { 2971483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith void *InsertPos = 0; 2972483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith if (!DeducedType.isNull()) { 2973483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith // Look in the folding set for an existing type. 2974483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith llvm::FoldingSetNodeID ID; 2975483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith AutoType::Profile(ID, DeducedType); 2976483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith if (AutoType *AT = AutoTypes.FindNodeOrInsertPos(ID, InsertPos)) 2977483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith return QualType(AT, 0); 2978483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith } 2979483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith 2980483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith AutoType *AT = new (*this, TypeAlignment) AutoType(DeducedType); 2981483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith Types.push_back(AT); 2982483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith if (InsertPos) 2983483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith AutoTypes.InsertNode(AT, InsertPos); 2984483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith return QualType(AT, 0); 298534b41d939a1328f484511c6002ba2456db879a29Richard Smith} 298634b41d939a1328f484511c6002ba2456db879a29Richard Smith 2987b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman/// getAtomicType - Return the uniqued reference to the atomic type for 2988b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman/// the given value type. 2989b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli FriedmanQualType ASTContext::getAtomicType(QualType T) const { 2990b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // Unique pointers, to guarantee there is only one pointer of a particular 2991b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // structure. 2992b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman llvm::FoldingSetNodeID ID; 2993b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicType::Profile(ID, T); 2994b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 2995b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman void *InsertPos = 0; 2996b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos)) 2997b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return QualType(AT, 0); 2998b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 2999b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // If the atomic value type isn't canonical, this won't be a canonical type 3000b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // either, so fill in the canonical type field. 3001b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType Canonical; 3002b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (!T.isCanonical()) { 3003b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman Canonical = getAtomicType(getCanonicalType(T)); 3004b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 3005b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // Get the new insert position for the node we care about. 3006b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos); 3007b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 3008b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 3009b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicType *New = new (*this, TypeAlignment) AtomicType(T, Canonical); 3010b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman Types.push_back(New); 3011b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicTypes.InsertNode(New, InsertPos); 3012b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return QualType(New, 0); 3013b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman} 3014b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 3015ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// getAutoDeductType - Get type pattern for deducing against 'auto'. 3016ad762fcdc16b9e4705b12b09d92b8c026212b906Richard SmithQualType ASTContext::getAutoDeductType() const { 3017ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith if (AutoDeductTy.isNull()) 3018ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith AutoDeductTy = getAutoType(QualType()); 3019ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith assert(!AutoDeductTy.isNull() && "can't build 'auto' pattern"); 3020ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith return AutoDeductTy; 3021ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith} 3022ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith 3023ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// getAutoRRefDeductType - Get type pattern for deducing against 'auto &&'. 3024ad762fcdc16b9e4705b12b09d92b8c026212b906Richard SmithQualType ASTContext::getAutoRRefDeductType() const { 3025ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith if (AutoRRefDeductTy.isNull()) 3026ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith AutoRRefDeductTy = getRValueReferenceType(getAutoDeductType()); 3027ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith assert(!AutoRRefDeductTy.isNull() && "can't build 'auto &&' pattern"); 3028ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith return AutoRRefDeductTy; 3029ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith} 3030ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith 30315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getTagDeclType - Return the unique reference to the type for the 30325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// specified TagDecl (struct/union/class/enum) decl. 30334ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTagDeclType(const TagDecl *Decl) const { 3034d778f88d32b96a74c9edb7342c81357606a7cdc0Ted Kremenek assert (Decl); 3035e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump // FIXME: What is the design on getTagDeclType when it requires casting 3036e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump // away const? mutable? 3037e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump return getTypeDeclType(const_cast<TagDecl*>(Decl)); 30385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 30395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 30401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getSizeType - Return the unique type for "size_t" (C99 7.17), the result 30411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and 30421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// needs to agree with the definition in <stddef.h>. 3043a3ccda58913cc1a4b8564e349448b12acc462da7Anders CarlssonCanQualType ASTContext::getSizeType() const { 3044bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor return getFromTargetType(Target->getSizeType()); 30455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 30465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 304729e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg/// getIntMaxType - Return the unique type for "intmax_t" (C99 7.18.1.5). 304829e97cb35fab314388f62b68fefa78947e93c1dcHans WennborgCanQualType ASTContext::getIntMaxType() const { 304929e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg return getFromTargetType(Target->getIntMaxType()); 305029e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg} 305129e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg 305229e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg/// getUIntMaxType - Return the unique type for "uintmax_t" (C99 7.18.1.5). 305329e97cb35fab314388f62b68fefa78947e93c1dcHans WennborgCanQualType ASTContext::getUIntMaxType() const { 305429e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg return getFromTargetType(Target->getUIntMaxType()); 305529e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg} 305629e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg 305764c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// getSignedWCharType - Return the type of "signed wchar_t". 305864c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// Used when in C++, as a GCC extension. 305964c438a4be2a871fa43c78264663ba1e9788b94dArgyrios KyrtzidisQualType ASTContext::getSignedWCharType() const { 306064c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis // FIXME: derive from "Target" ? 306164c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis return WCharTy; 306264c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis} 306364c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 306464c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// getUnsignedWCharType - Return the type of "unsigned wchar_t". 306564c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// Used when in C++, as a GCC extension. 306664c438a4be2a871fa43c78264663ba1e9788b94dArgyrios KyrtzidisQualType ASTContext::getUnsignedWCharType() const { 306764c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis // FIXME: derive from "Target" ? 306864c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis return UnsignedIntTy; 306964c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis} 307064c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 307129e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg/// getPointerDiffType - Return the unique type for "ptrdiff_t" (C99 7.17) 30728b9023ba35a86838789e2c9034a6128728c547aaChris Lattner/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9). 30738b9023ba35a86838789e2c9034a6128728c547aaChris LattnerQualType ASTContext::getPointerDiffType() const { 3074bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor return getFromTargetType(Target->getPtrDiffType(0)); 30758b9023ba35a86838789e2c9034a6128728c547aaChris Lattner} 30768b9023ba35a86838789e2c9034a6128728c547aaChris Lattner 3077e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner//===----------------------------------------------------------------------===// 3078e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner// Type Operators 3079e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner//===----------------------------------------------------------------------===// 3080e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner 30814ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCanQualType ASTContext::getCanonicalParamType(QualType T) const { 308254e14c4db764c0636160d26c5bbf491637c83a76John McCall // Push qualifiers into arrays, and then discard any remaining 308354e14c4db764c0636160d26c5bbf491637c83a76John McCall // qualifiers. 308454e14c4db764c0636160d26c5bbf491637c83a76John McCall T = getCanonicalType(T); 3085745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian T = getVariableArrayDecayedType(T); 308654e14c4db764c0636160d26c5bbf491637c83a76John McCall const Type *Ty = T.getTypePtr(); 308754e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType Result; 308854e14c4db764c0636160d26c5bbf491637c83a76John McCall if (isa<ArrayType>(Ty)) { 308954e14c4db764c0636160d26c5bbf491637c83a76John McCall Result = getArrayDecayedType(QualType(Ty,0)); 309054e14c4db764c0636160d26c5bbf491637c83a76John McCall } else if (isa<FunctionType>(Ty)) { 309154e14c4db764c0636160d26c5bbf491637c83a76John McCall Result = getPointerType(QualType(Ty, 0)); 309254e14c4db764c0636160d26c5bbf491637c83a76John McCall } else { 309354e14c4db764c0636160d26c5bbf491637c83a76John McCall Result = QualType(Ty, 0); 309454e14c4db764c0636160d26c5bbf491637c83a76John McCall } 309554e14c4db764c0636160d26c5bbf491637c83a76John McCall 309654e14c4db764c0636160d26c5bbf491637c83a76John McCall return CanQualType::CreateUnsafe(Result); 309754e14c4db764c0636160d26c5bbf491637c83a76John McCall} 309854e14c4db764c0636160d26c5bbf491637c83a76John McCall 309962c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCallQualType ASTContext::getUnqualifiedArrayType(QualType type, 310062c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall Qualifiers &quals) { 310162c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall SplitQualType splitType = type.getSplitUnqualifiedType(); 310262c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 310362c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // FIXME: getSplitUnqualifiedType() actually walks all the way to 310462c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // the unqualified desugared type and then drops it on the floor. 310562c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // We then have to strip that sugar back off with 310662c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // getUnqualifiedDesugaredType(), which is silly. 310762c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall const ArrayType *AT = 3108200fa53fd420aa8369586f569dbece04930ad6a3John McCall dyn_cast<ArrayType>(splitType.Ty->getUnqualifiedDesugaredType()); 310962c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 311062c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // If we don't have an array, just use the results in splitType. 31119dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (!AT) { 3112200fa53fd420aa8369586f569dbece04930ad6a3John McCall quals = splitType.Quals; 3113200fa53fd420aa8369586f569dbece04930ad6a3John McCall return QualType(splitType.Ty, 0); 311428e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth } 311528e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 311662c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // Otherwise, recurse on the array's element type. 311762c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall QualType elementType = AT->getElementType(); 311862c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall QualType unqualElementType = getUnqualifiedArrayType(elementType, quals); 311962c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 312062c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // If that didn't change the element type, AT has no qualifiers, so we 312162c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // can just use the results in splitType. 312262c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall if (elementType == unqualElementType) { 312362c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall assert(quals.empty()); // from the recursive call 3124200fa53fd420aa8369586f569dbece04930ad6a3John McCall quals = splitType.Quals; 3125200fa53fd420aa8369586f569dbece04930ad6a3John McCall return QualType(splitType.Ty, 0); 312662c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall } 312762c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 312862c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // Otherwise, add in the qualifiers from the outermost type, then 312962c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // build the type back up. 3130200fa53fd420aa8369586f569dbece04930ad6a3John McCall quals.addConsistentQualifiers(splitType.Quals); 313128e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31329dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) { 313362c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getConstantArrayType(unqualElementType, CAT->getSize(), 313428e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth CAT->getSizeModifier(), 0); 313528e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth } 313628e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31379dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) { 313862c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getIncompleteArrayType(unqualElementType, IAT->getSizeModifier(), 0); 313928e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth } 314028e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31419dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(AT)) { 314262c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getVariableArrayType(unqualElementType, 31433fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall VAT->getSizeExpr(), 31449dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor VAT->getSizeModifier(), 31459dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor VAT->getIndexTypeCVRQualifiers(), 31469dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor VAT->getBracketsRange()); 31479dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor } 31489dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor 31499dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor const DependentSizedArrayType *DSAT = cast<DependentSizedArrayType>(AT); 315062c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getDependentSizedArrayType(unqualElementType, DSAT->getSizeExpr(), 315128e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth DSAT->getSizeModifier(), 0, 315228e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth SourceRange()); 315328e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth} 315428e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31555a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// UnwrapSimilarPointerTypes - If T1 and T2 are pointer types that 31565a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// may be similar (C++ 4.4), replaces T1 and T2 with the type that 31575a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// they point to and return true. If T1 and T2 aren't pointer types 31585a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// or pointer-to-member types, or if they are not similar at this 31595a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// level, returns false and leaves T1 and T2 unchanged. Top-level 31605a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// qualifiers on T1 and T2 are ignored. This function will typically 31615a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// be called in a loop that successively "unwraps" pointer and 31625a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// pointer-to-member types to compare them at each level. 31635a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregorbool ASTContext::UnwrapSimilarPointerTypes(QualType &T1, QualType &T2) { 31645a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor const PointerType *T1PtrType = T1->getAs<PointerType>(), 31655a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor *T2PtrType = T2->getAs<PointerType>(); 31665a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (T1PtrType && T2PtrType) { 31675a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T1 = T1PtrType->getPointeeType(); 31685a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T2 = T2PtrType->getPointeeType(); 31695a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return true; 31705a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 31715a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 31725a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor const MemberPointerType *T1MPType = T1->getAs<MemberPointerType>(), 31735a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor *T2MPType = T2->getAs<MemberPointerType>(); 31745a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (T1MPType && T2MPType && 31755a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0), 31765a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor QualType(T2MPType->getClass(), 0))) { 31775a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T1 = T1MPType->getPointeeType(); 31785a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T2 = T2MPType->getPointeeType(); 31795a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return true; 31805a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 31815a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 31825a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (getLangOptions().ObjC1) { 31835a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor const ObjCObjectPointerType *T1OPType = T1->getAs<ObjCObjectPointerType>(), 31845a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor *T2OPType = T2->getAs<ObjCObjectPointerType>(); 31855a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (T1OPType && T2OPType) { 31865a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T1 = T1OPType->getPointeeType(); 31875a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T2 = T2OPType->getPointeeType(); 31885a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return true; 31895a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 31905a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 31915a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 31925a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor // FIXME: Block pointers, too? 31935a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 31945a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return false; 31955a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor} 31965a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 31974ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadDeclarationNameInfo 31984ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getNameForTemplate(TemplateName Name, 31994ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad SourceLocation NameLoc) const { 3200146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall switch (Name.getKind()) { 3201146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::QualifiedTemplate: 3202146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::Template: 32032577743c5650c646fb705df01403707e94f2df04Abramo Bagnara // DNInfo work in progress: CHECKME: what about DNLoc? 3204146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo(Name.getAsTemplateDecl()->getDeclName(), 3205146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall NameLoc); 32062577743c5650c646fb705df01403707e94f2df04Abramo Bagnara 3207146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::OverloadedTemplate: { 3208146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall OverloadedTemplateStorage *Storage = Name.getAsOverloadedTemplate(); 3209146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall // DNInfo work in progress: CHECKME: what about DNLoc? 3210146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo((*Storage->begin())->getDeclName(), NameLoc); 3211146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3212146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3213146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::DependentTemplate: { 3214146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall DependentTemplateName *DTN = Name.getAsDependentTemplateName(); 32152577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DeclarationName DName; 321680ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall if (DTN->isIdentifier()) { 32172577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DName = DeclarationNames.getIdentifier(DTN->getIdentifier()); 32182577743c5650c646fb705df01403707e94f2df04Abramo Bagnara return DeclarationNameInfo(DName, NameLoc); 321980ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall } else { 32202577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DName = DeclarationNames.getCXXOperatorName(DTN->getOperator()); 32212577743c5650c646fb705df01403707e94f2df04Abramo Bagnara // DNInfo work in progress: FIXME: source locations? 32222577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DeclarationNameLoc DNLoc; 32232577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DNLoc.CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding(); 32242577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DNLoc.CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding(); 32252577743c5650c646fb705df01403707e94f2df04Abramo Bagnara return DeclarationNameInfo(DName, NameLoc, DNLoc); 322680ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall } 322780ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall } 322880ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall 3229146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParm: { 3230146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage *subst 3231146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParm(); 3232146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo(subst->getParameter()->getDeclName(), 3233146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall NameLoc); 3234146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3235146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3236146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParmPack: { 3237146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmPackStorage *subst 3238146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParmPack(); 3239146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo(subst->getParameterPack()->getDeclName(), 3240146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall NameLoc); 3241146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3242146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3243146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3244146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm_unreachable("bad template name kind!"); 324580ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall} 324680ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall 32474ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) const { 3248146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall switch (Name.getKind()) { 3249146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::QualifiedTemplate: 3250146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::Template: { 3251146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateDecl *Template = Name.getAsTemplateDecl(); 32523e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor if (TemplateTemplateParmDecl *TTP 3253146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = dyn_cast<TemplateTemplateParmDecl>(Template)) 32543e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor Template = getCanonicalTemplateTemplateParmDecl(TTP); 32553e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 32563e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // The canonical template name is the canonical template declaration. 325797fbaa2a38804268a024f1a104b43fcf8b4411b0Argyrios Kyrtzidis return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl())); 32583e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor } 325925a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor 3260146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::OverloadedTemplate: 3261146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm_unreachable("cannot canonicalize overloaded template"); 3262146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3263146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::DependentTemplate: { 3264146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall DependentTemplateName *DTN = Name.getAsDependentTemplateName(); 3265146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall assert(DTN && "Non-dependent template names must refer to template decls."); 3266146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DTN->CanonicalTemplateName; 3267146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3268146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3269146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParm: { 3270146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage *subst 3271146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParm(); 3272146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return getCanonicalTemplateName(subst->getReplacement()); 32731aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor } 32741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3275146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParmPack: { 3276146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmPackStorage *subst 3277146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParmPack(); 3278146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateTemplateParmDecl *canonParameter 3279146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = getCanonicalTemplateTemplateParmDecl(subst->getParameterPack()); 3280146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateArgument canonArgPack 3281146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = getCanonicalTemplateArgument(subst->getArgumentPack()); 3282146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return getSubstTemplateTemplateParmPack(canonParameter, canonArgPack); 3283146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3284146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3285146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3286146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm_unreachable("bad template name!"); 328725a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor} 328825a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor 3289db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregorbool ASTContext::hasSameTemplateName(TemplateName X, TemplateName Y) { 3290db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor X = getCanonicalTemplateName(X); 3291db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Y = getCanonicalTemplateName(Y); 3292db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return X.getAsVoidPointer() == Y.getAsVoidPointer(); 3293db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor} 3294db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor 32951eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpTemplateArgument 32964ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const { 32971275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor switch (Arg.getKind()) { 32981275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Null: 32991275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor return Arg; 33001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33011275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Expression: 33021275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor return Arg; 33031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33041275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Declaration: 3305833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall return TemplateArgument(Arg.getAsDecl()->getCanonicalDecl()); 33061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3307788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 3308788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate())); 3309a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 3310a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 3311a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return TemplateArgument(getCanonicalTemplateName( 3312a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Arg.getAsTemplateOrTemplatePattern()), 33132be29f423acad3bbe39099a78db2805acb5bdf17Douglas Gregor Arg.getNumTemplateExpansions()); 3314a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 33151275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Integral: 3316833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall return TemplateArgument(*Arg.getAsIntegral(), 33171275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor getCanonicalType(Arg.getIntegralType())); 33181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33191275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Type: 3320833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall return TemplateArgument(getCanonicalType(Arg.getAsType())); 33211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33221275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Pack: { 332387dd697dcc8ecb64df73ae64d61b8c80ff0c157cDouglas Gregor if (Arg.pack_size() == 0) 332487dd697dcc8ecb64df73ae64d61b8c80ff0c157cDouglas Gregor return Arg; 332587dd697dcc8ecb64df73ae64d61b8c80ff0c157cDouglas Gregor 3326910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgument *CanonArgs 3327910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor = new (*this) TemplateArgument[Arg.pack_size()]; 33281275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor unsigned Idx = 0; 33291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (TemplateArgument::pack_iterator A = Arg.pack_begin(), 33301275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor AEnd = Arg.pack_end(); 33311275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor A != AEnd; (void)++A, ++Idx) 33321275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor CanonArgs[Idx] = getCanonicalTemplateArgument(*A); 33331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3334910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor return TemplateArgument(CanonArgs, Arg.pack_size()); 33351275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor } 33361275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor } 33371275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor 33381275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // Silence GCC warning 3339b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unhandled template argument kind"); 33401275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor} 33411275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor 3342d57959af02b4af695276f4204443afe6e5d86bd8Douglas GregorNestedNameSpecifier * 33434ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const { 33441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (!NNS) 3345d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor return 0; 3346d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3347d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor switch (NNS->getKind()) { 3348d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::Identifier: 3349d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // Canonicalize the prefix but keep the identifier the same. 33501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return NestedNameSpecifier::Create(*this, 3351d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor getCanonicalNestedNameSpecifier(NNS->getPrefix()), 3352d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor NNS->getAsIdentifier()); 3353d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3354d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::Namespace: 3355d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // A namespace is canonical; build a nested-name-specifier with 3356d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // this namespace and no prefix. 335714aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor return NestedNameSpecifier::Create(*this, 0, 335814aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor NNS->getAsNamespace()->getOriginalNamespace()); 335914aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor 336014aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor case NestedNameSpecifier::NamespaceAlias: 336114aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor // A namespace is canonical; build a nested-name-specifier with 336214aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor // this namespace and no prefix. 336314aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor return NestedNameSpecifier::Create(*this, 0, 336414aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor NNS->getAsNamespaceAlias()->getNamespace() 336514aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor ->getOriginalNamespace()); 3366d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3367d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::TypeSpec: 3368d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::TypeSpecWithTemplate: { 3369d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor QualType T = getCanonicalType(QualType(NNS->getAsType(), 0)); 3370264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor 3371264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // If we have some kind of dependent-named type (e.g., "typename T::type"), 3372264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // break it apart into its prefix and identifier, then reconsititute those 3373264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // as the canonical nested-name-specifier. This is required to canonicalize 3374264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // a dependent nested-name-specifier involving typedefs of dependent-name 3375264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // types, e.g., 3376264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // typedef typename T::type T1; 3377264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // typedef typename T1::type T2; 337816412ef25a2203b7066d0db2b41f944631e5cf79Eli Friedman if (const DependentNameType *DNT = T->getAs<DependentNameType>()) 337916412ef25a2203b7066d0db2b41f944631e5cf79Eli Friedman return NestedNameSpecifier::Create(*this, DNT->getQualifier(), 3380264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor const_cast<IdentifierInfo *>(DNT->getIdentifier())); 3381264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor 338216412ef25a2203b7066d0db2b41f944631e5cf79Eli Friedman // Otherwise, just canonicalize the type, and force it to be a TypeSpec. 338316412ef25a2203b7066d0db2b41f944631e5cf79Eli Friedman // FIXME: Why are TypeSpec and TypeSpecWithTemplate distinct in the 338416412ef25a2203b7066d0db2b41f944631e5cf79Eli Friedman // first place? 33853b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return NestedNameSpecifier::Create(*this, 0, false, 33863b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall const_cast<Type*>(T.getTypePtr())); 3387d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor } 3388d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3389d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::Global: 3390d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // The global specifier is canonical and unique. 3391d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor return NNS; 3392d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor } 3393d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 33947530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie llvm_unreachable("Invalid NestedNameSpecifier::Kind!"); 3395d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor} 3396d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3397c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 33984ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadconst ArrayType *ASTContext::getAsArrayType(QualType T) const { 3399c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Handle the non-qualified case efficiently. 3400a4923eb7c4b04d360cb2747641a5e92818edf804Douglas Gregor if (!T.hasLocalQualifiers()) { 3401c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Handle the common positive case fast. 3402c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const ArrayType *AT = dyn_cast<ArrayType>(T)) 3403c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return AT; 3404c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner } 34051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 34060953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Handle the common negative case fast. 34073b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!isa<ArrayType>(T.getCanonicalType())) 3408c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return 0; 34091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 34100953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Apply any qualifiers from the array type to the element type. This 3411c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // implements C99 6.7.3p8: "If the specification of an array type includes 3412c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // any type qualifiers, the element type is so qualified, not the array type." 34131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3414c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // If we get here, we either have type qualifiers on the type, or we have 3415c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // sugar such as a typedef in the way. If we have type qualifiers on the type 341650d62d1b4a98adbc83de8f8cd1379ea1c25656f7Douglas Gregor // we must propagate them down into the element type. 34170953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 34183b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType split = T.getSplitDesugaredType(); 3419200fa53fd420aa8369586f569dbece04930ad6a3John McCall Qualifiers qs = split.Quals; 34201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3421c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // If we have a simple case, just return now. 3422200fa53fd420aa8369586f569dbece04930ad6a3John McCall const ArrayType *ATy = dyn_cast<ArrayType>(split.Ty); 34233b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (ATy == 0 || qs.empty()) 3424c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return ATy; 34251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3426c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Otherwise, we have an array and we have qualifiers on it. Push the 3427c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // qualifiers into the array element type and return a new array type. 34283b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType NewEltTy = getQualifiedType(ATy->getElementType(), qs); 34291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3430c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(ATy)) 3431c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(), 3432c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner CAT->getSizeModifier(), 34330953e767ff7817f97b3ab20896b229891eeff45bJohn McCall CAT->getIndexTypeCVRQualifiers())); 3434c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(ATy)) 3435c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return cast<ArrayType>(getIncompleteArrayType(NewEltTy, 3436c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner IAT->getSizeModifier(), 34370953e767ff7817f97b3ab20896b229891eeff45bJohn McCall IAT->getIndexTypeCVRQualifiers())); 3438898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 34391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const DependentSizedArrayType *DSAT 3440898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor = dyn_cast<DependentSizedArrayType>(ATy)) 3441898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return cast<ArrayType>( 34421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getDependentSizedArrayType(NewEltTy, 34433fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall DSAT->getSizeExpr(), 3444898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor DSAT->getSizeModifier(), 34450953e767ff7817f97b3ab20896b229891eeff45bJohn McCall DSAT->getIndexTypeCVRQualifiers(), 34467e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor DSAT->getBracketsRange())); 34471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3448c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner const VariableArrayType *VAT = cast<VariableArrayType>(ATy); 34497e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor return cast<ArrayType>(getVariableArrayType(NewEltTy, 34503fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall VAT->getSizeExpr(), 3451c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner VAT->getSizeModifier(), 34520953e767ff7817f97b3ab20896b229891eeff45bJohn McCall VAT->getIndexTypeCVRQualifiers(), 34537e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor VAT->getBracketsRange())); 345477c9647cae939104c6cb2b6a4dd8ca859d2e5770Chris Lattner} 345577c9647cae939104c6cb2b6a4dd8ca859d2e5770Chris Lattner 345679e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas GregorQualType ASTContext::getAdjustedParameterType(QualType T) { 345779e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // C99 6.7.5.3p7: 345879e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // A declaration of a parameter as "array of type" shall be 345979e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // adjusted to "qualified pointer to type", where the type 346079e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // qualifiers (if any) are those specified within the [ and ] of 346179e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // the array type derivation. 346279e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor if (T->isArrayType()) 346379e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return getArrayDecayedType(T); 346479e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 346579e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // C99 6.7.5.3p8: 346679e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // A declaration of a parameter as "function returning type" 346779e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // shall be adjusted to "pointer to function returning type", as 346879e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // in 6.3.2.1. 346979e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor if (T->isFunctionType()) 347079e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return getPointerType(T); 347179e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 347279e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return T; 347379e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor} 347479e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 347579e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas GregorQualType ASTContext::getSignatureParameterType(QualType T) { 347679e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor T = getVariableArrayDecayedType(T); 347779e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor T = getAdjustedParameterType(T); 347879e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return T.getUnqualifiedType(); 347979e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor} 348079e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 3481e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// getArrayDecayedType - Return the properly qualified result of decaying the 3482e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// specified array type to a pointer. This operation is non-trivial when 3483e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// handling typedefs etc. The canonical type of "T" must be an array type, 3484e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// this returns a pointer to a properly qualified element of the array. 3485e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// 3486e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// See C99 6.7.5.3p7 and C99 6.3.2.1p3. 34874ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getArrayDecayedType(QualType Ty) const { 3488c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Get the element type with 'getAsArrayType' so that we don't lose any 3489c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // typedefs in the element type of the array. This also handles propagation 3490c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // of type qualifiers from the array type into the element type if present 3491c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // (C99 6.7.3p8). 3492c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner const ArrayType *PrettyArrayType = getAsArrayType(Ty); 3493c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner assert(PrettyArrayType && "Not an array type!"); 34941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3495c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner QualType PtrTy = getPointerType(PrettyArrayType->getElementType()); 3496e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner 3497e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner // int x[restrict 4] -> int *restrict 34980953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return getQualifiedType(PtrTy, PrettyArrayType->getIndexTypeQualifiers()); 3499e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner} 3500e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner 35013b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getBaseElementType(const ArrayType *array) const { 35023b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return getBaseElementType(array->getElementType()); 35035e03f9ea8174ae588c5e69ec6b5ef4c68f8fd766Douglas Gregor} 35045e03f9ea8174ae588c5e69ec6b5ef4c68f8fd766Douglas Gregor 35053b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getBaseElementType(QualType type) const { 35063b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Qualifiers qs; 35073b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall while (true) { 35083b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType split = type.getSplitDesugaredType(); 3509200fa53fd420aa8369586f569dbece04930ad6a3John McCall const ArrayType *array = split.Ty->getAsArrayTypeUnsafe(); 35103b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!array) break; 35111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 35123b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall type = array->getElementType(); 3513200fa53fd420aa8369586f569dbece04930ad6a3John McCall qs.addConsistentQualifiers(split.Quals); 35143b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall } 35151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 35163b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return getQualifiedType(type, qs); 35176183a99b064b397d98297904fbd6cf00fe1f453dAnders Carlsson} 35186183a99b064b397d98297904fbd6cf00fe1f453dAnders Carlsson 35190de78998e7bda473b408437053e48661b510d453Fariborz Jahanian/// getConstantArrayElementCount - Returns number of constant array elements. 35201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpuint64_t 35210de78998e7bda473b408437053e48661b510d453Fariborz JahanianASTContext::getConstantArrayElementCount(const ConstantArrayType *CA) const { 35220de78998e7bda473b408437053e48661b510d453Fariborz Jahanian uint64_t ElementCount = 1; 35230de78998e7bda473b408437053e48661b510d453Fariborz Jahanian do { 35240de78998e7bda473b408437053e48661b510d453Fariborz Jahanian ElementCount *= CA->getSize().getZExtValue(); 35250de78998e7bda473b408437053e48661b510d453Fariborz Jahanian CA = dyn_cast<ConstantArrayType>(CA->getElementType()); 35260de78998e7bda473b408437053e48661b510d453Fariborz Jahanian } while (CA); 35270de78998e7bda473b408437053e48661b510d453Fariborz Jahanian return ElementCount; 35280de78998e7bda473b408437053e48661b510d453Fariborz Jahanian} 35290de78998e7bda473b408437053e48661b510d453Fariborz Jahanian 35305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getFloatingRank - Return a relative rank for floating point types. 35315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// This routine will assert if passed a built-in type that isn't a float. 3532a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattnerstatic FloatingRank getFloatingRank(QualType T) { 3533183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ComplexType *CT = T->getAs<ComplexType>()) 35345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return getFloatingRank(CT->getElementType()); 3535a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner 3536183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall assert(T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type"); 3537183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall switch (T->getAs<BuiltinType>()->getKind()) { 3538b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("getFloatingRank(): not a floating type"); 3539aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov case BuiltinType::Half: return HalfRank; 35405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Float: return FloatRank; 35415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Double: return DoubleRank; 35425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::LongDouble: return LongDoubleRank; 35435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 35445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 35455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 35461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getFloatingTypeOfSizeWithinDomain - Returns a real floating 35471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// point or a complex type (based on typeDomain/typeSize). 3548716c7304ff5d27a95e1e7823acd1d09d5ec3e37fSteve Naroff/// 'typeDomain' is a real floating point or complex type. 3549716c7304ff5d27a95e1e7823acd1d09d5ec3e37fSteve Naroff/// 'typeSize' is a real floating point or complex type. 35501361b11066239ea15764a2a844405352d87296b3Chris LattnerQualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size, 35511361b11066239ea15764a2a844405352d87296b3Chris Lattner QualType Domain) const { 35521361b11066239ea15764a2a844405352d87296b3Chris Lattner FloatingRank EltRank = getFloatingRank(Size); 35531361b11066239ea15764a2a844405352d87296b3Chris Lattner if (Domain->isComplexType()) { 35541361b11066239ea15764a2a844405352d87296b3Chris Lattner switch (EltRank) { 3555561d3abc881033776ece385a01a510e1cbc1fa92David Blaikie case HalfRank: llvm_unreachable("Complex half is not supported"); 3556f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff case FloatRank: return FloatComplexTy; 3557f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff case DoubleRank: return DoubleComplexTy; 3558f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff case LongDoubleRank: return LongDoubleComplexTy; 3559f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff } 3560f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff } 35611361b11066239ea15764a2a844405352d87296b3Chris Lattner 35621361b11066239ea15764a2a844405352d87296b3Chris Lattner assert(Domain->isRealFloatingType() && "Unknown domain!"); 35631361b11066239ea15764a2a844405352d87296b3Chris Lattner switch (EltRank) { 3564561d3abc881033776ece385a01a510e1cbc1fa92David Blaikie case HalfRank: llvm_unreachable("Half ranks are not valid here"); 35651361b11066239ea15764a2a844405352d87296b3Chris Lattner case FloatRank: return FloatTy; 35661361b11066239ea15764a2a844405352d87296b3Chris Lattner case DoubleRank: return DoubleTy; 35671361b11066239ea15764a2a844405352d87296b3Chris Lattner case LongDoubleRank: return LongDoubleTy; 35685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3569561d3abc881033776ece385a01a510e1cbc1fa92David Blaikie llvm_unreachable("getFloatingRank(): illegal value for rank"); 35705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 35715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 35727cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// getFloatingTypeOrder - Compare the rank of the two specified floating 35737cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// point types, ignoring the domain of the type (i.e. 'double' == 35747cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If 35751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// LHS < RHS, return -1. 35764ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadint ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) const { 3577a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner FloatingRank LHSR = getFloatingRank(LHS); 3578a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner FloatingRank RHSR = getFloatingRank(RHS); 35791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3580a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner if (LHSR == RHSR) 3581fb0d49669aa370b4c0993c5cee60275ef9fd6518Steve Naroff return 0; 3582a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner if (LHSR > RHSR) 3583fb0d49669aa370b4c0993c5cee60275ef9fd6518Steve Naroff return 1; 3584fb0d49669aa370b4c0993c5cee60275ef9fd6518Steve Naroff return -1; 35855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 35865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3587f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This 3588f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner/// routine will assert if passed a built-in type that isn't an integer or enum, 3589f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner/// or if it is not canonicalized. 3590f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCallunsigned ASTContext::getIntegerRank(const Type *T) const { 3591467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(T->isCanonicalUnqualified() && "T should be canonicalized"); 3592f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith 3593f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner switch (cast<BuiltinType>(T)->getKind()) { 3594b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("getIntegerRank(): not a built-in integer"); 35957cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Bool: 3596f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 1 + (getIntWidth(BoolTy) << 3); 35977cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Char_S: 35987cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Char_U: 35997cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::SChar: 36007cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::UChar: 3601f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 2 + (getIntWidth(CharTy) << 3); 36027cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Short: 36037cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::UShort: 3604f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 3 + (getIntWidth(ShortTy) << 3); 36057cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Int: 36067cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::UInt: 3607f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 4 + (getIntWidth(IntTy) << 3); 36087cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Long: 36097cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::ULong: 3610f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 5 + (getIntWidth(LongTy) << 3); 36117cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::LongLong: 36127cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::ULongLong: 3613f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 6 + (getIntWidth(LongLongTy) << 3); 36142df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::Int128: 36152df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::UInt128: 36162df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner return 7 + (getIntWidth(Int128Ty) << 3); 3617f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner } 3618f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner} 3619f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner 362004e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// \brief Whether this is a promotable bitfield reference according 362104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// to C99 6.3.1.1p2, bullet 2 (and GCC extensions). 362204e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// 362304e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// \returns the type this bit-field will promote to, or NULL if no 362404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// promotion occurs. 36254ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::isPromotableBitField(Expr *E) const { 3626ceafbdeb93ecf323cca74e660bf54504c86f3b71Douglas Gregor if (E->isTypeDependent() || E->isValueDependent()) 3627ceafbdeb93ecf323cca74e660bf54504c86f3b71Douglas Gregor return QualType(); 3628ceafbdeb93ecf323cca74e660bf54504c86f3b71Douglas Gregor 362904e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman FieldDecl *Field = E->getBitField(); 363004e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman if (!Field) 363104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return QualType(); 363204e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 363304e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman QualType FT = Field->getType(); 363404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 3635a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith uint64_t BitWidth = Field->getBitWidthValue(*this); 363604e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman uint64_t IntSize = getTypeSize(IntTy); 363704e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // GCC extension compatibility: if the bit-field size is less than or equal 363804e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // to the size of int, it gets promoted no matter what its type is. 363904e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // For instance, unsigned long bf : 4 gets promoted to signed int. 364004e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman if (BitWidth < IntSize) 364104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return IntTy; 364204e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 364304e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman if (BitWidth == IntSize) 364404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return FT->isSignedIntegerType() ? IntTy : UnsignedIntTy; 364504e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 364604e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // Types bigger than int are not subject to promotions, and therefore act 364704e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // like the base type. 364804e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // FIXME: This doesn't quite match what gcc does, but what gcc does here 364904e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // is ridiculous. 365004e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return QualType(); 365104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman} 365204e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 3653a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman/// getPromotedIntegerType - Returns the type that Promotable will 3654a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman/// promote to: C99 6.3.1.1p2, assuming that Promotable is a promotable 3655a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman/// integer type. 36564ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getPromotedIntegerType(QualType Promotable) const { 3657a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman assert(!Promotable.isNull()); 3658a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman assert(Promotable->isPromotableIntegerType()); 3659842aef8d942a880eeb9535d40de31a86838264cbJohn McCall if (const EnumType *ET = Promotable->getAs<EnumType>()) 3660842aef8d942a880eeb9535d40de31a86838264cbJohn McCall return ET->getDecl()->getPromotionType(); 366168a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman 366268a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman if (const BuiltinType *BT = Promotable->getAs<BuiltinType>()) { 366368a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // C++ [conv.prom]: A prvalue of type char16_t, char32_t, or wchar_t 366468a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // (3.9.1) can be converted to a prvalue of the first of the following 366568a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // types that can represent all the values of its underlying type: 366668a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // int, unsigned int, long int, unsigned long int, long long int, or 366768a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // unsigned long long int [...] 366868a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // FIXME: Is there some better way to compute this? 366968a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman if (BT->getKind() == BuiltinType::WChar_S || 367068a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman BT->getKind() == BuiltinType::WChar_U || 367168a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman BT->getKind() == BuiltinType::Char16 || 367268a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman BT->getKind() == BuiltinType::Char32) { 367368a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman bool FromIsSigned = BT->getKind() == BuiltinType::WChar_S; 367468a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman uint64_t FromSize = getTypeSize(BT); 367568a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman QualType PromoteTypes[] = { IntTy, UnsignedIntTy, LongTy, UnsignedLongTy, 367668a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman LongLongTy, UnsignedLongLongTy }; 367768a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman for (size_t Idx = 0; Idx < llvm::array_lengthof(PromoteTypes); ++Idx) { 367868a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman uint64_t ToSize = getTypeSize(PromoteTypes[Idx]); 367968a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman if (FromSize < ToSize || 368068a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman (FromSize == ToSize && 368168a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) 368268a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman return PromoteTypes[Idx]; 368368a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman } 368468a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman llvm_unreachable("char type should fit into long long"); 368568a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman } 368668a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman } 368768a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman 368868a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // At this point, we should have a signed or unsigned integer type. 3689a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman if (Promotable->isSignedIntegerType()) 3690a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman return IntTy; 3691a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman uint64_t PromotableSize = getTypeSize(Promotable); 3692a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman uint64_t IntSize = getTypeSize(IntTy); 3693a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman assert(Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize); 3694a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman return (PromotableSize != IntSize) ? IntTy : UnsignedIntTy; 3695a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman} 3696a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman 369731862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis/// \brief Recurses in pointer/array types until it finds an objc retainable 369831862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis/// type and returns its ownership. 369931862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios KyrtzidisQualifiers::ObjCLifetime ASTContext::getInnerObjCOwnership(QualType T) const { 370031862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis while (!T.isNull()) { 370131862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis if (T.getObjCLifetime() != Qualifiers::OCL_None) 370231862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis return T.getObjCLifetime(); 370331862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis if (T->isArrayType()) 370431862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis T = getBaseElementType(T); 370531862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis else if (const PointerType *PT = T->getAs<PointerType>()) 370631862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis T = PT->getPointeeType(); 370731862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis else if (const ReferenceType *RT = T->getAs<ReferenceType>()) 370828445f0b62f6aed851ff87ce64d9b19200d3211fArgyrios Kyrtzidis T = RT->getPointeeType(); 370931862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis else 371031862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis break; 371131862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis } 371231862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis 371331862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis return Qualifiers::OCL_None; 371431862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis} 371531862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis 37161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getIntegerTypeOrder - Returns the highest ranked integer type: 37177cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If 37181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// LHS < RHS, return -1. 37194ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadint ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) const { 3720f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall const Type *LHSC = getCanonicalType(LHS).getTypePtr(); 3721f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall const Type *RHSC = getCanonicalType(RHS).getTypePtr(); 37227cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSC == RHSC) return 0; 37231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3724f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner bool LHSUnsigned = LHSC->isUnsignedIntegerType(); 3725f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner bool RHSUnsigned = RHSC->isUnsignedIntegerType(); 37261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37277cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner unsigned LHSRank = getIntegerRank(LHSC); 37287cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner unsigned RHSRank = getIntegerRank(RHSC); 37291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37307cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned. 37317cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSRank == RHSRank) return 0; 37327cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return LHSRank > RHSRank ? 1 : -1; 37337cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner } 37341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37357cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // Otherwise, the LHS is signed and the RHS is unsigned or visa versa. 37367cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSUnsigned) { 37377cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the unsigned [LHS] type is larger, return it. 37387cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSRank >= RHSRank) 37397cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return 1; 37401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37417cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the signed type can represent all values of the unsigned type, it 37427cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // wins. Because we are dealing with 2's complement and types that are 37431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // powers of two larger than each other, this is always safe. 37447cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return -1; 37457cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner } 37467cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner 37477cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the unsigned [RHS] type is larger, return it. 37487cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (RHSRank >= LHSRank) 37497cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return -1; 37501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37517cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the signed type can represent all values of the unsigned type, it 37527cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // wins. Because we are dealing with 2's complement and types that are 37531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // powers of two larger than each other, this is always safe. 37547cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return 1; 37555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 375671993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson 375779cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlssonstatic RecordDecl * 3758ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo BagnaraCreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK, 3759ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara DeclContext *DC, IdentifierInfo *Id) { 3760ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara SourceLocation Loc; 376179cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson if (Ctx.getLangOptions().CPlusPlus) 3762ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 376379cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson else 3764ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 376579cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson} 3766ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara 37671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump// getCFConstantStringType - Return the type used for constant CFStrings. 37684ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getCFConstantStringType() const { 376971993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson if (!CFConstantStringTypeDecl) { 37701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump CFConstantStringTypeDecl = 3771ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara CreateRecordDecl(*this, TTK_Struct, TUDecl, 377279cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson &Idents.get("NSConstantString")); 37735cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall CFConstantStringTypeDecl->startDefinition(); 377479cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson 3775f06273f8bbacb086a46bde456429c8d08f6d07eeAnders Carlsson QualType FieldTypes[4]; 37761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 377771993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson // const int *isa; 37780953e767ff7817f97b3ab20896b229891eeff45bJohn McCall FieldTypes[0] = getPointerType(IntTy.withConst()); 3779f06273f8bbacb086a46bde456429c8d08f6d07eeAnders Carlsson // int flags; 3780f06273f8bbacb086a46bde456429c8d08f6d07eeAnders Carlsson FieldTypes[1] = IntTy; 378171993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson // const char *str; 37820953e767ff7817f97b3ab20896b229891eeff45bJohn McCall FieldTypes[2] = getPointerType(CharTy.withConst()); 378371993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson // long length; 37841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump FieldTypes[3] = LongTy; 37851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 378644b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor // Create fields 378744b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor for (unsigned i = 0; i < 4; ++i) { 37881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump FieldDecl *Field = FieldDecl::Create(*this, CFConstantStringTypeDecl, 3789ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara SourceLocation(), 379044b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor SourceLocation(), 0, 3791a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 37921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump /*BitWidth=*/0, 37937a614d8380297fcd2bc23986241905d97222948cRichard Smith /*Mutable=*/false, 37947a614d8380297fcd2bc23986241905d97222948cRichard Smith /*HasInit=*/false); 37952888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 379617945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis CFConstantStringTypeDecl->addDecl(Field); 379744b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor } 379844b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor 3799838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor CFConstantStringTypeDecl->completeDefinition(); 380071993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson } 38011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 380271993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson return getTagDeclType(CFConstantStringTypeDecl); 38038467583c2704e7a9691ea56939a029015f0ade0aGabor Greif} 3804b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson 3805319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregorvoid ASTContext::setCFConstantStringType(QualType T) { 38066217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek const RecordType *Rec = T->getAs<RecordType>(); 3807319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor assert(Rec && "Invalid CFConstantStringType"); 3808319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor CFConstantStringTypeDecl = Rec->getDecl(); 3809319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor} 3810319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor 38114ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getBlockDescriptorType() const { 3812adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump if (BlockDescriptorType) 3813adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump return getTagDeclType(BlockDescriptorType); 3814adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3815adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump RecordDecl *T; 3816adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump // FIXME: Needs the FlagAppleBlock bit. 3817ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara T = CreateRecordDecl(*this, TTK_Struct, TUDecl, 381879cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson &Idents.get("__block_descriptor")); 38195cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall T->startDefinition(); 3820adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3821adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump QualType FieldTypes[] = { 3822adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump UnsignedLongTy, 3823adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump UnsignedLongTy, 3824adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump }; 3825adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3826adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump const char *FieldNames[] = { 3827adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump "reserved", 3828083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "Size" 3829adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump }; 3830adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3831adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump for (size_t i = 0; i < 2; ++i) { 3832ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 3833adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump SourceLocation(), 3834adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump &Idents.get(FieldNames[i]), 3835a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 3836adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump /*BitWidth=*/0, 38377a614d8380297fcd2bc23986241905d97222948cRichard Smith /*Mutable=*/false, 38387a614d8380297fcd2bc23986241905d97222948cRichard Smith /*HasInit=*/false); 38392888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 3840adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump T->addDecl(Field); 3841adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump } 3842adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3843838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor T->completeDefinition(); 3844adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3845adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump BlockDescriptorType = T; 3846adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3847adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump return getTagDeclType(BlockDescriptorType); 3848adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump} 3849adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 38504ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getBlockDescriptorExtendedType() const { 3851083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump if (BlockDescriptorExtendedType) 3852083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump return getTagDeclType(BlockDescriptorExtendedType); 3853083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3854083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump RecordDecl *T; 3855083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump // FIXME: Needs the FlagAppleBlock bit. 3856ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara T = CreateRecordDecl(*this, TTK_Struct, TUDecl, 385779cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson &Idents.get("__block_descriptor_withcopydispose")); 38585cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall T->startDefinition(); 3859083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3860083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump QualType FieldTypes[] = { 3861083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump UnsignedLongTy, 3862083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump UnsignedLongTy, 3863083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump getPointerType(VoidPtrTy), 3864083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump getPointerType(VoidPtrTy) 3865083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump }; 3866083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3867083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump const char *FieldNames[] = { 3868083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "reserved", 3869083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "Size", 3870083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "CopyFuncPtr", 3871083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "DestroyFuncPtr" 3872083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump }; 3873083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3874083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump for (size_t i = 0; i < 4; ++i) { 3875ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 3876083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump SourceLocation(), 3877083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump &Idents.get(FieldNames[i]), 3878a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 3879083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump /*BitWidth=*/0, 38807a614d8380297fcd2bc23986241905d97222948cRichard Smith /*Mutable=*/false, 38817a614d8380297fcd2bc23986241905d97222948cRichard Smith /*HasInit=*/false); 38822888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 3883083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump T->addDecl(Field); 3884083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump } 3885083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3886838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor T->completeDefinition(); 3887083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3888083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump BlockDescriptorExtendedType = T; 3889083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3890083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump return getTagDeclType(BlockDescriptorExtendedType); 3891083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump} 3892083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 38934ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadbool ASTContext::BlockRequiresCopying(QualType Ty) const { 3894f85e193739c953358c865005855253af4f68a497John McCall if (Ty->isObjCRetainableType()) 3895af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump return true; 3896e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian if (getLangOptions().CPlusPlus) { 3897e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian if (const RecordType *RT = Ty->getAs<RecordType>()) { 3898e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 3899ffe37fdda5b4b4f162a45155c30d9f60ce110c12Sean Hunt return RD->hasConstCopyConstructor(); 3900e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian 3901e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian } 3902e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian } 3903af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump return false; 3904af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump} 3905af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 39064ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 39075f9e272e632e951b1efe824cd16acb4d96077930Chris LattnerASTContext::BuildByRefType(StringRef DeclName, QualType Ty) const { 3908af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // type = struct __Block_byref_1_X { 3909ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // void *__isa; 3910af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // struct __Block_byref_1_X *__forwarding; 3911ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // unsigned int __flags; 3912ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // unsigned int __size; 3913a7e6845660f91ec611427e1db842780e1ec12bdbEli Friedman // void *__copy_helper; // as needed 3914a7e6845660f91ec611427e1db842780e1ec12bdbEli Friedman // void *__destroy_help // as needed 3915af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // int X; 3916ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // } * 3917ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump 3918af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump bool HasCopyAndDispose = BlockRequiresCopying(Ty); 3919af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3920af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // FIXME: Move up 3921f7ccbad5d9949e7ddd1cbef43d482553b811e026Dylan Noblesmith SmallString<36> Name; 3922f5942a44880be26878592eb052b737579349411eBenjamin Kramer llvm::raw_svector_ostream(Name) << "__Block_byref_" << 3923f5942a44880be26878592eb052b737579349411eBenjamin Kramer ++UniqueBlockByRefTypeID << '_' << DeclName; 3924af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump RecordDecl *T; 3925ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara T = CreateRecordDecl(*this, TTK_Struct, TUDecl, &Idents.get(Name.str())); 3926af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump T->startDefinition(); 3927af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump QualType Int32Ty = IntTy; 3928af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump assert(getIntWidth(IntTy) == 32 && "non-32bit int not supported"); 3929af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump QualType FieldTypes[] = { 3930af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(VoidPtrTy), 3931af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(getTagDeclType(T)), 3932af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump Int32Ty, 3933af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump Int32Ty, 3934af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(VoidPtrTy), 3935af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(VoidPtrTy), 3936af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump Ty 3937af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump }; 3938af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 39395f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner StringRef FieldNames[] = { 3940af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__isa", 3941af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__forwarding", 3942af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__flags", 3943af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__size", 3944af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__copy_helper", 3945af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__destroy_helper", 3946af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump DeclName, 3947af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump }; 3948af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3949af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump for (size_t i = 0; i < 7; ++i) { 3950af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump if (!HasCopyAndDispose && i >=4 && i <= 5) 3951af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump continue; 3952af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 3953ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara SourceLocation(), 3954af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump &Idents.get(FieldNames[i]), 3955a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 39567a614d8380297fcd2bc23986241905d97222948cRichard Smith /*BitWidth=*/0, /*Mutable=*/false, 39577a614d8380297fcd2bc23986241905d97222948cRichard Smith /*HasInit=*/false); 39582888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 3959af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump T->addDecl(Field); 3960af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump } 3961af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3962838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor T->completeDefinition(); 3963af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3964af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump return getPointerType(getTagDeclType(T)); 3965ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump} 3966ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump 3967e97179c675b341927807c718be215c8d1aab8acbDouglas GregorTypedefDecl *ASTContext::getObjCInstanceTypeDecl() { 3968e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor if (!ObjCInstanceTypeDecl) 3969e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor ObjCInstanceTypeDecl = TypedefDecl::Create(*this, 3970e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor getTranslationUnitDecl(), 3971e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor SourceLocation(), 3972e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor SourceLocation(), 3973e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor &Idents.get("instancetype"), 3974e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor getTrivialTypeSourceInfo(getObjCIdType())); 3975e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor return ObjCInstanceTypeDecl; 3976e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor} 3977e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor 3978e8c49533521c40643653f943d47229e62d277f88Anders Carlsson// This returns true if a type has been typedefed to BOOL: 3979e8c49533521c40643653f943d47229e62d277f88Anders Carlsson// typedef <type> BOOL; 39802d99833e8c956775f2183601cd120b65b569c867Chris Lattnerstatic bool isTypeTypedefedAsBOOL(QualType T) { 3981e8c49533521c40643653f943d47229e62d277f88Anders Carlsson if (const TypedefType *TT = dyn_cast<TypedefType>(T)) 3982bb49c3ee5d270485f4b273691fd14bc97403fa5dChris Lattner if (IdentifierInfo *II = TT->getDecl()->getIdentifier()) 3983bb49c3ee5d270485f4b273691fd14bc97403fa5dChris Lattner return II->isStr("BOOL"); 39841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 398585f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson return false; 398685f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson} 398785f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson 3988a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek/// getObjCEncodingTypeSize returns size of type for objective-c encoding 398933e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian/// purpose. 39904ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getObjCEncodingTypeSize(QualType type) const { 3991f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor if (!type->isIncompleteArrayType() && type->isIncompleteType()) 3992f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return CharUnits::Zero(); 3993f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 3994199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits sz = getTypeSizeInChars(type); 39951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 399633e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Make all integer and enum types at least as large as an int 39972ade35e2cfd554e49d35a52047cea98a82787af9Douglas Gregor if (sz.isPositive() && type->isIntegralOrEnumerationType()) 3998199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck sz = std::max(sz, getTypeSizeInChars(IntTy)); 399933e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Treat arrays as pointers, since that's how they're passed in. 400033e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian else if (type->isArrayType()) 4001199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck sz = getTypeSizeInChars(VoidPtrTy); 4002aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck return sz; 4003199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck} 4004199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck 4005199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyckstatic inline 4006199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyckstd::string charUnitsToString(const CharUnits &CU) { 4007199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck return llvm::itostr(CU.getQuantity()); 400833e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian} 400933e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian 40106b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall/// getObjCEncodingForBlock - Return the encoded type for this block 40115e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall/// declaration. 40126b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCallstd::string ASTContext::getObjCEncodingForBlock(const BlockExpr *Expr) const { 40136b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall std::string S; 40146b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall 40155e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall const BlockDecl *Decl = Expr->getBlockDecl(); 40165e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall QualType BlockTy = 40175e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall Expr->getType()->getAs<BlockPointerType>()->getPointeeType(); 40185e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Encode result type. 4019c71a4915ca216847599d03cab4ed1c5086b0eb43John McCall getObjCEncodingForType(BlockTy->getAs<FunctionType>()->getResultType(), S); 40205e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Compute size of all parameters. 40215e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Start with computing size of a pointer in number of bytes. 40225e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // FIXME: There might(should) be a better way of doing this computation! 40235e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall SourceLocation Loc; 4024199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy); 4025199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits ParmOffset = PtrSize; 40266f46c2653c1545cc3fef0c0df996d18160160ce8Fariborz Jahanian for (BlockDecl::param_const_iterator PI = Decl->param_begin(), 40275e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall E = Decl->param_end(); PI != E; ++PI) { 40285e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall QualType PType = (*PI)->getType(); 4029aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck CharUnits sz = getObjCEncodingTypeSize(PType); 4030199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck assert (sz.isPositive() && "BlockExpr - Incomplete param type"); 40315e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall ParmOffset += sz; 40325e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall } 40335e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Size of the argument frame 4034199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 40355e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Block pointer and offset. 40365e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall S += "@?0"; 40375e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall 40385e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Argument types. 40395e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall ParmOffset = PtrSize; 40405e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall for (BlockDecl::param_const_iterator PI = Decl->param_begin(), E = 40415e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall Decl->param_end(); PI != E; ++PI) { 40425e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall ParmVarDecl *PVDecl = *PI; 40435e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall QualType PType = PVDecl->getOriginalType(); 40445e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall if (const ArrayType *AT = 40455e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 40465e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Use array's original type only if it has known number of 40475389f48b24937ad7b4093307128b3cbf25235654David Chisnall // elements. 40485389f48b24937ad7b4093307128b3cbf25235654David Chisnall if (!isa<ConstantArrayType>(AT)) 40495389f48b24937ad7b4093307128b3cbf25235654David Chisnall PType = PVDecl->getType(); 40505389f48b24937ad7b4093307128b3cbf25235654David Chisnall } else if (PType->isFunctionType()) 40515389f48b24937ad7b4093307128b3cbf25235654David Chisnall PType = PVDecl->getType(); 40525389f48b24937ad7b4093307128b3cbf25235654David Chisnall getObjCEncodingForType(PType, S); 40535389f48b24937ad7b4093307128b3cbf25235654David Chisnall S += charUnitsToString(ParmOffset); 40545389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmOffset += getObjCEncodingTypeSize(PType); 40555389f48b24937ad7b4093307128b3cbf25235654David Chisnall } 40566b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall 40576b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall return S; 40585389f48b24937ad7b4093307128b3cbf25235654David Chisnall} 40595389f48b24937ad7b4093307128b3cbf25235654David Chisnall 4060f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregorbool ASTContext::getObjCEncodingForFunctionDecl(const FunctionDecl *Decl, 40615389f48b24937ad7b4093307128b3cbf25235654David Chisnall std::string& S) { 40625389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Encode result type. 40635389f48b24937ad7b4093307128b3cbf25235654David Chisnall getObjCEncodingForType(Decl->getResultType(), S); 40645389f48b24937ad7b4093307128b3cbf25235654David Chisnall CharUnits ParmOffset; 40655389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Compute size of all parameters. 40665389f48b24937ad7b4093307128b3cbf25235654David Chisnall for (FunctionDecl::param_const_iterator PI = Decl->param_begin(), 40675389f48b24937ad7b4093307128b3cbf25235654David Chisnall E = Decl->param_end(); PI != E; ++PI) { 40685389f48b24937ad7b4093307128b3cbf25235654David Chisnall QualType PType = (*PI)->getType(); 40695389f48b24937ad7b4093307128b3cbf25235654David Chisnall CharUnits sz = getObjCEncodingTypeSize(PType); 4070f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor if (sz.isZero()) 4071f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return true; 4072f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 40735389f48b24937ad7b4093307128b3cbf25235654David Chisnall assert (sz.isPositive() && 4074f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor "getObjCEncodingForFunctionDecl - Incomplete param type"); 40755389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmOffset += sz; 40765389f48b24937ad7b4093307128b3cbf25235654David Chisnall } 40775389f48b24937ad7b4093307128b3cbf25235654David Chisnall S += charUnitsToString(ParmOffset); 40785389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmOffset = CharUnits::Zero(); 40795389f48b24937ad7b4093307128b3cbf25235654David Chisnall 40805389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Argument types. 40815389f48b24937ad7b4093307128b3cbf25235654David Chisnall for (FunctionDecl::param_const_iterator PI = Decl->param_begin(), 40825389f48b24937ad7b4093307128b3cbf25235654David Chisnall E = Decl->param_end(); PI != E; ++PI) { 40835389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmVarDecl *PVDecl = *PI; 40845389f48b24937ad7b4093307128b3cbf25235654David Chisnall QualType PType = PVDecl->getOriginalType(); 40855389f48b24937ad7b4093307128b3cbf25235654David Chisnall if (const ArrayType *AT = 40865389f48b24937ad7b4093307128b3cbf25235654David Chisnall dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 40875389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Use array's original type only if it has known number of 40885e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // elements. 40895e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall if (!isa<ConstantArrayType>(AT)) 40905e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall PType = PVDecl->getType(); 40915e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall } else if (PType->isFunctionType()) 40925e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall PType = PVDecl->getType(); 40935e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall getObjCEncodingForType(PType, S); 4094199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 4095aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck ParmOffset += getObjCEncodingTypeSize(PType); 40965e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall } 4097f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4098f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return false; 40995e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall} 41005e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall 4101dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson/// getObjCEncodingForMethodParameter - Return the encoded type for a single 4102dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson/// method parameter or return type. If Extended, include class names and 4103dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson/// block object types. 4104dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilsonvoid ASTContext::getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT, 4105dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson QualType T, std::string& S, 4106dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool Extended) const { 4107dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Encode type qualifer, 'in', 'inout', etc. for the parameter. 4108dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeQualifier(QT, S); 4109dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Encode parameter type. 4110dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeImpl(T, S, true, true, 0, 4111dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson true /*OutermostType*/, 4112dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /*EncodingProperty*/, 4113dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /*StructField*/, 4114dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson Extended /*EncodeBlockParameters*/, 4115dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson Extended /*EncodeClassNames*/); 4116dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson} 4117dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson 4118a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek/// getObjCEncodingForMethodDecl - Return the encoded type for this method 411933e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian/// declaration. 4120f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregorbool ASTContext::getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl, 4121dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson std::string& S, 4122dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool Extended) const { 4123c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: This is not very efficient. 4124dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Encode return type. 4125dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForMethodParameter(Decl->getObjCDeclQualifier(), 4126dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson Decl->getResultType(), S, Extended); 412733e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Compute size of all parameters. 412833e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Start with computing size of a pointer in number of bytes. 412933e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // FIXME: There might(should) be a better way of doing this computation! 413033e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian SourceLocation Loc; 4131199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy); 413233e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // The first two arguments (self and _cmd) are pointers; account for 413333e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // their size. 4134199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits ParmOffset = 2 * PtrSize; 4135491306a83c4f0f49f95a3bcbca8580cb98a91c7aArgyrios Kyrtzidis for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(), 41367732cc9c0fdc97a2f8cce4e5933d8103213d1aefFariborz Jahanian E = Decl->sel_param_end(); PI != E; ++PI) { 413789951a86b594513c2a013532ed45d197413b1087Chris Lattner QualType PType = (*PI)->getType(); 4138aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck CharUnits sz = getObjCEncodingTypeSize(PType); 4139f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor if (sz.isZero()) 4140f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return true; 4141f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4142199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck assert (sz.isPositive() && 4143199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck "getObjCEncodingForMethodDecl - Incomplete param type"); 414433e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian ParmOffset += sz; 414533e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian } 4146199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 414733e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian S += "@0:"; 4148199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(PtrSize); 41491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 415033e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Argument types. 415133e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian ParmOffset = 2 * PtrSize; 4152491306a83c4f0f49f95a3bcbca8580cb98a91c7aArgyrios Kyrtzidis for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(), 41537732cc9c0fdc97a2f8cce4e5933d8103213d1aefFariborz Jahanian E = Decl->sel_param_end(); PI != E; ++PI) { 4154491306a83c4f0f49f95a3bcbca8580cb98a91c7aArgyrios Kyrtzidis const ParmVarDecl *PVDecl = *PI; 41551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType PType = PVDecl->getOriginalType(); 41564306d3cb9116605728252e2738df24b9f6ab53c3Fariborz Jahanian if (const ArrayType *AT = 4157ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 4158ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff // Use array's original type only if it has known number of 4159ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff // elements. 4160bb3fde337fb712c0e6da8790d431621be4793048Steve Naroff if (!isa<ConstantArrayType>(AT)) 4161ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff PType = PVDecl->getType(); 4162ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff } else if (PType->isFunctionType()) 4163ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff PType = PVDecl->getType(); 4164dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForMethodParameter(PVDecl->getObjCDeclQualifier(), 4165dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson PType, S, Extended); 4166199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 4167aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck ParmOffset += getObjCEncodingTypeSize(PType); 416833e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian } 4169f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4170f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return false; 417133e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian} 417233e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian 4173c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar/// getObjCEncodingForPropertyDecl - Return the encoded type for this 417483bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// property declaration. If non-NULL, Container must be either an 4175c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar/// ObjCCategoryImplDecl or ObjCImplementationDecl; it should only be 4176c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar/// NULL when getting encodings for protocol properties. 41771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// Property attributes are stored as a comma-delimited C string. The simple 41781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// attributes readonly and bycopy are encoded as single characters. The 41791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// parametrized attributes, getter=name, setter=name, and ivar=name, are 41801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// encoded as single characters, followed by an identifier. Property types 41811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// are also encoded as a parametrized attribute. The characters used to encode 418283bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// these attributes are defined by the following enumeration: 418383bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// @code 418483bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// enum PropertyAttributes { 418583bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyReadOnly = 'R', // property is read-only. 418683bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyBycopy = 'C', // property is a copy of the value last assigned 418783bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyByref = '&', // property is a reference to the value last assigned 418883bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyDynamic = 'D', // property is dynamic 418983bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyGetter = 'G', // followed by getter selector name 419083bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertySetter = 'S', // followed by setter selector name 419183bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyInstanceVariable = 'V' // followed by instance variable name 419283bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyType = 't' // followed by old-style type encoding. 419383bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyWeak = 'W' // 'weak' property 419483bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyStrong = 'P' // property GC'able 419583bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyNonAtomic = 'N' // property non-atomic 419683bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// }; 419783bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// @endcode 41981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid ASTContext::getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD, 4199c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar const Decl *Container, 42004ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad std::string& S) const { 4201c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // Collect information from the property implementation decl(s). 4202c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar bool Dynamic = false; 4203c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar ObjCPropertyImplDecl *SynthesizePID = 0; 4204c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4205c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: Duplicated code due to poor abstraction. 4206c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (Container) { 42071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const ObjCCategoryImplDecl *CID = 4208c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar dyn_cast<ObjCCategoryImplDecl>(Container)) { 4209c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar for (ObjCCategoryImplDecl::propimpl_iterator 421017945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis i = CID->propimpl_begin(), e = CID->propimpl_end(); 4211653f1b1bf293a9bd96fd4dd6372e779cc7af1597Douglas Gregor i != e; ++i) { 4212c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar ObjCPropertyImplDecl *PID = *i; 4213c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyDecl() == PD) { 4214c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) { 4215c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar Dynamic = true; 4216c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 4217c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar SynthesizePID = PID; 4218c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4219c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4220c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4221c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 422261710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner const ObjCImplementationDecl *OID=cast<ObjCImplementationDecl>(Container); 4223c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar for (ObjCCategoryImplDecl::propimpl_iterator 422417945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis i = OID->propimpl_begin(), e = OID->propimpl_end(); 4225653f1b1bf293a9bd96fd4dd6372e779cc7af1597Douglas Gregor i != e; ++i) { 4226c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar ObjCPropertyImplDecl *PID = *i; 4227c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyDecl() == PD) { 4228c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) { 4229c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar Dynamic = true; 4230c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 4231c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar SynthesizePID = PID; 4232c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4233c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 42341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 4235c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4236c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4237c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4238c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: This is not very efficient. 4239c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S = "T"; 4240c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4241c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // Encode result type. 4242090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian // GCC has some special rules regarding encoding of properties which 4243090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian // closely resembles encoding of ivars. 42441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(PD->getType(), S, true, true, 0, 4245090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian true /* outermost type */, 4246090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian true /* encoding for property */); 4247c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4248c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PD->isReadOnly()) { 4249c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",R"; 4250c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 4251c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar switch (PD->getSetterKind()) { 4252c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case ObjCPropertyDecl::Assign: break; 4253c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case ObjCPropertyDecl::Copy: S += ",C"; break; 42541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case ObjCPropertyDecl::Retain: S += ",&"; break; 42553a02b44e3948f7762dbfba94b7961281ca29d022Fariborz Jahanian case ObjCPropertyDecl::Weak: S += ",W"; break; 4256c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4257c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4258c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4259c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // It really isn't clear at all what this means, since properties 4260c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // are "dynamic by default". 4261c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (Dynamic) 4262c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",D"; 4263c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4264090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic) 4265090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian S += ",N"; 42661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4267c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) { 4268c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",G"; 4269077bf5e2f48acfa9e7d69429b6e4ba86ea14896dChris Lattner S += PD->getGetterName().getAsString(); 4270c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4271c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4272c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) { 4273c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",S"; 4274077bf5e2f48acfa9e7d69429b6e4ba86ea14896dChris Lattner S += PD->getSetterName().getAsString(); 4275c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4276c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4277c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (SynthesizePID) { 4278c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar const ObjCIvarDecl *OID = SynthesizePID->getPropertyIvarDecl(); 4279c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",V"; 428039f34e97d6a468f0a7dfa5664c61217cffc65b74Chris Lattner S += OID->getNameAsString(); 4281c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4282c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4283c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: OBJCGC: weak & strong 4284c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar} 4285c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4286a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian/// getLegacyIntegralTypeEncoding - 42871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// Another legacy compatibility encoding: 32-bit longs are encoded as 42881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// 'l' or 'L' , but not always. For typedefs, we need to use 4289a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian/// 'i' or 'I' instead if encoding a struct field, or a pointer! 4290a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian/// 4291a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanianvoid ASTContext::getLegacyIntegralTypeEncoding (QualType &PointeeTy) const { 42928e1fab243ab8023b7ee3899745386b3b3a4258f8Mike Stump if (isa<TypedefType>(PointeeTy.getTypePtr())) { 4293183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const BuiltinType *BT = PointeeTy->getAs<BuiltinType>()) { 42944ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (BT->getKind() == BuiltinType::ULong && getIntWidth(PointeeTy) == 32) 4295a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian PointeeTy = UnsignedIntTy; 42961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump else 42974ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (BT->getKind() == BuiltinType::Long && getIntWidth(PointeeTy) == 32) 4298a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian PointeeTy = IntTy; 4299a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4300a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4301a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian} 4302a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian 43037d6b46d9a9d75dea8ef9f6973dd50633c1f37963Fariborz Jahanianvoid ASTContext::getObjCEncodingForType(QualType T, std::string& S, 43044ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const FieldDecl *Field) const { 430582a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // We follow the behavior of gcc, expanding structures which are 430682a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // directly pointed to, and expanding embedded structures. Note that 430782a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // these rules are sufficient to prevent recursive encoding of the 430882a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // same type. 43091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(T, S, true, true, Field, 43105b8c7d9fb620ba3a71e996d61e7b9bdf763b5c09Fariborz Jahanian true /* outermost type */); 431182a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar} 431282a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar 431364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnallstatic char ObjCEncodingForPrimitiveKind(const ASTContext *C, QualType T) { 431464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall switch (T->getAs<BuiltinType>()->getKind()) { 4315b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Unhandled builtin type kind"); 431664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Void: return 'v'; 431764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Bool: return 'B'; 431864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Char_U: 431964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UChar: return 'C'; 432064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UShort: return 'S'; 432164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UInt: return 'I'; 432264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::ULong: 43234ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad return C->getIntWidth(T) == 32 ? 'L' : 'Q'; 432464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UInt128: return 'T'; 432564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::ULongLong: return 'Q'; 432664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Char_S: 432764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::SChar: return 'c'; 432864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Short: return 's'; 43293f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_S: 43303f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_U: 433164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Int: return 'i'; 433264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Long: 43334ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad return C->getIntWidth(T) == 32 ? 'l' : 'q'; 433464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::LongLong: return 'q'; 433564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Int128: return 't'; 433664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Float: return 'f'; 433764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Double: return 'd'; 43383a0be84b2aed8563150cdbd976a98838afa261ebDaniel Dunbar case BuiltinType::LongDouble: return 'D'; 433964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall } 434064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall} 434164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall 43425471bc85b69912e3b448de004498a80c0de32296Douglas Gregorstatic char ObjCEncodingForEnumType(const ASTContext *C, const EnumType *ET) { 43435471bc85b69912e3b448de004498a80c0de32296Douglas Gregor EnumDecl *Enum = ET->getDecl(); 43445471bc85b69912e3b448de004498a80c0de32296Douglas Gregor 43455471bc85b69912e3b448de004498a80c0de32296Douglas Gregor // The encoding of an non-fixed enum type is always 'i', regardless of size. 43465471bc85b69912e3b448de004498a80c0de32296Douglas Gregor if (!Enum->isFixed()) 43475471bc85b69912e3b448de004498a80c0de32296Douglas Gregor return 'i'; 43485471bc85b69912e3b448de004498a80c0de32296Douglas Gregor 43495471bc85b69912e3b448de004498a80c0de32296Douglas Gregor // The encoding of a fixed enum type matches its fixed underlying type. 43505471bc85b69912e3b448de004498a80c0de32296Douglas Gregor return ObjCEncodingForPrimitiveKind(C, Enum->getIntegerType()); 43515471bc85b69912e3b448de004498a80c0de32296Douglas Gregor} 43525471bc85b69912e3b448de004498a80c0de32296Douglas Gregor 43534ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadstatic void EncodeBitField(const ASTContext *Ctx, std::string& S, 435464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall QualType T, const FieldDecl *FD) { 4355a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith assert(FD->isBitField() && "not a bitfield - getObjCEncodingForTypeImpl"); 43568b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian S += 'b'; 435764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // The NeXT runtime encodes bit fields as b followed by the number of bits. 435864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // The GNU runtime requires more information; bitfields are encoded as b, 435964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // then the offset (in bits) of the first element, then the type of the 436064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // bitfield, then the size in bits. For example, in this structure: 436164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // 436264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // struct 436364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // { 436464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // int integer; 436564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // int flags:2; 436664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // }; 436764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // On a 32-bit system, the encoding for flags would be b2 for the NeXT 436864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // runtime, but b32i2 for the GNU runtime. The reason for this extra 436964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // information is not especially sensible, but we're stuck with it for 437064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // compatibility with GCC, although providing it breaks anything that 437164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // actually uses runtime introspection and wants to work on both runtimes... 437264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall if (!Ctx->getLangOptions().NeXTRuntime) { 437364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall const RecordDecl *RD = FD->getParent(); 437464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall const ASTRecordLayout &RL = Ctx->getASTRecordLayout(RD); 437582905749d5c8d8b4edec11de754a73349cb96603Eli Friedman S += llvm::utostr(RL.getFieldOffset(FD->getFieldIndex())); 43765471bc85b69912e3b448de004498a80c0de32296Douglas Gregor if (const EnumType *ET = T->getAs<EnumType>()) 43775471bc85b69912e3b448de004498a80c0de32296Douglas Gregor S += ObjCEncodingForEnumType(Ctx, ET); 4378c7ff82c2040f45eaad2eddea0e4461dddc972cd1David Chisnall else 43794ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad S += ObjCEncodingForPrimitiveKind(Ctx, T); 438064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall } 4381a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith S += llvm::utostr(FD->getBitWidthValue(*Ctx)); 43828b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian} 43838b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian 438401eb9b9683535d8a65c704ad2c545903409e2d36Daniel Dunbar// FIXME: Use SmallString for accumulating string. 438582a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbarvoid ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S, 438682a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar bool ExpandPointedToStructures, 438782a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar bool ExpandStructures, 4388153bfe5795e2c1a5a738e73d3784964e082237fcDaniel Dunbar const FieldDecl *FD, 4389090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian bool OutermostType, 43902636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis bool EncodingProperty, 4391dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool StructField, 4392dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool EncodeBlockParameters, 4393dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool EncodeClassNames) const { 439464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall if (T->getAs<BuiltinType>()) { 4395ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (FD && FD->isBitField()) 439664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall return EncodeBitField(this, S, T, FD); 439764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall S += ObjCEncodingForPrimitiveKind(this, T); 4398ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4399ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 44001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4401183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ComplexType *CT = T->getAs<ComplexType>()) { 4402c612f7bc9a6379cd7e7c2dd306d05938e890051bAnders Carlsson S += 'j'; 44031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(CT->getElementType(), S, false, false, 0, false, 4404c612f7bc9a6379cd7e7c2dd306d05938e890051bAnders Carlsson false); 4405ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4406ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 440760bce3ef20a4c9684e3825cdd739fefb9810327dFariborz Jahanian 4408aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian // encoding for pointer or r3eference types. 4409aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian QualType PointeeTy; 44106217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const PointerType *PT = T->getAs<PointerType>()) { 44118d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian if (PT->isObjCSelType()) { 44128d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian S += ':'; 44138d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian return; 44148d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian } 4415aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian PointeeTy = PT->getPointeeType(); 4416aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian } 4417aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian else if (const ReferenceType *RT = T->getAs<ReferenceType>()) 4418aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian PointeeTy = RT->getPointeeType(); 4419aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian if (!PointeeTy.isNull()) { 4420a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian bool isReadOnly = false; 4421a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // For historical/compatibility reasons, the read-only qualifier of the 4422a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // pointee gets emitted _before_ the '^'. The read-only qualifier of 4423a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // the pointer itself gets ignored, _unless_ we are looking at a typedef! 44241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Also, do not emit the 'r' for anything but the outermost type! 44258e1fab243ab8023b7ee3899745386b3b3a4258f8Mike Stump if (isa<TypedefType>(T.getTypePtr())) { 4426a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian if (OutermostType && T.isConstQualified()) { 4427a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian isReadOnly = true; 4428a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian S += 'r'; 4429a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 44309fdbab3cbc2fc04bcaf5768023d83707f3151144Mike Stump } else if (OutermostType) { 4431a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian QualType P = PointeeTy; 44326217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek while (P->getAs<PointerType>()) 44336217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek P = P->getAs<PointerType>()->getPointeeType(); 4434a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian if (P.isConstQualified()) { 4435a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian isReadOnly = true; 4436a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian S += 'r'; 4437a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4438a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4439a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian if (isReadOnly) { 4440a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // Another legacy compatibility encoding. Some ObjC qualifier and type 4441a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // combinations need to be rearranged. 4442a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // Rewrite "in const" from "nr" to "rn" 44435f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner if (StringRef(S).endswith("nr")) 44440237941e0beb0c929934b66ad29443b484d987feBenjamin Kramer S.replace(S.end()-2, S.end(), "rn"); 4445a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 44461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 444785f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson if (PointeeTy->isCharType()) { 444885f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson // char pointer types should be encoded as '*' unless it is a 444985f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson // type that has been typedef'd to 'BOOL'. 4450e8c49533521c40643653f943d47229e62d277f88Anders Carlsson if (!isTypeTypedefedAsBOOL(PointeeTy)) { 445185f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson S += '*'; 445285f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson return; 445385f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson } 44546217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek } else if (const RecordType *RTy = PointeeTy->getAs<RecordType>()) { 44559533a7fdb8397421f3be52e879442460a87389f6Steve Naroff // GCC binary compat: Need to convert "struct objc_class *" to "#". 44569533a7fdb8397421f3be52e879442460a87389f6Steve Naroff if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_class")) { 44579533a7fdb8397421f3be52e879442460a87389f6Steve Naroff S += '#'; 44589533a7fdb8397421f3be52e879442460a87389f6Steve Naroff return; 44599533a7fdb8397421f3be52e879442460a87389f6Steve Naroff } 44609533a7fdb8397421f3be52e879442460a87389f6Steve Naroff // GCC binary compat: Need to convert "struct objc_object *" to "@". 44619533a7fdb8397421f3be52e879442460a87389f6Steve Naroff if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_object")) { 44629533a7fdb8397421f3be52e879442460a87389f6Steve Naroff S += '@'; 44639533a7fdb8397421f3be52e879442460a87389f6Steve Naroff return; 44649533a7fdb8397421f3be52e879442460a87389f6Steve Naroff } 44659533a7fdb8397421f3be52e879442460a87389f6Steve Naroff // fall through... 446685f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson } 446785f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson S += '^'; 4468a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian getLegacyIntegralTypeEncoding(PointeeTy); 4469a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian 44701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(PointeeTy, S, false, ExpandPointedToStructures, 447143822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian NULL); 4472ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4473ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 4474aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian 4475ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (const ArrayType *AT = 4476ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner // Ignore type qualifiers etc. 4477ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner dyn_cast<ArrayType>(T->getCanonicalTypeInternal())) { 44782636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (isa<IncompleteArrayType>(AT) && !StructField) { 4479559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson // Incomplete arrays are encoded as a pointer to the array element. 4480559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += '^'; 4481559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson 44821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(AT->getElementType(), S, 4483559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson false, ExpandStructures, FD); 4484559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson } else { 4485559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += '['; 44861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 44872636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) { 44882636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (getTypeSize(CAT->getElementType()) == 0) 44892636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '0'; 44902636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis else 44912636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += llvm::utostr(CAT->getSize().getZExtValue()); 44922636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 4493559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson //Variable length arrays are encoded as a regular array with 0 elements. 44942636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert((isa<VariableArrayType>(AT) || isa<IncompleteArrayType>(AT)) && 44952636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis "Unknown array type!"); 4496559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += '0'; 4497559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson } 44981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 44991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(AT->getElementType(), S, 4500559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson false, ExpandStructures, FD); 4501559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += ']'; 4502559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson } 4503ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4504ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 45051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4506183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (T->getAs<FunctionType>()) { 4507c0a87b7db06643178ad2cbce0767548c139ea387Anders Carlsson S += '?'; 4508ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4509ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 45101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45116217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const RecordType *RTy = T->getAs<RecordType>()) { 451282a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar RecordDecl *RDecl = RTy->getDecl(); 4513d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar S += RDecl->isUnion() ? '(' : '{'; 4514502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar // Anonymous structures print as '?' 4515502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar if (const IdentifierInfo *II = RDecl->getIdentifier()) { 4516502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar S += II->getName(); 45176fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian if (ClassTemplateSpecializationDecl *Spec 45186fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian = dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) { 45196fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 45206fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian std::string TemplateArgsStr 45216fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian = TemplateSpecializationType::PrintTemplateArgumentList( 4522910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgs.data(), 4523910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgs.size(), 452430c42404202d2e2512e51efc6066bd614cfdb5a4Douglas Gregor (*this).getPrintingPolicy()); 45256fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian 45266fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian S += TemplateArgsStr; 45276fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian } 4528502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar } else { 4529502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar S += '?'; 4530502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar } 45310d504c1da852e58ff802545c823ecff3b6c654b8Daniel Dunbar if (ExpandStructures) { 45327d6b46d9a9d75dea8ef9f6973dd50633c1f37963Fariborz Jahanian S += '='; 45332636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!RDecl->isUnion()) { 45342636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForStructureImpl(RDecl, S, FD); 45352636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 45362636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (RecordDecl::field_iterator Field = RDecl->field_begin(), 45372636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldEnd = RDecl->field_end(); 45382636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis Field != FieldEnd; ++Field) { 45392636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (FD) { 45402636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 45412636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += Field->getNameAsString(); 45422636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 45432636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 45441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45452636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // Special case bit-fields. 45462636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (Field->isBitField()) { 45472636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForTypeImpl(Field->getType(), S, false, true, 45482636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis (*Field)); 45492636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 45502636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis QualType qt = Field->getType(); 45512636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getLegacyIntegralTypeEncoding(qt); 45522636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForTypeImpl(qt, S, false, true, 45532636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FD, /*OutermostType*/false, 45542636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*EncodingProperty*/false, 45552636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*StructField*/true); 45562636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 4557d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar } 45587d6b46d9a9d75dea8ef9f6973dd50633c1f37963Fariborz Jahanian } 45596de88a873a4cbe06d72602eef57d68006730a80bFariborz Jahanian } 4560d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar S += RDecl->isUnion() ? ')' : '}'; 4561ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4562ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 4563e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian 45645471bc85b69912e3b448de004498a80c0de32296Douglas Gregor if (const EnumType *ET = T->getAs<EnumType>()) { 45658b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian if (FD && FD->isBitField()) 456664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall EncodeBitField(this, S, T, FD); 45678b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian else 45685471bc85b69912e3b448de004498a80c0de32296Douglas Gregor S += ObjCEncodingForEnumType(this, ET); 4569ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4570ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 45711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4572dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (const BlockPointerType *BT = T->getAs<BlockPointerType>()) { 457321a98b188857d690aa4510c52ac4317ffa0908a8Steve Naroff S += "@?"; // Unlike a pointer-to-function, which is "^?". 4574dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (EncodeBlockParameters) { 4575dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson const FunctionType *FT = BT->getPointeeType()->getAs<FunctionType>(); 4576dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson 4577dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson S += '<'; 4578dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Block return type 4579dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeImpl(FT->getResultType(), S, 4580dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson ExpandPointedToStructures, ExpandStructures, 4581dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson FD, 4582dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* OutermostType */, 4583dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodingProperty, 4584dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* StructField */, 4585dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeBlockParameters, 4586dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeClassNames); 4587dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Block self 4588dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson S += "@?"; 4589dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Block parameters 4590dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FT)) { 4591dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson for (FunctionProtoType::arg_type_iterator I = FPT->arg_type_begin(), 4592dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson E = FPT->arg_type_end(); I && (I != E); ++I) { 4593dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeImpl(*I, S, 4594dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson ExpandPointedToStructures, 4595dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson ExpandStructures, 4596dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson FD, 4597dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* OutermostType */, 4598dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodingProperty, 4599dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* StructField */, 4600dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeBlockParameters, 4601dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeClassNames); 4602dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson } 4603dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson } 4604dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson S += '>'; 4605dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson } 4606ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4607ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4609c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Ignore protocol qualifiers when mangling at this level. 4610c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OT = T->getAs<ObjCObjectType>()) 4611c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall T = OT->getBaseType(); 4612c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 46130953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (const ObjCInterfaceType *OIT = T->getAs<ObjCInterfaceType>()) { 461443822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian // @encode(class_name) 46150953e767ff7817f97b3ab20896b229891eeff45bJohn McCall ObjCInterfaceDecl *OI = OIT->getDecl(); 461643822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += '{'; 461743822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian const IdentifierInfo *II = OI->getIdentifier(); 461843822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += II->getName(); 461943822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += '='; 4620db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose SmallVector<const ObjCIvarDecl*, 32> Ivars; 46212c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian DeepCollectObjCIvars(OI, true, Ivars); 46222c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian for (unsigned i = 0, e = Ivars.size(); i != e; ++i) { 4623db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose const FieldDecl *Field = cast<FieldDecl>(Ivars[i]); 46242c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian if (Field->isBitField()) 46252c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian getObjCEncodingForTypeImpl(Field->getType(), S, false, true, Field); 462643822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian else 46272c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian getObjCEncodingForTypeImpl(Field->getType(), S, false, true, FD); 462843822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian } 462943822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += '}'; 4630ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 463143822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian } 46321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4633183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ObjCObjectPointerType *OPT = T->getAs<ObjCObjectPointerType>()) { 463414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (OPT->isObjCIdType()) { 463514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '@'; 463614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 4637ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 463927d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) { 464027d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff // FIXME: Consider if we need to output qualifiers for 'Class<p>'. 464127d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff // Since this is a binary compatibility issue, need to consult with runtime 464227d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff // folks. Fortunately, this is a *very* obsure construct. 464314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '#'; 464414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 4645ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4647ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (OPT->isObjCQualifiedIdType()) { 46481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(getObjCIdType(), S, 464914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff ExpandPointedToStructures, 465014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff ExpandStructures, FD); 4651dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (FD || EncodingProperty || EncodeClassNames) { 465214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff // Note that we do extended encoding of protocol qualifer list 465314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff // Only when doing ivar or property encoding. 465414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '"'; 465567ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(), 465667ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff E = OPT->qual_end(); I != E; ++I) { 465714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '<'; 465814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += (*I)->getNameAsString(); 465914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '>'; 466014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 466114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '"'; 466214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 466314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 4664ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4666ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner QualType PointeeTy = OPT->getPointeeType(); 4667ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (!EncodingProperty && 4668ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner isa<TypedefType>(PointeeTy.getTypePtr())) { 4669ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner // Another historical/compatibility reason. 46701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // We encode the underlying type which comes out as 4671ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner // {...}; 4672ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '^'; 46731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(PointeeTy, S, 46741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump false, ExpandPointedToStructures, 4675ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner NULL); 467614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 467714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 4678ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner 4679ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '@'; 4680dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (OPT->getInterfaceDecl() && 4681dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson (FD || EncodingProperty || EncodeClassNames)) { 4682ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '"'; 468327d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff S += OPT->getInterfaceDecl()->getIdentifier()->getName(); 468467ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(), 468567ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff E = OPT->qual_end(); I != E; ++I) { 4686ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '<'; 4687ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += (*I)->getNameAsString(); 4688ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '>'; 46891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 4690ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '"'; 4691ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 4692ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4693ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4695532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall // gcc just blithely ignores member pointers. 4696532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall // TODO: maybe there should be a mangling for these 4697532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall if (T->getAs<MemberPointerType>()) 4698532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall return; 4699e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian 4700e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian if (T->isVectorType()) { 4701e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian // This matches gcc's encoding, even though technically it is 4702e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian // insufficient. 4703e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian // FIXME. We should do a better job than gcc. 4704e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian return; 4705e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian } 4706e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian 4707b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("@encode for type not implemented!"); 470885f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson} 470985f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson 47102636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidisvoid ASTContext::getObjCEncodingForStructureImpl(RecordDecl *RDecl, 47112636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::string &S, 47122636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis const FieldDecl *FD, 47132636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis bool includeVBases) const { 47142636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert(RDecl && "Expected non-null RecordDecl"); 47152636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert(!RDecl->isUnion() && "Should not be called for unions"); 47162636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!RDecl->getDefinition()) 47172636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis return; 47182636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47192636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CXXRecordDecl *CXXRec = dyn_cast<CXXRecordDecl>(RDecl); 47202636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::multimap<uint64_t, NamedDecl *> FieldOrBaseOffsets; 47212636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis const ASTRecordLayout &layout = getASTRecordLayout(RDecl); 47222636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47232636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRec) { 47242636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (CXXRecordDecl::base_class_iterator 47252636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BI = CXXRec->bases_begin(), 47262636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BE = CXXRec->bases_end(); BI != BE; ++BI) { 47272636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!BI->isVirtual()) { 47282636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CXXRecordDecl *base = BI->getType()->getAsCXXRecordDecl(); 4729829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis if (base->isEmpty()) 4730829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis continue; 47312636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = layout.getBaseClassOffsetInBits(base); 47322636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs), 47332636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::make_pair(offs, base)); 47342636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47352636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47362636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47372636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47382636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis unsigned i = 0; 47392636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (RecordDecl::field_iterator Field = RDecl->field_begin(), 47402636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldEnd = RDecl->field_end(); 47412636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis Field != FieldEnd; ++Field, ++i) { 47422636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = layout.getFieldOffset(i); 47432636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs), 47442636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::make_pair(offs, *Field)); 47452636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47462636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47472636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRec && includeVBases) { 47482636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (CXXRecordDecl::base_class_iterator 47492636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BI = CXXRec->vbases_begin(), 47502636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BE = CXXRec->vbases_end(); BI != BE; ++BI) { 47512636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CXXRecordDecl *base = BI->getType()->getAsCXXRecordDecl(); 4752829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis if (base->isEmpty()) 4753829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis continue; 47542636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = layout.getVBaseClassOffsetInBits(base); 475519aa8609a5d04eed9b81aa1c4608e8a4f3df6ccdArgyrios Kyrtzidis if (FieldOrBaseOffsets.find(offs) == FieldOrBaseOffsets.end()) 475619aa8609a5d04eed9b81aa1c4608e8a4f3df6ccdArgyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.end(), 475719aa8609a5d04eed9b81aa1c4608e8a4f3df6ccdArgyrios Kyrtzidis std::make_pair(offs, base)); 47582636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47592636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47602636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47612636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CharUnits size; 47622636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRec) { 47632636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis size = includeVBases ? layout.getSize() : layout.getNonVirtualSize(); 47642636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 47652636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis size = layout.getSize(); 47662636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47672636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47682636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t CurOffs = 0; 47692636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::multimap<uint64_t, NamedDecl *>::iterator 47702636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurLayObj = FieldOrBaseOffsets.begin(); 47712636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 4772cb8061e321bc6f46f154529885028256c7ae1fb2Argyrios Kyrtzidis if ((CurLayObj != FieldOrBaseOffsets.end() && CurLayObj->first != 0) || 4773cb8061e321bc6f46f154529885028256c7ae1fb2Argyrios Kyrtzidis (CurLayObj == FieldOrBaseOffsets.end() && 4774cb8061e321bc6f46f154529885028256c7ae1fb2Argyrios Kyrtzidis CXXRec && CXXRec->isDynamicClass())) { 47752636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert(CXXRec && CXXRec->isDynamicClass() && 47762636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis "Offset 0 was empty but no VTable ?"); 47772636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (FD) { 47782636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += "\"_vptr$"; 47792636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::string recname = CXXRec->getNameAsString(); 47802636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (recname.empty()) recname = "?"; 47812636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += recname; 47822636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 47832636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47842636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += "^^?"; 47852636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurOffs += getTypeSize(VoidPtrTy); 47862636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47872636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47882636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!RDecl->hasFlexibleArrayMember()) { 47892636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // Mark the end of the structure. 47902636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = toBits(size); 47912636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs), 47922636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::make_pair(offs, (NamedDecl*)0)); 47932636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47942636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47952636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (; CurLayObj != FieldOrBaseOffsets.end(); ++CurLayObj) { 47962636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert(CurOffs <= CurLayObj->first); 47972636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47982636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CurOffs < CurLayObj->first) { 47992636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t padding = CurLayObj->first - CurOffs; 48002636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // FIXME: There doesn't seem to be a way to indicate in the encoding that 48012636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // packing/alignment of members is different that normal, in which case 48022636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // the encoding will be out-of-sync with the real layout. 48032636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // If the runtime switches to just consider the size of types without 48042636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // taking into account alignment, we could make padding explicit in the 48052636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // encoding (e.g. using arrays of chars). The encoding strings would be 48062636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // longer then though. 48072636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurOffs += padding; 48082636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48092636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48102636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis NamedDecl *dcl = CurLayObj->second; 48112636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (dcl == 0) 48122636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis break; // reached end of structure. 48132636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48142636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRecordDecl *base = dyn_cast<CXXRecordDecl>(dcl)) { 48152636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // We expand the bases without their virtual bases since those are going 48162636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // in the initial structure. Note that this differs from gcc which 48172636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // expands virtual bases each time one is encountered in the hierarchy, 48182636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // making the encoding type bigger than it really is. 48192636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForStructureImpl(base, S, FD, /*includeVBases*/false); 4820829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis assert(!base->isEmpty()); 4821829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis CurOffs += toBits(getASTRecordLayout(base).getNonVirtualSize()); 48222636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 48232636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldDecl *field = cast<FieldDecl>(dcl); 48242636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (FD) { 48252636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 48262636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += field->getNameAsString(); 48272636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 48282636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48292636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48302636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (field->isBitField()) { 48312636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis EncodeBitField(this, S, field->getType(), field); 4832a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith CurOffs += field->getBitWidthValue(*this); 48332636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 48342636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis QualType qt = field->getType(); 48352636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getLegacyIntegralTypeEncoding(qt); 48362636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForTypeImpl(qt, S, false, true, FD, 48372636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*OutermostType*/false, 48382636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*EncodingProperty*/false, 48392636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*StructField*/true); 48402636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurOffs += getTypeSize(field->getType()); 48412636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48422636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48432636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48442636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis} 48452636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT, 4847ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian std::string& S) const { 4848ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_In) 4849ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'n'; 4850ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Inout) 4851ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'N'; 4852ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Out) 4853ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'o'; 4854ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Bycopy) 4855ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'O'; 4856ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Byref) 4857ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'R'; 4858ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Oneway) 4859ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'V'; 4860ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian} 4861ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian 4862ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattnervoid ASTContext::setBuiltinVaListType(QualType T) { 4863b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson assert(BuiltinVaListType.isNull() && "__builtin_va_list type already set!"); 48641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4865b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson BuiltinVaListType = T; 4866b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson} 4867b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson 48684dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas GregorTypedefDecl *ASTContext::getObjCIdDecl() const { 48694dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor if (!ObjCIdDecl) { 48704dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor QualType T = getObjCObjectType(ObjCBuiltinIdTy, 0, 0); 48714dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor T = getObjCObjectPointerType(T); 48724dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor TypeSourceInfo *IdInfo = getTrivialTypeSourceInfo(T); 48734dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor ObjCIdDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 48744dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor getTranslationUnitDecl(), 48754dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor SourceLocation(), SourceLocation(), 48764dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor &Idents.get("id"), IdInfo); 48774dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor } 48784dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor 48794dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor return ObjCIdDecl; 48807e219e47de26346885d667131977bd9ca2d7662aSteve Naroff} 48817e219e47de26346885d667131977bd9ca2d7662aSteve Naroff 48827a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas GregorTypedefDecl *ASTContext::getObjCSelDecl() const { 48837a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor if (!ObjCSelDecl) { 48847a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor QualType SelT = getPointerType(ObjCBuiltinSelTy); 48857a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor TypeSourceInfo *SelInfo = getTrivialTypeSourceInfo(SelT); 48867a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor ObjCSelDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 48877a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor getTranslationUnitDecl(), 48887a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor SourceLocation(), SourceLocation(), 48897a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor &Idents.get("SEL"), SelInfo); 48907a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor } 48917a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor return ObjCSelDecl; 4892b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian} 4893b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian 489479d6726921897811232554ed94c5d77b5b7b3fc0Douglas GregorTypedefDecl *ASTContext::getObjCClassDecl() const { 489579d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor if (!ObjCClassDecl) { 489679d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor QualType T = getObjCObjectType(ObjCBuiltinClassTy, 0, 0); 489779d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor T = getObjCObjectPointerType(T); 489879d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor TypeSourceInfo *ClassInfo = getTrivialTypeSourceInfo(T); 489979d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor ObjCClassDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 490079d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor getTranslationUnitDecl(), 490179d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor SourceLocation(), SourceLocation(), 490279d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor &Idents.get("Class"), ClassInfo); 490379d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor } 490479d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor 490579d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor return ObjCClassDecl; 4906a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor} 4907a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor 4908a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas GregorObjCInterfaceDecl *ASTContext::getObjCProtocolDecl() const { 4909a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor if (!ObjCProtocolClassDecl) { 4910a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor ObjCProtocolClassDecl 4911a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor = ObjCInterfaceDecl::Create(*this, getTranslationUnitDecl(), 4912a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor SourceLocation(), 4913a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor &Idents.get("Protocol"), 4914a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor /*PrevDecl=*/0, 4915a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor SourceLocation(), true); 4916a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor } 4917a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor 4918a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor return ObjCProtocolClassDecl; 49198baaca50f07d0c10bba69c8d88c1b9078c92d06dAnders Carlsson} 49208baaca50f07d0c10bba69c8d88c1b9078c92d06dAnders Carlsson 4921a526c5c67e5a0473c340903ee542ce570119665fTed Kremenekvoid ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) { 49221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(ObjCConstantStringType.isNull() && 49232198891824c38d45b2279de5d5e3ef9394eb457cSteve Naroff "'NSConstantString' type already set!"); 49241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4925a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCConstantStringType = getObjCInterfaceType(Decl); 49262198891824c38d45b2279de5d5e3ef9394eb457cSteve Naroff} 49272198891824c38d45b2279de5d5e3ef9394eb457cSteve Naroff 49280bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall/// \brief Retrieve the template name that corresponds to a non-empty 49290bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall/// lookup. 49304ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName 49314ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getOverloadedTemplateName(UnresolvedSetIterator Begin, 49324ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad UnresolvedSetIterator End) const { 49330bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall unsigned size = End - Begin; 49340bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall assert(size > 1 && "set is not overloaded!"); 49357532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 49360bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall void *memory = Allocate(sizeof(OverloadedTemplateStorage) + 49370bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall size * sizeof(FunctionTemplateDecl*)); 49380bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall OverloadedTemplateStorage *OT = new(memory) OverloadedTemplateStorage(size); 49390bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall 49400bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall NamedDecl **Storage = OT->getStorage(); 4941eec51cf1ba5f0e62c9cdb81b5c63babdd6e649abJohn McCall for (UnresolvedSetIterator I = Begin; I != End; ++I) { 49420bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall NamedDecl *D = *I; 49430bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall assert(isa<FunctionTemplateDecl>(D) || 49440bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall (isa<UsingShadowDecl>(D) && 49450bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall isa<FunctionTemplateDecl>(D->getUnderlyingDecl()))); 49460bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall *Storage++ = D; 49477532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor } 49487532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 49490bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall return TemplateName(OT); 49507532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor} 49517532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 4952d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor/// \brief Retrieve the template name that represents a qualified 4953d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor/// template name such as \c std::vector. 49544ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName 49554ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS, 49564ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad bool TemplateKeyword, 49574ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad TemplateDecl *Template) const { 49580f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor assert(NNS && "Missing nested-name-specifier in qualified template name"); 49590f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor 4960789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor // FIXME: Canonicalization? 4961d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor llvm::FoldingSetNodeID ID; 4962d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template); 49631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4964d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor void *InsertPos = 0; 4965d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QualifiedTemplateName *QTN = 49660bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 4967d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor if (!QTN) { 4968d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QTN = new (*this,4) QualifiedTemplateName(NNS, TemplateKeyword, Template); 4969d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QualifiedTemplateNames.InsertNode(QTN, InsertPos); 4970d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor } 49711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4972d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor return TemplateName(QTN); 4973d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor} 4974d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor 49757532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor/// \brief Retrieve the template name that represents a dependent 49767532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor/// template name such as \c MetaFun::template apply. 49774ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName 49784ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getDependentTemplateName(NestedNameSpecifier *NNS, 49794ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const IdentifierInfo *Name) const { 49801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert((!NNS || NNS->isDependent()) && 49813b6afbb99a1c44b4076f8e15fb7311405941b306Douglas Gregor "Nested name specifier must be dependent"); 49827532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 49837532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor llvm::FoldingSetNodeID ID; 49847532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateName::Profile(ID, NNS, Name); 49857532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 49867532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor void *InsertPos = 0; 49877532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateName *QTN = 49887532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 49897532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 49907532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor if (QTN) 49917532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor return TemplateName(QTN); 49927532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 49937532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 49947532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor if (CanonNNS == NNS) { 49957532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Name); 49967532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor } else { 49977532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor TemplateName Canon = getDependentTemplateName(CanonNNS, Name); 49987532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Name, Canon); 4999789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateName *CheckQTN = 5000789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 5001789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!CheckQTN && "Dependent type name canonicalization broken"); 5002789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CheckQTN; 50037532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor } 50047532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 50057532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateNames.InsertNode(QTN, InsertPos); 50067532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor return TemplateName(QTN); 50077532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor} 50087532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 5009ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor/// \brief Retrieve the template name that represents a dependent 5010ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor/// template name such as \c MetaFun::template operator+. 5011ca1bdd7c269a2390d43c040a60511edd017ee130Douglas GregorTemplateName 5012ca1bdd7c269a2390d43c040a60511edd017ee130Douglas GregorASTContext::getDependentTemplateName(NestedNameSpecifier *NNS, 50134ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad OverloadedOperatorKind Operator) const { 5014ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor assert((!NNS || NNS->isDependent()) && 5015ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor "Nested name specifier must be dependent"); 5016ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5017ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor llvm::FoldingSetNodeID ID; 5018ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor DependentTemplateName::Profile(ID, NNS, Operator); 5019ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5020ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor void *InsertPos = 0; 5021789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateName *QTN 5022789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 5023ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5024ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor if (QTN) 5025ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor return TemplateName(QTN); 5026ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5027ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 5028ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor if (CanonNNS == NNS) { 5029ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Operator); 5030ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor } else { 5031ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor TemplateName Canon = getDependentTemplateName(CanonNNS, Operator); 5032ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Operator, Canon); 5033789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 5034789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateName *CheckQTN 5035789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 5036789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!CheckQTN && "Dependent template name canonicalization broken"); 5037789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CheckQTN; 5038ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor } 5039ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5040ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor DependentTemplateNames.InsertNode(QTN, InsertPos); 5041ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor return TemplateName(QTN); 5042ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor} 5043ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 50441aee05d08b2184acadeb36de300e216390780d6cDouglas GregorTemplateName 5045146060435c3efce95c95a092c7a1eb651cfb9ae0John McCallASTContext::getSubstTemplateTemplateParm(TemplateTemplateParmDecl *param, 5046146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateName replacement) const { 5047146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm::FoldingSetNodeID ID; 5048146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage::Profile(ID, param, replacement); 5049146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5050146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall void *insertPos = 0; 5051146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage *subst 5052146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = SubstTemplateTemplateParms.FindNodeOrInsertPos(ID, insertPos); 5053146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5054146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall if (!subst) { 5055146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall subst = new (*this) SubstTemplateTemplateParmStorage(param, replacement); 5056146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParms.InsertNode(subst, insertPos); 5057146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 5058146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5059146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return TemplateName(subst); 5060146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall} 5061146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5062146060435c3efce95c95a092c7a1eb651cfb9ae0John McCallTemplateName 50631aee05d08b2184acadeb36de300e216390780d6cDouglas GregorASTContext::getSubstTemplateTemplateParmPack(TemplateTemplateParmDecl *Param, 50641aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor const TemplateArgument &ArgPack) const { 50651aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor ASTContext &Self = const_cast<ASTContext &>(*this); 50661aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor llvm::FoldingSetNodeID ID; 50671aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor SubstTemplateTemplateParmPackStorage::Profile(ID, Self, Param, ArgPack); 50681aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 50691aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor void *InsertPos = 0; 50701aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor SubstTemplateTemplateParmPackStorage *Subst 50711aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor = SubstTemplateTemplateParmPacks.FindNodeOrInsertPos(ID, InsertPos); 50721aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 50731aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor if (!Subst) { 5074146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall Subst = new (*this) SubstTemplateTemplateParmPackStorage(Param, 50751aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor ArgPack.pack_size(), 50761aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor ArgPack.pack_begin()); 50771aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor SubstTemplateTemplateParmPacks.InsertNode(Subst, InsertPos); 50781aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor } 50791aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 50801aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor return TemplateName(Subst); 50811aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor} 50821aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 5083b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor/// getFromTargetType - Given one of the integer types provided by 5084d934112e6170b0fd940d8e40db6936cea2cdcf62Douglas Gregor/// TargetInfo, produce the corresponding type. The unsigned @p Type 5085d934112e6170b0fd940d8e40db6936cea2cdcf62Douglas Gregor/// is actually a value of type @c TargetInfo::IntType. 5086e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCallCanQualType ASTContext::getFromTargetType(unsigned Type) const { 5087b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor switch (Type) { 5088e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCall case TargetInfo::NoInt: return CanQualType(); 5089b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedShort: return ShortTy; 5090b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedShort: return UnsignedShortTy; 5091b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedInt: return IntTy; 5092b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedInt: return UnsignedIntTy; 5093b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedLong: return LongTy; 5094b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedLong: return UnsignedLongTy; 5095b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedLongLong: return LongLongTy; 5096b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedLongLong: return UnsignedLongLongTy; 5097b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor } 5098b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor 5099b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unhandled TargetInfo::IntType value"); 5100b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor} 5101b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek 5102b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek//===----------------------------------------------------------------------===// 5103b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek// Type Predicates. 5104b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek//===----------------------------------------------------------------------===// 5105b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek 51064fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian/// getObjCGCAttr - Returns one of GCNone, Weak or Strong objc's 51074fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian/// garbage collection attribute. 51084fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian/// 5109ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCallQualifiers::GC ASTContext::getObjCGCAttrKind(QualType Ty) const { 5110e289d81369914678db386f6aa86faf8f178e245dDouglas Gregor if (getLangOptions().getGC() == LangOptions::NonGC) 5111ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall return Qualifiers::GCNone; 5112ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall 5113ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall assert(getLangOptions().ObjC1); 5114ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall Qualifiers::GC GCAttrs = Ty.getObjCGCAttr(); 5115ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall 5116ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // Default behaviour under objective-C's gc is for ObjC pointers 5117ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // (or pointers to them) be treated as though they were declared 5118ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // as __strong. 5119ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall if (GCAttrs == Qualifiers::GCNone) { 5120ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType()) 5121ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall return Qualifiers::Strong; 5122ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall else if (Ty->isPointerType()) 5123ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall return getObjCGCAttrKind(Ty->getAs<PointerType>()->getPointeeType()); 5124ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall } else { 5125ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // It's not valid to set GC attributes on anything that isn't a 5126ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // pointer. 5127ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall#ifndef NDEBUG 5128ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall QualType CT = Ty->getCanonicalTypeInternal(); 5129ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall while (const ArrayType *AT = dyn_cast<ArrayType>(CT)) 5130ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall CT = AT->getElementType(); 5131ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall assert(CT->isAnyPointerType() || CT->isBlockPointerType()); 5132ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall#endif 51334fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian } 5134b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris Lattner return GCAttrs; 51354fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian} 51364fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian 51376ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner//===----------------------------------------------------------------------===// 51386ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner// Type Compatibility Testing 51396ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner//===----------------------------------------------------------------------===// 5140770951b5bb6028a8d326ddb4a13cef7d4a128162Chris Lattner 51411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// areCompatVectorTypes - Return true if the two specified vector types are 51426ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner/// compatible. 51436ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattnerstatic bool areCompatVectorTypes(const VectorType *LHS, 51446ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner const VectorType *RHS) { 5145467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified()); 51466ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner return LHS->getElementType() == RHS->getElementType() && 514761710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner LHS->getNumElements() == RHS->getNumElements(); 51486ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner} 51496ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner 5150255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregorbool ASTContext::areCompatibleVectorTypes(QualType FirstVec, 5151255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor QualType SecondVec) { 5152255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor assert(FirstVec->isVectorType() && "FirstVec should be a vector type"); 5153255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor assert(SecondVec->isVectorType() && "SecondVec should be a vector type"); 5154255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 5155255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor if (hasSameUnqualifiedType(FirstVec, SecondVec)) 5156255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor return true; 5157255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 5158f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson // Treat Neon vector types and most AltiVec vector types as if they are the 5159f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson // equivalent GCC vector types. 5160255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor const VectorType *First = FirstVec->getAs<VectorType>(); 5161255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor const VectorType *Second = SecondVec->getAs<VectorType>(); 5162f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson if (First->getNumElements() == Second->getNumElements() && 5163255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor hasSameType(First->getElementType(), Second->getElementType()) && 5164f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson First->getVectorKind() != VectorType::AltiVecPixel && 5165f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson First->getVectorKind() != VectorType::AltiVecBool && 5166f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson Second->getVectorKind() != VectorType::AltiVecPixel && 5167f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson Second->getVectorKind() != VectorType::AltiVecBool) 5168255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor return true; 5169255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 5170255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor return false; 5171255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor} 5172255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 51734084c306635b70f37029dca938444e6013f08684Steve Naroff//===----------------------------------------------------------------------===// 51744084c306635b70f37029dca938444e6013f08684Steve Naroff// ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's. 51754084c306635b70f37029dca938444e6013f08684Steve Naroff//===----------------------------------------------------------------------===// 51764084c306635b70f37029dca938444e6013f08684Steve Naroff 51774084c306635b70f37029dca938444e6013f08684Steve Naroff/// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the 51784084c306635b70f37029dca938444e6013f08684Steve Naroff/// inheritance hierarchy of 'rProto'. 51794ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadbool 51804ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto, 51814ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad ObjCProtocolDecl *rProto) const { 51823fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor if (declaresSameEntity(lProto, rProto)) 518314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return true; 51844084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCProtocolDecl::protocol_iterator PI = rProto->protocol_begin(), 51854084c306635b70f37029dca938444e6013f08684Steve Naroff E = rProto->protocol_end(); PI != E; ++PI) 51864084c306635b70f37029dca938444e6013f08684Steve Naroff if (ProtocolCompatibleWithProtocol(lProto, *PI)) 51874084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 51884084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 51894084c306635b70f37029dca938444e6013f08684Steve Naroff} 519014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 51914084c306635b70f37029dca938444e6013f08684Steve Naroff/// QualifiedIdConformsQualifiedId - compare id<p,...> with id<p1,...> 51924084c306635b70f37029dca938444e6013f08684Steve Naroff/// return true if lhs's protocols conform to rhs's protocol; false 51934084c306635b70f37029dca938444e6013f08684Steve Naroff/// otherwise. 51944084c306635b70f37029dca938444e6013f08684Steve Naroffbool ASTContext::QualifiedIdConformsQualifiedId(QualType lhs, QualType rhs) { 51954084c306635b70f37029dca938444e6013f08684Steve Naroff if (lhs->isObjCQualifiedIdType() && rhs->isObjCQualifiedIdType()) 51964084c306635b70f37029dca938444e6013f08684Steve Naroff return ObjCQualifiedIdTypesAreCompatible(lhs, rhs, false); 51974084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 51984084c306635b70f37029dca938444e6013f08684Steve Naroff} 51994084c306635b70f37029dca938444e6013f08684Steve Naroff 5200a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian/// ObjCQualifiedClassTypesAreCompatible - compare Class<p,...> and 5201a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian/// Class<p1, ...>. 5202a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanianbool ASTContext::ObjCQualifiedClassTypesAreCompatible(QualType lhs, 5203a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian QualType rhs) { 5204a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian const ObjCObjectPointerType *lhsQID = lhs->getAs<ObjCObjectPointerType>(); 5205a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>(); 5206a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian assert ((lhsQID && rhsOPT) && "ObjCQualifiedClassTypesAreCompatible"); 5207a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 5208a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 5209a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian E = lhsQID->qual_end(); I != E; ++I) { 5210a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian bool match = false; 5211a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian ObjCProtocolDecl *lhsProto = *I; 5212a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(), 5213a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian E = rhsOPT->qual_end(); J != E; ++J) { 5214a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian ObjCProtocolDecl *rhsProto = *J; 5215a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto)) { 5216a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian match = true; 5217a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian break; 5218a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian } 5219a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian } 5220a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian if (!match) 5221a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian return false; 5222a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian } 5223a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian return true; 5224a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian} 5225a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 52264084c306635b70f37029dca938444e6013f08684Steve Naroff/// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an 52274084c306635b70f37029dca938444e6013f08684Steve Naroff/// ObjCQualifiedIDType. 52284084c306635b70f37029dca938444e6013f08684Steve Naroffbool ASTContext::ObjCQualifiedIdTypesAreCompatible(QualType lhs, QualType rhs, 52294084c306635b70f37029dca938444e6013f08684Steve Naroff bool compare) { 52304084c306635b70f37029dca938444e6013f08684Steve Naroff // Allow id<P..> and an 'id' or void* type in all cases. 52311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (lhs->isVoidPointerType() || 52324084c306635b70f37029dca938444e6013f08684Steve Naroff lhs->isObjCIdType() || lhs->isObjCClassType()) 52334084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 52341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump else if (rhs->isVoidPointerType() || 52354084c306635b70f37029dca938444e6013f08684Steve Naroff rhs->isObjCIdType() || rhs->isObjCClassType()) 52364084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 52374084c306635b70f37029dca938444e6013f08684Steve Naroff 52384084c306635b70f37029dca938444e6013f08684Steve Naroff if (const ObjCObjectPointerType *lhsQID = lhs->getAsObjCQualifiedIdType()) { 5239183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>(); 52401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 52414084c306635b70f37029dca938444e6013f08684Steve Naroff if (!rhsOPT) return false; 52421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 52434084c306635b70f37029dca938444e6013f08684Steve Naroff if (rhsOPT->qual_empty()) { 52441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the RHS is a unqualified interface pointer "NSString*", 52454084c306635b70f37029dca938444e6013f08684Steve Naroff // make sure we check the class hierarchy. 52464084c306635b70f37029dca938444e6013f08684Steve Naroff if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) { 52474084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 52484084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsQID->qual_end(); I != E; ++I) { 52494084c306635b70f37029dca938444e6013f08684Steve Naroff // when comparing an id<P> on lhs with a static type on rhs, 52504084c306635b70f37029dca938444e6013f08684Steve Naroff // see if static class implements all of id's protocols, directly or 52514084c306635b70f37029dca938444e6013f08684Steve Naroff // through its super class and categories. 52520fd8904c5f71a11d29f67716c3ebdf7ad1c855fbFariborz Jahanian if (!rhsID->ClassImplementsProtocol(*I, true)) 52534084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 52544084c306635b70f37029dca938444e6013f08684Steve Naroff } 52554084c306635b70f37029dca938444e6013f08684Steve Naroff } 52564084c306635b70f37029dca938444e6013f08684Steve Naroff // If there are no qualifiers and no interface, we have an 'id'. 52574084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 52584084c306635b70f37029dca938444e6013f08684Steve Naroff } 52591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Both the right and left sides have qualifiers. 52604084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 52614084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsQID->qual_end(); I != E; ++I) { 52624084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *lhsProto = *I; 52634084c306635b70f37029dca938444e6013f08684Steve Naroff bool match = false; 5264de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff 5265de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff // when comparing an id<P> on lhs with a static type on rhs, 5266de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff // see if static class implements all of id's protocols, directly or 5267de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff // through its super class and categories. 52684084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(), 52694084c306635b70f37029dca938444e6013f08684Steve Naroff E = rhsOPT->qual_end(); J != E; ++J) { 52704084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *rhsProto = *J; 52714084c306635b70f37029dca938444e6013f08684Steve Naroff if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 52724084c306635b70f37029dca938444e6013f08684Steve Naroff (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 52734084c306635b70f37029dca938444e6013f08684Steve Naroff match = true; 52748f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff break; 52758f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff } 5276de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff } 52771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the RHS is a qualified interface pointer "NSString<P>*", 52784084c306635b70f37029dca938444e6013f08684Steve Naroff // make sure we check the class hierarchy. 52794084c306635b70f37029dca938444e6013f08684Steve Naroff if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) { 52804084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 52814084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsQID->qual_end(); I != E; ++I) { 52824084c306635b70f37029dca938444e6013f08684Steve Naroff // when comparing an id<P> on lhs with a static type on rhs, 52834084c306635b70f37029dca938444e6013f08684Steve Naroff // see if static class implements all of id's protocols, directly or 52844084c306635b70f37029dca938444e6013f08684Steve Naroff // through its super class and categories. 52850fd8904c5f71a11d29f67716c3ebdf7ad1c855fbFariborz Jahanian if (rhsID->ClassImplementsProtocol(*I, true)) { 52864084c306635b70f37029dca938444e6013f08684Steve Naroff match = true; 52874084c306635b70f37029dca938444e6013f08684Steve Naroff break; 52884084c306635b70f37029dca938444e6013f08684Steve Naroff } 52894084c306635b70f37029dca938444e6013f08684Steve Naroff } 52904084c306635b70f37029dca938444e6013f08684Steve Naroff } 52914084c306635b70f37029dca938444e6013f08684Steve Naroff if (!match) 5292de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff return false; 5293de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff } 52941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5295de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff return true; 5296de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff } 52971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 52984084c306635b70f37029dca938444e6013f08684Steve Naroff const ObjCObjectPointerType *rhsQID = rhs->getAsObjCQualifiedIdType(); 52994084c306635b70f37029dca938444e6013f08684Steve Naroff assert(rhsQID && "One of the LHS/RHS should be id<x>"); 53004084c306635b70f37029dca938444e6013f08684Steve Naroff 53011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const ObjCObjectPointerType *lhsOPT = 53024084c306635b70f37029dca938444e6013f08684Steve Naroff lhs->getAsObjCInterfacePointerType()) { 5303de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // If both the right and left sides have qualifiers. 53044084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsOPT->qual_begin(), 53054084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsOPT->qual_end(); I != E; ++I) { 53064084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *lhsProto = *I; 53074084c306635b70f37029dca938444e6013f08684Steve Naroff bool match = false; 53084084c306635b70f37029dca938444e6013f08684Steve Naroff 5309de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // when comparing an id<P> on rhs with a static type on lhs, 53104084c306635b70f37029dca938444e6013f08684Steve Naroff // see if static class implements all of id's protocols, directly or 53114084c306635b70f37029dca938444e6013f08684Steve Naroff // through its super class and categories. 5312de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // First, lhs protocols in the qualifier list must be found, direct 5313de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // or indirect in rhs's qualifier list or it is a mismatch. 53144084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(), 53154084c306635b70f37029dca938444e6013f08684Steve Naroff E = rhsQID->qual_end(); J != E; ++J) { 53164084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *rhsProto = *J; 53174084c306635b70f37029dca938444e6013f08684Steve Naroff if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 53184084c306635b70f37029dca938444e6013f08684Steve Naroff (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 53194084c306635b70f37029dca938444e6013f08684Steve Naroff match = true; 53204084c306635b70f37029dca938444e6013f08684Steve Naroff break; 53214084c306635b70f37029dca938444e6013f08684Steve Naroff } 53224084c306635b70f37029dca938444e6013f08684Steve Naroff } 53234084c306635b70f37029dca938444e6013f08684Steve Naroff if (!match) 53244084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 53254084c306635b70f37029dca938444e6013f08684Steve Naroff } 5326de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian 5327de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // Static class's protocols, or its super class or category protocols 5328de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // must be found, direct or indirect in rhs's qualifier list or it is a mismatch. 5329de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (ObjCInterfaceDecl *lhsID = lhsOPT->getInterfaceDecl()) { 5330de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols; 5331de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian CollectInheritedProtocols(lhsID, LHSInheritedProtocols); 5332de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // This is rather dubious but matches gcc's behavior. If lhs has 5333de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // no type qualifier and its class has no static protocol(s) 5334de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // assume that it is mismatch. 5335de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (LHSInheritedProtocols.empty() && lhsOPT->qual_empty()) 5336de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian return false; 5337de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 5338de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian LHSInheritedProtocols.begin(), 5339de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian E = LHSInheritedProtocols.end(); I != E; ++I) { 5340de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian bool match = false; 5341de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian ObjCProtocolDecl *lhsProto = (*I); 5342de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(), 5343de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian E = rhsQID->qual_end(); J != E; ++J) { 5344de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian ObjCProtocolDecl *rhsProto = *J; 5345de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 5346de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 5347de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian match = true; 5348de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian break; 5349de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 5350de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 5351de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (!match) 5352de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian return false; 5353de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 5354de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 53554084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 53564084c306635b70f37029dca938444e6013f08684Steve Naroff } 53574084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 53584084c306635b70f37029dca938444e6013f08684Steve Naroff} 53594084c306635b70f37029dca938444e6013f08684Steve Naroff 53604084c306635b70f37029dca938444e6013f08684Steve Naroff/// canAssignObjCInterfaces - Return true if the two interface types are 53614084c306635b70f37029dca938444e6013f08684Steve Naroff/// compatible for assignment from RHS to LHS. This handles validation of any 53624084c306635b70f37029dca938444e6013f08684Steve Naroff/// protocol qualifiers on the LHS or RHS. 53634084c306635b70f37029dca938444e6013f08684Steve Naroff/// 53644084c306635b70f37029dca938444e6013f08684Steve Naroffbool ASTContext::canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, 53654084c306635b70f37029dca938444e6013f08684Steve Naroff const ObjCObjectPointerType *RHSOPT) { 5366c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* LHS = LHSOPT->getObjectType(); 5367c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* RHS = RHSOPT->getObjectType(); 5368c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 53694084c306635b70f37029dca938444e6013f08684Steve Naroff // If either type represents the built-in 'id' or 'Class' types, return true. 5370c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHS->isObjCUnqualifiedIdOrClass() || 5371c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall RHS->isObjCUnqualifiedIdOrClass()) 53724084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 53734084c306635b70f37029dca938444e6013f08684Steve Naroff 5374c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHS->isObjCQualifiedId() || RHS->isObjCQualifiedId()) 53751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0), 53761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType(RHSOPT,0), 53774084c306635b70f37029dca938444e6013f08684Steve Naroff false); 5378a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 5379a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian if (LHS->isObjCQualifiedClass() && RHS->isObjCQualifiedClass()) 5380a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian return ObjCQualifiedClassTypesAreCompatible(QualType(LHSOPT,0), 5381a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian QualType(RHSOPT,0)); 5382a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 5383c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // If we have 2 user-defined types, fall into that path. 5384c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHS->getInterface() && RHS->getInterface()) 53854084c306635b70f37029dca938444e6013f08684Steve Naroff return canAssignObjCInterfaces(LHS, RHS); 53861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 53874084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 538814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff} 538914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 5390132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// canAssignObjCInterfacesInBlockPointer - This routine is specifically written 5391fc8f0e14ad142ed811e90fbd9a30e419e301c717Chris Lattner/// for providing type-safety for objective-c pointers used to pass/return 5392132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// arguments in block literals. When passed as arguments, passing 'A*' where 5393132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// 'id' is expected is not OK. Passing 'Sub *" where 'Super *" is expected is 5394132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// not OK. For the return type, the opposite is not OK. 5395132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanianbool ASTContext::canAssignObjCInterfacesInBlockPointer( 5396132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian const ObjCObjectPointerType *LHSOPT, 5397a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian const ObjCObjectPointerType *RHSOPT, 5398a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian bool BlockReturnType) { 5399a98344869c278295f38e106583906377520079b8Fariborz Jahanian if (RHSOPT->isObjCBuiltinType() || LHSOPT->isObjCIdType()) 5400132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return true; 5401132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5402132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHSOPT->isObjCBuiltinType()) { 5403132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return RHSOPT->isObjCBuiltinType() || RHSOPT->isObjCQualifiedIdType(); 5404132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 5405132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5406a98344869c278295f38e106583906377520079b8Fariborz Jahanian if (LHSOPT->isObjCQualifiedIdType() || RHSOPT->isObjCQualifiedIdType()) 5407132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0), 5408132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian QualType(RHSOPT,0), 5409132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian false); 5410132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5411132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType(); 5412132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType(); 5413132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHS && RHS) { // We have 2 user-defined types. 5414132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHS != RHS) { 5415132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHS->getDecl()->isSuperClassOf(RHS->getDecl())) 5416a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian return BlockReturnType; 5417132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (RHS->getDecl()->isSuperClassOf(LHS->getDecl())) 5418a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian return !BlockReturnType; 5419132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 5420132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian else 5421132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return true; 5422132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 5423132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return false; 5424132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian} 5425132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5426e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// getIntersectionOfProtocols - This routine finds the intersection of set 5427e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// of protocols inherited from two distinct objective-c pointer objects. 5428e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// It is used to build composite qualifier list of the composite type of 5429e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// the conditional expression involving two objective-c pointer objects. 5430e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanianstatic 5431e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanianvoid getIntersectionOfProtocols(ASTContext &Context, 5432e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian const ObjCObjectPointerType *LHSOPT, 5433e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian const ObjCObjectPointerType *RHSOPT, 54345f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<ObjCProtocolDecl *> &IntersectionOfProtocols) { 5435e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5436c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* LHS = LHSOPT->getObjectType(); 5437c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* RHS = RHSOPT->getObjectType(); 5438c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(LHS->getInterface() && "LHS must have an interface base"); 5439c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(RHS->getInterface() && "RHS must have an interface base"); 5440e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5441e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocolSet; 5442e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian unsigned LHSNumProtocols = LHS->getNumProtocols(); 5443e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (LHSNumProtocols > 0) 5444e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian InheritedProtocolSet.insert(LHS->qual_begin(), LHS->qual_end()); 5445e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian else { 5446432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols; 5447c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Context.CollectInheritedProtocols(LHS->getInterface(), 5448c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall LHSInheritedProtocols); 5449e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian InheritedProtocolSet.insert(LHSInheritedProtocols.begin(), 5450e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian LHSInheritedProtocols.end()); 5451e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 5452e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5453e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian unsigned RHSNumProtocols = RHS->getNumProtocols(); 5454e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (RHSNumProtocols > 0) { 5455cb421fa690da545b58a720abe5f1c49b166dbde7Dan Gohman ObjCProtocolDecl **RHSProtocols = 5456cb421fa690da545b58a720abe5f1c49b166dbde7Dan Gohman const_cast<ObjCProtocolDecl **>(RHS->qual_begin()); 5457e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (unsigned i = 0; i < RHSNumProtocols; ++i) 5458e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (InheritedProtocolSet.count(RHSProtocols[i])) 5459e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian IntersectionOfProtocols.push_back(RHSProtocols[i]); 54603060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 5461432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> RHSInheritedProtocols; 5462c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Context.CollectInheritedProtocols(RHS->getInterface(), 5463c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall RHSInheritedProtocols); 5464432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 5465432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian RHSInheritedProtocols.begin(), 5466432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian E = RHSInheritedProtocols.end(); I != E; ++I) 5467432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian if (InheritedProtocolSet.count((*I))) 5468432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian IntersectionOfProtocols.push_back((*I)); 5469e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 5470e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian} 5471e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5472db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// areCommonBaseCompatible - Returns common base class of the two classes if 5473db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// one found. Note that this is O'2 algorithm. But it will be called as the 5474db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// last type comparison in a ?-exp of ObjC pointer types before a 5475db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// warning is issued. So, its invokation is extremely rare. 5476db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz JahanianQualType ASTContext::areCommonBaseCompatible( 5477c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectPointerType *Lptr, 5478c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectPointerType *Rptr) { 5479c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType *LHS = Lptr->getObjectType(); 5480c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType *RHS = Rptr->getObjectType(); 5481c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCInterfaceDecl* LDecl = LHS->getInterface(); 5482c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCInterfaceDecl* RDecl = RHS->getInterface(); 548360ef308e51c71b760d7f598c1b763ceb7b768148Douglas Gregor if (!LDecl || !RDecl || (declaresSameEntity(LDecl, RDecl))) 5484db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian return QualType(); 5485db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian 54867c2bdcb4d30f2d370b4367664e6a11b075ce2cb3Fariborz Jahanian do { 5487c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall LHS = cast<ObjCInterfaceType>(getObjCInterfaceType(LDecl)); 5488e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (canAssignObjCInterfaces(LHS, RHS)) { 54895f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<ObjCProtocolDecl *, 8> Protocols; 5490c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall getIntersectionOfProtocols(*this, Lptr, Rptr, Protocols); 5491c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 5492c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall QualType Result = QualType(LHS, 0); 5493c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!Protocols.empty()) 5494c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Result = getObjCObjectType(Result, Protocols.data(), Protocols.size()); 5495c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Result = getObjCObjectPointerType(Result); 5496c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return Result; 5497e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 54987c2bdcb4d30f2d370b4367664e6a11b075ce2cb3Fariborz Jahanian } while ((LDecl = LDecl->getSuperClass())); 5499db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian 5500db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian return QualType(); 5501db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian} 5502db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian 5503c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCallbool ASTContext::canAssignObjCInterfaces(const ObjCObjectType *LHS, 5504c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType *RHS) { 5505c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(LHS->getInterface() && "LHS is not an interface type"); 5506c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(RHS->getInterface() && "RHS is not an interface type"); 5507c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 55086ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // Verify that the base decls are compatible: the RHS must be a subclass of 55096ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // the LHS. 5510c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!LHS->getInterface()->isSuperClassOf(RHS->getInterface())) 55116ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner return false; 55121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 55136ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // RHS must have a superset of the protocols in the LHS. If the LHS is not 55146ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // protocol qualified at all, then we are good. 5515c15cb2af27514ecc879daba9aa01389c5203685dSteve Naroff if (LHS->getNumProtocols() == 0) 55166ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner return true; 55171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5518b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // Okay, we know the LHS has protocol qualifiers. If the RHS doesn't, 5519b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // more detailed analysis is required. 5520b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (RHS->getNumProtocols() == 0) { 5521b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // OK, if LHS is a superclass of RHS *and* 5522b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // this superclass is assignment compatible with LHS. 5523b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // false otherwise. 5524627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian bool IsSuperClass = 5525627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian LHS->getInterface()->isSuperClassOf(RHS->getInterface()); 5526627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian if (IsSuperClass) { 5527b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // OK if conversion of LHS to SuperClass results in narrowing of types 5528b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // ; i.e., SuperClass may implement at least one of the protocols 5529b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // in LHS's protocol list. Example, SuperObj<P1> = lhs<P1,P2> is ok. 5530b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // But not SuperObj<P1,P2,P3> = lhs<P1,P2>. 5531b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> SuperClassInheritedProtocols; 5532627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian CollectInheritedProtocols(RHS->getInterface(), SuperClassInheritedProtocols); 5533b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // If super class has no protocols, it is not a match. 5534b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (SuperClassInheritedProtocols.empty()) 5535b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return false; 5536b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian 5537b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian for (ObjCObjectType::qual_iterator LHSPI = LHS->qual_begin(), 5538b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian LHSPE = LHS->qual_end(); 5539b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian LHSPI != LHSPE; LHSPI++) { 5540b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian bool SuperImplementsProtocol = false; 5541b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian ObjCProtocolDecl *LHSProto = (*LHSPI); 5542b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian 5543b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 5544b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian SuperClassInheritedProtocols.begin(), 5545b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian E = SuperClassInheritedProtocols.end(); I != E; ++I) { 5546b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian ObjCProtocolDecl *SuperClassProto = (*I); 5547b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (SuperClassProto->lookupProtocolNamed(LHSProto->getIdentifier())) { 5548b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian SuperImplementsProtocol = true; 5549b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian break; 5550b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5551b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5552b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (!SuperImplementsProtocol) 5553b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return false; 5554b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5555b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return true; 5556b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5557b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return false; 5558b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 55591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5560c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall for (ObjCObjectType::qual_iterator LHSPI = LHS->qual_begin(), 5561c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall LHSPE = LHS->qual_end(); 556291b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff LHSPI != LHSPE; LHSPI++) { 556391b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff bool RHSImplementsProtocol = false; 556491b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff 556591b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // If the RHS doesn't implement the protocol on the left, the types 556691b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // are incompatible. 5567c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall for (ObjCObjectType::qual_iterator RHSPI = RHS->qual_begin(), 5568c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall RHSPE = RHS->qual_end(); 55698f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff RHSPI != RHSPE; RHSPI++) { 55708f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff if ((*RHSPI)->lookupProtocolNamed((*LHSPI)->getIdentifier())) { 557191b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff RHSImplementsProtocol = true; 55728f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff break; 55738f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff } 557491b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff } 557591b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // FIXME: For better diagnostics, consider passing back the protocol name. 557691b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff if (!RHSImplementsProtocol) 557791b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff return false; 557891b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff } 557991b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // The RHS implements all protocols listed on the LHS. 558091b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff return true; 55816ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner} 55826ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner 5583389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroffbool ASTContext::areComparableObjCPointerTypes(QualType LHS, QualType RHS) { 5584389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff // get the "pointed to" types 5585183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const ObjCObjectPointerType *LHSOPT = LHS->getAs<ObjCObjectPointerType>(); 5586183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const ObjCObjectPointerType *RHSOPT = RHS->getAs<ObjCObjectPointerType>(); 55871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 558814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (!LHSOPT || !RHSOPT) 5589389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff return false; 559014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 559114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return canAssignObjCInterfaces(LHSOPT, RHSOPT) || 559214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff canAssignObjCInterfaces(RHSOPT, LHSOPT); 5593389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff} 5594389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff 5595569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregorbool ASTContext::canBindObjCObjectType(QualType To, QualType From) { 5596569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor return canAssignObjCInterfaces( 5597569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor getObjCObjectPointerType(To)->getAs<ObjCObjectPointerType>(), 5598569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor getObjCObjectPointerType(From)->getAs<ObjCObjectPointerType>()); 5599569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor} 5600569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor 56011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible, 5602ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff/// both shall have the identically qualified version of a compatible type. 56031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// C99 6.2.7p1: Two types have compatible types if their types are the 5604ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff/// same. See 6.7.[2,3,5] for additional rules. 5605447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregorbool ASTContext::typesAreCompatible(QualType LHS, QualType RHS, 5606447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool CompareUnqualified) { 56070e709abafbd939326850501f795cc7a92c88a354Douglas Gregor if (getLangOptions().CPlusPlus) 56080e709abafbd939326850501f795cc7a92c88a354Douglas Gregor return hasSameType(LHS, RHS); 56090e709abafbd939326850501f795cc7a92c88a354Douglas Gregor 5610447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor return !mergeTypes(LHS, RHS, false, CompareUnqualified).isNull(); 56113d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman} 56123d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 5613c286f3835eb6001c61664cef5d610dfaf80a6e9bFariborz Jahanianbool ASTContext::propertyTypesAreCompatible(QualType LHS, QualType RHS) { 561482378391dfc3b2fc22f63dbf1552bd9aed39dc42Fariborz Jahanian return typesAreCompatible(LHS, RHS); 5615c286f3835eb6001c61664cef5d610dfaf80a6e9bFariborz Jahanian} 5616c286f3835eb6001c61664cef5d610dfaf80a6e9bFariborz Jahanian 5617132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanianbool ASTContext::typesAreBlockPointerCompatible(QualType LHS, QualType RHS) { 5618132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return !mergeTypes(LHS, RHS, true).isNull(); 5619132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian} 5620132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 56214846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// mergeTransparentUnionType - if T is a transparent union type and a member 56224846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// of T is compatible with SubType, return the merged type, else return 56234846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// QualType() 56244846675e0e42d1802b0ffd8972a45e72aeb3758dPeter CollingbourneQualType ASTContext::mergeTransparentUnionType(QualType T, QualType SubType, 56254846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool OfBlockPointer, 56264846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool Unqualified) { 56274846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (const RecordType *UT = T->getAsUnionType()) { 56284846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne RecordDecl *UD = UT->getDecl(); 56294846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (UD->hasAttr<TransparentUnionAttr>()) { 56304846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne for (RecordDecl::field_iterator it = UD->field_begin(), 56314846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne itend = UD->field_end(); it != itend; ++it) { 5632f91d7572ee7fa6f2926c8e7e816039a1154a59f8Peter Collingbourne QualType ET = it->getType().getUnqualifiedType(); 56334846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType MT = mergeTypes(ET, SubType, OfBlockPointer, Unqualified); 56344846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (!MT.isNull()) 56354846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return MT; 56364846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne } 56374846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne } 56384846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne } 56394846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 56404846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return QualType(); 56414846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne} 56424846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 56434846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// mergeFunctionArgumentTypes - merge two types which appear as function 56444846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// argument types 56454846675e0e42d1802b0ffd8972a45e72aeb3758dPeter CollingbourneQualType ASTContext::mergeFunctionArgumentTypes(QualType lhs, QualType rhs, 56464846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool OfBlockPointer, 56474846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool Unqualified) { 56484846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne // GNU extension: two types are compatible if they appear as a function 56494846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne // argument, one of the types is a transparent union type and the other 56504846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne // type is compatible with a union member 56514846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType lmerge = mergeTransparentUnionType(lhs, rhs, OfBlockPointer, 56524846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne Unqualified); 56534846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (!lmerge.isNull()) 56544846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return lmerge; 56554846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 56564846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType rmerge = mergeTransparentUnionType(rhs, lhs, OfBlockPointer, 56574846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne Unqualified); 56584846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (!rmerge.isNull()) 56594846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return rmerge; 56604846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 56614846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return mergeTypes(lhs, rhs, OfBlockPointer, Unqualified); 56624846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne} 56634846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 5664132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz JahanianQualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs, 5665447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool OfBlockPointer, 5666447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool Unqualified) { 5667183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const FunctionType *lbase = lhs->getAs<FunctionType>(); 5668183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const FunctionType *rbase = rhs->getAs<FunctionType>(); 566972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase); 567072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase); 56713d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman bool allLTypes = true; 56723d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman bool allRTypes = true; 56733d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 56743d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Check return type 5675132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian QualType retType; 5676d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian if (OfBlockPointer) { 5677d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian QualType RHS = rbase->getResultType(); 5678d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian QualType LHS = lbase->getResultType(); 5679d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian bool UnqualifiedResult = Unqualified; 5680d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian if (!UnqualifiedResult) 5681d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian UnqualifiedResult = (!RHS.hasQualifiers() && LHS.hasQualifiers()); 5682a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian retType = mergeTypes(LHS, RHS, true, UnqualifiedResult, true); 5683d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian } 5684132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian else 56858cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall retType = mergeTypes(lbase->getResultType(), rbase->getResultType(), false, 56868cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall Unqualified); 56873d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (retType.isNull()) return QualType(); 5688447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5689447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) 5690447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor retType = retType.getUnqualifiedType(); 5691447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5692447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor CanQualType LRetType = getCanonicalType(lbase->getResultType()); 5693447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor CanQualType RRetType = getCanonicalType(rbase->getResultType()); 5694447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5695447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LRetType = LRetType.getUnqualifiedType(); 5696447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RRetType = RRetType.getUnqualifiedType(); 5697447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 5698447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5699447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (getCanonicalType(retType) != LRetType) 570061710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allLTypes = false; 5701447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (getCanonicalType(retType) != RRetType) 570261710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allRTypes = false; 57038cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 57046a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // FIXME: double check this 57056a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // FIXME: should we error if lbase->getRegParmAttr() != 0 && 57066a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // rbase->getRegParmAttr() != 0 && 57076a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // lbase->getRegParmAttr() != rbase->getRegParmAttr()? 5708264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo lbaseInfo = lbase->getExtInfo(); 5709264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo rbaseInfo = rbase->getExtInfo(); 57108cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 57118cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall // Compatible functions must have compatible calling conventions 57128cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall if (!isSameCallConv(lbaseInfo.getCC(), rbaseInfo.getCC())) 57138cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall return QualType(); 57148cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 57158cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall // Regparm is part of the calling convention. 5716a49218e17bcbb1acde0245773173e2c0c42f4f19Eli Friedman if (lbaseInfo.getHasRegParm() != rbaseInfo.getHasRegParm()) 5717a49218e17bcbb1acde0245773173e2c0c42f4f19Eli Friedman return QualType(); 57188cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall if (lbaseInfo.getRegParm() != rbaseInfo.getRegParm()) 57198cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall return QualType(); 57208cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 5721f85e193739c953358c865005855253af4f68a497John McCall if (lbaseInfo.getProducesResult() != rbaseInfo.getProducesResult()) 5722f85e193739c953358c865005855253af4f68a497John McCall return QualType(); 5723f85e193739c953358c865005855253af4f68a497John McCall 572453c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian // functypes which return are preferred over those that do not. 572553c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian if (lbaseInfo.getNoReturn() && !rbaseInfo.getNoReturn()) 57266a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar allLTypes = false; 572753c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian else if (!lbaseInfo.getNoReturn() && rbaseInfo.getNoReturn()) 57286a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar allRTypes = false; 572953c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian // FIXME: some uses, e.g. conditional exprs, really want this to be 'both'. 573053c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian bool NoReturn = lbaseInfo.getNoReturn() || rbaseInfo.getNoReturn(); 57311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5732f85e193739c953358c865005855253af4f68a497John McCall FunctionType::ExtInfo einfo = lbaseInfo.withNoReturn(NoReturn); 5733e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 57343d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto && rproto) { // two C99 style function prototypes 5735465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl assert(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() && 5736465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl "C++ shouldn't be here"); 57373d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman unsigned lproto_nargs = lproto->getNumArgs(); 57383d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman unsigned rproto_nargs = rproto->getNumArgs(); 57393d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 57403d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Compatible functions must have the same number of arguments 57413d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto_nargs != rproto_nargs) 57423d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 57433d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 57443d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Variadic and non-variadic functions aren't compatible 57453d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto->isVariadic() != rproto->isVariadic()) 57463d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 57473d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 57487fb5e4888221cd36652d078c6b171ac55e7f406dArgyrios Kyrtzidis if (lproto->getTypeQuals() != rproto->getTypeQuals()) 57497fb5e4888221cd36652d078c6b171ac55e7f406dArgyrios Kyrtzidis return QualType(); 57507fb5e4888221cd36652d078c6b171ac55e7f406dArgyrios Kyrtzidis 575178213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (LangOpts.ObjCAutoRefCount && 575278213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian !FunctionTypesMatchOnNSConsumedAttrs(rproto, lproto)) 575378213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return QualType(); 575478213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian 57553d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Check argument compatibility 57565f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 10> types; 57573d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman for (unsigned i = 0; i < lproto_nargs; i++) { 57583d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType largtype = lproto->getArgType(i).getUnqualifiedType(); 57593d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType rargtype = rproto->getArgType(i).getUnqualifiedType(); 57604846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType argtype = mergeFunctionArgumentTypes(largtype, rargtype, 57614846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne OfBlockPointer, 57624846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne Unqualified); 57633d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (argtype.isNull()) return QualType(); 5764447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5765447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) 5766447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor argtype = argtype.getUnqualifiedType(); 5767447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 57683d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman types.push_back(argtype); 5769447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5770447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor largtype = largtype.getUnqualifiedType(); 5771447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor rargtype = rargtype.getUnqualifiedType(); 5772447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 5773447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 577461710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (getCanonicalType(argtype) != getCanonicalType(largtype)) 577561710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allLTypes = false; 577661710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (getCanonicalType(argtype) != getCanonicalType(rargtype)) 577761710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allRTypes = false; 57783d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 577978213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian 57803d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allLTypes) return lhs; 57813d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allRTypes) return rhs; 5782e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 5783e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI = lproto->getExtProtoInfo(); 5784e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall EPI.ExtInfo = einfo; 5785e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall return getFunctionType(retType, types.begin(), types.size(), EPI); 57863d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 57873d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 57883d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto) allRTypes = false; 57893d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (rproto) allLTypes = false; 57903d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 579172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor const FunctionProtoType *proto = lproto ? lproto : rproto; 57923d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (proto) { 5793465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl assert(!proto->hasExceptionSpec() && "C++ shouldn't be here"); 57943d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (proto->isVariadic()) return QualType(); 57953d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Check that the types are compatible with the types that 57963d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // would result from default argument promotions (C99 6.7.5.3p15). 57973d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // The only types actually affected are promotable integer 57983d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // types and floats, which would be passed as a different 57993d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // type depending on whether the prototype is visible. 58003d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman unsigned proto_nargs = proto->getNumArgs(); 58013d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman for (unsigned i = 0; i < proto_nargs; ++i) { 58023d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType argTy = proto->getArgType(i); 5803b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor 5804b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor // Look at the promotion type of enum types, since that is the type used 5805b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor // to pass enum values. 5806b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor if (const EnumType *Enum = argTy->getAs<EnumType>()) 5807b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor argTy = Enum->getDecl()->getPromotionType(); 5808b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor 58093d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (argTy->isPromotableIntegerType() || 58103d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman getCanonicalType(argTy).getUnqualifiedType() == FloatTy) 58113d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 58123d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 58133d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 58143d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allLTypes) return lhs; 58153d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allRTypes) return rhs; 5816e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 5817e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI = proto->getExtProtoInfo(); 5818e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall EPI.ExtInfo = einfo; 58193d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return getFunctionType(retType, proto->arg_type_begin(), 5820e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall proto->getNumArgs(), EPI); 58213d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 58223d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 58233d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allLTypes) return lhs; 58243d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allRTypes) return rhs; 58258cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall return getFunctionNoProtoType(retType, einfo); 58263d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman} 58273d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 5828132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz JahanianQualType ASTContext::mergeTypes(QualType LHS, QualType RHS, 5829447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool OfBlockPointer, 5830a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian bool Unqualified, bool BlockReturnType) { 583143d69750e7f7b26076e7474dec8839bb777b260fBill Wendling // C++ [expr]: If an expression initially has the type "reference to T", the 583243d69750e7f7b26076e7474dec8839bb777b260fBill Wendling // type is adjusted to "T" prior to any further analysis, the expression 583343d69750e7f7b26076e7474dec8839bb777b260fBill Wendling // designates the object or function denoted by the reference, and the 58347c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // expression is an lvalue unless the reference is an rvalue reference and 58357c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // the expression is a function call (possibly inside parentheses). 58360e709abafbd939326850501f795cc7a92c88a354Douglas Gregor assert(!LHS->getAs<ReferenceType>() && "LHS is a reference type?"); 58370e709abafbd939326850501f795cc7a92c88a354Douglas Gregor assert(!RHS->getAs<ReferenceType>() && "RHS is a reference type?"); 5838447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5839447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5840447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHS = LHS.getUnqualifiedType(); 5841447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHS = RHS.getUnqualifiedType(); 5842447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 58430e709abafbd939326850501f795cc7a92c88a354Douglas Gregor 58443d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType LHSCan = getCanonicalType(LHS), 58453d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman RHSCan = getCanonicalType(RHS); 58463d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 5847f3692dc4a47dc48d10cec0415c6e9e39b7a39707Chris Lattner // If two types are identical, they are compatible. 58483d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (LHSCan == RHSCan) 58493d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 58503d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 58510953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If the qualifiers are different, the types aren't compatible... mostly. 5852a4923eb7c4b04d360cb2747641a5e92818edf804Douglas Gregor Qualifiers LQuals = LHSCan.getLocalQualifiers(); 5853a4923eb7c4b04d360cb2747641a5e92818edf804Douglas Gregor Qualifiers RQuals = RHSCan.getLocalQualifiers(); 58540953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (LQuals != RQuals) { 58550953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If any of these qualifiers are different, we have a type 58560953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // mismatch. 58570953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() || 5858f85e193739c953358c865005855253af4f68a497John McCall LQuals.getAddressSpace() != RQuals.getAddressSpace() || 5859f85e193739c953358c865005855253af4f68a497John McCall LQuals.getObjCLifetime() != RQuals.getObjCLifetime()) 58600953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return QualType(); 58610953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 58620953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Exactly one GC qualifier difference is allowed: __strong is 58630953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // okay if the other type has no GC qualifier but is an Objective 58640953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // C object pointer (i.e. implicitly strong by default). We fix 58650953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // this by pretending that the unqualified type was actually 58660953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // qualified __strong. 58670953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers::GC GC_L = LQuals.getObjCGCAttr(); 58680953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers::GC GC_R = RQuals.getObjCGCAttr(); 58690953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements"); 58700953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 58710953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak) 58720953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return QualType(); 58730953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 58740953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (GC_L == Qualifiers::Strong && RHSCan->isObjCObjectPointerType()) { 58750953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return mergeTypes(LHS, getObjCGCQualType(RHS, Qualifiers::Strong)); 58760953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 58770953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (GC_R == Qualifiers::Strong && LHSCan->isObjCObjectPointerType()) { 58780953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return mergeTypes(getObjCGCQualType(LHS, Qualifiers::Strong), RHS); 58790953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 58803d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 58810953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 58820953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 58830953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Okay, qualifiers are equal. 58843d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 5885852d63b806c5cbd730c6b9d696e2e27d02546b49Eli Friedman Type::TypeClass LHSClass = LHSCan->getTypeClass(); 5886852d63b806c5cbd730c6b9d696e2e27d02546b49Eli Friedman Type::TypeClass RHSClass = RHSCan->getTypeClass(); 5887f3692dc4a47dc48d10cec0415c6e9e39b7a39707Chris Lattner 58881adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner // We want to consider the two function types to be the same for these 58891adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner // comparisons, just force one to the other. 58901adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto; 58911adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto; 58924c721d381fb279899337d120edd4a24d405e56b2Eli Friedman 58934c721d381fb279899337d120edd4a24d405e56b2Eli Friedman // Same as above for arrays 5894a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray) 5895a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner LHSClass = Type::ConstantArray; 5896a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray) 5897a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner RHSClass = Type::ConstantArray; 58981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5899c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // ObjCInterfaces are just specialized ObjCObjects. 5900c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject; 5901c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject; 5902c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 5903213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // Canonicalize ExtVector -> Vector. 5904213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (LHSClass == Type::ExtVector) LHSClass = Type::Vector; 5905213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (RHSClass == Type::ExtVector) RHSClass = Type::Vector; 59061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 59074e78fd0a960eaa7e97467f2e8f390f3a57da279bSteve Naroff // If the canonical type classes don't match. 59084e78fd0a960eaa7e97467f2e8f390f3a57da279bSteve Naroff if (LHSClass != RHSClass) { 59091adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner // C99 6.7.2.2p4: Each enumerated type shall be compatible with char, 59101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // a signed integer type, or an unsigned integer type. 5911842aef8d942a880eeb9535d40de31a86838264cbJohn McCall // Compatibility is based on the underlying type, not the promotion 5912842aef8d942a880eeb9535d40de31a86838264cbJohn McCall // type. 5913183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const EnumType* ETy = LHS->getAs<EnumType>()) { 5914b918d6b1f794266e126e5445d69233462087d764Fariborz Jahanian QualType TINT = ETy->getDecl()->getIntegerType(); 5915b918d6b1f794266e126e5445d69233462087d764Fariborz Jahanian if (!TINT.isNull() && hasSameType(TINT, RHSCan.getUnqualifiedType())) 59163d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return RHS; 5917bab96968886f4b77083f4e26a28986ddb1e42d67Eli Friedman } 5918183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const EnumType* ETy = RHS->getAs<EnumType>()) { 5919b918d6b1f794266e126e5445d69233462087d764Fariborz Jahanian QualType TINT = ETy->getDecl()->getIntegerType(); 5920b918d6b1f794266e126e5445d69233462087d764Fariborz Jahanian if (!TINT.isNull() && hasSameType(TINT, LHSCan.getUnqualifiedType())) 59213d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 5922bab96968886f4b77083f4e26a28986ddb1e42d67Eli Friedman } 5923e7cff2c00c3d74e38984a4db5c48d7e303d3ab8eFariborz Jahanian // allow block pointer type to match an 'id' type. 5924419636316c04d570c183b4797fc811932c588358Fariborz Jahanian if (OfBlockPointer && !BlockReturnType) { 5925419636316c04d570c183b4797fc811932c588358Fariborz Jahanian if (LHS->isObjCIdType() && RHS->isBlockPointerType()) 5926419636316c04d570c183b4797fc811932c588358Fariborz Jahanian return LHS; 5927419636316c04d570c183b4797fc811932c588358Fariborz Jahanian if (RHS->isObjCIdType() && LHS->isBlockPointerType()) 5928419636316c04d570c183b4797fc811932c588358Fariborz Jahanian return RHS; 5929419636316c04d570c183b4797fc811932c588358Fariborz Jahanian } 5930e7cff2c00c3d74e38984a4db5c48d7e303d3ab8eFariborz Jahanian 59313d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 5932ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff } 59333d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 59344a74678ed6c3dedac05d02b1ee341f1db869f049Steve Naroff // The canonical type classes match. 59351adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner switch (LHSClass) { 593672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define TYPE(Class, Base) 593772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define ABSTRACT_TYPE(Class, Base) 5938ad5e73887052193afda72db8efcb812bd083a4a8John McCall#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class: 593972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 594072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define DEPENDENT_TYPE(Class, Base) case Type::Class: 594172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#include "clang/AST/TypeNodes.def" 5942b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Non-canonical and dependent types shouldn't get here"); 594372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 59447c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl case Type::LValueReference: 59457c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl case Type::RValueReference: 594672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::MemberPointer: 5947b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("C++ should never be in mergeTypes"); 594872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 5949c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCInterface: 595072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::IncompleteArray: 595172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::VariableArray: 595272564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::FunctionProto: 595372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::ExtVector: 5954b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Types are eliminated above"); 595572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 59561adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::Pointer: 59573d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman { 59583d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Merge two pointer types, while trying to preserve typedef info 59596217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType LHSPointee = LHS->getAs<PointerType>()->getPointeeType(); 59606217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType RHSPointee = RHS->getAs<PointerType>()->getPointeeType(); 5961447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5962447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHSPointee = LHSPointee.getUnqualifiedType(); 5963447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHSPointee = RHSPointee.getUnqualifiedType(); 5964447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 5965447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor QualType ResultType = mergeTypes(LHSPointee, RHSPointee, false, 5966447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor Unqualified); 59673d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (ResultType.isNull()) return QualType(); 596807d258756dc856c6987c394a0972884e6ed46765Eli Friedman if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType)) 596961710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return LHS; 597007d258756dc856c6987c394a0972884e6ed46765Eli Friedman if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType)) 597161710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return RHS; 59723d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return getPointerType(ResultType); 59733d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 5974c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff case Type::BlockPointer: 5975c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff { 5976c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff // Merge two block pointer types, while trying to preserve typedef info 59776217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType LHSPointee = LHS->getAs<BlockPointerType>()->getPointeeType(); 59786217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType RHSPointee = RHS->getAs<BlockPointerType>()->getPointeeType(); 5979447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5980447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHSPointee = LHSPointee.getUnqualifiedType(); 5981447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHSPointee = RHSPointee.getUnqualifiedType(); 5982447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 5983447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor QualType ResultType = mergeTypes(LHSPointee, RHSPointee, OfBlockPointer, 5984447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor Unqualified); 5985c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff if (ResultType.isNull()) return QualType(); 5986c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType)) 5987c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff return LHS; 5988c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType)) 5989c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff return RHS; 5990c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff return getBlockPointerType(ResultType); 5991c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff } 5992b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: 5993b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman { 5994b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // Merge two pointer types, while trying to preserve typedef info 5995b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType LHSValue = LHS->getAs<AtomicType>()->getValueType(); 5996b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType RHSValue = RHS->getAs<AtomicType>()->getValueType(); 5997b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (Unqualified) { 5998b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman LHSValue = LHSValue.getUnqualifiedType(); 5999b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman RHSValue = RHSValue.getUnqualifiedType(); 6000b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 6001b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType ResultType = mergeTypes(LHSValue, RHSValue, false, 6002b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman Unqualified); 6003b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (ResultType.isNull()) return QualType(); 6004b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (getCanonicalType(LHSValue) == getCanonicalType(ResultType)) 6005b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return LHS; 6006b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (getCanonicalType(RHSValue) == getCanonicalType(ResultType)) 6007b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return RHS; 6008b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return getAtomicType(ResultType); 6009b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 60101adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::ConstantArray: 60113d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman { 60123d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const ConstantArrayType* LCAT = getAsConstantArrayType(LHS); 60133d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const ConstantArrayType* RCAT = getAsConstantArrayType(RHS); 60143d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (LCAT && RCAT && RCAT->getSize() != LCAT->getSize()) 60153d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 60163d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 60173d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType LHSElem = getAsArrayType(LHS)->getElementType(); 60183d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType RHSElem = getAsArrayType(RHS)->getElementType(); 6019447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 6020447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHSElem = LHSElem.getUnqualifiedType(); 6021447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHSElem = RHSElem.getUnqualifiedType(); 6022447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 6023447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 6024447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor QualType ResultType = mergeTypes(LHSElem, RHSElem, false, Unqualified); 60253d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (ResultType.isNull()) return QualType(); 602661710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (LCAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType)) 602761710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return LHS; 602861710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (RCAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType)) 602961710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return RHS; 60303bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (LCAT) return getConstantArrayType(ResultType, LCAT->getSize(), 60313bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman ArrayType::ArraySizeModifier(), 0); 60323bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (RCAT) return getConstantArrayType(ResultType, RCAT->getSize(), 60333bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman ArrayType::ArraySizeModifier(), 0); 60343d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const VariableArrayType* LVAT = getAsVariableArrayType(LHS); 60353d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const VariableArrayType* RVAT = getAsVariableArrayType(RHS); 603661710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (LVAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType)) 603761710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return LHS; 603861710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (RVAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType)) 603961710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return RHS; 60403d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (LVAT) { 60413d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // FIXME: This isn't correct! But tricky to implement because 60423d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // the array's size has to be the size of LHS, but the type 60433d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // has to be different. 60443d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 60453d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 60463d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (RVAT) { 60473d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // FIXME: This isn't correct! But tricky to implement because 60483d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // the array's size has to be the size of RHS, but the type 60493d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // has to be different. 60503d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return RHS; 60513d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 60523bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (getCanonicalType(LHSElem) == getCanonicalType(ResultType)) return LHS; 60533bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (getCanonicalType(RHSElem) == getCanonicalType(ResultType)) return RHS; 60547e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor return getIncompleteArrayType(ResultType, 60557e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor ArrayType::ArraySizeModifier(), 0); 60563d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 60571adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::FunctionNoProto: 6058447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor return mergeFunctionTypes(LHS, RHS, OfBlockPointer, Unqualified); 605972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Record: 606072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Enum: 60613d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 60621adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::Builtin: 60633cc4c0c3058a788689b8fc73c0ac139544435c97Chris Lattner // Only exactly equal builtin types are compatible, which is tested above. 60643d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 606564cfdb7da3cb744642fe8a99ad5c851ad3c930b2Daniel Dunbar case Type::Complex: 606664cfdb7da3cb744642fe8a99ad5c851ad3c930b2Daniel Dunbar // Distinct complex types are incompatible. 606764cfdb7da3cb744642fe8a99ad5c851ad3c930b2Daniel Dunbar return QualType(); 60683cc4c0c3058a788689b8fc73c0ac139544435c97Chris Lattner case Type::Vector: 60695a61f0e5c5aaecd5713c3fa4b78be7167a7eeff2Eli Friedman // FIXME: The merged type should be an ExtVector! 60701c471f3e1c0ec8cbc82447bb35908dfc55463e46John McCall if (areCompatVectorTypes(LHSCan->getAs<VectorType>(), 60711c471f3e1c0ec8cbc82447bb35908dfc55463e46John McCall RHSCan->getAs<VectorType>())) 60723d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 607361710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return QualType(); 6074c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCObject: { 6075c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Check if the types are assignment compatible. 60765a61f0e5c5aaecd5713c3fa4b78be7167a7eeff2Eli Friedman // FIXME: This should be type compatibility, e.g. whether 60775a61f0e5c5aaecd5713c3fa4b78be7167a7eeff2Eli Friedman // "LHS x; RHS x;" at global scope is legal. 6078c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* LHSIface = LHS->getAs<ObjCObjectType>(); 6079c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* RHSIface = RHS->getAs<ObjCObjectType>(); 6080c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (canAssignObjCInterfaces(LHSIface, RHSIface)) 60815fd659db11922fc12a58e478f7b745f9656b15a7Steve Naroff return LHS; 60825fd659db11922fc12a58e478f7b745f9656b15a7Steve Naroff 60833d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 608461490e9a965cfee8a78c12c6802138844f04250dCedric Venet } 608514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff case Type::ObjCObjectPointer: { 6086132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (OfBlockPointer) { 6087132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (canAssignObjCInterfacesInBlockPointer( 6088132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian LHS->getAs<ObjCObjectPointerType>(), 6089a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian RHS->getAs<ObjCObjectPointerType>(), 6090a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian BlockReturnType)) 60917530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie return LHS; 6092132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return QualType(); 6093132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 6094183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (canAssignObjCInterfaces(LHS->getAs<ObjCObjectPointerType>(), 6095183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall RHS->getAs<ObjCObjectPointerType>())) 609614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return LHS; 609714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 6098bc76dd06eb881c70c9775b74bab8b88cd747f173Steve Naroff return QualType(); 60997530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie } 6100ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff } 610172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 61027530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie llvm_unreachable("Invalid Type::Class!"); 6103ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff} 61047192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek 610578213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanianbool ASTContext::FunctionTypesMatchOnNSConsumedAttrs( 610678213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian const FunctionProtoType *FromFunctionType, 610778213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian const FunctionProtoType *ToFunctionType) { 610878213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (FromFunctionType->hasAnyConsumedArgs() != 610978213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ToFunctionType->hasAnyConsumedArgs()) 611078213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return false; 611178213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian FunctionProtoType::ExtProtoInfo FromEPI = 611278213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian FromFunctionType->getExtProtoInfo(); 611378213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian FunctionProtoType::ExtProtoInfo ToEPI = 611478213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ToFunctionType->getExtProtoInfo(); 611578213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (FromEPI.ConsumedArguments && ToEPI.ConsumedArguments) 611678213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumArgs(); 611778213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ArgIdx != NumArgs; ++ArgIdx) { 611878213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (FromEPI.ConsumedArguments[ArgIdx] != 611978213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ToEPI.ConsumedArguments[ArgIdx]) 612078213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return false; 612178213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian } 612278213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return true; 612378213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian} 612478213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian 61252390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian/// mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and 61262390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian/// 'RHS' attributes and returns the merged version; including for function 61272390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian/// return types. 61282390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz JahanianQualType ASTContext::mergeObjCGCQualifiers(QualType LHS, QualType RHS) { 61292390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType LHSCan = getCanonicalType(LHS), 61302390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian RHSCan = getCanonicalType(RHS); 61312390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // If two types are identical, they are compatible. 61322390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LHSCan == RHSCan) 61332390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return LHS; 61342390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (RHSCan->isFunctionType()) { 61352390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (!LHSCan->isFunctionType()) 61362390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61372390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType OldReturnType = 61382390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian cast<FunctionType>(RHSCan.getTypePtr())->getResultType(); 61392390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType NewReturnType = 61402390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian cast<FunctionType>(LHSCan.getTypePtr())->getResultType(); 61412390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType ResReturnType = 61422390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian mergeObjCGCQualifiers(NewReturnType, OldReturnType); 61432390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResReturnType.isNull()) 61442390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61452390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResReturnType == NewReturnType || ResReturnType == OldReturnType) { 61462390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // id foo(); ... __strong id foo(); or: __strong id foo(); ... id foo(); 61472390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // In either case, use OldReturnType to build the new function type. 61482390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian const FunctionType *F = LHS->getAs<FunctionType>(); 61492390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (const FunctionProtoType *FPT = cast<FunctionProtoType>(F)) { 6150e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 6151e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall EPI.ExtInfo = getFunctionExtInfo(LHS); 61522390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType ResultType 61532390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian = getFunctionType(OldReturnType, FPT->arg_type_begin(), 6154e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FPT->getNumArgs(), EPI); 61552390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return ResultType; 61562390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 61572390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 61582390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61592390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 61602390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 61612390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // If the qualifiers are different, the types can still be merged. 61622390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers LQuals = LHSCan.getLocalQualifiers(); 61632390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers RQuals = RHSCan.getLocalQualifiers(); 61642390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LQuals != RQuals) { 61652390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // If any of these qualifiers are different, we have a type mismatch. 61662390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() || 61672390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian LQuals.getAddressSpace() != RQuals.getAddressSpace()) 61682390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61692390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 61702390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // Exactly one GC qualifier difference is allowed: __strong is 61712390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // okay if the other type has no GC qualifier but is an Objective 61722390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // C object pointer (i.e. implicitly strong by default). We fix 61732390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // this by pretending that the unqualified type was actually 61742390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // qualified __strong. 61752390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers::GC GC_L = LQuals.getObjCGCAttr(); 61762390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers::GC GC_R = RQuals.getObjCGCAttr(); 61772390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements"); 61782390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 61792390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak) 61802390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61812390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 61822390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (GC_L == Qualifiers::Strong) 61832390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return LHS; 61842390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (GC_R == Qualifiers::Strong) 61852390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return RHS; 61862390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61872390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 61882390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 61892390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LHSCan->isObjCObjectPointerType() && RHSCan->isObjCObjectPointerType()) { 61902390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType LHSBaseQT = LHS->getAs<ObjCObjectPointerType>()->getPointeeType(); 61912390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType RHSBaseQT = RHS->getAs<ObjCObjectPointerType>()->getPointeeType(); 61922390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType ResQT = mergeObjCGCQualifiers(LHSBaseQT, RHSBaseQT); 61932390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResQT == LHSBaseQT) 61942390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return LHS; 61952390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResQT == RHSBaseQT) 61962390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return RHS; 61972390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 61982390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 61992390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian} 62002390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 62015426bf6456a5aeac416a9150de157904d101c819Chris Lattner//===----------------------------------------------------------------------===// 6202ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman// Integer Predicates 6203ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman//===----------------------------------------------------------------------===// 620488054dee0402e4d3c1f64e6b697acc47195c0d72Chris Lattner 62054ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadunsigned ASTContext::getIntWidth(QualType T) const { 6206f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall if (const EnumType *ET = dyn_cast<EnumType>(T)) 620729a7f3342c3c6dd15d914c61ae22246c36d51ce7Eli Friedman T = ET->getDecl()->getIntegerType(); 62081274ccd90aec0b205fc838c3d504821ccfb55482Douglas Gregor if (T->isBooleanType()) 62091274ccd90aec0b205fc838c3d504821ccfb55482Douglas Gregor return 1; 6210f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman // For builtin types, just use the standard type sizing method 6211ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return (unsigned)getTypeSize(T); 6212ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman} 6213ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman 6214ad74a758189180b8ab8faea648e4766c3bfd7fcbEli FriedmanQualType ASTContext::getCorrespondingUnsignedType(QualType T) { 6215f60946222721d9ba3c059563935c17b84703187aDouglas Gregor assert(T->hasSignedIntegerRepresentation() && "Unexpected type"); 62166a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner 62176a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner // Turn <4 x signed int> -> <4 x unsigned int> 62186a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner if (const VectorType *VTy = T->getAs<VectorType>()) 62196a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner return getVectorType(getCorrespondingUnsignedType(VTy->getElementType()), 6220e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VTy->getNumElements(), VTy->getVectorKind()); 62216a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner 62226a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner // For enums, we return the unsigned version of the base type. 62236a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner if (const EnumType *ETy = T->getAs<EnumType>()) 6224ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman T = ETy->getDecl()->getIntegerType(); 62256a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner 62266a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner const BuiltinType *BTy = T->getAs<BuiltinType>(); 62276a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner assert(BTy && "Unexpected signed integer type"); 6228ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman switch (BTy->getKind()) { 6229ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Char_S: 6230ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::SChar: 6231ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedCharTy; 6232ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Short: 6233ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedShortTy; 6234ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Int: 6235ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedIntTy; 6236ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Long: 6237ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedLongTy; 6238ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::LongLong: 6239ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedLongLongTy; 62402df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::Int128: 62412df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner return UnsignedInt128Ty; 6242ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman default: 6243b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unexpected signed integer type"); 6244ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman } 6245ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman} 6246ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman 62477b90340c9c7d07aef4e301e72b5e8a30d5f4f0c8Argyrios KyrtzidisASTMutationListener::~ASTMutationListener() { } 62487b90340c9c7d07aef4e301e72b5e8a30d5f4f0c8Argyrios Kyrtzidis 624986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 625086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner//===----------------------------------------------------------------------===// 625186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner// Builtin Type Computation 625286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner//===----------------------------------------------------------------------===// 625386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 625486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner/// DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the 625533daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// pointer over the consumed characters. This returns the resultant type. If 625633daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// AllowTypeModifiers is false then modifier like * are not parsed, just basic 625733daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// types. This allows "v2i*" to be parsed as a pointer to a v2i instead of 625833daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// a vector of "i*". 625914e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner/// 626014e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner/// RequiresICE is filled in on return to indicate whether the value is required 626114e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner/// to be an Integer Constant Expression. 62624ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadstatic QualType DecodeTypeFromStr(const char *&Str, const ASTContext &Context, 626386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner ASTContext::GetBuiltinTypeError &Error, 626414e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner bool &RequiresICE, 626533daae66462e8f51ee153463b32bdefd60c801aaChris Lattner bool AllowTypeModifiers) { 626686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // Modifiers. 626786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner int HowLong = 0; 626886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner bool Signed = false, Unsigned = false; 626914e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE = false; 6270393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner 627133daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // Read the prefixed modifiers first. 627286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner bool Done = false; 627386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner while (!Done) { 627486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner switch (*Str++) { 62751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump default: Done = true; --Str; break; 6276393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner case 'I': 627714e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE = true; 6278393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner break; 627986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'S': 628086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Unsigned && "Can't use both 'S' and 'U' modifiers!"); 628186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Signed && "Can't use 'S' modifier multiple times!"); 628286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Signed = true; 628386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 628486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'U': 628586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Signed && "Can't use both 'S' and 'U' modifiers!"); 628686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Unsigned && "Can't use 'S' modifier multiple times!"); 628786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Unsigned = true; 628886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 628986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'L': 629086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong <= 2 && "Can't have LLLL modifier"); 629186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner ++HowLong; 629286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 629386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 629486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 629586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 629686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner QualType Type; 62971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 629886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // Read the base type. 629986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner switch (*Str++) { 6300b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Unknown builtin type letter!"); 630186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'v': 630286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && 630386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "Bad modifiers used with 'v'!"); 630486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.VoidTy; 630586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 630686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'f': 630786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && 630886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "Bad modifiers used with 'f'!"); 630986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.FloatTy; 631086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 631186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'd': 631286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong < 2 && !Signed && !Unsigned && 631386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "Bad modifiers used with 'd'!"); 631486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (HowLong) 631586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.LongDoubleTy; 631686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 631786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.DoubleTy; 631886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 631986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 's': 632086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && "Bad modifiers used with 's'!"); 632186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Unsigned) 632286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.UnsignedShortTy; 632386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 632486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.ShortTy; 632586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 632686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'i': 632786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (HowLong == 3) 632886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty; 632986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else if (HowLong == 2) 633086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy; 633186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else if (HowLong == 1) 633286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedLongTy : Context.LongTy; 633386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 633486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedIntTy : Context.IntTy; 633586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 633686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'c': 633786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && "Bad modifiers used with 'c'!"); 633886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Signed) 633986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.SignedCharTy; 634086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else if (Unsigned) 634186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.UnsignedCharTy; 634286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 634386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.CharTy; 634486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 634586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'b': // boolean 634686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'b'!"); 634786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.BoolTy; 634886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 634986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'z': // size_t. 635086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'z'!"); 635186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getSizeType(); 635286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 635386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'F': 635486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getCFConstantStringType(); 635586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 6356ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian case 'G': 6357ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian Type = Context.getObjCIdType(); 6358ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian break; 6359ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian case 'H': 6360ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian Type = Context.getObjCSelType(); 6361ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian break; 636286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'a': 636386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getBuiltinVaListType(); 636486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Type.isNull() && "builtin va list type not initialized!"); 636586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 636686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'A': 636786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // This is a "reference" to a va_list; however, what exactly 636886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // this means depends on how va_list is defined. There are two 636986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // different kinds of va_list: ones passed by value, and ones 637086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // passed by reference. An example of a by-value va_list is 637186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // x86, where va_list is a char*. An example of by-ref va_list 637286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // is x86-64, where va_list is a __va_list_tag[1]. For x86, 637386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // we want this argument to be a char*&; for x86-64, we want 637486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // it to be a __va_list_tag*. 637586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getBuiltinVaListType(); 637686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Type.isNull() && "builtin va list type not initialized!"); 637714e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner if (Type->isArrayType()) 637886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getArrayDecayedType(Type); 637914e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner else 638086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getLValueReferenceType(Type); 638186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 638286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'V': { 638386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner char *End; 638486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner unsigned NumElements = strtoul(Str, &End, 10); 638586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(End != Str && "Missing vector size"); 638686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Str = End; 63871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 638814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType ElementType = DecodeTypeFromStr(Str, Context, Error, 638914e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE, false); 639014e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert(!RequiresICE && "Can't require vector ICE"); 639133daae66462e8f51ee153463b32bdefd60c801aaChris Lattner 639233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // TODO: No way to make AltiVec vectors in builtins yet. 6393788b0fd67e1992f23555454efcdb16a19dfefac3Chris Lattner Type = Context.getVectorType(ElementType, NumElements, 6394e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType::GenericVector); 639586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 639686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 6397d3a23b238a2b2c0f11e6ac4951c7410a8c5717bfDouglas Gregor case 'X': { 639814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE, 639914e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner false); 640014e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert(!RequiresICE && "Can't require complex ICE"); 6401d3a23b238a2b2c0f11e6ac4951c7410a8c5717bfDouglas Gregor Type = Context.getComplexType(ElementType); 6402d3a23b238a2b2c0f11e6ac4951c7410a8c5717bfDouglas Gregor break; 6403cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian } 6404cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian case 'Y' : { 6405cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian Type = Context.getPointerDiffType(); 6406cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian break; 6407cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian } 64089a5a7e7351f78345a72c4956af25590f6d40ebcdChris Lattner case 'P': 6409c29f77b769bcc5b6dc85e72c8e3cc2e348e5cf25Douglas Gregor Type = Context.getFILEType(); 6410c29f77b769bcc5b6dc85e72c8e3cc2e348e5cf25Douglas Gregor if (Type.isNull()) { 6411f711c41dd9412a8182793259d355c4f6979ed5edMike Stump Error = ASTContext::GE_Missing_stdio; 641286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return QualType(); 641386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 6414fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump break; 64159a5a7e7351f78345a72c4956af25590f6d40ebcdChris Lattner case 'J': 6416f711c41dd9412a8182793259d355c4f6979ed5edMike Stump if (Signed) 6417782fa308a765aeac2acb39c4e697c937ec21185bMike Stump Type = Context.getsigjmp_bufType(); 6418f711c41dd9412a8182793259d355c4f6979ed5edMike Stump else 6419f711c41dd9412a8182793259d355c4f6979ed5edMike Stump Type = Context.getjmp_bufType(); 6420f711c41dd9412a8182793259d355c4f6979ed5edMike Stump 6421fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump if (Type.isNull()) { 6422f711c41dd9412a8182793259d355c4f6979ed5edMike Stump Error = ASTContext::GE_Missing_setjmp; 6423fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump return QualType(); 6424fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump } 6425fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump break; 6426e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola case 'K': 6427e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'K'!"); 6428e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola Type = Context.getucontext_tType(); 6429e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola 6430e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola if (Type.isNull()) { 6431e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola Error = ASTContext::GE_Missing_ucontext; 6432e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola return QualType(); 6433e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola } 6434e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola break; 6435782fa308a765aeac2acb39c4e697c937ec21185bMike Stump } 64361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 643733daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // If there are modifiers and if we're allowed to parse them, go for it. 643833daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Done = !AllowTypeModifiers; 643986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner while (!Done) { 6440187ab37a05b8f7015b9f39cc8cd9129a0c6d0b48John McCall switch (char c = *Str++) { 644133daae66462e8f51ee153463b32bdefd60c801aaChris Lattner default: Done = true; --Str; break; 644233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case '*': 644333daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case '&': { 644433daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // Both pointers and references can have their pointee types 644533daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // qualified with an address space. 644633daae66462e8f51ee153463b32bdefd60c801aaChris Lattner char *End; 644733daae66462e8f51ee153463b32bdefd60c801aaChris Lattner unsigned AddrSpace = strtoul(Str, &End, 10); 644833daae66462e8f51ee153463b32bdefd60c801aaChris Lattner if (End != Str && AddrSpace != 0) { 644933daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getAddrSpaceQualType(Type, AddrSpace); 645033daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Str = End; 645133daae66462e8f51ee153463b32bdefd60c801aaChris Lattner } 645233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner if (c == '*') 645333daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getPointerType(Type); 645433daae66462e8f51ee153463b32bdefd60c801aaChris Lattner else 645533daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getLValueReferenceType(Type); 645633daae66462e8f51ee153463b32bdefd60c801aaChris Lattner break; 645733daae66462e8f51ee153463b32bdefd60c801aaChris Lattner } 645833daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // FIXME: There's no way to have a built-in with an rvalue ref arg. 645933daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case 'C': 646033daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Type.withConst(); 646133daae66462e8f51ee153463b32bdefd60c801aaChris Lattner break; 646233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case 'D': 646333daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getVolatileType(Type); 646433daae66462e8f51ee153463b32bdefd60c801aaChris Lattner break; 646518932a0f2a94a7813ec461d1118c39ecf8aa936fTed Kremenek case 'R': 646618932a0f2a94a7813ec461d1118c39ecf8aa936fTed Kremenek Type = Type.withRestrict(); 646718932a0f2a94a7813ec461d1118c39ecf8aa936fTed Kremenek break; 646886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 646986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 6470393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner 647114e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert((!RequiresICE || Type->isIntegralOrEnumerationType()) && 6472393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner "Integer constant 'I' type must be an integer"); 64731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 647486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return Type; 647586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner} 647686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 647786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner/// GetBuiltinType - Return the type for the specified builtin. 647833daae66462e8f51ee153463b32bdefd60c801aaChris LattnerQualType ASTContext::GetBuiltinType(unsigned Id, 647914e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner GetBuiltinTypeError &Error, 64804ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned *IntegerConstantArgs) const { 648133daae66462e8f51ee153463b32bdefd60c801aaChris Lattner const char *TypeStr = BuiltinInfo.GetTypeString(Id); 64821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 64835f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 8> ArgTypes; 64841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 648514e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner bool RequiresICE = false; 648686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Error = GE_None; 648714e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType ResType = DecodeTypeFromStr(TypeStr, *this, Error, 648814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE, true); 648986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Error != GE_None) 649086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return QualType(); 649114e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner 649214e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert(!RequiresICE && "Result of intrinsic cannot be required to be an ICE"); 649314e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner 649486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner while (TypeStr[0] && TypeStr[0] != '.') { 649514e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType Ty = DecodeTypeFromStr(TypeStr, *this, Error, RequiresICE, true); 649686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Error != GE_None) 649786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return QualType(); 649886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 649914e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner // If this argument is required to be an IntegerConstantExpression and the 650014e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner // caller cares, fill in the bitmask we return. 650114e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner if (RequiresICE && IntegerConstantArgs) 650214e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner *IntegerConstantArgs |= 1 << ArgTypes.size(); 650314e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner 650486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // Do array -> pointer decay. The builtin should use the decayed type. 650586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Ty->isArrayType()) 650686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Ty = getArrayDecayedType(Ty); 65071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 650886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner ArgTypes.push_back(Ty); 650986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 651086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 651186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert((TypeStr[0] != '.' || TypeStr[1] == 0) && 651286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "'.' should only occur at end of builtin type list!"); 651386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 651400ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall FunctionType::ExtInfo EI; 651500ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall if (BuiltinInfo.isNoReturn(Id)) EI = EI.withNoReturn(true); 651600ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall 651700ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall bool Variadic = (TypeStr[0] == '.'); 651800ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall 651900ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall // We really shouldn't be making a no-proto type here, especially in C++. 652000ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall if (ArgTypes.empty() && Variadic) 652100ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall return getFunctionNoProtoType(ResType, EI); 6522ce056bcaa1c97b89a4b2de2112c62d060863be2bDouglas Gregor 6523e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI; 652400ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall EPI.ExtInfo = EI; 652500ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall EPI.Variadic = Variadic; 6526e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 6527e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall return getFunctionType(ResType, ArgTypes.data(), ArgTypes.size(), EPI); 652886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner} 6529a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman 653090e99a84ddd020e8fda79643748243725a2ed071Argyrios KyrtzidisGVALinkage ASTContext::GetGVALinkageForFunction(const FunctionDecl *FD) { 653190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis GVALinkage External = GVA_StrongExternal; 653290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 653390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis Linkage L = FD->getLinkage(); 653490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (L) { 653590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case NoLinkage: 653690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case InternalLinkage: 653790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case UniqueExternalLinkage: 653890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_Internal; 653990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 654090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case ExternalLinkage: 654190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (FD->getTemplateSpecializationKind()) { 654290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_Undeclared: 654390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitSpecialization: 654490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis External = GVA_StrongExternal; 654590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis break; 654690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 654790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDefinition: 654890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_ExplicitTemplateInstantiation; 654990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 655090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDeclaration: 655190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ImplicitInstantiation: 655290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis External = GVA_TemplateInstantiation; 655390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis break; 655490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 655590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 655690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 655790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (!FD->isInlined()) 655890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return External; 655990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 656090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (!getLangOptions().CPlusPlus || FD->hasAttr<GNUInlineAttr>()) { 656190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // GNU or C99 inline semantics. Determine whether this symbol should be 656290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // externally visible. 656390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (FD->isInlineDefinitionExternallyVisible()) 656490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return External; 656590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 656690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // C99 inline semantics, where the symbol is not externally visible. 656790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_C99Inline; 656890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 656990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 657090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // C++0x [temp.explicit]p9: 657190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // [ Note: The intent is that an inline function that is the subject of 657290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // an explicit instantiation declaration will still be implicitly 657390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // instantiated when used so that the body can be considered for 657490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // inlining, but that no out-of-line copy of the inline function would be 657590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // generated in the translation unit. -- end note ] 657690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (FD->getTemplateSpecializationKind() 657790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis == TSK_ExplicitInstantiationDeclaration) 657890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_C99Inline; 657990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 658090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_CXXInline; 658190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis} 658290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 658390e99a84ddd020e8fda79643748243725a2ed071Argyrios KyrtzidisGVALinkage ASTContext::GetGVALinkageForVariable(const VarDecl *VD) { 658490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // If this is a static data member, compute the kind of template 658590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // specialization. Otherwise, this variable is not part of a 658690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // template. 658790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis TemplateSpecializationKind TSK = TSK_Undeclared; 658890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (VD->isStaticDataMember()) 658990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis TSK = VD->getTemplateSpecializationKind(); 659090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 659190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis Linkage L = VD->getLinkage(); 659290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (L == ExternalLinkage && getLangOptions().CPlusPlus && 659390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis VD->getType()->getLinkage() == UniqueExternalLinkage) 659490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis L = UniqueExternalLinkage; 659590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 659690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (L) { 659790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case NoLinkage: 659890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case InternalLinkage: 659990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case UniqueExternalLinkage: 660090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_Internal; 660190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 660290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case ExternalLinkage: 660390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (TSK) { 660490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_Undeclared: 660590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitSpecialization: 660690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_StrongExternal; 660790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 660890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDeclaration: 660990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis llvm_unreachable("Variable should not be instantiated"); 661090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Fall through to treat this like any other instantiation. 661190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 661290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDefinition: 661390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_ExplicitTemplateInstantiation; 661490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 661590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ImplicitInstantiation: 661690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_TemplateInstantiation; 661790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 661890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 661990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 66207530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie llvm_unreachable("Invalid Linkage!"); 662190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis} 662290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 66234ac7c0bb39696e92fd220118fedc484c09a69870Argyrios Kyrtzidisbool ASTContext::DeclMustBeEmitted(const Decl *D) { 662490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 662590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (!VD->isFileVarDecl()) 662690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 6627144b38a7995cbe0928e34fbcc865bb2d2be4f7a3Argyrios Kyrtzidis } else if (!isa<FunctionDecl>(D)) 662890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 662990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 6630ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis // Weak references don't produce any output by themselves. 6631ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis if (D->hasAttr<WeakRefAttr>()) 6632ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis return false; 6633ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis 663490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Aliases and used decls are required. 663590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (D->hasAttr<AliasAttr>() || D->hasAttr<UsedAttr>()) 663690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 663790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 663890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 663990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Forward declarations aren't required. 664010620eb5164e31208fcbf0437cd79ae535ed0559Sean Hunt if (!FD->doesThisDeclarationHaveABody()) 6641dce67a70a86db8758c926a76fdd980f5369d5746Nick Lewycky return FD->doesDeclarationForceExternallyVisibleDefinition(); 664290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 664390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Constructors and destructors are required. 664490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (FD->hasAttr<ConstructorAttr>() || FD->hasAttr<DestructorAttr>()) 664590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 664690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 664790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // The key function for a class is required. 664890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 664990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis const CXXRecordDecl *RD = MD->getParent(); 665090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (MD->isOutOfLine() && RD->isDynamicClass()) { 665190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis const CXXMethodDecl *KeyFunc = getKeyFunction(RD); 665290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (KeyFunc && KeyFunc->getCanonicalDecl() == MD->getCanonicalDecl()) 665390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 665490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 665590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 665690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 665790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis GVALinkage Linkage = GetGVALinkageForFunction(FD); 665890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 665990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // static, static inline, always_inline, and extern inline functions can 666090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // always be deferred. Normal inline functions can be deferred in C99/C++. 666190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Implicit template instantiations can also be deferred in C++. 666290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (Linkage == GVA_Internal || Linkage == GVA_C99Inline || 66633a5aca8112e03814f78906dc5d032287adb272b5Anton Yartsev Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) 666490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 666590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 666690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 666794da1587f7d584fc61df793229d197969f204cd9Douglas Gregor 666890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis const VarDecl *VD = cast<VarDecl>(D); 666990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis assert(VD->isFileVarDecl() && "Expected file scoped var"); 667090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 6671ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly) 6672ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis return false; 6673ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis 667490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Structs that have non-trivial constructors or destructors are required. 667590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 667690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // FIXME: Handle references. 6677023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt // FIXME: Be more selective about which constructors we care about. 667890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const RecordType *RT = VD->getType()->getAs<RecordType>()) { 667990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 6680023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt if (RD->hasDefinition() && !(RD->hasTrivialDefaultConstructor() && 6681023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt RD->hasTrivialCopyConstructor() && 6682023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt RD->hasTrivialMoveConstructor() && 6683023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt RD->hasTrivialDestructor())) 668490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 668590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 668690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 668790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 668890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis GVALinkage L = GetGVALinkageForVariable(VD); 668990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (L == GVA_Internal || L == GVA_TemplateInstantiation) { 669090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (!(VD->getInit() && VD->getInit()->HasSideEffects(*this))) 669190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 669290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 669390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 669490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 669590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis} 6696071cc7deffad608165b1ddd5263e8bf181861520Charles Davis 6697ee743f903858e337434ac0335f147f4de4ecae05Charles DavisCallingConv ASTContext::getDefaultMethodCallConv() { 6698ee743f903858e337434ac0335f147f4de4ecae05Charles Davis // Pass through to the C++ ABI object 6699ee743f903858e337434ac0335f147f4de4ecae05Charles Davis return ABI->getDefaultMethodCallConv(); 6700ee743f903858e337434ac0335f147f4de4ecae05Charles Davis} 6701ee743f903858e337434ac0335f147f4de4ecae05Charles Davis 67024ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadbool ASTContext::isNearlyEmpty(const CXXRecordDecl *RD) const { 6703dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson // Pass through to the C++ ABI object 6704dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson return ABI->isNearlyEmpty(RD); 6705dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson} 6706dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson 670714110477887e3dc168ffc6c191e72d705051f99ePeter CollingbourneMangleContext *ASTContext::createMangleContext() { 6708bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor switch (Target->getCXXABI()) { 670914110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne case CXXABI_ARM: 671014110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne case CXXABI_Itanium: 671114110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne return createItaniumMangleContext(*this, getDiagnostics()); 671214110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne case CXXABI_Microsoft: 671314110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne return createMicrosoftMangleContext(*this, getDiagnostics()); 671414110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne } 6715b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unsupported ABI"); 671614110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne} 671714110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne 6718071cc7deffad608165b1ddd5263e8bf181861520Charles DavisCXXABI::~CXXABI() {} 6719ba29bd25515fbd99e98ba0fedb9d93617b27609eTed Kremenek 6720ba29bd25515fbd99e98ba0fedb9d93617b27609eTed Kremeneksize_t ASTContext::getSideTableAllocatedMemory() const { 67210c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek return ASTRecordLayouts.getMemorySize() 67220c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(ObjCLayouts) 67230c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(KeyFunctions) 67240c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(ObjCImpls) 67250c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(BlockVarCopyInits) 67260c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(DeclAttrs) 67270c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromStaticDataMember) 67280c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromUsingDecl) 67290c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromUsingShadowDecl) 67300c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromUnnamedFieldDecl) 67310c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(OverriddenMethods) 67320c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(Types) 6733af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet + llvm::capacity_in_bytes(VariableArrayTypes) 67340d95f0d7b81110f77e99e833f766d19be7b7e072Francois Pichet + llvm::capacity_in_bytes(ClassScopeSpecializationPattern); 6735ba29bd25515fbd99e98ba0fedb9d93617b27609eTed Kremenek} 6736d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek 67379e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregorunsigned ASTContext::getLambdaManglingNumber(CXXMethodDecl *CallOperator) { 67389e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregor CXXRecordDecl *Lambda = CallOperator->getParent(); 67399e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregor return LambdaMangleContexts[Lambda->getDeclContext()] 67409e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregor .getManglingNumber(CallOperator); 67419e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregor} 67429e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregor 67439e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregor 6744d211cb709510fbe7e75167b9feee0050851d001aTed Kremenekvoid ASTContext::setParameterIndex(const ParmVarDecl *D, unsigned int index) { 6745d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek ParamIndices[D] = index; 6746d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek} 6747d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek 6748d211cb709510fbe7e75167b9feee0050851d001aTed Kremenekunsigned ASTContext::getParameterIndex(const ParmVarDecl *D) const { 6749d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek ParameterIndexTable::const_iterator I = ParamIndices.find(D); 6750d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek assert(I != ParamIndices.end() && 6751d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek "ParmIndices lacks entry set by ParmVarDecl"); 6752d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek return I->second; 6753d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek} 6754