ASTContext.cpp revision c5613b26a24a33d7450e3d0bf315c6ccc920ce7b
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 2094dc34ebf2a0716bf77ba110dab6777a3fc4397ddPeter Collingbourne 3, // opencl_constant 2104dc34ebf2a0716bf77ba110dab6777a3fc4397ddPeter Collingbourne 4, // cuda_device 2114dc34ebf2a0716bf77ba110dab6777a3fc4397ddPeter Collingbourne 5, // cuda_constant 2124dc34ebf2a0716bf77ba110dab6777a3fc4397ddPeter Collingbourne 6 // cuda_shared 213207f4d8543529221932af82836016a2ef066c917Peter Collingbourne }; 214bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor return &FakeAddrSpaceMap; 215207f4d8543529221932af82836016a2ef066c917Peter Collingbourne } else { 216bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor return &T.getAddressSpaceMap(); 217207f4d8543529221932af82836016a2ef066c917Peter Collingbourne } 218207f4d8543529221932af82836016a2ef066c917Peter Collingbourne} 219207f4d8543529221932af82836016a2ef066c917Peter Collingbourne 2203e3cd93b2fd9644e970c389e715c13883faf68b6Douglas GregorASTContext::ASTContext(LangOptions& LOpts, SourceManager &SM, 221bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor const TargetInfo *t, 222e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar IdentifierTable &idents, SelectorTable &sels, 2231b63e4f732dbc73d90abf886b4d21f8e3a165f6dChris Lattner Builtin::Context &builtins, 224bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor unsigned size_reserve, 225bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor bool DelayInitialization) 226bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor : FunctionProtoTypes(this_()), 227bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor TemplateSpecializationTypes(this_()), 228bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor DependentTemplateSpecializationTypes(this_()), 229bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor SubstTemplateTemplateParmPacks(this_()), 230bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor GlobalNestedNameSpecifier(0), 231bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Int128Decl(0), UInt128Decl(0), 232c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge BuiltinVaListDecl(0), 233a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor ObjCIdDecl(0), ObjCSelDecl(0), ObjCClassDecl(0), ObjCProtocolClassDecl(0), 234e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor CFConstantStringTypeDecl(0), ObjCInstanceTypeDecl(0), 235bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor FILEDecl(0), 236e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola jmp_bufDecl(0), sigjmp_bufDecl(0), ucontext_tDecl(0), 237e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola BlockDescriptorType(0), BlockDescriptorExtendedType(0), 238e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola cudaConfigureCallDecl(0), 239e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor NullTypeSourceInfo(QualType()), 240e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor FirstLocalImport(), LastLocalImport(), 241bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor SourceMgr(SM), LangOpts(LOpts), 24230c42404202d2e2512e51efc6066bd614cfdb5a4Douglas Gregor AddrSpaceMap(0), Target(t), PrintingPolicy(LOpts), 243bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Idents(idents), Selectors(sels), 244bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor BuiltinInfo(builtins), 245bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor DeclarationNames(*this), 24630c42404202d2e2512e51efc6066bd614cfdb5a4Douglas Gregor ExternalSource(0), Listener(0), 247bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor LastSDM(0, 0), 248bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor UniqueBlockByRefTypeID(0) 249bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor{ 2501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (size_reserve > 0) Types.reserve(size_reserve); 251e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar TUDecl = TranslationUnitDecl::Create(*this); 252bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor 253bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor if (!DelayInitialization) { 254bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor assert(t && "No target supplied for ASTContext initialization"); 255bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor InitBuiltinTypes(*t); 256bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor } 257e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar} 258e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar 2595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerASTContext::~ASTContext() { 2603478eb6872d836600caf45b0f81c2065d685d6e0Ted Kremenek // Release the DenseMaps associated with DeclContext objects. 2613478eb6872d836600caf45b0f81c2065d685d6e0Ted Kremenek // FIXME: Is this the ideal solution? 2623478eb6872d836600caf45b0f81c2065d685d6e0Ted Kremenek ReleaseDeclContextMaps(); 2637d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 26463fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor // Call all of the deallocation functions. 26563fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor for (unsigned I = 0, N = Deallocations.size(); I != N; ++I) 26663fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor Deallocations[I].first(Deallocations[I].second); 2670054531488928a424666ac11fcdc6bcc5112de52Douglas Gregor 268dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek // ASTRecordLayout objects in ASTRecordLayouts must always be destroyed 26963fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor // because they can contain DenseMaps. 27063fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor for (llvm::DenseMap<const ObjCContainerDecl*, 27163fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor const ASTRecordLayout*>::iterator 27263fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor I = ObjCLayouts.begin(), E = ObjCLayouts.end(); I != E; ) 27363fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor // Increment in loop to prevent using deallocated memory. 27463fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor if (ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second)) 27563fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor R->Destroy(*this); 27663fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor 277dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator 278dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) { 279dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek // Increment in loop to prevent using deallocated memory. 280dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek if (ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second)) 281dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek R->Destroy(*this); 282dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek } 2836320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 2846320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(), 2856320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor AEnd = DeclAttrs.end(); 2866320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor A != AEnd; ++A) 2876320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor A->second->~AttrVec(); 2886320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor} 289ab452ba8323d1985e08bade2bced588cddf2cc28Douglas Gregor 2900054531488928a424666ac11fcdc6bcc5112de52Douglas Gregorvoid ASTContext::AddDeallocation(void (*Callback)(void*), void *Data) { 2910054531488928a424666ac11fcdc6bcc5112de52Douglas Gregor Deallocations.push_back(std::make_pair(Callback, Data)); 2920054531488928a424666ac11fcdc6bcc5112de52Douglas Gregor} 2930054531488928a424666ac11fcdc6bcc5112de52Douglas Gregor 2941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid 2956f42b62b6194f53bcbc349f5d17388e1936535d7Dylan NoblesmithASTContext::setExternalSource(OwningPtr<ExternalASTSource> &Source) { 2962cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor ExternalSource.reset(Source.take()); 2972cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor} 2982cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor 2995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid ASTContext::PrintStats() const { 300cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << "\n*** AST Context Stats:\n"; 301cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << " " << Types.size() << " types total.\n"; 3027c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 303dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor unsigned counts[] = { 3041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump#define TYPE(Name, Parent) 0, 305dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor#define ABSTRACT_TYPE(Name, Parent) 306dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor#include "clang/AST/TypeNodes.def" 307dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor 0 // Extra 308dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor }; 309c2ee10d79f70036af652a395ac1f8273f3d04e12Douglas Gregor 3105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0, e = Types.size(); i != e; ++i) { 3115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Type *T = Types[i]; 312dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor counts[(unsigned)T->getTypeClass()]++; 3135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 315dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor unsigned Idx = 0; 316dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor unsigned TotalBytes = 0; 317dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor#define TYPE(Name, Parent) \ 318dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor if (counts[Idx]) \ 319cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << " " << counts[Idx] << " " << #Name \ 320cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " types\n"; \ 321dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor TotalBytes += counts[Idx] * sizeof(Name##Type); \ 322dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor ++Idx; 323dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor#define ABSTRACT_TYPE(Name, Parent) 324dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor#include "clang/AST/TypeNodes.def" 3251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 326cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << "Total bytes = " << TotalBytes << "\n"; 327cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth 3284923aa25eb39d64106a5817c02d560a3aecf8b2cDouglas Gregor // Implicit special member functions. 329cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << NumImplicitDefaultConstructorsDeclared << "/" 330cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << NumImplicitDefaultConstructors 331cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " implicit default constructors created\n"; 332cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << NumImplicitCopyConstructorsDeclared << "/" 333cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << NumImplicitCopyConstructors 334cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " implicit copy constructors created\n"; 3354e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (getLangOpts().CPlusPlus) 336cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << NumImplicitMoveConstructorsDeclared << "/" 337cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << NumImplicitMoveConstructors 338cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " implicit move constructors created\n"; 339cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << NumImplicitCopyAssignmentOperatorsDeclared << "/" 340cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << NumImplicitCopyAssignmentOperators 341cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " implicit copy assignment operators created\n"; 3424e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (getLangOpts().CPlusPlus) 343cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << NumImplicitMoveAssignmentOperatorsDeclared << "/" 344cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << NumImplicitMoveAssignmentOperators 345cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " implicit move assignment operators created\n"; 346cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << NumImplicitDestructorsDeclared << "/" 347cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << NumImplicitDestructors 348cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth << " implicit destructors created\n"; 349cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth 3502cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor if (ExternalSource.get()) { 351cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth llvm::errs() << "\n"; 3522cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor ExternalSource->PrintStats(); 3532cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor } 354cd92a65edc7cbbbb7e3aee8d31008594de90fa51Chandler Carruth 35563fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor BumpAlloc.PrintStats(); 3565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 358772eeaefef2c883aabe35caf4543e7e32d290183Douglas GregorTypedefDecl *ASTContext::getInt128Decl() const { 359772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor if (!Int128Decl) { 360772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(Int128Ty); 361772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor Int128Decl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 362772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor getTranslationUnitDecl(), 363772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor SourceLocation(), 364772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor SourceLocation(), 365772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor &Idents.get("__int128_t"), 366772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor TInfo); 367772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor } 368772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor 369772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor return Int128Decl; 370772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor} 371772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor 372772eeaefef2c883aabe35caf4543e7e32d290183Douglas GregorTypedefDecl *ASTContext::getUInt128Decl() const { 373772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor if (!UInt128Decl) { 374772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(UnsignedInt128Ty); 375772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor UInt128Decl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 376772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor getTranslationUnitDecl(), 377772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor SourceLocation(), 378772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor SourceLocation(), 379772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor &Idents.get("__uint128_t"), 380772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor TInfo); 381772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor } 382772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor 383772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor return UInt128Decl; 384772eeaefef2c883aabe35caf4543e7e32d290183Douglas Gregor} 3855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 386e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCallvoid ASTContext::InitBuiltinType(CanQualType &R, BuiltinType::Kind K) { 3876b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall BuiltinType *Ty = new (*this, TypeAlignment) BuiltinType(K); 388e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCall R = CanQualType::CreateUnsafe(QualType(Ty, 0)); 3896b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall Types.push_back(Ty); 3905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 392bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregorvoid ASTContext::InitBuiltinTypes(const TargetInfo &Target) { 393bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor assert((!this->Target || this->Target == &Target) && 394bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor "Incorrect target reinitialization"); 3955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(VoidTy.isNull() && "Context reinitialized?"); 3961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 397bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor this->Target = &Target; 398bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor 399bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor ABI.reset(createCXXABI(Target)); 400bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor AddrSpaceMap = getAddressSpaceMap(Target, LangOpts); 401bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor 4025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p19. 4035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(VoidTy, BuiltinType::Void); 4041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p2. 4065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(BoolTy, BuiltinType::Bool); 4075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p3. 40815b91764d08e886391c865c4a444d7b51141c284Eli Friedman if (LangOpts.CharIsSigned) 4095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(CharTy, BuiltinType::Char_S); 4105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer else 4115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(CharTy, BuiltinType::Char_U); 4125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p4. 4135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(SignedCharTy, BuiltinType::SChar); 4145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(ShortTy, BuiltinType::Short); 4155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(IntTy, BuiltinType::Int); 4165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(LongTy, BuiltinType::Long); 4175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(LongLongTy, BuiltinType::LongLong); 4181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p6. 4205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(UnsignedCharTy, BuiltinType::UChar); 4215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(UnsignedShortTy, BuiltinType::UShort); 4225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(UnsignedIntTy, BuiltinType::UInt); 4235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(UnsignedLongTy, BuiltinType::ULong); 4245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(UnsignedLongLongTy, BuiltinType::ULongLong); 4251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p10. 4275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(FloatTy, BuiltinType::Float); 4285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(DoubleTy, BuiltinType::Double); 4295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InitBuiltinType(LongDoubleTy, BuiltinType::LongDouble); 43064c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 4312df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner // GNU extension, 128-bit integers. 4322df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner InitBuiltinType(Int128Ty, BuiltinType::Int128); 4332df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner InitBuiltinType(UnsignedInt128Ty, BuiltinType::UInt128); 4342df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner 4353f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner if (LangOpts.CPlusPlus) { // C++ 3.9.1p5 436d3d77cd138f8e830f6547b6f83fcd5721ccf5f5dEli Friedman if (TargetInfo::isTypeSigned(Target.getWCharType())) 4373f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner InitBuiltinType(WCharTy, BuiltinType::WChar_S); 4383f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner else // -fshort-wchar makes wchar_t be unsigned. 4393f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner InitBuiltinType(WCharTy, BuiltinType::WChar_U); 4403f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner } else // C99 4413a2503227c3db04a3619735127483263c1075ef7Chris Lattner WCharTy = getFromTargetType(Target.getWCharType()); 44264c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 443392da48160bd92ceb486792780467cbfdb2d0e8cJames Molloy WIntTy = getFromTargetType(Target.getWIntType()); 444392da48160bd92ceb486792780467cbfdb2d0e8cJames Molloy 445f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++ 446f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith InitBuiltinType(Char16Ty, BuiltinType::Char16); 447f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith else // C99 448f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith Char16Ty = getFromTargetType(Target.getChar16Type()); 449f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith 450f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++ 451f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith InitBuiltinType(Char32Ty, BuiltinType::Char32); 452f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith else // C99 453f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith Char32Ty = getFromTargetType(Target.getChar32Type()); 454f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith 455898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // Placeholder type for type-dependent expressions whose type is 456898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // completely unknown. No code should ever check a type against 457898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // DependentTy and users should never see it; however, it is here to 458898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // help diagnose failures to properly check for type-dependent 459898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // expressions. 460898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor InitBuiltinType(DependentTy, BuiltinType::Dependent); 4618e9bebdea69c590dedfbf27374114cb76fe12fbdDouglas Gregor 4622a984cad5ac3fdceeff2bd99daa7b90979313475John McCall // Placeholder type for functions. 4632a984cad5ac3fdceeff2bd99daa7b90979313475John McCall InitBuiltinType(OverloadTy, BuiltinType::Overload); 4642a984cad5ac3fdceeff2bd99daa7b90979313475John McCall 465864c041e118155c2b1ce0ba36942a3da5a4a055eJohn McCall // Placeholder type for bound members. 466864c041e118155c2b1ce0ba36942a3da5a4a055eJohn McCall InitBuiltinType(BoundMemberTy, BuiltinType::BoundMember); 467864c041e118155c2b1ce0ba36942a3da5a4a055eJohn McCall 4683c3b7f90a863af43fa63043d396553ecf205351cJohn McCall // Placeholder type for pseudo-objects. 4693c3b7f90a863af43fa63043d396553ecf205351cJohn McCall InitBuiltinType(PseudoObjectTy, BuiltinType::PseudoObject); 4703c3b7f90a863af43fa63043d396553ecf205351cJohn McCall 4711de4d4e8cb2e9c88809fea8092bc6e835a5473d2John McCall // "any" type; useful for debugger-like clients. 4721de4d4e8cb2e9c88809fea8092bc6e835a5473d2John McCall InitBuiltinType(UnknownAnyTy, BuiltinType::UnknownAny); 4731de4d4e8cb2e9c88809fea8092bc6e835a5473d2John McCall 4740ddaeb9b031070ec64afe92d9892875ac44df427John McCall // Placeholder type for unbridged ARC casts. 4750ddaeb9b031070ec64afe92d9892875ac44df427John McCall InitBuiltinType(ARCUnbridgedCastTy, BuiltinType::ARCUnbridgedCast); 4760ddaeb9b031070ec64afe92d9892875ac44df427John McCall 4775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.2.5p11. 4785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer FloatComplexTy = getComplexType(FloatTy); 4795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer DoubleComplexTy = getComplexType(DoubleTy); 4805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer LongDoubleComplexTy = getComplexType(LongDoubleTy); 4818e9bebdea69c590dedfbf27374114cb76fe12fbdDouglas Gregor 48213dcd00615de5c4279d97bdf63cd5f0a14fd9dccFariborz Jahanian // Builtin types for 'id', 'Class', and 'SEL'. 483de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId); 484de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff InitBuiltinType(ObjCBuiltinClassTy, BuiltinType::ObjCClass); 48513dcd00615de5c4279d97bdf63cd5f0a14fd9dccFariborz Jahanian InitBuiltinType(ObjCBuiltinSelTy, BuiltinType::ObjCSel); 486ebcb57a8d298862c65043e88b2429591ab3c58d3Ted Kremenek 487ebcb57a8d298862c65043e88b2429591ab3c58d3Ted Kremenek // Builtin type for __objc_yes and __objc_no 48893a49944e0e68e32bc22d45d44ee136b34beffb3Fariborz Jahanian ObjCBuiltinBoolTy = (Target.useSignedCharForObjCBool() ? 48993a49944e0e68e32bc22d45d44ee136b34beffb3Fariborz Jahanian SignedCharTy : BoolTy); 490ebcb57a8d298862c65043e88b2429591ab3c58d3Ted Kremenek 491a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCConstantStringType = QualType(); 4921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 49333e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // void * type 49433e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian VoidPtrTy = getPointerType(VoidTy); 4956e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl 4966e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl // nullptr type (C++0x 2.14.7) 4976e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl InitBuiltinType(NullPtrTy, BuiltinType::NullPtr); 498aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov 499aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov // half type (OpenCL 6.1.1.1) / ARM NEON __fp16 500aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov InitBuiltinType(HalfTy, BuiltinType::Half); 5015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 5025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 503d6471f7c1921c7802804ce3ff6fe9768310f72b9David BlaikieDiagnosticsEngine &ASTContext::getDiagnostics() const { 50478a916ec5ff5b66adec3c499e1b9af7b87668309Argyrios Kyrtzidis return SourceMgr.getDiagnostics(); 50578a916ec5ff5b66adec3c499e1b9af7b87668309Argyrios Kyrtzidis} 50678a916ec5ff5b66adec3c499e1b9af7b87668309Argyrios Kyrtzidis 5076320064d0c60fa8683f5623881c9394fd4aa7689Douglas GregorAttrVec& ASTContext::getDeclAttrs(const Decl *D) { 5086320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor AttrVec *&Result = DeclAttrs[D]; 5096320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor if (!Result) { 5106320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor void *Mem = Allocate(sizeof(AttrVec)); 5116320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor Result = new (Mem) AttrVec; 5126320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor } 5136320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 5146320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor return *Result; 5156320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor} 5166320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 5176320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor/// \brief Erase the attributes corresponding to the given declaration. 5186320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregorvoid ASTContext::eraseDeclAttrs(const Decl *D) { 5196320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D); 5206320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor if (Pos != DeclAttrs.end()) { 5216320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor Pos->second->~AttrVec(); 5226320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor DeclAttrs.erase(Pos); 5236320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor } 5246320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor} 5256320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 526251b4ff2578e26959a4c036140ccd61c5e9292f2Douglas GregorMemberSpecializationInfo * 527663b5a0be7261c29bc4c526a71cffcfa02d4153eDouglas GregorASTContext::getInstantiatedFromStaticDataMember(const VarDecl *Var) { 5287caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor assert(Var->isStaticDataMember() && "Not a static data member"); 529663b5a0be7261c29bc4c526a71cffcfa02d4153eDouglas Gregor llvm::DenseMap<const VarDecl *, MemberSpecializationInfo *>::iterator Pos 5307caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor = InstantiatedFromStaticDataMember.find(Var); 5317caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor if (Pos == InstantiatedFromStaticDataMember.end()) 5327caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor return 0; 5331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5347caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor return Pos->second; 5357caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor} 5367caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor 5371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid 538251b4ff2578e26959a4c036140ccd61c5e9292f2Douglas GregorASTContext::setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl, 5399421adc43891e272156fab640e5d5ee5054b779cArgyrios Kyrtzidis TemplateSpecializationKind TSK, 5409421adc43891e272156fab640e5d5ee5054b779cArgyrios Kyrtzidis SourceLocation PointOfInstantiation) { 5417caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor assert(Inst->isStaticDataMember() && "Not a static data member"); 5427caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor assert(Tmpl->isStaticDataMember() && "Not a static data member"); 5437caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor assert(!InstantiatedFromStaticDataMember[Inst] && 5447caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor "Already noted what static data member was instantiated from"); 545251b4ff2578e26959a4c036140ccd61c5e9292f2Douglas Gregor InstantiatedFromStaticDataMember[Inst] 5469421adc43891e272156fab640e5d5ee5054b779cArgyrios Kyrtzidis = new (*this) MemberSpecializationInfo(Tmpl, TSK, PointOfInstantiation); 5477caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor} 5487caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor 549af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois PichetFunctionDecl *ASTContext::getClassScopeSpecializationPattern( 550af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet const FunctionDecl *FD){ 551af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet assert(FD && "Specialization is 0"); 552af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet llvm::DenseMap<const FunctionDecl*, FunctionDecl *>::const_iterator Pos 5530d95f0d7b81110f77e99e833f766d19be7b7e072Francois Pichet = ClassScopeSpecializationPattern.find(FD); 5540d95f0d7b81110f77e99e833f766d19be7b7e072Francois Pichet if (Pos == ClassScopeSpecializationPattern.end()) 555af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet return 0; 556af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet 557af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet return Pos->second; 558af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet} 559af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet 560af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichetvoid ASTContext::setClassScopeSpecializationPattern(FunctionDecl *FD, 561af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet FunctionDecl *Pattern) { 562af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet assert(FD && "Specialization is 0"); 563af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet assert(Pattern && "Class scope specialization pattern is 0"); 5640d95f0d7b81110f77e99e833f766d19be7b7e072Francois Pichet ClassScopeSpecializationPattern[FD] = Pattern; 565af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet} 566af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet 5677ba107a1863ddfa1664555854f0d7bdb3c491c92John McCallNamedDecl * 568ed97649e9574b9d854fa4d6109c9333ae0993554John McCallASTContext::getInstantiatedFromUsingDecl(UsingDecl *UUD) { 5697ba107a1863ddfa1664555854f0d7bdb3c491c92John McCall llvm::DenseMap<UsingDecl *, NamedDecl *>::const_iterator Pos 570ed97649e9574b9d854fa4d6109c9333ae0993554John McCall = InstantiatedFromUsingDecl.find(UUD); 571ed97649e9574b9d854fa4d6109c9333ae0993554John McCall if (Pos == InstantiatedFromUsingDecl.end()) 5720d8df780aef1acda5962347a32591efc629b6748Anders Carlsson return 0; 5731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5740d8df780aef1acda5962347a32591efc629b6748Anders Carlsson return Pos->second; 5750d8df780aef1acda5962347a32591efc629b6748Anders Carlsson} 5760d8df780aef1acda5962347a32591efc629b6748Anders Carlsson 5770d8df780aef1acda5962347a32591efc629b6748Anders Carlssonvoid 578ed97649e9574b9d854fa4d6109c9333ae0993554John McCallASTContext::setInstantiatedFromUsingDecl(UsingDecl *Inst, NamedDecl *Pattern) { 579ed97649e9574b9d854fa4d6109c9333ae0993554John McCall assert((isa<UsingDecl>(Pattern) || 580ed97649e9574b9d854fa4d6109c9333ae0993554John McCall isa<UnresolvedUsingValueDecl>(Pattern) || 581ed97649e9574b9d854fa4d6109c9333ae0993554John McCall isa<UnresolvedUsingTypenameDecl>(Pattern)) && 582ed97649e9574b9d854fa4d6109c9333ae0993554John McCall "pattern decl is not a using decl"); 583ed97649e9574b9d854fa4d6109c9333ae0993554John McCall assert(!InstantiatedFromUsingDecl[Inst] && "pattern already exists"); 584ed97649e9574b9d854fa4d6109c9333ae0993554John McCall InstantiatedFromUsingDecl[Inst] = Pattern; 585ed97649e9574b9d854fa4d6109c9333ae0993554John McCall} 586ed97649e9574b9d854fa4d6109c9333ae0993554John McCall 587ed97649e9574b9d854fa4d6109c9333ae0993554John McCallUsingShadowDecl * 588ed97649e9574b9d854fa4d6109c9333ae0993554John McCallASTContext::getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst) { 589ed97649e9574b9d854fa4d6109c9333ae0993554John McCall llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos 590ed97649e9574b9d854fa4d6109c9333ae0993554John McCall = InstantiatedFromUsingShadowDecl.find(Inst); 591ed97649e9574b9d854fa4d6109c9333ae0993554John McCall if (Pos == InstantiatedFromUsingShadowDecl.end()) 592ed97649e9574b9d854fa4d6109c9333ae0993554John McCall return 0; 593ed97649e9574b9d854fa4d6109c9333ae0993554John McCall 594ed97649e9574b9d854fa4d6109c9333ae0993554John McCall return Pos->second; 595ed97649e9574b9d854fa4d6109c9333ae0993554John McCall} 596ed97649e9574b9d854fa4d6109c9333ae0993554John McCall 597ed97649e9574b9d854fa4d6109c9333ae0993554John McCallvoid 598ed97649e9574b9d854fa4d6109c9333ae0993554John McCallASTContext::setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, 599ed97649e9574b9d854fa4d6109c9333ae0993554John McCall UsingShadowDecl *Pattern) { 600ed97649e9574b9d854fa4d6109c9333ae0993554John McCall assert(!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists"); 601ed97649e9574b9d854fa4d6109c9333ae0993554John McCall InstantiatedFromUsingShadowDecl[Inst] = Pattern; 6020d8df780aef1acda5962347a32591efc629b6748Anders Carlsson} 6030d8df780aef1acda5962347a32591efc629b6748Anders Carlsson 604d8b285fee4471f393da8ee30f552ceacdc362afaAnders CarlssonFieldDecl *ASTContext::getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) { 605d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos 606d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson = InstantiatedFromUnnamedFieldDecl.find(Field); 607d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson if (Pos == InstantiatedFromUnnamedFieldDecl.end()) 608d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson return 0; 6091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 610d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson return Pos->second; 611d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson} 612d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson 613d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlssonvoid ASTContext::setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, 614d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson FieldDecl *Tmpl) { 615d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson assert(!Inst->getDeclName() && "Instantiated field decl is not unnamed"); 616d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson assert(!Tmpl->getDeclName() && "Template field decl is not unnamed"); 617d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson assert(!InstantiatedFromUnnamedFieldDecl[Inst] && 618d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson "Already noted what unnamed field was instantiated from"); 6191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 620d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl; 621d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson} 622d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson 62314d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanianbool ASTContext::ZeroBitfieldFollowsNonBitfield(const FieldDecl *FD, 62414d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanian const FieldDecl *LastFD) const { 62514d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanian return (FD->isBitField() && LastFD && !LastFD->isBitField() && 626a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith FD->getBitWidthValue(*this) == 0); 62714d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanian} 62814d56ef43ff4921c6749f7340212fbb743fdbb9bFariborz Jahanian 629340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanianbool ASTContext::ZeroBitfieldFollowsBitfield(const FieldDecl *FD, 630340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanian const FieldDecl *LastFD) const { 631340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanian return (FD->isBitField() && LastFD && LastFD->isBitField() && 632a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith FD->getBitWidthValue(*this) == 0 && 633a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith LastFD->getBitWidthValue(*this) != 0); 634340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanian} 635340fa242130c2d8d74c83edca0952e771aebe0e6Fariborz Jahanian 6369b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanianbool ASTContext::BitfieldFollowsBitfield(const FieldDecl *FD, 6379b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanian const FieldDecl *LastFD) const { 6389b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanian return (FD->isBitField() && LastFD && LastFD->isBitField() && 639a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith FD->getBitWidthValue(*this) && 640a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith LastFD->getBitWidthValue(*this)); 6419b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanian} 6429b3acaa32548d0ce78b9c39a3911397f6738a47cFariborz Jahanian 643dd7fddb5b6883326e52b278a9b7e9cefea29aae0Chad Rosierbool ASTContext::NonBitfieldFollowsBitfield(const FieldDecl *FD, 64452bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian const FieldDecl *LastFD) const { 64552bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian return (!FD->isBitField() && LastFD && LastFD->isBitField() && 646a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith LastFD->getBitWidthValue(*this)); 64752bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian} 64852bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian 649dd7fddb5b6883326e52b278a9b7e9cefea29aae0Chad Rosierbool ASTContext::BitfieldFollowsNonBitfield(const FieldDecl *FD, 65052bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian const FieldDecl *LastFD) const { 65152bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian return (FD->isBitField() && LastFD && !LastFD->isBitField() && 652a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith FD->getBitWidthValue(*this)); 65352bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian} 65452bbe7a1133c3cb57e9246f1b96c12940ea3821aFariborz Jahanian 6557d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas GregorASTContext::overridden_cxx_method_iterator 6567d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas GregorASTContext::overridden_methods_begin(const CXXMethodDecl *Method) const { 6577d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 6587d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor = OverriddenMethods.find(Method); 6597d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor if (Pos == OverriddenMethods.end()) 6607d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor return 0; 6617d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 6627d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor return Pos->second.begin(); 6637d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor} 6647d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 6657d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas GregorASTContext::overridden_cxx_method_iterator 6667d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas GregorASTContext::overridden_methods_end(const CXXMethodDecl *Method) const { 6677d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 6687d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor = OverriddenMethods.find(Method); 6697d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor if (Pos == OverriddenMethods.end()) 6707d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor return 0; 6717d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 6727d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor return Pos->second.end(); 6737d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor} 6747d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 675c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidisunsigned 676c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios KyrtzidisASTContext::overridden_methods_size(const CXXMethodDecl *Method) const { 677c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 678c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis = OverriddenMethods.find(Method); 679c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis if (Pos == OverriddenMethods.end()) 680c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis return 0; 681c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis 682c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis return Pos->second.size(); 683c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis} 684c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis 6857d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregorvoid ASTContext::addOverriddenMethod(const CXXMethodDecl *Method, 6867d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor const CXXMethodDecl *Overridden) { 6877d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor OverriddenMethods[Method].push_back(Overridden); 6887d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor} 6897d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 690e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregorvoid ASTContext::addedLocalImportDecl(ImportDecl *Import) { 691e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor assert(!Import->NextLocalImport && "Import declaration already in the chain"); 692e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor assert(!Import->isFromASTFile() && "Non-local import declaration"); 693e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor if (!FirstLocalImport) { 694e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor FirstLocalImport = Import; 695e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor LastLocalImport = Import; 696e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor return; 697e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor } 698e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor 699e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor LastLocalImport->NextLocalImport = Import; 700e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor LastLocalImport = Import; 701e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor} 702e664977aca2a05a77abab5a06dc0fb69e870cfb9Douglas Gregor 703464175bba1318bef7905122e9fda20cff926df78Chris Lattner//===----------------------------------------------------------------------===// 704464175bba1318bef7905122e9fda20cff926df78Chris Lattner// Type Sizing and Analysis 705464175bba1318bef7905122e9fda20cff926df78Chris Lattner//===----------------------------------------------------------------------===// 706a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 707b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner/// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified 708b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner/// scalar floating point type. 709b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattnerconst llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const { 710183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const BuiltinType *BT = T->getAs<BuiltinType>(); 711b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner assert(BT && "Not a floating point type!"); 712b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner switch (BT->getKind()) { 713b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Not a floating point type!"); 714aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov case BuiltinType::Half: return Target->getHalfFormat(); 715bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor case BuiltinType::Float: return Target->getFloatFormat(); 716bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor case BuiltinType::Double: return Target->getDoubleFormat(); 717bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor case BuiltinType::LongDouble: return Target->getLongDoubleFormat(); 718b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner } 719b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner} 720b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner 7218b752f10c394b140f9ef89e049cbad1a7676fc25Ken Dyck/// getDeclAlign - Return a conservative estimate of the alignment of the 722af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner/// specified decl. Note that bitfields do not have a valid alignment, so 723af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner/// this method will assert on them. 7245d484e8cf710207010720589d89602233de61d01Sebastian Redl/// If @p RefAsPointee, references are treated like their underlying type 7255d484e8cf710207010720589d89602233de61d01Sebastian Redl/// (for alignof), else they're treated like pointers (for CodeGen). 7264ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getDeclAlign(const Decl *D, bool RefAsPointee) const { 727bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor unsigned Align = Target->getCharWidth(); 728dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman 7294081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall bool UseAlignAttrOnly = false; 7304081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall if (unsigned AlignFromAttr = D->getMaxAlignment()) { 7314081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall Align = AlignFromAttr; 7324081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall 7334081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // __attribute__((aligned)) can increase or decrease alignment 7344081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // *except* on a struct or struct member, where it only increases 7354081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // alignment unless 'packed' is also specified. 7364081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // 73782d0b0aab9088e977c2a44c4a5a90479c63149fePeter Collingbourne // It is an error for alignas to decrease alignment, so we can 7384081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // ignore that possibility; Sema should diagnose it. 7394081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall if (isa<FieldDecl>(D)) { 7404081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall UseAlignAttrOnly = D->hasAttr<PackedAttr>() || 7414081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>(); 7424081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall } else { 7434081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall UseAlignAttrOnly = true; 7444081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall } 7454081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall } 74678a7d7d79964119a3f35b262eb154b5cbf1001edFariborz Jahanian else if (isa<FieldDecl>(D)) 74778a7d7d79964119a3f35b262eb154b5cbf1001edFariborz Jahanian UseAlignAttrOnly = 74878a7d7d79964119a3f35b262eb154b5cbf1001edFariborz Jahanian D->hasAttr<PackedAttr>() || 74978a7d7d79964119a3f35b262eb154b5cbf1001edFariborz Jahanian cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>(); 750dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman 751ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // If we're using the align attribute only, just ignore everything 752ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // else about the declaration and its type. 7534081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall if (UseAlignAttrOnly) { 754ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // do nothing 755ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 7564081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall } else if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) { 757af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner QualType T = VD->getType(); 7586217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const ReferenceType* RT = T->getAs<ReferenceType>()) { 7595d484e8cf710207010720589d89602233de61d01Sebastian Redl if (RefAsPointee) 7605d484e8cf710207010720589d89602233de61d01Sebastian Redl T = RT->getPointeeType(); 7615d484e8cf710207010720589d89602233de61d01Sebastian Redl else 7625d484e8cf710207010720589d89602233de61d01Sebastian Redl T = getPointerType(RT->getPointeeType()); 7635d484e8cf710207010720589d89602233de61d01Sebastian Redl } 7645d484e8cf710207010720589d89602233de61d01Sebastian Redl if (!T->isIncompleteType() && !T->isFunctionType()) { 7653b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Adjust alignments of declarations with array type by the 7663b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // large-array alignment on the target. 767bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor unsigned MinWidth = Target->getLargeArrayMinWidth(); 7683b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall const ArrayType *arrayType; 7693b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (MinWidth && (arrayType = getAsArrayType(T))) { 7703b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (isa<VariableArrayType>(arrayType)) 771bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = std::max(Align, Target->getLargeArrayAlign()); 7723b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall else if (isa<ConstantArrayType>(arrayType) && 7733b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall MinWidth <= getTypeSize(cast<ConstantArrayType>(arrayType))) 774bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = std::max(Align, Target->getLargeArrayAlign()); 7753b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 7763b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Walk through any array types while we're at it. 7773b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall T = getBaseElementType(arrayType); 7786deecb0d46bcfd048e651d2db7c4fb0d6407da96Rafael Espindola } 7799f1210c3280104417a4ad30f0a00825ac8fa718aChad Rosier Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr())); 780dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman } 781ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 782ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // Fields can be subject to extra alignment constraints, like if 783ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // the field is packed, the struct is packed, or the struct has a 784ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // a max-field-alignment constraint (#pragma pack). So calculate 785ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // the actual alignment of the field within the struct, and then 786ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // (as we're expected to) constrain that by the alignment of the type. 787ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall if (const FieldDecl *field = dyn_cast<FieldDecl>(VD)) { 788ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // So calculate the alignment of the field. 789ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall const ASTRecordLayout &layout = getASTRecordLayout(field->getParent()); 790ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 791ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // Start with the record's overall alignment. 792dac54c124e302d6f028ea5723c425b7f66fc7c71Ken Dyck unsigned fieldAlign = toBits(layout.getAlignment()); 793ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 794ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // Use the GCD of that and the offset within the record. 795ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall uint64_t offset = layout.getFieldOffset(field->getFieldIndex()); 796ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall if (offset > 0) { 797ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // Alignment is always a power of 2, so the GCD will be a power of 2, 798ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall // which means we get to do this crazy thing instead of Euclid's. 799ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall uint64_t lowBitOfOffset = offset & (~offset + 1); 800ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall if (lowBitOfOffset < fieldAlign) 801ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall fieldAlign = static_cast<unsigned>(lowBitOfOffset); 802ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall } 803ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall 804ba4f5d5754c8291690d01ca9581926673d69b24cJohn McCall Align = std::min(Align, fieldAlign); 80505f62474dd2b0f1cb69adbe0787f2868788aa949Charles Davis } 806af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner } 807dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman 808eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(Align); 809af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner} 810b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner 811ea1471e0e967548c596a71469702f8846dbaf3c0John McCallstd::pair<CharUnits, CharUnits> 812bee5a79fc95e3003d755031e3d2bb4410a71e1c1Ken DyckASTContext::getTypeInfoInChars(const Type *T) const { 813ea1471e0e967548c596a71469702f8846dbaf3c0John McCall std::pair<uint64_t, unsigned> Info = getTypeInfo(T); 814eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return std::make_pair(toCharUnitsFromBits(Info.first), 815eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck toCharUnitsFromBits(Info.second)); 816ea1471e0e967548c596a71469702f8846dbaf3c0John McCall} 817ea1471e0e967548c596a71469702f8846dbaf3c0John McCall 818ea1471e0e967548c596a71469702f8846dbaf3c0John McCallstd::pair<CharUnits, CharUnits> 819bee5a79fc95e3003d755031e3d2bb4410a71e1c1Ken DyckASTContext::getTypeInfoInChars(QualType T) const { 820ea1471e0e967548c596a71469702f8846dbaf3c0John McCall return getTypeInfoInChars(T.getTypePtr()); 821ea1471e0e967548c596a71469702f8846dbaf3c0John McCall} 822ea1471e0e967548c596a71469702f8846dbaf3c0John McCall 823bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbarstd::pair<uint64_t, unsigned> ASTContext::getTypeInfo(const Type *T) const { 824bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar TypeInfoMap::iterator it = MemoizedTypeInfo.find(T); 825bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar if (it != MemoizedTypeInfo.end()) 826bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar return it->second; 827bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar 828bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar std::pair<uint64_t, unsigned> Info = getTypeInfoImpl(T); 829bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar MemoizedTypeInfo.insert(std::make_pair(T, Info)); 830bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar return Info; 831bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar} 832bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar 833bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar/// getTypeInfoImpl - Return the size of the specified type, in bits. This 834bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar/// method does not work on incomplete types. 8350953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// 8360953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// FIXME: Pointers into different addr spaces could have different sizes and 8370953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// alignment requirements: getPointerInfo should take an AddrSpace, this 8380953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// should take a QualType, &c. 839d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattnerstd::pair<uint64_t, unsigned> 840bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel DunbarASTContext::getTypeInfoImpl(const Type *T) const { 8415e301007e31e14c8ff647288e1b8bd8dbf8a5fe4Mike Stump uint64_t Width=0; 8425e301007e31e14c8ff647288e1b8bd8dbf8a5fe4Mike Stump unsigned Align=8; 843a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner switch (T->getTypeClass()) { 84472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define TYPE(Class, Base) 84572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define ABSTRACT_TYPE(Class, Base) 84618857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor#define NON_CANONICAL_TYPE(Class, Base) 84772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define DEPENDENT_TYPE(Class, Base) case Type::Class: 84872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#include "clang/AST/TypeNodes.def" 849d3d49bb27c7ffd9accc0a6c00e887111c0348845John McCall llvm_unreachable("Should not see dependent types"); 85072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 8515d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner case Type::FunctionNoProto: 8525d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner case Type::FunctionProto: 85318857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor // GCC extension: alignof(function) = 32 bits 85418857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Width = 0; 85518857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Align = 32; 85618857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor break; 85718857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 85872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::IncompleteArray: 859fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case Type::VariableArray: 86018857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Width = 0; 86118857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Align = getTypeAlign(cast<ArrayType>(T)->getElementType()); 86218857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor break; 86318857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 864fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff case Type::ConstantArray: { 8651d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const ConstantArrayType *CAT = cast<ConstantArrayType>(T); 8661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 86798be4943e8dc4f3905629a7102668960873cf863Chris Lattner std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(CAT->getElementType()); 868fea966a4103ed9c018d1494b95e9d09b161f5a70Abramo Bagnara uint64_t Size = CAT->getSize().getZExtValue(); 869bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar assert((Size == 0 || EltInfo.first <= (uint64_t)(-1)/Size) && 870bc5419a2edc4030d1a623576fe339fbd3eed17a6Daniel Dunbar "Overflow in array type bit size evaluation"); 871fea966a4103ed9c018d1494b95e9d09b161f5a70Abramo Bagnara Width = EltInfo.first*Size; 872030d8846c7e520330007087e949f621989876e3aChris Lattner Align = EltInfo.second; 873cd88b4171753dcb2bc0a21d78f1597c796bb8a20Argyrios Kyrtzidis Width = llvm::RoundUpToAlignment(Width, Align); 874030d8846c7e520330007087e949f621989876e3aChris Lattner break; 8755c09a02a5db85e08a432b6eeced9aa656349710dChristopher Lamb } 876213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman case Type::ExtVector: 877030d8846c7e520330007087e949f621989876e3aChris Lattner case Type::Vector: { 8789fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner const VectorType *VT = cast<VectorType>(T); 8799fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(VT->getElementType()); 8809fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner Width = EltInfo.first*VT->getNumElements(); 8814bd998bbc228915d2b9cae5b67879de48940d05eEli Friedman Align = Width; 8826fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // If the alignment is not a power of 2, round up to the next power of 2. 8836fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // This happens for non-power-of-2 length vectors. 8848eefcd353c1d06a10104f69e5079ebab3183f9a3Dan Gohman if (Align & (Align-1)) { 8859fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner Align = llvm::NextPowerOf2(Align); 8869fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner Width = llvm::RoundUpToAlignment(Width, Align); 8879fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner } 888030d8846c7e520330007087e949f621989876e3aChris Lattner break; 889030d8846c7e520330007087e949f621989876e3aChris Lattner } 8905d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner 8919e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner case Type::Builtin: 892a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner switch (cast<BuiltinType>(T)->getKind()) { 893b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Unknown builtin type!"); 894d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner case BuiltinType::Void: 89518857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor // GCC extension: alignof(void) = 8 bits. 89618857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Width = 0; 89718857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Align = 8; 89818857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor break; 89918857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 9006f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Bool: 901bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getBoolWidth(); 902bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getBoolAlign(); 9036f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 904692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::Char_S: 905692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::Char_U: 906692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::UChar: 9076f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::SChar: 908bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getCharWidth(); 909bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getCharAlign(); 9106f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 9113f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_S: 9123f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_U: 913bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getWCharWidth(); 914bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getWCharAlign(); 91564c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis break; 916f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case BuiltinType::Char16: 917bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getChar16Width(); 918bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getChar16Align(); 919f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith break; 920f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case BuiltinType::Char32: 921bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getChar32Width(); 922bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getChar32Align(); 923f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith break; 924692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::UShort: 9256f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Short: 926bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getShortWidth(); 927bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getShortAlign(); 9286f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 929692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::UInt: 9306f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Int: 931bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getIntWidth(); 932bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getIntAlign(); 9336f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 934692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::ULong: 9356f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Long: 936bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getLongWidth(); 937bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getLongAlign(); 9386f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 939692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner case BuiltinType::ULongLong: 9406f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::LongLong: 941bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getLongLongWidth(); 942bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getLongLongAlign(); 9436f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 944ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner case BuiltinType::Int128: 945ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner case BuiltinType::UInt128: 946ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner Width = 128; 947ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner Align = 128; // int128_t is 128-bit aligned on all targets. 948ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner break; 949aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov case BuiltinType::Half: 950aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Width = Target->getHalfWidth(); 951aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Align = Target->getHalfAlign(); 952aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov break; 9536f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Float: 954bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getFloatWidth(); 955bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getFloatAlign(); 9566f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 9576f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::Double: 958bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getDoubleWidth(); 959bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getDoubleAlign(); 9606f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 9616f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case BuiltinType::LongDouble: 962bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getLongDoubleWidth(); 963bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getLongDoubleAlign(); 9646f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 9656e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl case BuiltinType::NullPtr: 966bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t) 967bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(0); // == sizeof(void*) 9681590d9c0fec4c710c2962e4bb71f76979b5163d3Sebastian Redl break; 969e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian case BuiltinType::ObjCId: 970e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian case BuiltinType::ObjCClass: 971e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian case BuiltinType::ObjCSel: 972bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(0); 973bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(0); 974e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian break; 975a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner } 976bfef6d7c67831a135d6ab79931f010f750a730adChris Lattner break; 977d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff case Type::ObjCObjectPointer: 978bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(0); 979bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(0); 9806f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 981485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff case Type::BlockPointer: { 982207f4d8543529221932af82836016a2ef066c917Peter Collingbourne unsigned AS = getTargetAddressSpace( 983207f4d8543529221932af82836016a2ef066c917Peter Collingbourne cast<BlockPointerType>(T)->getPointeeType()); 984bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(AS); 985bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(AS); 986485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff break; 987485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff } 9885d484e8cf710207010720589d89602233de61d01Sebastian Redl case Type::LValueReference: 9895d484e8cf710207010720589d89602233de61d01Sebastian Redl case Type::RValueReference: { 9905d484e8cf710207010720589d89602233de61d01Sebastian Redl // alignof and sizeof should never enter this code path here, so we go 9915d484e8cf710207010720589d89602233de61d01Sebastian Redl // the pointer route. 992207f4d8543529221932af82836016a2ef066c917Peter Collingbourne unsigned AS = getTargetAddressSpace( 993207f4d8543529221932af82836016a2ef066c917Peter Collingbourne cast<ReferenceType>(T)->getPointeeType()); 994bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(AS); 995bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(AS); 9965d484e8cf710207010720589d89602233de61d01Sebastian Redl break; 9975d484e8cf710207010720589d89602233de61d01Sebastian Redl } 998f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner case Type::Pointer: { 999207f4d8543529221932af82836016a2ef066c917Peter Collingbourne unsigned AS = getTargetAddressSpace(cast<PointerType>(T)->getPointeeType()); 1000bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Width = Target->getPointerWidth(AS); 1001bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor Align = Target->getPointerAlign(AS); 1002f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner break; 1003f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner } 1004f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl case Type::MemberPointer: { 1005071cc7deffad608165b1ddd5263e8bf181861520Charles Davis const MemberPointerType *MPT = cast<MemberPointerType>(T); 10061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump std::pair<uint64_t, unsigned> PtrDiffInfo = 10071cca74ef3627a3a0ab14501d23e336548f6611b2Anders Carlsson getTypeInfo(getPointerDiffType()); 1008071cc7deffad608165b1ddd5263e8bf181861520Charles Davis Width = PtrDiffInfo.first * ABI->getMemberPointerSize(MPT); 10091cca74ef3627a3a0ab14501d23e336548f6611b2Anders Carlsson Align = PtrDiffInfo.second; 10101cca74ef3627a3a0ab14501d23e336548f6611b2Anders Carlsson break; 1011f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl } 10125d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner case Type::Complex: { 10135d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner // Complex types have the same alignment as their elements, but twice the 10145d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner // size. 10151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump std::pair<uint64_t, unsigned> EltInfo = 101698be4943e8dc4f3905629a7102668960873cf863Chris Lattner getTypeInfo(cast<ComplexType>(T)->getElementType()); 10179e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner Width = EltInfo.first*2; 10185d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner Align = EltInfo.second; 10195d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner break; 10205d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner } 1021c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCObject: 1022c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return getTypeInfo(cast<ObjCObjectType>(T)->getBaseType().getTypePtr()); 102344a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel case Type::ObjCInterface: { 10241d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const ObjCInterfaceType *ObjCI = cast<ObjCInterfaceType>(T); 102544a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl()); 1026dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck Width = toBits(Layout.getSize()); 1027dac54c124e302d6f028ea5723c425b7f66fc7c71Ken Dyck Align = toBits(Layout.getAlignment()); 102844a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel break; 102944a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel } 103072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Record: 103172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Enum: { 10321d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const TagType *TT = cast<TagType>(T); 10331d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar 10341d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar if (TT->getDecl()->isInvalidDecl()) { 103522ce41d9fc8509da65858c75bf5b3c4dae2d8c04Douglas Gregor Width = 8; 103622ce41d9fc8509da65858c75bf5b3c4dae2d8c04Douglas Gregor Align = 8; 10378389eab190afef3462f6418b8d8fb70fb01c4005Chris Lattner break; 10388389eab190afef3462f6418b8d8fb70fb01c4005Chris Lattner } 10391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10401d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar if (const EnumType *ET = dyn_cast<EnumType>(TT)) 10417176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner return getTypeInfo(ET->getDecl()->getIntegerType()); 10427176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner 10431d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar const RecordType *RT = cast<RecordType>(TT); 10447176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner const ASTRecordLayout &Layout = getASTRecordLayout(RT->getDecl()); 1045dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck Width = toBits(Layout.getSize()); 1046dac54c124e302d6f028ea5723c425b7f66fc7c71Ken Dyck Align = toBits(Layout.getAlignment()); 1047dc0d73e6495404418acf8548875aeaff07791a74Chris Lattner break; 1048a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner } 10497532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 10509fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner case Type::SubstTemplateTypeParm: 105149a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall return getTypeInfo(cast<SubstTemplateTypeParmType>(T)-> 105249a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall getReplacementType().getTypePtr()); 105349a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 105434b41d939a1328f484511c6002ba2456db879a29Richard Smith case Type::Auto: { 105534b41d939a1328f484511c6002ba2456db879a29Richard Smith const AutoType *A = cast<AutoType>(T); 105634b41d939a1328f484511c6002ba2456db879a29Richard Smith assert(A->isDeduced() && "Cannot request the size of a dependent type"); 1057dc856aff4428380baa9afb5577ea04f8fb6beb13Matt Beaumont-Gay return getTypeInfo(A->getDeducedType().getTypePtr()); 105834b41d939a1328f484511c6002ba2456db879a29Richard Smith } 105934b41d939a1328f484511c6002ba2456db879a29Richard Smith 1060075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara case Type::Paren: 1061075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return getTypeInfo(cast<ParenType>(T)->getInnerType().getTypePtr()); 1062075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 106318857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor case Type::Typedef: { 1064162e1c1b487352434552147967c3dd296ebee2f7Richard Smith const TypedefNameDecl *Typedef = cast<TypedefType>(T)->getDecl(); 1065df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor std::pair<uint64_t, unsigned> Info 1066df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor = getTypeInfo(Typedef->getUnderlyingType().getTypePtr()); 1067c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner // If the typedef has an aligned attribute on it, it overrides any computed 1068c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner // alignment we have. This violates the GCC documentation (which says that 1069c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner // attribute(aligned) can only round up) but matches its implementation. 1070c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner if (unsigned AttrAlign = Typedef->getMaxAlignment()) 1071c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner Align = AttrAlign; 1072c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner else 1073c1de52de64725945e5ae87e6f99ddedf161856e5Chris Lattner Align = Info.second; 1074df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor Width = Info.first; 10757532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor break; 10767176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner } 107718857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 107818857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor case Type::TypeOfExpr: 107918857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor return getTypeInfo(cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType() 108018857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor .getTypePtr()); 108118857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 108218857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor case Type::TypeOf: 108318857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor return getTypeInfo(cast<TypeOfType>(T)->getUnderlyingType().getTypePtr()); 108418857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 1085395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson case Type::Decltype: 1086395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson return getTypeInfo(cast<DecltypeType>(T)->getUnderlyingExpr()->getType() 1087395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson .getTypePtr()); 1088395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson 1089ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt case Type::UnaryTransform: 1090ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt return getTypeInfo(cast<UnaryTransformType>(T)->getUnderlyingType()); 1091ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt 1092465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara case Type::Elaborated: 1093465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr()); 10941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10959d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall case Type::Attributed: 10969d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall return getTypeInfo( 10979d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall cast<AttributedType>(T)->getEquivalentType().getTypePtr()); 10989d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 10993e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith case Type::TemplateSpecialization: { 11001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(getCanonicalType(T) != T && 110118857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor "Cannot request the size of a dependent type"); 11023e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith const TemplateSpecializationType *TST = cast<TemplateSpecializationType>(T); 11033e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith // A type alias template specialization may refer to a typedef with the 11043e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith // aligned attribute on it. 11053e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith if (TST->isTypeAlias()) 11063e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith return getTypeInfo(TST->getAliasedType().getTypePtr()); 11073e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith else 11083e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith return getTypeInfo(getCanonicalType(T)); 11093e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith } 11103e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith 1111b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: { 11122be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman std::pair<uint64_t, unsigned> Info 11132be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman = getTypeInfo(cast<AtomicType>(T)->getValueType()); 11142be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman Width = Info.first; 11152be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman Align = Info.second; 11162be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman if (Width != 0 && Width <= Target->getMaxAtomicPromoteWidth() && 11172be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman llvm::isPowerOf2_64(Width)) { 11182be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // We can potentially perform lock-free atomic operations for this 11192be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // type; promote the alignment appropriately. 11202be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // FIXME: We could potentially promote the width here as well... 11212be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // is that worthwhile? (Non-struct atomic types generally have 11222be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // power-of-two size anyway, but structs might not. Requires a bit 11232be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman // of implementation work to make sure we zero out the extra bits.) 11242be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman Align = static_cast<unsigned>(Width); 11252be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman } 1126b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 1127b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 112818857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor } 11291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11302be460723940f8184ec36529b6f6ddf59c04e411Eli Friedman assert(llvm::isPowerOf2_32(Align) && "Alignment must be power of 2"); 11319e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner return std::make_pair(Width, Align); 1132a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner} 1133a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 1134eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck/// toCharUnitsFromBits - Convert a size in bits to a size in characters. 1135eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen DyckCharUnits ASTContext::toCharUnitsFromBits(int64_t BitSize) const { 1136eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return CharUnits::fromQuantity(BitSize / getCharWidth()); 1137eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck} 1138eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck 1139dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck/// toBits - Convert a size in characters to a size in characters. 1140dd76a9ab9ea675671200f94b18ce95766841952bKen Dyckint64_t ASTContext::toBits(CharUnits CharSize) const { 1141dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck return CharSize.getQuantity() * getCharWidth(); 1142dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck} 1143dd76a9ab9ea675671200f94b18ce95766841952bKen Dyck 1144bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck/// getTypeSizeInChars - Return the size of the specified type, in characters. 1145bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck/// This method does not work on incomplete types. 11464ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeSizeInChars(QualType T) const { 1147eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeSize(T)); 1148bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck} 11494ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeSizeInChars(const Type *T) const { 1150eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeSize(T)); 1151bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck} 1152bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck 115316e20cce43385001f33f8e3f90ee345609c805d1Ken Dyck/// getTypeAlignInChars - Return the ABI-specified alignment of a type, in 115486fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck/// characters. This method does not work on incomplete types. 11554ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeAlignInChars(QualType T) const { 1156eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeAlign(T)); 115786fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck} 11584ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getTypeAlignInChars(const Type *T) const { 1159eb6f5dc86531f794ba7746a2da4d28e37cf5da7eKen Dyck return toCharUnitsFromBits(getTypeAlign(T)); 116086fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck} 116186fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck 116234ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// getPreferredTypeAlign - Return the "preferred" alignment of the specified 116334ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// type for the current target in bits. This can be different than the ABI 116434ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// alignment in cases where it is beneficial for performance to overalign 116534ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner/// a data type. 11664ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadunsigned ASTContext::getPreferredTypeAlign(const Type *T) const { 116734ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner unsigned ABIAlign = getTypeAlign(T); 11681eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman 11691eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman // Double and long long should be naturally aligned if possible. 1170183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ComplexType* CT = T->getAs<ComplexType>()) 11711eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman T = CT->getElementType().getTypePtr(); 11721eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman if (T->isSpecificBuiltinType(BuiltinType::Double) || 1173cde7a1dc68af2eb063a039b5a31c3b7dd92b1aa9Chad Rosier T->isSpecificBuiltinType(BuiltinType::LongLong) || 1174cde7a1dc68af2eb063a039b5a31c3b7dd92b1aa9Chad Rosier T->isSpecificBuiltinType(BuiltinType::ULongLong)) 11751eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman return std::max(ABIAlign, (unsigned)getTypeSize(T)); 11761eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman 117734ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner return ABIAlign; 117834ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner} 117934ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner 11802c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// DeepCollectObjCIvars - 11812c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// This routine first collects all declared, but not synthesized, ivars in 11822c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// super class and then collects all ivars, including those synthesized for 11832c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// current class. This routine is used for implementation of current class 11842c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// when all ivars, declared and synthesized are known. 11859820074dd47d37681085e964cd3392ac0b3e67b9Fariborz Jahanian/// 11862c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanianvoid ASTContext::DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, 11872c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian bool leafClass, 1188db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const { 11892c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass()) 11902c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian DeepCollectObjCIvars(SuperClass, false, Ivars); 11912c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian if (!leafClass) { 11922c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(), 11932c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian E = OI->ivar_end(); I != E; ++I) 1194581deb3da481053c4993c7600f97acf7768caac5David Blaikie Ivars.push_back(*I); 11953060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 1196bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian ObjCInterfaceDecl *IDecl = const_cast<ObjCInterfaceDecl *>(OI); 1197db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose for (const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv; 1198bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian Iv= Iv->getNextIvar()) 1199bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian Ivars.push_back(Iv); 1200bf9eb88792e022e54a658657bf22e1925948e384Fariborz Jahanian } 12019820074dd47d37681085e964cd3392ac0b3e67b9Fariborz Jahanian} 12029820074dd47d37681085e964cd3392ac0b3e67b9Fariborz Jahanian 1203e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// CollectInheritedProtocols - Collect all protocols in current class and 1204e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// those inherited by it. 1205e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanianvoid ASTContext::CollectInheritedProtocols(const Decl *CDecl, 1206432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) { 1207e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (const ObjCInterfaceDecl *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) { 120853b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek // We can use protocol_iterator here instead of 120953b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek // all_referenced_protocol_iterator since we are walking all categories. 121053b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek for (ObjCInterfaceDecl::all_protocol_iterator P = OI->all_referenced_protocol_begin(), 121153b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek PE = OI->all_referenced_protocol_end(); P != PE; ++P) { 1212e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian ObjCProtocolDecl *Proto = (*P); 12133fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert(Proto->getCanonicalDecl()); 1214e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 1215b2f812165676230bce5d0215e49a4749c451ca9cFariborz Jahanian PE = Proto->protocol_end(); P != PE; ++P) { 12163fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert((*P)->getCanonicalDecl()); 1217e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(*P, Protocols); 1218e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1219b2f812165676230bce5d0215e49a4749c451ca9cFariborz Jahanian } 1220e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 1221e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian // Categories of this Interface. 1222e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (const ObjCCategoryDecl *CDeclChain = OI->getCategoryList(); 1223e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CDeclChain; CDeclChain = CDeclChain->getNextClassCategory()) 1224e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(CDeclChain, Protocols); 1225e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (ObjCInterfaceDecl *SD = OI->getSuperClass()) 1226e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian while (SD) { 1227e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(SD, Protocols); 1228e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian SD = SD->getSuperClass(); 1229e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1230b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer } else if (const ObjCCategoryDecl *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) { 123153b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek for (ObjCCategoryDecl::protocol_iterator P = OC->protocol_begin(), 1232e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = OC->protocol_end(); P != PE; ++P) { 1233e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian ObjCProtocolDecl *Proto = (*P); 12343fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert(Proto->getCanonicalDecl()); 1235e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 1236e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = Proto->protocol_end(); P != PE; ++P) 1237e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(*P, Protocols); 1238e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1239b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer } else if (const ObjCProtocolDecl *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) { 1240e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = OP->protocol_begin(), 1241e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = OP->protocol_end(); P != PE; ++P) { 1242e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian ObjCProtocolDecl *Proto = (*P); 12433fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor Protocols.insert(Proto->getCanonicalDecl()); 1244e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 1245e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian PE = Proto->protocol_end(); P != PE; ++P) 1246e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian CollectInheritedProtocols(*P, Protocols); 1247e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1248e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 1249e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian} 1250e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 12514ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadunsigned ASTContext::CountNonClassIvars(const ObjCInterfaceDecl *OI) const { 12523bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian unsigned count = 0; 12533bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian // Count ivars declared in class extension. 125480aa1cd7973561889e51c1c152c8990a8de9c953Fariborz Jahanian for (const ObjCCategoryDecl *CDecl = OI->getFirstClassExtension(); CDecl; 125580aa1cd7973561889e51c1c152c8990a8de9c953Fariborz Jahanian CDecl = CDecl->getNextClassExtension()) 1256b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer count += CDecl->ivar_size(); 1257b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer 12583bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian // Count ivar defined in this class's implementation. This 12593bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian // includes synthesized ivars. 12603bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian if (ObjCImplementationDecl *ImplDecl = OI->getImplementation()) 1261b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer count += ImplDecl->ivar_size(); 1262b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer 12638e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian return count; 12648e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian} 12658e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian 12668deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidisbool ASTContext::isSentinelNullExpr(const Expr *E) { 12678deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis if (!E) 12688deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis return false; 12698deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12708deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis // nullptr_t is always treated as null. 12718deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis if (E->getType()->isNullPtrType()) return true; 12728deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12738deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis if (E->getType()->isAnyPointerType() && 12748deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis E->IgnoreParenCasts()->isNullPointerConstant(*this, 12758deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis Expr::NPC_ValueDependentIsNull)) 12768deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis return true; 12778deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12788deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis // Unfortunately, __null has type 'int'. 12798deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis if (isa<GNUNullExpr>(E)) return true; 12808deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12818deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis return false; 12828deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis} 12838deabc133c121f6c5561d0b2171a41cb2c29b2ceArgyrios Kyrtzidis 12848a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Get the implementation of ObjCInterfaceDecl,or NULL if none exists. 12858a1d722f13df383600f36d77f842957c8adb5f1bArgyrios KyrtzidisObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) { 12868a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator 12878a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis I = ObjCImpls.find(D); 12888a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis if (I != ObjCImpls.end()) 12898a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return cast<ObjCImplementationDecl>(I->second); 12908a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return 0; 12918a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 12928a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Get the implementation of ObjCCategoryDecl, or NULL if none exists. 12938a1d722f13df383600f36d77f842957c8adb5f1bArgyrios KyrtzidisObjCCategoryImplDecl *ASTContext::getObjCImplementation(ObjCCategoryDecl *D) { 12948a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator 12958a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis I = ObjCImpls.find(D); 12968a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis if (I != ObjCImpls.end()) 12978a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return cast<ObjCCategoryImplDecl>(I->second); 12988a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return 0; 12998a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 13008a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis 13018a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Set the implementation of ObjCInterfaceDecl. 13028a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidisvoid ASTContext::setObjCImplementation(ObjCInterfaceDecl *IFaceD, 13038a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCImplementationDecl *ImplD) { 13048a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis assert(IFaceD && ImplD && "Passed null params"); 13058a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCImpls[IFaceD] = ImplD; 13068a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 13078a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis/// \brief Set the implementation of ObjCCategoryDecl. 13088a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidisvoid ASTContext::setObjCImplementation(ObjCCategoryDecl *CatD, 13098a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCCategoryImplDecl *ImplD) { 13108a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis assert(CatD && ImplD && "Passed null params"); 13118a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ObjCImpls[CatD] = ImplD; 13128a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis} 13138a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis 131487ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios KyrtzidisObjCInterfaceDecl *ASTContext::getObjContainingInterface(NamedDecl *ND) const { 131587ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(ND->getDeclContext())) 131687ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return ID; 131787ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(ND->getDeclContext())) 131887ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return CD->getClassInterface(); 131987ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis if (ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(ND->getDeclContext())) 132087ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return IMD->getClassInterface(); 132187ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis 132287ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis return 0; 132387ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis} 132487ec9c257c99b4136af6c7f5be5a2d486906ba84Argyrios Kyrtzidis 13251ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian/// \brief Get the copy initialization expression of VarDecl,or NULL if 13261ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian/// none exists. 1327830937bc1100fba7682f7c32c40512085870f50cFariborz JahanianExpr *ASTContext::getBlockVarCopyInits(const VarDecl*VD) { 1328d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian assert(VD && "Passed null params"); 1329d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian assert(VD->hasAttr<BlocksAttr>() && 1330d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian "getBlockVarCopyInits - not __block var"); 1331830937bc1100fba7682f7c32c40512085870f50cFariborz Jahanian llvm::DenseMap<const VarDecl*, Expr*>::iterator 1332d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian I = BlockVarCopyInits.find(VD); 13331ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian return (I != BlockVarCopyInits.end()) ? cast<Expr>(I->second) : 0; 13341ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian} 13351ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian 13361ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian/// \brief Set the copy inialization expression of a block var decl. 13371ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanianvoid ASTContext::setBlockVarCopyInits(VarDecl*VD, Expr* Init) { 13381ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian assert(VD && Init && "Passed null params"); 1339d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian assert(VD->hasAttr<BlocksAttr>() && 1340d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian "setBlockVarCopyInits - not __block var"); 13411ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian BlockVarCopyInits[VD] = Init; 13421ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian} 13431ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian 1344a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCallTypeSourceInfo *ASTContext::CreateTypeSourceInfo(QualType T, 13454ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned DataSize) const { 1346109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall if (!DataSize) 1347109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall DataSize = TypeLoc::getFullDataSizeForType(T); 1348109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall else 1349109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall assert(DataSize == TypeLoc::getFullDataSizeForType(T) && 1350a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall "incorrect data size provided to CreateTypeSourceInfo!"); 1351109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall 1352a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall TypeSourceInfo *TInfo = 1353a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall (TypeSourceInfo*)BumpAlloc.Allocate(sizeof(TypeSourceInfo) + DataSize, 8); 1354a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall new (TInfo) TypeSourceInfo(T); 1355a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall return TInfo; 1356b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis} 1357b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis 1358a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCallTypeSourceInfo *ASTContext::getTrivialTypeSourceInfo(QualType T, 13596952f1e4256c5b43aee5e98cea4e9b663bd1d413Douglas Gregor SourceLocation L) const { 1360a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall TypeSourceInfo *DI = CreateTypeSourceInfo(T); 1361c21c7e9c2cded68f91be15be6847c9649242dc17Douglas Gregor DI->getTypeLoc().initialize(const_cast<ASTContext &>(*this), L); 1362a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall return DI; 1363a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall} 1364a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall 1365b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbarconst ASTRecordLayout & 13664ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const { 1367b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar return getObjCLayout(D, 0); 1368b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar} 1369b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar 1370b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbarconst ASTRecordLayout & 13714ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getASTObjCImplementationLayout( 13724ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const ObjCImplementationDecl *D) const { 1373b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar return getObjCLayout(D->getClassInterface(), D); 1374b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar} 1375b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar 1376a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner//===----------------------------------------------------------------------===// 1377a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner// Type creation/memoization methods 1378a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner//===----------------------------------------------------------------------===// 1379a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 13804ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 13813b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallASTContext::getExtQualType(const Type *baseType, Qualifiers quals) const { 13823b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall unsigned fastQuals = quals.getFastQualifiers(); 13833b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall quals.removeFastQualifiers(); 13840953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 13850953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Check if we've already instantiated this type. 13860953e767ff7817f97b3ab20896b229891eeff45bJohn McCall llvm::FoldingSetNodeID ID; 13873b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ExtQuals::Profile(ID, baseType, quals); 13883b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall void *insertPos = 0; 13893b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (ExtQuals *eq = ExtQualNodes.FindNodeOrInsertPos(ID, insertPos)) { 13903b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert(eq->getQualifiers() == quals); 13913b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(eq, fastQuals); 13920953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 13930953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 13943b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If the base type is not canonical, make the appropriate canonical type. 13953b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType canon; 13963b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!baseType->isCanonicalUnqualified()) { 13973b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = baseType->getCanonicalTypeInternal().split(); 1398200fa53fd420aa8369586f569dbece04930ad6a3John McCall canonSplit.Quals.addConsistentQualifiers(quals); 1399200fa53fd420aa8369586f569dbece04930ad6a3John McCall canon = getExtQualType(canonSplit.Ty, canonSplit.Quals); 14003b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 14013b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Re-find the insert position. 14023b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos); 14033b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall } 14043b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 14053b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ExtQuals *eq = new (*this, TypeAlignment) ExtQuals(baseType, canon, quals); 14063b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ExtQualNodes.InsertNode(eq, insertPos); 14073b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(eq, fastQuals); 14080953e767ff7817f97b3ab20896b229891eeff45bJohn McCall} 14090953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 14104ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 14114ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getAddrSpaceQualType(QualType T, unsigned AddressSpace) const { 1412f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner QualType CanT = getCanonicalType(T); 1413f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner if (CanT.getAddressSpace() == AddressSpace) 1414f46699ce225811d8d9dbab9d00189a0e54469457Chris Lattner return T; 1415b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris Lattner 14160953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If we are composing extended qualifiers together, merge together 14170953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // into one ExtQuals node. 14180953e767ff7817f97b3ab20896b229891eeff45bJohn McCall QualifierCollector Quals; 14190953e767ff7817f97b3ab20896b229891eeff45bJohn McCall const Type *TypeNode = Quals.strip(T); 14201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14210953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If this type already has an address space specified, it cannot get 14220953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // another one. 14230953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert(!Quals.hasAddressSpace() && 14240953e767ff7817f97b3ab20896b229891eeff45bJohn McCall "Type cannot be in multiple addr spaces!"); 14250953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Quals.addAddressSpace(AddressSpace); 14261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14270953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return getExtQualType(TypeNode, Quals); 1428ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb} 1429ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb 1430b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris LattnerQualType ASTContext::getObjCGCQualType(QualType T, 14314ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Qualifiers::GC GCAttr) const { 1432d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian QualType CanT = getCanonicalType(T); 1433b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris Lattner if (CanT.getObjCGCAttr() == GCAttr) 1434d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian return T; 14351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14367f040a9d817cd1c72b565e92abff473510bf9e1dJohn McCall if (const PointerType *ptr = T->getAs<PointerType>()) { 14377f040a9d817cd1c72b565e92abff473510bf9e1dJohn McCall QualType Pointee = ptr->getPointeeType(); 143858f9f2c884af6b72d036b746a016d8031d31cb7aSteve Naroff if (Pointee->isAnyPointerType()) { 14394027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian QualType ResultType = getObjCGCQualType(Pointee, GCAttr); 14404027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian return getPointerType(ResultType); 14414027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian } 14424027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian } 14431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14440953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If we are composing extended qualifiers together, merge together 14450953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // into one ExtQuals node. 14460953e767ff7817f97b3ab20896b229891eeff45bJohn McCall QualifierCollector Quals; 14470953e767ff7817f97b3ab20896b229891eeff45bJohn McCall const Type *TypeNode = Quals.strip(T); 14481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14490953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If this type already has an ObjCGC specified, it cannot get 14500953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // another one. 14510953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert(!Quals.hasObjCGCAttr() && 14520953e767ff7817f97b3ab20896b229891eeff45bJohn McCall "Type cannot have multiple ObjCGCs!"); 14530953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Quals.addObjCGCAttr(GCAttr); 14541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14550953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return getExtQualType(TypeNode, Quals); 1456d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian} 1457a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner 1458e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCallconst FunctionType *ASTContext::adjustFunctionType(const FunctionType *T, 1459e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall FunctionType::ExtInfo Info) { 1460e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall if (T->getExtInfo() == Info) 1461e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall return T; 1462e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 1463e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall QualType Result; 1464e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall if (const FunctionNoProtoType *FNPT = dyn_cast<FunctionNoProtoType>(T)) { 1465e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall Result = getFunctionNoProtoType(FNPT->getResultType(), Info); 1466e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall } else { 1467e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall const FunctionProtoType *FPT = cast<FunctionProtoType>(T); 1468e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 1469e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall EPI.ExtInfo = Info; 1470e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall Result = getFunctionType(FPT->getResultType(), FPT->arg_type_begin(), 1471e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall FPT->getNumArgs(), EPI); 1472e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall } 1473e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 1474e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall return cast<FunctionType>(Result.getTypePtr()); 1475e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall} 1476e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 14775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getComplexType - Return the uniqued reference to the type for a complex 14785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// number with the specified element type. 14794ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getComplexType(QualType T) const { 14805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique pointers, to guarantee there is only one pointer of a particular 14815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 14825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 14835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ComplexType::Profile(ID, T); 14841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 14865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos)) 14875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(CT, 0); 14881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the pointee type isn't canonical, this won't be a canonical type either, 14905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // so fill in the canonical type field. 14915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 1492467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!T.isCanonical()) { 1493f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner Canonical = getComplexType(getCanonicalType(T)); 14941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 14955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 14965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos); 1497c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 14985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 14996b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ComplexType *New = new (*this, TypeAlignment) ComplexType(T, Canonical); 15005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 15015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ComplexTypes.InsertNode(New, InsertPos); 15025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 15035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 15045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 15055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getPointerType - Return the uniqued reference to the type for a pointer to 15065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// the specified type. 15074ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getPointerType(QualType T) const { 15085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique pointers, to guarantee there is only one pointer of a particular 15095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 15105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 15115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PointerType::Profile(ID, T); 15121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 15145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 15155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(PT, 0); 15161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the pointee type isn't canonical, this won't be a canonical type either, 15185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // so fill in the canonical type field. 15195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 1520467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!T.isCanonical()) { 1521f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner Canonical = getPointerType(getCanonicalType(T)); 15221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 15245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1525c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 15265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 15276b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall PointerType *New = new (*this, TypeAlignment) PointerType(T, Canonical); 15285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 15295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PointerTypes.InsertNode(New, InsertPos); 15305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 15315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 15325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 15331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getBlockPointerType - Return the uniqued reference to the type for 15345618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff/// a pointer to the specified block. 15354ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getBlockPointerType(QualType T) const { 1536296e8d5fdcf9946f51e866adc8d281379e51efe9Steve Naroff assert(T->isFunctionType() && "block of function types only"); 1537296e8d5fdcf9946f51e866adc8d281379e51efe9Steve Naroff // Unique pointers, to guarantee there is only one block of a particular 15385618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // structure. 15395618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff llvm::FoldingSetNodeID ID; 15405618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerType::Profile(ID, T); 15411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15425618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff void *InsertPos = 0; 15435618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff if (BlockPointerType *PT = 15445618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 15455618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff return QualType(PT, 0); 15461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the block pointee type isn't canonical, this won't be a canonical 15485618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // type either so fill in the canonical type field. 15495618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff QualType Canonical; 1550467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!T.isCanonical()) { 15515618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff Canonical = getBlockPointerType(getCanonicalType(T)); 15521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15535618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff // Get the new insert position for the node we care about. 15545618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerType *NewIP = 15555618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1556c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 15575618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff } 15586b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall BlockPointerType *New 15596b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) BlockPointerType(T, Canonical); 15605618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff Types.push_back(New); 15615618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BlockPointerTypes.InsertNode(New, InsertPos); 15625618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff return QualType(New, 0); 15635618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff} 15645618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff 15657c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// getLValueReferenceType - Return the uniqued reference to the type for an 15667c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// lvalue reference to the specified type. 15674ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 15684ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getLValueReferenceType(QualType T, bool SpelledAsLValue) const { 15699625e44c0252485277a340746ed8ac950686156fDouglas Gregor assert(getCanonicalType(T) != OverloadTy && 15709625e44c0252485277a340746ed8ac950686156fDouglas Gregor "Unresolved overloaded function type"); 15719625e44c0252485277a340746ed8ac950686156fDouglas Gregor 15725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique pointers, to guarantee there is only one pointer of a particular 15735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 15745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 157554e14c4db764c0636160d26c5bbf491637c83a76John McCall ReferenceType::Profile(ID, T, SpelledAsLValue); 15765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 15775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 15787c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl if (LValueReferenceType *RT = 15797c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 15805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(RT, 0); 15817c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 158254e14c4db764c0636160d26c5bbf491637c83a76John McCall const ReferenceType *InnerRef = T->getAs<ReferenceType>(); 158354e14c4db764c0636160d26c5bbf491637c83a76John McCall 15845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the referencee type isn't canonical, this won't be a canonical type 15855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // either, so fill in the canonical type field. 15865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 158754e14c4db764c0636160d26c5bbf491637c83a76John McCall if (!SpelledAsLValue || InnerRef || !T.isCanonical()) { 158854e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T); 158954e14c4db764c0636160d26c5bbf491637c83a76John McCall Canonical = getLValueReferenceType(getCanonicalType(PointeeType)); 15907c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 15917c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // Get the new insert position for the node we care about. 15927c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceType *NewIP = 15937c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 1594c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 15957c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl } 15967c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 15976b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall LValueReferenceType *New 159854e14c4db764c0636160d26c5bbf491637c83a76John McCall = new (*this, TypeAlignment) LValueReferenceType(T, Canonical, 159954e14c4db764c0636160d26c5bbf491637c83a76John McCall SpelledAsLValue); 16007c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl Types.push_back(New); 16017c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl LValueReferenceTypes.InsertNode(New, InsertPos); 160254e14c4db764c0636160d26c5bbf491637c83a76John McCall 16037c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl return QualType(New, 0); 16047c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl} 16057c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 16067c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// getRValueReferenceType - Return the uniqued reference to the type for an 16077c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// rvalue reference to the specified type. 16084ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getRValueReferenceType(QualType T) const { 16097c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // Unique pointers, to guarantee there is only one pointer of a particular 16107c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // structure. 16117c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl llvm::FoldingSetNodeID ID; 161254e14c4db764c0636160d26c5bbf491637c83a76John McCall ReferenceType::Profile(ID, T, false); 16137c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 16147c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl void *InsertPos = 0; 16157c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl if (RValueReferenceType *RT = 16167c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 16177c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl return QualType(RT, 0); 16187c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 161954e14c4db764c0636160d26c5bbf491637c83a76John McCall const ReferenceType *InnerRef = T->getAs<ReferenceType>(); 162054e14c4db764c0636160d26c5bbf491637c83a76John McCall 16217c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // If the referencee type isn't canonical, this won't be a canonical type 16227c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // either, so fill in the canonical type field. 16237c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl QualType Canonical; 162454e14c4db764c0636160d26c5bbf491637c83a76John McCall if (InnerRef || !T.isCanonical()) { 162554e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T); 162654e14c4db764c0636160d26c5bbf491637c83a76John McCall Canonical = getRValueReferenceType(getCanonicalType(PointeeType)); 16277c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 16285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 16297c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceType *NewIP = 16307c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 1631c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 16325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 16335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 16346b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall RValueReferenceType *New 16356b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) RValueReferenceType(T, Canonical); 16365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 16377c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl RValueReferenceTypes.InsertNode(New, InsertPos); 16385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 16395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 16405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1641f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl/// getMemberPointerType - Return the uniqued reference to the type for a 1642f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl/// member pointer to the specified type, in the specified class. 16434ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) const { 1644f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // Unique pointers, to guarantee there is only one pointer of a particular 1645f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // structure. 1646f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl llvm::FoldingSetNodeID ID; 1647f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerType::Profile(ID, T, Cls); 1648f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1649f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl void *InsertPos = 0; 1650f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl if (MemberPointerType *PT = 1651f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 1652f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl return QualType(PT, 0); 1653f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1654f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // If the pointee or class type isn't canonical, this won't be a canonical 1655f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // type either, so fill in the canonical type field. 1656f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl QualType Canonical; 165787c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) { 1658f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls)); 1659f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1660f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // Get the new insert position for the node we care about. 1661f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerType *NewIP = 1662f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 1663c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 1664f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl } 16656b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall MemberPointerType *New 16666b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical); 1667f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl Types.push_back(New); 1668f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MemberPointerTypes.InsertNode(New, InsertPos); 1669f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl return QualType(New, 0); 1670f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl} 1671f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 16721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getConstantArrayType - Return the unique reference to the type for an 1673fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff/// array of the specified element type. 16741eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType ASTContext::getConstantArrayType(QualType EltTy, 167538aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner const llvm::APInt &ArySizeIn, 1676c9406125e2cac9208098655ac8058c095c2c3a65Steve Naroff ArrayType::ArraySizeModifier ASM, 167763e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara unsigned IndexTypeQuals) const { 1678923d56d436f750bc1f29db50e641078725558a1bSebastian Redl assert((EltTy->isDependentType() || 1679923d56d436f750bc1f29db50e641078725558a1bSebastian Redl EltTy->isIncompleteType() || EltTy->isConstantSizeType()) && 1680587cbdfd95f4b0aaccc14b31f5debe85d5daf7edEli Friedman "Constant array of VLAs is illegal!"); 1681587cbdfd95f4b0aaccc14b31f5debe85d5daf7edEli Friedman 168238aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner // Convert the array size into a canonical width matching the pointer size for 168338aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner // the target. 168438aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner llvm::APInt ArySize(ArySizeIn); 16859f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad ArySize = 1686bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor ArySize.zextOrTrunc(Target->getPointerWidth(getTargetAddressSpace(EltTy))); 16871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 168963e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, IndexTypeQuals); 16901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 16921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (ConstantArrayType *ATP = 16937192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos)) 16945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(ATP, 0); 16951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 16963b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If the element type isn't canonical or has qualifiers, this won't 16973b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // be a canonical type either, so fill in the canonical type field. 16983b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType Canon; 16993b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) { 17003b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = getCanonicalType(EltTy).split(); 1701200fa53fd420aa8369586f569dbece04930ad6a3John McCall Canon = getConstantArrayType(QualType(canonSplit.Ty, 0), ArySize, 170263e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara ASM, IndexTypeQuals); 1703200fa53fd420aa8369586f569dbece04930ad6a3John McCall Canon = getQualifiedType(Canon, canonSplit.Quals); 17043b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 17055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 17061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ConstantArrayType *NewIP = 17077192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos); 1708c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 17095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 17101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 17116b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ConstantArrayType *New = new(*this,TypeAlignment) 171263e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara ConstantArrayType(EltTy, Canon, ArySize, ASM, IndexTypeQuals); 17137192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek ConstantArrayTypes.InsertNode(New, InsertPos); 17145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 17155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 17165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 17175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1718ce8890371fcdb983ae487c87fa40606a34896ff7John McCall/// getVariableArrayDecayedType - Turns the given type, which may be 1719ce8890371fcdb983ae487c87fa40606a34896ff7John McCall/// variably-modified, into the corresponding type with all the known 1720ce8890371fcdb983ae487c87fa40606a34896ff7John McCall/// sizes replaced with [*]. 1721ce8890371fcdb983ae487c87fa40606a34896ff7John McCallQualType ASTContext::getVariableArrayDecayedType(QualType type) const { 1722ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Vastly most common case. 1723ce8890371fcdb983ae487c87fa40606a34896ff7John McCall if (!type->isVariablyModifiedType()) return type; 1724ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1725ce8890371fcdb983ae487c87fa40606a34896ff7John McCall QualType result; 1726ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1727ce8890371fcdb983ae487c87fa40606a34896ff7John McCall SplitQualType split = type.getSplitDesugaredType(); 1728200fa53fd420aa8369586f569dbece04930ad6a3John McCall const Type *ty = split.Ty; 1729ce8890371fcdb983ae487c87fa40606a34896ff7John McCall switch (ty->getTypeClass()) { 1730ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#define TYPE(Class, Base) 1731ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#define ABSTRACT_TYPE(Class, Base) 1732ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 1733ce8890371fcdb983ae487c87fa40606a34896ff7John McCall#include "clang/AST/TypeNodes.def" 1734ce8890371fcdb983ae487c87fa40606a34896ff7John McCall llvm_unreachable("didn't desugar past all non-canonical types?"); 1735ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1736ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // These types should never be variably-modified. 1737ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Builtin: 1738ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Complex: 1739ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Vector: 1740ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ExtVector: 1741ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentSizedExtVector: 1742ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ObjCObject: 1743ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ObjCInterface: 1744ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ObjCObjectPointer: 1745ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Record: 1746ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Enum: 1747ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::UnresolvedUsing: 1748ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TypeOfExpr: 1749ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TypeOf: 1750ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Decltype: 1751ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt case Type::UnaryTransform: 1752ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentName: 1753ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::InjectedClassName: 1754ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TemplateSpecialization: 1755ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentTemplateSpecialization: 1756ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::TemplateTypeParm: 1757ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::SubstTemplateTypeParmPack: 175834b41d939a1328f484511c6002ba2456db879a29Richard Smith case Type::Auto: 1759ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::PackExpansion: 1760ce8890371fcdb983ae487c87fa40606a34896ff7John McCall llvm_unreachable("type should never be variably-modified"); 1761ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1762ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // These types can be variably-modified but should never need to 1763ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // further decay. 1764ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::FunctionNoProto: 1765ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::FunctionProto: 1766ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::BlockPointer: 1767ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::MemberPointer: 1768ce8890371fcdb983ae487c87fa40606a34896ff7John McCall return type; 1769ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1770ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // These types can be variably-modified. All these modifications 1771ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // preserve structure except as noted by comments. 1772ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // TODO: if we ever care about optimizing VLAs, there are no-op 1773ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // optimizations available here. 1774ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::Pointer: 1775ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getPointerType(getVariableArrayDecayedType( 1776ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cast<PointerType>(ty)->getPointeeType())); 1777ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1778ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1779ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::LValueReference: { 1780ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const LValueReferenceType *lv = cast<LValueReferenceType>(ty); 1781ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getLValueReferenceType( 1782ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(lv->getPointeeType()), 1783ce8890371fcdb983ae487c87fa40606a34896ff7John McCall lv->isSpelledAsLValue()); 1784ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1785745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 1786ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1787ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::RValueReference: { 1788ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const RValueReferenceType *lv = cast<RValueReferenceType>(ty); 1789ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getRValueReferenceType( 1790ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(lv->getPointeeType())); 1791ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1792745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 1793745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1794b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: { 1795b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman const AtomicType *at = cast<AtomicType>(ty); 1796b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman result = getAtomicType(getVariableArrayDecayedType(at->getValueType())); 1797b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman break; 1798b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 1799b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 1800ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::ConstantArray: { 1801ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const ConstantArrayType *cat = cast<ConstantArrayType>(ty); 1802ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getConstantArrayType( 1803ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(cat->getElementType()), 1804ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cat->getSize(), 1805ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cat->getSizeModifier(), 1806ce8890371fcdb983ae487c87fa40606a34896ff7John McCall cat->getIndexTypeCVRQualifiers()); 1807ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1808745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 1809745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1810ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::DependentSizedArray: { 1811ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const DependentSizedArrayType *dat = cast<DependentSizedArrayType>(ty); 1812ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getDependentSizedArrayType( 1813ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(dat->getElementType()), 1814ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getSizeExpr(), 1815ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getSizeModifier(), 1816ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getIndexTypeCVRQualifiers(), 1817ce8890371fcdb983ae487c87fa40606a34896ff7John McCall dat->getBracketsRange()); 1818ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1819ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1820ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1821ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Turn incomplete types into [*] types. 1822ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::IncompleteArray: { 1823ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const IncompleteArrayType *iat = cast<IncompleteArrayType>(ty); 1824ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getVariableArrayType( 1825ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(iat->getElementType()), 1826ce8890371fcdb983ae487c87fa40606a34896ff7John McCall /*size*/ 0, 1827ce8890371fcdb983ae487c87fa40606a34896ff7John McCall ArrayType::Normal, 1828ce8890371fcdb983ae487c87fa40606a34896ff7John McCall iat->getIndexTypeCVRQualifiers(), 1829ce8890371fcdb983ae487c87fa40606a34896ff7John McCall SourceRange()); 1830ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1831ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1832ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1833ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Turn VLA types into [*] types. 1834ce8890371fcdb983ae487c87fa40606a34896ff7John McCall case Type::VariableArray: { 1835ce8890371fcdb983ae487c87fa40606a34896ff7John McCall const VariableArrayType *vat = cast<VariableArrayType>(ty); 1836ce8890371fcdb983ae487c87fa40606a34896ff7John McCall result = getVariableArrayType( 1837ce8890371fcdb983ae487c87fa40606a34896ff7John McCall getVariableArrayDecayedType(vat->getElementType()), 1838ce8890371fcdb983ae487c87fa40606a34896ff7John McCall /*size*/ 0, 1839ce8890371fcdb983ae487c87fa40606a34896ff7John McCall ArrayType::Star, 1840ce8890371fcdb983ae487c87fa40606a34896ff7John McCall vat->getIndexTypeCVRQualifiers(), 1841ce8890371fcdb983ae487c87fa40606a34896ff7John McCall vat->getBracketsRange()); 1842ce8890371fcdb983ae487c87fa40606a34896ff7John McCall break; 1843ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1844ce8890371fcdb983ae487c87fa40606a34896ff7John McCall } 1845ce8890371fcdb983ae487c87fa40606a34896ff7John McCall 1846ce8890371fcdb983ae487c87fa40606a34896ff7John McCall // Apply the top-level qualifiers from the original. 1847200fa53fd420aa8369586f569dbece04930ad6a3John McCall return getQualifiedType(result, split.Quals); 1848ce8890371fcdb983ae487c87fa40606a34896ff7John McCall} 1849745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1850bdbf7b030a3e0ddb95240076683830e6f78c79a5Steve Naroff/// getVariableArrayType - Returns a non-unique reference to the type for a 1851bdbf7b030a3e0ddb95240076683830e6f78c79a5Steve Naroff/// variable array of the specified element type. 18527e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas GregorQualType ASTContext::getVariableArrayType(QualType EltTy, 18537e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor Expr *NumElts, 1854c9406125e2cac9208098655ac8058c095c2c3a65Steve Naroff ArrayType::ArraySizeModifier ASM, 185563e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara unsigned IndexTypeQuals, 18564ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad SourceRange Brackets) const { 1857c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // Since we don't unique expressions, it isn't possible to unique VLA's 1858c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // that have an expression provided for their size. 18593b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType Canon; 1860715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor 18613b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Be sure to pull qualifiers off the element type. 18623b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) { 18633b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = getCanonicalType(EltTy).split(); 1864200fa53fd420aa8369586f569dbece04930ad6a3John McCall Canon = getVariableArrayType(QualType(canonSplit.Ty, 0), NumElts, ASM, 186563e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara IndexTypeQuals, Brackets); 1866200fa53fd420aa8369586f569dbece04930ad6a3John McCall Canon = getQualifiedType(Canon, canonSplit.Quals); 1867715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor } 1868715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor 18696b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall VariableArrayType *New = new(*this, TypeAlignment) 187063e7d25d2e6036616b42f744fd4a39cd5f911960Abramo Bagnara VariableArrayType(EltTy, Canon, NumElts, ASM, IndexTypeQuals, Brackets); 1871c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1872c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman VariableArrayTypes.push_back(New); 1873c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman Types.push_back(New); 1874c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman return QualType(New, 0); 1875c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman} 1876c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1877898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// getDependentSizedArrayType - Returns a non-unique reference to 1878898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// the type for a dependently-sized array of the specified element 187904d4beee4b86af20a9e4457023d3925cab8f9908Douglas Gregor/// type. 18803b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getDependentSizedArrayType(QualType elementType, 18813b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Expr *numElements, 1882898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor ArrayType::ArraySizeModifier ASM, 18833b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall unsigned elementTypeQuals, 18843b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SourceRange brackets) const { 18853b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert((!numElements || numElements->isTypeDependent() || 18863b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall numElements->isValueDependent()) && 1887898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor "Size must be type- or value-dependent!"); 1888898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 18893b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Dependently-sized array types that do not have a specified number 18903b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // of elements will have their sizes deduced from a dependent 18913b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // initializer. We do no canonicalization here at all, which is okay 18923b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // because they can't be used in most locations. 18933b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!numElements) { 18943b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType *newType 18953b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall = new (*this, TypeAlignment) 18963b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType(*this, elementType, QualType(), 18973b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall numElements, ASM, elementTypeQuals, 18983b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall brackets); 18993b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(newType); 19003b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(newType, 0); 1901cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor } 1902cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor 19033b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Otherwise, we actually build a new type every time, but we 19043b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // also build a canonical type. 19051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 19063b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonElementType = getCanonicalType(elementType).split(); 1907898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 19083b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall void *insertPos = 0; 19093b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall llvm::FoldingSetNodeID ID; 19103b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType::Profile(ID, *this, 1911200fa53fd420aa8369586f569dbece04930ad6a3John McCall QualType(canonElementType.Ty, 0), 19123b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ASM, elementTypeQuals, numElements); 19133b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19143b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Look for an existing type with these properties. 19153b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType *canonTy = 19163b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos); 19173b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19183b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If we don't have one, build one. 19193b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!canonTy) { 19203b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall canonTy = new (*this, TypeAlignment) 1921200fa53fd420aa8369586f569dbece04930ad6a3John McCall DependentSizedArrayType(*this, QualType(canonElementType.Ty, 0), 19223b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType(), numElements, ASM, elementTypeQuals, 19233b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall brackets); 19243b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayTypes.InsertNode(canonTy, insertPos); 19253b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(canonTy); 19263b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall } 19273b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19283b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Apply qualifiers from the element type to the array. 19293b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType canon = getQualifiedType(QualType(canonTy,0), 1930200fa53fd420aa8369586f569dbece04930ad6a3John McCall canonElementType.Quals); 19313b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19323b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // If we didn't need extra canonicalization for the element type, 19333b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // then just use that as our result. 1934200fa53fd420aa8369586f569dbece04930ad6a3John McCall if (QualType(canonElementType.Ty, 0) == elementType) 19353b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return canon; 19363b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19373b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // Otherwise, we need to build a type which follows the spelling 19383b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // of the element type. 19393b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType *sugaredType 19403b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall = new (*this, TypeAlignment) 19413b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall DependentSizedArrayType(*this, elementType, canon, numElements, 19423b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ASM, elementTypeQuals, brackets); 19433b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(sugaredType); 19443b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(sugaredType, 0); 19453b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall} 19463b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall 19473b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getIncompleteArrayType(QualType elementType, 1948c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman ArrayType::ArraySizeModifier ASM, 19493b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall unsigned elementTypeQuals) const { 1950c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman llvm::FoldingSetNodeID ID; 19513b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType::Profile(ID, elementType, ASM, elementTypeQuals); 1952c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19533b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall void *insertPos = 0; 19543b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (IncompleteArrayType *iat = 19553b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos)) 19563b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(iat, 0); 1957c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1958c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // If the element type isn't canonical, this won't be a canonical type 19593b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // either, so fill in the canonical type field. We also have to pull 19603b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall // qualifiers off the element type. 19613b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType canon; 1962c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19633b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!elementType.isCanonical() || elementType.hasLocalQualifiers()) { 19643b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType canonSplit = getCanonicalType(elementType).split(); 1965200fa53fd420aa8369586f569dbece04930ad6a3John McCall canon = getIncompleteArrayType(QualType(canonSplit.Ty, 0), 19663b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall ASM, elementTypeQuals); 1967200fa53fd420aa8369586f569dbece04930ad6a3John McCall canon = getQualifiedType(canon, canonSplit.Quals); 1968c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1969c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman // Get the new insert position for the node we care about. 19703b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType *existing = 19713b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos); 19723b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert(!existing && "Shouldn't be in the map!"); (void) existing; 19732bd24ba6d10f8c811c8e2a57c8397e07082ba497Ted Kremenek } 1974c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19753b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType *newType = new (*this, TypeAlignment) 19763b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayType(elementType, canon, ASM, elementTypeQuals); 1977c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 19783b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall IncompleteArrayTypes.InsertNode(newType, insertPos); 19793b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Types.push_back(newType); 19803b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return QualType(newType, 0); 1981fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff} 1982fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff 198373322924127c873c13101b705dd823f5539ffa5fSteve Naroff/// getVectorType - Return the unique reference to a vector type of 198473322924127c873c13101b705dd823f5539ffa5fSteve Naroff/// the specified element type and size. VectorType must be a built-in type. 198582287d19ded35248c4ce6a425ce74116a13ce44eJohn ThompsonQualType ASTContext::getVectorType(QualType vecType, unsigned NumElts, 19864ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad VectorType::VectorKind VecKind) const { 19873b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall assert(vecType->isBuiltinType()); 19881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 19895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Check if we've already instantiated a vector of this type. 19905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 1991e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType::Profile(ID, vecType, NumElts, Type::Vector, VecKind); 1992788b0fd67e1992f23555454efcdb16a19dfefac3Chris Lattner 19935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 19945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 19955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(VTP, 0); 19965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 19975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the element type isn't canonical, this won't be a canonical type either, 19985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // so fill in the canonical type field. 19995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 2000255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor if (!vecType.isCanonical()) { 2001231da7eb3dd13007e5e40fffe48998e5ef284e06Bob Wilson Canonical = getVectorType(getCanonicalType(vecType), NumElts, VecKind); 20021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 20045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2005c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 20065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 20076b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall VectorType *New = new (*this, TypeAlignment) 2008e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType(vecType, NumElts, Canonical, VecKind); 20095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer VectorTypes.InsertNode(New, InsertPos); 20105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 20115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 20125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 20135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2014213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman/// getExtVectorType - Return the unique reference to an extended vector type of 201573322924127c873c13101b705dd823f5539ffa5fSteve Naroff/// the specified element type and size. VectorType must be a built-in type. 20164ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 20174ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getExtVectorType(QualType vecType, unsigned NumElts) const { 20184ac01401b1ec602a1f58c217544d3dcb5fcbd7f1Douglas Gregor assert(vecType->isBuiltinType() || vecType->isDependentType()); 20191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 202073322924127c873c13101b705dd823f5539ffa5fSteve Naroff // Check if we've already instantiated a vector of this type. 202173322924127c873c13101b705dd823f5539ffa5fSteve Naroff llvm::FoldingSetNodeID ID; 2022788b0fd67e1992f23555454efcdb16a19dfefac3Chris Lattner VectorType::Profile(ID, vecType, NumElts, Type::ExtVector, 2023e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType::GenericVector); 202473322924127c873c13101b705dd823f5539ffa5fSteve Naroff void *InsertPos = 0; 202573322924127c873c13101b705dd823f5539ffa5fSteve Naroff if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 202673322924127c873c13101b705dd823f5539ffa5fSteve Naroff return QualType(VTP, 0); 202773322924127c873c13101b705dd823f5539ffa5fSteve Naroff 202873322924127c873c13101b705dd823f5539ffa5fSteve Naroff // If the element type isn't canonical, this won't be a canonical type either, 202973322924127c873c13101b705dd823f5539ffa5fSteve Naroff // so fill in the canonical type field. 203073322924127c873c13101b705dd823f5539ffa5fSteve Naroff QualType Canonical; 2031467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (!vecType.isCanonical()) { 2032213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman Canonical = getExtVectorType(getCanonicalType(vecType), NumElts); 20331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 203473322924127c873c13101b705dd823f5539ffa5fSteve Naroff // Get the new insert position for the node we care about. 203573322924127c873c13101b705dd823f5539ffa5fSteve Naroff VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2036c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 203773322924127c873c13101b705dd823f5539ffa5fSteve Naroff } 20386b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ExtVectorType *New = new (*this, TypeAlignment) 20396b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ExtVectorType(vecType, NumElts, Canonical); 204073322924127c873c13101b705dd823f5539ffa5fSteve Naroff VectorTypes.InsertNode(New, InsertPos); 204173322924127c873c13101b705dd823f5539ffa5fSteve Naroff Types.push_back(New); 204273322924127c873c13101b705dd823f5539ffa5fSteve Naroff return QualType(New, 0); 204373322924127c873c13101b705dd823f5539ffa5fSteve Naroff} 204473322924127c873c13101b705dd823f5539ffa5fSteve Naroff 20454ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 20464ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getDependentSizedExtVectorType(QualType vecType, 20474ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Expr *SizeExpr, 20484ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad SourceLocation AttrLoc) const { 20492ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor llvm::FoldingSetNodeID ID; 20501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump DependentSizedExtVectorType::Profile(ID, *this, getCanonicalType(vecType), 20512ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor SizeExpr); 20521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20532ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor void *InsertPos = 0; 20542ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor DependentSizedExtVectorType *Canon 20552ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos); 20562ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor DependentSizedExtVectorType *New; 20572ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor if (Canon) { 20582ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor // We already have a canonical version of this array type; use it as 20592ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor // the canonical type for a newly-built type. 20606b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall New = new (*this, TypeAlignment) 20616b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall DependentSizedExtVectorType(*this, vecType, QualType(Canon, 0), 20626b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall SizeExpr, AttrLoc); 20632ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } else { 20642ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor QualType CanonVecTy = getCanonicalType(vecType); 20652ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor if (CanonVecTy == vecType) { 20666b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall New = new (*this, TypeAlignment) 20676b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall DependentSizedExtVectorType(*this, vecType, QualType(), SizeExpr, 20686b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall AttrLoc); 2069789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2070789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentSizedExtVectorType *CanonCheck 2071789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2072789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!CanonCheck && "Dependent-sized ext_vector canonical type broken"); 2073789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CanonCheck; 20742ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor DependentSizedExtVectorTypes.InsertNode(New, InsertPos); 20752ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } else { 20762ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr, 20772ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor SourceLocation()); 20786b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall New = new (*this, TypeAlignment) 20796b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall DependentSizedExtVectorType(*this, vecType, Canon, SizeExpr, AttrLoc); 20802ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } 20812ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } 20821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20839cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor Types.push_back(New); 20849cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor return QualType(New, 0); 20859cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor} 20869cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor 208772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'. 20885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 20894ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 20904ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getFunctionNoProtoType(QualType ResultTy, 20914ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const FunctionType::ExtInfo &Info) const { 2092cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv DefaultCC = Info.getCC(); 2093cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv CallConv = (LangOpts.MRTD && DefaultCC == CC_Default) ? 2094cfe9af250f466e7e38becea4428990448ae07737Roman Divacky CC_X86StdCall : DefaultCC; 20955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique functions, to guarantee there is only one function of a particular 20965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 20975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 2098264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionNoProtoType::Profile(ID, ResultTy, Info); 20991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 21005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 21011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (FunctionNoProtoType *FT = 210272564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) 21035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(FT, 0); 21041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 21055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 2106ab8bbf4ebd3e3e6eab913cb044772a62b7581941Douglas Gregor if (!ResultTy.isCanonical() || 210704a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall getCanonicalCallConv(CallConv) != CallConv) { 2108264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola Canonical = 2109264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola getFunctionNoProtoType(getCanonicalType(ResultTy), 2110264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola Info.withCallingConv(getCanonicalCallConv(CallConv))); 21111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 21125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 211372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoType *NewIP = 211472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos); 2115c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 21165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 21171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2118cfe9af250f466e7e38becea4428990448ae07737Roman Divacky FunctionProtoType::ExtInfo newInfo = Info.withCallingConv(CallConv); 21196b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall FunctionNoProtoType *New = new (*this, TypeAlignment) 2120cfe9af250f466e7e38becea4428990448ae07737Roman Divacky FunctionNoProtoType(ResultTy, Canonical, newInfo); 21215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(New); 212272564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionNoProtoTypes.InsertNode(New, InsertPos); 21235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(New, 0); 21245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 21255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 21265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getFunctionType - Return a normal function type with a typed argument 21275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// list. isVariadic indicates whether the argument list includes '...'. 21284ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 21294ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getFunctionType(QualType ResultTy, 21304ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const QualType *ArgArray, unsigned NumArgs, 21314ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const FunctionProtoType::ExtProtoInfo &EPI) const { 21325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unique functions, to guarantee there is only one function of a particular 21335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // structure. 21345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::FoldingSetNodeID ID; 21358026f6d82f7fa544bc0453714fe94bca62a1196eSebastian Redl FunctionProtoType::Profile(ID, ResultTy, ArgArray, NumArgs, EPI, *this); 21365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 21375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer void *InsertPos = 0; 21381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (FunctionProtoType *FTP = 213972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) 21405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(FTP, 0); 2141465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 2142465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl // Determine whether the type being created is already canonical or not. 2143eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith bool isCanonical = 2144eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith EPI.ExceptionSpecType == EST_None && ResultTy.isCanonical() && 2145eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith !EPI.HasTrailingReturn; 21465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0; i != NumArgs && isCanonical; ++i) 214754e14c4db764c0636160d26c5bbf491637c83a76John McCall if (!ArgArray[i].isCanonicalAsParam()) 21485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer isCanonical = false; 21495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2150cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv DefaultCC = EPI.ExtInfo.getCC(); 2151cfe9af250f466e7e38becea4428990448ae07737Roman Divacky const CallingConv CallConv = (LangOpts.MRTD && DefaultCC == CC_Default) ? 2152cfe9af250f466e7e38becea4428990448ae07737Roman Divacky CC_X86StdCall : DefaultCC; 2153e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 21545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this type isn't canonical, get the canonical version of it. 2155465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl // The exception spec is not part of the canonical type. 21565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Canonical; 215704a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall if (!isCanonical || getCanonicalCallConv(CallConv) != CallConv) { 21585f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 16> CanonicalArgs; 21595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer CanonicalArgs.reserve(NumArgs); 21605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0; i != NumArgs; ++i) 216154e14c4db764c0636160d26c5bbf491637c83a76John McCall CanonicalArgs.push_back(getCanonicalParamType(ArgArray[i])); 2162465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 2163e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo CanonicalEPI = EPI; 2164eefb3d5b49c844347f212073a7e975b8118fe8e9Richard Smith CanonicalEPI.HasTrailingReturn = false; 21658b5b4099c61a136e9a1714c4d8a593febe942268Sebastian Redl CanonicalEPI.ExceptionSpecType = EST_None; 21668b5b4099c61a136e9a1714c4d8a593febe942268Sebastian Redl CanonicalEPI.NumExceptions = 0; 2167e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall CanonicalEPI.ExtInfo 2168e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall = CanonicalEPI.ExtInfo.withCallingConv(getCanonicalCallConv(CallConv)); 2169e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 2170f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner Canonical = getFunctionType(getCanonicalType(ResultTy), 2171beaaccd8e2a8748f77b66e2b330fb9136937e14cJay Foad CanonicalArgs.data(), NumArgs, 2172e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall CanonicalEPI); 2173465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 21745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the new insert position for the node we care about. 217572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoType *NewIP = 217672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos); 2177c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 21785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2179465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 2180f85e193739c953358c865005855253af4f68a497John McCall // FunctionProtoType objects are allocated with extra bytes after 2181f85e193739c953358c865005855253af4f68a497John McCall // them for three variable size arrays at the end: 2182f85e193739c953358c865005855253af4f68a497John McCall // - parameter types 2183f85e193739c953358c865005855253af4f68a497John McCall // - exception types 2184f85e193739c953358c865005855253af4f68a497John McCall // - consumed-arguments flags 2185f85e193739c953358c865005855253af4f68a497John McCall // Instead of the exception types, there could be a noexcept 2186f85e193739c953358c865005855253af4f68a497John McCall // expression. 2187e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall size_t Size = sizeof(FunctionProtoType) + 218860618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl NumArgs * sizeof(QualType); 218960618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl if (EPI.ExceptionSpecType == EST_Dynamic) 219060618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl Size += EPI.NumExceptions * sizeof(QualType); 219160618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl else if (EPI.ExceptionSpecType == EST_ComputedNoexcept) { 21928026f6d82f7fa544bc0453714fe94bca62a1196eSebastian Redl Size += sizeof(Expr*); 2193e6975e9b0985ad7f7ff9187e38d95bfe9ac4181bRichard Smith } else if (EPI.ExceptionSpecType == EST_Uninstantiated) { 219413bffc532bafd45d4a77867993c1afb83c7661beRichard Smith Size += 2 * sizeof(FunctionDecl*); 219560618fa7f88d5162bb5b40988b6b38d4d75d6fc6Sebastian Redl } 2196f85e193739c953358c865005855253af4f68a497John McCall if (EPI.ConsumedArguments) 2197f85e193739c953358c865005855253af4f68a497John McCall Size += NumArgs * sizeof(bool); 2198f85e193739c953358c865005855253af4f68a497John McCall 2199e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType *FTP = (FunctionProtoType*) Allocate(Size, TypeAlignment); 2200cfe9af250f466e7e38becea4428990448ae07737Roman Divacky FunctionProtoType::ExtProtoInfo newEPI = EPI; 2201cfe9af250f466e7e38becea4428990448ae07737Roman Divacky newEPI.ExtInfo = EPI.ExtInfo.withCallingConv(CallConv); 22028026f6d82f7fa544bc0453714fe94bca62a1196eSebastian Redl new (FTP) FunctionProtoType(ResultTy, ArgArray, NumArgs, Canonical, newEPI); 22035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Types.push_back(FTP); 220472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor FunctionProtoTypes.InsertNode(FTP, InsertPos); 22055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return QualType(FTP, 0); 22065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 22075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 22083cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall#ifndef NDEBUG 22093cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallstatic bool NeedsInjectedClassNameType(const RecordDecl *D) { 22103cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (!isa<CXXRecordDecl>(D)) return false; 22113cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall const CXXRecordDecl *RD = cast<CXXRecordDecl>(D); 22123cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (isa<ClassTemplatePartialSpecializationDecl>(RD)) 22133cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return true; 22143cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (RD->getDescribedClassTemplate() && 22153cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall !isa<ClassTemplateSpecializationDecl>(RD)) 22163cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return true; 22173cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return false; 22183cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall} 22193cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall#endif 22203cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 22213cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall/// getInjectedClassNameType - Return the unique reference to the 22223cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall/// injected class name type for the specified templated declaration. 22233cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallQualType ASTContext::getInjectedClassNameType(CXXRecordDecl *Decl, 22244ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType TST) const { 22253cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(NeedsInjectedClassNameType(Decl)); 22263cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (Decl->TypeForDecl) { 22273cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(isa<InjectedClassNameType>(Decl->TypeForDecl)); 2228ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor } else if (CXXRecordDecl *PrevDecl = Decl->getPreviousDecl()) { 22293cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(PrevDecl->TypeForDecl && "previous declaration has no type"); 22303cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall Decl->TypeForDecl = PrevDecl->TypeForDecl; 22313cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall assert(isa<InjectedClassNameType>(Decl->TypeForDecl)); 22323cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } else { 2233f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Type *newType = 223431f17ecbef57b5679c017c375db330546b7b5145John McCall new (*this, TypeAlignment) InjectedClassNameType(Decl, TST); 2235f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2236f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 22373cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } 22383cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return QualType(Decl->TypeForDecl, 0); 22393cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall} 22403cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 22412ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor/// getTypeDeclType - Return the unique reference to the type for the 22422ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor/// specified type declaration. 22434ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTypeDeclTypeSlow(const TypeDecl *Decl) const { 22441e6759e9e33dcaa73ce14c8a908ac9f87ac16463Argyrios Kyrtzidis assert(Decl && "Passed null for Decl param"); 2245becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall assert(!Decl->TypeForDecl && "TypeForDecl present in slow case"); 22461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2247162e1c1b487352434552147967c3dd296ebee2f7Richard Smith if (const TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Decl)) 22482ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor return getTypedefType(Typedef); 2249becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall 2250becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall assert(!isa<TemplateTypeParmDecl>(Decl) && 2251becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall "Template type parameter types are always available."); 2252becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall 225319c8576b7328f4dc2d07682f5da552875c1912efJohn McCall if (const RecordDecl *Record = dyn_cast<RecordDecl>(Decl)) { 2254ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor assert(!Record->getPreviousDecl() && 2255becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall "struct/union has previous declaration"); 2256becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall assert(!NeedsInjectedClassNameType(Record)); 2257400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return getRecordType(Record); 225819c8576b7328f4dc2d07682f5da552875c1912efJohn McCall } else if (const EnumDecl *Enum = dyn_cast<EnumDecl>(Decl)) { 2259ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor assert(!Enum->getPreviousDecl() && 2260becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall "enum has previous declaration"); 2261400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return getEnumType(Enum); 226219c8576b7328f4dc2d07682f5da552875c1912efJohn McCall } else if (const UnresolvedUsingTypenameDecl *Using = 2263ed97649e9574b9d854fa4d6109c9333ae0993554John McCall dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) { 2264f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Type *newType = new (*this, TypeAlignment) UnresolvedUsingType(Using); 2265f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2266f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 22679fdbab3cbc2fc04bcaf5768023d83707f3151144Mike Stump } else 2268becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall llvm_unreachable("TypeDecl without a type?"); 226949aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidis 227049aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidis return QualType(Decl->TypeForDecl, 0); 22712ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor} 22722ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor 22735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getTypedefType - Return the unique reference to the type for the 2274162e1c1b487352434552147967c3dd296ebee2f7Richard Smith/// specified typedef name decl. 22759763e221e16026ddf487d2564ed349d2c874a1a1Argyrios KyrtzidisQualType 2276162e1c1b487352434552147967c3dd296ebee2f7Richard SmithASTContext::getTypedefType(const TypedefNameDecl *Decl, 2277162e1c1b487352434552147967c3dd296ebee2f7Richard Smith QualType Canonical) const { 22785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 22791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 22809763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis if (Canonical.isNull()) 22819763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis Canonical = getCanonicalType(Decl->getUnderlyingType()); 2282f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall TypedefType *newType = new(*this, TypeAlignment) 22836b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypedefType(Type::Typedef, Decl, Canonical); 2284f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2285f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 2286f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall return QualType(newType, 0); 22875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 22885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 22894ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getRecordType(const RecordDecl *Decl) const { 2290400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 2291400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2292ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor if (const RecordDecl *PrevDecl = Decl->getPreviousDecl()) 2293400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (PrevDecl->TypeForDecl) 2294400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0); 2295400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2296f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall RecordType *newType = new (*this, TypeAlignment) RecordType(Decl); 2297f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2298f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 2299f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall return QualType(newType, 0); 2300400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis} 2301400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 23024ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getEnumType(const EnumDecl *Decl) const { 2303400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 2304400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2305ef96ee0be5f100789f451641542a69cd719144d2Douglas Gregor if (const EnumDecl *PrevDecl = Decl->getPreviousDecl()) 2306400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (PrevDecl->TypeForDecl) 2307400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0); 2308400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 2309f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall EnumType *newType = new (*this, TypeAlignment) EnumType(Decl); 2310f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Decl->TypeForDecl = newType; 2311f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall Types.push_back(newType); 2312f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall return QualType(newType, 0); 2313400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis} 2314400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 23159d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCallQualType ASTContext::getAttributedType(AttributedType::Kind attrKind, 23169d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall QualType modifiedType, 23179d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall QualType equivalentType) { 23189d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall llvm::FoldingSetNodeID id; 23199d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedType::Profile(id, attrKind, modifiedType, equivalentType); 23209d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23219d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall void *insertPos = 0; 23229d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedType *type = AttributedTypes.FindNodeOrInsertPos(id, insertPos); 23239d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall if (type) return QualType(type, 0); 23249d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23259d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall QualType canon = getCanonicalType(equivalentType); 23269d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall type = new (*this, TypeAlignment) 23279d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedType(canon, attrKind, modifiedType, equivalentType); 23289d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23299d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall Types.push_back(type); 23309d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall AttributedTypes.InsertNode(type, insertPos); 23319d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23329d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall return QualType(type, 0); 23339d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall} 23349d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 23359d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 233649a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall/// \brief Retrieve a substitution-result type. 233749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCallQualType 233849a832bd499d6f61c23655f1fac99f0dd229756eJohn McCallASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm, 23394ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType Replacement) const { 2340467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(Replacement.isCanonical() 234149a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall && "replacement types must always be canonical"); 234249a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 234349a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall llvm::FoldingSetNodeID ID; 234449a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmType::Profile(ID, Parm, Replacement); 234549a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall void *InsertPos = 0; 234649a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmType *SubstParm 234749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 234849a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 234949a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall if (!SubstParm) { 235049a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstParm = new (*this, TypeAlignment) 235149a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmType(Parm, Replacement); 235249a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall Types.push_back(SubstParm); 235349a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos); 235449a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall } 235549a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 235649a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall return QualType(SubstParm, 0); 235749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall} 235849a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 2359c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor/// \brief Retrieve a 2360c3069d618f4661d923cb1b5c4525b082fce73b04Douglas GregorQualType ASTContext::getSubstTemplateTypeParmPackType( 2361c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor const TemplateTypeParmType *Parm, 2362c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor const TemplateArgument &ArgPack) { 2363c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor#ifndef NDEBUG 2364c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor for (TemplateArgument::pack_iterator P = ArgPack.pack_begin(), 2365c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor PEnd = ArgPack.pack_end(); 2366c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor P != PEnd; ++P) { 2367c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor assert(P->getKind() == TemplateArgument::Type &&"Pack contains a non-type"); 2368c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor assert(P->getAsType().isCanonical() && "Pack contains non-canonical type"); 2369c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor } 2370c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor#endif 2371c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2372c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor llvm::FoldingSetNodeID ID; 2373c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmPackType::Profile(ID, Parm, ArgPack); 2374c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor void *InsertPos = 0; 2375c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor if (SubstTemplateTypeParmPackType *SubstParm 2376c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor = SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos)) 2377c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor return QualType(SubstParm, 0); 2378c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2379c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor QualType Canon; 2380c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor if (!Parm->isCanonicalUnqualified()) { 2381c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor Canon = getCanonicalType(QualType(Parm, 0)); 2382c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor Canon = getSubstTemplateTypeParmPackType(cast<TemplateTypeParmType>(Canon), 2383c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor ArgPack); 2384c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos); 2385c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor } 2386c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2387c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmPackType *SubstParm 2388c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor = new (*this, TypeAlignment) SubstTemplateTypeParmPackType(Parm, Canon, 2389c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor ArgPack); 2390c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor Types.push_back(SubstParm); 2391c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos); 2392c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor return QualType(SubstParm, 0); 2393c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor} 2394c3069d618f4661d923cb1b5c4525b082fce73b04Douglas Gregor 2395fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor/// \brief Retrieve the template type parameter type for a template 23961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// parameter or parameter pack with the given depth, index, and (optionally) 239776e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson/// name. 23981eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index, 239976e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson bool ParameterPack, 24004fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TemplateTypeParmDecl *TTPDecl) const { 2401fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor llvm::FoldingSetNodeID ID; 24024fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, TTPDecl); 2403fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor void *InsertPos = 0; 24041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateTypeParmType *TypeParm 2405fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 2406fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 2407fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor if (TypeParm) 2408fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor return QualType(TypeParm, 0); 24091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 24104fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth if (TTPDecl) { 241176e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack); 24124fb86f8c4585e53c21c847ad3de9e3b2de123cd9Chandler Carruth TypeParm = new (*this, TypeAlignment) TemplateTypeParmType(TTPDecl, Canon); 2413789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2414789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor TemplateTypeParmType *TypeCheck 2415789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 2416789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!TypeCheck && "Template type parameter canonical type broken"); 2417789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)TypeCheck; 241876e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson } else 24196b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypeParm = new (*this, TypeAlignment) 24206b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TemplateTypeParmType(Depth, Index, ParameterPack); 2421fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 2422fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor Types.push_back(TypeParm); 2423fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos); 2424fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 2425fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor return QualType(TypeParm, 0); 2426fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor} 2427fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 24283cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallTypeSourceInfo * 24293cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCallASTContext::getTemplateSpecializationTypeInfo(TemplateName Name, 24303cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall SourceLocation NameLoc, 24313cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall const TemplateArgumentListInfo &Args, 24323e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType Underlying) const { 24337c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Name.getAsDependentTemplateName() && 24347c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 24353e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType TST = getTemplateSpecializationType(Name, Args, Underlying); 24363cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 24373cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TypeSourceInfo *DI = CreateTypeSourceInfo(TST); 24383cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TemplateSpecializationTypeLoc TL 24393cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall = cast<TemplateSpecializationTypeLoc>(DI->getTypeLoc()); 244055d23c925b058be29b792008ddb7d68f6c4fa9a0Abramo Bagnara TL.setTemplateKeywordLoc(SourceLocation()); 24413cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setTemplateNameLoc(NameLoc); 24423cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setLAngleLoc(Args.getLAngleLoc()); 24433cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setRAngleLoc(Args.getRAngleLoc()); 24443cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 24453cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TL.setArgLocInfo(i, Args[i].getLocInfo()); 24463cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return DI; 24473cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall} 24483cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 24491eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType 24507532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas GregorASTContext::getTemplateSpecializationType(TemplateName Template, 2451d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall const TemplateArgumentListInfo &Args, 24523e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType Underlying) const { 24537c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Template.getAsDependentTemplateName() && 24547c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 24557c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor 2456d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall unsigned NumArgs = Args.size(); 2457d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall 24585f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> ArgVec; 2459833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall ArgVec.reserve(NumArgs); 2460833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall for (unsigned i = 0; i != NumArgs; ++i) 2461833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall ArgVec.push_back(Args[i].getArgument()); 2462833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 246331f17ecbef57b5679c017c375db330546b7b5145John McCall return getTemplateSpecializationType(Template, ArgVec.data(), NumArgs, 24643e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith Underlying); 2465833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall} 2466833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 2467b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor#ifndef NDEBUG 2468b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregorstatic bool hasAnyPackExpansions(const TemplateArgument *Args, 2469b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor unsigned NumArgs) { 2470b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor for (unsigned I = 0; I != NumArgs; ++I) 2471b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor if (Args[I].isPackExpansion()) 2472b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor return true; 2473b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor 2474b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor return true; 2475b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor} 2476b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor#endif 2477b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor 2478833ca991c1bfc967f0995974ca86f66ba1f666b5John McCallQualType 2479833ca991c1bfc967f0995974ca86f66ba1f666b5John McCallASTContext::getTemplateSpecializationType(TemplateName Template, 24807532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor const TemplateArgument *Args, 24817532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor unsigned NumArgs, 24823e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType Underlying) const { 24837c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Template.getAsDependentTemplateName() && 24847c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 24850f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor // Look through qualified template names. 24860f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 24870f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor Template = TemplateName(QTN->getTemplateDecl()); 24887c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor 2489b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor bool IsTypeAlias = 24903e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith Template.getAsTemplateDecl() && 24913e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith isa<TypeAliasTemplateDecl>(Template.getAsTemplateDecl()); 24923e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType CanonType; 24933e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith if (!Underlying.isNull()) 24943e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith CanonType = getCanonicalType(Underlying); 24953e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith else { 2496b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor // We can get here with an alias template when the specialization contains 2497b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor // a pack expansion that does not match up with a parameter pack. 2498b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor assert((!IsTypeAlias || hasAnyPackExpansions(Args, NumArgs)) && 2499b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor "Caller must compute aliased type"); 2500b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor IsTypeAlias = false; 25013e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith CanonType = getCanonicalTemplateSpecializationType(Template, Args, 25023e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith NumArgs); 25033e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith } 2504fc705b84347e6fb4746a1a7e26949f64c2f2f358Douglas Gregor 25051275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // Allocate the (non-canonical) template specialization type, but don't 25061275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // try to unique it: these types typically have location information that 25071275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // we don't unique and don't want to lose. 25083e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith void *Mem = Allocate(sizeof(TemplateSpecializationType) + 25093e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith sizeof(TemplateArgument) * NumArgs + 2510b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor (IsTypeAlias? sizeof(QualType) : 0), 25116b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypeAlignment); 25121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateSpecializationType *Spec 2513b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor = new (Mem) TemplateSpecializationType(Template, Args, NumArgs, CanonType, 2514b70126a328f89937f46db42f9e3cba1592887c91Douglas Gregor IsTypeAlias ? Underlying : QualType()); 25151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 251655f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor Types.push_back(Spec); 25171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return QualType(Spec, 0); 251855f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor} 251955f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor 25201eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType 25219763e221e16026ddf487d2564ed349d2c874a1a1Argyrios KyrtzidisASTContext::getCanonicalTemplateSpecializationType(TemplateName Template, 25229763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis const TemplateArgument *Args, 25234ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned NumArgs) const { 25247c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor assert(!Template.getAsDependentTemplateName() && 25257c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor "No dependent template names here!"); 25263e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith 25270f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor // Look through qualified template names. 25280f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 25290f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor Template = TemplateName(QTN->getTemplateDecl()); 25307c3179cf463c3b3b8c21dbb955f933ba50b74f28Douglas Gregor 25319763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Build the canonical template specialization type. 25329763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateName CanonTemplate = getCanonicalTemplateName(Template); 25335f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 4> CanonArgs; 25349763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.reserve(NumArgs); 25359763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis for (unsigned I = 0; I != NumArgs; ++I) 25369763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.push_back(getCanonicalTemplateArgument(Args[I])); 25379763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25389763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Determine whether this canonical template specialization type already 25399763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // exists. 25409763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis llvm::FoldingSetNodeID ID; 25419763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateSpecializationType::Profile(ID, CanonTemplate, 25429763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.data(), NumArgs, *this); 25439763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25449763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis void *InsertPos = 0; 25459763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateSpecializationType *Spec 25469763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 25479763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25489763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis if (!Spec) { 25499763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Allocate a new canonical template specialization type. 25509763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis void *Mem = Allocate((sizeof(TemplateSpecializationType) + 25519763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis sizeof(TemplateArgument) * NumArgs), 25529763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TypeAlignment); 25539763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis Spec = new (Mem) TemplateSpecializationType(CanonTemplate, 25549763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis CanonArgs.data(), NumArgs, 25553e4c6c4c79a03f5cb0c4671d7c282d623c6dc35eRichard Smith QualType(), QualType()); 25569763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis Types.push_back(Spec); 25579763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TemplateSpecializationTypes.InsertNode(Spec, InsertPos); 25589763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis } 25599763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25609763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis assert(Spec->isDependentType() && 25619763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis "Non-dependent template-id type must have a canonical type"); 25629763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis return QualType(Spec, 0); 25639763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis} 25649763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 25659763e221e16026ddf487d2564ed349d2c874a1a1Argyrios KyrtzidisQualType 2566465d41b92b2c862f3062c412a0538db65c6a2661Abramo BagnaraASTContext::getElaboratedType(ElaboratedTypeKeyword Keyword, 2567465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara NestedNameSpecifier *NNS, 25684ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType NamedType) const { 2569e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor llvm::FoldingSetNodeID ID; 2570465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedType::Profile(ID, Keyword, NNS, NamedType); 2571e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor 2572e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor void *InsertPos = 0; 2573465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedType *T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos); 2574e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor if (T) 2575e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor return QualType(T, 0); 2576e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor 2577789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor QualType Canon = NamedType; 2578789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor if (!Canon.isCanonical()) { 2579789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor Canon = getCanonicalType(NamedType); 2580465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedType *CheckT = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos); 2581465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara assert(!CheckT && "Elaborated canonical type broken"); 2582789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CheckT; 2583789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor } 2584789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2585465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara T = new (*this) ElaboratedType(Keyword, NNS, NamedType, Canon); 2586e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor Types.push_back(T); 2587465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara ElaboratedTypes.InsertNode(T, InsertPos); 2588e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor return QualType(T, 0); 2589e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor} 2590e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor 2591075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo BagnaraQualType 25924ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getParenType(QualType InnerType) const { 2593075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara llvm::FoldingSetNodeID ID; 2594075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenType::Profile(ID, InnerType); 2595075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 2596075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara void *InsertPos = 0; 2597075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenType *T = ParenTypes.FindNodeOrInsertPos(ID, InsertPos); 2598075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara if (T) 2599075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return QualType(T, 0); 2600075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 2601075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara QualType Canon = InnerType; 2602075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara if (!Canon.isCanonical()) { 2603075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara Canon = getCanonicalType(InnerType); 2604075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos); 2605075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara assert(!CheckT && "Paren canonical type broken"); 2606075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara (void)CheckT; 2607075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara } 2608075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 2609075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara T = new (*this) ParenType(InnerType, Canon); 2610075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara Types.push_back(T); 2611075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara ParenTypes.InsertNode(T, InsertPos); 2612075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return QualType(T, 0); 2613075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara} 2614075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 26154a2023f5014e82389d5980d307b89c545dbbac81Douglas GregorQualType ASTContext::getDependentNameType(ElaboratedTypeKeyword Keyword, 26164a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor NestedNameSpecifier *NNS, 26174a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor const IdentifierInfo *Name, 26184ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType Canon) const { 2619d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor assert(NNS->isDependent() && "nested-name-specifier must be dependent"); 2620d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2621d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor if (Canon.isNull()) { 2622d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 26234a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor ElaboratedTypeKeyword CanonKeyword = Keyword; 26244a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor if (Keyword == ETK_None) 26254a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor CanonKeyword = ETK_Typename; 26264a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor 26274a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor if (CanonNNS != NNS || CanonKeyword != Keyword) 26284a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor Canon = getDependentNameType(CanonKeyword, CanonNNS, Name); 2629d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor } 2630d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2631d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor llvm::FoldingSetNodeID ID; 26324a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor DependentNameType::Profile(ID, Keyword, NNS, Name); 2633d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2634d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor void *InsertPos = 0; 26354714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor DependentNameType *T 26364714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos); 2637d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor if (T) 2638d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor return QualType(T, 0); 2639d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 26404a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor T = new (*this) DependentNameType(Keyword, NNS, Name, Canon); 2641d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor Types.push_back(T); 26424714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor DependentNameTypes.InsertNode(T, InsertPos); 26431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return QualType(T, 0); 2644d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor} 2645d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 26461eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType 264733500955d731c73717af52088b7fc0e7a85681e7John McCallASTContext::getDependentTemplateSpecializationType( 264833500955d731c73717af52088b7fc0e7a85681e7John McCall ElaboratedTypeKeyword Keyword, 26494a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor NestedNameSpecifier *NNS, 265033500955d731c73717af52088b7fc0e7a85681e7John McCall const IdentifierInfo *Name, 26514ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const TemplateArgumentListInfo &Args) const { 265233500955d731c73717af52088b7fc0e7a85681e7John McCall // TODO: avoid this copy 26535f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 16> ArgCopy; 265433500955d731c73717af52088b7fc0e7a85681e7John McCall for (unsigned I = 0, E = Args.size(); I != E; ++I) 265533500955d731c73717af52088b7fc0e7a85681e7John McCall ArgCopy.push_back(Args[I].getArgument()); 265633500955d731c73717af52088b7fc0e7a85681e7John McCall return getDependentTemplateSpecializationType(Keyword, NNS, Name, 265733500955d731c73717af52088b7fc0e7a85681e7John McCall ArgCopy.size(), 265833500955d731c73717af52088b7fc0e7a85681e7John McCall ArgCopy.data()); 265933500955d731c73717af52088b7fc0e7a85681e7John McCall} 266033500955d731c73717af52088b7fc0e7a85681e7John McCall 266133500955d731c73717af52088b7fc0e7a85681e7John McCallQualType 266233500955d731c73717af52088b7fc0e7a85681e7John McCallASTContext::getDependentTemplateSpecializationType( 266333500955d731c73717af52088b7fc0e7a85681e7John McCall ElaboratedTypeKeyword Keyword, 266433500955d731c73717af52088b7fc0e7a85681e7John McCall NestedNameSpecifier *NNS, 266533500955d731c73717af52088b7fc0e7a85681e7John McCall const IdentifierInfo *Name, 266633500955d731c73717af52088b7fc0e7a85681e7John McCall unsigned NumArgs, 26674ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const TemplateArgument *Args) const { 2668aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor assert((!NNS || NNS->isDependent()) && 2669aa2187de137e5b809dcbbe14f3b61ae907a3d8aaDouglas Gregor "nested-name-specifier must be dependent"); 26701734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 2671789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor llvm::FoldingSetNodeID ID; 267233500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS, 267333500955d731c73717af52088b7fc0e7a85681e7John McCall Name, NumArgs, Args); 2674789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2675789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor void *InsertPos = 0; 267633500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationType *T 267733500955d731c73717af52088b7fc0e7a85681e7John McCall = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 2678789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor if (T) 2679789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor return QualType(T, 0); 2680789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 268133500955d731c73717af52088b7fc0e7a85681e7John McCall NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 268233500955d731c73717af52088b7fc0e7a85681e7John McCall 268333500955d731c73717af52088b7fc0e7a85681e7John McCall ElaboratedTypeKeyword CanonKeyword = Keyword; 268433500955d731c73717af52088b7fc0e7a85681e7John McCall if (Keyword == ETK_None) CanonKeyword = ETK_Typename; 26851734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 268633500955d731c73717af52088b7fc0e7a85681e7John McCall bool AnyNonCanonArgs = false; 26875f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<TemplateArgument, 16> CanonArgs(NumArgs); 268833500955d731c73717af52088b7fc0e7a85681e7John McCall for (unsigned I = 0; I != NumArgs; ++I) { 268933500955d731c73717af52088b7fc0e7a85681e7John McCall CanonArgs[I] = getCanonicalTemplateArgument(Args[I]); 269033500955d731c73717af52088b7fc0e7a85681e7John McCall if (!CanonArgs[I].structurallyEquals(Args[I])) 269133500955d731c73717af52088b7fc0e7a85681e7John McCall AnyNonCanonArgs = true; 2692789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor } 26931734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 269433500955d731c73717af52088b7fc0e7a85681e7John McCall QualType Canon; 269533500955d731c73717af52088b7fc0e7a85681e7John McCall if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) { 269633500955d731c73717af52088b7fc0e7a85681e7John McCall Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS, 269733500955d731c73717af52088b7fc0e7a85681e7John McCall Name, NumArgs, 269833500955d731c73717af52088b7fc0e7a85681e7John McCall CanonArgs.data()); 269933500955d731c73717af52088b7fc0e7a85681e7John McCall 270033500955d731c73717af52088b7fc0e7a85681e7John McCall // Find the insert position again. 270133500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 270233500955d731c73717af52088b7fc0e7a85681e7John McCall } 270333500955d731c73717af52088b7fc0e7a85681e7John McCall 270433500955d731c73717af52088b7fc0e7a85681e7John McCall void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) + 270533500955d731c73717af52088b7fc0e7a85681e7John McCall sizeof(TemplateArgument) * NumArgs), 270633500955d731c73717af52088b7fc0e7a85681e7John McCall TypeAlignment); 2707ef99001908e799c388f1363b1e607dad5f5b57d3John McCall T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS, 270833500955d731c73717af52088b7fc0e7a85681e7John McCall Name, NumArgs, Args, Canon); 27091734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor Types.push_back(T); 271033500955d731c73717af52088b7fc0e7a85681e7John McCall DependentTemplateSpecializationTypes.InsertNode(T, InsertPos); 27111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return QualType(T, 0); 27121734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor} 27131734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 2714cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas GregorQualType ASTContext::getPackExpansionType(QualType Pattern, 2715cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor llvm::Optional<unsigned> NumExpansions) { 27167536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor llvm::FoldingSetNodeID ID; 2717cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor PackExpansionType::Profile(ID, Pattern, NumExpansions); 27187536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 27197536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor assert(Pattern->containsUnexpandedParameterPack() && 27207536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor "Pack expansions must expand one or more parameter packs"); 27217536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor void *InsertPos = 0; 27227536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor PackExpansionType *T 27237536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor = PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos); 27247536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor if (T) 27257536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor return QualType(T, 0); 27267536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 27277536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor QualType Canon; 27287536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor if (!Pattern.isCanonical()) { 2729cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor Canon = getPackExpansionType(getCanonicalType(Pattern), NumExpansions); 27307536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 27317536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor // Find the insert position again. 27327536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos); 27337536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor } 27347536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 2735cded4f649cd4b7ba7d461c25c6482ef52b8d3a2aDouglas Gregor T = new (*this) PackExpansionType(Pattern, Canon, NumExpansions); 27367536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor Types.push_back(T); 27377536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor PackExpansionTypes.InsertNode(T, InsertPos); 27387536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor return QualType(T, 0); 27397536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor} 27407536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor 274188cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner/// CmpProtocolNames - Comparison predicate for sorting protocols 274288cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner/// alphabetically. 274388cb27a160adc305783a44f922ee4b216006ebf9Chris Lattnerstatic bool CmpProtocolNames(const ObjCProtocolDecl *LHS, 274488cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner const ObjCProtocolDecl *RHS) { 27452e1cd4264d363ca869bf37ef160902f211d21b8cDouglas Gregor return LHS->getDeclName() < RHS->getDeclName(); 274688cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner} 274788cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 2748c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCallstatic bool areSortedAndUniqued(ObjCProtocolDecl * const *Protocols, 274954e14c4db764c0636160d26c5bbf491637c83a76John McCall unsigned NumProtocols) { 275054e14c4db764c0636160d26c5bbf491637c83a76John McCall if (NumProtocols == 0) return true; 275154e14c4db764c0636160d26c5bbf491637c83a76John McCall 275261cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor if (Protocols[0]->getCanonicalDecl() != Protocols[0]) 275361cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor return false; 275461cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor 275554e14c4db764c0636160d26c5bbf491637c83a76John McCall for (unsigned i = 1; i != NumProtocols; ++i) 275661cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor if (!CmpProtocolNames(Protocols[i-1], Protocols[i]) || 275761cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor Protocols[i]->getCanonicalDecl() != Protocols[i]) 275854e14c4db764c0636160d26c5bbf491637c83a76John McCall return false; 275954e14c4db764c0636160d26c5bbf491637c83a76John McCall return true; 276054e14c4db764c0636160d26c5bbf491637c83a76John McCall} 276154e14c4db764c0636160d26c5bbf491637c83a76John McCall 276254e14c4db764c0636160d26c5bbf491637c83a76John McCallstatic void SortAndUniqueProtocols(ObjCProtocolDecl **Protocols, 276388cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner unsigned &NumProtocols) { 276488cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner ObjCProtocolDecl **ProtocolsEnd = Protocols+NumProtocols; 27651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 276688cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner // Sort protocols, keyed by name. 276788cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner std::sort(Protocols, Protocols+NumProtocols, CmpProtocolNames); 276888cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 276961cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor // Canonicalize. 277061cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor for (unsigned I = 0, N = NumProtocols; I != N; ++I) 277161cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor Protocols[I] = Protocols[I]->getCanonicalDecl(); 277261cc296de6c1f82fa84c0abb3ecd142a584838efDouglas Gregor 277388cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner // Remove duplicates. 277488cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner ProtocolsEnd = std::unique(Protocols, ProtocolsEnd); 277588cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner NumProtocols = ProtocolsEnd-Protocols; 277688cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner} 277788cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 2778c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCallQualType ASTContext::getObjCObjectType(QualType BaseType, 2779c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCProtocolDecl * const *Protocols, 27804ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned NumProtocols) const { 2781c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // If the base type is an interface and there aren't any protocols 2782c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // to add, then the interface type will do just fine. 2783c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!NumProtocols && isa<ObjCInterfaceType>(BaseType)) 2784c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return BaseType; 2785d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff 2786c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Look in the folding set for an existing type. 2787c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall llvm::FoldingSetNodeID ID; 2788c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypeImpl::Profile(ID, BaseType, Protocols, NumProtocols); 2789d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff void *InsertPos = 0; 2790c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos)) 2791c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return QualType(QT, 0); 2792d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff 2793c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Build the canonical type, which has the canonical base type and 2794c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // a sorted-and-uniqued list of protocols. 279554e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType Canonical; 2796c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall bool ProtocolsSorted = areSortedAndUniqued(Protocols, NumProtocols); 2797c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!ProtocolsSorted || !BaseType.isCanonical()) { 2798c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!ProtocolsSorted) { 27995f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<ObjCProtocolDecl*, 8> Sorted(Protocols, 28000237941e0beb0c929934b66ad29443b484d987feBenjamin Kramer Protocols + NumProtocols); 280154e14c4db764c0636160d26c5bbf491637c83a76John McCall unsigned UniqueCount = NumProtocols; 280254e14c4db764c0636160d26c5bbf491637c83a76John McCall 280354e14c4db764c0636160d26c5bbf491637c83a76John McCall SortAndUniqueProtocols(&Sorted[0], UniqueCount); 2804c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Canonical = getObjCObjectType(getCanonicalType(BaseType), 2805c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall &Sorted[0], UniqueCount); 280654e14c4db764c0636160d26c5bbf491637c83a76John McCall } else { 2807c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Canonical = getObjCObjectType(getCanonicalType(BaseType), 2808c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Protocols, NumProtocols); 280954e14c4db764c0636160d26c5bbf491637c83a76John McCall } 281054e14c4db764c0636160d26c5bbf491637c83a76John McCall 281154e14c4db764c0636160d26c5bbf491637c83a76John McCall // Regenerate InsertPos. 2812c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos); 281354e14c4db764c0636160d26c5bbf491637c83a76John McCall } 281454e14c4db764c0636160d26c5bbf491637c83a76John McCall 2815c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall unsigned Size = sizeof(ObjCObjectTypeImpl); 2816c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Size += NumProtocols * sizeof(ObjCProtocolDecl *); 2817fd6a0887a099256c35a5b23e9afd517ffe95fa0aDouglas Gregor void *Mem = Allocate(Size, TypeAlignment); 2818c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypeImpl *T = 2819c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall new (Mem) ObjCObjectTypeImpl(Canonical, BaseType, Protocols, NumProtocols); 28201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2821c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Types.push_back(T); 2822c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectTypes.InsertNode(T, InsertPos); 2823c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return QualType(T, 0); 2824d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff} 282588cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner 2826c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall/// getObjCObjectPointerType - Return a ObjCObjectPointerType type for 2827c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall/// the given object type. 28284ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getObjCObjectPointerType(QualType ObjectT) const { 28294b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian llvm::FoldingSetNodeID ID; 2830c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerType::Profile(ID, ObjectT); 28311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 28324b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian void *InsertPos = 0; 2833c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (ObjCObjectPointerType *QT = 2834c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 28354b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian return QualType(QT, 0); 28361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2837c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Find the canonical object type. 283854e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType Canonical; 2839c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!ObjectT.isCanonical()) { 2840c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Canonical = getObjCObjectPointerType(getCanonicalType(ObjectT)); 284154e14c4db764c0636160d26c5bbf491637c83a76John McCall 2842c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Regenerate InsertPos. 2843c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 284454e14c4db764c0636160d26c5bbf491637c83a76John McCall } 284554e14c4db764c0636160d26c5bbf491637c83a76John McCall 2846c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // No match. 2847c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall void *Mem = Allocate(sizeof(ObjCObjectPointerType), TypeAlignment); 2848c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerType *QType = 2849c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall new (Mem) ObjCObjectPointerType(Canonical, ObjectT); 285024fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis 285124fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis Types.push_back(QType); 2852c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall ObjCObjectPointerTypes.InsertNode(QType, InsertPos); 285324fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis return QualType(QType, 0); 285424fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis} 285524fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis 2856deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor/// getObjCInterfaceType - Return the unique reference to the type for the 2857deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor/// specified ObjC interface decl. The list of protocols is optional. 28580af550115df1f57f17a4f125ff0e8b34820c65d1Douglas GregorQualType ASTContext::getObjCInterfaceType(const ObjCInterfaceDecl *Decl, 28590af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor ObjCInterfaceDecl *PrevDecl) const { 2860deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor if (Decl->TypeForDecl) 2861deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor return QualType(Decl->TypeForDecl, 0); 286274c730ad1f6818b676b0bad46d806a9176950328Sebastian Redl 28630af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor if (PrevDecl) { 28640af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor assert(PrevDecl->TypeForDecl && "previous decl has no TypeForDecl"); 28650af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor Decl->TypeForDecl = PrevDecl->TypeForDecl; 28660af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor return QualType(PrevDecl->TypeForDecl, 0); 28670af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor } 28680af550115df1f57f17a4f125ff0e8b34820c65d1Douglas Gregor 28698d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor // Prefer the definition, if there is one. 28708d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor if (const ObjCInterfaceDecl *Def = Decl->getDefinition()) 28718d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor Decl = Def; 28728d2dbbf9ddfd9d762a341d83f83d840ff68ce03dDouglas Gregor 2873deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor void *Mem = Allocate(sizeof(ObjCInterfaceType), TypeAlignment); 2874deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor ObjCInterfaceType *T = new (Mem) ObjCInterfaceType(Decl); 2875deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor Decl->TypeForDecl = T; 2876deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor Types.push_back(T); 2877deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor return QualType(T, 0); 2878c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall} 2879c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 288072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor/// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique 288172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor/// TypeOfExprType AST's (since expression's are never shared). For example, 28829752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// multiple declarations that refer to "typeof(x)" all contain different 28831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// DeclRefExpr's. This doesn't effect the type checker, since it operates 28849752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// on canonical type's (which are always unique). 28854ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTypeOfExprType(Expr *tofExpr) const { 2886dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor TypeOfExprType *toe; 2887b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor if (tofExpr->isTypeDependent()) { 2888b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor llvm::FoldingSetNodeID ID; 2889b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor DependentTypeOfExprType::Profile(ID, *this, tofExpr); 28901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2891b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor void *InsertPos = 0; 2892b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor DependentTypeOfExprType *Canon 2893b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos); 2894b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor if (Canon) { 2895b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor // We already have a "canonical" version of an identical, dependent 2896b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor // typeof(expr) type. Use that as our canonical type. 28976b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, 2898b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor QualType((TypeOfExprType*)Canon, 0)); 28993060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 2900b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor // Build a new, canonical typeof(expr) type. 29016b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall Canon 29026b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr); 2903b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor DependentTypeOfExprTypes.InsertNode(Canon, InsertPos); 2904b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor toe = Canon; 2905b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor } 2906b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor } else { 2907dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor QualType Canonical = getCanonicalType(tofExpr->getType()); 29086b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical); 2909dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor } 29109752f25748d954df99087d741ea35db37ff16beaSteve Naroff Types.push_back(toe); 29119752f25748d954df99087d741ea35db37ff16beaSteve Naroff return QualType(toe, 0); 2912d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff} 2913d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff 29149752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// getTypeOfType - Unlike many "get<Type>" functions, we don't unique 29159752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// TypeOfType AST's. The only motivation to unique these nodes would be 29169752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be 29171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// an issue. This doesn't effect the type checker, since it operates 29189752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// on canonical type's (which are always unique). 29194ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTypeOfType(QualType tofType) const { 2920f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner QualType Canonical = getCanonicalType(tofType); 29216b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall TypeOfType *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical); 29229752f25748d954df99087d741ea35db37ff16beaSteve Naroff Types.push_back(tot); 29239752f25748d954df99087d741ea35db37ff16beaSteve Naroff return QualType(tot, 0); 2924d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff} 2925d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff 292660a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson 2927395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson/// getDecltypeType - Unlike many "get<Type>" functions, we don't unique 2928395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson/// DecltypeType AST's. The only motivation to unique these nodes would be 2929395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson/// memory savings. Since decltype(t) is fairly uncommon, space shouldn't be 29301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// an issue. This doesn't effect the type checker, since it operates 293139e02032b01874a0d02ba85a4cd3922adda81376David Blaikie/// on canonical types (which are always unique). 2932f8af98286022f72157d84951b48fde5fb369ab29Douglas GregorQualType ASTContext::getDecltypeType(Expr *e, QualType UnderlyingType) const { 2933dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor DecltypeType *dt; 2934561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor 2935561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // C++0x [temp.type]p2: 2936561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // If an expression e involves a template parameter, decltype(e) denotes a 2937561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // unique dependent type. Two such decltype-specifiers refer to the same 2938561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor // type only if their expressions are equivalent (14.5.6.1). 2939561f81243f665cf2001caadc45df505f826b72d6Douglas Gregor if (e->isInstantiationDependent()) { 29409d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor llvm::FoldingSetNodeID ID; 29419d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor DependentDecltypeType::Profile(ID, *this, e); 29421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 29439d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor void *InsertPos = 0; 29449d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor DependentDecltypeType *Canon 29459d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos); 29469d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor if (Canon) { 29479d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor // We already have a "canonical" version of an equivalent, dependent 29489d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor // decltype type. Use that as our canonical type. 29496b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall dt = new (*this, TypeAlignment) DecltypeType(e, DependentTy, 29509d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor QualType((DecltypeType*)Canon, 0)); 29513060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 29529d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor // Build a new, canonical typeof(expr) type. 29536b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall Canon = new (*this, TypeAlignment) DependentDecltypeType(*this, e); 29549d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor DependentDecltypeTypes.InsertNode(Canon, InsertPos); 29559d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor dt = Canon; 29569d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor } 29579d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor } else { 2958f8af98286022f72157d84951b48fde5fb369ab29Douglas Gregor dt = new (*this, TypeAlignment) DecltypeType(e, UnderlyingType, 2959f8af98286022f72157d84951b48fde5fb369ab29Douglas Gregor getCanonicalType(UnderlyingType)); 2960dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor } 2961395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson Types.push_back(dt); 2962395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson return QualType(dt, 0); 2963395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson} 2964395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson 2965ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt/// getUnaryTransformationType - We don't unique these, since the memory 2966ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt/// savings are minimal and these are rare. 2967ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean HuntQualType ASTContext::getUnaryTransformType(QualType BaseType, 2968ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt QualType UnderlyingType, 2969ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt UnaryTransformType::UTTKind Kind) 2970ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt const { 2971ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt UnaryTransformType *Ty = 297269d9775da47a4b9f165dbc33277f02982928a94eDouglas Gregor new (*this, TypeAlignment) UnaryTransformType (BaseType, UnderlyingType, 297369d9775da47a4b9f165dbc33277f02982928a94eDouglas Gregor Kind, 297469d9775da47a4b9f165dbc33277f02982928a94eDouglas Gregor UnderlyingType->isDependentType() ? 297512fc4b0624706b474fa10308631fa8daf92f340fPeter Collingbourne QualType() : getCanonicalType(UnderlyingType)); 2976ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt Types.push_back(Ty); 2977ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt return QualType(Ty, 0); 2978ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt} 2979ca63c200346c0ca9e00194ec6e34a5a7b0ed9321Sean Hunt 2980483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith/// getAutoType - We only unique auto types after they've been deduced. 298134b41d939a1328f484511c6002ba2456db879a29Richard SmithQualType ASTContext::getAutoType(QualType DeducedType) const { 2982483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith void *InsertPos = 0; 2983483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith if (!DeducedType.isNull()) { 2984483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith // Look in the folding set for an existing type. 2985483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith llvm::FoldingSetNodeID ID; 2986483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith AutoType::Profile(ID, DeducedType); 2987483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith if (AutoType *AT = AutoTypes.FindNodeOrInsertPos(ID, InsertPos)) 2988483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith return QualType(AT, 0); 2989483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith } 2990483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith 2991483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith AutoType *AT = new (*this, TypeAlignment) AutoType(DeducedType); 2992483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith Types.push_back(AT); 2993483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith if (InsertPos) 2994483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith AutoTypes.InsertNode(AT, InsertPos); 2995483b9f3bc05c5409e2c6643f1c9d91e21c8ff9d2Richard Smith return QualType(AT, 0); 299634b41d939a1328f484511c6002ba2456db879a29Richard Smith} 299734b41d939a1328f484511c6002ba2456db879a29Richard Smith 2998b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman/// getAtomicType - Return the uniqued reference to the atomic type for 2999b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman/// the given value type. 3000b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli FriedmanQualType ASTContext::getAtomicType(QualType T) const { 3001b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // Unique pointers, to guarantee there is only one pointer of a particular 3002b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // structure. 3003b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman llvm::FoldingSetNodeID ID; 3004b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicType::Profile(ID, T); 3005b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 3006b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman void *InsertPos = 0; 3007b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos)) 3008b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return QualType(AT, 0); 3009b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 3010b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // If the atomic value type isn't canonical, this won't be a canonical type 3011b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // either, so fill in the canonical type field. 3012b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType Canonical; 3013b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (!T.isCanonical()) { 3014b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman Canonical = getAtomicType(getCanonicalType(T)); 3015b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 3016b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // Get the new insert position for the node we care about. 3017b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos); 3018b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 3019b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 3020b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicType *New = new (*this, TypeAlignment) AtomicType(T, Canonical); 3021b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman Types.push_back(New); 3022b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman AtomicTypes.InsertNode(New, InsertPos); 3023b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return QualType(New, 0); 3024b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman} 3025b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 3026ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// getAutoDeductType - Get type pattern for deducing against 'auto'. 3027ad762fcdc16b9e4705b12b09d92b8c026212b906Richard SmithQualType ASTContext::getAutoDeductType() const { 3028ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith if (AutoDeductTy.isNull()) 3029ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith AutoDeductTy = getAutoType(QualType()); 3030ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith assert(!AutoDeductTy.isNull() && "can't build 'auto' pattern"); 3031ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith return AutoDeductTy; 3032ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith} 3033ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith 3034ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// getAutoRRefDeductType - Get type pattern for deducing against 'auto &&'. 3035ad762fcdc16b9e4705b12b09d92b8c026212b906Richard SmithQualType ASTContext::getAutoRRefDeductType() const { 3036ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith if (AutoRRefDeductTy.isNull()) 3037ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith AutoRRefDeductTy = getRValueReferenceType(getAutoDeductType()); 3038ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith assert(!AutoRRefDeductTy.isNull() && "can't build 'auto &&' pattern"); 3039ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith return AutoRRefDeductTy; 3040ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith} 3041ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith 30425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getTagDeclType - Return the unique reference to the type for the 30435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// specified TagDecl (struct/union/class/enum) decl. 30444ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getTagDeclType(const TagDecl *Decl) const { 3045d778f88d32b96a74c9edb7342c81357606a7cdc0Ted Kremenek assert (Decl); 3046e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump // FIXME: What is the design on getTagDeclType when it requires casting 3047e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump // away const? mutable? 3048e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump return getTypeDeclType(const_cast<TagDecl*>(Decl)); 30495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 30505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 30511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getSizeType - Return the unique type for "size_t" (C99 7.17), the result 30521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and 30531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// needs to agree with the definition in <stddef.h>. 3054a3ccda58913cc1a4b8564e349448b12acc462da7Anders CarlssonCanQualType ASTContext::getSizeType() const { 3055bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor return getFromTargetType(Target->getSizeType()); 30565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 30575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 305829e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg/// getIntMaxType - Return the unique type for "intmax_t" (C99 7.18.1.5). 305929e97cb35fab314388f62b68fefa78947e93c1dcHans WennborgCanQualType ASTContext::getIntMaxType() const { 306029e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg return getFromTargetType(Target->getIntMaxType()); 306129e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg} 306229e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg 306329e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg/// getUIntMaxType - Return the unique type for "uintmax_t" (C99 7.18.1.5). 306429e97cb35fab314388f62b68fefa78947e93c1dcHans WennborgCanQualType ASTContext::getUIntMaxType() const { 306529e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg return getFromTargetType(Target->getUIntMaxType()); 306629e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg} 306729e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg 306864c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// getSignedWCharType - Return the type of "signed wchar_t". 306964c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// Used when in C++, as a GCC extension. 307064c438a4be2a871fa43c78264663ba1e9788b94dArgyrios KyrtzidisQualType ASTContext::getSignedWCharType() const { 307164c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis // FIXME: derive from "Target" ? 307264c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis return WCharTy; 307364c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis} 307464c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 307564c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// getUnsignedWCharType - Return the type of "unsigned wchar_t". 307664c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis/// Used when in C++, as a GCC extension. 307764c438a4be2a871fa43c78264663ba1e9788b94dArgyrios KyrtzidisQualType ASTContext::getUnsignedWCharType() const { 307864c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis // FIXME: derive from "Target" ? 307964c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis return UnsignedIntTy; 308064c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis} 308164c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 308229e97cb35fab314388f62b68fefa78947e93c1dcHans Wennborg/// getPointerDiffType - Return the unique type for "ptrdiff_t" (C99 7.17) 30838b9023ba35a86838789e2c9034a6128728c547aaChris Lattner/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9). 30848b9023ba35a86838789e2c9034a6128728c547aaChris LattnerQualType ASTContext::getPointerDiffType() const { 3085bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor return getFromTargetType(Target->getPtrDiffType(0)); 30868b9023ba35a86838789e2c9034a6128728c547aaChris Lattner} 30878b9023ba35a86838789e2c9034a6128728c547aaChris Lattner 3088e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner//===----------------------------------------------------------------------===// 3089e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner// Type Operators 3090e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner//===----------------------------------------------------------------------===// 3091e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner 30924ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCanQualType ASTContext::getCanonicalParamType(QualType T) const { 309354e14c4db764c0636160d26c5bbf491637c83a76John McCall // Push qualifiers into arrays, and then discard any remaining 309454e14c4db764c0636160d26c5bbf491637c83a76John McCall // qualifiers. 309554e14c4db764c0636160d26c5bbf491637c83a76John McCall T = getCanonicalType(T); 3096745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian T = getVariableArrayDecayedType(T); 309754e14c4db764c0636160d26c5bbf491637c83a76John McCall const Type *Ty = T.getTypePtr(); 309854e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType Result; 309954e14c4db764c0636160d26c5bbf491637c83a76John McCall if (isa<ArrayType>(Ty)) { 310054e14c4db764c0636160d26c5bbf491637c83a76John McCall Result = getArrayDecayedType(QualType(Ty,0)); 310154e14c4db764c0636160d26c5bbf491637c83a76John McCall } else if (isa<FunctionType>(Ty)) { 310254e14c4db764c0636160d26c5bbf491637c83a76John McCall Result = getPointerType(QualType(Ty, 0)); 310354e14c4db764c0636160d26c5bbf491637c83a76John McCall } else { 310454e14c4db764c0636160d26c5bbf491637c83a76John McCall Result = QualType(Ty, 0); 310554e14c4db764c0636160d26c5bbf491637c83a76John McCall } 310654e14c4db764c0636160d26c5bbf491637c83a76John McCall 310754e14c4db764c0636160d26c5bbf491637c83a76John McCall return CanQualType::CreateUnsafe(Result); 310854e14c4db764c0636160d26c5bbf491637c83a76John McCall} 310954e14c4db764c0636160d26c5bbf491637c83a76John McCall 311062c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCallQualType ASTContext::getUnqualifiedArrayType(QualType type, 311162c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall Qualifiers &quals) { 311262c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall SplitQualType splitType = type.getSplitUnqualifiedType(); 311362c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 311462c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // FIXME: getSplitUnqualifiedType() actually walks all the way to 311562c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // the unqualified desugared type and then drops it on the floor. 311662c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // We then have to strip that sugar back off with 311762c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // getUnqualifiedDesugaredType(), which is silly. 311862c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall const ArrayType *AT = 3119200fa53fd420aa8369586f569dbece04930ad6a3John McCall dyn_cast<ArrayType>(splitType.Ty->getUnqualifiedDesugaredType()); 312062c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 312162c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // If we don't have an array, just use the results in splitType. 31229dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (!AT) { 3123200fa53fd420aa8369586f569dbece04930ad6a3John McCall quals = splitType.Quals; 3124200fa53fd420aa8369586f569dbece04930ad6a3John McCall return QualType(splitType.Ty, 0); 312528e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth } 312628e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 312762c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // Otherwise, recurse on the array's element type. 312862c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall QualType elementType = AT->getElementType(); 312962c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall QualType unqualElementType = getUnqualifiedArrayType(elementType, quals); 313062c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 313162c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // If that didn't change the element type, AT has no qualifiers, so we 313262c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // can just use the results in splitType. 313362c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall if (elementType == unqualElementType) { 313462c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall assert(quals.empty()); // from the recursive call 3135200fa53fd420aa8369586f569dbece04930ad6a3John McCall quals = splitType.Quals; 3136200fa53fd420aa8369586f569dbece04930ad6a3John McCall return QualType(splitType.Ty, 0); 313762c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall } 313862c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall 313962c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // Otherwise, add in the qualifiers from the outermost type, then 314062c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall // build the type back up. 3141200fa53fd420aa8369586f569dbece04930ad6a3John McCall quals.addConsistentQualifiers(splitType.Quals); 314228e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31439dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) { 314462c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getConstantArrayType(unqualElementType, CAT->getSize(), 314528e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth CAT->getSizeModifier(), 0); 314628e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth } 314728e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31489dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) { 314962c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getIncompleteArrayType(unqualElementType, IAT->getSizeModifier(), 0); 315028e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth } 315128e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31529dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(AT)) { 315362c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getVariableArrayType(unqualElementType, 31543fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall VAT->getSizeExpr(), 31559dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor VAT->getSizeModifier(), 31569dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor VAT->getIndexTypeCVRQualifiers(), 31579dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor VAT->getBracketsRange()); 31589dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor } 31599dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor 31609dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor const DependentSizedArrayType *DSAT = cast<DependentSizedArrayType>(AT); 316162c28c831bbf207cc36e683e7c321fc33bf8928cJohn McCall return getDependentSizedArrayType(unqualElementType, DSAT->getSizeExpr(), 316228e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth DSAT->getSizeModifier(), 0, 316328e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth SourceRange()); 316428e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth} 316528e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 31665a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// UnwrapSimilarPointerTypes - If T1 and T2 are pointer types that 31675a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// may be similar (C++ 4.4), replaces T1 and T2 with the type that 31685a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// they point to and return true. If T1 and T2 aren't pointer types 31695a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// or pointer-to-member types, or if they are not similar at this 31705a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// level, returns false and leaves T1 and T2 unchanged. Top-level 31715a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// qualifiers on T1 and T2 are ignored. This function will typically 31725a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// be called in a loop that successively "unwraps" pointer and 31735a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor/// pointer-to-member types to compare them at each level. 31745a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregorbool ASTContext::UnwrapSimilarPointerTypes(QualType &T1, QualType &T2) { 31755a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor const PointerType *T1PtrType = T1->getAs<PointerType>(), 31765a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor *T2PtrType = T2->getAs<PointerType>(); 31775a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (T1PtrType && T2PtrType) { 31785a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T1 = T1PtrType->getPointeeType(); 31795a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T2 = T2PtrType->getPointeeType(); 31805a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return true; 31815a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 31825a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 31835a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor const MemberPointerType *T1MPType = T1->getAs<MemberPointerType>(), 31845a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor *T2MPType = T2->getAs<MemberPointerType>(); 31855a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (T1MPType && T2MPType && 31865a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0), 31875a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor QualType(T2MPType->getClass(), 0))) { 31885a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T1 = T1MPType->getPointeeType(); 31895a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T2 = T2MPType->getPointeeType(); 31905a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return true; 31915a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 31925a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 31934e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (getLangOpts().ObjC1) { 31945a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor const ObjCObjectPointerType *T1OPType = T1->getAs<ObjCObjectPointerType>(), 31955a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor *T2OPType = T2->getAs<ObjCObjectPointerType>(); 31965a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (T1OPType && T2OPType) { 31975a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T1 = T1OPType->getPointeeType(); 31985a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor T2 = T2OPType->getPointeeType(); 31995a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return true; 32005a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 32015a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 32025a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 32035a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor // FIXME: Block pointers, too? 32045a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 32055a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return false; 32065a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor} 32075a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 32084ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadDeclarationNameInfo 32094ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getNameForTemplate(TemplateName Name, 32104ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad SourceLocation NameLoc) const { 3211146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall switch (Name.getKind()) { 3212146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::QualifiedTemplate: 3213146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::Template: 32142577743c5650c646fb705df01403707e94f2df04Abramo Bagnara // DNInfo work in progress: CHECKME: what about DNLoc? 3215146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo(Name.getAsTemplateDecl()->getDeclName(), 3216146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall NameLoc); 32172577743c5650c646fb705df01403707e94f2df04Abramo Bagnara 3218146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::OverloadedTemplate: { 3219146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall OverloadedTemplateStorage *Storage = Name.getAsOverloadedTemplate(); 3220146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall // DNInfo work in progress: CHECKME: what about DNLoc? 3221146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo((*Storage->begin())->getDeclName(), NameLoc); 3222146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3223146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3224146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::DependentTemplate: { 3225146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall DependentTemplateName *DTN = Name.getAsDependentTemplateName(); 32262577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DeclarationName DName; 322780ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall if (DTN->isIdentifier()) { 32282577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DName = DeclarationNames.getIdentifier(DTN->getIdentifier()); 32292577743c5650c646fb705df01403707e94f2df04Abramo Bagnara return DeclarationNameInfo(DName, NameLoc); 323080ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall } else { 32312577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DName = DeclarationNames.getCXXOperatorName(DTN->getOperator()); 32322577743c5650c646fb705df01403707e94f2df04Abramo Bagnara // DNInfo work in progress: FIXME: source locations? 32332577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DeclarationNameLoc DNLoc; 32342577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DNLoc.CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding(); 32352577743c5650c646fb705df01403707e94f2df04Abramo Bagnara DNLoc.CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding(); 32362577743c5650c646fb705df01403707e94f2df04Abramo Bagnara return DeclarationNameInfo(DName, NameLoc, DNLoc); 323780ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall } 323880ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall } 323980ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall 3240146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParm: { 3241146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage *subst 3242146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParm(); 3243146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo(subst->getParameter()->getDeclName(), 3244146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall NameLoc); 3245146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3246146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3247146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParmPack: { 3248146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmPackStorage *subst 3249146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParmPack(); 3250146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DeclarationNameInfo(subst->getParameterPack()->getDeclName(), 3251146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall NameLoc); 3252146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3253146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3254146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3255146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm_unreachable("bad template name kind!"); 325680ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall} 325780ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall 32584ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) const { 3259146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall switch (Name.getKind()) { 3260146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::QualifiedTemplate: 3261146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::Template: { 3262146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateDecl *Template = Name.getAsTemplateDecl(); 32633e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor if (TemplateTemplateParmDecl *TTP 3264146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = dyn_cast<TemplateTemplateParmDecl>(Template)) 32653e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor Template = getCanonicalTemplateTemplateParmDecl(TTP); 32663e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 32673e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // The canonical template name is the canonical template declaration. 326897fbaa2a38804268a024f1a104b43fcf8b4411b0Argyrios Kyrtzidis return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl())); 32693e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor } 327025a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor 3271146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::OverloadedTemplate: 3272146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm_unreachable("cannot canonicalize overloaded template"); 3273146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3274146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::DependentTemplate: { 3275146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall DependentTemplateName *DTN = Name.getAsDependentTemplateName(); 3276146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall assert(DTN && "Non-dependent template names must refer to template decls."); 3277146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return DTN->CanonicalTemplateName; 3278146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3279146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3280146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParm: { 3281146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage *subst 3282146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParm(); 3283146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return getCanonicalTemplateName(subst->getReplacement()); 32841aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor } 32851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3286146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall case TemplateName::SubstTemplateTemplateParmPack: { 3287146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmPackStorage *subst 3288146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = Name.getAsSubstTemplateTemplateParmPack(); 3289146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateTemplateParmDecl *canonParameter 3290146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = getCanonicalTemplateTemplateParmDecl(subst->getParameterPack()); 3291146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateArgument canonArgPack 3292146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = getCanonicalTemplateArgument(subst->getArgumentPack()); 3293146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return getSubstTemplateTemplateParmPack(canonParameter, canonArgPack); 3294146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3295146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 3296146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 3297146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm_unreachable("bad template name!"); 329825a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor} 329925a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor 3300db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregorbool ASTContext::hasSameTemplateName(TemplateName X, TemplateName Y) { 3301db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor X = getCanonicalTemplateName(X); 3302db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Y = getCanonicalTemplateName(Y); 3303db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return X.getAsVoidPointer() == Y.getAsVoidPointer(); 3304db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor} 3305db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor 33061eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpTemplateArgument 33074ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const { 33081275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor switch (Arg.getKind()) { 33091275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Null: 33101275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor return Arg; 33111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33121275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Expression: 33131275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor return Arg; 33141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3315d2008e2c80d6c9282044ec873a937a17a0f33579Douglas Gregor case TemplateArgument::Declaration: { 3316d2008e2c80d6c9282044ec873a937a17a0f33579Douglas Gregor if (Decl *D = Arg.getAsDecl()) 3317d2008e2c80d6c9282044ec873a937a17a0f33579Douglas Gregor return TemplateArgument(D->getCanonicalDecl()); 3318d2008e2c80d6c9282044ec873a937a17a0f33579Douglas Gregor return TemplateArgument((Decl*)0); 3319d2008e2c80d6c9282044ec873a937a17a0f33579Douglas Gregor } 33201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3321788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TemplateArgument::Template: 3322788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate())); 3323a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 3324a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor case TemplateArgument::TemplateExpansion: 3325a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return TemplateArgument(getCanonicalTemplateName( 3326a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor Arg.getAsTemplateOrTemplatePattern()), 33272be29f423acad3bbe39099a78db2805acb5bdf17Douglas Gregor Arg.getNumTemplateExpansions()); 3328a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor 33291275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Integral: 3330855243789cb44799c03f4c7216d3d6308805f549Benjamin Kramer return TemplateArgument(Arg, getCanonicalType(Arg.getIntegralType())); 33311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33321275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Type: 3333833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall return TemplateArgument(getCanonicalType(Arg.getAsType())); 33341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 33351275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TemplateArgument::Pack: { 333687dd697dcc8ecb64df73ae64d61b8c80ff0c157cDouglas Gregor if (Arg.pack_size() == 0) 333787dd697dcc8ecb64df73ae64d61b8c80ff0c157cDouglas Gregor return Arg; 333887dd697dcc8ecb64df73ae64d61b8c80ff0c157cDouglas Gregor 3339910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgument *CanonArgs 3340910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor = new (*this) TemplateArgument[Arg.pack_size()]; 33411275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor unsigned Idx = 0; 33421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (TemplateArgument::pack_iterator A = Arg.pack_begin(), 33431275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor AEnd = Arg.pack_end(); 33441275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor A != AEnd; (void)++A, ++Idx) 33451275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor CanonArgs[Idx] = getCanonicalTemplateArgument(*A); 33461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3347910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor return TemplateArgument(CanonArgs, Arg.pack_size()); 33481275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor } 33491275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor } 33501275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor 33511275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // Silence GCC warning 3352b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unhandled template argument kind"); 33531275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor} 33541275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor 3355d57959af02b4af695276f4204443afe6e5d86bd8Douglas GregorNestedNameSpecifier * 33564ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const { 33571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (!NNS) 3358d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor return 0; 3359d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3360d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor switch (NNS->getKind()) { 3361d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::Identifier: 3362d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // Canonicalize the prefix but keep the identifier the same. 33631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return NestedNameSpecifier::Create(*this, 3364d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor getCanonicalNestedNameSpecifier(NNS->getPrefix()), 3365d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor NNS->getAsIdentifier()); 3366d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3367d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::Namespace: 3368d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // A namespace is canonical; build a nested-name-specifier with 3369d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // this namespace and no prefix. 337014aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor return NestedNameSpecifier::Create(*this, 0, 337114aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor NNS->getAsNamespace()->getOriginalNamespace()); 337214aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor 337314aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor case NestedNameSpecifier::NamespaceAlias: 337414aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor // A namespace is canonical; build a nested-name-specifier with 337514aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor // this namespace and no prefix. 337614aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor return NestedNameSpecifier::Create(*this, 0, 337714aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor NNS->getAsNamespaceAlias()->getNamespace() 337814aba76042e041b2c5e439bf4ae353a0a3c7fd73Douglas Gregor ->getOriginalNamespace()); 3379d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3380d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::TypeSpec: 3381d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::TypeSpecWithTemplate: { 3382d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor QualType T = getCanonicalType(QualType(NNS->getAsType(), 0)); 3383264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor 3384264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // If we have some kind of dependent-named type (e.g., "typename T::type"), 3385264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // break it apart into its prefix and identifier, then reconsititute those 3386264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // as the canonical nested-name-specifier. This is required to canonicalize 3387264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // a dependent nested-name-specifier involving typedefs of dependent-name 3388264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // types, e.g., 3389264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // typedef typename T::type T1; 3390264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // typedef typename T1::type T2; 339116412ef25a2203b7066d0db2b41f944631e5cf79Eli Friedman if (const DependentNameType *DNT = T->getAs<DependentNameType>()) 339216412ef25a2203b7066d0db2b41f944631e5cf79Eli Friedman return NestedNameSpecifier::Create(*this, DNT->getQualifier(), 3393264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor const_cast<IdentifierInfo *>(DNT->getIdentifier())); 3394264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor 339516412ef25a2203b7066d0db2b41f944631e5cf79Eli Friedman // Otherwise, just canonicalize the type, and force it to be a TypeSpec. 339616412ef25a2203b7066d0db2b41f944631e5cf79Eli Friedman // FIXME: Why are TypeSpec and TypeSpecWithTemplate distinct in the 339716412ef25a2203b7066d0db2b41f944631e5cf79Eli Friedman // first place? 33983b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return NestedNameSpecifier::Create(*this, 0, false, 33993b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall const_cast<Type*>(T.getTypePtr())); 3400d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor } 3401d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3402d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case NestedNameSpecifier::Global: 3403d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // The global specifier is canonical and unique. 3404d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor return NNS; 3405d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor } 3406d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 34077530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie llvm_unreachable("Invalid NestedNameSpecifier::Kind!"); 3408d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor} 3409d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 3410c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 34114ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadconst ArrayType *ASTContext::getAsArrayType(QualType T) const { 3412c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Handle the non-qualified case efficiently. 3413a4923eb7c4b04d360cb2747641a5e92818edf804Douglas Gregor if (!T.hasLocalQualifiers()) { 3414c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Handle the common positive case fast. 3415c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const ArrayType *AT = dyn_cast<ArrayType>(T)) 3416c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return AT; 3417c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner } 34181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 34190953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Handle the common negative case fast. 34203b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!isa<ArrayType>(T.getCanonicalType())) 3421c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return 0; 34221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 34230953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Apply any qualifiers from the array type to the element type. This 3424c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // implements C99 6.7.3p8: "If the specification of an array type includes 3425c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // any type qualifiers, the element type is so qualified, not the array type." 34261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3427c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // If we get here, we either have type qualifiers on the type, or we have 3428c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // sugar such as a typedef in the way. If we have type qualifiers on the type 342950d62d1b4a98adbc83de8f8cd1379ea1c25656f7Douglas Gregor // we must propagate them down into the element type. 34300953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 34313b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType split = T.getSplitDesugaredType(); 3432200fa53fd420aa8369586f569dbece04930ad6a3John McCall Qualifiers qs = split.Quals; 34331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3434c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // If we have a simple case, just return now. 3435200fa53fd420aa8369586f569dbece04930ad6a3John McCall const ArrayType *ATy = dyn_cast<ArrayType>(split.Ty); 34363b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (ATy == 0 || qs.empty()) 3437c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return ATy; 34381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3439c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Otherwise, we have an array and we have qualifiers on it. Push the 3440c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // qualifiers into the array element type and return a new array type. 34413b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall QualType NewEltTy = getQualifiedType(ATy->getElementType(), qs); 34421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3443c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(ATy)) 3444c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(), 3445c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner CAT->getSizeModifier(), 34460953e767ff7817f97b3ab20896b229891eeff45bJohn McCall CAT->getIndexTypeCVRQualifiers())); 3447c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(ATy)) 3448c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return cast<ArrayType>(getIncompleteArrayType(NewEltTy, 3449c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner IAT->getSizeModifier(), 34500953e767ff7817f97b3ab20896b229891eeff45bJohn McCall IAT->getIndexTypeCVRQualifiers())); 3451898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 34521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const DependentSizedArrayType *DSAT 3453898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor = dyn_cast<DependentSizedArrayType>(ATy)) 3454898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return cast<ArrayType>( 34551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getDependentSizedArrayType(NewEltTy, 34563fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall DSAT->getSizeExpr(), 3457898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor DSAT->getSizeModifier(), 34580953e767ff7817f97b3ab20896b229891eeff45bJohn McCall DSAT->getIndexTypeCVRQualifiers(), 34597e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor DSAT->getBracketsRange())); 34601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3461c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner const VariableArrayType *VAT = cast<VariableArrayType>(ATy); 34627e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor return cast<ArrayType>(getVariableArrayType(NewEltTy, 34633fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall VAT->getSizeExpr(), 3464c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner VAT->getSizeModifier(), 34650953e767ff7817f97b3ab20896b229891eeff45bJohn McCall VAT->getIndexTypeCVRQualifiers(), 34667e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor VAT->getBracketsRange())); 346777c9647cae939104c6cb2b6a4dd8ca859d2e5770Chris Lattner} 346877c9647cae939104c6cb2b6a4dd8ca859d2e5770Chris Lattner 3469ad9689f3531c49e4bff467d9469993606800068cAbramo BagnaraQualType ASTContext::getAdjustedParameterType(QualType T) const { 347079e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // C99 6.7.5.3p7: 347179e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // A declaration of a parameter as "array of type" shall be 347279e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // adjusted to "qualified pointer to type", where the type 347379e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // qualifiers (if any) are those specified within the [ and ] of 347479e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // the array type derivation. 347579e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor if (T->isArrayType()) 347679e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return getArrayDecayedType(T); 347779e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 347879e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // C99 6.7.5.3p8: 347979e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // A declaration of a parameter as "function returning type" 348079e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // shall be adjusted to "pointer to function returning type", as 348179e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor // in 6.3.2.1. 348279e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor if (T->isFunctionType()) 348379e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return getPointerType(T); 348479e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 348579e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return T; 348679e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor} 348779e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 3488ad9689f3531c49e4bff467d9469993606800068cAbramo BagnaraQualType ASTContext::getSignatureParameterType(QualType T) const { 348979e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor T = getVariableArrayDecayedType(T); 349079e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor T = getAdjustedParameterType(T); 349179e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor return T.getUnqualifiedType(); 349279e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor} 349379e6bd379773447a74cc3e579d9081e4c5cb6d63Douglas Gregor 3494e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// getArrayDecayedType - Return the properly qualified result of decaying the 3495e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// specified array type to a pointer. This operation is non-trivial when 3496e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// handling typedefs etc. The canonical type of "T" must be an array type, 3497e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// this returns a pointer to a properly qualified element of the array. 3498e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// 3499e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner/// See C99 6.7.5.3p7 and C99 6.3.2.1p3. 35004ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getArrayDecayedType(QualType Ty) const { 3501c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // Get the element type with 'getAsArrayType' so that we don't lose any 3502c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // typedefs in the element type of the array. This also handles propagation 3503c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // of type qualifiers from the array type into the element type if present 3504c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // (C99 6.7.3p8). 3505c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner const ArrayType *PrettyArrayType = getAsArrayType(Ty); 3506c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner assert(PrettyArrayType && "Not an array type!"); 35071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3508c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner QualType PtrTy = getPointerType(PrettyArrayType->getElementType()); 3509e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner 3510e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner // int x[restrict 4] -> int *restrict 35110953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return getQualifiedType(PtrTy, PrettyArrayType->getIndexTypeQualifiers()); 3512e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner} 3513e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner 35143b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getBaseElementType(const ArrayType *array) const { 35153b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return getBaseElementType(array->getElementType()); 35165e03f9ea8174ae588c5e69ec6b5ef4c68f8fd766Douglas Gregor} 35175e03f9ea8174ae588c5e69ec6b5ef4c68f8fd766Douglas Gregor 35183b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCallQualType ASTContext::getBaseElementType(QualType type) const { 35193b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall Qualifiers qs; 35203b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall while (true) { 35213b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall SplitQualType split = type.getSplitDesugaredType(); 3522200fa53fd420aa8369586f569dbece04930ad6a3John McCall const ArrayType *array = split.Ty->getAsArrayTypeUnsafe(); 35233b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall if (!array) break; 35241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 35253b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall type = array->getElementType(); 3526200fa53fd420aa8369586f569dbece04930ad6a3John McCall qs.addConsistentQualifiers(split.Quals); 35273b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall } 35281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 35293b6575108a5b6d8b92ac3a9a7794bf6c3a210907John McCall return getQualifiedType(type, qs); 35306183a99b064b397d98297904fbd6cf00fe1f453dAnders Carlsson} 35316183a99b064b397d98297904fbd6cf00fe1f453dAnders Carlsson 35320de78998e7bda473b408437053e48661b510d453Fariborz Jahanian/// getConstantArrayElementCount - Returns number of constant array elements. 35331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpuint64_t 35340de78998e7bda473b408437053e48661b510d453Fariborz JahanianASTContext::getConstantArrayElementCount(const ConstantArrayType *CA) const { 35350de78998e7bda473b408437053e48661b510d453Fariborz Jahanian uint64_t ElementCount = 1; 35360de78998e7bda473b408437053e48661b510d453Fariborz Jahanian do { 35370de78998e7bda473b408437053e48661b510d453Fariborz Jahanian ElementCount *= CA->getSize().getZExtValue(); 35380de78998e7bda473b408437053e48661b510d453Fariborz Jahanian CA = dyn_cast<ConstantArrayType>(CA->getElementType()); 35390de78998e7bda473b408437053e48661b510d453Fariborz Jahanian } while (CA); 35400de78998e7bda473b408437053e48661b510d453Fariborz Jahanian return ElementCount; 35410de78998e7bda473b408437053e48661b510d453Fariborz Jahanian} 35420de78998e7bda473b408437053e48661b510d453Fariborz Jahanian 35435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getFloatingRank - Return a relative rank for floating point types. 35445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// This routine will assert if passed a built-in type that isn't a float. 3545a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattnerstatic FloatingRank getFloatingRank(QualType T) { 3546183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ComplexType *CT = T->getAs<ComplexType>()) 35475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return getFloatingRank(CT->getElementType()); 3548a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner 3549183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall assert(T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type"); 3550183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall switch (T->getAs<BuiltinType>()->getKind()) { 3551b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("getFloatingRank(): not a floating type"); 3552aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov case BuiltinType::Half: return HalfRank; 35535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Float: return FloatRank; 35545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::Double: return DoubleRank; 35555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BuiltinType::LongDouble: return LongDoubleRank; 35565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 35575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 35585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 35591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getFloatingTypeOfSizeWithinDomain - Returns a real floating 35601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// point or a complex type (based on typeDomain/typeSize). 3561716c7304ff5d27a95e1e7823acd1d09d5ec3e37fSteve Naroff/// 'typeDomain' is a real floating point or complex type. 3562716c7304ff5d27a95e1e7823acd1d09d5ec3e37fSteve Naroff/// 'typeSize' is a real floating point or complex type. 35631361b11066239ea15764a2a844405352d87296b3Chris LattnerQualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size, 35641361b11066239ea15764a2a844405352d87296b3Chris Lattner QualType Domain) const { 35651361b11066239ea15764a2a844405352d87296b3Chris Lattner FloatingRank EltRank = getFloatingRank(Size); 35661361b11066239ea15764a2a844405352d87296b3Chris Lattner if (Domain->isComplexType()) { 35671361b11066239ea15764a2a844405352d87296b3Chris Lattner switch (EltRank) { 3568561d3abc881033776ece385a01a510e1cbc1fa92David Blaikie case HalfRank: llvm_unreachable("Complex half is not supported"); 3569f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff case FloatRank: return FloatComplexTy; 3570f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff case DoubleRank: return DoubleComplexTy; 3571f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff case LongDoubleRank: return LongDoubleComplexTy; 3572f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff } 3573f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff } 35741361b11066239ea15764a2a844405352d87296b3Chris Lattner 35751361b11066239ea15764a2a844405352d87296b3Chris Lattner assert(Domain->isRealFloatingType() && "Unknown domain!"); 35761361b11066239ea15764a2a844405352d87296b3Chris Lattner switch (EltRank) { 3577561d3abc881033776ece385a01a510e1cbc1fa92David Blaikie case HalfRank: llvm_unreachable("Half ranks are not valid here"); 35781361b11066239ea15764a2a844405352d87296b3Chris Lattner case FloatRank: return FloatTy; 35791361b11066239ea15764a2a844405352d87296b3Chris Lattner case DoubleRank: return DoubleTy; 35801361b11066239ea15764a2a844405352d87296b3Chris Lattner case LongDoubleRank: return LongDoubleTy; 35815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3582561d3abc881033776ece385a01a510e1cbc1fa92David Blaikie llvm_unreachable("getFloatingRank(): illegal value for rank"); 35835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 35845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 35857cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// getFloatingTypeOrder - Compare the rank of the two specified floating 35867cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// point types, ignoring the domain of the type (i.e. 'double' == 35877cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If 35881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// LHS < RHS, return -1. 35894ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadint ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) const { 3590a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner FloatingRank LHSR = getFloatingRank(LHS); 3591a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner FloatingRank RHSR = getFloatingRank(RHS); 35921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3593a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner if (LHSR == RHSR) 3594fb0d49669aa370b4c0993c5cee60275ef9fd6518Steve Naroff return 0; 3595a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner if (LHSR > RHSR) 3596fb0d49669aa370b4c0993c5cee60275ef9fd6518Steve Naroff return 1; 3597fb0d49669aa370b4c0993c5cee60275ef9fd6518Steve Naroff return -1; 35985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 35995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3600f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This 3601f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner/// routine will assert if passed a built-in type that isn't an integer or enum, 3602f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner/// or if it is not canonicalized. 3603f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCallunsigned ASTContext::getIntegerRank(const Type *T) const { 3604467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(T->isCanonicalUnqualified() && "T should be canonicalized"); 3605f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith 3606f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner switch (cast<BuiltinType>(T)->getKind()) { 3607b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("getIntegerRank(): not a built-in integer"); 36087cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Bool: 3609f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 1 + (getIntWidth(BoolTy) << 3); 36107cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Char_S: 36117cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Char_U: 36127cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::SChar: 36137cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::UChar: 3614f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 2 + (getIntWidth(CharTy) << 3); 36157cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Short: 36167cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::UShort: 3617f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 3 + (getIntWidth(ShortTy) << 3); 36187cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Int: 36197cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::UInt: 3620f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 4 + (getIntWidth(IntTy) << 3); 36217cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::Long: 36227cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::ULong: 3623f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 5 + (getIntWidth(LongTy) << 3); 36247cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::LongLong: 36257cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case BuiltinType::ULongLong: 3626f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return 6 + (getIntWidth(LongLongTy) << 3); 36272df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::Int128: 36282df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::UInt128: 36292df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner return 7 + (getIntWidth(Int128Ty) << 3); 3630f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner } 3631f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner} 3632f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner 363304e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// \brief Whether this is a promotable bitfield reference according 363404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// to C99 6.3.1.1p2, bullet 2 (and GCC extensions). 363504e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// 363604e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// \returns the type this bit-field will promote to, or NULL if no 363704e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman/// promotion occurs. 36384ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::isPromotableBitField(Expr *E) const { 3639ceafbdeb93ecf323cca74e660bf54504c86f3b71Douglas Gregor if (E->isTypeDependent() || E->isValueDependent()) 3640ceafbdeb93ecf323cca74e660bf54504c86f3b71Douglas Gregor return QualType(); 3641ceafbdeb93ecf323cca74e660bf54504c86f3b71Douglas Gregor 364204e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman FieldDecl *Field = E->getBitField(); 364304e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman if (!Field) 364404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return QualType(); 364504e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 364604e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman QualType FT = Field->getType(); 364704e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 3648a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith uint64_t BitWidth = Field->getBitWidthValue(*this); 364904e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman uint64_t IntSize = getTypeSize(IntTy); 365004e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // GCC extension compatibility: if the bit-field size is less than or equal 365104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // to the size of int, it gets promoted no matter what its type is. 365204e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // For instance, unsigned long bf : 4 gets promoted to signed int. 365304e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman if (BitWidth < IntSize) 365404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return IntTy; 365504e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 365604e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman if (BitWidth == IntSize) 365704e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return FT->isSignedIntegerType() ? IntTy : UnsignedIntTy; 365804e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 365904e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // Types bigger than int are not subject to promotions, and therefore act 366004e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // like the base type. 366104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // FIXME: This doesn't quite match what gcc does, but what gcc does here 366204e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman // is ridiculous. 366304e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return QualType(); 366404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman} 366504e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 3666a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman/// getPromotedIntegerType - Returns the type that Promotable will 3667a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman/// promote to: C99 6.3.1.1p2, assuming that Promotable is a promotable 3668a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman/// integer type. 36694ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getPromotedIntegerType(QualType Promotable) const { 3670a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman assert(!Promotable.isNull()); 3671a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman assert(Promotable->isPromotableIntegerType()); 3672842aef8d942a880eeb9535d40de31a86838264cbJohn McCall if (const EnumType *ET = Promotable->getAs<EnumType>()) 3673842aef8d942a880eeb9535d40de31a86838264cbJohn McCall return ET->getDecl()->getPromotionType(); 367468a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman 367568a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman if (const BuiltinType *BT = Promotable->getAs<BuiltinType>()) { 367668a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // C++ [conv.prom]: A prvalue of type char16_t, char32_t, or wchar_t 367768a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // (3.9.1) can be converted to a prvalue of the first of the following 367868a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // types that can represent all the values of its underlying type: 367968a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // int, unsigned int, long int, unsigned long int, long long int, or 368068a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // unsigned long long int [...] 368168a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // FIXME: Is there some better way to compute this? 368268a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman if (BT->getKind() == BuiltinType::WChar_S || 368368a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman BT->getKind() == BuiltinType::WChar_U || 368468a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman BT->getKind() == BuiltinType::Char16 || 368568a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman BT->getKind() == BuiltinType::Char32) { 368668a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman bool FromIsSigned = BT->getKind() == BuiltinType::WChar_S; 368768a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman uint64_t FromSize = getTypeSize(BT); 368868a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman QualType PromoteTypes[] = { IntTy, UnsignedIntTy, LongTy, UnsignedLongTy, 368968a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman LongLongTy, UnsignedLongLongTy }; 369068a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman for (size_t Idx = 0; Idx < llvm::array_lengthof(PromoteTypes); ++Idx) { 369168a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman uint64_t ToSize = getTypeSize(PromoteTypes[Idx]); 369268a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman if (FromSize < ToSize || 369368a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman (FromSize == ToSize && 369468a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) 369568a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman return PromoteTypes[Idx]; 369668a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman } 369768a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman llvm_unreachable("char type should fit into long long"); 369868a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman } 369968a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman } 370068a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman 370168a2dc446fe6d32d5da3557902100ed06b21b12bEli Friedman // At this point, we should have a signed or unsigned integer type. 3702a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman if (Promotable->isSignedIntegerType()) 3703a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman return IntTy; 3704a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman uint64_t PromotableSize = getTypeSize(Promotable); 3705a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman uint64_t IntSize = getTypeSize(IntTy); 3706a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman assert(Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize); 3707a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman return (PromotableSize != IntSize) ? IntTy : UnsignedIntTy; 3708a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman} 3709a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman 371031862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis/// \brief Recurses in pointer/array types until it finds an objc retainable 371131862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis/// type and returns its ownership. 371231862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios KyrtzidisQualifiers::ObjCLifetime ASTContext::getInnerObjCOwnership(QualType T) const { 371331862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis while (!T.isNull()) { 371431862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis if (T.getObjCLifetime() != Qualifiers::OCL_None) 371531862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis return T.getObjCLifetime(); 371631862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis if (T->isArrayType()) 371731862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis T = getBaseElementType(T); 371831862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis else if (const PointerType *PT = T->getAs<PointerType>()) 371931862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis T = PT->getPointeeType(); 372031862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis else if (const ReferenceType *RT = T->getAs<ReferenceType>()) 372128445f0b62f6aed851ff87ce64d9b19200d3211fArgyrios Kyrtzidis T = RT->getPointeeType(); 372231862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis else 372331862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis break; 372431862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis } 372531862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis 372631862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis return Qualifiers::OCL_None; 372731862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis} 372831862ba5ea70b1f2c81d03f8a0100b61cd6f06f6Argyrios Kyrtzidis 37291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// getIntegerTypeOrder - Returns the highest ranked integer type: 37307cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If 37311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// LHS < RHS, return -1. 37324ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadint ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) const { 3733f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall const Type *LHSC = getCanonicalType(LHS).getTypePtr(); 3734f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall const Type *RHSC = getCanonicalType(RHS).getTypePtr(); 37357cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSC == RHSC) return 0; 37361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3737f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner bool LHSUnsigned = LHSC->isUnsignedIntegerType(); 3738f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner bool RHSUnsigned = RHSC->isUnsignedIntegerType(); 37391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37407cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner unsigned LHSRank = getIntegerRank(LHSC); 37417cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner unsigned RHSRank = getIntegerRank(RHSC); 37421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37437cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned. 37447cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSRank == RHSRank) return 0; 37457cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return LHSRank > RHSRank ? 1 : -1; 37467cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner } 37471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37487cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // Otherwise, the LHS is signed and the RHS is unsigned or visa versa. 37497cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSUnsigned) { 37507cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the unsigned [LHS] type is larger, return it. 37517cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (LHSRank >= RHSRank) 37527cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return 1; 37531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37547cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the signed type can represent all values of the unsigned type, it 37557cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // wins. Because we are dealing with 2's complement and types that are 37561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // powers of two larger than each other, this is always safe. 37577cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return -1; 37587cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner } 37597cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner 37607cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the unsigned [RHS] type is larger, return it. 37617cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (RHSRank >= LHSRank) 37627cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return -1; 37631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 37647cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // If the signed type can represent all values of the unsigned type, it 37657cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner // wins. Because we are dealing with 2's complement and types that are 37661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // powers of two larger than each other, this is always safe. 37677cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return 1; 37685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 376971993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson 377079cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlssonstatic RecordDecl * 3771ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo BagnaraCreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK, 3772ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara DeclContext *DC, IdentifierInfo *Id) { 3773ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara SourceLocation Loc; 37744e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (Ctx.getLangOpts().CPlusPlus) 3775ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 377679cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson else 3777ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 377879cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson} 3779ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara 37801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump// getCFConstantStringType - Return the type used for constant CFStrings. 37814ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getCFConstantStringType() const { 378271993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson if (!CFConstantStringTypeDecl) { 37831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump CFConstantStringTypeDecl = 3784ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara CreateRecordDecl(*this, TTK_Struct, TUDecl, 378579cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson &Idents.get("NSConstantString")); 37865cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall CFConstantStringTypeDecl->startDefinition(); 378779cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson 3788f06273f8bbacb086a46bde456429c8d08f6d07eeAnders Carlsson QualType FieldTypes[4]; 37891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 379071993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson // const int *isa; 37910953e767ff7817f97b3ab20896b229891eeff45bJohn McCall FieldTypes[0] = getPointerType(IntTy.withConst()); 3792f06273f8bbacb086a46bde456429c8d08f6d07eeAnders Carlsson // int flags; 3793f06273f8bbacb086a46bde456429c8d08f6d07eeAnders Carlsson FieldTypes[1] = IntTy; 379471993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson // const char *str; 37950953e767ff7817f97b3ab20896b229891eeff45bJohn McCall FieldTypes[2] = getPointerType(CharTy.withConst()); 379671993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson // long length; 37971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump FieldTypes[3] = LongTy; 37981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 379944b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor // Create fields 380044b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor for (unsigned i = 0; i < 4; ++i) { 38011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump FieldDecl *Field = FieldDecl::Create(*this, CFConstantStringTypeDecl, 3802ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara SourceLocation(), 380344b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor SourceLocation(), 0, 3804a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 38051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump /*BitWidth=*/0, 38067a614d8380297fcd2bc23986241905d97222948cRichard Smith /*Mutable=*/false, 3807ca5233044ef679840d1ad1c46a36b16e2ee8a6e1Richard Smith ICIS_NoInit); 38082888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 380917945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis CFConstantStringTypeDecl->addDecl(Field); 381044b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor } 381144b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor 3812838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor CFConstantStringTypeDecl->completeDefinition(); 381371993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson } 38141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 381571993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson return getTagDeclType(CFConstantStringTypeDecl); 38168467583c2704e7a9691ea56939a029015f0ade0aGabor Greif} 3817b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson 3818319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregorvoid ASTContext::setCFConstantStringType(QualType T) { 38196217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek const RecordType *Rec = T->getAs<RecordType>(); 3820319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor assert(Rec && "Invalid CFConstantStringType"); 3821319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor CFConstantStringTypeDecl = Rec->getDecl(); 3822319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor} 3823319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor 38244ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getBlockDescriptorType() const { 3825adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump if (BlockDescriptorType) 3826adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump return getTagDeclType(BlockDescriptorType); 3827adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3828adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump RecordDecl *T; 3829adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump // FIXME: Needs the FlagAppleBlock bit. 3830ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara T = CreateRecordDecl(*this, TTK_Struct, TUDecl, 383179cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson &Idents.get("__block_descriptor")); 38325cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall T->startDefinition(); 3833adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3834adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump QualType FieldTypes[] = { 3835adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump UnsignedLongTy, 3836adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump UnsignedLongTy, 3837adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump }; 3838adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3839adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump const char *FieldNames[] = { 3840adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump "reserved", 3841083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "Size" 3842adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump }; 3843adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3844adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump for (size_t i = 0; i < 2; ++i) { 3845ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 3846adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump SourceLocation(), 3847adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump &Idents.get(FieldNames[i]), 3848a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 3849adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump /*BitWidth=*/0, 38507a614d8380297fcd2bc23986241905d97222948cRichard Smith /*Mutable=*/false, 3851ca5233044ef679840d1ad1c46a36b16e2ee8a6e1Richard Smith ICIS_NoInit); 38522888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 3853adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump T->addDecl(Field); 3854adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump } 3855adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3856838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor T->completeDefinition(); 3857adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3858adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump BlockDescriptorType = T; 3859adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3860adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump return getTagDeclType(BlockDescriptorType); 3861adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump} 3862adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 38634ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType ASTContext::getBlockDescriptorExtendedType() const { 3864083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump if (BlockDescriptorExtendedType) 3865083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump return getTagDeclType(BlockDescriptorExtendedType); 3866083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3867083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump RecordDecl *T; 3868083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump // FIXME: Needs the FlagAppleBlock bit. 3869ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara T = CreateRecordDecl(*this, TTK_Struct, TUDecl, 387079cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson &Idents.get("__block_descriptor_withcopydispose")); 38715cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall T->startDefinition(); 3872083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3873083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump QualType FieldTypes[] = { 3874083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump UnsignedLongTy, 3875083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump UnsignedLongTy, 3876083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump getPointerType(VoidPtrTy), 3877083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump getPointerType(VoidPtrTy) 3878083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump }; 3879083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3880083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump const char *FieldNames[] = { 3881083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "reserved", 3882083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "Size", 3883083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "CopyFuncPtr", 3884083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump "DestroyFuncPtr" 3885083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump }; 3886083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3887083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump for (size_t i = 0; i < 4; ++i) { 3888ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 3889083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump SourceLocation(), 3890083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump &Idents.get(FieldNames[i]), 3891a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 3892083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump /*BitWidth=*/0, 38937a614d8380297fcd2bc23986241905d97222948cRichard Smith /*Mutable=*/false, 3894ca5233044ef679840d1ad1c46a36b16e2ee8a6e1Richard Smith ICIS_NoInit); 38952888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 3896083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump T->addDecl(Field); 3897083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump } 3898083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3899838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor T->completeDefinition(); 3900083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3901083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump BlockDescriptorExtendedType = T; 3902083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3903083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump return getTagDeclType(BlockDescriptorExtendedType); 3904083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump} 3905083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 39064ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadbool ASTContext::BlockRequiresCopying(QualType Ty) const { 3907f85e193739c953358c865005855253af4f68a497John McCall if (Ty->isObjCRetainableType()) 3908af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump return true; 39094e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (getLangOpts().CPlusPlus) { 3910e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian if (const RecordType *RT = Ty->getAs<RecordType>()) { 3911e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 3912ffe37fdda5b4b4f162a45155c30d9f60ce110c12Sean Hunt return RD->hasConstCopyConstructor(); 3913e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian 3914e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian } 3915e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian } 3916af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump return false; 3917af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump} 3918af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 39194ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadQualType 39205f9e272e632e951b1efe824cd16acb4d96077930Chris LattnerASTContext::BuildByRefType(StringRef DeclName, QualType Ty) const { 3921af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // type = struct __Block_byref_1_X { 3922ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // void *__isa; 3923af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // struct __Block_byref_1_X *__forwarding; 3924ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // unsigned int __flags; 3925ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // unsigned int __size; 3926a7e6845660f91ec611427e1db842780e1ec12bdbEli Friedman // void *__copy_helper; // as needed 3927a7e6845660f91ec611427e1db842780e1ec12bdbEli Friedman // void *__destroy_help // as needed 3928af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // int X; 3929ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // } * 3930ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump 3931af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump bool HasCopyAndDispose = BlockRequiresCopying(Ty); 3932af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3933af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // FIXME: Move up 3934f7ccbad5d9949e7ddd1cbef43d482553b811e026Dylan Noblesmith SmallString<36> Name; 3935f5942a44880be26878592eb052b737579349411eBenjamin Kramer llvm::raw_svector_ostream(Name) << "__Block_byref_" << 3936f5942a44880be26878592eb052b737579349411eBenjamin Kramer ++UniqueBlockByRefTypeID << '_' << DeclName; 3937af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump RecordDecl *T; 3938ba877adeb49ed6dc17f27fa3a3bcd0cca713fd68Abramo Bagnara T = CreateRecordDecl(*this, TTK_Struct, TUDecl, &Idents.get(Name.str())); 3939af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump T->startDefinition(); 3940af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump QualType Int32Ty = IntTy; 3941af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump assert(getIntWidth(IntTy) == 32 && "non-32bit int not supported"); 3942af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump QualType FieldTypes[] = { 3943af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(VoidPtrTy), 3944af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(getTagDeclType(T)), 3945af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump Int32Ty, 3946af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump Int32Ty, 3947af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(VoidPtrTy), 3948af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump getPointerType(VoidPtrTy), 3949af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump Ty 3950af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump }; 3951af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 39525f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner StringRef FieldNames[] = { 3953af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__isa", 3954af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__forwarding", 3955af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__flags", 3956af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__size", 3957af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__copy_helper", 3958af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump "__destroy_helper", 3959af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump DeclName, 3960af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump }; 3961af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3962af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump for (size_t i = 0; i < 7; ++i) { 3963af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump if (!HasCopyAndDispose && i >=4 && i <= 5) 3964af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump continue; 3965af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 3966ff676cb48fe8bf7be2feaa251dc7c5fb15af4730Abramo Bagnara SourceLocation(), 3967af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump &Idents.get(FieldNames[i]), 3968a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall FieldTypes[i], /*TInfo=*/0, 39697a614d8380297fcd2bc23986241905d97222948cRichard Smith /*BitWidth=*/0, /*Mutable=*/false, 3970ca5233044ef679840d1ad1c46a36b16e2ee8a6e1Richard Smith ICIS_NoInit); 39712888b65aae768f54062505330df7be230a0510c7John McCall Field->setAccess(AS_public); 3972af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump T->addDecl(Field); 3973af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump } 3974af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3975838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor T->completeDefinition(); 3976af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3977af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump return getPointerType(getTagDeclType(T)); 3978ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump} 3979ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump 3980e97179c675b341927807c718be215c8d1aab8acbDouglas GregorTypedefDecl *ASTContext::getObjCInstanceTypeDecl() { 3981e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor if (!ObjCInstanceTypeDecl) 3982e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor ObjCInstanceTypeDecl = TypedefDecl::Create(*this, 3983e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor getTranslationUnitDecl(), 3984e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor SourceLocation(), 3985e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor SourceLocation(), 3986e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor &Idents.get("instancetype"), 3987e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor getTrivialTypeSourceInfo(getObjCIdType())); 3988e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor return ObjCInstanceTypeDecl; 3989e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor} 3990e97179c675b341927807c718be215c8d1aab8acbDouglas Gregor 3991e8c49533521c40643653f943d47229e62d277f88Anders Carlsson// This returns true if a type has been typedefed to BOOL: 3992e8c49533521c40643653f943d47229e62d277f88Anders Carlsson// typedef <type> BOOL; 39932d99833e8c956775f2183601cd120b65b569c867Chris Lattnerstatic bool isTypeTypedefedAsBOOL(QualType T) { 3994e8c49533521c40643653f943d47229e62d277f88Anders Carlsson if (const TypedefType *TT = dyn_cast<TypedefType>(T)) 3995bb49c3ee5d270485f4b273691fd14bc97403fa5dChris Lattner if (IdentifierInfo *II = TT->getDecl()->getIdentifier()) 3996bb49c3ee5d270485f4b273691fd14bc97403fa5dChris Lattner return II->isStr("BOOL"); 39971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 399885f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson return false; 399985f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson} 400085f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson 4001a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek/// getObjCEncodingTypeSize returns size of type for objective-c encoding 400233e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian/// purpose. 40034ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCharUnits ASTContext::getObjCEncodingTypeSize(QualType type) const { 4004f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor if (!type->isIncompleteArrayType() && type->isIncompleteType()) 4005f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return CharUnits::Zero(); 4006f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4007199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits sz = getTypeSizeInChars(type); 40081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 400933e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Make all integer and enum types at least as large as an int 40102ade35e2cfd554e49d35a52047cea98a82787af9Douglas Gregor if (sz.isPositive() && type->isIntegralOrEnumerationType()) 4011199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck sz = std::max(sz, getTypeSizeInChars(IntTy)); 401233e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Treat arrays as pointers, since that's how they're passed in. 401333e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian else if (type->isArrayType()) 4014199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck sz = getTypeSizeInChars(VoidPtrTy); 4015aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck return sz; 4016199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck} 4017199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck 4018199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyckstatic inline 4019199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyckstd::string charUnitsToString(const CharUnits &CU) { 4020199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck return llvm::itostr(CU.getQuantity()); 402133e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian} 402233e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian 40236b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall/// getObjCEncodingForBlock - Return the encoded type for this block 40245e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall/// declaration. 40256b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCallstd::string ASTContext::getObjCEncodingForBlock(const BlockExpr *Expr) const { 40266b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall std::string S; 40276b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall 40285e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall const BlockDecl *Decl = Expr->getBlockDecl(); 40295e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall QualType BlockTy = 40305e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall Expr->getType()->getAs<BlockPointerType>()->getPointeeType(); 40315e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Encode result type. 4032c71a4915ca216847599d03cab4ed1c5086b0eb43John McCall getObjCEncodingForType(BlockTy->getAs<FunctionType>()->getResultType(), S); 40335e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Compute size of all parameters. 40345e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Start with computing size of a pointer in number of bytes. 40355e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // FIXME: There might(should) be a better way of doing this computation! 40365e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall SourceLocation Loc; 4037199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy); 4038199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits ParmOffset = PtrSize; 40396f46c2653c1545cc3fef0c0df996d18160160ce8Fariborz Jahanian for (BlockDecl::param_const_iterator PI = Decl->param_begin(), 40405e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall E = Decl->param_end(); PI != E; ++PI) { 40415e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall QualType PType = (*PI)->getType(); 4042aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck CharUnits sz = getObjCEncodingTypeSize(PType); 4043199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck assert (sz.isPositive() && "BlockExpr - Incomplete param type"); 40445e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall ParmOffset += sz; 40455e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall } 40465e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Size of the argument frame 4047199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 40485e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Block pointer and offset. 40495e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall S += "@?0"; 40505e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall 40515e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Argument types. 40525e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall ParmOffset = PtrSize; 40535e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall for (BlockDecl::param_const_iterator PI = Decl->param_begin(), E = 40545e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall Decl->param_end(); PI != E; ++PI) { 40555e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall ParmVarDecl *PVDecl = *PI; 40565e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall QualType PType = PVDecl->getOriginalType(); 40575e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall if (const ArrayType *AT = 40585e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 40595e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Use array's original type only if it has known number of 40605389f48b24937ad7b4093307128b3cbf25235654David Chisnall // elements. 40615389f48b24937ad7b4093307128b3cbf25235654David Chisnall if (!isa<ConstantArrayType>(AT)) 40625389f48b24937ad7b4093307128b3cbf25235654David Chisnall PType = PVDecl->getType(); 40635389f48b24937ad7b4093307128b3cbf25235654David Chisnall } else if (PType->isFunctionType()) 40645389f48b24937ad7b4093307128b3cbf25235654David Chisnall PType = PVDecl->getType(); 40655389f48b24937ad7b4093307128b3cbf25235654David Chisnall getObjCEncodingForType(PType, S); 40665389f48b24937ad7b4093307128b3cbf25235654David Chisnall S += charUnitsToString(ParmOffset); 40675389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmOffset += getObjCEncodingTypeSize(PType); 40685389f48b24937ad7b4093307128b3cbf25235654David Chisnall } 40696b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall 40706b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall return S; 40715389f48b24937ad7b4093307128b3cbf25235654David Chisnall} 40725389f48b24937ad7b4093307128b3cbf25235654David Chisnall 4073f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregorbool ASTContext::getObjCEncodingForFunctionDecl(const FunctionDecl *Decl, 40745389f48b24937ad7b4093307128b3cbf25235654David Chisnall std::string& S) { 40755389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Encode result type. 40765389f48b24937ad7b4093307128b3cbf25235654David Chisnall getObjCEncodingForType(Decl->getResultType(), S); 40775389f48b24937ad7b4093307128b3cbf25235654David Chisnall CharUnits ParmOffset; 40785389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Compute size of all parameters. 40795389f48b24937ad7b4093307128b3cbf25235654David Chisnall for (FunctionDecl::param_const_iterator PI = Decl->param_begin(), 40805389f48b24937ad7b4093307128b3cbf25235654David Chisnall E = Decl->param_end(); PI != E; ++PI) { 40815389f48b24937ad7b4093307128b3cbf25235654David Chisnall QualType PType = (*PI)->getType(); 40825389f48b24937ad7b4093307128b3cbf25235654David Chisnall CharUnits sz = getObjCEncodingTypeSize(PType); 4083f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor if (sz.isZero()) 4084f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return true; 4085f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 40865389f48b24937ad7b4093307128b3cbf25235654David Chisnall assert (sz.isPositive() && 4087f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor "getObjCEncodingForFunctionDecl - Incomplete param type"); 40885389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmOffset += sz; 40895389f48b24937ad7b4093307128b3cbf25235654David Chisnall } 40905389f48b24937ad7b4093307128b3cbf25235654David Chisnall S += charUnitsToString(ParmOffset); 40915389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmOffset = CharUnits::Zero(); 40925389f48b24937ad7b4093307128b3cbf25235654David Chisnall 40935389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Argument types. 40945389f48b24937ad7b4093307128b3cbf25235654David Chisnall for (FunctionDecl::param_const_iterator PI = Decl->param_begin(), 40955389f48b24937ad7b4093307128b3cbf25235654David Chisnall E = Decl->param_end(); PI != E; ++PI) { 40965389f48b24937ad7b4093307128b3cbf25235654David Chisnall ParmVarDecl *PVDecl = *PI; 40975389f48b24937ad7b4093307128b3cbf25235654David Chisnall QualType PType = PVDecl->getOriginalType(); 40985389f48b24937ad7b4093307128b3cbf25235654David Chisnall if (const ArrayType *AT = 40995389f48b24937ad7b4093307128b3cbf25235654David Chisnall dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 41005389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Use array's original type only if it has known number of 41015e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // elements. 41025e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall if (!isa<ConstantArrayType>(AT)) 41035e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall PType = PVDecl->getType(); 41045e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall } else if (PType->isFunctionType()) 41055e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall PType = PVDecl->getType(); 41065e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall getObjCEncodingForType(PType, S); 4107199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 4108aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck ParmOffset += getObjCEncodingTypeSize(PType); 41095e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall } 4110f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4111f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return false; 41125e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall} 41135e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall 4114dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson/// getObjCEncodingForMethodParameter - Return the encoded type for a single 4115dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson/// method parameter or return type. If Extended, include class names and 4116dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson/// block object types. 4117dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilsonvoid ASTContext::getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT, 4118dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson QualType T, std::string& S, 4119dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool Extended) const { 4120dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Encode type qualifer, 'in', 'inout', etc. for the parameter. 4121dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeQualifier(QT, S); 4122dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Encode parameter type. 4123dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeImpl(T, S, true, true, 0, 4124dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson true /*OutermostType*/, 4125dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /*EncodingProperty*/, 4126dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /*StructField*/, 4127dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson Extended /*EncodeBlockParameters*/, 4128dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson Extended /*EncodeClassNames*/); 4129dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson} 4130dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson 4131a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek/// getObjCEncodingForMethodDecl - Return the encoded type for this method 413233e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian/// declaration. 4133f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregorbool ASTContext::getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl, 4134dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson std::string& S, 4135dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool Extended) const { 4136c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: This is not very efficient. 4137dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Encode return type. 4138dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForMethodParameter(Decl->getObjCDeclQualifier(), 4139dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson Decl->getResultType(), S, Extended); 414033e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Compute size of all parameters. 414133e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Start with computing size of a pointer in number of bytes. 414233e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // FIXME: There might(should) be a better way of doing this computation! 414333e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian SourceLocation Loc; 4144199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy); 414533e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // The first two arguments (self and _cmd) are pointers; account for 414633e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // their size. 4147199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits ParmOffset = 2 * PtrSize; 4148491306a83c4f0f49f95a3bcbca8580cb98a91c7aArgyrios Kyrtzidis for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(), 41497732cc9c0fdc97a2f8cce4e5933d8103213d1aefFariborz Jahanian E = Decl->sel_param_end(); PI != E; ++PI) { 415089951a86b594513c2a013532ed45d197413b1087Chris Lattner QualType PType = (*PI)->getType(); 4151aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck CharUnits sz = getObjCEncodingTypeSize(PType); 4152f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor if (sz.isZero()) 4153f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return true; 4154f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4155199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck assert (sz.isPositive() && 4156199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck "getObjCEncodingForMethodDecl - Incomplete param type"); 415733e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian ParmOffset += sz; 415833e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian } 4159199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 416033e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian S += "@0:"; 4161199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(PtrSize); 41621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 416333e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // Argument types. 416433e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian ParmOffset = 2 * PtrSize; 4165491306a83c4f0f49f95a3bcbca8580cb98a91c7aArgyrios Kyrtzidis for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(), 41667732cc9c0fdc97a2f8cce4e5933d8103213d1aefFariborz Jahanian E = Decl->sel_param_end(); PI != E; ++PI) { 4167491306a83c4f0f49f95a3bcbca8580cb98a91c7aArgyrios Kyrtzidis const ParmVarDecl *PVDecl = *PI; 41681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType PType = PVDecl->getOriginalType(); 41694306d3cb9116605728252e2738df24b9f6ab53c3Fariborz Jahanian if (const ArrayType *AT = 4170ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 4171ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff // Use array's original type only if it has known number of 4172ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff // elements. 4173bb3fde337fb712c0e6da8790d431621be4793048Steve Naroff if (!isa<ConstantArrayType>(AT)) 4174ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff PType = PVDecl->getType(); 4175ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff } else if (PType->isFunctionType()) 4176ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff PType = PVDecl->getType(); 4177dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForMethodParameter(PVDecl->getObjCDeclQualifier(), 4178dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson PType, S, Extended); 4179199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck S += charUnitsToString(ParmOffset); 4180aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck ParmOffset += getObjCEncodingTypeSize(PType); 418133e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian } 4182f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor 4183f968d8374791c37bc464efd9168c2d33dd73605fDouglas Gregor return false; 418433e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian} 418533e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian 4186c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar/// getObjCEncodingForPropertyDecl - Return the encoded type for this 418783bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// property declaration. If non-NULL, Container must be either an 4188c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar/// ObjCCategoryImplDecl or ObjCImplementationDecl; it should only be 4189c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar/// NULL when getting encodings for protocol properties. 41901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// Property attributes are stored as a comma-delimited C string. The simple 41911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// attributes readonly and bycopy are encoded as single characters. The 41921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// parametrized attributes, getter=name, setter=name, and ivar=name, are 41931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// encoded as single characters, followed by an identifier. Property types 41941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// are also encoded as a parametrized attribute. The characters used to encode 419583bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// these attributes are defined by the following enumeration: 419683bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// @code 419783bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// enum PropertyAttributes { 419883bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyReadOnly = 'R', // property is read-only. 419983bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyBycopy = 'C', // property is a copy of the value last assigned 420083bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyByref = '&', // property is a reference to the value last assigned 420183bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyDynamic = 'D', // property is dynamic 420283bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyGetter = 'G', // followed by getter selector name 420383bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertySetter = 'S', // followed by setter selector name 420483bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyInstanceVariable = 'V' // followed by instance variable name 42050d4cb85130d91da61c45aecb9fd31c7097a7cfccBob Wilson/// kPropertyType = 'T' // followed by old-style type encoding. 420683bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyWeak = 'W' // 'weak' property 420783bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyStrong = 'P' // property GC'able 420883bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// kPropertyNonAtomic = 'N' // property non-atomic 420983bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// }; 421083bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian/// @endcode 42111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid ASTContext::getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD, 4212c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar const Decl *Container, 42134ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad std::string& S) const { 4214c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // Collect information from the property implementation decl(s). 4215c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar bool Dynamic = false; 4216c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar ObjCPropertyImplDecl *SynthesizePID = 0; 4217c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4218c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: Duplicated code due to poor abstraction. 4219c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (Container) { 42201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const ObjCCategoryImplDecl *CID = 4221c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar dyn_cast<ObjCCategoryImplDecl>(Container)) { 4222c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar for (ObjCCategoryImplDecl::propimpl_iterator 422317945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis i = CID->propimpl_begin(), e = CID->propimpl_end(); 4224653f1b1bf293a9bd96fd4dd6372e779cc7af1597Douglas Gregor i != e; ++i) { 4225581deb3da481053c4993c7600f97acf7768caac5David Blaikie ObjCPropertyImplDecl *PID = *i; 4226c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyDecl() == PD) { 4227c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) { 4228c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar Dynamic = true; 4229c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 4230c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar SynthesizePID = PID; 4231c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4232c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4233c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4234c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 423561710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner const ObjCImplementationDecl *OID=cast<ObjCImplementationDecl>(Container); 4236c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar for (ObjCCategoryImplDecl::propimpl_iterator 423717945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis i = OID->propimpl_begin(), e = OID->propimpl_end(); 4238653f1b1bf293a9bd96fd4dd6372e779cc7af1597Douglas Gregor i != e; ++i) { 4239581deb3da481053c4993c7600f97acf7768caac5David Blaikie ObjCPropertyImplDecl *PID = *i; 4240c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyDecl() == PD) { 4241c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) { 4242c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar Dynamic = true; 4243c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 4244c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar SynthesizePID = PID; 4245c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4246c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 42471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 4248c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4249c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4250c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4251c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: This is not very efficient. 4252c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S = "T"; 4253c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4254c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // Encode result type. 4255090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian // GCC has some special rules regarding encoding of properties which 4256090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian // closely resembles encoding of ivars. 42571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(PD->getType(), S, true, true, 0, 4258090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian true /* outermost type */, 4259090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian true /* encoding for property */); 4260c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4261c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PD->isReadOnly()) { 4262c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",R"; 4263c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } else { 4264c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar switch (PD->getSetterKind()) { 4265c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case ObjCPropertyDecl::Assign: break; 4266c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case ObjCPropertyDecl::Copy: S += ",C"; break; 42671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case ObjCPropertyDecl::Retain: S += ",&"; break; 42683a02b44e3948f7762dbfba94b7961281ca29d022Fariborz Jahanian case ObjCPropertyDecl::Weak: S += ",W"; break; 4269c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4270c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4271c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4272c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // It really isn't clear at all what this means, since properties 4273c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // are "dynamic by default". 4274c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (Dynamic) 4275c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",D"; 4276c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4277090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic) 4278090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian S += ",N"; 42791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4280c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) { 4281c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",G"; 4282077bf5e2f48acfa9e7d69429b6e4ba86ea14896dChris Lattner S += PD->getGetterName().getAsString(); 4283c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4284c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4285c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) { 4286c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",S"; 4287077bf5e2f48acfa9e7d69429b6e4ba86ea14896dChris Lattner S += PD->getSetterName().getAsString(); 4288c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4289c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4290c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (SynthesizePID) { 4291c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar const ObjCIvarDecl *OID = SynthesizePID->getPropertyIvarDecl(); 4292c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar S += ",V"; 429339f34e97d6a468f0a7dfa5664c61217cffc65b74Chris Lattner S += OID->getNameAsString(); 4294c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 4295c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4296c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // FIXME: OBJCGC: weak & strong 4297c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar} 4298c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 4299a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian/// getLegacyIntegralTypeEncoding - 43001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// Another legacy compatibility encoding: 32-bit longs are encoded as 43011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// 'l' or 'L' , but not always. For typedefs, we need to use 4302a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian/// 'i' or 'I' instead if encoding a struct field, or a pointer! 4303a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian/// 4304a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanianvoid ASTContext::getLegacyIntegralTypeEncoding (QualType &PointeeTy) const { 43058e1fab243ab8023b7ee3899745386b3b3a4258f8Mike Stump if (isa<TypedefType>(PointeeTy.getTypePtr())) { 4306183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const BuiltinType *BT = PointeeTy->getAs<BuiltinType>()) { 43074ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (BT->getKind() == BuiltinType::ULong && getIntWidth(PointeeTy) == 32) 4308a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian PointeeTy = UnsignedIntTy; 43091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump else 43104ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (BT->getKind() == BuiltinType::Long && getIntWidth(PointeeTy) == 32) 4311a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian PointeeTy = IntTy; 4312a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4313a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4314a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian} 4315a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian 43167d6b46d9a9d75dea8ef9f6973dd50633c1f37963Fariborz Jahanianvoid ASTContext::getObjCEncodingForType(QualType T, std::string& S, 43174ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const FieldDecl *Field) const { 431882a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // We follow the behavior of gcc, expanding structures which are 431982a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // directly pointed to, and expanding embedded structures. Note that 432082a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // these rules are sufficient to prevent recursive encoding of the 432182a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar // same type. 43221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(T, S, true, true, Field, 43235b8c7d9fb620ba3a71e996d61e7b9bdf763b5c09Fariborz Jahanian true /* outermost type */); 432482a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar} 432582a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar 432664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnallstatic char ObjCEncodingForPrimitiveKind(const ASTContext *C, QualType T) { 432764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall switch (T->getAs<BuiltinType>()->getKind()) { 4328b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Unhandled builtin type kind"); 432964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Void: return 'v'; 433064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Bool: return 'B'; 433164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Char_U: 433264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UChar: return 'C'; 433364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UShort: return 'S'; 433464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UInt: return 'I'; 433564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::ULong: 43364ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad return C->getIntWidth(T) == 32 ? 'L' : 'Q'; 433764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::UInt128: return 'T'; 433864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::ULongLong: return 'Q'; 433964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Char_S: 434064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::SChar: return 'c'; 434164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Short: return 's'; 43423f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_S: 43433f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner case BuiltinType::WChar_U: 434464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Int: return 'i'; 434564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Long: 43464ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad return C->getIntWidth(T) == 32 ? 'l' : 'q'; 434764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::LongLong: return 'q'; 434864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Int128: return 't'; 434964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Float: return 'f'; 435064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall case BuiltinType::Double: return 'd'; 43513a0be84b2aed8563150cdbd976a98838afa261ebDaniel Dunbar case BuiltinType::LongDouble: return 'D'; 435264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall } 435364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall} 435464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall 43555471bc85b69912e3b448de004498a80c0de32296Douglas Gregorstatic char ObjCEncodingForEnumType(const ASTContext *C, const EnumType *ET) { 43565471bc85b69912e3b448de004498a80c0de32296Douglas Gregor EnumDecl *Enum = ET->getDecl(); 43575471bc85b69912e3b448de004498a80c0de32296Douglas Gregor 43585471bc85b69912e3b448de004498a80c0de32296Douglas Gregor // The encoding of an non-fixed enum type is always 'i', regardless of size. 43595471bc85b69912e3b448de004498a80c0de32296Douglas Gregor if (!Enum->isFixed()) 43605471bc85b69912e3b448de004498a80c0de32296Douglas Gregor return 'i'; 43615471bc85b69912e3b448de004498a80c0de32296Douglas Gregor 43625471bc85b69912e3b448de004498a80c0de32296Douglas Gregor // The encoding of a fixed enum type matches its fixed underlying type. 43635471bc85b69912e3b448de004498a80c0de32296Douglas Gregor return ObjCEncodingForPrimitiveKind(C, Enum->getIntegerType()); 43645471bc85b69912e3b448de004498a80c0de32296Douglas Gregor} 43655471bc85b69912e3b448de004498a80c0de32296Douglas Gregor 43664ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadstatic void EncodeBitField(const ASTContext *Ctx, std::string& S, 436764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall QualType T, const FieldDecl *FD) { 4368a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith assert(FD->isBitField() && "not a bitfield - getObjCEncodingForTypeImpl"); 43698b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian S += 'b'; 437064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // The NeXT runtime encodes bit fields as b followed by the number of bits. 437164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // The GNU runtime requires more information; bitfields are encoded as b, 437264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // then the offset (in bits) of the first element, then the type of the 437364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // bitfield, then the size in bits. For example, in this structure: 437464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // 437564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // struct 437664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // { 437764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // int integer; 437864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // int flags:2; 437964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // }; 438064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // On a 32-bit system, the encoding for flags would be b2 for the NeXT 438164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // runtime, but b32i2 for the GNU runtime. The reason for this extra 438264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // information is not especially sensible, but we're stuck with it for 438364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // compatibility with GCC, although providing it breaks anything that 438464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall // actually uses runtime introspection and wants to work on both runtimes... 43854e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (!Ctx->getLangOpts().NeXTRuntime) { 438664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall const RecordDecl *RD = FD->getParent(); 438764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall const ASTRecordLayout &RL = Ctx->getASTRecordLayout(RD); 438882905749d5c8d8b4edec11de754a73349cb96603Eli Friedman S += llvm::utostr(RL.getFieldOffset(FD->getFieldIndex())); 43895471bc85b69912e3b448de004498a80c0de32296Douglas Gregor if (const EnumType *ET = T->getAs<EnumType>()) 43905471bc85b69912e3b448de004498a80c0de32296Douglas Gregor S += ObjCEncodingForEnumType(Ctx, ET); 4391c7ff82c2040f45eaad2eddea0e4461dddc972cd1David Chisnall else 43924ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad S += ObjCEncodingForPrimitiveKind(Ctx, T); 439364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall } 4394a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith S += llvm::utostr(FD->getBitWidthValue(*Ctx)); 43958b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian} 43968b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian 439701eb9b9683535d8a65c704ad2c545903409e2d36Daniel Dunbar// FIXME: Use SmallString for accumulating string. 439882a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbarvoid ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S, 439982a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar bool ExpandPointedToStructures, 440082a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar bool ExpandStructures, 4401153bfe5795e2c1a5a738e73d3784964e082237fcDaniel Dunbar const FieldDecl *FD, 4402090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian bool OutermostType, 44032636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis bool EncodingProperty, 4404dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool StructField, 4405dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool EncodeBlockParameters, 4406dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson bool EncodeClassNames) const { 440764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall if (T->getAs<BuiltinType>()) { 4408ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (FD && FD->isBitField()) 440964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall return EncodeBitField(this, S, T, FD); 441064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall S += ObjCEncodingForPrimitiveKind(this, T); 4411ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4412ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 44131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4414183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ComplexType *CT = T->getAs<ComplexType>()) { 4415c612f7bc9a6379cd7e7c2dd306d05938e890051bAnders Carlsson S += 'j'; 44161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(CT->getElementType(), S, false, false, 0, false, 4417c612f7bc9a6379cd7e7c2dd306d05938e890051bAnders Carlsson false); 4418ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4419ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 442060bce3ef20a4c9684e3825cdd739fefb9810327dFariborz Jahanian 4421aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian // encoding for pointer or r3eference types. 4422aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian QualType PointeeTy; 44236217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const PointerType *PT = T->getAs<PointerType>()) { 44248d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian if (PT->isObjCSelType()) { 44258d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian S += ':'; 44268d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian return; 44278d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian } 4428aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian PointeeTy = PT->getPointeeType(); 4429aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian } 4430aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian else if (const ReferenceType *RT = T->getAs<ReferenceType>()) 4431aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian PointeeTy = RT->getPointeeType(); 4432aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian if (!PointeeTy.isNull()) { 4433a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian bool isReadOnly = false; 4434a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // For historical/compatibility reasons, the read-only qualifier of the 4435a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // pointee gets emitted _before_ the '^'. The read-only qualifier of 4436a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // the pointer itself gets ignored, _unless_ we are looking at a typedef! 44371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Also, do not emit the 'r' for anything but the outermost type! 44388e1fab243ab8023b7ee3899745386b3b3a4258f8Mike Stump if (isa<TypedefType>(T.getTypePtr())) { 4439a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian if (OutermostType && T.isConstQualified()) { 4440a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian isReadOnly = true; 4441a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian S += 'r'; 4442a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 44439fdbab3cbc2fc04bcaf5768023d83707f3151144Mike Stump } else if (OutermostType) { 4444a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian QualType P = PointeeTy; 44456217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek while (P->getAs<PointerType>()) 44466217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek P = P->getAs<PointerType>()->getPointeeType(); 4447a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian if (P.isConstQualified()) { 4448a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian isReadOnly = true; 4449a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian S += 'r'; 4450a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4451a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 4452a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian if (isReadOnly) { 4453a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // Another legacy compatibility encoding. Some ObjC qualifier and type 4454a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // combinations need to be rearranged. 4455a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // Rewrite "in const" from "nr" to "rn" 44565f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner if (StringRef(S).endswith("nr")) 44570237941e0beb0c929934b66ad29443b484d987feBenjamin Kramer S.replace(S.end()-2, S.end(), "rn"); 4458a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 44591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 446085f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson if (PointeeTy->isCharType()) { 446185f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson // char pointer types should be encoded as '*' unless it is a 446285f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson // type that has been typedef'd to 'BOOL'. 4463e8c49533521c40643653f943d47229e62d277f88Anders Carlsson if (!isTypeTypedefedAsBOOL(PointeeTy)) { 446485f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson S += '*'; 446585f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson return; 446685f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson } 44676217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek } else if (const RecordType *RTy = PointeeTy->getAs<RecordType>()) { 44689533a7fdb8397421f3be52e879442460a87389f6Steve Naroff // GCC binary compat: Need to convert "struct objc_class *" to "#". 44699533a7fdb8397421f3be52e879442460a87389f6Steve Naroff if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_class")) { 44709533a7fdb8397421f3be52e879442460a87389f6Steve Naroff S += '#'; 44719533a7fdb8397421f3be52e879442460a87389f6Steve Naroff return; 44729533a7fdb8397421f3be52e879442460a87389f6Steve Naroff } 44739533a7fdb8397421f3be52e879442460a87389f6Steve Naroff // GCC binary compat: Need to convert "struct objc_object *" to "@". 44749533a7fdb8397421f3be52e879442460a87389f6Steve Naroff if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_object")) { 44759533a7fdb8397421f3be52e879442460a87389f6Steve Naroff S += '@'; 44769533a7fdb8397421f3be52e879442460a87389f6Steve Naroff return; 44779533a7fdb8397421f3be52e879442460a87389f6Steve Naroff } 44789533a7fdb8397421f3be52e879442460a87389f6Steve Naroff // fall through... 447985f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson } 448085f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson S += '^'; 4481a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian getLegacyIntegralTypeEncoding(PointeeTy); 4482a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian 44831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(PointeeTy, S, false, ExpandPointedToStructures, 448443822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian NULL); 4485ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4486ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 4487aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian 4488ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (const ArrayType *AT = 4489ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner // Ignore type qualifiers etc. 4490ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner dyn_cast<ArrayType>(T->getCanonicalTypeInternal())) { 44912636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (isa<IncompleteArrayType>(AT) && !StructField) { 4492559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson // Incomplete arrays are encoded as a pointer to the array element. 4493559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += '^'; 4494559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson 44951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(AT->getElementType(), S, 4496559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson false, ExpandStructures, FD); 4497559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson } else { 4498559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += '['; 44991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45002636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) { 45012636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (getTypeSize(CAT->getElementType()) == 0) 45022636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '0'; 45032636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis else 45042636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += llvm::utostr(CAT->getSize().getZExtValue()); 45052636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 4506559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson //Variable length arrays are encoded as a regular array with 0 elements. 45072636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert((isa<VariableArrayType>(AT) || isa<IncompleteArrayType>(AT)) && 45082636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis "Unknown array type!"); 4509559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += '0'; 4510559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson } 45111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(AT->getElementType(), S, 4513559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson false, ExpandStructures, FD); 4514559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson S += ']'; 4515559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson } 4516ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4517ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 45181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4519183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (T->getAs<FunctionType>()) { 4520c0a87b7db06643178ad2cbce0767548c139ea387Anders Carlsson S += '?'; 4521ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4522ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 45231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45246217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const RecordType *RTy = T->getAs<RecordType>()) { 452582a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar RecordDecl *RDecl = RTy->getDecl(); 4526d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar S += RDecl->isUnion() ? '(' : '{'; 4527502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar // Anonymous structures print as '?' 4528502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar if (const IdentifierInfo *II = RDecl->getIdentifier()) { 4529502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar S += II->getName(); 45306fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian if (ClassTemplateSpecializationDecl *Spec 45316fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian = dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) { 45326fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 45336fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian std::string TemplateArgsStr 45346fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian = TemplateSpecializationType::PrintTemplateArgumentList( 4535910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgs.data(), 4536910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor TemplateArgs.size(), 453730c42404202d2e2512e51efc6066bd614cfdb5a4Douglas Gregor (*this).getPrintingPolicy()); 45386fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian 45396fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian S += TemplateArgsStr; 45406fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian } 4541502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar } else { 4542502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar S += '?'; 4543502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar } 45440d504c1da852e58ff802545c823ecff3b6c654b8Daniel Dunbar if (ExpandStructures) { 45457d6b46d9a9d75dea8ef9f6973dd50633c1f37963Fariborz Jahanian S += '='; 45462636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!RDecl->isUnion()) { 45472636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForStructureImpl(RDecl, S, FD); 45482636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 45492636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (RecordDecl::field_iterator Field = RDecl->field_begin(), 45502636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldEnd = RDecl->field_end(); 45512636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis Field != FieldEnd; ++Field) { 45522636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (FD) { 45532636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 45542636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += Field->getNameAsString(); 45552636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 45562636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 45571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45582636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // Special case bit-fields. 45592636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (Field->isBitField()) { 45602636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForTypeImpl(Field->getType(), S, false, true, 4561581deb3da481053c4993c7600f97acf7768caac5David Blaikie *Field); 45622636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 45632636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis QualType qt = Field->getType(); 45642636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getLegacyIntegralTypeEncoding(qt); 45652636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForTypeImpl(qt, S, false, true, 45662636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FD, /*OutermostType*/false, 45672636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*EncodingProperty*/false, 45682636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*StructField*/true); 45692636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 4570d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar } 45717d6b46d9a9d75dea8ef9f6973dd50633c1f37963Fariborz Jahanian } 45726de88a873a4cbe06d72602eef57d68006730a80bFariborz Jahanian } 4573d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar S += RDecl->isUnion() ? ')' : '}'; 4574ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4575ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 4576e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian 45775471bc85b69912e3b448de004498a80c0de32296Douglas Gregor if (const EnumType *ET = T->getAs<EnumType>()) { 45788b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian if (FD && FD->isBitField()) 457964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall EncodeBitField(this, S, T, FD); 45808b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian else 45815471bc85b69912e3b448de004498a80c0de32296Douglas Gregor S += ObjCEncodingForEnumType(this, ET); 4582ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4583ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 45841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4585dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (const BlockPointerType *BT = T->getAs<BlockPointerType>()) { 458621a98b188857d690aa4510c52ac4317ffa0908a8Steve Naroff S += "@?"; // Unlike a pointer-to-function, which is "^?". 4587dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (EncodeBlockParameters) { 4588dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson const FunctionType *FT = BT->getPointeeType()->getAs<FunctionType>(); 4589dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson 4590dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson S += '<'; 4591dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Block return type 4592dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeImpl(FT->getResultType(), S, 4593dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson ExpandPointedToStructures, ExpandStructures, 4594dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson FD, 4595dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* OutermostType */, 4596dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodingProperty, 4597dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* StructField */, 4598dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeBlockParameters, 4599dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeClassNames); 4600dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Block self 4601dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson S += "@?"; 4602dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson // Block parameters 4603dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FT)) { 4604dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson for (FunctionProtoType::arg_type_iterator I = FPT->arg_type_begin(), 4605dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson E = FPT->arg_type_end(); I && (I != E); ++I) { 4606dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson getObjCEncodingForTypeImpl(*I, S, 4607dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson ExpandPointedToStructures, 4608dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson ExpandStructures, 4609dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson FD, 4610dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* OutermostType */, 4611dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodingProperty, 4612dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson false /* StructField */, 4613dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeBlockParameters, 4614dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson EncodeClassNames); 4615dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson } 4616dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson } 4617dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson S += '>'; 4618dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson } 4619ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4620ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4622c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Ignore protocol qualifiers when mangling at this level. 4623c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OT = T->getAs<ObjCObjectType>()) 4624c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall T = OT->getBaseType(); 4625c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 46260953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (const ObjCInterfaceType *OIT = T->getAs<ObjCInterfaceType>()) { 462743822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian // @encode(class_name) 46280953e767ff7817f97b3ab20896b229891eeff45bJohn McCall ObjCInterfaceDecl *OI = OIT->getDecl(); 462943822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += '{'; 463043822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian const IdentifierInfo *II = OI->getIdentifier(); 463143822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += II->getName(); 463243822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += '='; 4633db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose SmallVector<const ObjCIvarDecl*, 32> Ivars; 46342c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian DeepCollectObjCIvars(OI, true, Ivars); 46352c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian for (unsigned i = 0, e = Ivars.size(); i != e; ++i) { 4636db8264e4c5ffd7af6fbad4ca4306bd382bb02691Jordy Rose const FieldDecl *Field = cast<FieldDecl>(Ivars[i]); 46372c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian if (Field->isBitField()) 46382c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian getObjCEncodingForTypeImpl(Field->getType(), S, false, true, Field); 463943822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian else 46402c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian getObjCEncodingForTypeImpl(Field->getType(), S, false, true, FD); 464143822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian } 464243822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S += '}'; 4643ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 464443822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian } 46451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4646183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const ObjCObjectPointerType *OPT = T->getAs<ObjCObjectPointerType>()) { 464714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (OPT->isObjCIdType()) { 464814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '@'; 464914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 4650ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 465227d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) { 465327d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff // FIXME: Consider if we need to output qualifiers for 'Class<p>'. 465427d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff // Since this is a binary compatibility issue, need to consult with runtime 465527d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff // folks. Fortunately, this is a *very* obsure construct. 465614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '#'; 465714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 4658ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4660ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (OPT->isObjCQualifiedIdType()) { 46611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(getObjCIdType(), S, 466214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff ExpandPointedToStructures, 466314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff ExpandStructures, FD); 4664dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (FD || EncodingProperty || EncodeClassNames) { 466514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff // Note that we do extended encoding of protocol qualifer list 466614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff // Only when doing ivar or property encoding. 466714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '"'; 466867ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(), 466967ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff E = OPT->qual_end(); I != E; ++I) { 467014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '<'; 467114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += (*I)->getNameAsString(); 467214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '>'; 467314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 467414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff S += '"'; 467514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 467614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 4677ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 46781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4679ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner QualType PointeeTy = OPT->getPointeeType(); 4680ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (!EncodingProperty && 4681ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner isa<TypedefType>(PointeeTy.getTypePtr())) { 4682ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner // Another historical/compatibility reason. 46831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // We encode the underlying type which comes out as 4684ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner // {...}; 4685ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '^'; 46861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump getObjCEncodingForTypeImpl(PointeeTy, S, 46871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump false, ExpandPointedToStructures, 4688ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner NULL); 468914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return; 469014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 4691ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner 4692ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '@'; 4693dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson if (OPT->getInterfaceDecl() && 4694dc8dab6fabf4bfd4f4b94bf572ac3342a5bbfcd7Bob Wilson (FD || EncodingProperty || EncodeClassNames)) { 4695ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '"'; 469627d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff S += OPT->getInterfaceDecl()->getIdentifier()->getName(); 469767ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(), 469867ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff E = OPT->qual_end(); I != E; ++I) { 4699ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '<'; 4700ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += (*I)->getNameAsString(); 4701ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '>'; 47021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 4703ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner S += '"'; 4704ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 4705ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return; 4706ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 47071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4708532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall // gcc just blithely ignores member pointers. 4709532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall // TODO: maybe there should be a mangling for these 4710532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall if (T->getAs<MemberPointerType>()) 4711532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall return; 4712e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian 4713e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian if (T->isVectorType()) { 4714e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian // This matches gcc's encoding, even though technically it is 4715e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian // insufficient. 4716e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian // FIXME. We should do a better job than gcc. 4717e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian return; 4718e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian } 4719e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian 4720b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("@encode for type not implemented!"); 472185f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson} 472285f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson 47232636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidisvoid ASTContext::getObjCEncodingForStructureImpl(RecordDecl *RDecl, 47242636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::string &S, 47252636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis const FieldDecl *FD, 47262636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis bool includeVBases) const { 47272636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert(RDecl && "Expected non-null RecordDecl"); 47282636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert(!RDecl->isUnion() && "Should not be called for unions"); 47292636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!RDecl->getDefinition()) 47302636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis return; 47312636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47322636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CXXRecordDecl *CXXRec = dyn_cast<CXXRecordDecl>(RDecl); 47332636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::multimap<uint64_t, NamedDecl *> FieldOrBaseOffsets; 47342636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis const ASTRecordLayout &layout = getASTRecordLayout(RDecl); 47352636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47362636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRec) { 47372636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (CXXRecordDecl::base_class_iterator 47382636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BI = CXXRec->bases_begin(), 47392636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BE = CXXRec->bases_end(); BI != BE; ++BI) { 47402636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!BI->isVirtual()) { 47412636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CXXRecordDecl *base = BI->getType()->getAsCXXRecordDecl(); 4742829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis if (base->isEmpty()) 4743829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis continue; 47442636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = layout.getBaseClassOffsetInBits(base); 47452636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs), 47462636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::make_pair(offs, base)); 47472636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47482636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47492636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47502636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47512636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis unsigned i = 0; 47522636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (RecordDecl::field_iterator Field = RDecl->field_begin(), 47532636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldEnd = RDecl->field_end(); 47542636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis Field != FieldEnd; ++Field, ++i) { 47552636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = layout.getFieldOffset(i); 47562636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs), 4757581deb3da481053c4993c7600f97acf7768caac5David Blaikie std::make_pair(offs, *Field)); 47582636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47592636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47602636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRec && includeVBases) { 47612636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (CXXRecordDecl::base_class_iterator 47622636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BI = CXXRec->vbases_begin(), 47632636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis BE = CXXRec->vbases_end(); BI != BE; ++BI) { 47642636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CXXRecordDecl *base = BI->getType()->getAsCXXRecordDecl(); 4765829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis if (base->isEmpty()) 4766829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis continue; 47672636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = layout.getVBaseClassOffsetInBits(base); 476819aa8609a5d04eed9b81aa1c4608e8a4f3df6ccdArgyrios Kyrtzidis if (FieldOrBaseOffsets.find(offs) == FieldOrBaseOffsets.end()) 476919aa8609a5d04eed9b81aa1c4608e8a4f3df6ccdArgyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.end(), 477019aa8609a5d04eed9b81aa1c4608e8a4f3df6ccdArgyrios Kyrtzidis std::make_pair(offs, base)); 47712636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47722636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47732636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47742636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CharUnits size; 47752636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRec) { 47762636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis size = includeVBases ? layout.getSize() : layout.getNonVirtualSize(); 47772636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 47782636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis size = layout.getSize(); 47792636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47802636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47812636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t CurOffs = 0; 47822636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::multimap<uint64_t, NamedDecl *>::iterator 47832636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurLayObj = FieldOrBaseOffsets.begin(); 47842636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 478558db7a575efc9a2f35266fe240feac3cf317753dDouglas Gregor if (CXXRec && CXXRec->isDynamicClass() && 478658db7a575efc9a2f35266fe240feac3cf317753dDouglas Gregor (CurLayObj == FieldOrBaseOffsets.end() || CurLayObj->first != 0)) { 47872636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (FD) { 47882636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += "\"_vptr$"; 47892636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::string recname = CXXRec->getNameAsString(); 47902636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (recname.empty()) recname = "?"; 47912636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += recname; 47922636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 47932636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47942636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += "^^?"; 47952636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurOffs += getTypeSize(VoidPtrTy); 47962636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 47972636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 47982636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (!RDecl->hasFlexibleArrayMember()) { 47992636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // Mark the end of the structure. 48002636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t offs = toBits(size); 48012636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs), 48022636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis std::make_pair(offs, (NamedDecl*)0)); 48032636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48042636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48052636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis for (; CurLayObj != FieldOrBaseOffsets.end(); ++CurLayObj) { 48062636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis assert(CurOffs <= CurLayObj->first); 48072636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48082636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CurOffs < CurLayObj->first) { 48092636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis uint64_t padding = CurLayObj->first - CurOffs; 48102636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // FIXME: There doesn't seem to be a way to indicate in the encoding that 48112636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // packing/alignment of members is different that normal, in which case 48122636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // the encoding will be out-of-sync with the real layout. 48132636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // If the runtime switches to just consider the size of types without 48142636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // taking into account alignment, we could make padding explicit in the 48152636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // encoding (e.g. using arrays of chars). The encoding strings would be 48162636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // longer then though. 48172636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurOffs += padding; 48182636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48192636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48202636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis NamedDecl *dcl = CurLayObj->second; 48212636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (dcl == 0) 48222636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis break; // reached end of structure. 48232636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48242636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (CXXRecordDecl *base = dyn_cast<CXXRecordDecl>(dcl)) { 48252636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // We expand the bases without their virtual bases since those are going 48262636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // in the initial structure. Note that this differs from gcc which 48272636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // expands virtual bases each time one is encountered in the hierarchy, 48282636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis // making the encoding type bigger than it really is. 48292636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForStructureImpl(base, S, FD, /*includeVBases*/false); 4830829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis assert(!base->isEmpty()); 4831829f20097e030229fd4c234b84948f53312eaf55Argyrios Kyrtzidis CurOffs += toBits(getASTRecordLayout(base).getNonVirtualSize()); 48322636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 48332636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis FieldDecl *field = cast<FieldDecl>(dcl); 48342636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (FD) { 48352636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 48362636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += field->getNameAsString(); 48372636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis S += '"'; 48382636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48392636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48402636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis if (field->isBitField()) { 48412636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis EncodeBitField(this, S, field->getType(), field); 4842a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith CurOffs += field->getBitWidthValue(*this); 48432636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } else { 48442636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis QualType qt = field->getType(); 48452636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getLegacyIntegralTypeEncoding(qt); 48462636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis getObjCEncodingForTypeImpl(qt, S, false, true, FD, 48472636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*OutermostType*/false, 48482636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*EncodingProperty*/false, 48492636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis /*StructField*/true); 48502636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis CurOffs += getTypeSize(field->getType()); 48512636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48522636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48532636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis } 48542636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis} 48552636197098e02fd7c90f9496056b8ab886dcbff0Argyrios Kyrtzidis 48561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT, 4857ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian std::string& S) const { 4858ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_In) 4859ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'n'; 4860ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Inout) 4861ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'N'; 4862ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Out) 4863ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'o'; 4864ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Bycopy) 4865ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'O'; 4866ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Byref) 4867ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'R'; 4868ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian if (QT & Decl::OBJC_TQ_Oneway) 4869ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian S += 'V'; 4870ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian} 4871ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian 48724dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas GregorTypedefDecl *ASTContext::getObjCIdDecl() const { 48734dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor if (!ObjCIdDecl) { 48744dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor QualType T = getObjCObjectType(ObjCBuiltinIdTy, 0, 0); 48754dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor T = getObjCObjectPointerType(T); 48764dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor TypeSourceInfo *IdInfo = getTrivialTypeSourceInfo(T); 48774dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor ObjCIdDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 48784dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor getTranslationUnitDecl(), 48794dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor SourceLocation(), SourceLocation(), 48804dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor &Idents.get("id"), IdInfo); 48814dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor } 48824dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor 48834dfd02a17c6d604c72e6936527c5e1c56d3ecb7aDouglas Gregor return ObjCIdDecl; 48847e219e47de26346885d667131977bd9ca2d7662aSteve Naroff} 48857e219e47de26346885d667131977bd9ca2d7662aSteve Naroff 48867a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas GregorTypedefDecl *ASTContext::getObjCSelDecl() const { 48877a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor if (!ObjCSelDecl) { 48887a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor QualType SelT = getPointerType(ObjCBuiltinSelTy); 48897a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor TypeSourceInfo *SelInfo = getTrivialTypeSourceInfo(SelT); 48907a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor ObjCSelDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 48917a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor getTranslationUnitDecl(), 48927a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor SourceLocation(), SourceLocation(), 48937a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor &Idents.get("SEL"), SelInfo); 48947a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor } 48957a27ea52b7bd635c89bec5a9c521a3bf7d204238Douglas Gregor return ObjCSelDecl; 4896b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian} 4897b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian 489879d6726921897811232554ed94c5d77b5b7b3fc0Douglas GregorTypedefDecl *ASTContext::getObjCClassDecl() const { 489979d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor if (!ObjCClassDecl) { 490079d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor QualType T = getObjCObjectType(ObjCBuiltinClassTy, 0, 0); 490179d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor T = getObjCObjectPointerType(T); 490279d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor TypeSourceInfo *ClassInfo = getTrivialTypeSourceInfo(T); 490379d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor ObjCClassDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 490479d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor getTranslationUnitDecl(), 490579d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor SourceLocation(), SourceLocation(), 490679d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor &Idents.get("Class"), ClassInfo); 490779d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor } 490879d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor 490979d6726921897811232554ed94c5d77b5b7b3fc0Douglas Gregor return ObjCClassDecl; 4910a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor} 4911a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor 4912a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas GregorObjCInterfaceDecl *ASTContext::getObjCProtocolDecl() const { 4913a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor if (!ObjCProtocolClassDecl) { 4914a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor ObjCProtocolClassDecl 4915a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor = ObjCInterfaceDecl::Create(*this, getTranslationUnitDecl(), 4916a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor SourceLocation(), 4917a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor &Idents.get("Protocol"), 4918a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor /*PrevDecl=*/0, 4919a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor SourceLocation(), true); 4920a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor } 4921a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor 4922a6ea10e22b600d92e084f6b11b9b9a92d0eb2412Douglas Gregor return ObjCProtocolClassDecl; 49238baaca50f07d0c10bba69c8d88c1b9078c92d06dAnders Carlsson} 49248baaca50f07d0c10bba69c8d88c1b9078c92d06dAnders Carlsson 4925c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge//===----------------------------------------------------------------------===// 4926c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge// __builtin_va_list Construction Functions 4927c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge//===----------------------------------------------------------------------===// 4928c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 4929c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Ingestatic TypedefDecl *CreateCharPtrBuiltinVaListDecl(const ASTContext *Context) { 4930c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // typedef char* __builtin_va_list; 4931c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge QualType CharPtrType = Context->getPointerType(Context->CharTy); 4932c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge TypeSourceInfo *TInfo 4933c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge = Context->getTrivialTypeSourceInfo(CharPtrType); 4934c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 4935c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge TypedefDecl *VaListTypeDecl 4936c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge = TypedefDecl::Create(const_cast<ASTContext &>(*Context), 4937c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Context->getTranslationUnitDecl(), 4938c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge SourceLocation(), SourceLocation(), 4939c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge &Context->Idents.get("__builtin_va_list"), 4940c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge TInfo); 4941c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge return VaListTypeDecl; 4942c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge} 4943c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 4944c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Ingestatic TypedefDecl *CreateVoidPtrBuiltinVaListDecl(const ASTContext *Context) { 4945c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // typedef void* __builtin_va_list; 4946c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge QualType VoidPtrType = Context->getPointerType(Context->VoidTy); 4947c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge TypeSourceInfo *TInfo 4948c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge = Context->getTrivialTypeSourceInfo(VoidPtrType); 4949c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 4950c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge TypedefDecl *VaListTypeDecl 4951c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge = TypedefDecl::Create(const_cast<ASTContext &>(*Context), 4952c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Context->getTranslationUnitDecl(), 4953c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge SourceLocation(), SourceLocation(), 4954c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge &Context->Idents.get("__builtin_va_list"), 4955c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge TInfo); 4956c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge return VaListTypeDecl; 4957c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge} 4958c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 4959c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Ingestatic TypedefDecl *CreatePowerABIBuiltinVaListDecl(const ASTContext *Context) { 4960c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // typedef struct __va_list_tag { 4961c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge RecordDecl *VaListTagDecl; 4962c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 4963c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge VaListTagDecl = CreateRecordDecl(*Context, TTK_Struct, 4964c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Context->getTranslationUnitDecl(), 4965c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge &Context->Idents.get("__va_list_tag")); 4966c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge VaListTagDecl->startDefinition(); 4967c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 4968c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge const size_t NumFields = 5; 4969c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge QualType FieldTypes[NumFields]; 4970c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge const char *FieldNames[NumFields]; 4971c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 4972c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // unsigned char gpr; 4973c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldTypes[0] = Context->UnsignedCharTy; 4974c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldNames[0] = "gpr"; 4975c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 4976c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // unsigned char fpr; 4977c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldTypes[1] = Context->UnsignedCharTy; 4978c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldNames[1] = "fpr"; 4979c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 4980c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // unsigned short reserved; 4981c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldTypes[2] = Context->UnsignedShortTy; 4982c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldNames[2] = "reserved"; 4983c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 4984c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // void* overflow_arg_area; 4985c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldTypes[3] = Context->getPointerType(Context->VoidTy); 4986c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldNames[3] = "overflow_arg_area"; 4987c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 4988c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // void* reg_save_area; 4989c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldTypes[4] = Context->getPointerType(Context->VoidTy); 4990c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldNames[4] = "reg_save_area"; 4991c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 4992c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // Create fields 4993c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge for (unsigned i = 0; i < NumFields; ++i) { 4994c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldDecl *Field = FieldDecl::Create(*Context, VaListTagDecl, 4995c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge SourceLocation(), 4996c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge SourceLocation(), 4997c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge &Context->Idents.get(FieldNames[i]), 4998c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldTypes[i], /*TInfo=*/0, 4999c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge /*BitWidth=*/0, 5000c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge /*Mutable=*/false, 5001c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge ICIS_NoInit); 5002c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Field->setAccess(AS_public); 5003c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge VaListTagDecl->addDecl(Field); 5004c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge } 5005c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge VaListTagDecl->completeDefinition(); 5006c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge QualType VaListTagType = Context->getRecordType(VaListTagDecl); 5007c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5008c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // } __va_list_tag; 5009c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge TypedefDecl *VaListTagTypedefDecl 5010c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge = TypedefDecl::Create(const_cast<ASTContext &>(*Context), 5011c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Context->getTranslationUnitDecl(), 5012c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge SourceLocation(), SourceLocation(), 5013c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge &Context->Idents.get("__va_list_tag"), 5014c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Context->getTrivialTypeSourceInfo(VaListTagType)); 5015c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge QualType VaListTagTypedefType = 5016c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Context->getTypedefType(VaListTagTypedefDecl); 5017c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5018c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // typedef __va_list_tag __builtin_va_list[1]; 5019c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1); 5020c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge QualType VaListTagArrayType 5021c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge = Context->getConstantArrayType(VaListTagTypedefType, 5022c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Size, ArrayType::Normal, 0); 5023c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge TypeSourceInfo *TInfo 5024c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge = Context->getTrivialTypeSourceInfo(VaListTagArrayType); 5025c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge TypedefDecl *VaListTypedefDecl 5026c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge = TypedefDecl::Create(const_cast<ASTContext &>(*Context), 5027c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Context->getTranslationUnitDecl(), 5028c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge SourceLocation(), SourceLocation(), 5029c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge &Context->Idents.get("__builtin_va_list"), 5030c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge TInfo); 5031c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5032c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge return VaListTypedefDecl; 5033c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge} 5034c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5035c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Ingestatic TypedefDecl * 5036c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador IngeCreateX86_64ABIBuiltinVaListDecl(const ASTContext *Context) { 5037c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // typedef struct __va_list_tag { 5038c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge RecordDecl *VaListTagDecl; 5039c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge VaListTagDecl = CreateRecordDecl(*Context, TTK_Struct, 5040c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Context->getTranslationUnitDecl(), 5041c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge &Context->Idents.get("__va_list_tag")); 5042c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge VaListTagDecl->startDefinition(); 5043c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5044c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge const size_t NumFields = 4; 5045c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge QualType FieldTypes[NumFields]; 5046c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge const char *FieldNames[NumFields]; 5047c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5048c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // unsigned gp_offset; 5049c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldTypes[0] = Context->UnsignedIntTy; 5050c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldNames[0] = "gp_offset"; 5051c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5052c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // unsigned fp_offset; 5053c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldTypes[1] = Context->UnsignedIntTy; 5054c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldNames[1] = "fp_offset"; 5055c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5056c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // void* overflow_arg_area; 5057c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldTypes[2] = Context->getPointerType(Context->VoidTy); 5058c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldNames[2] = "overflow_arg_area"; 5059c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5060c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // void* reg_save_area; 5061c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldTypes[3] = Context->getPointerType(Context->VoidTy); 5062c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldNames[3] = "reg_save_area"; 5063c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5064c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // Create fields 5065c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge for (unsigned i = 0; i < NumFields; ++i) { 5066c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context), 5067c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge VaListTagDecl, 5068c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge SourceLocation(), 5069c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge SourceLocation(), 5070c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge &Context->Idents.get(FieldNames[i]), 5071c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge FieldTypes[i], /*TInfo=*/0, 5072c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge /*BitWidth=*/0, 5073c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge /*Mutable=*/false, 5074c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge ICIS_NoInit); 5075c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Field->setAccess(AS_public); 5076c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge VaListTagDecl->addDecl(Field); 5077c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge } 5078c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge VaListTagDecl->completeDefinition(); 5079c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge QualType VaListTagType = Context->getRecordType(VaListTagDecl); 5080c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5081c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // } __va_list_tag; 5082c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge TypedefDecl *VaListTagTypedefDecl 5083c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge = TypedefDecl::Create(const_cast<ASTContext &>(*Context), 5084c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Context->getTranslationUnitDecl(), 5085c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge SourceLocation(), SourceLocation(), 5086c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge &Context->Idents.get("__va_list_tag"), 5087c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Context->getTrivialTypeSourceInfo(VaListTagType)); 5088c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge QualType VaListTagTypedefType = 5089c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Context->getTypedefType(VaListTagTypedefDecl); 5090c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5091c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // typedef __va_list_tag __builtin_va_list[1]; 5092c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1); 5093c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge QualType VaListTagArrayType 5094c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge = Context->getConstantArrayType(VaListTagTypedefType, 5095c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Size, ArrayType::Normal,0); 5096c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge TypeSourceInfo *TInfo 5097c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge = Context->getTrivialTypeSourceInfo(VaListTagArrayType); 5098c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge TypedefDecl *VaListTypedefDecl 5099c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge = TypedefDecl::Create(const_cast<ASTContext &>(*Context), 5100c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Context->getTranslationUnitDecl(), 5101c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge SourceLocation(), SourceLocation(), 5102c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge &Context->Idents.get("__builtin_va_list"), 5103c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge TInfo); 5104c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5105c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge return VaListTypedefDecl; 5106c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge} 5107c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5108c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Ingestatic TypedefDecl *CreatePNaClABIBuiltinVaListDecl(const ASTContext *Context) { 5109c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge // typedef int __builtin_va_list[4]; 5110c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 4); 5111c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge QualType IntArrayType 5112c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge = Context->getConstantArrayType(Context->IntTy, 5113c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Size, ArrayType::Normal, 0); 5114c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge TypedefDecl *VaListTypedefDecl 5115c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge = TypedefDecl::Create(const_cast<ASTContext &>(*Context), 5116c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Context->getTranslationUnitDecl(), 5117c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge SourceLocation(), SourceLocation(), 5118c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge &Context->Idents.get("__builtin_va_list"), 5119c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge Context->getTrivialTypeSourceInfo(IntArrayType)); 5120c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5121c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge return VaListTypedefDecl; 5122c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge} 5123c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5124c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Ingestatic TypedefDecl *CreateVaListDecl(const ASTContext *Context, 5125c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge TargetInfo::BuiltinVaListKind Kind) { 5126c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge switch (Kind) { 5127c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge case TargetInfo::CharPtrBuiltinVaList: 5128c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge return CreateCharPtrBuiltinVaListDecl(Context); 5129c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge case TargetInfo::VoidPtrBuiltinVaList: 5130c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge return CreateVoidPtrBuiltinVaListDecl(Context); 5131c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge case TargetInfo::PowerABIBuiltinVaList: 5132c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge return CreatePowerABIBuiltinVaListDecl(Context); 5133c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge case TargetInfo::X86_64ABIBuiltinVaList: 5134c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge return CreateX86_64ABIBuiltinVaListDecl(Context); 5135c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge case TargetInfo::PNaClABIBuiltinVaList: 5136c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge return CreatePNaClABIBuiltinVaListDecl(Context); 5137c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge } 5138c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5139c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge llvm_unreachable("Unhandled __builtin_va_list type kind"); 5140c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge} 5141c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5142c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador IngeTypedefDecl *ASTContext::getBuiltinVaListDecl() const { 5143c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge if (!BuiltinVaListDecl) 5144c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge BuiltinVaListDecl = CreateVaListDecl(this, Target->getBuiltinVaListKind()); 5145c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5146c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge return BuiltinVaListDecl; 5147c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge} 5148c5613b26a24a33d7450e3d0bf315c6ccc920ce7bMeador Inge 5149a526c5c67e5a0473c340903ee542ce570119665fTed Kremenekvoid ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) { 51501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(ObjCConstantStringType.isNull() && 51512198891824c38d45b2279de5d5e3ef9394eb457cSteve Naroff "'NSConstantString' type already set!"); 51521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5153a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCConstantStringType = getObjCInterfaceType(Decl); 51542198891824c38d45b2279de5d5e3ef9394eb457cSteve Naroff} 51552198891824c38d45b2279de5d5e3ef9394eb457cSteve Naroff 51560bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall/// \brief Retrieve the template name that corresponds to a non-empty 51570bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall/// lookup. 51584ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName 51594ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getOverloadedTemplateName(UnresolvedSetIterator Begin, 51604ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad UnresolvedSetIterator End) const { 51610bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall unsigned size = End - Begin; 51620bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall assert(size > 1 && "set is not overloaded!"); 51637532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 51640bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall void *memory = Allocate(sizeof(OverloadedTemplateStorage) + 51650bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall size * sizeof(FunctionTemplateDecl*)); 51660bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall OverloadedTemplateStorage *OT = new(memory) OverloadedTemplateStorage(size); 51670bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall 51680bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall NamedDecl **Storage = OT->getStorage(); 5169eec51cf1ba5f0e62c9cdb81b5c63babdd6e649abJohn McCall for (UnresolvedSetIterator I = Begin; I != End; ++I) { 51700bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall NamedDecl *D = *I; 51710bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall assert(isa<FunctionTemplateDecl>(D) || 51720bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall (isa<UsingShadowDecl>(D) && 51730bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall isa<FunctionTemplateDecl>(D->getUnderlyingDecl()))); 51740bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall *Storage++ = D; 51757532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor } 51767532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 51770bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall return TemplateName(OT); 51787532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor} 51797532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 5180d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor/// \brief Retrieve the template name that represents a qualified 5181d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor/// template name such as \c std::vector. 51824ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName 51834ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS, 51844ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad bool TemplateKeyword, 51854ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad TemplateDecl *Template) const { 51860f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor assert(NNS && "Missing nested-name-specifier in qualified template name"); 51870f0ea2a96534c615ff5fdd81363989b23cf2164aDouglas Gregor 5188789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor // FIXME: Canonicalization? 5189d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor llvm::FoldingSetNodeID ID; 5190d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template); 51911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5192d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor void *InsertPos = 0; 5193d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QualifiedTemplateName *QTN = 51940bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 5195d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor if (!QTN) { 5196d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QTN = new (*this,4) QualifiedTemplateName(NNS, TemplateKeyword, Template); 5197d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor QualifiedTemplateNames.InsertNode(QTN, InsertPos); 5198d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor } 51991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5200d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor return TemplateName(QTN); 5201d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor} 5202d99cbe66403ee39c2ee58024b9582b95649a4fc5Douglas Gregor 52037532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor/// \brief Retrieve the template name that represents a dependent 52047532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor/// template name such as \c MetaFun::template apply. 52054ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadTemplateName 52064ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::getDependentTemplateName(NestedNameSpecifier *NNS, 52074ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const IdentifierInfo *Name) const { 52081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert((!NNS || NNS->isDependent()) && 52093b6afbb99a1c44b4076f8e15fb7311405941b306Douglas Gregor "Nested name specifier must be dependent"); 52107532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 52117532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor llvm::FoldingSetNodeID ID; 52127532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateName::Profile(ID, NNS, Name); 52137532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 52147532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor void *InsertPos = 0; 52157532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateName *QTN = 52167532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 52177532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 52187532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor if (QTN) 52197532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor return TemplateName(QTN); 52207532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 52217532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 52227532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor if (CanonNNS == NNS) { 52237532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Name); 52247532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor } else { 52257532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor TemplateName Canon = getDependentTemplateName(CanonNNS, Name); 52267532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Name, Canon); 5227789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateName *CheckQTN = 5228789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 5229789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!CheckQTN && "Dependent type name canonicalization broken"); 5230789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CheckQTN; 52317532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor } 52327532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 52337532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor DependentTemplateNames.InsertNode(QTN, InsertPos); 52347532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor return TemplateName(QTN); 52357532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor} 52367532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor 5237ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor/// \brief Retrieve the template name that represents a dependent 5238ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor/// template name such as \c MetaFun::template operator+. 5239ca1bdd7c269a2390d43c040a60511edd017ee130Douglas GregorTemplateName 5240ca1bdd7c269a2390d43c040a60511edd017ee130Douglas GregorASTContext::getDependentTemplateName(NestedNameSpecifier *NNS, 52414ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad OverloadedOperatorKind Operator) const { 5242ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor assert((!NNS || NNS->isDependent()) && 5243ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor "Nested name specifier must be dependent"); 5244ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5245ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor llvm::FoldingSetNodeID ID; 5246ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor DependentTemplateName::Profile(ID, NNS, Operator); 5247ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5248ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor void *InsertPos = 0; 5249789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateName *QTN 5250789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 5251ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5252ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor if (QTN) 5253ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor return TemplateName(QTN); 5254ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5255ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 5256ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor if (CanonNNS == NNS) { 5257ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Operator); 5258ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor } else { 5259ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor TemplateName Canon = getDependentTemplateName(CanonNNS, Operator); 5260ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor QTN = new (*this,4) DependentTemplateName(NNS, Operator, Canon); 5261789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 5262789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor DependentTemplateName *CheckQTN 5263789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 5264789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor assert(!CheckQTN && "Dependent template name canonicalization broken"); 5265789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor (void)CheckQTN; 5266ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor } 5267ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 5268ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor DependentTemplateNames.InsertNode(QTN, InsertPos); 5269ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor return TemplateName(QTN); 5270ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor} 5271ca1bdd7c269a2390d43c040a60511edd017ee130Douglas Gregor 52721aee05d08b2184acadeb36de300e216390780d6cDouglas GregorTemplateName 5273146060435c3efce95c95a092c7a1eb651cfb9ae0John McCallASTContext::getSubstTemplateTemplateParm(TemplateTemplateParmDecl *param, 5274146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall TemplateName replacement) const { 5275146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall llvm::FoldingSetNodeID ID; 5276146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage::Profile(ID, param, replacement); 5277146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5278146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall void *insertPos = 0; 5279146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParmStorage *subst 5280146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall = SubstTemplateTemplateParms.FindNodeOrInsertPos(ID, insertPos); 5281146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5282146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall if (!subst) { 5283146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall subst = new (*this) SubstTemplateTemplateParmStorage(param, replacement); 5284146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall SubstTemplateTemplateParms.InsertNode(subst, insertPos); 5285146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall } 5286146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5287146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall return TemplateName(subst); 5288146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall} 5289146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall 5290146060435c3efce95c95a092c7a1eb651cfb9ae0John McCallTemplateName 52911aee05d08b2184acadeb36de300e216390780d6cDouglas GregorASTContext::getSubstTemplateTemplateParmPack(TemplateTemplateParmDecl *Param, 52921aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor const TemplateArgument &ArgPack) const { 52931aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor ASTContext &Self = const_cast<ASTContext &>(*this); 52941aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor llvm::FoldingSetNodeID ID; 52951aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor SubstTemplateTemplateParmPackStorage::Profile(ID, Self, Param, ArgPack); 52961aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 52971aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor void *InsertPos = 0; 52981aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor SubstTemplateTemplateParmPackStorage *Subst 52991aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor = SubstTemplateTemplateParmPacks.FindNodeOrInsertPos(ID, InsertPos); 53001aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 53011aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor if (!Subst) { 5302146060435c3efce95c95a092c7a1eb651cfb9ae0John McCall Subst = new (*this) SubstTemplateTemplateParmPackStorage(Param, 53031aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor ArgPack.pack_size(), 53041aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor ArgPack.pack_begin()); 53051aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor SubstTemplateTemplateParmPacks.InsertNode(Subst, InsertPos); 53061aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor } 53071aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 53081aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor return TemplateName(Subst); 53091aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor} 53101aee05d08b2184acadeb36de300e216390780d6cDouglas Gregor 5311b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor/// getFromTargetType - Given one of the integer types provided by 5312d934112e6170b0fd940d8e40db6936cea2cdcf62Douglas Gregor/// TargetInfo, produce the corresponding type. The unsigned @p Type 5313d934112e6170b0fd940d8e40db6936cea2cdcf62Douglas Gregor/// is actually a value of type @c TargetInfo::IntType. 5314e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCallCanQualType ASTContext::getFromTargetType(unsigned Type) const { 5315b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor switch (Type) { 5316e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCall case TargetInfo::NoInt: return CanQualType(); 5317b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedShort: return ShortTy; 5318b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedShort: return UnsignedShortTy; 5319b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedInt: return IntTy; 5320b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedInt: return UnsignedIntTy; 5321b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedLong: return LongTy; 5322b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedLong: return UnsignedLongTy; 5323b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::SignedLongLong: return LongLongTy; 5324b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TargetInfo::UnsignedLongLong: return UnsignedLongLongTy; 5325b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor } 5326b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor 5327b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unhandled TargetInfo::IntType value"); 5328b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor} 5329b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek 5330b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek//===----------------------------------------------------------------------===// 5331b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek// Type Predicates. 5332b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek//===----------------------------------------------------------------------===// 5333b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek 53344fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian/// getObjCGCAttr - Returns one of GCNone, Weak or Strong objc's 53354fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian/// garbage collection attribute. 53364fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian/// 5337ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCallQualifiers::GC ASTContext::getObjCGCAttrKind(QualType Ty) const { 53384e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (getLangOpts().getGC() == LangOptions::NonGC) 5339ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall return Qualifiers::GCNone; 5340ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall 53414e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie assert(getLangOpts().ObjC1); 5342ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall Qualifiers::GC GCAttrs = Ty.getObjCGCAttr(); 5343ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall 5344ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // Default behaviour under objective-C's gc is for ObjC pointers 5345ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // (or pointers to them) be treated as though they were declared 5346ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // as __strong. 5347ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall if (GCAttrs == Qualifiers::GCNone) { 5348ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType()) 5349ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall return Qualifiers::Strong; 5350ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall else if (Ty->isPointerType()) 5351ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall return getObjCGCAttrKind(Ty->getAs<PointerType>()->getPointeeType()); 5352ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall } else { 5353ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // It's not valid to set GC attributes on anything that isn't a 5354ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall // pointer. 5355ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall#ifndef NDEBUG 5356ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall QualType CT = Ty->getCanonicalTypeInternal(); 5357ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall while (const ArrayType *AT = dyn_cast<ArrayType>(CT)) 5358ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall CT = AT->getElementType(); 5359ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall assert(CT->isAnyPointerType() || CT->isBlockPointerType()); 5360ae278a3a57595349a411f6474938d4dd1b263a0eJohn McCall#endif 53614fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian } 5362b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris Lattner return GCAttrs; 53634fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian} 53644fd83ea566f4a0c083001c84b75da6cc8c99c1d6Fariborz Jahanian 53656ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner//===----------------------------------------------------------------------===// 53666ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner// Type Compatibility Testing 53676ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner//===----------------------------------------------------------------------===// 5368770951b5bb6028a8d326ddb4a13cef7d4a128162Chris Lattner 53691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// areCompatVectorTypes - Return true if the two specified vector types are 53706ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner/// compatible. 53716ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattnerstatic bool areCompatVectorTypes(const VectorType *LHS, 53726ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner const VectorType *RHS) { 5373467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified()); 53746ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner return LHS->getElementType() == RHS->getElementType() && 537561710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner LHS->getNumElements() == RHS->getNumElements(); 53766ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner} 53776ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner 5378255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregorbool ASTContext::areCompatibleVectorTypes(QualType FirstVec, 5379255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor QualType SecondVec) { 5380255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor assert(FirstVec->isVectorType() && "FirstVec should be a vector type"); 5381255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor assert(SecondVec->isVectorType() && "SecondVec should be a vector type"); 5382255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 5383255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor if (hasSameUnqualifiedType(FirstVec, SecondVec)) 5384255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor return true; 5385255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 5386f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson // Treat Neon vector types and most AltiVec vector types as if they are the 5387f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson // equivalent GCC vector types. 5388255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor const VectorType *First = FirstVec->getAs<VectorType>(); 5389255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor const VectorType *Second = SecondVec->getAs<VectorType>(); 5390f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson if (First->getNumElements() == Second->getNumElements() && 5391255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor hasSameType(First->getElementType(), Second->getElementType()) && 5392f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson First->getVectorKind() != VectorType::AltiVecPixel && 5393f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson First->getVectorKind() != VectorType::AltiVecBool && 5394f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson Second->getVectorKind() != VectorType::AltiVecPixel && 5395f69eb7cf8e616b5aad7911ec6f79b24b0a009227Bob Wilson Second->getVectorKind() != VectorType::AltiVecBool) 5396255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor return true; 5397255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 5398255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor return false; 5399255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor} 5400255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor 54014084c306635b70f37029dca938444e6013f08684Steve Naroff//===----------------------------------------------------------------------===// 54024084c306635b70f37029dca938444e6013f08684Steve Naroff// ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's. 54034084c306635b70f37029dca938444e6013f08684Steve Naroff//===----------------------------------------------------------------------===// 54044084c306635b70f37029dca938444e6013f08684Steve Naroff 54054084c306635b70f37029dca938444e6013f08684Steve Naroff/// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the 54064084c306635b70f37029dca938444e6013f08684Steve Naroff/// inheritance hierarchy of 'rProto'. 54074ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadbool 54084ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTContext::ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto, 54094ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad ObjCProtocolDecl *rProto) const { 54103fc73ee0c613715ebce78e30b4d050ea715a007dDouglas Gregor if (declaresSameEntity(lProto, rProto)) 541114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return true; 54124084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCProtocolDecl::protocol_iterator PI = rProto->protocol_begin(), 54134084c306635b70f37029dca938444e6013f08684Steve Naroff E = rProto->protocol_end(); PI != E; ++PI) 54144084c306635b70f37029dca938444e6013f08684Steve Naroff if (ProtocolCompatibleWithProtocol(lProto, *PI)) 54154084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 54164084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 54174084c306635b70f37029dca938444e6013f08684Steve Naroff} 541814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 54194084c306635b70f37029dca938444e6013f08684Steve Naroff/// QualifiedIdConformsQualifiedId - compare id<p,...> with id<p1,...> 54204084c306635b70f37029dca938444e6013f08684Steve Naroff/// return true if lhs's protocols conform to rhs's protocol; false 54214084c306635b70f37029dca938444e6013f08684Steve Naroff/// otherwise. 54224084c306635b70f37029dca938444e6013f08684Steve Naroffbool ASTContext::QualifiedIdConformsQualifiedId(QualType lhs, QualType rhs) { 54234084c306635b70f37029dca938444e6013f08684Steve Naroff if (lhs->isObjCQualifiedIdType() && rhs->isObjCQualifiedIdType()) 54244084c306635b70f37029dca938444e6013f08684Steve Naroff return ObjCQualifiedIdTypesAreCompatible(lhs, rhs, false); 54254084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 54264084c306635b70f37029dca938444e6013f08684Steve Naroff} 54274084c306635b70f37029dca938444e6013f08684Steve Naroff 5428a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian/// ObjCQualifiedClassTypesAreCompatible - compare Class<p,...> and 5429a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian/// Class<p1, ...>. 5430a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanianbool ASTContext::ObjCQualifiedClassTypesAreCompatible(QualType lhs, 5431a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian QualType rhs) { 5432a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian const ObjCObjectPointerType *lhsQID = lhs->getAs<ObjCObjectPointerType>(); 5433a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>(); 5434a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian assert ((lhsQID && rhsOPT) && "ObjCQualifiedClassTypesAreCompatible"); 5435a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 5436a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 5437a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian E = lhsQID->qual_end(); I != E; ++I) { 5438a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian bool match = false; 5439a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian ObjCProtocolDecl *lhsProto = *I; 5440a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(), 5441a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian E = rhsOPT->qual_end(); J != E; ++J) { 5442a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian ObjCProtocolDecl *rhsProto = *J; 5443a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto)) { 5444a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian match = true; 5445a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian break; 5446a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian } 5447a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian } 5448a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian if (!match) 5449a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian return false; 5450a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian } 5451a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian return true; 5452a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian} 5453a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 54544084c306635b70f37029dca938444e6013f08684Steve Naroff/// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an 54554084c306635b70f37029dca938444e6013f08684Steve Naroff/// ObjCQualifiedIDType. 54564084c306635b70f37029dca938444e6013f08684Steve Naroffbool ASTContext::ObjCQualifiedIdTypesAreCompatible(QualType lhs, QualType rhs, 54574084c306635b70f37029dca938444e6013f08684Steve Naroff bool compare) { 54584084c306635b70f37029dca938444e6013f08684Steve Naroff // Allow id<P..> and an 'id' or void* type in all cases. 54591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (lhs->isVoidPointerType() || 54604084c306635b70f37029dca938444e6013f08684Steve Naroff lhs->isObjCIdType() || lhs->isObjCClassType()) 54614084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 54621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump else if (rhs->isVoidPointerType() || 54634084c306635b70f37029dca938444e6013f08684Steve Naroff rhs->isObjCIdType() || rhs->isObjCClassType()) 54644084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 54654084c306635b70f37029dca938444e6013f08684Steve Naroff 54664084c306635b70f37029dca938444e6013f08684Steve Naroff if (const ObjCObjectPointerType *lhsQID = lhs->getAsObjCQualifiedIdType()) { 5467183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>(); 54681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 54694084c306635b70f37029dca938444e6013f08684Steve Naroff if (!rhsOPT) return false; 54701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 54714084c306635b70f37029dca938444e6013f08684Steve Naroff if (rhsOPT->qual_empty()) { 54721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the RHS is a unqualified interface pointer "NSString*", 54734084c306635b70f37029dca938444e6013f08684Steve Naroff // make sure we check the class hierarchy. 54744084c306635b70f37029dca938444e6013f08684Steve Naroff if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) { 54754084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 54764084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsQID->qual_end(); I != E; ++I) { 54774084c306635b70f37029dca938444e6013f08684Steve Naroff // when comparing an id<P> on lhs with a static type on rhs, 54784084c306635b70f37029dca938444e6013f08684Steve Naroff // see if static class implements all of id's protocols, directly or 54794084c306635b70f37029dca938444e6013f08684Steve Naroff // through its super class and categories. 54800fd8904c5f71a11d29f67716c3ebdf7ad1c855fbFariborz Jahanian if (!rhsID->ClassImplementsProtocol(*I, true)) 54814084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 54824084c306635b70f37029dca938444e6013f08684Steve Naroff } 54834084c306635b70f37029dca938444e6013f08684Steve Naroff } 54844084c306635b70f37029dca938444e6013f08684Steve Naroff // If there are no qualifiers and no interface, we have an 'id'. 54854084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 54864084c306635b70f37029dca938444e6013f08684Steve Naroff } 54871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Both the right and left sides have qualifiers. 54884084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 54894084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsQID->qual_end(); I != E; ++I) { 54904084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *lhsProto = *I; 54914084c306635b70f37029dca938444e6013f08684Steve Naroff bool match = false; 5492de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff 5493de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff // when comparing an id<P> on lhs with a static type on rhs, 5494de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff // see if static class implements all of id's protocols, directly or 5495de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff // through its super class and categories. 54964084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(), 54974084c306635b70f37029dca938444e6013f08684Steve Naroff E = rhsOPT->qual_end(); J != E; ++J) { 54984084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *rhsProto = *J; 54994084c306635b70f37029dca938444e6013f08684Steve Naroff if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 55004084c306635b70f37029dca938444e6013f08684Steve Naroff (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 55014084c306635b70f37029dca938444e6013f08684Steve Naroff match = true; 55028f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff break; 55038f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff } 5504de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff } 55051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If the RHS is a qualified interface pointer "NSString<P>*", 55064084c306635b70f37029dca938444e6013f08684Steve Naroff // make sure we check the class hierarchy. 55074084c306635b70f37029dca938444e6013f08684Steve Naroff if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) { 55084084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 55094084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsQID->qual_end(); I != E; ++I) { 55104084c306635b70f37029dca938444e6013f08684Steve Naroff // when comparing an id<P> on lhs with a static type on rhs, 55114084c306635b70f37029dca938444e6013f08684Steve Naroff // see if static class implements all of id's protocols, directly or 55124084c306635b70f37029dca938444e6013f08684Steve Naroff // through its super class and categories. 55130fd8904c5f71a11d29f67716c3ebdf7ad1c855fbFariborz Jahanian if (rhsID->ClassImplementsProtocol(*I, true)) { 55144084c306635b70f37029dca938444e6013f08684Steve Naroff match = true; 55154084c306635b70f37029dca938444e6013f08684Steve Naroff break; 55164084c306635b70f37029dca938444e6013f08684Steve Naroff } 55174084c306635b70f37029dca938444e6013f08684Steve Naroff } 55184084c306635b70f37029dca938444e6013f08684Steve Naroff } 55194084c306635b70f37029dca938444e6013f08684Steve Naroff if (!match) 5520de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff return false; 5521de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff } 55221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5523de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff return true; 5524de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff } 55251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 55264084c306635b70f37029dca938444e6013f08684Steve Naroff const ObjCObjectPointerType *rhsQID = rhs->getAsObjCQualifiedIdType(); 55274084c306635b70f37029dca938444e6013f08684Steve Naroff assert(rhsQID && "One of the LHS/RHS should be id<x>"); 55284084c306635b70f37029dca938444e6013f08684Steve Naroff 55291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const ObjCObjectPointerType *lhsOPT = 55304084c306635b70f37029dca938444e6013f08684Steve Naroff lhs->getAsObjCInterfacePointerType()) { 5531de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // If both the right and left sides have qualifiers. 55324084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator I = lhsOPT->qual_begin(), 55334084c306635b70f37029dca938444e6013f08684Steve Naroff E = lhsOPT->qual_end(); I != E; ++I) { 55344084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *lhsProto = *I; 55354084c306635b70f37029dca938444e6013f08684Steve Naroff bool match = false; 55364084c306635b70f37029dca938444e6013f08684Steve Naroff 5537de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // when comparing an id<P> on rhs with a static type on lhs, 55384084c306635b70f37029dca938444e6013f08684Steve Naroff // see if static class implements all of id's protocols, directly or 55394084c306635b70f37029dca938444e6013f08684Steve Naroff // through its super class and categories. 5540de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // First, lhs protocols in the qualifier list must be found, direct 5541de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // or indirect in rhs's qualifier list or it is a mismatch. 55424084c306635b70f37029dca938444e6013f08684Steve Naroff for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(), 55434084c306635b70f37029dca938444e6013f08684Steve Naroff E = rhsQID->qual_end(); J != E; ++J) { 55444084c306635b70f37029dca938444e6013f08684Steve Naroff ObjCProtocolDecl *rhsProto = *J; 55454084c306635b70f37029dca938444e6013f08684Steve Naroff if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 55464084c306635b70f37029dca938444e6013f08684Steve Naroff (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 55474084c306635b70f37029dca938444e6013f08684Steve Naroff match = true; 55484084c306635b70f37029dca938444e6013f08684Steve Naroff break; 55494084c306635b70f37029dca938444e6013f08684Steve Naroff } 55504084c306635b70f37029dca938444e6013f08684Steve Naroff } 55514084c306635b70f37029dca938444e6013f08684Steve Naroff if (!match) 55524084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 55534084c306635b70f37029dca938444e6013f08684Steve Naroff } 5554de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian 5555de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // Static class's protocols, or its super class or category protocols 5556de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // must be found, direct or indirect in rhs's qualifier list or it is a mismatch. 5557de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (ObjCInterfaceDecl *lhsID = lhsOPT->getInterfaceDecl()) { 5558de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols; 5559de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian CollectInheritedProtocols(lhsID, LHSInheritedProtocols); 5560de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // This is rather dubious but matches gcc's behavior. If lhs has 5561de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // no type qualifier and its class has no static protocol(s) 5562de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian // assume that it is mismatch. 5563de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (LHSInheritedProtocols.empty() && lhsOPT->qual_empty()) 5564de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian return false; 5565de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 5566de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian LHSInheritedProtocols.begin(), 5567de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian E = LHSInheritedProtocols.end(); I != E; ++I) { 5568de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian bool match = false; 5569de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian ObjCProtocolDecl *lhsProto = (*I); 5570de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(), 5571de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian E = rhsQID->qual_end(); J != E; ++J) { 5572de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian ObjCProtocolDecl *rhsProto = *J; 5573de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 5574de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 5575de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian match = true; 5576de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian break; 5577de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 5578de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 5579de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian if (!match) 5580de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian return false; 5581de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 5582de5b17ea3c74d2844ed035a1edfa6479866139b5Fariborz Jahanian } 55834084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 55844084c306635b70f37029dca938444e6013f08684Steve Naroff } 55854084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 55864084c306635b70f37029dca938444e6013f08684Steve Naroff} 55874084c306635b70f37029dca938444e6013f08684Steve Naroff 55884084c306635b70f37029dca938444e6013f08684Steve Naroff/// canAssignObjCInterfaces - Return true if the two interface types are 55894084c306635b70f37029dca938444e6013f08684Steve Naroff/// compatible for assignment from RHS to LHS. This handles validation of any 55904084c306635b70f37029dca938444e6013f08684Steve Naroff/// protocol qualifiers on the LHS or RHS. 55914084c306635b70f37029dca938444e6013f08684Steve Naroff/// 55924084c306635b70f37029dca938444e6013f08684Steve Naroffbool ASTContext::canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, 55934084c306635b70f37029dca938444e6013f08684Steve Naroff const ObjCObjectPointerType *RHSOPT) { 5594c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* LHS = LHSOPT->getObjectType(); 5595c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* RHS = RHSOPT->getObjectType(); 5596c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 55974084c306635b70f37029dca938444e6013f08684Steve Naroff // If either type represents the built-in 'id' or 'Class' types, return true. 5598c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHS->isObjCUnqualifiedIdOrClass() || 5599c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall RHS->isObjCUnqualifiedIdOrClass()) 56004084c306635b70f37029dca938444e6013f08684Steve Naroff return true; 56014084c306635b70f37029dca938444e6013f08684Steve Naroff 5602c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHS->isObjCQualifiedId() || RHS->isObjCQualifiedId()) 56031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0), 56041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType(RHSOPT,0), 56054084c306635b70f37029dca938444e6013f08684Steve Naroff false); 5606a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 5607a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian if (LHS->isObjCQualifiedClass() && RHS->isObjCQualifiedClass()) 5608a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian return ObjCQualifiedClassTypesAreCompatible(QualType(LHSOPT,0), 5609a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian QualType(RHSOPT,0)); 5610a8f8dac6a29f6d33474a38a32ce9dd859b696da9Fariborz Jahanian 5611c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // If we have 2 user-defined types, fall into that path. 5612c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHS->getInterface() && RHS->getInterface()) 56134084c306635b70f37029dca938444e6013f08684Steve Naroff return canAssignObjCInterfaces(LHS, RHS); 56141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 56154084c306635b70f37029dca938444e6013f08684Steve Naroff return false; 561614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff} 561714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 5618132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// canAssignObjCInterfacesInBlockPointer - This routine is specifically written 5619fc8f0e14ad142ed811e90fbd9a30e419e301c717Chris Lattner/// for providing type-safety for objective-c pointers used to pass/return 5620132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// arguments in block literals. When passed as arguments, passing 'A*' where 5621132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// 'id' is expected is not OK. Passing 'Sub *" where 'Super *" is expected is 5622132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian/// not OK. For the return type, the opposite is not OK. 5623132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanianbool ASTContext::canAssignObjCInterfacesInBlockPointer( 5624132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian const ObjCObjectPointerType *LHSOPT, 5625a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian const ObjCObjectPointerType *RHSOPT, 5626a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian bool BlockReturnType) { 5627a98344869c278295f38e106583906377520079b8Fariborz Jahanian if (RHSOPT->isObjCBuiltinType() || LHSOPT->isObjCIdType()) 5628132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return true; 5629132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5630132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHSOPT->isObjCBuiltinType()) { 5631132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return RHSOPT->isObjCBuiltinType() || RHSOPT->isObjCQualifiedIdType(); 5632132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 5633132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5634a98344869c278295f38e106583906377520079b8Fariborz Jahanian if (LHSOPT->isObjCQualifiedIdType() || RHSOPT->isObjCQualifiedIdType()) 5635132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0), 5636132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian QualType(RHSOPT,0), 5637132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian false); 5638132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5639132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType(); 5640132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType(); 5641132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHS && RHS) { // We have 2 user-defined types. 5642132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHS != RHS) { 5643132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (LHS->getDecl()->isSuperClassOf(RHS->getDecl())) 5644a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian return BlockReturnType; 5645132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (RHS->getDecl()->isSuperClassOf(LHS->getDecl())) 5646a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian return !BlockReturnType; 5647132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 5648132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian else 5649132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return true; 5650132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 5651132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return false; 5652132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian} 5653132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 5654e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// getIntersectionOfProtocols - This routine finds the intersection of set 5655e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// of protocols inherited from two distinct objective-c pointer objects. 5656e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// It is used to build composite qualifier list of the composite type of 5657e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian/// the conditional expression involving two objective-c pointer objects. 5658e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanianstatic 5659e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanianvoid getIntersectionOfProtocols(ASTContext &Context, 5660e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian const ObjCObjectPointerType *LHSOPT, 5661e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian const ObjCObjectPointerType *RHSOPT, 56625f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVectorImpl<ObjCProtocolDecl *> &IntersectionOfProtocols) { 5663e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5664c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* LHS = LHSOPT->getObjectType(); 5665c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* RHS = RHSOPT->getObjectType(); 5666c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(LHS->getInterface() && "LHS must have an interface base"); 5667c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(RHS->getInterface() && "RHS must have an interface base"); 5668e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5669e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocolSet; 5670e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian unsigned LHSNumProtocols = LHS->getNumProtocols(); 5671e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (LHSNumProtocols > 0) 5672e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian InheritedProtocolSet.insert(LHS->qual_begin(), LHS->qual_end()); 5673e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian else { 5674432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols; 5675c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Context.CollectInheritedProtocols(LHS->getInterface(), 5676c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall LHSInheritedProtocols); 5677e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian InheritedProtocolSet.insert(LHSInheritedProtocols.begin(), 5678e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian LHSInheritedProtocols.end()); 5679e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 5680e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5681e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian unsigned RHSNumProtocols = RHS->getNumProtocols(); 5682e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (RHSNumProtocols > 0) { 5683cb421fa690da545b58a720abe5f1c49b166dbde7Dan Gohman ObjCProtocolDecl **RHSProtocols = 5684cb421fa690da545b58a720abe5f1c49b166dbde7Dan Gohman const_cast<ObjCProtocolDecl **>(RHS->qual_begin()); 5685e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (unsigned i = 0; i < RHSNumProtocols; ++i) 5686e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (InheritedProtocolSet.count(RHSProtocols[i])) 5687e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian IntersectionOfProtocols.push_back(RHSProtocols[i]); 56883060178ad9df29789505c1e6debcfc80a3a13587Chad Rosier } else { 5689432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> RHSInheritedProtocols; 5690c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Context.CollectInheritedProtocols(RHS->getInterface(), 5691c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall RHSInheritedProtocols); 5692432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 5693432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian RHSInheritedProtocols.begin(), 5694432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian E = RHSInheritedProtocols.end(); I != E; ++I) 5695432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian if (InheritedProtocolSet.count((*I))) 5696432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian IntersectionOfProtocols.push_back((*I)); 5697e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 5698e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian} 5699e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 5700db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// areCommonBaseCompatible - Returns common base class of the two classes if 5701db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// one found. Note that this is O'2 algorithm. But it will be called as the 5702db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// last type comparison in a ?-exp of ObjC pointer types before a 5703db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian/// warning is issued. So, its invokation is extremely rare. 5704db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz JahanianQualType ASTContext::areCommonBaseCompatible( 5705c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectPointerType *Lptr, 5706c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectPointerType *Rptr) { 5707c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType *LHS = Lptr->getObjectType(); 5708c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType *RHS = Rptr->getObjectType(); 5709c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCInterfaceDecl* LDecl = LHS->getInterface(); 5710c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCInterfaceDecl* RDecl = RHS->getInterface(); 571160ef308e51c71b760d7f598c1b763ceb7b768148Douglas Gregor if (!LDecl || !RDecl || (declaresSameEntity(LDecl, RDecl))) 5712db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian return QualType(); 5713db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian 57147c2bdcb4d30f2d370b4367664e6a11b075ce2cb3Fariborz Jahanian do { 5715c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall LHS = cast<ObjCInterfaceType>(getObjCInterfaceType(LDecl)); 5716e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian if (canAssignObjCInterfaces(LHS, RHS)) { 57175f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<ObjCProtocolDecl *, 8> Protocols; 5718c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall getIntersectionOfProtocols(*this, Lptr, Rptr, Protocols); 5719c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 5720c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall QualType Result = QualType(LHS, 0); 5721c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!Protocols.empty()) 5722c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Result = getObjCObjectType(Result, Protocols.data(), Protocols.size()); 5723c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Result = getObjCObjectPointerType(Result); 5724c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return Result; 5725e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 57267c2bdcb4d30f2d370b4367664e6a11b075ce2cb3Fariborz Jahanian } while ((LDecl = LDecl->getSuperClass())); 5727db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian 5728db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian return QualType(); 5729db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian} 5730db07b3f7cdcb505329c1280d7cf70791739a7cadFariborz Jahanian 5731c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCallbool ASTContext::canAssignObjCInterfaces(const ObjCObjectType *LHS, 5732c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType *RHS) { 5733c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(LHS->getInterface() && "LHS is not an interface type"); 5734c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall assert(RHS->getInterface() && "RHS is not an interface type"); 5735c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 57366ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // Verify that the base decls are compatible: the RHS must be a subclass of 57376ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // the LHS. 5738c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!LHS->getInterface()->isSuperClassOf(RHS->getInterface())) 57396ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner return false; 57401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 57416ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // RHS must have a superset of the protocols in the LHS. If the LHS is not 57426ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner // protocol qualified at all, then we are good. 5743c15cb2af27514ecc879daba9aa01389c5203685dSteve Naroff if (LHS->getNumProtocols() == 0) 57446ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner return true; 57451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5746b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // Okay, we know the LHS has protocol qualifiers. If the RHS doesn't, 5747b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // more detailed analysis is required. 5748b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (RHS->getNumProtocols() == 0) { 5749b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // OK, if LHS is a superclass of RHS *and* 5750b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // this superclass is assignment compatible with LHS. 5751b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // false otherwise. 5752627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian bool IsSuperClass = 5753627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian LHS->getInterface()->isSuperClassOf(RHS->getInterface()); 5754627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian if (IsSuperClass) { 5755b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // OK if conversion of LHS to SuperClass results in narrowing of types 5756b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // ; i.e., SuperClass may implement at least one of the protocols 5757b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // in LHS's protocol list. Example, SuperObj<P1> = lhs<P1,P2> is ok. 5758b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // But not SuperObj<P1,P2,P3> = lhs<P1,P2>. 5759b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian llvm::SmallPtrSet<ObjCProtocolDecl *, 8> SuperClassInheritedProtocols; 5760627788c29976fbeb4ad47bcfcb3576889070e357Fariborz Jahanian CollectInheritedProtocols(RHS->getInterface(), SuperClassInheritedProtocols); 5761b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian // If super class has no protocols, it is not a match. 5762b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (SuperClassInheritedProtocols.empty()) 5763b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return false; 5764b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian 5765b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian for (ObjCObjectType::qual_iterator LHSPI = LHS->qual_begin(), 5766b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian LHSPE = LHS->qual_end(); 5767b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian LHSPI != LHSPE; LHSPI++) { 5768b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian bool SuperImplementsProtocol = false; 5769b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian ObjCProtocolDecl *LHSProto = (*LHSPI); 5770b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian 5771b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 5772b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian SuperClassInheritedProtocols.begin(), 5773b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian E = SuperClassInheritedProtocols.end(); I != E; ++I) { 5774b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian ObjCProtocolDecl *SuperClassProto = (*I); 5775b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (SuperClassProto->lookupProtocolNamed(LHSProto->getIdentifier())) { 5776b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian SuperImplementsProtocol = true; 5777b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian break; 5778b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5779b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5780b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian if (!SuperImplementsProtocol) 5781b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return false; 5782b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5783b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return true; 5784b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 5785b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian return false; 5786b7bc34a83aff8af09f2a78aa6d1dcafe18ad8619Fariborz Jahanian } 57871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5788c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall for (ObjCObjectType::qual_iterator LHSPI = LHS->qual_begin(), 5789c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall LHSPE = LHS->qual_end(); 579091b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff LHSPI != LHSPE; LHSPI++) { 579191b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff bool RHSImplementsProtocol = false; 579291b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff 579391b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // If the RHS doesn't implement the protocol on the left, the types 579491b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // are incompatible. 5795c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall for (ObjCObjectType::qual_iterator RHSPI = RHS->qual_begin(), 5796c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall RHSPE = RHS->qual_end(); 57978f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff RHSPI != RHSPE; RHSPI++) { 57988f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff if ((*RHSPI)->lookupProtocolNamed((*LHSPI)->getIdentifier())) { 579991b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff RHSImplementsProtocol = true; 58008f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff break; 58018f16756441450ed9fb39316e47d107fc2a1ef35bSteve Naroff } 580291b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff } 580391b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // FIXME: For better diagnostics, consider passing back the protocol name. 580491b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff if (!RHSImplementsProtocol) 580591b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff return false; 580691b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff } 580791b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff // The RHS implements all protocols listed on the LHS. 580891b0b0cf6b537cbcbca0038c7032f87161a41d31Steve Naroff return true; 58096ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner} 58106ac46a4a521366d7ab36ebe2ce4e624ab96b06f9Chris Lattner 5811389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroffbool ASTContext::areComparableObjCPointerTypes(QualType LHS, QualType RHS) { 5812389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff // get the "pointed to" types 5813183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const ObjCObjectPointerType *LHSOPT = LHS->getAs<ObjCObjectPointerType>(); 5814183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const ObjCObjectPointerType *RHSOPT = RHS->getAs<ObjCObjectPointerType>(); 58151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 581614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (!LHSOPT || !RHSOPT) 5817389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff return false; 581814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 581914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return canAssignObjCInterfaces(LHSOPT, RHSOPT) || 582014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff canAssignObjCInterfaces(RHSOPT, LHSOPT); 5821389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff} 5822389bf46ae41241a656ed71b00ac2177d7f385651Steve Naroff 5823569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregorbool ASTContext::canBindObjCObjectType(QualType To, QualType From) { 5824569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor return canAssignObjCInterfaces( 5825569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor getObjCObjectPointerType(To)->getAs<ObjCObjectPointerType>(), 5826569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor getObjCObjectPointerType(From)->getAs<ObjCObjectPointerType>()); 5827569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor} 5828569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor 58291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible, 5830ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff/// both shall have the identically qualified version of a compatible type. 58311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// C99 6.2.7p1: Two types have compatible types if their types are the 5832ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff/// same. See 6.7.[2,3,5] for additional rules. 5833447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregorbool ASTContext::typesAreCompatible(QualType LHS, QualType RHS, 5834447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool CompareUnqualified) { 58354e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (getLangOpts().CPlusPlus) 58360e709abafbd939326850501f795cc7a92c88a354Douglas Gregor return hasSameType(LHS, RHS); 58370e709abafbd939326850501f795cc7a92c88a354Douglas Gregor 5838447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor return !mergeTypes(LHS, RHS, false, CompareUnqualified).isNull(); 58393d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman} 58403d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 5841c286f3835eb6001c61664cef5d610dfaf80a6e9bFariborz Jahanianbool ASTContext::propertyTypesAreCompatible(QualType LHS, QualType RHS) { 584282378391dfc3b2fc22f63dbf1552bd9aed39dc42Fariborz Jahanian return typesAreCompatible(LHS, RHS); 5843c286f3835eb6001c61664cef5d610dfaf80a6e9bFariborz Jahanian} 5844c286f3835eb6001c61664cef5d610dfaf80a6e9bFariborz Jahanian 5845132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanianbool ASTContext::typesAreBlockPointerCompatible(QualType LHS, QualType RHS) { 5846132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return !mergeTypes(LHS, RHS, true).isNull(); 5847132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian} 5848132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian 58494846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// mergeTransparentUnionType - if T is a transparent union type and a member 58504846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// of T is compatible with SubType, return the merged type, else return 58514846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// QualType() 58524846675e0e42d1802b0ffd8972a45e72aeb3758dPeter CollingbourneQualType ASTContext::mergeTransparentUnionType(QualType T, QualType SubType, 58534846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool OfBlockPointer, 58544846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool Unqualified) { 58554846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (const RecordType *UT = T->getAsUnionType()) { 58564846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne RecordDecl *UD = UT->getDecl(); 58574846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (UD->hasAttr<TransparentUnionAttr>()) { 58584846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne for (RecordDecl::field_iterator it = UD->field_begin(), 58594846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne itend = UD->field_end(); it != itend; ++it) { 5860f91d7572ee7fa6f2926c8e7e816039a1154a59f8Peter Collingbourne QualType ET = it->getType().getUnqualifiedType(); 58614846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType MT = mergeTypes(ET, SubType, OfBlockPointer, Unqualified); 58624846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (!MT.isNull()) 58634846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return MT; 58644846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne } 58654846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne } 58664846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne } 58674846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 58684846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return QualType(); 58694846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne} 58704846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 58714846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// mergeFunctionArgumentTypes - merge two types which appear as function 58724846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne/// argument types 58734846675e0e42d1802b0ffd8972a45e72aeb3758dPeter CollingbourneQualType ASTContext::mergeFunctionArgumentTypes(QualType lhs, QualType rhs, 58744846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool OfBlockPointer, 58754846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne bool Unqualified) { 58764846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne // GNU extension: two types are compatible if they appear as a function 58774846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne // argument, one of the types is a transparent union type and the other 58784846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne // type is compatible with a union member 58794846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType lmerge = mergeTransparentUnionType(lhs, rhs, OfBlockPointer, 58804846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne Unqualified); 58814846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (!lmerge.isNull()) 58824846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return lmerge; 58834846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 58844846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType rmerge = mergeTransparentUnionType(rhs, lhs, OfBlockPointer, 58854846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne Unqualified); 58864846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne if (!rmerge.isNull()) 58874846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return rmerge; 58884846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 58894846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne return mergeTypes(lhs, rhs, OfBlockPointer, Unqualified); 58904846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne} 58914846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne 5892132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz JahanianQualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs, 5893447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool OfBlockPointer, 5894447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool Unqualified) { 5895183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const FunctionType *lbase = lhs->getAs<FunctionType>(); 5896183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const FunctionType *rbase = rhs->getAs<FunctionType>(); 589772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase); 589872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase); 58993d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman bool allLTypes = true; 59003d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman bool allRTypes = true; 59013d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 59023d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Check return type 5903132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian QualType retType; 5904d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian if (OfBlockPointer) { 5905d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian QualType RHS = rbase->getResultType(); 5906d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian QualType LHS = lbase->getResultType(); 5907d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian bool UnqualifiedResult = Unqualified; 5908d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian if (!UnqualifiedResult) 5909d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian UnqualifiedResult = (!RHS.hasQualifiers() && LHS.hasQualifiers()); 5910a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian retType = mergeTypes(LHS, RHS, true, UnqualifiedResult, true); 5911d263fd1451299b1e5f5f1acb2bb13b0a4119aee8Fariborz Jahanian } 5912132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian else 59138cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall retType = mergeTypes(lbase->getResultType(), rbase->getResultType(), false, 59148cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall Unqualified); 59153d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (retType.isNull()) return QualType(); 5916447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5917447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) 5918447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor retType = retType.getUnqualifiedType(); 5919447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5920447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor CanQualType LRetType = getCanonicalType(lbase->getResultType()); 5921447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor CanQualType RRetType = getCanonicalType(rbase->getResultType()); 5922447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5923447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LRetType = LRetType.getUnqualifiedType(); 5924447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RRetType = RRetType.getUnqualifiedType(); 5925447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 5926447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5927447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (getCanonicalType(retType) != LRetType) 592861710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allLTypes = false; 5929447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (getCanonicalType(retType) != RRetType) 593061710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allRTypes = false; 59318cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 59326a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // FIXME: double check this 59336a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // FIXME: should we error if lbase->getRegParmAttr() != 0 && 59346a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // rbase->getRegParmAttr() != 0 && 59356a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar // lbase->getRegParmAttr() != rbase->getRegParmAttr()? 5936264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo lbaseInfo = lbase->getExtInfo(); 5937264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo rbaseInfo = rbase->getExtInfo(); 59388cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 59398cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall // Compatible functions must have compatible calling conventions 59408cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall if (!isSameCallConv(lbaseInfo.getCC(), rbaseInfo.getCC())) 59418cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall return QualType(); 59428cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 59438cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall // Regparm is part of the calling convention. 5944a49218e17bcbb1acde0245773173e2c0c42f4f19Eli Friedman if (lbaseInfo.getHasRegParm() != rbaseInfo.getHasRegParm()) 5945a49218e17bcbb1acde0245773173e2c0c42f4f19Eli Friedman return QualType(); 59468cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall if (lbaseInfo.getRegParm() != rbaseInfo.getRegParm()) 59478cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall return QualType(); 59488cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall 5949f85e193739c953358c865005855253af4f68a497John McCall if (lbaseInfo.getProducesResult() != rbaseInfo.getProducesResult()) 5950f85e193739c953358c865005855253af4f68a497John McCall return QualType(); 5951f85e193739c953358c865005855253af4f68a497John McCall 595253c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian // functypes which return are preferred over those that do not. 595353c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian if (lbaseInfo.getNoReturn() && !rbaseInfo.getNoReturn()) 59546a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar allLTypes = false; 595553c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian else if (!lbaseInfo.getNoReturn() && rbaseInfo.getNoReturn()) 59566a15c8586cc3e5d6e01c4c4e8b4374584569b58fDaniel Dunbar allRTypes = false; 595753c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian // FIXME: some uses, e.g. conditional exprs, really want this to be 'both'. 595853c8167d7a007daae87f342c0fedd03f1dcf1b62Fariborz Jahanian bool NoReturn = lbaseInfo.getNoReturn() || rbaseInfo.getNoReturn(); 59591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5960f85e193739c953358c865005855253af4f68a497John McCall FunctionType::ExtInfo einfo = lbaseInfo.withNoReturn(NoReturn); 5961e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 59623d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto && rproto) { // two C99 style function prototypes 5963465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl assert(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() && 5964465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl "C++ shouldn't be here"); 59653d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman unsigned lproto_nargs = lproto->getNumArgs(); 59663d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman unsigned rproto_nargs = rproto->getNumArgs(); 59673d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 59683d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Compatible functions must have the same number of arguments 59693d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto_nargs != rproto_nargs) 59703d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 59713d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 59723d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Variadic and non-variadic functions aren't compatible 59733d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto->isVariadic() != rproto->isVariadic()) 59743d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 59753d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 59767fb5e4888221cd36652d078c6b171ac55e7f406dArgyrios Kyrtzidis if (lproto->getTypeQuals() != rproto->getTypeQuals()) 59777fb5e4888221cd36652d078c6b171ac55e7f406dArgyrios Kyrtzidis return QualType(); 59787fb5e4888221cd36652d078c6b171ac55e7f406dArgyrios Kyrtzidis 597978213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (LangOpts.ObjCAutoRefCount && 598078213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian !FunctionTypesMatchOnNSConsumedAttrs(rproto, lproto)) 598178213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return QualType(); 598278213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian 59833d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Check argument compatibility 59845f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 10> types; 59853d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman for (unsigned i = 0; i < lproto_nargs; i++) { 59863d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType largtype = lproto->getArgType(i).getUnqualifiedType(); 59873d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType rargtype = rproto->getArgType(i).getUnqualifiedType(); 59884846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne QualType argtype = mergeFunctionArgumentTypes(largtype, rargtype, 59894846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne OfBlockPointer, 59904846675e0e42d1802b0ffd8972a45e72aeb3758dPeter Collingbourne Unqualified); 59913d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (argtype.isNull()) return QualType(); 5992447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 5993447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) 5994447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor argtype = argtype.getUnqualifiedType(); 5995447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 59963d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman types.push_back(argtype); 5997447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 5998447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor largtype = largtype.getUnqualifiedType(); 5999447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor rargtype = rargtype.getUnqualifiedType(); 6000447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 6001447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 600261710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (getCanonicalType(argtype) != getCanonicalType(largtype)) 600361710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allLTypes = false; 600461710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (getCanonicalType(argtype) != getCanonicalType(rargtype)) 600561710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner allRTypes = false; 60063d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 600778213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian 60083d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allLTypes) return lhs; 60093d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allRTypes) return rhs; 6010e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 6011e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI = lproto->getExtProtoInfo(); 6012e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall EPI.ExtInfo = einfo; 6013e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall return getFunctionType(retType, types.begin(), types.size(), EPI); 60143d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 60153d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 60163d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (lproto) allRTypes = false; 60173d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (rproto) allLTypes = false; 60183d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 601972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor const FunctionProtoType *proto = lproto ? lproto : rproto; 60203d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (proto) { 6021465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl assert(!proto->hasExceptionSpec() && "C++ shouldn't be here"); 60223d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (proto->isVariadic()) return QualType(); 60233d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Check that the types are compatible with the types that 60243d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // would result from default argument promotions (C99 6.7.5.3p15). 60253d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // The only types actually affected are promotable integer 60263d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // types and floats, which would be passed as a different 60273d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // type depending on whether the prototype is visible. 60283d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman unsigned proto_nargs = proto->getNumArgs(); 60293d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman for (unsigned i = 0; i < proto_nargs; ++i) { 60303d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType argTy = proto->getArgType(i); 6031b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor 6032b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor // Look at the promotion type of enum types, since that is the type used 6033b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor // to pass enum values. 6034b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor if (const EnumType *Enum = argTy->getAs<EnumType>()) 6035b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor argTy = Enum->getDecl()->getPromotionType(); 6036b0f8eacfdcd0d43f51e669f2d723992d4af9f746Douglas Gregor 60373d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (argTy->isPromotableIntegerType() || 60383d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman getCanonicalType(argTy).getUnqualifiedType() == FloatTy) 60393d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 60403d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 60413d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 60423d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allLTypes) return lhs; 60433d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allRTypes) return rhs; 6044e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 6045e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI = proto->getExtProtoInfo(); 6046e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall EPI.ExtInfo = einfo; 60473d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return getFunctionType(retType, proto->arg_type_begin(), 6048e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall proto->getNumArgs(), EPI); 60493d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 60503d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 60513d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allLTypes) return lhs; 60523d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (allRTypes) return rhs; 60538cc246c9a68c783a5b90d2e8b8927521cb3a49b7John McCall return getFunctionNoProtoType(retType, einfo); 60543d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman} 60553d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 6056132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz JahanianQualType ASTContext::mergeTypes(QualType LHS, QualType RHS, 6057447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor bool OfBlockPointer, 6058a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian bool Unqualified, bool BlockReturnType) { 605943d69750e7f7b26076e7474dec8839bb777b260fBill Wendling // C++ [expr]: If an expression initially has the type "reference to T", the 606043d69750e7f7b26076e7474dec8839bb777b260fBill Wendling // type is adjusted to "T" prior to any further analysis, the expression 606143d69750e7f7b26076e7474dec8839bb777b260fBill Wendling // designates the object or function denoted by the reference, and the 60627c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // expression is an lvalue unless the reference is an rvalue reference and 60637c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // the expression is a function call (possibly inside parentheses). 60640e709abafbd939326850501f795cc7a92c88a354Douglas Gregor assert(!LHS->getAs<ReferenceType>() && "LHS is a reference type?"); 60650e709abafbd939326850501f795cc7a92c88a354Douglas Gregor assert(!RHS->getAs<ReferenceType>() && "RHS is a reference type?"); 6066447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 6067447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 6068447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHS = LHS.getUnqualifiedType(); 6069447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHS = RHS.getUnqualifiedType(); 6070447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 60710e709abafbd939326850501f795cc7a92c88a354Douglas Gregor 60723d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType LHSCan = getCanonicalType(LHS), 60733d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman RHSCan = getCanonicalType(RHS); 60743d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 6075f3692dc4a47dc48d10cec0415c6e9e39b7a39707Chris Lattner // If two types are identical, they are compatible. 60763d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (LHSCan == RHSCan) 60773d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 60783d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 60790953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If the qualifiers are different, the types aren't compatible... mostly. 6080a4923eb7c4b04d360cb2747641a5e92818edf804Douglas Gregor Qualifiers LQuals = LHSCan.getLocalQualifiers(); 6081a4923eb7c4b04d360cb2747641a5e92818edf804Douglas Gregor Qualifiers RQuals = RHSCan.getLocalQualifiers(); 60820953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (LQuals != RQuals) { 60830953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // If any of these qualifiers are different, we have a type 60840953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // mismatch. 60850953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() || 6086f85e193739c953358c865005855253af4f68a497John McCall LQuals.getAddressSpace() != RQuals.getAddressSpace() || 6087f85e193739c953358c865005855253af4f68a497John McCall LQuals.getObjCLifetime() != RQuals.getObjCLifetime()) 60880953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return QualType(); 60890953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 60900953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Exactly one GC qualifier difference is allowed: __strong is 60910953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // okay if the other type has no GC qualifier but is an Objective 60920953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // C object pointer (i.e. implicitly strong by default). We fix 60930953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // this by pretending that the unqualified type was actually 60940953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // qualified __strong. 60950953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers::GC GC_L = LQuals.getObjCGCAttr(); 60960953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers::GC GC_R = RQuals.getObjCGCAttr(); 60970953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements"); 60980953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 60990953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak) 61000953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return QualType(); 61010953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 61020953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (GC_L == Qualifiers::Strong && RHSCan->isObjCObjectPointerType()) { 61030953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return mergeTypes(LHS, getObjCGCQualType(RHS, Qualifiers::Strong)); 61040953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 61050953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (GC_R == Qualifiers::Strong && LHSCan->isObjCObjectPointerType()) { 61060953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return mergeTypes(getObjCGCQualType(LHS, Qualifiers::Strong), RHS); 61070953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 61083d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 61090953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 61100953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 61110953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Okay, qualifiers are equal. 61123d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 6113852d63b806c5cbd730c6b9d696e2e27d02546b49Eli Friedman Type::TypeClass LHSClass = LHSCan->getTypeClass(); 6114852d63b806c5cbd730c6b9d696e2e27d02546b49Eli Friedman Type::TypeClass RHSClass = RHSCan->getTypeClass(); 6115f3692dc4a47dc48d10cec0415c6e9e39b7a39707Chris Lattner 61161adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner // We want to consider the two function types to be the same for these 61171adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner // comparisons, just force one to the other. 61181adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto; 61191adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto; 61204c721d381fb279899337d120edd4a24d405e56b2Eli Friedman 61214c721d381fb279899337d120edd4a24d405e56b2Eli Friedman // Same as above for arrays 6122a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray) 6123a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner LHSClass = Type::ConstantArray; 6124a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray) 6125a36a61f218b9f7a97f2c0f511e0b29eb42e8f78bChris Lattner RHSClass = Type::ConstantArray; 61261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6127c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // ObjCInterfaces are just specialized ObjCObjects. 6128c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject; 6129c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject; 6130c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 6131213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // Canonicalize ExtVector -> Vector. 6132213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (LHSClass == Type::ExtVector) LHSClass = Type::Vector; 6133213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (RHSClass == Type::ExtVector) RHSClass = Type::Vector; 61341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 61354e78fd0a960eaa7e97467f2e8f390f3a57da279bSteve Naroff // If the canonical type classes don't match. 61364e78fd0a960eaa7e97467f2e8f390f3a57da279bSteve Naroff if (LHSClass != RHSClass) { 61371adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner // C99 6.7.2.2p4: Each enumerated type shall be compatible with char, 61381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // a signed integer type, or an unsigned integer type. 6139842aef8d942a880eeb9535d40de31a86838264cbJohn McCall // Compatibility is based on the underlying type, not the promotion 6140842aef8d942a880eeb9535d40de31a86838264cbJohn McCall // type. 6141183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const EnumType* ETy = LHS->getAs<EnumType>()) { 6142b918d6b1f794266e126e5445d69233462087d764Fariborz Jahanian QualType TINT = ETy->getDecl()->getIntegerType(); 6143b918d6b1f794266e126e5445d69233462087d764Fariborz Jahanian if (!TINT.isNull() && hasSameType(TINT, RHSCan.getUnqualifiedType())) 61443d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return RHS; 6145bab96968886f4b77083f4e26a28986ddb1e42d67Eli Friedman } 6146183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const EnumType* ETy = RHS->getAs<EnumType>()) { 6147b918d6b1f794266e126e5445d69233462087d764Fariborz Jahanian QualType TINT = ETy->getDecl()->getIntegerType(); 6148b918d6b1f794266e126e5445d69233462087d764Fariborz Jahanian if (!TINT.isNull() && hasSameType(TINT, LHSCan.getUnqualifiedType())) 61493d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 6150bab96968886f4b77083f4e26a28986ddb1e42d67Eli Friedman } 6151e7cff2c00c3d74e38984a4db5c48d7e303d3ab8eFariborz Jahanian // allow block pointer type to match an 'id' type. 6152419636316c04d570c183b4797fc811932c588358Fariborz Jahanian if (OfBlockPointer && !BlockReturnType) { 6153419636316c04d570c183b4797fc811932c588358Fariborz Jahanian if (LHS->isObjCIdType() && RHS->isBlockPointerType()) 6154419636316c04d570c183b4797fc811932c588358Fariborz Jahanian return LHS; 6155419636316c04d570c183b4797fc811932c588358Fariborz Jahanian if (RHS->isObjCIdType() && LHS->isBlockPointerType()) 6156419636316c04d570c183b4797fc811932c588358Fariborz Jahanian return RHS; 6157419636316c04d570c183b4797fc811932c588358Fariborz Jahanian } 6158e7cff2c00c3d74e38984a4db5c48d7e303d3ab8eFariborz Jahanian 61593d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 6160ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff } 61613d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 61624a74678ed6c3dedac05d02b1ee341f1db869f049Steve Naroff // The canonical type classes match. 61631adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner switch (LHSClass) { 616472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define TYPE(Class, Base) 616572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define ABSTRACT_TYPE(Class, Base) 6166ad5e73887052193afda72db8efcb812bd083a4a8John McCall#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class: 616772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 616872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#define DEPENDENT_TYPE(Class, Base) case Type::Class: 616972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor#include "clang/AST/TypeNodes.def" 6170b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Non-canonical and dependent types shouldn't get here"); 617172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 61727c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl case Type::LValueReference: 61737c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl case Type::RValueReference: 617472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::MemberPointer: 6175b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("C++ should never be in mergeTypes"); 617672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 6177c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCInterface: 617872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::IncompleteArray: 617972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::VariableArray: 618072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::FunctionProto: 618172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::ExtVector: 6182b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Types are eliminated above"); 618372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 61841adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::Pointer: 61853d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman { 61863d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // Merge two pointer types, while trying to preserve typedef info 61876217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType LHSPointee = LHS->getAs<PointerType>()->getPointeeType(); 61886217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType RHSPointee = RHS->getAs<PointerType>()->getPointeeType(); 6189447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 6190447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHSPointee = LHSPointee.getUnqualifiedType(); 6191447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHSPointee = RHSPointee.getUnqualifiedType(); 6192447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 6193447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor QualType ResultType = mergeTypes(LHSPointee, RHSPointee, false, 6194447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor Unqualified); 61953d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (ResultType.isNull()) return QualType(); 619607d258756dc856c6987c394a0972884e6ed46765Eli Friedman if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType)) 619761710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return LHS; 619807d258756dc856c6987c394a0972884e6ed46765Eli Friedman if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType)) 619961710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return RHS; 62003d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return getPointerType(ResultType); 62013d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 6202c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff case Type::BlockPointer: 6203c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff { 6204c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff // Merge two block pointer types, while trying to preserve typedef info 62056217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType LHSPointee = LHS->getAs<BlockPointerType>()->getPointeeType(); 62066217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType RHSPointee = RHS->getAs<BlockPointerType>()->getPointeeType(); 6207447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 6208447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHSPointee = LHSPointee.getUnqualifiedType(); 6209447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHSPointee = RHSPointee.getUnqualifiedType(); 6210447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 6211447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor QualType ResultType = mergeTypes(LHSPointee, RHSPointee, OfBlockPointer, 6212447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor Unqualified); 6213c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff if (ResultType.isNull()) return QualType(); 6214c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType)) 6215c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff return LHS; 6216c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType)) 6217c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff return RHS; 6218c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff return getBlockPointerType(ResultType); 6219c0febd58f5cbf4a93fd12f461863564dba0af76dSteve Naroff } 6220b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: 6221b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman { 6222b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman // Merge two pointer types, while trying to preserve typedef info 6223b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType LHSValue = LHS->getAs<AtomicType>()->getValueType(); 6224b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType RHSValue = RHS->getAs<AtomicType>()->getValueType(); 6225b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (Unqualified) { 6226b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman LHSValue = LHSValue.getUnqualifiedType(); 6227b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman RHSValue = RHSValue.getUnqualifiedType(); 6228b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 6229b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman QualType ResultType = mergeTypes(LHSValue, RHSValue, false, 6230b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman Unqualified); 6231b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (ResultType.isNull()) return QualType(); 6232b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (getCanonicalType(LHSValue) == getCanonicalType(ResultType)) 6233b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return LHS; 6234b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman if (getCanonicalType(RHSValue) == getCanonicalType(ResultType)) 6235b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return RHS; 6236b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman return getAtomicType(ResultType); 6237b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman } 62381adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::ConstantArray: 62393d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman { 62403d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const ConstantArrayType* LCAT = getAsConstantArrayType(LHS); 62413d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const ConstantArrayType* RCAT = getAsConstantArrayType(RHS); 62423d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (LCAT && RCAT && RCAT->getSize() != LCAT->getSize()) 62433d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 62443d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman 62453d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType LHSElem = getAsArrayType(LHS)->getElementType(); 62463d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman QualType RHSElem = getAsArrayType(RHS)->getElementType(); 6247447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor if (Unqualified) { 6248447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor LHSElem = LHSElem.getUnqualifiedType(); 6249447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor RHSElem = RHSElem.getUnqualifiedType(); 6250447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor } 6251447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor 6252447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor QualType ResultType = mergeTypes(LHSElem, RHSElem, false, Unqualified); 62533d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (ResultType.isNull()) return QualType(); 625461710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (LCAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType)) 625561710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return LHS; 625661710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (RCAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType)) 625761710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return RHS; 62583bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (LCAT) return getConstantArrayType(ResultType, LCAT->getSize(), 62593bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman ArrayType::ArraySizeModifier(), 0); 62603bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (RCAT) return getConstantArrayType(ResultType, RCAT->getSize(), 62613bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman ArrayType::ArraySizeModifier(), 0); 62623d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const VariableArrayType* LVAT = getAsVariableArrayType(LHS); 62633d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman const VariableArrayType* RVAT = getAsVariableArrayType(RHS); 626461710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (LVAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType)) 626561710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return LHS; 626661710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner if (RVAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType)) 626761710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return RHS; 62683d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (LVAT) { 62693d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // FIXME: This isn't correct! But tricky to implement because 62703d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // the array's size has to be the size of LHS, but the type 62713d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // has to be different. 62723d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 62733d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 62743d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman if (RVAT) { 62753d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // FIXME: This isn't correct! But tricky to implement because 62763d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // the array's size has to be the size of RHS, but the type 62773d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman // has to be different. 62783d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return RHS; 62793d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 62803bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (getCanonicalType(LHSElem) == getCanonicalType(ResultType)) return LHS; 62813bc0f45a5e65814f42b22dcdf7249d1120d16f36Eli Friedman if (getCanonicalType(RHSElem) == getCanonicalType(ResultType)) return RHS; 62827e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor return getIncompleteArrayType(ResultType, 62837e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor ArrayType::ArraySizeModifier(), 0); 62843d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman } 62851adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::FunctionNoProto: 6286447234dd459a00a5ed9b7c3e066162cd7a75bf2dDouglas Gregor return mergeFunctionTypes(LHS, RHS, OfBlockPointer, Unqualified); 628772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Record: 628872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case Type::Enum: 62893d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 62901adb88370beab45af2f065afe86b51ccd59ec50dChris Lattner case Type::Builtin: 62913cc4c0c3058a788689b8fc73c0ac139544435c97Chris Lattner // Only exactly equal builtin types are compatible, which is tested above. 62923d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 629364cfdb7da3cb744642fe8a99ad5c851ad3c930b2Daniel Dunbar case Type::Complex: 629464cfdb7da3cb744642fe8a99ad5c851ad3c930b2Daniel Dunbar // Distinct complex types are incompatible. 629564cfdb7da3cb744642fe8a99ad5c851ad3c930b2Daniel Dunbar return QualType(); 62963cc4c0c3058a788689b8fc73c0ac139544435c97Chris Lattner case Type::Vector: 62975a61f0e5c5aaecd5713c3fa4b78be7167a7eeff2Eli Friedman // FIXME: The merged type should be an ExtVector! 62981c471f3e1c0ec8cbc82447bb35908dfc55463e46John McCall if (areCompatVectorTypes(LHSCan->getAs<VectorType>(), 62991c471f3e1c0ec8cbc82447bb35908dfc55463e46John McCall RHSCan->getAs<VectorType>())) 63003d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return LHS; 630161710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner return QualType(); 6302c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case Type::ObjCObject: { 6303c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Check if the types are assignment compatible. 63045a61f0e5c5aaecd5713c3fa4b78be7167a7eeff2Eli Friedman // FIXME: This should be type compatibility, e.g. whether 63055a61f0e5c5aaecd5713c3fa4b78be7167a7eeff2Eli Friedman // "LHS x; RHS x;" at global scope is legal. 6306c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* LHSIface = LHS->getAs<ObjCObjectType>(); 6307c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall const ObjCObjectType* RHSIface = RHS->getAs<ObjCObjectType>(); 6308c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (canAssignObjCInterfaces(LHSIface, RHSIface)) 63095fd659db11922fc12a58e478f7b745f9656b15a7Steve Naroff return LHS; 63105fd659db11922fc12a58e478f7b745f9656b15a7Steve Naroff 63113d815e7eb56c25d7ed812eced32e41df43039f9aEli Friedman return QualType(); 631261490e9a965cfee8a78c12c6802138844f04250dCedric Venet } 631314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff case Type::ObjCObjectPointer: { 6314132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (OfBlockPointer) { 6315132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian if (canAssignObjCInterfacesInBlockPointer( 6316132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian LHS->getAs<ObjCObjectPointerType>(), 6317a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian RHS->getAs<ObjCObjectPointerType>(), 6318a4fdbfad150ae37bddaa4094d3925a27a1a1cf3fFariborz Jahanian BlockReturnType)) 63197530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie return LHS; 6320132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian return QualType(); 6321132f2a2da34f378fc675b9e174564b0f52c31d98Fariborz Jahanian } 6322183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (canAssignObjCInterfaces(LHS->getAs<ObjCObjectPointerType>(), 6323183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall RHS->getAs<ObjCObjectPointerType>())) 632414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff return LHS; 632514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 6326bc76dd06eb881c70c9775b74bab8b88cd747f173Steve Naroff return QualType(); 63277530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie } 6328ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff } 632972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 63307530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie llvm_unreachable("Invalid Type::Class!"); 6331ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff} 63327192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek 633378213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanianbool ASTContext::FunctionTypesMatchOnNSConsumedAttrs( 633478213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian const FunctionProtoType *FromFunctionType, 633578213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian const FunctionProtoType *ToFunctionType) { 633678213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (FromFunctionType->hasAnyConsumedArgs() != 633778213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ToFunctionType->hasAnyConsumedArgs()) 633878213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return false; 633978213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian FunctionProtoType::ExtProtoInfo FromEPI = 634078213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian FromFunctionType->getExtProtoInfo(); 634178213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian FunctionProtoType::ExtProtoInfo ToEPI = 634278213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ToFunctionType->getExtProtoInfo(); 634378213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (FromEPI.ConsumedArguments && ToEPI.ConsumedArguments) 634478213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumArgs(); 634578213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ArgIdx != NumArgs; ++ArgIdx) { 634678213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian if (FromEPI.ConsumedArguments[ArgIdx] != 634778213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian ToEPI.ConsumedArguments[ArgIdx]) 634878213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return false; 634978213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian } 635078213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian return true; 635178213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian} 635278213e4aec6d8d22b5828dd2687fa19116ebaa26Fariborz Jahanian 63532390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian/// mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and 63542390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian/// 'RHS' attributes and returns the merged version; including for function 63552390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian/// return types. 63562390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz JahanianQualType ASTContext::mergeObjCGCQualifiers(QualType LHS, QualType RHS) { 63572390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType LHSCan = getCanonicalType(LHS), 63582390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian RHSCan = getCanonicalType(RHS); 63592390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // If two types are identical, they are compatible. 63602390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LHSCan == RHSCan) 63612390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return LHS; 63622390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (RHSCan->isFunctionType()) { 63632390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (!LHSCan->isFunctionType()) 63642390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 63652390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType OldReturnType = 63662390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian cast<FunctionType>(RHSCan.getTypePtr())->getResultType(); 63672390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType NewReturnType = 63682390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian cast<FunctionType>(LHSCan.getTypePtr())->getResultType(); 63692390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType ResReturnType = 63702390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian mergeObjCGCQualifiers(NewReturnType, OldReturnType); 63712390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResReturnType.isNull()) 63722390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 63732390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResReturnType == NewReturnType || ResReturnType == OldReturnType) { 63742390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // id foo(); ... __strong id foo(); or: __strong id foo(); ... id foo(); 63752390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // In either case, use OldReturnType to build the new function type. 63762390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian const FunctionType *F = LHS->getAs<FunctionType>(); 63772390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (const FunctionProtoType *FPT = cast<FunctionProtoType>(F)) { 6378e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 6379e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall EPI.ExtInfo = getFunctionExtInfo(LHS); 63802390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType ResultType 63812390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian = getFunctionType(OldReturnType, FPT->arg_type_begin(), 6382e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FPT->getNumArgs(), EPI); 63832390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return ResultType; 63842390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 63852390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 63862390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 63872390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 63882390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 63892390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // If the qualifiers are different, the types can still be merged. 63902390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers LQuals = LHSCan.getLocalQualifiers(); 63912390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers RQuals = RHSCan.getLocalQualifiers(); 63922390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LQuals != RQuals) { 63932390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // If any of these qualifiers are different, we have a type mismatch. 63942390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() || 63952390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian LQuals.getAddressSpace() != RQuals.getAddressSpace()) 63962390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 63972390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 63982390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // Exactly one GC qualifier difference is allowed: __strong is 63992390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // okay if the other type has no GC qualifier but is an Objective 64002390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // C object pointer (i.e. implicitly strong by default). We fix 64012390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // this by pretending that the unqualified type was actually 64022390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian // qualified __strong. 64032390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers::GC GC_L = LQuals.getObjCGCAttr(); 64042390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian Qualifiers::GC GC_R = RQuals.getObjCGCAttr(); 64052390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements"); 64062390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 64072390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak) 64082390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 64092390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 64102390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (GC_L == Qualifiers::Strong) 64112390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return LHS; 64122390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (GC_R == Qualifiers::Strong) 64132390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return RHS; 64142390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 64152390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 64162390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 64172390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (LHSCan->isObjCObjectPointerType() && RHSCan->isObjCObjectPointerType()) { 64182390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType LHSBaseQT = LHS->getAs<ObjCObjectPointerType>()->getPointeeType(); 64192390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType RHSBaseQT = RHS->getAs<ObjCObjectPointerType>()->getPointeeType(); 64202390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian QualType ResQT = mergeObjCGCQualifiers(LHSBaseQT, RHSBaseQT); 64212390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResQT == LHSBaseQT) 64222390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return LHS; 64232390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian if (ResQT == RHSBaseQT) 64242390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return RHS; 64252390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian } 64262390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian return QualType(); 64272390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian} 64282390a72a3ebd37737fec5ba1385db9c3bb22fc59Fariborz Jahanian 64295426bf6456a5aeac416a9150de157904d101c819Chris Lattner//===----------------------------------------------------------------------===// 6430ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman// Integer Predicates 6431ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman//===----------------------------------------------------------------------===// 643288054dee0402e4d3c1f64e6b697acc47195c0d72Chris Lattner 64334ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadunsigned ASTContext::getIntWidth(QualType T) const { 6434f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall if (const EnumType *ET = dyn_cast<EnumType>(T)) 643529a7f3342c3c6dd15d914c61ae22246c36d51ce7Eli Friedman T = ET->getDecl()->getIntegerType(); 64361274ccd90aec0b205fc838c3d504821ccfb55482Douglas Gregor if (T->isBooleanType()) 64371274ccd90aec0b205fc838c3d504821ccfb55482Douglas Gregor return 1; 6438f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman // For builtin types, just use the standard type sizing method 6439ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return (unsigned)getTypeSize(T); 6440ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman} 6441ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman 6442ad74a758189180b8ab8faea648e4766c3bfd7fcbEli FriedmanQualType ASTContext::getCorrespondingUnsignedType(QualType T) { 6443f60946222721d9ba3c059563935c17b84703187aDouglas Gregor assert(T->hasSignedIntegerRepresentation() && "Unexpected type"); 64446a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner 64456a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner // Turn <4 x signed int> -> <4 x unsigned int> 64466a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner if (const VectorType *VTy = T->getAs<VectorType>()) 64476a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner return getVectorType(getCorrespondingUnsignedType(VTy->getElementType()), 6448e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VTy->getNumElements(), VTy->getVectorKind()); 64496a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner 64506a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner // For enums, we return the unsigned version of the base type. 64516a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner if (const EnumType *ETy = T->getAs<EnumType>()) 6452ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman T = ETy->getDecl()->getIntegerType(); 64536a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner 64546a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner const BuiltinType *BTy = T->getAs<BuiltinType>(); 64556a2b9261bf9c973c7122d9d1febce24a38fa862dChris Lattner assert(BTy && "Unexpected signed integer type"); 6456ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman switch (BTy->getKind()) { 6457ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Char_S: 6458ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::SChar: 6459ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedCharTy; 6460ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Short: 6461ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedShortTy; 6462ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Int: 6463ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedIntTy; 6464ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::Long: 6465ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedLongTy; 6466ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman case BuiltinType::LongLong: 6467ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman return UnsignedLongLongTy; 64682df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case BuiltinType::Int128: 64692df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner return UnsignedInt128Ty; 6470ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman default: 6471b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unexpected signed integer type"); 6472ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman } 6473ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman} 6474ad74a758189180b8ab8faea648e4766c3bfd7fcbEli Friedman 64757b90340c9c7d07aef4e301e72b5e8a30d5f4f0c8Argyrios KyrtzidisASTMutationListener::~ASTMutationListener() { } 64767b90340c9c7d07aef4e301e72b5e8a30d5f4f0c8Argyrios Kyrtzidis 647786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 647886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner//===----------------------------------------------------------------------===// 647986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner// Builtin Type Computation 648086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner//===----------------------------------------------------------------------===// 648186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 648286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner/// DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the 648333daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// pointer over the consumed characters. This returns the resultant type. If 648433daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// AllowTypeModifiers is false then modifier like * are not parsed, just basic 648533daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// types. This allows "v2i*" to be parsed as a pointer to a v2i instead of 648633daae66462e8f51ee153463b32bdefd60c801aaChris Lattner/// a vector of "i*". 648714e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner/// 648814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner/// RequiresICE is filled in on return to indicate whether the value is required 648914e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner/// to be an Integer Constant Expression. 64904ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadstatic QualType DecodeTypeFromStr(const char *&Str, const ASTContext &Context, 649186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner ASTContext::GetBuiltinTypeError &Error, 649214e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner bool &RequiresICE, 649333daae66462e8f51ee153463b32bdefd60c801aaChris Lattner bool AllowTypeModifiers) { 649486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // Modifiers. 649586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner int HowLong = 0; 649686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner bool Signed = false, Unsigned = false; 649714e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE = false; 6498393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner 649933daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // Read the prefixed modifiers first. 650086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner bool Done = false; 650186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner while (!Done) { 650286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner switch (*Str++) { 65031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump default: Done = true; --Str; break; 6504393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner case 'I': 650514e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE = true; 6506393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner break; 650786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'S': 650886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Unsigned && "Can't use both 'S' and 'U' modifiers!"); 650986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Signed && "Can't use 'S' modifier multiple times!"); 651086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Signed = true; 651186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 651286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'U': 651386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Signed && "Can't use both 'S' and 'U' modifiers!"); 651486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Unsigned && "Can't use 'S' modifier multiple times!"); 651586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Unsigned = true; 651686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 651786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'L': 651886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong <= 2 && "Can't have LLLL modifier"); 651986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner ++HowLong; 652086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 652186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 652286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 652386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 652486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner QualType Type; 65251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 652686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // Read the base type. 652786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner switch (*Str++) { 6528b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Unknown builtin type letter!"); 652986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'v': 653086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && 653186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "Bad modifiers used with 'v'!"); 653286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.VoidTy; 653386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 653486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'f': 653586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && 653686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "Bad modifiers used with 'f'!"); 653786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.FloatTy; 653886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 653986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'd': 654086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong < 2 && !Signed && !Unsigned && 654186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "Bad modifiers used with 'd'!"); 654286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (HowLong) 654386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.LongDoubleTy; 654486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 654586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.DoubleTy; 654686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 654786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 's': 654886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && "Bad modifiers used with 's'!"); 654986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Unsigned) 655086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.UnsignedShortTy; 655186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 655286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.ShortTy; 655386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 655486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'i': 655586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (HowLong == 3) 655686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty; 655786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else if (HowLong == 2) 655886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy; 655986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else if (HowLong == 1) 656086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedLongTy : Context.LongTy; 656186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 656286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Unsigned ? Context.UnsignedIntTy : Context.IntTy; 656386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 656486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'c': 656586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && "Bad modifiers used with 'c'!"); 656686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Signed) 656786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.SignedCharTy; 656886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else if (Unsigned) 656986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.UnsignedCharTy; 657086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner else 657186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.CharTy; 657286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 657386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'b': // boolean 657486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'b'!"); 657586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.BoolTy; 657686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 657786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'z': // size_t. 657886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'z'!"); 657986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getSizeType(); 658086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 658186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'F': 658286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getCFConstantStringType(); 658386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 6584ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian case 'G': 6585ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian Type = Context.getObjCIdType(); 6586ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian break; 6587ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian case 'H': 6588ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian Type = Context.getObjCSelType(); 6589ba8bda05fefd3bb2f1ef201784b685f715bdde29Fariborz Jahanian break; 659086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'a': 659186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getBuiltinVaListType(); 659286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Type.isNull() && "builtin va list type not initialized!"); 659386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 659486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'A': 659586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // This is a "reference" to a va_list; however, what exactly 659686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // this means depends on how va_list is defined. There are two 659786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // different kinds of va_list: ones passed by value, and ones 659886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // passed by reference. An example of a by-value va_list is 659986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // x86, where va_list is a char*. An example of by-ref va_list 660086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // is x86-64, where va_list is a __va_list_tag[1]. For x86, 660186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // we want this argument to be a char*&; for x86-64, we want 660286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // it to be a __va_list_tag*. 660386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getBuiltinVaListType(); 660486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(!Type.isNull() && "builtin va list type not initialized!"); 660514e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner if (Type->isArrayType()) 660686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getArrayDecayedType(Type); 660714e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner else 660886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Type = Context.getLValueReferenceType(Type); 660986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 661086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner case 'V': { 661186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner char *End; 661286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner unsigned NumElements = strtoul(Str, &End, 10); 661386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert(End != Str && "Missing vector size"); 661486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Str = End; 66151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 661614e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType ElementType = DecodeTypeFromStr(Str, Context, Error, 661714e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE, false); 661814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert(!RequiresICE && "Can't require vector ICE"); 661933daae66462e8f51ee153463b32bdefd60c801aaChris Lattner 662033daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // TODO: No way to make AltiVec vectors in builtins yet. 6621788b0fd67e1992f23555454efcdb16a19dfefac3Chris Lattner Type = Context.getVectorType(ElementType, NumElements, 6622e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType::GenericVector); 662386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner break; 662486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 6625b4bc99ba5540a618c86c136c9112ead8fb1d9866Douglas Gregor case 'E': { 6626b4bc99ba5540a618c86c136c9112ead8fb1d9866Douglas Gregor char *End; 6627b4bc99ba5540a618c86c136c9112ead8fb1d9866Douglas Gregor 6628b4bc99ba5540a618c86c136c9112ead8fb1d9866Douglas Gregor unsigned NumElements = strtoul(Str, &End, 10); 6629b4bc99ba5540a618c86c136c9112ead8fb1d9866Douglas Gregor assert(End != Str && "Missing vector size"); 6630b4bc99ba5540a618c86c136c9112ead8fb1d9866Douglas Gregor 6631b4bc99ba5540a618c86c136c9112ead8fb1d9866Douglas Gregor Str = End; 6632b4bc99ba5540a618c86c136c9112ead8fb1d9866Douglas Gregor 6633b4bc99ba5540a618c86c136c9112ead8fb1d9866Douglas Gregor QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE, 6634b4bc99ba5540a618c86c136c9112ead8fb1d9866Douglas Gregor false); 6635b4bc99ba5540a618c86c136c9112ead8fb1d9866Douglas Gregor Type = Context.getExtVectorType(ElementType, NumElements); 6636b4bc99ba5540a618c86c136c9112ead8fb1d9866Douglas Gregor break; 6637b4bc99ba5540a618c86c136c9112ead8fb1d9866Douglas Gregor } 6638d3a23b238a2b2c0f11e6ac4951c7410a8c5717bfDouglas Gregor case 'X': { 663914e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE, 664014e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner false); 664114e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert(!RequiresICE && "Can't require complex ICE"); 6642d3a23b238a2b2c0f11e6ac4951c7410a8c5717bfDouglas Gregor Type = Context.getComplexType(ElementType); 6643d3a23b238a2b2c0f11e6ac4951c7410a8c5717bfDouglas Gregor break; 6644cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian } 6645cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian case 'Y' : { 6646cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian Type = Context.getPointerDiffType(); 6647cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian break; 6648cc075e4092900ac9eec9dc92e35096eae1ee29c7Fariborz Jahanian } 66499a5a7e7351f78345a72c4956af25590f6d40ebcdChris Lattner case 'P': 6650c29f77b769bcc5b6dc85e72c8e3cc2e348e5cf25Douglas Gregor Type = Context.getFILEType(); 6651c29f77b769bcc5b6dc85e72c8e3cc2e348e5cf25Douglas Gregor if (Type.isNull()) { 6652f711c41dd9412a8182793259d355c4f6979ed5edMike Stump Error = ASTContext::GE_Missing_stdio; 665386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return QualType(); 665486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 6655fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump break; 66569a5a7e7351f78345a72c4956af25590f6d40ebcdChris Lattner case 'J': 6657f711c41dd9412a8182793259d355c4f6979ed5edMike Stump if (Signed) 6658782fa308a765aeac2acb39c4e697c937ec21185bMike Stump Type = Context.getsigjmp_bufType(); 6659f711c41dd9412a8182793259d355c4f6979ed5edMike Stump else 6660f711c41dd9412a8182793259d355c4f6979ed5edMike Stump Type = Context.getjmp_bufType(); 6661f711c41dd9412a8182793259d355c4f6979ed5edMike Stump 6662fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump if (Type.isNull()) { 6663f711c41dd9412a8182793259d355c4f6979ed5edMike Stump Error = ASTContext::GE_Missing_setjmp; 6664fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump return QualType(); 6665fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump } 6666fd612dbb23cd31c03c898ae53ff18d0dfd8488f9Mike Stump break; 6667e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola case 'K': 6668e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'K'!"); 6669e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola Type = Context.getucontext_tType(); 6670e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola 6671e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola if (Type.isNull()) { 6672e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola Error = ASTContext::GE_Missing_ucontext; 6673e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola return QualType(); 6674e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola } 6675e2d4f4ed44a32f179c6d48cd1dba8346ab2129d9Rafael Espindola break; 6676782fa308a765aeac2acb39c4e697c937ec21185bMike Stump } 66771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 667833daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // If there are modifiers and if we're allowed to parse them, go for it. 667933daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Done = !AllowTypeModifiers; 668086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner while (!Done) { 6681187ab37a05b8f7015b9f39cc8cd9129a0c6d0b48John McCall switch (char c = *Str++) { 668233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner default: Done = true; --Str; break; 668333daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case '*': 668433daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case '&': { 668533daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // Both pointers and references can have their pointee types 668633daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // qualified with an address space. 668733daae66462e8f51ee153463b32bdefd60c801aaChris Lattner char *End; 668833daae66462e8f51ee153463b32bdefd60c801aaChris Lattner unsigned AddrSpace = strtoul(Str, &End, 10); 668933daae66462e8f51ee153463b32bdefd60c801aaChris Lattner if (End != Str && AddrSpace != 0) { 669033daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getAddrSpaceQualType(Type, AddrSpace); 669133daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Str = End; 669233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner } 669333daae66462e8f51ee153463b32bdefd60c801aaChris Lattner if (c == '*') 669433daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getPointerType(Type); 669533daae66462e8f51ee153463b32bdefd60c801aaChris Lattner else 669633daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getLValueReferenceType(Type); 669733daae66462e8f51ee153463b32bdefd60c801aaChris Lattner break; 669833daae66462e8f51ee153463b32bdefd60c801aaChris Lattner } 669933daae66462e8f51ee153463b32bdefd60c801aaChris Lattner // FIXME: There's no way to have a built-in with an rvalue ref arg. 670033daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case 'C': 670133daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Type.withConst(); 670233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner break; 670333daae66462e8f51ee153463b32bdefd60c801aaChris Lattner case 'D': 670433daae66462e8f51ee153463b32bdefd60c801aaChris Lattner Type = Context.getVolatileType(Type); 670533daae66462e8f51ee153463b32bdefd60c801aaChris Lattner break; 670618932a0f2a94a7813ec461d1118c39ecf8aa936fTed Kremenek case 'R': 670718932a0f2a94a7813ec461d1118c39ecf8aa936fTed Kremenek Type = Type.withRestrict(); 670818932a0f2a94a7813ec461d1118c39ecf8aa936fTed Kremenek break; 670986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 671086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 6711393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner 671214e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert((!RequiresICE || Type->isIntegralOrEnumerationType()) && 6713393bd8e185692a451b2ba16bdfc9e7d3543b4217Chris Lattner "Integer constant 'I' type must be an integer"); 67141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 671586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return Type; 671686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner} 671786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 671886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner/// GetBuiltinType - Return the type for the specified builtin. 671933daae66462e8f51ee153463b32bdefd60c801aaChris LattnerQualType ASTContext::GetBuiltinType(unsigned Id, 672014e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner GetBuiltinTypeError &Error, 67214ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned *IntegerConstantArgs) const { 672233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner const char *TypeStr = BuiltinInfo.GetTypeString(Id); 67231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 67245f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<QualType, 8> ArgTypes; 67251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 672614e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner bool RequiresICE = false; 672786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Error = GE_None; 672814e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType ResType = DecodeTypeFromStr(TypeStr, *this, Error, 672914e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner RequiresICE, true); 673086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Error != GE_None) 673186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return QualType(); 673214e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner 673314e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner assert(!RequiresICE && "Result of intrinsic cannot be required to be an ICE"); 673414e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner 673586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner while (TypeStr[0] && TypeStr[0] != '.') { 673614e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner QualType Ty = DecodeTypeFromStr(TypeStr, *this, Error, RequiresICE, true); 673786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Error != GE_None) 673886df27bbdbb98c39ec2184695c0561209f91beddChris Lattner return QualType(); 673986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 674014e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner // If this argument is required to be an IntegerConstantExpression and the 674114e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner // caller cares, fill in the bitmask we return. 674214e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner if (RequiresICE && IntegerConstantArgs) 674314e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner *IntegerConstantArgs |= 1 << ArgTypes.size(); 674414e0e7436cf6650a72052baea1f8ebe644cef489Chris Lattner 674586df27bbdbb98c39ec2184695c0561209f91beddChris Lattner // Do array -> pointer decay. The builtin should use the decayed type. 674686df27bbdbb98c39ec2184695c0561209f91beddChris Lattner if (Ty->isArrayType()) 674786df27bbdbb98c39ec2184695c0561209f91beddChris Lattner Ty = getArrayDecayedType(Ty); 67481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 674986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner ArgTypes.push_back(Ty); 675086df27bbdbb98c39ec2184695c0561209f91beddChris Lattner } 675186df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 675286df27bbdbb98c39ec2184695c0561209f91beddChris Lattner assert((TypeStr[0] != '.' || TypeStr[1] == 0) && 675386df27bbdbb98c39ec2184695c0561209f91beddChris Lattner "'.' should only occur at end of builtin type list!"); 675486df27bbdbb98c39ec2184695c0561209f91beddChris Lattner 675500ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall FunctionType::ExtInfo EI; 675600ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall if (BuiltinInfo.isNoReturn(Id)) EI = EI.withNoReturn(true); 675700ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall 675800ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall bool Variadic = (TypeStr[0] == '.'); 675900ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall 676000ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall // We really shouldn't be making a no-proto type here, especially in C++. 676100ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall if (ArgTypes.empty() && Variadic) 676200ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall return getFunctionNoProtoType(ResType, EI); 6763ce056bcaa1c97b89a4b2de2112c62d060863be2bDouglas Gregor 6764e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo EPI; 676500ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall EPI.ExtInfo = EI; 676600ccbefcffeb88ea3e2e6323e594fa968753ad14John McCall EPI.Variadic = Variadic; 6767e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 6768e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall return getFunctionType(ResType, ArgTypes.data(), ArgTypes.size(), EPI); 676986df27bbdbb98c39ec2184695c0561209f91beddChris Lattner} 6770a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman 677190e99a84ddd020e8fda79643748243725a2ed071Argyrios KyrtzidisGVALinkage ASTContext::GetGVALinkageForFunction(const FunctionDecl *FD) { 677290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis GVALinkage External = GVA_StrongExternal; 677390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 677490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis Linkage L = FD->getLinkage(); 677590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (L) { 677690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case NoLinkage: 677790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case InternalLinkage: 677890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case UniqueExternalLinkage: 677990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_Internal; 678090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 678190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case ExternalLinkage: 678290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (FD->getTemplateSpecializationKind()) { 678390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_Undeclared: 678490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitSpecialization: 678590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis External = GVA_StrongExternal; 678690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis break; 678790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 678890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDefinition: 678990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_ExplicitTemplateInstantiation; 679090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 679190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDeclaration: 679290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ImplicitInstantiation: 679390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis External = GVA_TemplateInstantiation; 679490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis break; 679590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 679690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 679790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 679890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (!FD->isInlined()) 679990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return External; 680090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 68014e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (!getLangOpts().CPlusPlus || FD->hasAttr<GNUInlineAttr>()) { 680290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // GNU or C99 inline semantics. Determine whether this symbol should be 680390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // externally visible. 680490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (FD->isInlineDefinitionExternallyVisible()) 680590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return External; 680690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 680790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // C99 inline semantics, where the symbol is not externally visible. 680890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_C99Inline; 680990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 681090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 681190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // C++0x [temp.explicit]p9: 681290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // [ Note: The intent is that an inline function that is the subject of 681390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // an explicit instantiation declaration will still be implicitly 681490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // instantiated when used so that the body can be considered for 681590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // inlining, but that no out-of-line copy of the inline function would be 681690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // generated in the translation unit. -- end note ] 681790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (FD->getTemplateSpecializationKind() 681890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis == TSK_ExplicitInstantiationDeclaration) 681990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_C99Inline; 682090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 682190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_CXXInline; 682290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis} 682390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 682490e99a84ddd020e8fda79643748243725a2ed071Argyrios KyrtzidisGVALinkage ASTContext::GetGVALinkageForVariable(const VarDecl *VD) { 682590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // If this is a static data member, compute the kind of template 682690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // specialization. Otherwise, this variable is not part of a 682790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // template. 682890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis TemplateSpecializationKind TSK = TSK_Undeclared; 682990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (VD->isStaticDataMember()) 683090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis TSK = VD->getTemplateSpecializationKind(); 683190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 683290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis Linkage L = VD->getLinkage(); 68334e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (L == ExternalLinkage && getLangOpts().CPlusPlus && 683490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis VD->getType()->getLinkage() == UniqueExternalLinkage) 683590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis L = UniqueExternalLinkage; 683690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 683790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (L) { 683890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case NoLinkage: 683990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case InternalLinkage: 684090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case UniqueExternalLinkage: 684190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_Internal; 684290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 684390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case ExternalLinkage: 684490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis switch (TSK) { 684590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_Undeclared: 684690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitSpecialization: 684790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_StrongExternal; 684890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 684990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDeclaration: 685090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis llvm_unreachable("Variable should not be instantiated"); 685190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Fall through to treat this like any other instantiation. 685290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 685390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ExplicitInstantiationDefinition: 685490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_ExplicitTemplateInstantiation; 685590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 685690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis case TSK_ImplicitInstantiation: 685790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return GVA_TemplateInstantiation; 685890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 685990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 686090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 68617530c034c0c71a64c5a9173206d9742ae847af8bDavid Blaikie llvm_unreachable("Invalid Linkage!"); 686290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis} 686390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 68644ac7c0bb39696e92fd220118fedc484c09a69870Argyrios Kyrtzidisbool ASTContext::DeclMustBeEmitted(const Decl *D) { 686590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 686690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (!VD->isFileVarDecl()) 686790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 6868144b38a7995cbe0928e34fbcc865bb2d2be4f7a3Argyrios Kyrtzidis } else if (!isa<FunctionDecl>(D)) 686990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 687090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 6871ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis // Weak references don't produce any output by themselves. 6872ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis if (D->hasAttr<WeakRefAttr>()) 6873ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis return false; 6874ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis 687590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Aliases and used decls are required. 687690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (D->hasAttr<AliasAttr>() || D->hasAttr<UsedAttr>()) 687790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 687890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 687990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 688090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Forward declarations aren't required. 688110620eb5164e31208fcbf0437cd79ae535ed0559Sean Hunt if (!FD->doesThisDeclarationHaveABody()) 6882dce67a70a86db8758c926a76fdd980f5369d5746Nick Lewycky return FD->doesDeclarationForceExternallyVisibleDefinition(); 688390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 688490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Constructors and destructors are required. 688590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (FD->hasAttr<ConstructorAttr>() || FD->hasAttr<DestructorAttr>()) 688690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 688790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 688890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // The key function for a class is required. 688990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 689090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis const CXXRecordDecl *RD = MD->getParent(); 689190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (MD->isOutOfLine() && RD->isDynamicClass()) { 689290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis const CXXMethodDecl *KeyFunc = getKeyFunction(RD); 689390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (KeyFunc && KeyFunc->getCanonicalDecl() == MD->getCanonicalDecl()) 689490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 689590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 689690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 689790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 689890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis GVALinkage Linkage = GetGVALinkageForFunction(FD); 689990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 690090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // static, static inline, always_inline, and extern inline functions can 690190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // always be deferred. Normal inline functions can be deferred in C99/C++. 690290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Implicit template instantiations can also be deferred in C++. 690390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (Linkage == GVA_Internal || Linkage == GVA_C99Inline || 69043a5aca8112e03814f78906dc5d032287adb272b5Anton Yartsev Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) 690590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 690690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 690790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 690894da1587f7d584fc61df793229d197969f204cd9Douglas Gregor 690990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis const VarDecl *VD = cast<VarDecl>(D); 691090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis assert(VD->isFileVarDecl() && "Expected file scoped var"); 691190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 6912ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly) 6913ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis return false; 6914ab411c8c2efed8f2403bf8596e780c0f2f905a19Argyrios Kyrtzidis 691590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // Structs that have non-trivial constructors or destructors are required. 691690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 691790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis // FIXME: Handle references. 6918023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt // FIXME: Be more selective about which constructors we care about. 691990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const RecordType *RT = VD->getType()->getAs<RecordType>()) { 692090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 6921023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt if (RD->hasDefinition() && !(RD->hasTrivialDefaultConstructor() && 6922023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt RD->hasTrivialCopyConstructor() && 6923023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt RD->hasTrivialMoveConstructor() && 6924023df37c27ee8035664fb62f206ca58f4e2a169dSean Hunt RD->hasTrivialDestructor())) 692590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 692690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 692790e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 692890e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 692990e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis GVALinkage L = GetGVALinkageForVariable(VD); 693090e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (L == GVA_Internal || L == GVA_TemplateInstantiation) { 693190e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis if (!(VD->getInit() && VD->getInit()->HasSideEffects(*this))) 693290e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return false; 693390e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis } 693490e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis 693590e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis return true; 693690e99a84ddd020e8fda79643748243725a2ed071Argyrios Kyrtzidis} 6937071cc7deffad608165b1ddd5263e8bf181861520Charles Davis 6938ee743f903858e337434ac0335f147f4de4ecae05Charles DavisCallingConv ASTContext::getDefaultMethodCallConv() { 6939ee743f903858e337434ac0335f147f4de4ecae05Charles Davis // Pass through to the C++ ABI object 6940ee743f903858e337434ac0335f147f4de4ecae05Charles Davis return ABI->getDefaultMethodCallConv(); 6941ee743f903858e337434ac0335f147f4de4ecae05Charles Davis} 6942ee743f903858e337434ac0335f147f4de4ecae05Charles Davis 69434ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadbool ASTContext::isNearlyEmpty(const CXXRecordDecl *RD) const { 6944dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson // Pass through to the C++ ABI object 6945dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson return ABI->isNearlyEmpty(RD); 6946dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson} 6947dae0cb52e4e3d46bbfc9a4510909522197a92e54Anders Carlsson 694814110477887e3dc168ffc6c191e72d705051f99ePeter CollingbourneMangleContext *ASTContext::createMangleContext() { 6949bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor switch (Target->getCXXABI()) { 695014110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne case CXXABI_ARM: 695114110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne case CXXABI_Itanium: 695214110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne return createItaniumMangleContext(*this, getDiagnostics()); 695314110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne case CXXABI_Microsoft: 695414110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne return createMicrosoftMangleContext(*this, getDiagnostics()); 695514110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne } 6956b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unsupported ABI"); 695714110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne} 695814110477887e3dc168ffc6c191e72d705051f99ePeter Collingbourne 6959071cc7deffad608165b1ddd5263e8bf181861520Charles DavisCXXABI::~CXXABI() {} 6960ba29bd25515fbd99e98ba0fedb9d93617b27609eTed Kremenek 6961ba29bd25515fbd99e98ba0fedb9d93617b27609eTed Kremeneksize_t ASTContext::getSideTableAllocatedMemory() const { 69620c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek return ASTRecordLayouts.getMemorySize() 69630c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(ObjCLayouts) 69640c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(KeyFunctions) 69650c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(ObjCImpls) 69660c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(BlockVarCopyInits) 69670c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(DeclAttrs) 69680c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromStaticDataMember) 69690c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromUsingDecl) 69700c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromUsingShadowDecl) 69710c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(InstantiatedFromUnnamedFieldDecl) 69720c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(OverriddenMethods) 69730c8cd1ac55720276ad41fa7b4f8785bead5afd32Ted Kremenek + llvm::capacity_in_bytes(Types) 6974af0f4d0b2e38c810effc8b024ad2fb6604eec5d3Francois Pichet + llvm::capacity_in_bytes(VariableArrayTypes) 69750d95f0d7b81110f77e99e833f766d19be7b7e072Francois Pichet + llvm::capacity_in_bytes(ClassScopeSpecializationPattern); 6976ba29bd25515fbd99e98ba0fedb9d93617b27609eTed Kremenek} 6977d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek 69789e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregorunsigned ASTContext::getLambdaManglingNumber(CXXMethodDecl *CallOperator) { 69799e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregor CXXRecordDecl *Lambda = CallOperator->getParent(); 69809e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregor return LambdaMangleContexts[Lambda->getDeclContext()] 69819e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregor .getManglingNumber(CallOperator); 69829e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregor} 69839e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregor 69849e8c92a9c9b949bbb0408fbbd9a58e34894b6efcDouglas Gregor 6985d211cb709510fbe7e75167b9feee0050851d001aTed Kremenekvoid ASTContext::setParameterIndex(const ParmVarDecl *D, unsigned int index) { 6986d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek ParamIndices[D] = index; 6987d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek} 6988d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek 6989d211cb709510fbe7e75167b9feee0050851d001aTed Kremenekunsigned ASTContext::getParameterIndex(const ParmVarDecl *D) const { 6990d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek ParameterIndexTable::const_iterator I = ParamIndices.find(D); 6991d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek assert(I != ParamIndices.end() && 6992d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek "ParmIndices lacks entry set by ParmVarDecl"); 6993d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek return I->second; 6994d211cb709510fbe7e75167b9feee0050851d001aTed Kremenek} 6995