ASTReader.cpp revision 6e50e00c2fe6a04b2c35592588a4b10a2c269416
15f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--- ASTReader.cpp - AST File Reader ------------------------*- C++ -*-===// 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 defines the ASTReader class, which reads AST files. 115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Serialization/ASTReader.h" 15bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck#include "clang/Serialization/ASTDeserializationListener.h" 1649aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidis#include "ASTCommon.h" 17980e508ca70d6de75d2abfd96b4681fc98bb2698Steve Naroff#include "clang/Frontend/FrontendDiagnostic.h" 18aaba5e346dffdbad5d1c42765a89e4a7afb0da67Douglas Gregor#include "clang/Frontend/Utils.h" 19b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis#include "clang/Sema/Sema.h" 20e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar#include "clang/Sema/Scope.h" 21ea1471e0e967548c596a71469702f8846dbaf3c0John McCall#include "clang/AST/ASTConsumer.h" 222cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor#include "clang/AST/ASTContext.h" 237b90340c9c7d07aef4e301e72b5e8a30d5f4f0c8Argyrios Kyrtzidis#include "clang/AST/Expr.h" 2419cc4abea06a9b49e0e16a50d335c064cd723572Anders Carlsson#include "clang/AST/ExprCXX.h" 251b63e4f732dbc73d90abf886b4d21f8e3a165f6dChris Lattner#include "clang/AST/Type.h" 26a9376d470ccb0eac74fe09a6b2a18a890f1d17c4Chris Lattner#include "clang/AST/TypeLocVisitor.h" 275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Lex/MacroInfo.h" 28f5942a44880be26878592eb052b737579349411eBenjamin Kramer#include "clang/Lex/PreprocessingRecord.h" 2985f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson#include "clang/Lex/Preprocessor.h" 306fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman#include "clang/Lex/HeaderSearch.h" 31f5942a44880be26878592eb052b737579349411eBenjamin Kramer#include "clang/Basic/OnDiskHashTable.h" 32071cc7deffad608165b1ddd5263e8bf181861520Charles Davis#include "clang/Basic/SourceManager.h" 3329445a0542d128cd7ee587ee52229670b9b54a12Anders Carlsson#include "clang/Basic/SourceManagerInternals.h" 345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Basic/FileManager.h" 355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Basic/TargetInfo.h" 361827403a7138946305c0058f262e02b595cf882fDouglas Gregor#include "clang/Basic/Version.h" 371827403a7138946305c0058f262e02b595cf882fDouglas Gregor#include "llvm/ADT/StringExtras.h" 38225843186e3972ce798d3de00f86da9008b15a0eDouglas Gregor#include "llvm/Bitcode/BitstreamReader.h" 39225843186e3972ce798d3de00f86da9008b15a0eDouglas Gregor#include "llvm/Support/MemoryBuffer.h" 40a376d10acfacf19d6dfa41069f7929739a18dd7aDouglas Gregor#include "llvm/Support/ErrorHandling.h" 41a376d10acfacf19d6dfa41069f7929739a18dd7aDouglas Gregor#include "llvm/System/Path.h" 424923aa25eb39d64106a5817c02d560a3aecf8b2cDouglas Gregor#include <algorithm> 434923aa25eb39d64106a5817c02d560a3aecf8b2cDouglas Gregor#include <iterator> 444923aa25eb39d64106a5817c02d560a3aecf8b2cDouglas Gregor#include <cstdio> 455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include <sys/stat.h> 465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang::serialization; 485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 493e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor//===----------------------------------------------------------------------===// 503e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor// PCH validator implementation 513e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor//===----------------------------------------------------------------------===// 523e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 533e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas GregorASTReaderListener::~ASTReaderListener() {} 5461c4d28e36cd3f1be392cb77f07436d1fa6b0f9fDouglas Gregor 553e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregorbool 563e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas GregorPCHValidator::ReadLanguageOptions(const LangOptions &LangOpts) { 573e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor const LangOptions &PPLangOpts = PP.getLangOptions(); 583e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor#define PARSE_LANGOPT_BENIGN(Option) 593e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor#define PARSE_LANGOPT_IMPORTANT(Option, DiagID) \ 603e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor if (PPLangOpts.Option != LangOpts.Option) { \ 613e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor Reader.Diag(DiagID) << LangOpts.Option << PPLangOpts.Option; \ 623e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor return true; \ 633e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor } 643e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 653e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_BENIGN(Trigraphs); 663e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_BENIGN(BCPLComment); 673e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_BENIGN(DollarIdents); 683e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_BENIGN(AsmPreprocessor); 6961c4d28e36cd3f1be392cb77f07436d1fa6b0f9fDouglas Gregor PARSE_LANGOPT_IMPORTANT(GNUMode, diag::warn_pch_gnu_extensions); 703e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(GNUKeywords, diag::warn_pch_gnu_keywords); 713e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_BENIGN(ImplicitInt); 723e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_BENIGN(Digraphs); 733e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_BENIGN(HexFloats); 743e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(C99, diag::warn_pch_c99); 753e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(Microsoft, diag::warn_pch_microsoft_extensions); 763e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(CPlusPlus, diag::warn_pch_cplusplus); 773e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(CPlusPlus0x, diag::warn_pch_cplusplus0x); 783e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_BENIGN(CXXOperatorName); 793e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(ObjC1, diag::warn_pch_objective_c); 803e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(ObjC2, diag::warn_pch_objective_c2); 813e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI, diag::warn_pch_nonfragile_abi); 824ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI2, diag::warn_pch_nonfragile_abi2); 833e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(NoConstantCFStrings, 843e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor diag::warn_pch_no_constant_cfstrings); 853e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_BENIGN(PascalStrings); 863e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_BENIGN(WritableStrings); 873e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(LaxVectorConversions, 883e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor diag::warn_pch_lax_vector_conversions); 893e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(AltiVec, diag::warn_pch_altivec); 903e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(Exceptions, diag::warn_pch_exceptions); 913e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(SjLjExceptions, diag::warn_pch_sjlj_exceptions); 923e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(NeXTRuntime, diag::warn_pch_objc_runtime); 933e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(Freestanding, diag::warn_pch_freestanding); 943e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(NoBuiltin, diag::warn_pch_builtins); 953e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(ThreadsafeStatics, 963e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor diag::warn_pch_thread_safe_statics); 973e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(POSIXThreads, diag::warn_pch_posix_threads); 983e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(Blocks, diag::warn_pch_blocks); 993e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_BENIGN(EmitAllDecls); 1003e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(MathErrno, diag::warn_pch_math_errno); 1013e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_BENIGN(getSignedOverflowBehavior()); 1023e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(HeinousExtensions, 1033e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor diag::warn_pch_heinous_extensions); 1043e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // FIXME: Most of the options below are benign if the macro wasn't 1053e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // used. Unfortunately, this means that a PCH compiled without 1063e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // optimization can't be used with optimization turned on, even 1073e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // though the only thing that changes is whether __OPTIMIZE__ was 1083e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // defined... but if __OPTIMIZE__ never showed up in the header, it 1093e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // doesn't matter. We could consider making this some special kind 1103e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor // of check. 1113e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(Optimize, diag::warn_pch_optimize); 11210738d36b150aa65206890c1c845cdba076e4200Douglas Gregor PARSE_LANGOPT_IMPORTANT(OptimizeSize, diag::warn_pch_optimize_size); 1133e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(Static, diag::warn_pch_static); 1143e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(PICLevel, diag::warn_pch_pic_level); 1153e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(GNUInline, diag::warn_pch_gnu_inline); 1163e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(NoInline, diag::warn_pch_no_inline); 1173e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(AccessControl, diag::warn_pch_access_control); 1183e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(CharIsSigned, diag::warn_pch_char_signed); 1193e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(ShortWChar, diag::warn_pch_short_wchar); 1203e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor if ((PPLangOpts.getGCMode() != 0) != (LangOpts.getGCMode() != 0)) { 1213e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor Reader.Diag(diag::warn_pch_gc_mode) 12261c4d28e36cd3f1be392cb77f07436d1fa6b0f9fDouglas Gregor << LangOpts.getGCMode() << PPLangOpts.getGCMode(); 12361c4d28e36cd3f1be392cb77f07436d1fa6b0f9fDouglas Gregor return true; 12461c4d28e36cd3f1be392cb77f07436d1fa6b0f9fDouglas Gregor } 1253e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_BENIGN(getVisibilityMode()); 1263e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(getStackProtectorMode(), 1273e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor diag::warn_pch_stack_protector); 1283e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_BENIGN(InstantiationDepth); 1293e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(OpenCL, diag::warn_pch_opencl); 1303e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_BENIGN(CatchUndefined); 1313e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_IMPORTANT(ElideConstructors, diag::warn_pch_elide_constructors); 1323e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor PARSE_LANGOPT_BENIGN(SpellChecking); 1333e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor#undef PARSE_LANGOPT_IMPORTANT 1343e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor#undef PARSE_LANGOPT_BENIGN 1353e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 1363e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor return false; 1373e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor} 1383e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor 1393e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregorbool PCHValidator::ReadTargetTriple(llvm::StringRef Triple) { 1403e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor if (Triple == PP.getTargetInfo().getTriple().str()) 1413e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor return false; 142071cc7deffad608165b1ddd5263e8bf181861520Charles Davis 143ee79a4c30e5d1c5285551c9a25b8ec6d45d46aa7John McCall Reader.Diag(diag::warn_pch_target_triple) 144ee79a4c30e5d1c5285551c9a25b8ec6d45d46aa7John McCall << Triple << PP.getTargetInfo().getTriple().str(); 14520cf717034ba1f20fc47c025ecb72ed9b631ad13Charles Davis return true; 146ee79a4c30e5d1c5285551c9a25b8ec6d45d46aa7John McCall} 147ee79a4c30e5d1c5285551c9a25b8ec6d45d46aa7John McCall 148ee79a4c30e5d1c5285551c9a25b8ec6d45d46aa7John McCallstruct EmptyStringRef { 149071cc7deffad608165b1ddd5263e8bf181861520Charles Davis bool operator ()(llvm::StringRef r) const { return r.empty(); } 15020cf717034ba1f20fc47c025ecb72ed9b631ad13Charles Davis}; 15120cf717034ba1f20fc47c025ecb72ed9b631ad13Charles Davisstruct EmptyBlock { 15220cf717034ba1f20fc47c025ecb72ed9b631ad13Charles Davis bool operator ()(const PCHPredefinesBlock &r) const { return r.Data.empty(); } 153ee79a4c30e5d1c5285551c9a25b8ec6d45d46aa7John McCall}; 154071cc7deffad608165b1ddd5263e8bf181861520Charles Davis 155071cc7deffad608165b1ddd5263e8bf181861520Charles Davisstatic bool EqualConcatenations(llvm::SmallVector<llvm::StringRef, 2> L, 15661710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner PCHPredefinesBlocks R) { 157444be7366d0a1e172c0290a1ea54c1cb16b5947cDaniel Dunbar // First, sum up the lengths. 158e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar unsigned LL = 0, RL = 0; 1591b63e4f732dbc73d90abf886b4d21f8e3a165f6dChris Lattner for (unsigned I = 0, N = L.size(); I != N; ++I) { 16063fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor LL += L[I].size(); 161ef99001908e799c388f1363b1e607dad5f5b57d3John McCall } 162ef99001908e799c388f1363b1e607dad5f5b57d3John McCall for (unsigned I = 0, N = R.size(); I != N; ++I) { 163006113841bdae1edb77aef75ba1ffdf2e55a3094Argyrios Kyrtzidis RL += R[I].Data.size(); 164006113841bdae1edb77aef75ba1ffdf2e55a3094Argyrios Kyrtzidis } 165782fa308a765aeac2acb39c4e697c937ec21185bMike Stump if (LL != RL) 166083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump return false; 167bf1a028246d884a540aeafa38e89be59a269b072John McCall if (LL == 0 && RL == 0) 168071cc7deffad608165b1ddd5263e8bf181861520Charles Davis return true; 1692e22253e03e175144aeb9d13350a12fd83f858beDouglas Gregor 170ac9590effa90406767a544005ed1de52e258306bTed Kremenek // Kick out empty parts, they confuse the algorithm below. 171ac9590effa90406767a544005ed1de52e258306bTed Kremenek L.erase(std::remove_if(L.begin(), L.end(), EmptyStringRef()), L.end()); 1729a44b5f5593bd8a385d06b07c564795f643ec8daArgyrios Kyrtzidis R.erase(std::remove_if(R.begin(), R.end(), EmptyBlock()), R.end()); 173f057bf78a69d37ee511430c88852a85eea19ad15Ted Kremenek 174f057bf78a69d37ee511430c88852a85eea19ad15Ted Kremenek // Do it the hard way. At this point, both vectors must be non-empty. 1750f436560640a1cff5b6d96f80f540770f139453fDavid Chisnall llvm::StringRef LR = L[0], RR = R[0].Data; 1760f436560640a1cff5b6d96f80f540770f139453fDavid Chisnall unsigned LI = 0, RI = 0, LN = L.size(), RN = R.size(); 17763fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor (void) RN; 1781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (;;) { 179e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar // Compare the current pieces. 18014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (LR.size() == RR.size()) { 181e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar // If they're the same length, it's pretty easy. 182e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar if (LR != RR) 1835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 1843478eb6872d836600caf45b0f81c2065d685d6e0Ted Kremenek // Both pieces are done, advance. 1853478eb6872d836600caf45b0f81c2065d685d6e0Ted Kremenek ++LI; 1863478eb6872d836600caf45b0f81c2065d685d6e0Ted Kremenek ++RI; 1877d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor // If either string is done, they're both done, since they're the same 18863fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor // length. 18963fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor if (LI == LN) { 19063fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor assert(RI == RN && "Strings not the same length after all?"); 1910054531488928a424666ac11fcdc6bcc5112de52Douglas Gregor return true; 1927d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor } 1937d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor LR = L[LI]; 1947d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor RR = R[RI].Data; 1957d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor } else if (LR.size() < RR.size()) { 1967d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor // Right piece is longer. 1973478eb6872d836600caf45b0f81c2065d685d6e0Ted Kremenek if (!RR.startswith(LR)) 198dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek return false; 19963fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor ++LI; 20063fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor assert(LI != LN && "Strings not the same length after all?"); 20163fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor RR = RR.substr(LR.size()); 20263fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor LR = L[LI]; 20363fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor } else { 20463fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor // Left piece is longer. 20563fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor if (!LR.startswith(RR)) 20663fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor return false; 207dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek ++RI; 208dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek assert(RI != RN && "Strings not the same length after all?"); 209dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek LR = LR.substr(RR.size()); 210dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek RR = R[RI].Data; 211dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek } 212dcfcfbec478f7ed96cd8d92f30c29bd4e30d5b9cTed Kremenek } 2136320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor} 2146320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 2156320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregorstatic std::pair<FileID, llvm::StringRef::size_type> 2166320064d0c60fa8683f5623881c9394fd4aa7689Douglas GregorFindMacro(const PCHPredefinesBlocks &Buffers, llvm::StringRef MacroDef) { 2176320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor std::pair<FileID, llvm::StringRef::size_type> Res; 2186320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor for (unsigned I = 0, N = Buffers.size(); I != N; ++I) { 219ab452ba8323d1985e08bade2bced588cddf2cc28Douglas Gregor Res.second = Buffers[I].Data.find(MacroDef); 2200054531488928a424666ac11fcdc6bcc5112de52Douglas Gregor if (Res.second != llvm::StringRef::npos) { 2210054531488928a424666ac11fcdc6bcc5112de52Douglas Gregor Res.first = Buffers[I].BufferID; 2220054531488928a424666ac11fcdc6bcc5112de52Douglas Gregor break; 2230054531488928a424666ac11fcdc6bcc5112de52Douglas Gregor } 2241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 2252cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor return Res; 2262cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor} 2272cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor 2282cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregorbool PCHValidator::ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers, 2295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::StringRef OriginalFileName, 2305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer std::string &SuggestedPredefines) { 2315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // We are in the context of an implicit include, so the predefines buffer will 2327c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // have a #include entry for the PCH file itself (as normalized by the 233dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor // preprocessor initialization). Find it and skip over it in the checking 2341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // below. 235dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor llvm::SmallString<256> PCHInclude; 236dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor PCHInclude += "#include \""; 237dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor PCHInclude += NormalizeDashIncludePath(OriginalFileName); 238dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor PCHInclude += "\"\n"; 239c2ee10d79f70036af652a395ac1f8273f3d04e12Douglas Gregor std::pair<llvm::StringRef,llvm::StringRef> Split = 2405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::StringRef(PP.getPredefines()).split(PCHInclude.str()); 2415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::StringRef Left = Split.first, Right = Split.second; 242dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor if (Left == PP.getPredefines()) { 2435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Error("Missing PCH include entry!"); 2445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 245dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor } 246dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor 247dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor // If the concatenation of all the PCH buffers is equal to the adjusted 248dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor // command line, we're done. 249dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor llvm::SmallVector<llvm::StringRef, 2> CommandLine; 250dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor CommandLine.push_back(Left); 251dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor CommandLine.push_back(Right); 252dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor if (EqualConcatenations(CommandLine, Buffers)) 253dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor return false; 2541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 255dbe833da54e1b6192991b64fc453cd50b5ee7909Douglas Gregor SourceManager &SourceMgr = PP.getSourceManager(); 256ed8abf18329df67b0abcbb3a10458bd8c1d2a595Douglas Gregor 2574923aa25eb39d64106a5817c02d560a3aecf8b2cDouglas Gregor // The predefines buffers are different. Determine what the differences are, 2581827403a7138946305c0058f262e02b595cf882fDouglas Gregor // and whether they require us to reject the PCH file. 2591827403a7138946305c0058f262e02b595cf882fDouglas Gregor llvm::SmallVector<llvm::StringRef, 8> PCHLines; 2601827403a7138946305c0058f262e02b595cf882fDouglas Gregor for (unsigned I = 0, N = Buffers.size(); I != N; ++I) 261225843186e3972ce798d3de00f86da9008b15a0eDouglas Gregor Buffers[I].Data.split(PCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false); 262225843186e3972ce798d3de00f86da9008b15a0eDouglas Gregor 263225843186e3972ce798d3de00f86da9008b15a0eDouglas Gregor llvm::SmallVector<llvm::StringRef, 8> CmdLineLines; 264a376d10acfacf19d6dfa41069f7929739a18dd7aDouglas Gregor Left.split(CmdLineLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false); 265a376d10acfacf19d6dfa41069f7929739a18dd7aDouglas Gregor Right.split(CmdLineLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false); 266a376d10acfacf19d6dfa41069f7929739a18dd7aDouglas Gregor 2674923aa25eb39d64106a5817c02d560a3aecf8b2cDouglas Gregor // Sort both sets of predefined buffer lines, since we allow some extra 2684923aa25eb39d64106a5817c02d560a3aecf8b2cDouglas Gregor // definitions and they may appear at any point in the output. 2694923aa25eb39d64106a5817c02d560a3aecf8b2cDouglas Gregor std::sort(CmdLineLines.begin(), CmdLineLines.end()); 2702cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor std::sort(PCHLines.begin(), PCHLines.end()); 2712cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor 2722cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor // Determine which predefines that were used to build the PCH file are missing 2732cf2634ffdb4f7c8d46cef3f8e60a55993f1c57aDouglas Gregor // from the command line. 274ed8abf18329df67b0abcbb3a10458bd8c1d2a595Douglas Gregor std::vector<llvm::StringRef> MissingPredefines; 27563fe86bee66fc145942c56b2cc564ea0b9b9ea12Douglas Gregor std::set_difference(PCHLines.begin(), PCHLines.end(), 2765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer CmdLineLines.begin(), CmdLineLines.end(), 2775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer std::back_inserter(MissingPredefines)); 2785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 279e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCall bool MissingDefines = false; 2806b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall bool ConflictingDefines = false; 281e27ec8ad56dbf1efb2de004b90fbbb86f740e3f1John McCall for (unsigned I = 0, N = MissingPredefines.size(); I != N; ++I) { 2826b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall llvm::StringRef Missing = MissingPredefines[I]; 2835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!Missing.startswith("#define ")) { 2845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Reader.Diag(diag::warn_pch_compiler_options_mismatch); 2855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 2865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // This is a macro definition. Determine the name of the macro we're 2895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // defining. 2901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump std::string::size_type StartOfMacroName = strlen("#define "); 2915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer std::string::size_type EndOfMacroName 2925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer = Missing.find_first_of("( \n\r", StartOfMacroName); 2935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(EndOfMacroName != std::string::npos && 29415b91764d08e886391c865c4a444d7b51141c284Eli Friedman "Couldn't find the end of the macro name"); 2955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::StringRef MacroName = Missing.slice(StartOfMacroName, EndOfMacroName); 2965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Determine whether this macro was given a different definition on the 2985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // command line. 2995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer std::string MacroDefStart = "#define " + MacroName.str(); 3005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer std::string::size_type MacroDefLen = MacroDefStart.size(); 3015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::SmallVector<llvm::StringRef, 8>::iterator ConflictPos 3025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer = std::lower_bound(CmdLineLines.begin(), CmdLineLines.end(), 3035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer MacroDefStart); 3041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (; ConflictPos != CmdLineLines.end(); ++ConflictPos) { 3055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!ConflictPos->startswith(MacroDefStart)) { 3065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Different macro; we're done. 3075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ConflictPos = CmdLineLines.end(); 3085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 3095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(ConflictPos->size() > MacroDefLen && 3125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer "Invalid #define in predefines buffer?"); 3135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if ((*ConflictPos)[MacroDefLen] != ' ' && 3145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer (*ConflictPos)[MacroDefLen] != '(') 3155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer continue; // Longer macro name; keep trying. 31664c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 3172df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner // We found a conflicting macro definition. 3182df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner break; 3192df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner } 3202df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner 3213f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner if (ConflictPos != CmdLineLines.end()) { 3223f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner Reader.Diag(diag::warn_cmdline_conflicting_macro_def) 3233f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner << MacroName; 3243f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner 3253f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner // Show the definition of this macro within the PCH file. 3263f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner std::pair<FileID, llvm::StringRef::size_type> MacroLoc = 3273a2503227c3db04a3619735127483263c1075ef7Chris Lattner FindMacro(Buffers, Missing); 32864c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis assert(MacroLoc.second!=llvm::StringRef::npos && "Unable to find macro!"); 329f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith SourceLocation PCHMissingLoc = 330f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith SourceMgr.getLocForStartOfFile(MacroLoc.first) 331f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith .getFileLocWithOffset(MacroLoc.second); 332f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith Reader.Diag(PCHMissingLoc, diag::note_pch_macro_defined_as) << MacroName; 333f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith 334f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith ConflictingDefines = true; 335f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith continue; 336f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith } 337f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith 338f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith // If the macro doesn't conflict, then we'll just pick up the macro 339898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // definition from the PCH file. Warn the user that they made a mistake. 340898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor if (ConflictingDefines) 341898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor continue; // Don't complain if there are already conflicting defs 342898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 343898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor if (!MissingDefines) { 344898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor Reader.Diag(diag::warn_cmdline_missing_macro_defs); 3458e9bebdea69c590dedfbf27374114cb76fe12fbdDouglas Gregor MissingDefines = true; 3462a984cad5ac3fdceeff2bd99daa7b90979313475John McCall } 3472a984cad5ac3fdceeff2bd99daa7b90979313475John McCall 3482a984cad5ac3fdceeff2bd99daa7b90979313475John McCall // Show the definition of this macro within the PCH file. 3491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump std::pair<FileID, llvm::StringRef::size_type> MacroLoc = 350e89d15944dd3be750a09805ad21222d2fa9321faAnders Carlsson FindMacro(Buffers, Missing); 3512a984cad5ac3fdceeff2bd99daa7b90979313475John McCall assert(MacroLoc.second!=llvm::StringRef::npos && "Unable to find macro!"); 3521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SourceLocation PCHMissingLoc = 3535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer SourceMgr.getLocForStartOfFile(MacroLoc.first) 3545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer .getFileLocWithOffset(MacroLoc.second); 3555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Reader.Diag(PCHMissingLoc, diag::note_using_macro_def_from_pch); 3565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3578e9bebdea69c590dedfbf27374114cb76fe12fbdDouglas Gregor 3587e219e47de26346885d667131977bd9ca2d7662aSteve Naroff if (ConflictingDefines) 3591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return true; 360de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff 361de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff // Determine what predefines were introduced based on command-line 362de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff // parameters that were not present when building the PCH 36313dcd00615de5c4279d97bdf63cd5f0a14fd9dccFariborz Jahanian // file. Extra #defines are okay, so long as the identifiers being 3641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // defined were not used within the precompiled header. 36513dcd00615de5c4279d97bdf63cd5f0a14fd9dccFariborz Jahanian std::vector<llvm::StringRef> ExtraPredefines; 366de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff std::set_difference(CmdLineLines.begin(), CmdLineLines.end(), 367de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff PCHLines.begin(), PCHLines.end(), 36813dcd00615de5c4279d97bdf63cd5f0a14fd9dccFariborz Jahanian std::back_inserter(ExtraPredefines)); 36914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff for (unsigned I = 0, N = ExtraPredefines.size(); I != N; ++I) { 370a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek llvm::StringRef &Extra = ExtraPredefines[I]; 3711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (!Extra.startswith("#define ")) { 37233e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian Reader.Diag(diag::warn_pch_compiler_options_mismatch); 37333e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian return true; 3746e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl } 3756e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl 3766e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl // This is an extra macro definition. Determine the name of the 3775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // macro we're defining. 3785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer std::string::size_type StartOfMacroName = strlen("#define "); 37978a916ec5ff5b66adec3c499e1b9af7b87668309Argyrios Kyrtzidis std::string::size_type EndOfMacroName 38078a916ec5ff5b66adec3c499e1b9af7b87668309Argyrios Kyrtzidis = Extra.find_first_of("( \n\r", StartOfMacroName); 38178a916ec5ff5b66adec3c499e1b9af7b87668309Argyrios Kyrtzidis assert(EndOfMacroName != std::string::npos && 38278a916ec5ff5b66adec3c499e1b9af7b87668309Argyrios Kyrtzidis "Couldn't find the end of the macro name"); 3836320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor llvm::StringRef MacroName = Extra.slice(StartOfMacroName, EndOfMacroName); 3846320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 3856320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor // Check whether this name was used somewhere in the PCH file. If 3866320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor // so, defining it as a macro could change behavior, so we reject 3876320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor // the PCH file. 3886320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor if (IdentifierInfo *II = Reader.get(MacroName)) { 3896320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor Reader.Diag(diag::warn_macro_name_used_in_pch) << II; 3906320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor return true; 3916320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor } 3926320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 3936320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor // Add this definition to the suggested predefines buffer. 3946320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor SuggestedPredefines += Extra; 3956320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor SuggestedPredefines += '\n'; 3966320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor } 3976320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 3986320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor // If we get here, it's because the predefines buffer had compatible 3996320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor // contents. Accept the PCH file. 4006320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor return false; 4016320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor} 4026320064d0c60fa8683f5623881c9394fd4aa7689Douglas Gregor 403251b4ff2578e26959a4c036140ccd61c5e9292f2Douglas Gregorvoid PCHValidator::ReadHeaderFileInfo(const HeaderFileInfo &HFI, 404663b5a0be7261c29bc4c526a71cffcfa02d4153eDouglas Gregor unsigned ID) { 4057caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor PP.getHeaderSearchInfo().setHeaderFileInfoForUID(HFI, ID); 406663b5a0be7261c29bc4c526a71cffcfa02d4153eDouglas Gregor ++NumHeaderInfos; 4077caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor} 4087caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor 4097caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregorvoid PCHValidator::ReadCounter(unsigned Value) { 4101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump PP.setCounterValue(Value); 4117caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor} 4127caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor 4137caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor//===----------------------------------------------------------------------===// 4141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump// AST reader implementation 415251b4ff2578e26959a4c036140ccd61c5e9292f2Douglas Gregor//===----------------------------------------------------------------------===// 4169421adc43891e272156fab640e5d5ee5054b779cArgyrios Kyrtzidis 4179421adc43891e272156fab640e5d5ee5054b779cArgyrios Kyrtzidisvoid 4187caa6825f42a0f7e97d6fc06233133c42b218e46Douglas GregorASTReader::setDeserializationListener(ASTDeserializationListener *Listener) { 4197caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor DeserializationListener = Listener; 4207caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor if (DeserializationListener) 4217caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor DeserializationListener->SetReader(this); 422251b4ff2578e26959a4c036140ccd61c5e9292f2Douglas Gregor} 4239421adc43891e272156fab640e5d5ee5054b779cArgyrios Kyrtzidis 4247caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregor 4257caa6825f42a0f7e97d6fc06233133c42b218e46Douglas Gregornamespace { 4267ba107a1863ddfa1664555854f0d7bdb3c491c92John McCallclass ASTSelectorLookupTrait { 427ed97649e9574b9d854fa4d6109c9333ae0993554John McCall ASTReader &Reader; 4287ba107a1863ddfa1664555854f0d7bdb3c491c92John McCall 429ed97649e9574b9d854fa4d6109c9333ae0993554John McCallpublic: 430ed97649e9574b9d854fa4d6109c9333ae0993554John McCall struct data_type { 4310d8df780aef1acda5962347a32591efc629b6748Anders Carlsson SelectorID ID; 4321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ObjCMethodList Instance, Factory; 4330d8df780aef1acda5962347a32591efc629b6748Anders Carlsson }; 4340d8df780aef1acda5962347a32591efc629b6748Anders Carlsson 4350d8df780aef1acda5962347a32591efc629b6748Anders Carlsson typedef Selector external_key_type; 4360d8df780aef1acda5962347a32591efc629b6748Anders Carlsson typedef external_key_type internal_key_type; 437ed97649e9574b9d854fa4d6109c9333ae0993554John McCall 438ed97649e9574b9d854fa4d6109c9333ae0993554John McCall explicit ASTSelectorLookupTrait(ASTReader &Reader) : Reader(Reader) { } 439ed97649e9574b9d854fa4d6109c9333ae0993554John McCall 440ed97649e9574b9d854fa4d6109c9333ae0993554John McCall static bool EqualKey(const internal_key_type& a, 441ed97649e9574b9d854fa4d6109c9333ae0993554John McCall const internal_key_type& b) { 442ed97649e9574b9d854fa4d6109c9333ae0993554John McCall return a == b; 443ed97649e9574b9d854fa4d6109c9333ae0993554John McCall } 444ed97649e9574b9d854fa4d6109c9333ae0993554John McCall 445ed97649e9574b9d854fa4d6109c9333ae0993554John McCall static unsigned ComputeHash(Selector Sel) { 446ed97649e9574b9d854fa4d6109c9333ae0993554John McCall return serialization::ComputeHash(Sel); 447ed97649e9574b9d854fa4d6109c9333ae0993554John McCall } 448ed97649e9574b9d854fa4d6109c9333ae0993554John McCall 449ed97649e9574b9d854fa4d6109c9333ae0993554John McCall // This hopefully will just get inlined and removed by the optimizer. 450ed97649e9574b9d854fa4d6109c9333ae0993554John McCall static const internal_key_type& 451ed97649e9574b9d854fa4d6109c9333ae0993554John McCall GetInternalKey(const external_key_type& x) { return x; } 452ed97649e9574b9d854fa4d6109c9333ae0993554John McCall 453ed97649e9574b9d854fa4d6109c9333ae0993554John McCall static std::pair<unsigned, unsigned> 454ed97649e9574b9d854fa4d6109c9333ae0993554John McCall ReadKeyDataLength(const unsigned char*& d) { 455ed97649e9574b9d854fa4d6109c9333ae0993554John McCall using namespace clang::io; 456ed97649e9574b9d854fa4d6109c9333ae0993554John McCall unsigned KeyLen = ReadUnalignedLE16(d); 457ed97649e9574b9d854fa4d6109c9333ae0993554John McCall unsigned DataLen = ReadUnalignedLE16(d); 458ed97649e9574b9d854fa4d6109c9333ae0993554John McCall return std::make_pair(KeyLen, DataLen); 459ed97649e9574b9d854fa4d6109c9333ae0993554John McCall } 460ed97649e9574b9d854fa4d6109c9333ae0993554John McCall 4610d8df780aef1acda5962347a32591efc629b6748Anders Carlsson internal_key_type ReadKey(const unsigned char* d, unsigned) { 4620d8df780aef1acda5962347a32591efc629b6748Anders Carlsson using namespace clang::io; 463d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson SelectorTable &SelTable = Reader.getContext()->Selectors; 464d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson unsigned N = ReadUnalignedLE16(d); 465d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson IdentifierInfo *FirstII 466d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson = Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d)); 467d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson if (N == 0) 4681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return SelTable.getNullarySelector(FirstII); 469d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson else if (N == 1) 470d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson return SelTable.getUnarySelector(FirstII); 471d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson 472d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson llvm::SmallVector<IdentifierInfo *, 16> Args; 473d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson Args.push_back(FirstII); 474d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson for (unsigned I = 1; I != N; ++I) 475d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson Args.push_back(Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d))); 476d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson 477d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson return SelTable.getSelector(N, Args.data()); 4781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 479d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson 480d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson data_type ReadData(Selector, const unsigned char* d, unsigned DataLen) { 481d8b285fee4471f393da8ee30f552ceacdc362afaAnders Carlsson using namespace clang::io; 4827d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 4837d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor data_type Result; 4847d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 4857d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor Result.ID = ReadUnalignedLE32(d); 4867d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor unsigned NumInstanceMethods = ReadUnalignedLE16(d); 4877d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor unsigned NumFactoryMethods = ReadUnalignedLE16(d); 4887d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 4897d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor // Load instance methods 4907d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor ObjCMethodList *Prev = 0; 4917d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor for (unsigned I = 0; I != NumInstanceMethods; ++I) { 4927d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor ObjCMethodDecl *Method 4937d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor = cast<ObjCMethodDecl>(Reader.GetDecl(ReadUnalignedLE32(d))); 4947d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor if (!Result.Instance.Method) { 4957d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor // This is the first method, which is the easy case. 4967d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor Result.Instance.Method = Method; 4977d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor Prev = &Result.Instance; 4987d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor continue; 4997d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor } 5007d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor 5017d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor ObjCMethodList *Mem = 502c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>(); 503c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis Prev->Next = new (Mem) ObjCMethodList(Method, 0); 504c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis Prev = Prev->Next; 505c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis } 506c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis 507c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis // Load factory methods 508c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis Prev = 0; 509c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis for (unsigned I = 0; I != NumFactoryMethods; ++I) { 510c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis ObjCMethodDecl *Method 511c91e9f439ae85d5f79a6b65672f1d7d1b55ccda0Argyrios Kyrtzidis = cast<ObjCMethodDecl>(Reader.GetDecl(ReadUnalignedLE32(d))); 5127d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor if (!Result.Factory.Method) { 5137d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor // This is the first method, which is the easy case. 5147d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor Result.Factory.Method = Method; 5157d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor Prev = &Result.Factory; 5167d10b7eb670b821741b4c96f6cf7afbc3bb39abeDouglas Gregor continue; 517464175bba1318bef7905122e9fda20cff926df78Chris Lattner } 518464175bba1318bef7905122e9fda20cff926df78Chris Lattner 519464175bba1318bef7905122e9fda20cff926df78Chris Lattner ObjCMethodList *Mem = 520a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>(); 521b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner Prev->Next = new (Mem) ObjCMethodList(Method, 0); 522b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner Prev = Prev->Next; 523b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner } 524183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall 525b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner return Result; 526b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner } 527b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner}; 528b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner 529b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner} // end anonymous namespace 530b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner 531b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner/// \brief The on-disk hash table used for the global method pool. 532b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattnertypedef OnDiskChainedHashTable<ASTSelectorLookupTrait> 533b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner ASTSelectorLookupTable; 5348b752f10c394b140f9ef89e049cbad1a7676fc25Ken Dyck 535af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattnernamespace { 536af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattnerclass ASTIdentifierLookupTrait { 5375d484e8cf710207010720589d89602233de61d01Sebastian Redl ASTReader &Reader; 5385d484e8cf710207010720589d89602233de61d01Sebastian Redl llvm::BitstreamCursor &Stream; 5394ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad 540dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman // If we know the IdentifierInfo in advance, it is here and we will 541dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman // not build a new one. Used when deserializing information about an 5424081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall // identifier that was constructed before the AST file was read. 5434081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall IdentifierInfo *KnownII; 5444081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall 5454081a5c5f1381c4ec77f8ab3866693917e4329c4John McCallpublic: 5464081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall typedef IdentifierInfo * data_type; 5474081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall 5484081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall typedef const std::pair<const char*, unsigned> external_key_type; 5494081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall 5504081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall typedef external_key_type internal_key_type; 5514081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall 5524081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall ASTIdentifierLookupTrait(ASTReader &Reader, llvm::BitstreamCursor &Stream, 5534081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall IdentifierInfo *II = 0) 5544081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall : Reader(Reader), Stream(Stream), KnownII(II) { } 5554081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall 5564081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall static bool EqualKey(const internal_key_type& a, 5574081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall const internal_key_type& b) { 5584081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall return (a.second == b.second) ? memcmp(a.first, b.first, a.second) == 0 559dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman : false; 5604081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall } 5614081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall 5624081a5c5f1381c4ec77f8ab3866693917e4329c4John McCall static unsigned ComputeHash(const internal_key_type& a) { 563af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner return llvm::HashString(llvm::StringRef(a.first, a.second)); 5646217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek } 5655d484e8cf710207010720589d89602233de61d01Sebastian Redl 5665d484e8cf710207010720589d89602233de61d01Sebastian Redl // This hopefully will just get inlined and removed by the optimizer. 5675d484e8cf710207010720589d89602233de61d01Sebastian Redl static const internal_key_type& 5685d484e8cf710207010720589d89602233de61d01Sebastian Redl GetInternalKey(const external_key_type& x) { return x; } 5695d484e8cf710207010720589d89602233de61d01Sebastian Redl 5705d484e8cf710207010720589d89602233de61d01Sebastian Redl static std::pair<unsigned, unsigned> 5716deecb0d46bcfd048e651d2db7c4fb0d6407da96Rafael Espindola ReadKeyDataLength(const unsigned char*& d) { 5726deecb0d46bcfd048e651d2db7c4fb0d6407da96Rafael Espindola using namespace clang::io; 5736deecb0d46bcfd048e651d2db7c4fb0d6407da96Rafael Espindola unsigned DataLen = ReadUnalignedLE16(d); 5746deecb0d46bcfd048e651d2db7c4fb0d6407da96Rafael Espindola unsigned KeyLen = ReadUnalignedLE16(d); 5756deecb0d46bcfd048e651d2db7c4fb0d6407da96Rafael Espindola return std::make_pair(KeyLen, DataLen); 5766deecb0d46bcfd048e651d2db7c4fb0d6407da96Rafael Espindola } 5776deecb0d46bcfd048e651d2db7c4fb0d6407da96Rafael Espindola 5786deecb0d46bcfd048e651d2db7c4fb0d6407da96Rafael Espindola static std::pair<const char*, unsigned> 5796deecb0d46bcfd048e651d2db7c4fb0d6407da96Rafael Espindola ReadKey(const unsigned char* d, unsigned n) { 5804cc2cfd48d7c2d11141871cad590db7b52ce00a0Anders Carlsson assert(n >= 2 && d[n-1] == '\0'); 581dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman return std::make_pair((const char*) d, n-1); 582dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman } 583dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman 584dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman IdentifierInfo *ReadData(const internal_key_type& k, 585dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman const unsigned char* d, 58605f62474dd2b0f1cb69adbe0787f2868788aa949Charles Davis unsigned DataLen) { 58705f62474dd2b0f1cb69adbe0787f2868788aa949Charles Davis using namespace clang::io; 58805f62474dd2b0f1cb69adbe0787f2868788aa949Charles Davis IdentID ID = ReadUnalignedLE32(d); 58905f62474dd2b0f1cb69adbe0787f2868788aa949Charles Davis bool IsInteresting = ID & 0x01; 59005f62474dd2b0f1cb69adbe0787f2868788aa949Charles Davis 59105f62474dd2b0f1cb69adbe0787f2868788aa949Charles Davis // Wipe out the "is interesting" bit. 592af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner ID = ID >> 1; 593dcdafb6a701aa9d81edcb088915f58933315dc05Eli Friedman 5948b752f10c394b140f9ef89e049cbad1a7676fc25Ken Dyck if (!IsInteresting) { 595af707ab8fbb9451e8febb8d766f6c043628125c4Chris Lattner // For uninteresting identifiers, just build the IdentifierInfo 596b7cfe88e88cb4f46308de89cf3f0c81bfe624128Chris Lattner // and associate it with the persistent ID. 597ea1471e0e967548c596a71469702f8846dbaf3c0John McCall IdentifierInfo *II = KnownII; 598ea1471e0e967548c596a71469702f8846dbaf3c0John McCall if (!II) 599ea1471e0e967548c596a71469702f8846dbaf3c0John McCall II = &Reader.getIdentifierTable().getOwn(k.first, k.first + k.second); 600ea1471e0e967548c596a71469702f8846dbaf3c0John McCall Reader.SetIdentifierInfo(ID, II); 601ea1471e0e967548c596a71469702f8846dbaf3c0John McCall II->setIsFromAST(); 602ea1471e0e967548c596a71469702f8846dbaf3c0John McCall return II; 603ea1471e0e967548c596a71469702f8846dbaf3c0John McCall } 604ea1471e0e967548c596a71469702f8846dbaf3c0John McCall 605ea1471e0e967548c596a71469702f8846dbaf3c0John McCall unsigned Bits = ReadUnalignedLE16(d); 606ea1471e0e967548c596a71469702f8846dbaf3c0John McCall bool CPlusPlusOperatorKeyword = Bits & 0x01; 607ea1471e0e967548c596a71469702f8846dbaf3c0John McCall Bits >>= 1; 608ea1471e0e967548c596a71469702f8846dbaf3c0John McCall bool HasRevertedTokenIDToIdentifier = Bits & 0x01; 609a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner Bits >>= 1; 610a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner bool Poisoned = Bits & 0x01; 6110953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Bits >>= 1; 6120953e767ff7817f97b3ab20896b229891eeff45bJohn McCall bool ExtensionToken = Bits & 0x01; 6130953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Bits >>= 1; 6140953e767ff7817f97b3ab20896b229891eeff45bJohn McCall bool hasMacroDefinition = Bits & 0x01; 615d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner Bits >>= 1; 6164ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad unsigned ObjCOrBuiltinID = Bits & 0x3FF; 6175e301007e31e14c8ff647288e1b8bd8dbf8a5fe4Mike Stump Bits >>= 10; 6185e301007e31e14c8ff647288e1b8bd8dbf8a5fe4Mike Stump 619a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner assert(Bits == 0 && "Extra bits in the identifier?"); 62072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor DataLen -= 6; 62172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 62218857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor // Build the IdentifierInfo itself and link the identifier ID with 62372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor // the new IdentifierInfo. 62472564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor IdentifierInfo *II = KnownII; 62518857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor if (!II) 62672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor II = &Reader.getIdentifierTable().getOwn(k.first, k.first + k.second); 62772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor Reader.SetIdentifierInfo(ID, II); 6285d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner 6295d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner // Set or check the various bits in the IdentifierInfo structure. 63018857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor // Token IDs are read-only. 63118857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor if (HasRevertedTokenIDToIdentifier) 63218857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor II->RevertTokenIDToIdentifier(); 63318857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor II->setObjCOrBuiltinID(ObjCOrBuiltinID); 63418857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor assert(II->isExtensionToken() == ExtensionToken && 63572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor "Incorrect extension token flag"); 636fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff (void)ExtensionToken; 63718857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor II->setIsPoisoned(Poisoned); 63818857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword && 63918857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor "Incorrect C++ operator keyword flag"); 64018857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor (void)CPlusPlusOperatorKeyword; 641fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff 6421d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar // If this identifier is a macro, deserialize the macro 6431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // definition. 64498be4943e8dc4f3905629a7102668960873cf863Chris Lattner if (hasMacroDefinition) { 6459e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner uint32_t Offset = ReadUnalignedLE32(d); 646030d8846c7e520330007087e949f621989876e3aChris Lattner Reader.ReadMacroRecord(Stream, Offset); 647030d8846c7e520330007087e949f621989876e3aChris Lattner DataLen -= 4; 6485c09a02a5db85e08a432b6eeced9aa656349710dChristopher Lamb } 649213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman 650030d8846c7e520330007087e949f621989876e3aChris Lattner // Read all of the declarations visible at global scope with this 6519fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner // name. 6529fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner if (Reader.getContext() == 0) return II; 6539fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner if (DataLen > 0) { 6544bd998bbc228915d2b9cae5b67879de48940d05eEli Friedman llvm::SmallVector<uint32_t, 4> DeclIDs; 6556fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman for (; DataLen > 0; DataLen -= 4) 6566fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman DeclIDs.push_back(ReadUnalignedLE32(d)); 6578eefcd353c1d06a10104f69e5079ebab3183f9a3Dan Gohman Reader.SetGloballyVisibleDecls(II, DeclIDs); 6589fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner } 6599fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner 6609fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner II->setIsFromAST(); 661030d8846c7e520330007087e949f621989876e3aChris Lattner return II; 662030d8846c7e520330007087e949f621989876e3aChris Lattner } 6635d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner}; 6649e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner 665a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner} // end anonymous namespace 666692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner 667d2d2a11a91d7ddf468bfb70f66362d24806ed601Chris Lattner/// \brief The on-disk hash table used to contain information about 66818857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor/// all of the identifiers in the program. 66918857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregortypedef OnDiskChainedHashTable<ASTIdentifierLookupTrait> 67018857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor ASTIdentifierLookupTable; 67118857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 67218857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregornamespace { 6736f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattnerclass ASTDeclContextNameLookupTrait { 6749e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner ASTReader &Reader; 6759e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner 6766f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattnerpublic: 677692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner /// \brief Pair of begin/end iterators for DeclIDs. 678692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner typedef std::pair<DeclID *, DeclID *> data_type; 679692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner 6806f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner /// \brief Special internal key for declaration names. 6819e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner /// The hash table creates keys for comparison; we do not create 6829e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner /// a DeclarationName for the internal key to avoid deserializing types. 6836f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner struct DeclNameKey { 6843f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner DeclarationName::NameKind Kind; 6853f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner uint64_t Data; 68664c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis DeclNameKey() : Kind((DeclarationName::NameKind)0), Data(0) { } 68764c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis }; 68864c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 689f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith typedef DeclarationName external_key_type; 690f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith typedef DeclNameKey internal_key_type; 691f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith 692f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith explicit ASTDeclContextNameLookupTrait(ASTReader &Reader) : Reader(Reader) { } 693f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith 694f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith static bool EqualKey(const internal_key_type& a, 695f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith const internal_key_type& b) { 696f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith return a.Kind == b.Kind && a.Data == b.Data; 697692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner } 6986f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner 6999e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner unsigned ComputeHash(const DeclNameKey &Key) const { 7009e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner llvm::FoldingSetNodeID ID; 7016f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner ID.AddInteger(Key.Kind); 702692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner 7036f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner switch (Key.Kind) { 7049e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner case DeclarationName::Identifier: 7059e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner case DeclarationName::CXXLiteralOperatorName: 7066f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner ID.AddString(((IdentifierInfo*)Key.Data)->getName()); 707692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner break; 7086f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case DeclarationName::ObjCZeroArgSelector: 7099e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner case DeclarationName::ObjCOneArgSelector: 7109e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner case DeclarationName::ObjCMultiArgSelector: 7116f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner ID.AddInteger(serialization::ComputeHash(Selector(Key.Data))); 712692233e90a99c3a81dd04879d36eb9688f137c44Chris Lattner break; 7136f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner case DeclarationName::CXXConstructorName: 7149e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner case DeclarationName::CXXDestructorName: 7159e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner case DeclarationName::CXXConversionFunctionName: 7166f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner ID.AddInteger((TypeID)Key.Data); 717ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner break; 718ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner case DeclarationName::CXXOperatorName: 719ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner ID.AddInteger((OverloadedOperatorKind)Key.Data); 720ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner break; 721ec16cb9b5a481d62a73ad47fa59034ced4d62022Chris Lattner case DeclarationName::CXXUsingDirective: 7226f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner break; 7239e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner } 7249e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner 7256f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner return ID.ComputeHash(); 7266f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner } 7275426bf6456a5aeac416a9150de157904d101c819Chris Lattner 7285426bf6456a5aeac416a9150de157904d101c819Chris Lattner internal_key_type GetInternalKey(const external_key_type& Name) const { 7296f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner DeclNameKey Key; 7306f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner Key.Kind = Name.getNameKind(); 7319e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner switch (Name.getNameKind()) { 7329e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner case DeclarationName::Identifier: 7336f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner Key.Data = (uint64_t)Name.getAsIdentifierInfo(); 7346e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl break; 7356e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl case DeclarationName::ObjCZeroArgSelector: 7366e8ed16ffef02b82995a90bdcf10ffff7d63839aSebastian Redl case DeclarationName::ObjCOneArgSelector: 7371590d9c0fec4c710c2962e4bb71f76979b5163d3Sebastian Redl case DeclarationName::ObjCMultiArgSelector: 738e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr(); 739e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian break; 740e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian case DeclarationName::CXXConstructorName: 741e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian case DeclarationName::CXXDestructorName: 742e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian case DeclarationName::CXXConversionFunctionName: 743e04f5fc25cf49e8a5b836459d836c20dc3229a95Fariborz Jahanian Key.Data = Reader.GetTypeID(Name.getCXXNameType()); 744a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner break; 745bfef6d7c67831a135d6ab79931f010f750a730adChris Lattner case DeclarationName::CXXOperatorName: 746d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff Key.Data = Name.getCXXOverloadedOperator(); 7475426bf6456a5aeac416a9150de157904d101c819Chris Lattner break; 748f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner case DeclarationName::CXXLiteralOperatorName: 7496f62c2abd8077bf70d2166d37e8caa426b34d8e4Chris Lattner Key.Data = (uint64_t)Name.getCXXLiteralIdentifier(); 750485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff break; 751485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff case DeclarationName::CXXUsingDirective: 752485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff break; 753485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff } 754485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff 755485eeff9ba73376c8e01179bf1a501b1723446cbSteve Naroff return Key; 7565d484e8cf710207010720589d89602233de61d01Sebastian Redl } 7575d484e8cf710207010720589d89602233de61d01Sebastian Redl 7585d484e8cf710207010720589d89602233de61d01Sebastian Redl external_key_type GetExternalKey(const internal_key_type& Key) const { 7595d484e8cf710207010720589d89602233de61d01Sebastian Redl ASTContext *Context = Reader.getContext(); 7605d484e8cf710207010720589d89602233de61d01Sebastian Redl switch (Key.Kind) { 7615d484e8cf710207010720589d89602233de61d01Sebastian Redl case DeclarationName::Identifier: 7625d484e8cf710207010720589d89602233de61d01Sebastian Redl return DeclarationName((IdentifierInfo*)Key.Data); 7635d484e8cf710207010720589d89602233de61d01Sebastian Redl 7645d484e8cf710207010720589d89602233de61d01Sebastian Redl case DeclarationName::ObjCZeroArgSelector: 765f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner case DeclarationName::ObjCOneArgSelector: 766f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner case DeclarationName::ObjCMultiArgSelector: 7675426bf6456a5aeac416a9150de157904d101c819Chris Lattner return DeclarationName(Selector(Key.Data)); 768f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner 769f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner case DeclarationName::CXXConstructorName: 770f72a44330b9d9a4b2d93e9b91cfb8ab7bd4a0643Chris Lattner return Context->DeclarationNames.getCXXConstructorName( 771f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl Context->getCanonicalType(Reader.GetType(Key.Data))); 772071cc7deffad608165b1ddd5263e8bf181861520Charles Davis 7731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case DeclarationName::CXXDestructorName: 7741cca74ef3627a3a0ab14501d23e336548f6611b2Anders Carlsson return Context->DeclarationNames.getCXXDestructorName( 775071cc7deffad608165b1ddd5263e8bf181861520Charles Davis Context->getCanonicalType(Reader.GetType(Key.Data))); 7761cca74ef3627a3a0ab14501d23e336548f6611b2Anders Carlsson 7771cca74ef3627a3a0ab14501d23e336548f6611b2Anders Carlsson case DeclarationName::CXXConversionFunctionName: 778f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl return Context->DeclarationNames.getCXXConversionFunctionName( 7795d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner Context->getCanonicalType(Reader.GetType(Key.Data))); 7805d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner 7815d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner case DeclarationName::CXXOperatorName: 7821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Context->DeclarationNames.getCXXOperatorName( 78398be4943e8dc4f3905629a7102668960873cf863Chris Lattner (OverloadedOperatorKind)Key.Data); 7849e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner 7855d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner case DeclarationName::CXXLiteralOperatorName: 7865d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner return Context->DeclarationNames.getCXXLiteralOperatorName( 7875d2a6303467184b1f159bb6556efc434e50e3c28Chris Lattner (IdentifierInfo*)Key.Data); 788c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 789c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case DeclarationName::CXXUsingDirective: 79044a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel return DeclarationName::getUsingDirectiveName(); 7911d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar } 79244a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel 79344a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel llvm_unreachable("Invalid Name Kind ?"); 79444a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel } 79544a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel 79644a3dded8080c5c9cfdad208ade8f8f7850d9a4fDevang Patel static std::pair<unsigned, unsigned> 79772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor ReadKeyDataLength(const unsigned char*& d) { 79872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor using namespace clang::io; 7991d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar unsigned KeyLen = ReadUnalignedLE16(d); 8001d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar unsigned DataLen = ReadUnalignedLE16(d); 8011d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar return std::make_pair(KeyLen, DataLen); 8028389eab190afef3462f6418b8d8fb70fb01c4005Chris Lattner } 8038389eab190afef3462f6418b8d8fb70fb01c4005Chris Lattner 8048389eab190afef3462f6418b8d8fb70fb01c4005Chris Lattner internal_key_type ReadKey(const unsigned char* d, unsigned) { 8058389eab190afef3462f6418b8d8fb70fb01c4005Chris Lattner using namespace clang::io; 8061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 8071d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar DeclNameKey Key; 8087176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner Key.Kind = (DeclarationName::NameKind)*d++; 8097176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner switch (Key.Kind) { 8101d75118af76cae2bfc06389cde410e14bd0a19fcDaniel Dunbar case DeclarationName::Identifier: 8117176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner Key.Data = (uint64_t)Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d)); 8127176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner break; 8137176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner case DeclarationName::ObjCZeroArgSelector: 814dc0d73e6495404418acf8548875aeaff07791a74Chris Lattner case DeclarationName::ObjCOneArgSelector: 815a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner case DeclarationName::ObjCMultiArgSelector: 8167532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor Key.Data = 8179fcfe926432f3c3f7e9a61219e55c352fd358e45Chris Lattner (uint64_t)Reader.DecodeSelector(ReadUnalignedLE32(d)).getAsOpaquePtr(); 81849a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall break; 81949a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall case DeclarationName::CXXConstructorName: 82049a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall case DeclarationName::CXXDestructorName: 821075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara case DeclarationName::CXXConversionFunctionName: 822075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara Key.Data = ReadUnalignedLE32(d); // TypeID 823075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara break; 82418857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor case DeclarationName::CXXOperatorName: 82518857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Key.Data = *d++; // OverloadedOperatorKind 826df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor break; 827df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor case DeclarationName::CXXLiteralOperatorName: 828df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor Key.Data = (uint64_t)Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d)); 829df1367af26cb2959775e9511108f12dcd2370a27Douglas Gregor break; 8307532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor case DeclarationName::CXXUsingDirective: 8317176331b0f5cfaaa2b5aa487a6660e859e371119Chris Lattner break; 83218857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor } 83318857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 83418857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor return Key; 83518857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor } 83618857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 83718857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor data_type ReadData(internal_key_type, const unsigned char* d, 83818857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor unsigned DataLen) { 83918857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor using namespace clang::io; 840395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson unsigned NumDecls = ReadUnalignedLE16(d); 841395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson DeclID *Start = (DeclID *)d; 842395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson return std::make_pair(Start, Start + NumDecls); 843395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson } 844465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara}; 845465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara 8461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump} // end anonymous namespace 8479d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 8489d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall/// \brief The on-disk hash table used for the DeclContext's Name lookup table. 8499d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCalltypedef OnDiskChainedHashTable<ASTDeclContextNameLookupTrait> 8509d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall ASTDeclContextNameLookupTable; 85118857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor 8521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpbool ASTReader::ReadDeclContextStorage(llvm::BitstreamCursor &Cursor, 85318857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor const std::pair<uint64_t, uint64_t> &Offsets, 85418857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor DeclContextInfo &Info) { 85518857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor SavedStreamPosition SavedPosition(Cursor); 85618857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor // First the lexical decls. 85718857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor if (Offsets.first != 0) { 85818857644059c45da6776f1a288eec7b4cf3a844aDouglas Gregor Cursor.JumpToBit(Offsets.first); 8591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 860464175bba1318bef7905122e9fda20cff926df78Chris Lattner RecordData Record; 8619e9b6dc3fd413f5341fab54b681420eeb21cd169Chris Lattner const char *Blob; 862a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner unsigned BlobLen; 863a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner unsigned Code = Cursor.ReadCode(); 864bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen); 865bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck if (RecCode != DECL_CONTEXT_LEXICAL) { 8664ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Error("Expected lexical block"); 867199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck return true; 868bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck } 8694ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad 870199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck Info.LexicalDecls = reinterpret_cast<const DeclID*>(Blob); 871bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck Info.NumLexicalDecls = BlobLen / sizeof(DeclID); 872bdc601b196c48d4cd56a5ceb45d41ae4e87371abKen Dyck } else { 87316e20cce43385001f33f8e3f90ee345609c805d1Ken Dyck Info.LexicalDecls = 0; 87486fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck Info.NumLexicalDecls = 0; 8754ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad } 87686fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck 87786fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck // Now the lookup table. 8784ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (Offsets.second != 0) { 87986fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck Cursor.JumpToBit(Offsets.second); 88086fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck 88186fa4311c8a330957ff5b765fbb0a7750ecd38c9Ken Dyck RecordData Record; 88234ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner const char *Blob; 88334ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner unsigned BlobLen; 88434ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner unsigned Code = Cursor.ReadCode(); 88534ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen); 8864ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (RecCode != DECL_CONTEXT_VISIBLE) { 88734ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner Error("Expected visible lookup table block"); 8881eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman return true; 8891eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman } 890183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall Info.NameLookupTableData 8911eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman = ASTDeclContextNameLookupTable::Create( 8921eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman (const unsigned char *)Blob + Record[0], 8931eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman (const unsigned char *)Blob, 8941eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman ASTDeclContextNameLookupTrait(*this)); 8951eed60297ef4701b899c6a3b9680bf08f3403422Eli Friedman } else { 89634ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner Info.NameLookupTableData = 0; 89734ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner } 89834ebde404dc17d89487b07e6daaf1b47d5dfee39Chris Lattner 8998e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian return false; 9008e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian} 9018e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian 9028e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanianvoid ASTReader::Error(const char *Msg) { 9034ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Diag(diag::err_fe_pch_malformed) << Msg; 9042c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian} 9052c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian 9062c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// \brief Tell the AST listener about the predefines buffers in the chain. 9072c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanianbool ASTReader::CheckPredefinesBuffers() { 9082c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian if (Listener) 9092c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian return Listener->ReadPredefinesBuffer(PCHPredefinesBuffers, 9102c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian ActualOriginalFileName, 9112c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian SuggestedPredefines); 9122c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian return false; 9132c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian} 9142c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian 9152c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian//===----------------------------------------------------------------------===// 9162c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian// Source Manager Deserialization 9179820074dd47d37681085e964cd3392ac0b3e67b9Fariborz Jahanian//===----------------------------------------------------------------------===// 9182c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian 9192c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian/// \brief Read the line table in the source manager block. 9204ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad/// \returns true if ther was an error. 9212c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanianbool ASTReader::ParseLineTable(llvm::SmallVectorImpl<uint64_t> &Record) { 9222c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian unsigned Idx = 0; 9232c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian LineTableInfo &LineTable = SourceMgr.getLineTable(); 9242c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian 9252c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian // Parse the file names 92611062e11236b7bc689dad150e8b490fd6b063ec3Fariborz Jahanian std::map<int, int> FileIDs; 92711062e11236b7bc689dad150e8b490fd6b063ec3Fariborz Jahanian for (int I = 0, N = Record[Idx++]; I != N; ++I) { 9282c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian // Extract the file name 9292c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian unsigned FilenameLen = Record[Idx++]; 9309820074dd47d37681085e964cd3392ac0b3e67b9Fariborz Jahanian std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen); 9319820074dd47d37681085e964cd3392ac0b3e67b9Fariborz Jahanian Idx += FilenameLen; 932e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian MaybeAddSystemRootToFilename(Filename); 933e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian FileIDs[I] = LineTable.getLineTableFilenameID(Filename.c_str(), 934e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian Filename.size()); 935432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian } 936e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 93753b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek // Parse the line entries 93853b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek std::vector<LineEntry> Entries; 93953b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek while (Idx < Record.size()) { 94053b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek int FID = Record[Idx++]; 941e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 942432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian // Extract the line entries 943e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian unsigned NumEntries = Record[Idx++]; 944b2f812165676230bce5d0215e49a4749c451ca9cFariborz Jahanian assert(NumEntries && "Numentries is 00000"); 945b2f812165676230bce5d0215e49a4749c451ca9cFariborz Jahanian Entries.clear(); 946e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian Entries.reserve(NumEntries); 947e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian for (unsigned I = 0; I != NumEntries; ++I) { 948b2f812165676230bce5d0215e49a4749c451ca9cFariborz Jahanian unsigned FileOffset = Record[Idx++]; 949e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian unsigned LineNo = Record[Idx++]; 950e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian int FilenameID = FileIDs[Record[Idx++]]; 951e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian SrcMgr::CharacteristicKind FileKind 952e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian = (SrcMgr::CharacteristicKind)Record[Idx++]; 953e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian unsigned IncludeOffset = Record[Idx++]; 954e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID, 955e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian FileKind, IncludeOffset)); 956e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 957e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian LineTable.AddEntry(FID, Entries); 958e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian } 959b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer 96053b9441b5a81a24fa1f66f3f6416f1e36baa9c2fTed Kremenek return false; 961e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian} 962e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 963432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahaniannamespace { 964e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 965e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanianclass ASTStatData { 966e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanianpublic: 967e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian const bool hasStat; 968b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer const ino_t ino; 969e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian const dev_t dev; 970e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian const mode_t mode; 971e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian const time_t mtime; 972432a8893f7e30d141d7f279bd00b741a3cdac81fFariborz Jahanian const off_t size; 973e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 974e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian ASTStatData(ino_t i, dev_t d, mode_t mo, time_t m, off_t s) 975e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian : hasStat(true), ino(i), dev(d), mode(mo), mtime(m), size(s) {} 976e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian 977e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian ASTStatData() 978e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian : hasStat(false), ino(0), dev(0), mode(0), mtime(0), size(0) {} 979e23fa2d0e84d1b878e012442a726c664216a9adfFariborz Jahanian}; 9804ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad 9813bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanianclass ASTStatLookupTrait { 9823bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian public: 98380aa1cd7973561889e51c1c152c8990a8de9c953Fariborz Jahanian typedef const char *external_key_type; 98480aa1cd7973561889e51c1c152c8990a8de9c953Fariborz Jahanian typedef const char *internal_key_type; 985b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer 986b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer typedef ASTStatData data_type; 9873bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian 9883bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian static unsigned ComputeHash(const char *path) { 9893bfacdf6f0706987c1b33c625cd68fb880881c22Fariborz Jahanian return llvm::HashString(path); 990b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer } 991b170ca5f4a8397c10e52050ff5df6885a3e6eca9Benjamin Kramer 9928e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian static internal_key_type GetInternalKey(const char *path) { return path; } 9938e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian 9948e6ac1d80055fa37b9b84029c7e751624ba7f84cFariborz Jahanian static bool EqualKey(internal_key_type a, internal_key_type b) { 9958a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return strcmp(a, b) == 0; 9968a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis } 9978a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis 9988a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis static std::pair<unsigned, unsigned> 9998a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ReadKeyDataLength(const unsigned char*& d) { 10008a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d); 10018a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis unsigned DataLen = (unsigned) *d++; 10028a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return std::make_pair(KeyLen + 1, DataLen); 10038a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis } 10048a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis 10058a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis static internal_key_type ReadKey(const unsigned char *d, unsigned) { 10068a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return (const char *)d; 10078a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis } 10088a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis 10098a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis static data_type ReadData(const internal_key_type, const unsigned char *d, 10108a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis unsigned /*DataLen*/) { 10118a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis using namespace clang::io; 10128a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis 10138a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis if (*d++ == 1) 10148a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return data_type(); 10158a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis 10168a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis ino_t ino = (ino_t) ReadUnalignedLE32(d); 10178a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis dev_t dev = (dev_t) ReadUnalignedLE32(d); 10188a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis mode_t mode = (mode_t) ReadUnalignedLE16(d); 10198a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis time_t mtime = (time_t) ReadUnalignedLE64(d); 10208a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis off_t size = (off_t) ReadUnalignedLE64(d); 10218a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis return data_type(ino, dev, mode, mtime, size); 10228a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis } 10238a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis}; 10248a1d722f13df383600f36d77f842957c8adb5f1bArgyrios Kyrtzidis 10251ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian/// \brief stat() cache for precompiled headers. 10261ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian/// 1027830937bc1100fba7682f7c32c40512085870f50cFariborz Jahanian/// This cache is very similar to the stat cache used by pretokenized 1028d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian/// headers. 1029d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanianclass ASTStatCache : public StatSysCallCache { 1030d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian typedef OnDiskChainedHashTable<ASTStatLookupTrait> CacheTy; 1031830937bc1100fba7682f7c32c40512085870f50cFariborz Jahanian CacheTy *Cache; 1032d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian 10331ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian unsigned &NumStatHits, &NumStatMisses; 10341ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanianpublic: 10351ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian ASTStatCache(const unsigned char *Buckets, 10361ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian const unsigned char *Base, 10371ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian unsigned &NumStatHits, 10381ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian unsigned &NumStatMisses) 1039d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian : Cache(0), NumStatHits(NumStatHits), NumStatMisses(NumStatMisses) { 1040d016ec204c54d766c4561d43548551ffde0e6b43Fariborz Jahanian Cache = CacheTy::Create(Buckets, Base); 10411ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian } 10421ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian 10431ceee5c42d5c410217f67d384eecc6ea4a2bba9bFariborz Jahanian ~ASTStatCache() { delete Cache; } 1044a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall 1045b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis int stat(const char *path, struct stat *buf) { 1046a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall // Do the lookup for the file's data in the AST file. 1047b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis CacheTy::iterator I = Cache->find(path); 1048b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis 1049b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis // If we don't get a hit in the AST file just forward to 'stat'. 1050b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis if (I == Cache->end()) { 1051b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis ++NumStatMisses; 1052a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall return StatSysCallCache::stat(path, buf); 10534ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad } 1054109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall 1055109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall ++NumStatHits; 1056109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall ASTStatData Data = *I; 1057109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall 1058a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall if (!Data.hasStat) 1059109de5ead1dfcb3bc985cddb8cb3ed5bcecad88dJohn McCall return 1; 1060a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall 1061a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall buf->st_ino = Data.ino; 1062a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall buf->st_dev = Data.dev; 1063a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall buf->st_mtime = Data.mtime; 1064b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis buf->st_mode = Data.mode; 1065b17166c8077cd900cca83a895c43b30ea6660598Argyrios Kyrtzidis buf->st_size = Data.size; 1066a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall return 0; 1067a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall } 1068a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall}; 1069a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall} // end anonymous namespace 1070a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall 1071a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall 1072a4eb74d4dfe126c686dc708fec444c85ffb73b47John McCall/// \brief Read a source manager block 1073b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel DunbarASTReader::ASTReadResult ASTReader::ReadSourceManagerBlock(PerFileData &F) { 10744ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad using namespace SrcMgr; 1075b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar 1076b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar llvm::BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor; 1077b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar 1078b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar // Set the source-location entry cursor to the current position in 10794ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad // the stream. This cursor will be used to read the contents of the 10804ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad // source manager block initially, and then lazily read 1081b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar // source-location entries as needed. 1082b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar SLocEntryCursor = F.Stream; 1083b2dbbb99e12806eaaf53b7ccabc32f42b5719443Daniel Dunbar 1084a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner // The stream itself is going to skip over the source manager block. 1085a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner if (F.Stream.SkipBlock()) { 1086a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner Error("malformed block record in AST file"); 1087a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner return Failure; 10884ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad } 10894ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad 10900953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Enter the source manager block. 10910953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) { 10920953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Error("malformed source manager block record in AST file"); 10930953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return Failure; 10940953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 10950953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 10960953e767ff7817f97b3ab20896b229891eeff45bJohn McCall RecordData Record; 10970953e767ff7817f97b3ab20896b229891eeff45bJohn McCall while (true) { 10980953e767ff7817f97b3ab20896b229891eeff45bJohn McCall unsigned Code = SLocEntryCursor.ReadCode(); 10990953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (Code == llvm::bitc::END_BLOCK) { 11000953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (SLocEntryCursor.ReadBlockEnd()) { 11010953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Error("error at end of Source Manager block in AST file"); 11020953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return Failure; 110349f4e1cbd839da27ff4814b4ea6d85a79f786cbdJohn McCall } 11040953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return Success; 11050953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 11060953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 11070953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (Code == llvm::bitc::ENTER_SUBBLOCK) { 11080953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // No known subblocks, always skip them. 11094ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad SLocEntryCursor.ReadSubBlockID(); 11104ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (SLocEntryCursor.SkipBlock()) { 1111f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner Error("malformed block record in AST file"); 1112f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner return Failure; 1113f46699ce225811d8d9dbab9d00189a0e54469457Chris Lattner } 1114b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris Lattner continue; 11150953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 11160953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 11170953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (Code == llvm::bitc::DEFINE_ABBREV) { 11180953e767ff7817f97b3ab20896b229891eeff45bJohn McCall SLocEntryCursor.ReadAbbrevRecord(); 11191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump continue; 11200953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 11210953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 11220953e767ff7817f97b3ab20896b229891eeff45bJohn McCall // Read a record. 11230953e767ff7817f97b3ab20896b229891eeff45bJohn McCall const char *BlobStart; 11240953e767ff7817f97b3ab20896b229891eeff45bJohn McCall unsigned BlobLen; 11251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Record.clear(); 11260953e767ff7817f97b3ab20896b229891eeff45bJohn McCall switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 1127ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb default: // Default behavior: ignore. 1128ebb97e98c03f8d7034bd3748a10e35f39a95c289Christopher Lamb break; 1129b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris Lattner 11304ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad case SM_LINE_TABLE: 1131d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian if (ParseLineTable(Record)) 1132b7d2553edd2532d29b98b9e76bcf6a62bc48b417Chris Lattner return Failure; 1133d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian break; 11341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11357f040a9d817cd1c72b565e92abff473510bf9e1dJohn McCall case SM_SLOC_FILE_ENTRY: 11367f040a9d817cd1c72b565e92abff473510bf9e1dJohn McCall case SM_SLOC_BUFFER_ENTRY: 113758f9f2c884af6b72d036b746a016d8031d31cb7aSteve Naroff case SM_SLOC_INSTANTIATION_ENTRY: 11384027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian // Once we hit one of the source location entries, we're done. 11394027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian return Success; 11404027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian } 11414027cd1b924e29784a49085b1717f35cdd719146Fariborz Jahanian } 11421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump} 11430953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 11440953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// \brief Get a cursor that's correctly positioned for reading the source 11450953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// location entry with the given ID. 11460953e767ff7817f97b3ab20896b229891eeff45bJohn McCallllvm::BitstreamCursor &ASTReader::SLocCursorForID(unsigned ID) { 11471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(ID != 0 && ID <= TotalNumSLocEntries && 11480953e767ff7817f97b3ab20896b229891eeff45bJohn McCall "SLocCursorForID should only be called for real IDs."); 11490953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 11500953e767ff7817f97b3ab20896b229891eeff45bJohn McCall ID -= 1; 11510953e767ff7817f97b3ab20896b229891eeff45bJohn McCall PerFileData *F = 0; 11520953e767ff7817f97b3ab20896b229891eeff45bJohn McCall for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 11531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump F = Chain[N - I - 1]; 11540953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (ID < F->LocalNumSLocEntries) 1155d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian break; 1156a7674d8a9a69f3f6fe16e70cf2a3b2b15fb7c43dChris Lattner ID -= F->LocalNumSLocEntries; 1157e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall } 1158e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall assert(F && F->LocalNumSLocEntries > ID && "Chain corrupted"); 1159e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 1160e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall F->SLocEntryCursor.JumpToBit(F->SLocOffsets[ID]); 1161e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall return F->SLocEntryCursor; 1162e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall} 1163e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 1164e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall/// \brief Read in the source location entry with the given ID. 1165e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCallASTReader::ASTReadResult ASTReader::ReadSLocEntryRecord(unsigned ID) { 1166e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall if (ID == 0) 1167e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall return Success; 1168e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 1169e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall if (ID > TotalNumSLocEntries) { 1170e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall Error("source location entry ID out-of-range for AST file"); 1171e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall return Failure; 1172e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall } 1173e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 1174e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall llvm::BitstreamCursor &SLocEntryCursor = SLocCursorForID(ID); 1175e6a365d772a6b455f1e23ac9ae5f40d65a55a18cJohn McCall 11765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ++NumSLocEntriesRead; 11775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer unsigned Code = SLocEntryCursor.ReadCode(); 11784ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (Code == llvm::bitc::END_BLOCK || 11795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Code == llvm::bitc::ENTER_SUBBLOCK || 11805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Code == llvm::bitc::DEFINE_ABBREV) { 11815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Error("incorrectly-formatted source location entry in AST file"); 11825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return Failure; 11831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 11845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 11855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer RecordData Record; 11865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const char *BlobStart; 11871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump unsigned BlobLen; 11885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 11895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 11905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Error("incorrectly-formatted source location entry in AST file"); 1191467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall return Failure; 1192f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner 11931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case SM_SLOC_FILE_ENTRY: { 11945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer std::string Filename(BlobStart, BlobStart + BlobLen); 11955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer MaybeAddSystemRootToFilename(Filename); 1196c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin const FileEntry *File = FileMgr.getFile(Filename); 11975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (File == 0) { 11986b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall std::string ErrorStr = "could not find file '"; 11995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ErrorStr += Filename; 12005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ErrorStr += "' referenced by AST file"; 12015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Error(ErrorStr.c_str()); 12025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return Failure; 12035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 12045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 12055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Record.size() < 10) { 12064ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Error("source location entry is incorrect"); 12075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return Failure; 12085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 12095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 12105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!DisableValidation && 12111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ((off_t)Record[4] != File->getSize() 12125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#if !defined(LLVM_ON_WIN32) 12135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // In our regression testing, the Windows file system seems to 12145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // have inconsistent modification times that sometimes 12151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // erroneously trigger this error-handling path. 12165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer || (time_t)Record[5] != File->getModificationTime() 12175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#endif 12185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer )) { 1219467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall Diag(diag::err_fe_pch_file_modified) 1220f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner << Filename; 12211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Failure; 12225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 12235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1224c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin FileID FID = SourceMgr.createFileID(File, 12255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer SourceLocation::getFromRawEncoding(Record[1]), 12266b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall (SrcMgr::CharacteristicKind)Record[2], 12275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ID, Record[0]); 12285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Record[3]) 12295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile()) 12305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer .setHasLineDirectives(); 12315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 12321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Reconstruct header-search information for this file. 12335618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff HeaderFileInfo HFI; 12344ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad HFI.isImport = Record[6]; 1235296e8d5fdcf9946f51e866adc8d281379e51efe9Steve Naroff HFI.DirInfo = Record[7]; 1236296e8d5fdcf9946f51e866adc8d281379e51efe9Steve Naroff HFI.NumIncludes = Record[8]; 12375618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff HFI.ControllingMacroID = Record[9]; 12385618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff if (Listener) 12395618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff Listener->ReadHeaderFileInfo(HFI, File->getUID()); 12401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump break; 12415618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff } 12425618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff 12435618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff case SM_SLOC_BUFFER_ENTRY: { 12445618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff const char *Name = BlobStart; 12451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump unsigned Offset = Record[0]; 12461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump unsigned Code = SLocEntryCursor.ReadCode(); 12475618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff Record.clear(); 12485618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff unsigned RecCode 1249467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall = SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen); 12505618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff 12511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (RecCode != SM_SLOC_BUFFER_BLOB) { 12525618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff Error("AST record has invalid code"); 12535618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff return Failure; 12545618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff } 1255c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin 12565618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff llvm::MemoryBuffer *Buffer 12576b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall = llvm::MemoryBuffer::getMemBuffer(llvm::StringRef(BlobStart, BlobLen - 1), 12586b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall Name); 12595618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff FileID BufferID = SourceMgr.createFileIDForMemBuffer(Buffer, ID, Offset); 12605618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff 12615618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff if (strcmp(Name, "<built-in>") == 0) { 12625618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff PCHPredefinesBlock Block = { 12635618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff BufferID, 12647c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl llvm::StringRef(BlobStart, BlobLen - 1) 12657c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl }; 12664ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad PCHPredefinesBuffers.push_back(Block); 12674ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad } 12685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 12695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 12705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 127154e14c4db764c0636160d26c5bbf491637c83a76John McCall 12725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case SM_SLOC_INSTANTIATION_ENTRY: { 12735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer SourceLocation SpellingLoc 12747c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl = SourceLocation::getFromRawEncoding(Record[1]); 12757c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl SourceMgr.createInstantiationLoc(SpellingLoc, 12765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer SourceLocation::getFromRawEncoding(Record[2]), 12777c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl SourceLocation::getFromRawEncoding(Record[3]), 127854e14c4db764c0636160d26c5bbf491637c83a76John McCall Record[4], 127954e14c4db764c0636160d26c5bbf491637c83a76John McCall ID, 12805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Record[0]); 12815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 12825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 128354e14c4db764c0636160d26c5bbf491637c83a76John McCall } 128454e14c4db764c0636160d26c5bbf491637c83a76John McCall 128554e14c4db764c0636160d26c5bbf491637c83a76John McCall return Success; 12867c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl} 12877c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 12887c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the 12897c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl/// specified cursor. Read the abbreviations that are at the top of the block 1290c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin/// and then leave the cursor pointing into the block. 12917c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redlbool ASTReader::ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor, 12927c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl unsigned BlockID) { 12936b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall if (Cursor.EnterSubBlock(BlockID)) { 129454e14c4db764c0636160d26c5bbf491637c83a76John McCall Error("malformed block record in AST file"); 129554e14c4db764c0636160d26c5bbf491637c83a76John McCall return Failure; 12967c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl } 12977c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 129854e14c4db764c0636160d26c5bbf491637c83a76John McCall while (true) { 12997c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl unsigned Code = Cursor.ReadCode(); 13007c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 13017c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // We expect all abbrevs to be at the start of the block. 13027c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl if (Code != llvm::bitc::DEFINE_ABBREV) 13037c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl return false; 13044ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Cursor.ReadAbbrevRecord(); 13057c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl } 13067c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl} 13077c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 130854e14c4db764c0636160d26c5bbf491637c83a76John McCallvoid ASTReader::ReadMacroRecord(llvm::BitstreamCursor &Stream, uint64_t Offset){ 13097c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl assert(PP && "Forgot to set Preprocessor ?"); 13107c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 13117c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // Keep track of where we are in the stream, then jump back there 13127c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // after reading this macro. 13137c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl SavedStreamPosition SavedPosition(Stream); 13147c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 131554e14c4db764c0636160d26c5bbf491637c83a76John McCall Stream.JumpToBit(Offset); 131654e14c4db764c0636160d26c5bbf491637c83a76John McCall RecordData Record; 13177c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl llvm::SmallVector<IdentifierInfo*, 16> MacroArgs; 13187c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl MacroInfo *Macro = 0; 13197c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 132054e14c4db764c0636160d26c5bbf491637c83a76John McCall while (true) { 132154e14c4db764c0636160d26c5bbf491637c83a76John McCall unsigned Code = Stream.ReadCode(); 132254e14c4db764c0636160d26c5bbf491637c83a76John McCall switch (Code) { 13237c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl case llvm::bitc::END_BLOCK: 13245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return; 13257c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 13267c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl case llvm::bitc::ENTER_SUBBLOCK: 1327c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin // No known subblocks, always skip them. 13285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Stream.ReadSubBlockID(); 13295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Stream.SkipBlock()) { 13306b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall Error("malformed block record in AST file"); 13316b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall return; 13325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 13337c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl continue; 13345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 13355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case llvm::bitc::DEFINE_ABBREV: 13365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Stream.ReadAbbrevRecord(); 1337f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl continue; 1338f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl default: break; 13394ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad } 1340f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1341f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // Read a record. 1342f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl Record.clear(); 1343f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl PreprocessorRecordTypes RecType = 1344f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl (PreprocessorRecordTypes)Stream.ReadRecord(Code, Record); 1345f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl switch (RecType) { 1346f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl case PP_MACRO_OBJECT_LIKE: 1347f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl case PP_MACRO_FUNCTION_LIKE: { 1348f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // If we already have a macro, that means that we've hit the end 1349f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // of the definition of the macro we were looking for. We're 1350f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // done. 1351f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl if (Macro) 1352f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl return; 135387c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor 1354f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl IdentifierInfo *II = DecodeIdentifierInfo(Record[0]); 1355f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl if (II == 0) { 1356f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl Error("macro must have a name in AST file"); 1357f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl return; 1358f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl } 1359c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin SourceLocation Loc = SourceLocation::getFromRawEncoding(Record[1]); 1360f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl bool isUsed = Record[2]; 13616b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall 13626b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall MacroInfo *MI = PP->AllocateMacroInfo(Loc); 1363f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MI->setIsUsed(isUsed); 1364f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl MI->setIsFromAST(); 1365f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1366f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl unsigned NextIndex = 3; 1367f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl if (RecType == PP_MACRO_FUNCTION_LIKE) { 13681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Decode function-like macro info. 1369fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff bool isC99VarArgs = Record[3]; 13701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump bool isGNUVarArgs = Record[4]; 137138aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner MacroArgs.clear(); 1372c9406125e2cac9208098655ac8058c095c2c3a65Steve Naroff unsigned NumArgs = Record[5]; 13734ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad NextIndex = 6 + NumArgs; 1374923d56d436f750bc1f29db50e641078725558a1bSebastian Redl for (unsigned i = 0; i != NumArgs; ++i) 1375923d56d436f750bc1f29db50e641078725558a1bSebastian Redl MacroArgs.push_back(DecodeIdentifierInfo(Record[6+i])); 1376587cbdfd95f4b0aaccc14b31f5debe85d5daf7edEli Friedman 1377587cbdfd95f4b0aaccc14b31f5debe85d5daf7edEli Friedman // Install function-like macro info. 137838aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner MI->setIsFunctionLike(); 137938aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner if (isC99VarArgs) MI->setIsC99Varargs(); 138038aeec7299c48cb79523f7f89776fb258c84aeeaChris Lattner if (isGNUVarArgs) MI->setIsGNUVarargs(); 13819f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad MI->setArgumentList(MacroArgs.data(), MacroArgs.size(), 13829f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad PP->getPreprocessorAllocator()); 13831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 13845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 13850be2ef2321b1283ead38ebeb83b451335d90e0feChris Lattner // Finally, install the macro. 13861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump PP->setMacroInfo(II, MI); 13875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 13881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Remember that we saw this macro last so that we add the tokens that 13897192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek // form its body to it. 13905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Macro = MI; 13911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 13925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (NextIndex + 1 == Record.size() && PP->getPreprocessingRecord()) { 13935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // We have a macro definition. Load it now. 13945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PP->getPreprocessingRecord()->RegisterMacroDefinition(Macro, 1395467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall getMacroDefinition(Record[NextIndex])); 13961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 1397c9406125e2cac9208098655ac8058c095c2c3a65Steve Naroff 13985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ++NumMacrosRead; 13991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump break; 14007192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek } 1401c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin 14025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PP_TOKEN: { 14031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If we see a TOKEN before a PP_MACRO_*, then the file is 14046b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall // erroneous, just pretend we didn't see this. 14056b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall if (Macro == 0) break; 14067192f8e9592729882a09d84d77838db26e39ebd4Ted Kremenek 14075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Token Tok; 14085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Tok.startToken(); 14095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Tok.setLocation(SourceLocation::getFromRawEncoding(Record[0])); 14105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Tok.setLength(Record[1]); 1411745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian if (IdentifierInfo *II = DecodeIdentifierInfo(Record[2])) 1412745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian Tok.setIdentifierInfo(II); 14134ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Tok.setKind((tok::TokenKind)Record[3]); 1414745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian Tok.setFlag((Token::TokenFlags)Record[4]); 1415745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian Macro->AddTokenToBody(Tok); 1416745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian break; 1417745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 1418745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1419745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian case PP_MACRO_INSTANTIATION: { 1420745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian // If we already have a macro, that means that we've hit the end 1421745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian // of the definition of the macro we were looking for. We're 1422745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian // done. 1423745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian if (Macro) 1424745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian return; 1425745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1426745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian if (!PP->getPreprocessingRecord()) { 1427745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian Error("missing preprocessing record in AST file"); 1428745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian return; 1429745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 1430745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1431745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian PreprocessingRecord &PPRec = *PP->getPreprocessingRecord(); 1432745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian if (PPRec.getPreprocessedEntity(Record[0])) 1433745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian return; 1434745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1435745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian MacroInstantiation *MI 1436745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian = new (PPRec) MacroInstantiation(DecodeIdentifierInfo(Record[3]), 1437745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian SourceRange( 1438745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian SourceLocation::getFromRawEncoding(Record[1]), 1439745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian SourceLocation::getFromRawEncoding(Record[2])), 1440745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian getMacroDefinition(Record[4])); 1441745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian PPRec.SetPreallocatedEntity(Record[0], MI); 1442745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian return; 14434ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad } 1444745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1445745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian case PP_MACRO_DEFINITION: { 1446745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian // If we already have a macro, that means that we've hit the end 1447745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian // of the definition of the macro we were looking for. We're 1448745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian // done. 1449745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian if (Macro) 1450745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian return; 1451745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1452745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian if (!PP->getPreprocessingRecord()) { 1453745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian Error("missing preprocessing record in AST file"); 1454745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian return; 1455745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 1456745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian 1457745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian PreprocessingRecord &PPRec = *PP->getPreprocessingRecord(); 1458745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian if (PPRec.getPreprocessedEntity(Record[0])) 1459bdbf7b030a3e0ddb95240076683830e6f78c79a5Steve Naroff return; 1460bdbf7b030a3e0ddb95240076683830e6f78c79a5Steve Naroff 14617e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor if (Record[1] >= MacroDefinitionsLoaded.size()) { 14627e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor Error("out-of-bounds macro definition record"); 1463c9406125e2cac9208098655ac8058c095c2c3a65Steve Naroff return; 14647e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor } 14654ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad 1466c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman MacroDefinition *MD 1467c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman = new (PPRec) MacroDefinition(DecodeIdentifierInfo(Record[4]), 1468715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor SourceLocation::getFromRawEncoding(Record[5]), 1469715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor SourceRange( 1470715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor SourceLocation::getFromRawEncoding(Record[2]), 1471715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor SourceLocation::getFromRawEncoding(Record[3]))); 1472715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor PPRec.SetPreallocatedEntity(Record[0], MD); 1473715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor MacroDefinitionsLoaded[Record[1]] = MD; 1474715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor return; 14756b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall } 1476715e9c8a39437347e838aa108df443fe1086d359Douglas Gregor } 1477c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman } 1478c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman} 1479c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1480c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedmanvoid ASTReader::ReadDefinedMacros() { 1481c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 1482c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman llvm::BitstreamCursor &MacroCursor = Chain[N - I - 1]->MacroCursor; 1483898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 1484898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor // If there was no preprocessor block, skip this file. 148504d4beee4b86af20a9e4457023d3925cab8f9908Douglas Gregor if (!MacroCursor.getBitStreamReader()) 14867e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor continue; 14877e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor 1488898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor llvm::BitstreamCursor Cursor = MacroCursor; 14897e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor if (Cursor.EnterSubBlock(PREPROCESSOR_BLOCK_ID)) { 14904ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Error("malformed preprocessor block record in AST file"); 1491cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor return; 1492cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor } 1493898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 1494898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor RecordData Record; 149504d4beee4b86af20a9e4457023d3925cab8f9908Douglas Gregor while (true) { 1496cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor unsigned Code = Cursor.ReadCode(); 1497789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor if (Code == llvm::bitc::END_BLOCK) { 1498cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor if (Cursor.ReadBlockEnd()) { 149932adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor Error("error at end of preprocessor block in AST file"); 1500cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor return; 1501cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor } 1502cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor break; 1503cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor } 150432adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor 1505cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1506cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor // No known subblocks, always skip them. 1507cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor Cursor.ReadSubBlockID(); 1508cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor if (Cursor.SkipBlock()) { 1509cb78d8852a454684c987220132cdb5e54dd00121Douglas Gregor Error("malformed block record in AST file"); 151004d4beee4b86af20a9e4457023d3925cab8f9908Douglas Gregor return; 151104d4beee4b86af20a9e4457023d3925cab8f9908Douglas Gregor } 151204d4beee4b86af20a9e4457023d3925cab8f9908Douglas Gregor continue; 151304d4beee4b86af20a9e4457023d3925cab8f9908Douglas Gregor } 15146b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall 15156b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall if (Code == llvm::bitc::DEFINE_ABBREV) { 15166b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall Cursor.ReadAbbrevRecord(); 151732adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor continue; 151832adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor } 151932adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor 152032adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor // Read a record. 152132adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor const char *BlobStart; 152232adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor unsigned BlobLen; 152332adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor Record.clear(); 152432adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor switch (Cursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 152532adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor default: // Default behavior: ignore. 152632adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor break; 152732adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor 152832adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor case PP_MACRO_OBJECT_LIKE: 152932adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor case PP_MACRO_FUNCTION_LIKE: 153032adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor DecodeIdentifierInfo(Record[0]); 153104d4beee4b86af20a9e4457023d3925cab8f9908Douglas Gregor break; 153232adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor 153332adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor case PP_TOKEN: 153432adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor // Ignore tokens. 153532adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor break; 153632adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor 153732adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor case PP_MACRO_INSTANTIATION: 153832adc8bd6f05d1e26cc221102e48609da2c446baDouglas Gregor case PP_MACRO_DEFINITION: 153904d4beee4b86af20a9e4457023d3925cab8f9908Douglas Gregor // Read the macro record. 15401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ReadMacroRecord(Chain[N - I - 1]->Stream, Cursor.GetCurrentBitNo()); 1541898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor break; 1542898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor } 1543898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor } 1544898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor } 1545c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman} 1546c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 15474ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadMacroDefinition *ASTReader::getMacroDefinition(IdentID ID) { 1548c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman if (ID == 0 || ID >= MacroDefinitionsLoaded.size()) 15490be2ef2321b1283ead38ebeb83b451335d90e0feChris Lattner return 0; 1550c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1551c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman if (!MacroDefinitionsLoaded[ID]) { 15521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump unsigned Index = ID; 1553c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 1554c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman PerFileData &F = *Chain[N - I - 1]; 1555c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman if (Index < F.LocalNumMacroDefinitions) { 1556c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman ReadMacroRecord(F.Stream, F.MacroDefinitionOffsets[Index]); 1557c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman break; 1558c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman } 1559c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman Index -= F.LocalNumMacroDefinitions; 1560467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall } 1561f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner assert(MacroDefinitionsLoaded[ID] && "Broken chain"); 15622bd24ba6d10f8c811c8e2a57c8397e07082ba497Ted Kremenek } 1563c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1564c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman return MacroDefinitionsLoaded[ID]; 1565c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman} 1566c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1567c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin/// \brief If we are loading a relocatable PCH file, and the filename is 15682bd24ba6d10f8c811c8e2a57c8397e07082ba497Ted Kremenek/// not an absolute path, add the system root to the beginning of the file 1569c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman/// name. 15706b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCallvoid ASTReader::MaybeAddSystemRootToFilename(std::string &Filename) { 15716b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall // If this is not a relocatable PCH file, there's nothing to do. 1572c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman if (!RelocatablePCH) 1573c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman return; 1574c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman 1575c5773c4b8ce1ed6ed5c7112c9020c954a47dce96Eli Friedman if (Filename.empty() || llvm::sys::Path(Filename).isAbsolute()) 1576fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff return; 1577fb22d96692c5240fb8d611290dbf7eeed3759c73Steve Naroff 157873322924127c873c13101b705dd823f5539ffa5fSteve Naroff if (isysroot == 0) { 157973322924127c873c13101b705dd823f5539ffa5fSteve Naroff // If no system root was given, default to '/' 158082287d19ded35248c4ce6a425ce74116a13ce44eJohn Thompson Filename.insert(Filename.begin(), '/'); 15814ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad return; 158233daae66462e8f51ee153463b32bdefd60c801aaChris Lattner } 15831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 158433daae66462e8f51ee153463b32bdefd60c801aaChris Lattner unsigned Length = strlen(isysroot); 158533daae66462e8f51ee153463b32bdefd60c801aaChris Lattner if (isysroot[Length - 1] != '/') 15861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Filename.insert(Filename.begin(), '/'); 15875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 15885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Filename.insert(Filename.begin(), isysroot, isysroot + Length); 1589e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson} 1590788b0fd67e1992f23555454efcdb16a19dfefac3Chris Lattner 15915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerASTReader::ASTReadResult 15925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerASTReader::ReadASTBlock(PerFileData &F) { 15935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::BitstreamCursor &Stream = F.Stream; 15945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 15955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 15965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Error("malformed block record in AST file"); 15975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return Failure; 1598255210ef415b9893f0e3794e8d9a704194c12f3cDouglas Gregor } 1599231da7eb3dd13007e5e40fffe48998e5ef284e06Bob Wilson 16001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Read all of the records and blocks for the ASt file. 16015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer RecordData Record; 16025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer bool First = true; 1603c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin while (!Stream.AtEndOfStream()) { 16045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer unsigned Code = Stream.ReadCode(); 16056b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall if (Code == llvm::bitc::END_BLOCK) { 1606e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson if (Stream.ReadBlockEnd()) { 16075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Error("error at end of module block in AST file"); 16085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return Failure; 16095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 16105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 16115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return Success; 1612213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman } 161373322924127c873c13101b705dd823f5539ffa5fSteve Naroff 16144ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (Code == llvm::bitc::ENTER_SUBBLOCK) { 16154ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad switch (Stream.ReadSubBlockID()) { 161673322924127c873c13101b705dd823f5539ffa5fSteve Naroff case DECLTYPES_BLOCK_ID: 16171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // We lazily load the decls block, but we want to set up the 1618f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner // DeclsCursor cursor to point into it. Clone our current bitcode 1619213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // cursor to it, enter the block and read the abbrevs in that block. 16201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // With the main cursor, we just skip over it. 162173322924127c873c13101b705dd823f5539ffa5fSteve Naroff F.DeclsCursor = Stream; 162273322924127c873c13101b705dd823f5539ffa5fSteve Naroff if (Stream.SkipBlock() || // Skip with the main cursor. 1623788b0fd67e1992f23555454efcdb16a19dfefac3Chris Lattner // Read the abbrevs. 1624e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) { 162573322924127c873c13101b705dd823f5539ffa5fSteve Naroff Error("malformed block record in AST file"); 162673322924127c873c13101b705dd823f5539ffa5fSteve Naroff return Failure; 162773322924127c873c13101b705dd823f5539ffa5fSteve Naroff } 162873322924127c873c13101b705dd823f5539ffa5fSteve Naroff break; 162973322924127c873c13101b705dd823f5539ffa5fSteve Naroff 163073322924127c873c13101b705dd823f5539ffa5fSteve Naroff case PREPROCESSOR_BLOCK_ID: 163173322924127c873c13101b705dd823f5539ffa5fSteve Naroff F.MacroCursor = Stream; 1632467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall if (PP) 1633213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman PP->setExternalSource(this); 16341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 163573322924127c873c13101b705dd823f5539ffa5fSteve Naroff if (Stream.SkipBlock()) { 163673322924127c873c13101b705dd823f5539ffa5fSteve Naroff Error("malformed block record in AST file"); 1637c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin return Failure; 163873322924127c873c13101b705dd823f5539ffa5fSteve Naroff } 16396b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall break; 16406b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall 164173322924127c873c13101b705dd823f5539ffa5fSteve Naroff case SOURCE_MANAGER_BLOCK_ID: 164273322924127c873c13101b705dd823f5539ffa5fSteve Naroff switch (ReadSourceManagerBlock(F)) { 164373322924127c873c13101b705dd823f5539ffa5fSteve Naroff case Success: 164473322924127c873c13101b705dd823f5539ffa5fSteve Naroff break; 164573322924127c873c13101b705dd823f5539ffa5fSteve Naroff 16464ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad case Failure: 16474ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Error("malformed source manager block in AST file"); 16484ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad return Failure; 16494ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad 16502ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor case IgnorePCH: 16511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return IgnorePCH; 16522ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } 16531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump break; 16542ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } 16552ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor First = false; 16562ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor continue; 16572ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } 16582ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor 16592ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor if (Code == llvm::bitc::DEFINE_ABBREV) { 16602ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor Stream.ReadAbbrevRecord(); 16616b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall continue; 16626b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall } 16636b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall 16642ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor // Read and process a record. 16652ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor Record.clear(); 16662ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor const char *BlobStart = 0; 16676b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall unsigned BlobLen = 0; 16686b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall switch ((ASTRecordTypes)Stream.ReadRecord(Code, Record, 16696b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall &BlobStart, &BlobLen)) { 1670789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor default: // Default behavior: ignore. 1671789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor break; 1672789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 1673789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor case METADATA: { 1674789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor if (Record[0] != VERSION_MAJOR && !DisableValidation) { 16752ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old 16762ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor : diag::warn_pch_version_too_new); 16772ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor return IgnorePCH; 16782ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor } 16796b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall 16806b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall RelocatablePCH = Record[4]; 16812ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor if (Listener) { 16822ec09f1dc123e1942ed756e8ee4fef86451eac9eDouglas Gregor std::string TargetTriple(BlobStart, BlobLen); 16831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (Listener->ReadTargetTriple(TargetTriple)) 16849cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor return IgnorePCH; 16859cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor } 16869cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor break; 16879cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor } 168872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 16895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case CHAINED_METADATA: { 16904ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (!First) { 16914ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Error("CHAINED_METADATA is not first record in block"); 16924ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad return Failure; 1693264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola } 16945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Record[0] != VERSION_MAJOR && !DisableValidation) { 16955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old 16965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer : diag::warn_pch_version_too_new); 1697264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola return IgnorePCH; 16981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 16995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 17001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Load the chained file. 170172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor switch(ReadASTCore(llvm::StringRef(BlobStart, BlobLen))) { 17025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Failure: return Failure; 17031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // If we have to ignore the dependency, we'll have to ignore this too. 17045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case IgnorePCH: return IgnorePCH; 1705ab8bbf4ebd3e3e6eab913cb044772a62b7581941Douglas Gregor case Success: break; 170604a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall } 1707264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola break; 1708264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola } 1709264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola 17101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case TYPE_OFFSET: 17115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (F.LocalNumTypes != 0) { 171272564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor Error("duplicate TYPE_OFFSET record in AST file"); 171372564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor return Failure; 1714c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin } 17155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer F.TypeOffsets = (const uint32_t *)BlobStart; 17161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump F.LocalNumTypes = Record[0]; 17176b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall break; 1718264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola 17195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DECL_OFFSET: 172072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor if (F.LocalNumDecls != 0) { 17215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Error("duplicate DECL_OFFSET record in AST file"); 17225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return Failure; 17235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 17245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer F.DeclOffsets = (const uint32_t *)BlobStart; 17255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer F.LocalNumDecls = Record[0]; 17264ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad break; 17274ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad 17284ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad case TU_UPDATE_LEXICAL: { 17294ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad DeclContextInfo Info = { 17305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer /* No visible information */ 0, 17315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer reinterpret_cast<const DeclID *>(BlobStart), 17325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer BlobLen / sizeof(DeclID) 1733e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall }; 17345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer DeclContextOffsets[Context->getTranslationUnitDecl()].push_back(Info); 17355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 17361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 173772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor 17385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UPDATE_VISIBLE: { 1739465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl serialization::DeclID ID = Record[0]; 1740465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl void *Table = ASTDeclContextNameLookupTable::Create( 1741e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall (const unsigned char *)BlobStart + Record[1], 17425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer (const unsigned char *)BlobStart, 174354e14c4db764c0636160d26c5bbf491637c83a76John McCall ASTDeclContextNameLookupTrait(*this)); 17445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (ID == 1) { // Is it the TU? 17455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer DeclContextInfo Info = { 1746e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall Table, /* No lexical inforamtion */ 0, 0 1747e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall }; 17485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer DeclContextOffsets[Context->getTranslationUnitDecl()].push_back(Info); 1749465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl } else 17505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PendingVisibleUpdates[ID].push_back(Table); 175104a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall break; 17525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 17535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 17545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case REDECLS_UPDATE_LATEST: { 175554e14c4db764c0636160d26c5bbf491637c83a76John McCall assert(Record.size() % 2 == 0 && "Expected pairs of DeclIDs"); 1756465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl for (unsigned i = 0, e = Record.size(); i < e; i += 2) { 1757e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall DeclID First = Record[i], Latest = Record[i+1]; 1758e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall assert((FirstLatestDeclIDs.find(First) == FirstLatestDeclIDs.end() || 1759e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall Latest > FirstLatestDeclIDs[First]) && 1760e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall "The new latest is supposed to come after the previous latest"); 1761e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FirstLatestDeclIDs[First] = Latest; 1762e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall } 1763e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall break; 1764e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall } 1765e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 1766f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner case LANGUAGE_OPTIONS: 1767beaaccd8e2a8748f77b66e2b330fb9136937e14cJay Foad if (ParseLanguageOptions(Record) && !DisableValidation) 1768e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall return IgnorePCH; 1769465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl break; 17705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 177172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor case IDENTIFIER_TABLE: 177272564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor F.IdentifierTableData = BlobStart; 1773c6ed729f669044f5072a49d79041f455d971ece3Jeffrey Yasskin if (Record[0]) { 17745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer F.IdentifierLookupTable 1775465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl = ASTIdentifierLookupTable::Create( 177672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor (const unsigned char *)F.IdentifierTableData + Record[0], 1777465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl (const unsigned char *)F.IdentifierTableData, 1778465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl ASTIdentifierLookupTrait(*this, F.Stream)); 1779e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall if (PP) 1780e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall PP->getIdentifierTable().setExternalIdentifierLookup(this); 1781e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall } 1782e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall break; 1783e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 17845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case IDENTIFIER_OFFSET: 178572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor if (F.LocalNumIdentifiers != 0) { 17865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Error("duplicate IDENTIFIER_OFFSET record in AST file"); 17875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return Failure; 17885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 17893cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall F.IdentifierOffsets = (const uint32_t *)BlobStart; 17903cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall F.LocalNumIdentifiers = Record[0]; 17913cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall break; 17923cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 17933cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall case EXTERNAL_DEFINITIONS: 17943cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall // Optimization for the first block. 17953cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (ExternalDefinitions.empty()) 17963cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall ExternalDefinitions.swap(Record); 17973cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall else 17983cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall ExternalDefinitions.insert(ExternalDefinitions.end(), 17993cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall Record.begin(), Record.end()); 18003cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall break; 18013cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 18023cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall case SPECIAL_TYPES: 18033cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall // Optimization for the first block 18043cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (SpecialTypes.empty()) 18054ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad SpecialTypes.swap(Record); 18063cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall else 18073cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall SpecialTypes.insert(SpecialTypes.end(), Record.begin(), Record.end()); 18083cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall break; 180937ffed3b7f229844cae2463ff82b527506c86c74Argyrios Kyrtzidis 18103cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall case STATISTICS: 18113cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TotalNumStatements += Record[0]; 18123cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TotalNumMacros += Record[1]; 18133cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TotalLexicalDeclContexts += Record[2]; 181431f17ecbef57b5679c017c375db330546b7b5145John McCall TotalVisibleDeclContexts += Record[3]; 181531f17ecbef57b5679c017c375db330546b7b5145John McCall break; 18163cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 18173cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall case TENTATIVE_DEFINITIONS: 18183cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall // Optimization for the first block. 18193cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall if (TentativeDefinitions.empty()) 18203cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall TentativeDefinitions.swap(Record); 18212ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor else 18222ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor TentativeDefinitions.insert(TentativeDefinitions.end(), 18234ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Record.begin(), Record.end()); 18241e6759e9e33dcaa73ce14c8a908ac9f87ac16463Argyrios Kyrtzidis break; 1825becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall 18261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case UNUSED_FILESCOPED_DECLS: 182719c8576b7328f4dc2d07682f5da552875c1912efJohn McCall // Optimization for the first block. 18282ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor if (UnusedFileScopedDecls.empty()) 1829becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall UnusedFileScopedDecls.swap(Record); 1830becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall else 1831becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall UnusedFileScopedDecls.insert(UnusedFileScopedDecls.end(), 1832becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall Record.begin(), Record.end()); 183319c8576b7328f4dc2d07682f5da552875c1912efJohn McCall break; 1834becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall 1835becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall case WEAK_UNDECLARED_IDENTIFIERS: 1836becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall // Later blocks overwrite earlier ones. 1837400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis WeakUndeclaredIdentifiers.swap(Record); 183819c8576b7328f4dc2d07682f5da552875c1912efJohn McCall break; 1839becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall 1840becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall case LOCALLY_SCOPED_EXTERNAL_DECLS: 1841400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis // Optimization for the first block. 184219c8576b7328f4dc2d07682f5da552875c1912efJohn McCall if (LocallyScopedExternalDecls.empty()) 1843ed97649e9574b9d854fa4d6109c9333ae0993554John McCall LocallyScopedExternalDecls.swap(Record); 1844ed97649e9574b9d854fa4d6109c9333ae0993554John McCall else 18459fdbab3cbc2fc04bcaf5768023d83707f3151144Mike Stump LocallyScopedExternalDecls.insert(LocallyScopedExternalDecls.end(), 1846becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall Record.begin(), Record.end()); 184749aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidis break; 1848becb8d5a6ab5103393eac5344ae69bcb860601ddJohn McCall 184949aa7ff1245abd03e6e998e01302df31e4c6f8f6Argyrios Kyrtzidis case SELECTOR_OFFSETS: 18502ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor F.SelectorOffsets = (const uint32_t *)BlobStart; 18512ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor F.LocalNumSelectors = Record[0]; 18525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 18535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 18549763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis case METHOD_POOL: 18554ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad F.SelectorLookupTableData = (const unsigned char *)BlobStart; 18565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Record[0]) 18571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump F.SelectorLookupTable 18589763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis = ASTSelectorLookupTable::Create( 18599763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis F.SelectorLookupTableData + Record[0], 18606b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall F.SelectorLookupTableData, 18616b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ASTSelectorLookupTrait(*this)); 18625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer TotalNumMethodPoolEntries += Record[1]; 18635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 18645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 18655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case REFERENCED_SELECTOR_POOL: { 18664ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad ReferencedSelectorsData.insert(ReferencedSelectorsData.end(), 1867400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis Record.begin(), Record.end()); 1868400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis break; 1869400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis } 1870400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 1871400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis case PP_COUNTER_VALUE: 1872400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (!Record.empty() && Listener) 1873400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis Listener->ReadCounter(Record[0]); 1874400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis break; 1875400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 1876400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis case SOURCE_LOCATION_OFFSETS: 1877400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis F.SLocOffsets = (const uint32_t *)BlobStart; 18784ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad F.LocalNumSLocEntries = Record[0]; 1879400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis // We cannot delay this until the entire chain is loaded, because then 1880400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis // source location preloads would also have to be delayed. 1881400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis // FIXME: Is there a reason not to do that? 1882400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis TotalNumSLocEntries += F.LocalNumSLocEntries; 1883400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis SourceMgr.PreallocateSLocEntries(this, TotalNumSLocEntries, Record[1]); 1884400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis break; 1885400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis 1886400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis case SOURCE_LOCATION_PRELOADS: 1887400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis for (unsigned I = 0, N = Record.size(); I != N; ++I) { 1888400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis ASTReadResult Result = ReadSLocEntryRecord(Record[I]); 1889400f5125e2432d648f2c8a31b36a7f318a880c47Argyrios Kyrtzidis if (Result != Success) 18909d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall return Result; 18919d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall } 18929d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall break; 18939d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 18949d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall case STAT_CACHE: { 18959d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall ASTStatCache *MyStatCache = 18969d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall new ASTStatCache((const unsigned char *)BlobStart + Record[0], 18979d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall (const unsigned char *)BlobStart, 18989d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall NumStatHits, NumStatMisses); 18999d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall FileMgr.addStatCache(MyStatCache); 19009d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall F.StatCache = MyStatCache; 19019d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall break; 19029d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall } 19039d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall 19049d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall case EXT_VECTOR_DECLS: 19059d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall // Optimization for the first block. 19069d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall if (ExtVectorDecls.empty()) 19079d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall ExtVectorDecls.swap(Record); 19089d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall else 19099d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall ExtVectorDecls.insert(ExtVectorDecls.end(), 19109d156a7b1b2771e191f2f5a45a7b7a694129463bJohn McCall Record.begin(), Record.end()); 191149a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall break; 191249a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 191349a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall case VTABLE_USES: 19144ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad // Later tables overwrite earlier ones. 1915467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall VTableUses.swap(Record); 191649a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall break; 191749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 191849a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall case DYNAMIC_CLASSES: 191949a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall // Optimization for the first block. 192049a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall if (DynamicClasses.empty()) 192149a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall DynamicClasses.swap(Record); 192249a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall else 192349a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall DynamicClasses.insert(DynamicClasses.end(), 192449a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall Record.begin(), Record.end()); 192549a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall break; 192649a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall 192749a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall case PENDING_IMPLICIT_INSTANTIATIONS: 192849a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall // Optimization for the first block. 192949a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall if (PendingImplicitInstantiations.empty()) 193049a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall PendingImplicitInstantiations.swap(Record); 193149a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall else 193249a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall PendingImplicitInstantiations.insert( 193349a832bd499d6f61c23655f1fac99f0dd229756eJohn McCall PendingImplicitInstantiations.end(), Record.begin(), Record.end()); 1934fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor break; 19351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 193676e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson case SEMA_DECL_REFS: 19371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Later tables overwrite earlier ones. 193876e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson SemaDeclRefs.swap(Record); 19394ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad break; 1940fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 1941efed5c832de630715dd42211dd3b2aab5dd97a1bDouglas Gregor case ORIGINAL_FILE_NAME: 1942fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor // The primary AST will be the last to get here, so it will be the one 19431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // that's used. 1944fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor ActualOriginalFileName.assign(BlobStart, BlobLen); 1945fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor OriginalFileName = ActualOriginalFileName; 1946fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor MaybeAddSystemRootToFilename(OriginalFileName); 1947fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor break; 19481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1949efed5c832de630715dd42211dd3b2aab5dd97a1bDouglas Gregor case VERSION_CONTROL_BRANCH_REVISION: { 195076e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson const std::string &CurBranch = getClangFullRepositoryVersion(); 1951efed5c832de630715dd42211dd3b2aab5dd97a1bDouglas Gregor llvm::StringRef ASTBranch(BlobStart, BlobLen); 1952efed5c832de630715dd42211dd3b2aab5dd97a1bDouglas Gregor if (llvm::StringRef(CurBranch) != ASTBranch && !DisableValidation) { 1953789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch; 1954789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor return IgnorePCH; 1955789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor } 1956789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor break; 1957789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor } 195876e4ce42a30cee4dc40ce7c6014874fbc4f9baa7Anders Carlsson 19596b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall case MACRO_DEFINITION_OFFSETS: 19606b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall F.MacroDefinitionOffsets = (const uint32_t *)BlobStart; 1961fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor F.NumPreallocatedPreprocessingEntities = Record[0]; 1962fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor F.LocalNumMacroDefinitions = Record[1]; 1963fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor break; 1964fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor 1965fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor case DECL_REPLACEMENTS: { 1966fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor if (Record.size() % 2 != 0) { 1967fab9d67cebb87be968e7ae31a3b549a5279b5d51Douglas Gregor Error("invalid DECL_REPLACEMENTS block in AST file"); 19683cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall return Failure; 19693cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } 19703cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall for (unsigned I = 0, N = Record.size(); I != N; I += 2) 19713cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall ReplacedDecls[static_cast<DeclID>(Record[I])] = 19724ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad std::make_pair(&F, Record[I+1]); 19733cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall break; 19743cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } 19753cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall 19763cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall case ADDITIONAL_TEMPLATE_SPECIALIZATIONS: { 19773cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall AdditionalTemplateSpecializations &ATS = 19783cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall AdditionalTemplateSpecializationsPending[Record[0]]; 19793cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall ATS.insert(ATS.end(), Record.begin()+1, Record.end()); 19803cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall break; 19813cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } 19823cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } 19833cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall First = false; 19843cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall } 19853cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4John McCall Error("premature end of bitstream in AST file"); 19861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Failure; 19877532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor} 1988d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall 19894ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName) { 1990d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall switch(ReadASTCore(FileName)) { 1991d5532b6cfff2977e0c59fa6ead7f7973984a620dJohn McCall case Failure: return Failure; 1992833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall case IgnorePCH: return IgnorePCH; 1993833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall case Success: break; 1994833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall } 1995833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 1996833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall // Here comes stuff that we only do once the entire chain is loaded. 199731f17ecbef57b5679c017c375db330546b7b5145John McCall 199871d74bc0d6e522ce7c21a599db8e19d3883b518fJohn McCall // Allocate space for loaded identifiers, decls and types. 1999833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall unsigned TotalNumIdentifiers = 0, TotalNumTypes = 0, TotalNumDecls = 0, 2000833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall TotalNumPreallocatedPreprocessingEntities = 0, TotalNumMacroDefs = 0, 2001833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall TotalNumSelectors = 0; 2002833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 20037532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor TotalNumIdentifiers += Chain[I]->LocalNumIdentifiers; 20047532dc66648cfe7432c9fe66dec5225f0ab301c6Douglas Gregor TotalNumTypes += Chain[I]->LocalNumTypes; 20054ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad TotalNumDecls += Chain[I]->LocalNumDecls; 2006b88e888404ad0a2bdd9bfae457e8530bb38a87c5Douglas Gregor TotalNumPreallocatedPreprocessingEntities += 2007b88e888404ad0a2bdd9bfae457e8530bb38a87c5Douglas Gregor Chain[I]->NumPreallocatedPreprocessingEntities; 20089763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TotalNumMacroDefs += Chain[I]->LocalNumMacroDefinitions; 20099763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis TotalNumSelectors += Chain[I]->LocalNumSelectors; 2010fc705b84347e6fb4746a1a7e26949f64c2f2f358Douglas Gregor } 20111275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor IdentifiersLoaded.resize(TotalNumIdentifiers); 20121275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor TypesLoaded.resize(TotalNumTypes); 20131275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor DeclsLoaded.resize(TotalNumDecls); 20141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump MacroDefinitionsLoaded.resize(TotalNumMacroDefs); 201540808ce6ac04b102c3b56244a635d6b98eed6d97Douglas Gregor if (PP) { 20166b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall if (TotalNumIdentifiers > 0) 20171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump PP->getHeaderSearchInfo().SetExternalLookup(this); 2018ef99001908e799c388f1363b1e607dad5f5b57d3John McCall if (TotalNumPreallocatedPreprocessingEntities > 0) { 201931f17ecbef57b5679c017c375db330546b7b5145John McCall if (!PP->getPreprocessingRecord()) 2020828e226ab7ed08b3eb766549e9d3306432137460Douglas Gregor PP->createPreprocessingRecord(); 20211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump PP->getPreprocessingRecord()->SetExternalSource(*this, 202255f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor TotalNumPreallocatedPreprocessingEntities); 20231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 202455f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor } 202555f6b14230c94272efbbcdd89a92224c8db9f225Douglas Gregor SelectorsLoaded.resize(TotalNumSelectors); 20261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 20279763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Check the predefines buffers. 20289763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis if (!DisableValidation && CheckPredefinesBuffers()) 20294ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad return IgnorePCH; 20309763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis 20319763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis if (PP) { 20329763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Initialization of keywords and pragmas occurs before the 20339763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // AST file is read, so there may be some identifiers that were 20349763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // loaded into the IdentifierTable before we intercepted the 20359763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // creation of identifiers. Iterate through the list of known 20369763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // identifiers and determine whether we have to establish 20379763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // preprocessor definitions or top-level identifier declaration 20389763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // chains for those identifiers. 20399763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // 20409763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // We copy the IdentifierInfo pointers to a small vector first, 20419763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // since de-serializing declarations or macro definitions can add 20429763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // new entries into the identifier table, invalidating the 20439763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // iterators. 20449763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis llvm::SmallVector<IdentifierInfo *, 128> Identifiers; 20459763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis for (IdentifierTable::iterator Id = PP->getIdentifierTable().begin(), 20469763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis IdEnd = PP->getIdentifierTable().end(); 20479763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis Id != IdEnd; ++Id) 20489763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis Identifiers.push_back(Id->second); 20499763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // We need to search the tables in all files. 20509763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis for (unsigned J = 0, M = Chain.size(); J != M; ++J) { 20519763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis ASTIdentifierLookupTable *IdTable 20529763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis = (ASTIdentifierLookupTable *)Chain[J]->IdentifierLookupTable; 20539763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Not all AST files necessarily have identifier tables, only the useful 20549763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // ones. 20559763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis if (!IdTable) 20569763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis continue; 20579763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis for (unsigned I = 0, N = Identifiers.size(); I != N; ++I) { 20589763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis IdentifierInfo *II = Identifiers[I]; 20599763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis // Look in the on-disk hash tables for an entry for this identifier 20609763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis ASTIdentifierLookupTrait Info(*this, Chain[J]->Stream, II); 20619763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis std::pair<const char*,unsigned> Key(II->getNameStart(),II->getLength()); 20629763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key, &Info); 20639763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis if (Pos == IdTable->end()) 20649763e221e16026ddf487d2564ed349d2c874a1a1Argyrios Kyrtzidis continue; 2065465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara 2066465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara // Dereferencing the iterator has the effect of populating the 20674ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad // IdentifierInfo node with the various declarations it needs. 2068e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor (void)*Pos; 2069465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara } 2070e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor } 2071e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor } 2072465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara 2073e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor if (Context) 2074e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor InitializeContext(*Context); 2075e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor 2076789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor return Success; 2077789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor} 2078789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2079465d41b92b2c862f3062c412a0538db65c6a2661Abramo BagnaraASTReader::ASTReadResult ASTReader::ReadASTCore(llvm::StringRef FileName) { 2080465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara Chain.push_back(new PerFileData()); 2081789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor PerFileData &F = *Chain.back(); 2082789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 2083789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor // Set the AST file name. 2084465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara F.FileName = FileName; 2085e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor 2086465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara // Open the AST file. 2087e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor // 2088e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor // FIXME: This shouldn't be here, we should just take a raw_ostream. 2089e4e5b054b4917f0ee493bb2fda5b1ec749bfb9a1Douglas Gregor std::string ErrStr; 2090075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara F.Buffer.reset(llvm::MemoryBuffer::getFileOrSTDIN(FileName, &ErrStr)); 20914ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (!F.Buffer) { 2092075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara Error(ErrStr.c_str()); 2093075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return IgnorePCH; 2094075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara } 2095075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 2096075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara // Initialize the stream 2097075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara F.StreamFile.init((const unsigned char *)F.Buffer->getBufferStart(), 2098075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara (const unsigned char *)F.Buffer->getBufferEnd()); 2099075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara llvm::BitstreamCursor &Stream = F.Stream; 2100075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara Stream.init(F.StreamFile); 2101075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara F.SizeInBits = F.Buffer->getBufferSize() * 8; 2102075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 2103075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara // Sniff for the signature. 2104075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara if (Stream.Read(8) != 'C' || 2105075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara Stream.Read(8) != 'P' || 2106075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara Stream.Read(8) != 'C' || 2107075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara Stream.Read(8) != 'H') { 2108075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara Diag(diag::err_not_a_pch_file) << FileName; 2109075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return Failure; 2110075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara } 2111075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 2112075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara while (!Stream.AtEndOfStream()) { 2113075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara unsigned Code = Stream.ReadCode(); 21144a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor 21154a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor if (Code != llvm::bitc::ENTER_SUBBLOCK) { 21164a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor Error("invalid record at top-level of AST file"); 21174ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad return Failure; 2118d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor } 2119d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2120d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor unsigned BlockID = Stream.ReadSubBlockID(); 2121d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 21224a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor // We only know the AST subblock ID. 21234a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor switch (BlockID) { 21244a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor case llvm::bitc::BLOCKINFO_BLOCK_ID: 21254a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor if (Stream.ReadBlockInfoBlock()) { 21264a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor Error("malformed BlockInfoBlock in AST file"); 21274a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor return Failure; 2128d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor } 2129d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor break; 2130d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case AST_BLOCK_ID: 21314a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor switch (ReadASTBlock(F)) { 2132d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case Success: 2133d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor break; 21344714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor 21354714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor case Failure: 2136d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor return Failure; 2137d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2138d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case IgnorePCH: 21394a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor // FIXME: We could consider reading through to the end of this 2140d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // AST block, skipping subblocks, to see if there are other 21414714c12a1ab759156b78be8f109ea4c12213af57Douglas Gregor // AST blocks elsewhere. 21421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2143d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // Clear out any preallocated source location entries, so that 2144d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // the source manager does not try to resolve them later. 21451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SourceMgr.ClearPreallocatedSLocEntries(); 214633500955d731c73717af52088b7fc0e7a85681e7John McCall 214733500955d731c73717af52088b7fc0e7a85681e7John McCall // Remove the stat cache. 21484a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor if (F.StatCache) 214933500955d731c73717af52088b7fc0e7a85681e7John McCall FileMgr.removeStatCache((ASTStatCache*)F.StatCache); 21504ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad 215133500955d731c73717af52088b7fc0e7a85681e7John McCall return IgnorePCH; 215233500955d731c73717af52088b7fc0e7a85681e7John McCall } 215333500955d731c73717af52088b7fc0e7a85681e7John McCall break; 215433500955d731c73717af52088b7fc0e7a85681e7John McCall default: 215533500955d731c73717af52088b7fc0e7a85681e7John McCall if (Stream.SkipBlock()) { 215633500955d731c73717af52088b7fc0e7a85681e7John McCall Error("malformed block record in AST file"); 215733500955d731c73717af52088b7fc0e7a85681e7John McCall return Failure; 215833500955d731c73717af52088b7fc0e7a85681e7John McCall } 215933500955d731c73717af52088b7fc0e7a85681e7John McCall break; 216033500955d731c73717af52088b7fc0e7a85681e7John McCall } 216133500955d731c73717af52088b7fc0e7a85681e7John McCall } 216233500955d731c73717af52088b7fc0e7a85681e7John McCall 216333500955d731c73717af52088b7fc0e7a85681e7John McCall return Success; 216433500955d731c73717af52088b7fc0e7a85681e7John McCall} 216533500955d731c73717af52088b7fc0e7a85681e7John McCall 21664ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadvoid ASTReader::setPreprocessor(Preprocessor &pp) { 21671734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor PP = &pp; 21681734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor 2169789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor unsigned TotalNum = 0; 217033500955d731c73717af52088b7fc0e7a85681e7John McCall for (unsigned I = 0, N = Chain.size(); I != N; ++I) 217133500955d731c73717af52088b7fc0e7a85681e7John McCall TotalNum += Chain[I]->NumPreallocatedPreprocessingEntities; 2172789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor if (TotalNum) { 2173789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor if (!PP->getPreprocessingRecord()) 217433500955d731c73717af52088b7fc0e7a85681e7John McCall PP->createPreprocessingRecord(); 217533500955d731c73717af52088b7fc0e7a85681e7John McCall PP->getPreprocessingRecord()->SetExternalSource(*this, TotalNum); 2176789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor } 2177789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor} 2178789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 217933500955d731c73717af52088b7fc0e7a85681e7John McCallvoid ASTReader::InitializeContext(ASTContext &Ctx) { 218033500955d731c73717af52088b7fc0e7a85681e7John McCall Context = &Ctx; 218133500955d731c73717af52088b7fc0e7a85681e7John McCall assert(Context && "Passed null context!"); 218233500955d731c73717af52088b7fc0e7a85681e7John McCall 21831734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor assert(PP && "Forgot to set Preprocessor ?"); 218433500955d731c73717af52088b7fc0e7a85681e7John McCall PP->getIdentifierTable().setExternalIdentifierLookup(this); 218533500955d731c73717af52088b7fc0e7a85681e7John McCall PP->getHeaderSearchInfo().SetExternalLookup(this); 218633500955d731c73717af52088b7fc0e7a85681e7John McCall PP->setExternalSource(this); 218733500955d731c73717af52088b7fc0e7a85681e7John McCall 218833500955d731c73717af52088b7fc0e7a85681e7John McCall // Load the translation unit declaration 218933500955d731c73717af52088b7fc0e7a85681e7John McCall GetTranslationUnitDecl(); 2190789b1f640205e81b5af250693246120f1ce9d147Douglas Gregor 21911734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor // Load the special types. 219233500955d731c73717af52088b7fc0e7a85681e7John McCall Context->setBuiltinVaListType( 219333500955d731c73717af52088b7fc0e7a85681e7John McCall GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST])); 219433500955d731c73717af52088b7fc0e7a85681e7John McCall if (unsigned Id = SpecialTypes[SPECIAL_TYPE_OBJC_ID]) 219533500955d731c73717af52088b7fc0e7a85681e7John McCall Context->setObjCIdType(GetType(Id)); 219633500955d731c73717af52088b7fc0e7a85681e7John McCall if (unsigned Sel = SpecialTypes[SPECIAL_TYPE_OBJC_SELECTOR]) 219733500955d731c73717af52088b7fc0e7a85681e7John McCall Context->setObjCSelType(GetType(Sel)); 219833500955d731c73717af52088b7fc0e7a85681e7John McCall if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL]) 219933500955d731c73717af52088b7fc0e7a85681e7John McCall Context->setObjCProtoType(GetType(Proto)); 220033500955d731c73717af52088b7fc0e7a85681e7John McCall if (unsigned Class = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS]) 220133500955d731c73717af52088b7fc0e7a85681e7John McCall Context->setObjCClassType(GetType(Class)); 220233500955d731c73717af52088b7fc0e7a85681e7John McCall 220333500955d731c73717af52088b7fc0e7a85681e7John McCall if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) 220433500955d731c73717af52088b7fc0e7a85681e7John McCall Context->setCFConstantStringType(GetType(String)); 2205ef99001908e799c388f1363b1e607dad5f5b57d3John McCall if (unsigned FastEnum 220633500955d731c73717af52088b7fc0e7a85681e7John McCall = SpecialTypes[SPECIAL_TYPE_OBJC_FAST_ENUMERATION_STATE]) 22071734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor Context->setObjCFastEnumerationStateType(GetType(FastEnum)); 220833500955d731c73717af52088b7fc0e7a85681e7John McCall if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) { 22091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType FileType = GetType(File); 22101734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor if (FileType.isNull()) { 22111734317845d60307d474b5da8a8d33adbaf5e723Douglas Gregor Error("FILE type is NULL"); 22127536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor return; 22137536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor } 22147536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor if (const TypedefType *Typedef = FileType->getAs<TypedefType>()) 22157536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor Context->setFILEDecl(Typedef->getDecl()); 22167536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor else { 22177536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor const TagType *Tag = FileType->getAs<TagType>(); 22187536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor if (!Tag) { 22197536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor Error("Invalid FILE type in AST file"); 22207536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor return; 22217536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor } 22227536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor Context->setFILEDecl(Tag->getDecl()); 22237536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor } 22247536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor } 22257536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) { 22267536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor QualType Jmp_bufType = GetType(Jmp_buf); 22277536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor if (Jmp_bufType.isNull()) { 22287536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor Error("jmp_bug type is NULL"); 22297536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor return; 22307536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor } 22317536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>()) 22327536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor Context->setjmp_bufDecl(Typedef->getDecl()); 22337536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor else { 22347536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor const TagType *Tag = Jmp_bufType->getAs<TagType>(); 22357536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor if (!Tag) { 22367536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor Error("Invalid jmp_buf type in AST file"); 22377536dd5e6c99584481b7dab68b7e7d8df9c54054Douglas Gregor return; 223888cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner } 223988cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner Context->setjmp_bufDecl(Tag->getDecl()); 224088cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner } 224188cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner } 22422e1cd4264d363ca869bf37ef160902f211d21b8cDouglas Gregor if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) { 224388cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner QualType Sigjmp_bufType = GetType(Sigjmp_buf); 224488cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner if (Sigjmp_bufType.isNull()) { 2245c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Error("sigjmp_buf type is NULL"); 224654e14c4db764c0636160d26c5bbf491637c83a76John McCall return; 224754e14c4db764c0636160d26c5bbf491637c83a76John McCall } 224854e14c4db764c0636160d26c5bbf491637c83a76John McCall if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>()) 224954e14c4db764c0636160d26c5bbf491637c83a76John McCall Context->setsigjmp_bufDecl(Typedef->getDecl()); 225054e14c4db764c0636160d26c5bbf491637c83a76John McCall else { 225154e14c4db764c0636160d26c5bbf491637c83a76John McCall const TagType *Tag = Sigjmp_bufType->getAs<TagType>(); 225254e14c4db764c0636160d26c5bbf491637c83a76John McCall assert(Tag && "Invalid sigjmp_buf type in AST file"); 225354e14c4db764c0636160d26c5bbf491637c83a76John McCall Context->setsigjmp_bufDecl(Tag->getDecl()); 225454e14c4db764c0636160d26c5bbf491637c83a76John McCall } 225554e14c4db764c0636160d26c5bbf491637c83a76John McCall } 225688cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner if (unsigned ObjCIdRedef 225788cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) 22581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef); 225988cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner if (unsigned ObjCClassRedef 226088cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) 226188cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef); 226288cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner if (unsigned String = SpecialTypes[SPECIAL_TYPE_BLOCK_DESCRIPTOR]) 226388cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner Context->setBlockDescriptorType(GetType(String)); 226488cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner if (unsigned String 226588cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner = SpecialTypes[SPECIAL_TYPE_BLOCK_EXTENDED_DESCRIPTOR]) 226688cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner Context->setBlockDescriptorExtendedType(GetType(String)); 2267c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (unsigned ObjCSelRedef 2268c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) 22694ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Context->ObjCSelRedefinitionType = GetType(ObjCSelRedef); 2270c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (unsigned String = SpecialTypes[SPECIAL_TYPE_NS_CONSTANT_STRING]) 2271c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Context->setNSConstantStringType(GetType(String)); 2272c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 2273c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (SpecialTypes[SPECIAL_TYPE_INT128_INSTALLED]) 2274d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff Context->setInt128Installed(); 2275c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall} 2276c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 2277c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall/// \brief Retrieve the name of the original source file name 2278d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff/// directly from the AST file, without actually loading the AST 2279c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall/// file. 2280c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCallstd::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, 2281d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff Diagnostic &Diags) { 2282c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // Open the AST file. 2283c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall std::string ErrStr; 228454e14c4db764c0636160d26c5bbf491637c83a76John McCall llvm::OwningPtr<llvm::MemoryBuffer> Buffer; 2285c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Buffer.reset(llvm::MemoryBuffer::getFile(ASTFileName.c_str(), &ErrStr)); 2286c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (!Buffer) { 2287c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr; 22880237941e0beb0c929934b66ad29443b484d987feBenjamin Kramer return std::string(); 22890237941e0beb0c929934b66ad29443b484d987feBenjamin Kramer } 229054e14c4db764c0636160d26c5bbf491637c83a76John McCall 229154e14c4db764c0636160d26c5bbf491637c83a76John McCall // Initialize the stream 229254e14c4db764c0636160d26c5bbf491637c83a76John McCall llvm::BitstreamReader StreamFile; 2293c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall llvm::BitstreamCursor Stream; 2294c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 229554e14c4db764c0636160d26c5bbf491637c83a76John McCall (const unsigned char *)Buffer->getBufferEnd()); 2296c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Stream.init(StreamFile); 2297c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 229854e14c4db764c0636160d26c5bbf491637c83a76John McCall // Sniff for the signature. 229954e14c4db764c0636160d26c5bbf491637c83a76John McCall if (Stream.Read(8) != 'C' || 230054e14c4db764c0636160d26c5bbf491637c83a76John McCall Stream.Read(8) != 'P' || 2301c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Stream.Read(8) != 'C' || 230254e14c4db764c0636160d26c5bbf491637c83a76John McCall Stream.Read(8) != 'H') { 230354e14c4db764c0636160d26c5bbf491637c83a76John McCall Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName; 2304c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return std::string(); 2305c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall } 2306fd6a0887a099256c35a5b23e9afd517ffe95fa0aDouglas Gregor 2307c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall RecordData Record; 2308c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall while (!Stream.AtEndOfStream()) { 23091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump unsigned Code = Stream.ReadCode(); 2310c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 2311c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (Code == llvm::bitc::ENTER_SUBBLOCK) { 2312c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall unsigned BlockID = Stream.ReadSubBlockID(); 2313d1b3c2dd5bc1f3103bee6137957aa7c5f8f2f0bcSteve Naroff 231488cb27a160adc305783a44f922ee4b216006ebf9Chris Lattner // We only know the AST subblock ID. 2315c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall switch (BlockID) { 2316c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall case AST_BLOCK_ID: 23174ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 23184b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 2319c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return std::string(); 23201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 23214b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian break; 2322c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 2323c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall default: 23244b6c9051c6522894978c9ba6a819a659d102db36Fariborz Jahanian if (Stream.SkipBlock()) { 23251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 2326c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return std::string(); 232754e14c4db764c0636160d26c5bbf491637c83a76John McCall } 2328c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall break; 2329c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall } 233054e14c4db764c0636160d26c5bbf491637c83a76John McCall continue; 2331c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall } 2332c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall 233354e14c4db764c0636160d26c5bbf491637c83a76John McCall if (Code == llvm::bitc::END_BLOCK) { 233454e14c4db764c0636160d26c5bbf491637c83a76John McCall if (Stream.ReadBlockEnd()) { 2335c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName; 2336c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall return std::string(); 2337c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall } 2338c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall continue; 233924fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis } 234024fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis 2341c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (Code == llvm::bitc::DEFINE_ABBREV) { 234224fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis Stream.ReadAbbrevRecord(); 234324fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis continue; 234424fab41057e4b67ed69a6b4027d5ae0f2f6934dcArgyrios Kyrtzidis } 2345deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor 2346deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor Record.clear(); 23474ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad const char *BlobStart = 0; 2348deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor unsigned BlobLen = 0; 2349deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen) 235074c730ad1f6818b676b0bad46d806a9176950328Sebastian Redl == ORIGINAL_FILE_NAME) 2351deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor return std::string(BlobStart, BlobLen); 2352deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor } 2353deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor 2354deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor return std::string(); 2355deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor} 2356deacbdca554298ccdf636f19c6094a8825ec6b34Douglas Gregor 2357c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall/// \brief Parse the record that corresponds to a LangOptions data 2358c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall/// structure. 235972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor/// 236072564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor/// This routine parses the language options from the AST file and then gives 23619752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// them to the AST listener if one is set. 23621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// 23639752f25748d954df99087d741ea35db37ff16beaSteve Naroff/// \returns true if the listener deems the file unacceptable, false otherwise. 23644ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foadbool ASTReader::ParseLanguageOptions( 2365dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor const llvm::SmallVectorImpl<uint64_t> &Record) { 2366b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor if (Listener) { 2367b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor LangOptions LangOpts; 2368b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor 23691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump #define PARSE_LANGOPT(Option) \ 2370b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor LangOpts.Option = Record[Idx]; \ 2371b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor ++Idx 2372b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor 2373b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor unsigned Idx = 0; 2374b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor PARSE_LANGOPT(Trigraphs); 2375b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor PARSE_LANGOPT(BCPLComment); 23766b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall PARSE_LANGOPT(DollarIdents); 2377b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor PARSE_LANGOPT(AsmPreprocessor); 2378b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor PARSE_LANGOPT(GNUMode); 2379b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor PARSE_LANGOPT(GNUKeywords); 2380b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor PARSE_LANGOPT(ImplicitInt); 23816b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall PARSE_LANGOPT(Digraphs); 23826b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall PARSE_LANGOPT(HexFloats); 2383b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor PARSE_LANGOPT(C99); 2384b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor PARSE_LANGOPT(Microsoft); 2385b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor PARSE_LANGOPT(CPlusPlus); 2386b197572cf1cd70a817a1f546478cb2cb9112c48eDouglas Gregor PARSE_LANGOPT(CPlusPlus0x); 2387dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor PARSE_LANGOPT(CXXOperatorNames); 23886b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall PARSE_LANGOPT(ObjC1); 2389dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor PARSE_LANGOPT(ObjC2); 23909752f25748d954df99087d741ea35db37ff16beaSteve Naroff PARSE_LANGOPT(ObjCNonFragileABI); 23919752f25748d954df99087d741ea35db37ff16beaSteve Naroff PARSE_LANGOPT(ObjCNonFragileABI2); 2392d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff PARSE_LANGOPT(NoConstantCFStrings); 2393d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff PARSE_LANGOPT(PascalStrings); 23949752f25748d954df99087d741ea35db37ff16beaSteve Naroff PARSE_LANGOPT(WritableStrings); 23959752f25748d954df99087d741ea35db37ff16beaSteve Naroff PARSE_LANGOPT(LaxVectorConversions); 23969752f25748d954df99087d741ea35db37ff16beaSteve Naroff PARSE_LANGOPT(AltiVec); 23971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump PARSE_LANGOPT(Exceptions); 23989752f25748d954df99087d741ea35db37ff16beaSteve Naroff PARSE_LANGOPT(SjLjExceptions); 23994ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad PARSE_LANGOPT(NeXTRuntime); 2400f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner PARSE_LANGOPT(Freestanding); 24016b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall PARSE_LANGOPT(NoBuiltin); 24029752f25748d954df99087d741ea35db37ff16beaSteve Naroff PARSE_LANGOPT(ThreadsafeStatics); 24039752f25748d954df99087d741ea35db37ff16beaSteve Naroff PARSE_LANGOPT(POSIXThreads); 2404d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff PARSE_LANGOPT(Blocks); 2405d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff PARSE_LANGOPT(EmitAllDecls); 240660a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson PARSE_LANGOPT(MathErrno); 240760a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson LangOpts.setSignedOverflowBehavior((LangOptions::SignedOverflowBehaviorTy) 24084ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Record[Idx++]); 2409a07c33e64e1169e4261f7748c7f9191091a3ad2eAnders Carlsson PARSE_LANGOPT(HeinousExtensions); 2410a07c33e64e1169e4261f7748c7f9191091a3ad2eAnders Carlsson PARSE_LANGOPT(Optimize); 24111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump PARSE_LANGOPT(OptimizeSize); 241260a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson PARSE_LANGOPT(Static); 241360a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson PARSE_LANGOPT(PICLevel); 241460a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson PARSE_LANGOPT(GNUInline); 241560a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson PARSE_LANGOPT(NoInline); 241660a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson PARSE_LANGOPT(AccessControl); 241760a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson PARSE_LANGOPT(CharIsSigned); 241860a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson PARSE_LANGOPT(ShortWChar); 241960a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson LangOpts.setGCMode((LangOptions::GCMode)Record[Idx++]); 242060a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson LangOpts.setVisibilityMode((LangOptions::VisibilityMode)Record[Idx++]); 242160a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson LangOpts.setStackProtectorMode((LangOptions::StackProtectorMode) 242260a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson Record[Idx++]); 242360a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson PARSE_LANGOPT(InstantiationDepth); 242460a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson PARSE_LANGOPT(OpenCL); 242560a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson PARSE_LANGOPT(CatchUndefined); 242660a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson // FIXME: Missing ElideConstructors?! 24271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump #undef PARSE_LANGOPT 242860a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson 24291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Listener->ReadLanguageOptions(LangOpts); 24301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 243160a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson 24327eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall return false; 243360a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson} 24341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 243560a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlssonvoid ASTReader::ReadPreprocessedEntities() { 243660a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson ReadDefinedMacros(); 243760a9a2a404a4cf259d39133383e922aa00ca9043Anders Carlsson} 2438395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson 2439395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson/// \brief Get the correct cursor and offset for loading a type. 2440395b475a4474f1c7574d927ad142ca0c7997cbcaAnders CarlssonASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) { 24411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump PerFileData *F = 0; 2442395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 24434ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad F = Chain[N - I - 1]; 2444dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor if (Index < F->LocalNumTypes) 24459d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor break; 24469d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor Index -= F->LocalNumTypes; 24479d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor } 24481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(F && F->LocalNumTypes > Index && "Broken chain"); 24499d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor return RecordLocation(&F->DeclsCursor, F->TypeOffsets[Index]); 24509d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor} 24519d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor 24529d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor/// \brief Read and return the type with the given index.. 24539d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor/// 24549d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor/// The index is the type ID, shifted and minus the number of predefs. This 24556b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall/// routine actually reads the record corresponding to the type at the given 24569d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor/// location. It is a helper routine for GetType, which deals with reading type 24579d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor/// IDs. 24589d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas GregorQualType ASTReader::ReadTypeRecord(unsigned Index) { 24599d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor RecordLocation Loc = TypeCursorForIndex(Index); 24606b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall llvm::BitstreamCursor &DeclsCursor = *Loc.first; 24619d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor 24629d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor // Keep track of where we are in the stream, then jump back there 24639d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor // after reading this type. 24649d702ae1cd5cfa19d884cbef77e1df99395138bbDouglas Gregor SavedStreamPosition SavedPosition(DeclsCursor); 2465dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor 24666b304a0254a13f42390b865ff5ba668a49cc58aeJohn McCall ReadingKindTracker ReadingKind(Read_Type, *this); 2467dd0257c77719a13d4acd513df40b04300cbfc871Douglas Gregor 2468395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson // Note that we are loading a type record. 2469395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson Deserializing AType(this); 2470395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson 2471395b475a4474f1c7574d927ad142ca0c7997cbcaAnders Carlsson DeclsCursor.JumpToBit(Loc.second); 24725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer RecordData Record; 24735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer unsigned Code = DeclsCursor.ReadCode(); 24744ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) { 2475d778f88d32b96a74c9edb7342c81357606a7cdc0Ted Kremenek case TYPE_EXT_QUAL: { 2476e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump if (Record.size() != 2) { 2477e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump Error("Incorrect encoding of extended qualifier type"); 2478e607ed068334bacb8d7b093996b4671c6ca79e25Mike Stump return QualType(); 24795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 24805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Base = GetType(Record[0]); 24811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[1]); 24821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Context->getQualifiedType(Base, Quals); 24831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 2484a3ccda58913cc1a4b8564e349448b12acc462da7Anders Carlsson 2485b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor case TYPE_COMPLEX: { 24865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Record.size() != 1) { 24875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Error("Incorrect encoding of complex type"); 248864c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis return QualType(); 248964c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis } 249064c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis QualType ElemType = GetType(Record[0]); 249164c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis return Context->getComplexType(ElemType); 249264c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis } 249364c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis 249464c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis case TYPE_POINTER: { 249564c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis if (Record.size() != 1) { 249664c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis Error("Incorrect encoding of pointer type"); 249764c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis return QualType(); 249864c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis } 249964c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis QualType PointeeType = GetType(Record[0]); 250064c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis return Context->getPointerType(PointeeType); 250164c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis } 25028b9023ba35a86838789e2c9034a6128728c547aaChris Lattner 25038b9023ba35a86838789e2c9034a6128728c547aaChris Lattner case TYPE_BLOCK_POINTER: { 25048b9023ba35a86838789e2c9034a6128728c547aaChris Lattner if (Record.size() != 1) { 2505b4e66d5259f90e9aae4d40fc5de801e046c7df94Douglas Gregor Error("Incorrect encoding of block pointer type"); 25068b9023ba35a86838789e2c9034a6128728c547aaChris Lattner return QualType(); 25078b9023ba35a86838789e2c9034a6128728c547aaChris Lattner } 2508e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner QualType PointeeType = GetType(Record[0]); 2509e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner return Context->getBlockPointerType(PointeeType); 2510e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner } 2511e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner 25124ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad case TYPE_LVALUE_REFERENCE: { 251354e14c4db764c0636160d26c5bbf491637c83a76John McCall if (Record.size() != 1) { 251454e14c4db764c0636160d26c5bbf491637c83a76John McCall Error("Incorrect encoding of lvalue reference type"); 251554e14c4db764c0636160d26c5bbf491637c83a76John McCall return QualType(); 2516745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian } 251754e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType PointeeType = GetType(Record[0]); 251854e14c4db764c0636160d26c5bbf491637c83a76John McCall return Context->getLValueReferenceType(PointeeType); 251954e14c4db764c0636160d26c5bbf491637c83a76John McCall } 252054e14c4db764c0636160d26c5bbf491637c83a76John McCall 252154e14c4db764c0636160d26c5bbf491637c83a76John McCall case TYPE_RVALUE_REFERENCE: { 252254e14c4db764c0636160d26c5bbf491637c83a76John McCall if (Record.size() != 1) { 252354e14c4db764c0636160d26c5bbf491637c83a76John McCall Error("Incorrect encoding of rvalue reference type"); 252454e14c4db764c0636160d26c5bbf491637c83a76John McCall return QualType(); 252554e14c4db764c0636160d26c5bbf491637c83a76John McCall } 252654e14c4db764c0636160d26c5bbf491637c83a76John McCall QualType PointeeType = GetType(Record[0]); 252754e14c4db764c0636160d26c5bbf491637c83a76John McCall return Context->getRValueReferenceType(PointeeType); 252854e14c4db764c0636160d26c5bbf491637c83a76John McCall } 252954e14c4db764c0636160d26c5bbf491637c83a76John McCall 253077c9647cae939104c6cb2b6a4dd8ca859d2e5770Chris Lattner case TYPE_MEMBER_POINTER: { 253177c9647cae939104c6cb2b6a4dd8ca859d2e5770Chris Lattner if (Record.size() != 2) { 253277c9647cae939104c6cb2b6a4dd8ca859d2e5770Chris Lattner Error("Incorrect encoding of member pointer type"); 253377c9647cae939104c6cb2b6a4dd8ca859d2e5770Chris Lattner return QualType(); 253477c9647cae939104c6cb2b6a4dd8ca859d2e5770Chris Lattner } 253577c9647cae939104c6cb2b6a4dd8ca859d2e5770Chris Lattner QualType PointeeType = GetType(Record[0]); 25364ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad QualType ClassType = GetType(Record[1]); 25370953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return Context->getMemberPointerType(PointeeType, ClassType.getTypePtr()); 25380953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 25390953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 25400953e767ff7817f97b3ab20896b229891eeff45bJohn McCall case TYPE_CONSTANT_ARRAY: { 25410953e767ff7817f97b3ab20896b229891eeff45bJohn McCall QualType ElementType = GetType(Record[0]); 25420953e767ff7817f97b3ab20896b229891eeff45bJohn McCall ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 25431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump unsigned IndexTypeQuals = Record[2]; 25440953e767ff7817f97b3ab20896b229891eeff45bJohn McCall unsigned Idx = 3; 25450953e767ff7817f97b3ab20896b229891eeff45bJohn McCall llvm::APInt Size = ReadAPInt(Record, Idx); 254650d62d1b4a98adbc83de8f8cd1379ea1c25656f7Douglas Gregor return Context->getConstantArrayType(ElementType, Size, 2547c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner ASM, IndexTypeQuals); 25480953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 25490953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 25500953e767ff7817f97b3ab20896b229891eeff45bJohn McCall case TYPE_INCOMPLETE_ARRAY: { 2551c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner QualType ElementType = GetType(Record[0]); 2552c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 25530953e767ff7817f97b3ab20896b229891eeff45bJohn McCall unsigned IndexTypeQuals = Record[2]; 25541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Context->getIncompleteArrayType(ElementType, ASM, IndexTypeQuals); 2555c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner } 2556c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 25570953e767ff7817f97b3ab20896b229891eeff45bJohn McCall case TYPE_VARIABLE_ARRAY: { 2558c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner QualType ElementType = GetType(Record[0]); 25591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 2560c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner unsigned IndexTypeQuals = Record[2]; 256150d62d1b4a98adbc83de8f8cd1379ea1c25656f7Douglas Gregor SourceLocation LBLoc = SourceLocation::getFromRawEncoding(Record[3]); 256250d62d1b4a98adbc83de8f8cd1379ea1c25656f7Douglas Gregor SourceLocation RBLoc = SourceLocation::getFromRawEncoding(Record[4]); 256350d62d1b4a98adbc83de8f8cd1379ea1c25656f7Douglas Gregor return Context->getVariableArrayType(ElementType, ReadExpr(DeclsCursor), 25640953e767ff7817f97b3ab20896b229891eeff45bJohn McCall ASM, IndexTypeQuals, 2565c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner SourceRange(LBLoc, RBLoc)); 256650d62d1b4a98adbc83de8f8cd1379ea1c25656f7Douglas Gregor } 256750d62d1b4a98adbc83de8f8cd1379ea1c25656f7Douglas Gregor 25680953e767ff7817f97b3ab20896b229891eeff45bJohn McCall case TYPE_VECTOR: { 25691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (Record.size() != 3) { 2570898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor Error("incorrect encoding of vector type in AST file"); 257150d62d1b4a98adbc83de8f8cd1379ea1c25656f7Douglas Gregor return QualType(); 257250d62d1b4a98adbc83de8f8cd1379ea1c25656f7Douglas Gregor } 25733fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall 257450d62d1b4a98adbc83de8f8cd1379ea1c25656f7Douglas Gregor QualType ElementType = GetType(Record[0]); 25750953e767ff7817f97b3ab20896b229891eeff45bJohn McCall unsigned NumElements = Record[1]; 257687a924e37dc40c6e3e2b33d1dbd646aeccf4c15bDouglas Gregor unsigned AltiVecSpec = Record[2]; 2577898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return Context->getVectorType(ElementType, NumElements, 2578c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner (VectorType::AltiVecSpecific)AltiVecSpec); 257950d62d1b4a98adbc83de8f8cd1379ea1c25656f7Douglas Gregor } 25803fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall 258150d62d1b4a98adbc83de8f8cd1379ea1c25656f7Douglas Gregor case TYPE_EXT_VECTOR: { 25820953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (Record.size() != 3) { 258350d62d1b4a98adbc83de8f8cd1379ea1c25656f7Douglas Gregor Error("incorrect encoding of extended vector type in AST file"); 2584c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner return QualType(); 2585c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner } 258628e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 258728e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth QualType ElementType = GetType(Record[0]); 25885535c38a2fcface6c13bc8bbeca66882de2fa227Chandler Carruth unsigned NumElements = Record[1]; 25899dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor return Context->getExtVectorType(ElementType, NumElements); 25909dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor } 25915535c38a2fcface6c13bc8bbeca66882de2fa227Chandler Carruth 259228e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth case TYPE_FUNCTION_NO_PROTO: { 259328e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth if (Record.size() != 4) { 259428e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth Error("incorrect encoding of no-proto function type"); 2595c1ae0a8b0022a9fbb50d3413139f36ec5d8a63beZhongxing Xu return QualType(); 259628e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth } 259728e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth QualType ResultType = GetType(Record[0]); 259828e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth FunctionType::ExtInfo Info(Record[1], Record[2], (CallingConv)Record[3]); 25999dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor return Context->getFunctionNoProtoType(ResultType, Info); 260028e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth } 260128e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth 260228e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth case TYPE_FUNCTION_PROTO: { 260328e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth QualType ResultType = GetType(Record[0]); 26049dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor bool NoReturn = Record[1]; 260528e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth unsigned RegParm = Record[2]; 260628e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth CallingConv CallConv = (CallingConv)Record[3]; 260728e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth unsigned Idx = 4; 26089dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor unsigned NumParams = Record[Idx++]; 26099dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor llvm::SmallVector<QualType, 16> ParamTypes; 26103fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall for (unsigned I = 0; I != NumParams; ++I) 26119dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor ParamTypes.push_back(GetType(Record[Idx++])); 26129dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor bool isVariadic = Record[Idx++]; 26139dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor unsigned Quals = Record[Idx++]; 26149dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor bool hasExceptionSpec = Record[Idx++]; 26159dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor bool hasAnyExceptionSpec = Record[Idx++]; 26169dadd94e1c17fa030d1f88d8f2113ff59ccc6714Douglas Gregor unsigned NumExceptions = Record[Idx++]; 26173fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall llvm::SmallVector<QualType, 2> Exceptions; 261828e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth for (unsigned I = 0; I != NumExceptions; ++I) 261928e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth Exceptions.push_back(GetType(Record[Idx++])); 262028e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams, 262128e318cc6008c2bc008f0caee70dc736a03d6289Chandler Carruth isVariadic, Quals, hasExceptionSpec, 26225a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor hasAnyExceptionSpec, NumExceptions, 26235a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor Exceptions.data(), 26245a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor FunctionType::ExtInfo(NoReturn, RegParm, 26255a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor CallConv)); 26265a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 26275a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 26285a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor case TYPE_UNRESOLVED_USING: 26295a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return Context->getTypeDeclType( 26305a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor cast<UnresolvedUsingTypenameDecl>(GetDecl(Record[0]))); 26315a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 26325a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor case TYPE_TYPEDEF: { 26335a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (Record.size() != 2) { 26345a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor Error("incorrect encoding of typedef type"); 26355a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return QualType(); 26365a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 26375a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor TypedefDecl *Decl = cast<TypedefDecl>(GetDecl(Record[0])); 26385a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor QualType Canonical = GetType(Record[1]); 26395a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return Context->getTypedefType(Decl, Canonical); 26405a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 26415a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 26425a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor case TYPE_TYPEOF_EXPR: 26435a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return Context->getTypeOfExprType(ReadExpr(DeclsCursor)); 26445a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 26455a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor case TYPE_TYPEOF: { 26465a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (Record.size() != 1) { 26475a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor Error("incorrect encoding of typeof(type) in AST file"); 26485a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return QualType(); 26495a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 26505a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor QualType UnderlyingType = GetType(Record[0]); 26515a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return Context->getTypeOfType(UnderlyingType); 26525a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 26535a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 26545a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor case TYPE_DECLTYPE: 26555a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return Context->getDecltypeType(ReadExpr(DeclsCursor)); 26565a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor 26575a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor case TYPE_RECORD: { 26585a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor if (Record.size() != 2) { 26595a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor Error("incorrect encoding of record type"); 26605a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor return QualType(); 26615a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor } 26625a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor bool IsDependent = Record[0]; 26635a57efd7bf88a4a13018e0471ded8063a4abe8afDouglas Gregor QualType T = Context->getRecordType(cast<RecordDecl>(GetDecl(Record[1]))); 26644ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad T->Dependent = IsDependent; 26654ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad return T; 26664ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad } 266780ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall 26682577743c5650c646fb705df01403707e94f2df04Abramo Bagnara case TYPE_ENUM: { 26692577743c5650c646fb705df01403707e94f2df04Abramo Bagnara if (Record.size() != 2) { 26702577743c5650c646fb705df01403707e94f2df04Abramo Bagnara Error("incorrect encoding of enum type"); 267180ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall return QualType(); 26722577743c5650c646fb705df01403707e94f2df04Abramo Bagnara } 267380ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall bool IsDependent = Record[0]; 26742577743c5650c646fb705df01403707e94f2df04Abramo Bagnara QualType T = Context->getEnumType(cast<EnumDecl>(GetDecl(Record[1]))); 26752577743c5650c646fb705df01403707e94f2df04Abramo Bagnara T->Dependent = IsDependent; 267680ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall return T; 26772577743c5650c646fb705df01403707e94f2df04Abramo Bagnara } 26782577743c5650c646fb705df01403707e94f2df04Abramo Bagnara 26792577743c5650c646fb705df01403707e94f2df04Abramo Bagnara case TYPE_ELABORATED: { 26802577743c5650c646fb705df01403707e94f2df04Abramo Bagnara unsigned Idx = 0; 26812577743c5650c646fb705df01403707e94f2df04Abramo Bagnara ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 26822577743c5650c646fb705df01403707e94f2df04Abramo Bagnara NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 268380ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall QualType NamedType = GetType(Record[Idx++]); 268480ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall return Context->getElaboratedType(Keyword, NNS, NamedType); 268580ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall } 26860bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall 26870bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall case TYPE_OBJC_INTERFACE: { 26882577743c5650c646fb705df01403707e94f2df04Abramo Bagnara unsigned Idx = 0; 26892577743c5650c646fb705df01403707e94f2df04Abramo Bagnara ObjCInterfaceDecl *ItfD = cast<ObjCInterfaceDecl>(GetDecl(Record[Idx++])); 269080ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall return Context->getObjCInterfaceType(ItfD); 269180ad16f4b2b350ddbaae21a52975e63df5aafc2cJohn McCall } 26924ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad 26933e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor case TYPE_OBJC_OBJECT: { 26943e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor unsigned Idx = 0; 26953e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor QualType Base = GetType(Record[Idx++]); 26963e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor unsigned NumProtos = Record[Idx++]; 26973e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor llvm::SmallVector<ObjCProtocolDecl*, 4> Protos; 26983e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor for (unsigned I = 0; I != NumProtos; ++I) 269997fbaa2a38804268a024f1a104b43fcf8b4411b0Argyrios Kyrtzidis Protos.push_back(cast<ObjCProtocolDecl>(GetDecl(Record[Idx++]))); 27003e1274f2b99cb99c03cc8e2c6517c37d330b597aDouglas Gregor return Context->getObjCObjectType(Base, Protos.data(), NumProtos); 270125a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor } 27020bd6feb9e9d40fc889fd47e899985125a43dfed8John McCall 27031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case TYPE_OBJC_OBJECT_POINTER: { 270425a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor unsigned Idx = 0; 270525a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor QualType Pointee = GetType(Record[Idx++]); 270625a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor return Context->getObjCObjectPointerType(Pointee); 270725a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor } 270825a3ef7cc5fd55dc8cc67c6e6770c8595657e082Douglas Gregor 2709db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 2710db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor unsigned Idx = 0; 2711db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor QualType Parm = GetType(Record[Idx++]); 2712db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor QualType Replacement = GetType(Record[Idx++]); 2713db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor return 2714db0d4b751e83b8841b8f48f913f17e50467f13d4Douglas Gregor Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm), 27151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Replacement); 27164ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad } 27171275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor 27181275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TYPE_INJECTED_CLASS_NAME: { 27191275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor CXXRecordDecl *D = cast<CXXRecordDecl>(GetDecl(Record[0])); 27201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType TST = GetType(Record[1]); // probably derivable 27211275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 27221275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // for AST reading, too much interdependencies. 27231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return 27241275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0); 2725833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall } 27261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2727788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor case TYPE_TEMPLATE_TYPE_PARM: { 2728788cd06cf8e868a67158aafec5de3a1f408d14f3Douglas Gregor unsigned Idx = 0; 2729a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor unsigned Depth = Record[Idx++]; 2730a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor unsigned Index = Record[Idx++]; 2731a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor bool Pack = Record[Idx++]; 2732a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor IdentifierInfo *Name = GetIdentifierInfo(Record, Idx); 2733a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor return Context->getTemplateTypeParmType(Depth, Index, Pack, Name); 2734a7fc901a2e39bfe55bfcff5934b2d9fdf9656491Douglas Gregor } 27351275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor 2736833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall case TYPE_DEPENDENT_NAME: { 27371275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor unsigned Idx = 0; 27381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 27391275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 2740833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx); 27411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType Canon = GetType(Record[Idx++]); 27421275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor return Context->getDependentNameType(Keyword, NNS, Name, Canon); 274387dd697dcc8ecb64df73ae64d61b8c80ff0c157cDouglas Gregor } 274487dd697dcc8ecb64df73ae64d61b8c80ff0c157cDouglas Gregor 274587dd697dcc8ecb64df73ae64d61b8c80ff0c157cDouglas Gregor case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 2746910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor unsigned Idx = 0; 2747910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 27481275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 27491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx); 27501275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor unsigned NumArgs = Record[Idx++]; 27511275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor llvm::SmallVector<TemplateArgument, 8> Args; 27521275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor Args.reserve(NumArgs); 27531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump while (NumArgs--) 2754910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor Args.push_back(ReadTemplateArgument(DeclsCursor, Record, Idx)); 27551275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name, 27561275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor Args.size(), Args.data()); 27571275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor } 27581275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor 27591275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor case TYPE_DEPENDENT_SIZED_ARRAY: { 27601275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor unsigned Idx = 0; 27611275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor 27621275ae098acda31fe0e434510c729fcfed0458a1Douglas Gregor // ArrayType 2763d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor QualType ElementType = GetType(Record[Idx++]); 27644ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad ArrayType::ArraySizeModifier ASM 27651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump = (ArrayType::ArraySizeModifier)Record[Idx++]; 2766d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor unsigned IndexTypeQuals = Record[Idx++]; 2767d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2768d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // DependentSizedArrayType 2769d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor Expr *NumElts = ReadExpr(DeclsCursor); 2770d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor SourceRange Brackets = ReadSourceRange(Record, Idx); 27711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2772d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor return Context->getDependentSizedArrayType(ElementType, NumElts, ASM, 2773d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor IndexTypeQuals, Brackets); 2774d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor } 2775d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2776d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor case TYPE_TEMPLATE_SPECIALIZATION: { 2777d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor unsigned Idx = 0; 2778d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor bool IsDependent = Record[Idx++]; 2779d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor TemplateName Name = ReadTemplateName(Record, Idx); 2780d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor llvm::SmallVector<TemplateArgument, 8> Args; 2781d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor ReadTemplateArgumentList(Args, DeclsCursor, Record, Idx); 2782d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor QualType Canon = GetType(Record[Idx++]); 2783264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor QualType T; 2784264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor if (Canon.isNull()) 2785264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(), 2786264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor Args.size()); 2787264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor else 2788264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor T = Context->getTemplateSpecializationType(Name, Args.data(), 2789264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor Args.size(), Canon); 2790264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor T->Dependent = IsDependent; 2791264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor return T; 2792264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor } 2793264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor } 2794264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor // Suppress a GCC warning 2795264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor return QualType(); 2796264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor} 2797264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor 2798643f84353b3b7bbf9b73bcbc7da0ef8a39a5ca99Douglas Gregornamespace { 2799264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor 2800264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregorclass TypeLocReader : public TypeLocVisitor<TypeLocReader> { 2801264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor ASTReader &Reader; 2802264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor llvm::BitstreamCursor &DeclsCursor; 2803264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor const ASTReader::RecordData &Record; 2804264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor unsigned &Idx; 2805264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor 2806264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregorpublic: 2807264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor TypeLocReader(ASTReader &Reader, llvm::BitstreamCursor &Cursor, 2808264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor const ASTReader::RecordData &Record, unsigned &Idx) 2809264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor : Reader(Reader), DeclsCursor(Cursor), Record(Record), Idx(Idx) { } 2810264bf66d55563dd86a3d7e06738aa427de512d2cDouglas Gregor 2811d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // We want compile-time assurance that we've enumerated all of 2812d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // these, so unfortunately we have to declare them first, then 2813d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor // define them out-of-line. 2814d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor#define ABSTRACT_TYPELOC(CLASS, PARENT) 2815d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor#define TYPELOC(CLASS, PARENT) \ 2816d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 2817d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor#include "clang/AST/TypeLocNodes.def" 2818d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor 2819d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor void VisitFunctionTypeLoc(FunctionTypeLoc); 2820d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor void VisitArrayTypeLoc(ArrayTypeLoc); 2821d57959af02b4af695276f4204443afe6e5d86bd8Douglas Gregor}; 2822c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 28234ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad} 2824c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 2825a4923eb7c4b04d360cb2747641a5e92818edf804Douglas Gregorvoid TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 2826c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner // nothing to do 2827c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner} 2828c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattnervoid TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 2829c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner TL.setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 28301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (TL.needsExtraLocalData()) { 28310953e767ff7817f97b3ab20896b229891eeff45bJohn McCall TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 2832c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 28330953e767ff7817f97b3ab20896b229891eeff45bJohn McCall TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 2834c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner TL.setModeAttr(Record[Idx++]); 28351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 28360953e767ff7817f97b3ab20896b229891eeff45bJohn McCall} 2837c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattnervoid TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 2838c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 28391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump} 2840c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattnervoid TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 2841c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner TL.setStarLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 284250d62d1b4a98adbc83de8f8cd1379ea1c25656f7Douglas Gregor} 28430953e767ff7817f97b3ab20896b229891eeff45bJohn McCallvoid TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 28440953e767ff7817f97b3ab20896b229891eeff45bJohn McCall TL.setCaretLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 284549f4e1cbd839da27ff4814b4ea6d85a79f786cbdJohn McCall} 28461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 2847c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner TL.setAmpLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2848c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner} 28490953e767ff7817f97b3ab20896b229891eeff45bJohn McCallvoid TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 2850c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner TL.setAmpAmpLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 28511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump} 2852c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattnervoid TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 2853c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner TL.setStarLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2854c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner} 2855c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattnervoid TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 28560953e767ff7817f97b3ab20896b229891eeff45bJohn McCall TL.setLBracketLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 28571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TL.setRBracketLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2858c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (Record[Idx++]) 2859c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner TL.setSizeExpr(Reader.ReadExpr(DeclsCursor)); 2860c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner else 28610953e767ff7817f97b3ab20896b229891eeff45bJohn McCall TL.setSizeExpr(0); 2862c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner} 2863c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattnervoid TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 2864c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner VisitArrayTypeLoc(TL); 28650953e767ff7817f97b3ab20896b229891eeff45bJohn McCall} 2866898574e7496ba8fd76290079d3a9d06954992734Douglas Gregorvoid TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 28671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump VisitArrayTypeLoc(TL); 2868898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor} 2869898574e7496ba8fd76290079d3a9d06954992734Douglas Gregorvoid TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 28701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump VisitArrayTypeLoc(TL); 28713fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall} 2872898574e7496ba8fd76290079d3a9d06954992734Douglas Gregorvoid TypeLocReader::VisitDependentSizedArrayTypeLoc( 28730953e767ff7817f97b3ab20896b229891eeff45bJohn McCall DependentSizedArrayTypeLoc TL) { 28747e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor VisitArrayTypeLoc(TL); 28751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump} 2876c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattnervoid TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 28777e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor DependentSizedExtVectorTypeLoc TL) { 28783fa5cae9b3812cab9fab6c042c3329bb70a3d046John McCall TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2879c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner} 28800953e767ff7817f97b3ab20896b229891eeff45bJohn McCallvoid TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 28817e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 288277c9647cae939104c6cb2b6a4dd8ca859d2e5770Chris Lattner} 288377c9647cae939104c6cb2b6a4dd8ca859d2e5770Chris Lattnervoid TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 2884e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2885e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner} 2886e6327747b72bb687c948270f702ff53c30f411a6Chris Lattnervoid TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 2887e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner TL.setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2888e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner TL.setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2889e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 28904ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad TL.setArg(i, cast_or_null<ParmVarDecl>(Reader.GetDecl(Record[Idx++]))); 2891c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner } 2892c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner} 2893c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattnervoid TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 2894c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner VisitFunctionTypeLoc(TL); 2895c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner} 2896c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattnervoid TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 28971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump VisitFunctionTypeLoc(TL); 2898c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner} 2899e6327747b72bb687c948270f702ff53c30f411a6Chris Lattnervoid TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 2900e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29010953e767ff7817f97b3ab20896b229891eeff45bJohn McCall} 2902e6327747b72bb687c948270f702ff53c30f411a6Chris Lattnervoid TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 2903e6327747b72bb687c948270f702ff53c30f411a6Chris Lattner TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29044ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad} 29050953e767ff7817f97b3ab20896b229891eeff45bJohn McCallvoid TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 29060237941e0beb0c929934b66ad29443b484d987feBenjamin Kramer TL.setTypeofLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29070237941e0beb0c929934b66ad29443b484d987feBenjamin Kramer TL.setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 290849f4e1cbd839da27ff4814b4ea6d85a79f786cbdJohn McCall TL.setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29095e03f9ea8174ae588c5e69ec6b5ef4c68f8fd766Douglas Gregor} 29105e03f9ea8174ae588c5e69ec6b5ef4c68f8fd766Douglas Gregorvoid TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 29114ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad TL.setTypeofLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2912fbbce49c116aa8c8c7c0707cb6048b55f70461a9Anders Carlsson TL.setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TL.setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2914fbbce49c116aa8c8c7c0707cb6048b55f70461a9Anders Carlsson TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(DeclsCursor, Record, Idx)); 2915fbbce49c116aa8c8c7c0707cb6048b55f70461a9Anders Carlsson} 29161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 29176183a99b064b397d98297904fbd6cf00fe1f453dAnders Carlsson TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29186183a99b064b397d98297904fbd6cf00fe1f453dAnders Carlsson} 29196183a99b064b397d98297904fbd6cf00fe1f453dAnders Carlssonvoid TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 29200de78998e7bda473b408437053e48661b510d453Fariborz Jahanian TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump} 29220de78998e7bda473b408437053e48661b510d453Fariborz Jahanianvoid TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 29230de78998e7bda473b408437053e48661b510d453Fariborz Jahanian TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29240de78998e7bda473b408437053e48661b510d453Fariborz Jahanian} 29250de78998e7bda473b408437053e48661b510d453Fariborz Jahanianvoid TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 29260de78998e7bda473b408437053e48661b510d453Fariborz Jahanian TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29270de78998e7bda473b408437053e48661b510d453Fariborz Jahanian} 29280de78998e7bda473b408437053e48661b510d453Fariborz Jahanianvoid TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 29290de78998e7bda473b408437053e48661b510d453Fariborz Jahanian SubstTemplateTypeParmTypeLoc TL) { 29300de78998e7bda473b408437053e48661b510d453Fariborz Jahanian TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 29325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid TypeLocReader::VisitTemplateSpecializationTypeLoc( 2933a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner TemplateSpecializationTypeLoc TL) { 2934183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall TL.setTemplateNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer TL.setLAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2936a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner TL.setRAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2937183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 2938183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall TL.setArgLocInfo(i, 2939a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner Reader.GetTemplateArgumentLocInfo(TL.getTypePtr()->getArg(i).getKind(), 29405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer DeclsCursor, Record, Idx)); 29415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 29425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 29435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer TL.setKeywordLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer TL.setQualifierRange(Reader.ReadSourceRange(Record, Idx)); 29455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 29461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 29471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2948716c7304ff5d27a95e1e7823acd1d09d5ec3e37fSteve Naroff} 2949716c7304ff5d27a95e1e7823acd1d09d5ec3e37fSteve Naroffvoid TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 29501361b11066239ea15764a2a844405352d87296b3Chris Lattner TL.setKeywordLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29511361b11066239ea15764a2a844405352d87296b3Chris Lattner TL.setQualifierRange(Reader.ReadSourceRange(Record, Idx)); 29521361b11066239ea15764a2a844405352d87296b3Chris Lattner TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29531361b11066239ea15764a2a844405352d87296b3Chris Lattner} 29541361b11066239ea15764a2a844405352d87296b3Chris Lattnervoid TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 2955716c7304ff5d27a95e1e7823acd1d09d5ec3e37fSteve Naroff DependentTemplateSpecializationTypeLoc TL) { 2956f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff TL.setKeywordLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2957f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff TL.setQualifierRange(Reader.ReadSourceRange(Record, Idx)); 2958f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2959f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff TL.setLAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2960f1448a0e4a1e868ff873a8530a61a09cb68666ccSteve Naroff TL.setRAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29611361b11066239ea15764a2a844405352d87296b3Chris Lattner for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 29621361b11066239ea15764a2a844405352d87296b3Chris Lattner TL.setArgLocInfo(I, 29631361b11066239ea15764a2a844405352d87296b3Chris Lattner Reader.GetTemplateArgumentLocInfo(TL.getTypePtr()->getArg(I).getKind(), 29641361b11066239ea15764a2a844405352d87296b3Chris Lattner DeclsCursor, Record, Idx)); 29651361b11066239ea15764a2a844405352d87296b3Chris Lattner} 29661361b11066239ea15764a2a844405352d87296b3Chris Lattnervoid TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 29671361b11066239ea15764a2a844405352d87296b3Chris Lattner TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 29695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 29705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer TL.setHasBaseTypeAsWritten(Record[Idx++]); 29717cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner TL.setLAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29727cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner TL.setRAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29737cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 29741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TL.setProtocolLoc(i, SourceLocation::getFromRawEncoding(Record[Idx++])); 29754ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad} 2976a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattnervoid TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 2977a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner TL.setStarLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 29781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump} 2979a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner 2980fb0d49669aa370b4c0993c5cee60275ef9fd6518Steve NaroffTypeSourceInfo *ASTReader::GetTypeSourceInfo(llvm::BitstreamCursor &DeclsCursor, 2981a75cea3f6be0daa8054d36af81a6ffda1713f82dChris Lattner const RecordData &Record, 2982fb0d49669aa370b4c0993c5cee60275ef9fd6518Steve Naroff unsigned &Idx) { 2983fb0d49669aa370b4c0993c5cee60275ef9fd6518Steve Naroff QualType InfoTy = GetType(Record[Idx++]); 29845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (InfoTy.isNull()) 29855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return 0; 2986f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner 2987f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy); 2988f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner TypeLocReader TLR(*this, DeclsCursor, Record, Idx); 29894ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 2990467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall TLR.Visit(TL); 2991f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman return TInfo; 2992842aef8d942a880eeb9535d40de31a86838264cbJohn McCall} 2993f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman 29943f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris LattnerQualType ASTReader::GetType(TypeID ID) { 29953f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner unsigned FastQuals = ID & Qualifiers::FastMask; 2996a34267595534a72703290153a6f7e3da1adcec59Eli Friedman unsigned Index = ID >> Qualifiers::FastWidth; 2997a34267595534a72703290153a6f7e3da1adcec59Eli Friedman 2998f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith if (Index < NUM_PREDEF_TYPE_IDS) { 2999f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith QualType T; 3000f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith switch ((PredefinedTypeIDs)Index) { 3001f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case PREDEF_TYPE_NULL_ID: return QualType(); 3002f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break; 3003f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; break; 3004f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner 30057cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case PREDEF_TYPE_CHAR_U_ID: 30067cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case PREDEF_TYPE_CHAR_S_ID: 3007f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman // FIXME: Check that the signedness of CharTy is correct! 30087cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner T = Context->CharTy; 30097cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner break; 30107cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner 30117cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case PREDEF_TYPE_UCHAR_ID: T = Context->UnsignedCharTy; break; 3012f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman case PREDEF_TYPE_USHORT_ID: T = Context->UnsignedShortTy; break; 30137cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case PREDEF_TYPE_UINT_ID: T = Context->UnsignedIntTy; break; 30147cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case PREDEF_TYPE_ULONG_ID: T = Context->UnsignedLongTy; break; 3015f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman case PREDEF_TYPE_ULONGLONG_ID: T = Context->UnsignedLongLongTy; break; 30167cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case PREDEF_TYPE_UINT128_ID: T = Context->UnsignedInt128Ty; break; 30177cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case PREDEF_TYPE_SCHAR_ID: T = Context->SignedCharTy; break; 3018f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman case PREDEF_TYPE_WCHAR_ID: T = Context->WCharTy; break; 30197cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case PREDEF_TYPE_SHORT_ID: T = Context->ShortTy; break; 30207cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case PREDEF_TYPE_INT_ID: T = Context->IntTy; break; 3021f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman case PREDEF_TYPE_LONG_ID: T = Context->LongTy; break; 30227cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case PREDEF_TYPE_LONGLONG_ID: T = Context->LongLongTy; break; 30237cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case PREDEF_TYPE_INT128_ID: T = Context->Int128Ty; break; 3024f98aba35e6c3da5aae61843fc01334939e4e12ecEli Friedman case PREDEF_TYPE_FLOAT_ID: T = Context->FloatTy; break; 30252df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case PREDEF_TYPE_DOUBLE_ID: T = Context->DoubleTy; break; 30262df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy; break; 30272df9ced9fd1e8c7d7b38443db07e0e811de22571Chris Lattner case PREDEF_TYPE_OVERLOAD_ID: T = Context->OverloadTy; break; 3028f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner case PREDEF_TYPE_DEPENDENT_ID: T = Context->DependentTy; break; 3029f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner case PREDEF_TYPE_NULLPTR_ID: T = Context->NullPtrTy; break; 3030f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner case PREDEF_TYPE_CHAR16_ID: T = Context->Char16Ty; break; 303104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman case PREDEF_TYPE_CHAR32_ID: T = Context->Char32Ty; break; 303204e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman case PREDEF_TYPE_OBJC_ID: T = Context->ObjCBuiltinIdTy; break; 303304e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman case PREDEF_TYPE_OBJC_CLASS: T = Context->ObjCBuiltinClassTy; break; 303404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman case PREDEF_TYPE_OBJC_SEL: T = Context->ObjCBuiltinSelTy; break; 303504e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman } 30364ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad 3037ceafbdeb93ecf323cca74e660bf54504c86f3b71Douglas Gregor assert(!T.isNull() && "Unknown predefined type"); 3038ceafbdeb93ecf323cca74e660bf54504c86f3b71Douglas Gregor return T.withFastQualifiers(FastQuals); 3039ceafbdeb93ecf323cca74e660bf54504c86f3b71Douglas Gregor } 304004e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 304104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman Index -= NUM_PREDEF_TYPE_IDS; 304204e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman assert(Index < TypesLoaded.size() && "Type index out-of-range"); 304304e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman if (TypesLoaded[Index].isNull()) { 304404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman TypesLoaded[Index] = ReadTypeRecord(Index); 304504e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman TypesLoaded[Index]->setFromAST(); 304604e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman TypeIdxs[TypesLoaded[Index]] = TypeIdx::fromTypeID(ID); 304704e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman if (DeserializationListener) 304804e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 304904e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman TypesLoaded[Index]); 305004e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman } 305104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 305204e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return TypesLoaded[Index].withFastQualifiers(FastQuals); 305304e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman} 305404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 305504e8357f6801e9ff52673e7e899a67bbabf9de93Eli FriedmanTypeID ASTReader::GetTypeID(QualType T) const { 305604e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return MakeTypeID(T, 305704e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman std::bind1st(std::mem_fun(&ASTReader::GetTypeIdx), this)); 305804e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman} 305904e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 306004e8357f6801e9ff52673e7e899a67bbabf9de93Eli FriedmanTypeIdx ASTReader::GetTypeIdx(QualType T) const { 306104e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman if (T.isNull()) 306204e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman return TypeIdx(); 306304e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman assert(!T.getLocalFastQualifiers()); 306404e8357f6801e9ff52673e7e899a67bbabf9de93Eli Friedman 3065a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman TypeIdxMap::const_iterator I = TypeIdxs.find(T); 3066a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman // GetTypeIdx is mostly used for computing the hash of DeclarationNames and 3067a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman // comparing keys of ASTDeclContextNameLookupTable. 30684ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad // If the type didn't come from the AST file use a specially marked index 3069a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman // so that any hash/key comparison fail since no such index is stored 3070a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman // in a AST file. 3071842aef8d942a880eeb9535d40de31a86838264cbJohn McCall if (I == TypeIdxs.end()) 3072842aef8d942a880eeb9535d40de31a86838264cbJohn McCall return TypeIdx(-1); 3073a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman return I->second; 3074a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman} 3075a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman 3076a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli FriedmanTemplateArgumentLocInfo 3077a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli FriedmanASTReader::GetTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, 3078a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman llvm::BitstreamCursor &DeclsCursor, 3079a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman const RecordData &Record, 3080a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman unsigned &Index) { 30811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump switch (Kind) { 30827cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case TemplateArgument::Expression: 30831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return ReadExpr(DeclsCursor); 30844ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad case TemplateArgument::Type: 3085f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner return GetTypeSourceInfo(DeclsCursor, Record, Index); 3086f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner case TemplateArgument::Template: { 30877cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner SourceRange QualifierRange = ReadSourceRange(Record, Index); 30881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SourceLocation TemplateNameLoc = ReadSourceLocation(Record, Index); 3089f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner return TemplateArgumentLocInfo(QualifierRange, TemplateNameLoc); 3090f52ab250ff92bc51a9ac9a8e19bd43b63a5f844fChris Lattner } 30911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case TemplateArgument::Null: 30927cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case TemplateArgument::Integral: 30937cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner case TemplateArgument::Declaration: 30941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case TemplateArgument::Pack: 30957cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return TemplateArgumentLocInfo(); 30967cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner } 30977cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner llvm_unreachable("unexpected template argument loc"); 30987cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return TemplateArgumentLocInfo(); 30991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump} 31007cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner 31017cfeb08f2466d6263ec6ff1402298f93f6d6991fChris LattnerTemplateArgumentLoc 31027cfeb08f2466d6263ec6ff1402298f93f6d6991fChris LattnerASTReader::ReadTemplateArgumentLoc(llvm::BitstreamCursor &DeclsCursor, 31037cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner const RecordData &Record, unsigned &Index) { 31047cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner TemplateArgument Arg = ReadTemplateArgument(DeclsCursor, Record, Index); 31051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 31067cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (Arg.getKind() == TemplateArgument::Expression) { 31077cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner if (Record[Index++]) // bool InfoHasSameExpr. 31081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 31097cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner } 31107cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(Arg.getKind(), 31117cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner DeclsCursor, 31127cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner Record, Index)); 31137cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner} 31147cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner 31151eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpDecl *ASTReader::GetExternalDecl(uint32_t ID) { 31167cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner return GetDecl(ID); 31177cfeb08f2466d6263ec6ff1402298f93f6d6991fChris Lattner} 31181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 31197cfeb08f2466d6263ec6ff1402298f93f6d6991fChris LattnerTranslationUnitDecl *ASTReader::GetTranslationUnitDecl() { 31205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!DeclsLoaded[0]) { 312171993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson ReadDeclRecord(0, 1); 312279cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson if (DeserializationListener) 31234ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad DeserializationListener->DeclRead(1, DeclsLoaded[0]); 312479cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson } 312579cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson 312679cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson return cast<TranslationUnitDecl>(DeclsLoaded[0]); 312779cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson} 312879cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson 312979cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders CarlssonDecl *ASTReader::GetDecl(DeclID ID) { 313079cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson if (ID == 0) 31311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return 0; 31324ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad 313371993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson if (ID > DeclsLoaded.size()) { 31341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Error("declaration ID out-of-range for AST file"); 3135465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara return 0; 313679cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson } 31375cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall 313879cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson unsigned Index = ID - 1; 3139f06273f8bbacb086a46bde456429c8d08f6d07eeAnders Carlsson if (!DeclsLoaded[Index]) { 31401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ReadDeclRecord(Index, ID); 314171993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson if (DeserializationListener) 31420953e767ff7817f97b3ab20896b229891eeff45bJohn McCall DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 3143f06273f8bbacb086a46bde456429c8d08f6d07eeAnders Carlsson } 3144f06273f8bbacb086a46bde456429c8d08f6d07eeAnders Carlsson 314571993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson return DeclsLoaded[Index]; 31460953e767ff7817f97b3ab20896b229891eeff45bJohn McCall} 314771993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson 31481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Resolve the offset of a statement into a statement. 31491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// 315044b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor/// This operation will read a new statement from the external 315144b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor/// source each time it is called, and is meant to be used via a 31521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 315344b4321feab46299d3f5cfd404680884752a0fcfDouglas GregorStmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 3154a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall // Offset here is a global offset across the entire chain. 31551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 31564afa39deaa245592977136d367251ee2c173dd8dDouglas Gregor PerFileData &F = *Chain[N - I - 1]; 31572888b65aae768f54062505330df7be230a0510c7John McCall if (Offset < F.SizeInBits) { 315817945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis // Since we know that this statement is part of a decl, make sure to use 315944b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor // the decl cursor to read it. 316044b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor F.DeclsCursor.JumpToBit(Offset); 3161838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor return ReadStmtFromStream(F.DeclsCursor); 316271993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson } 31631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Offset -= F.SizeInBits; 316471993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson } 31658467583c2704e7a9691ea56939a029015f0ade0aGabor Greif llvm_unreachable("Broken chain"); 3166b2cf3573d7351094f6247fcca94703ce88eb9ee0Anders Carlsson} 3167319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor 31686217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenekbool ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 3169319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor llvm::SmallVectorImpl<Decl*> &Decls) { 3170319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor assert(DC->hasExternalLexicalStorage() && 3171319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor "DeclContext has no lexical decls in storage"); 3172319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor 31732bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian // There might be lexical decls in multiple parts of the chain, for the TU 31744ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad // at least. 31752bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian DeclContextInfos &Infos = DeclContextOffsets[DC]; 31762bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end(); 3177465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara I != E; ++I) { 31782bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian // IDs can be 0 if this context doesn't contain declarations. 31792bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian if (!I->LexicalDecls) 31802bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian continue; 31812bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian 31822bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian // Load all of the declaration IDs 31832bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian for (const DeclID *ID = I->LexicalDecls, 31842bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian *IDE = ID + I->NumLexicalDecls; 31852bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian ID != IDE; ++ID) 31862bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian Decls.push_back(GetDecl(*ID)); 31872bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian } 31882bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian 31892bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian ++NumLexicalDeclContextsRead; 31902bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian return false; 31912bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian} 31922bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian 31932bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz JahanianDeclContext::lookup_result 31942bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz JahanianASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 31952bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian DeclarationName Name) { 31962bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian assert(DC->hasExternalVisibleStorage() && 31972888b65aae768f54062505330df7be230a0510c7John McCall "DeclContext has no visible decls in storage"); 31982bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian if (!Name) 31992bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian return DeclContext::lookup_result(DeclContext::lookup_iterator(0), 32002bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian DeclContext::lookup_iterator(0)); 32012bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian 32022bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian llvm::SmallVector<NamedDecl *, 64> Decls; 32032bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian // There might be visible decls in multiple parts of the chain, for the TU 32042bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian // and namespaces. For any given name, the last available results replace 32052bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian // all earlier ones. For this reason, we walk in reverse. 32062bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian DeclContextInfos &Infos = DeclContextOffsets[DC]; 32072bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian for (DeclContextInfos::reverse_iterator I = Infos.rbegin(), E = Infos.rend(); 32082bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian I != E; ++I) { 32092bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian if (!I->NameLookupTableData) 32102bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian continue; 32112bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian 32122bb5ddaff86ee73d2cea7ec1835978afc88a83f0Fariborz Jahanian ASTDeclContextNameLookupTable *LookupTable = 32134ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad (ASTDeclContextNameLookupTable*)I->NameLookupTableData; 3214bd4c1ada2e8668f43a865dc2c662085cf61940c4Anders Carlsson ASTDeclContextNameLookupTable::iterator Pos = LookupTable->find(Name); 321544b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor if (Pos == LookupTable->end()) 3216465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara continue; 321779cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson 32185cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall ASTDeclContextNameLookupTrait::data_type Data = *Pos; 32191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (; Data.first != Data.second; ++Data.first) 3220bd4c1ada2e8668f43a865dc2c662085cf61940c4Anders Carlsson Decls.push_back(cast<NamedDecl>(GetDecl(*Data.first))); 3221bd4c1ada2e8668f43a865dc2c662085cf61940c4Anders Carlsson break; 3222de2e22d33afec98324a66a358dfe0951b3c7259aSteve Naroff } 3223bd4c1ada2e8668f43a865dc2c662085cf61940c4Anders Carlsson 3224bd4c1ada2e8668f43a865dc2c662085cf61940c4Anders Carlsson ++NumVisibleDeclContextsRead; 3225bd4c1ada2e8668f43a865dc2c662085cf61940c4Anders Carlsson 3226bd4c1ada2e8668f43a865dc2c662085cf61940c4Anders Carlsson SetExternalVisibleDeclsForName(DC, Name, Decls); 32271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return const_cast<DeclContext*>(DC)->lookup(Name); 322844b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor} 32291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 32301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid ASTReader::MaterializeVisibleDecls(const DeclContext *DC) { 32311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump assert(DC->hasExternalVisibleStorage() && 3232a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall "DeclContext has no visible decls in storage"); 32331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 32344afa39deaa245592977136d367251ee2c173dd8dDouglas Gregor llvm::SmallVector<NamedDecl *, 64> Decls; 32352888b65aae768f54062505330df7be230a0510c7John McCall // There might be visible decls in multiple parts of the chain, for the TU 323617945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis // and namespaces. 323744b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor DeclContextInfos &Infos = DeclContextOffsets[DC]; 32381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end(); 3239838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor I != E; ++I) { 3240bd4c1ada2e8668f43a865dc2c662085cf61940c4Anders Carlsson if (!I->NameLookupTableData) 32411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump continue; 3242bd4c1ada2e8668f43a865dc2c662085cf61940c4Anders Carlsson 3243bd4c1ada2e8668f43a865dc2c662085cf61940c4Anders Carlsson ASTDeclContextNameLookupTable *LookupTable = 3244bd4c1ada2e8668f43a865dc2c662085cf61940c4Anders Carlsson (ASTDeclContextNameLookupTable*)I->NameLookupTableData; 32454ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad for (ASTDeclContextNameLookupTable::item_iterator 3246adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump ItemI = LookupTable->item_begin(), 3247adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump ItemEnd = LookupTable->item_end() ; ItemI != ItemEnd; ++ItemI) { 3248adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump ASTDeclContextNameLookupTable::item_iterator::value_type Val 3249adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump = *ItemI; 3250adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump ASTDeclContextNameLookupTrait::data_type Data = Val.second; 3251465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara Decls.clear(); 325279cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson for (; Data.first != Data.second; ++Data.first) 32535cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall Decls.push_back(cast<NamedDecl>(GetDecl(*Data.first))); 3254adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump MaterializeVisibleDeclsForName(DC, Val.first, Decls); 3255adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump } 3256adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump } 3257adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump} 3258adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3259adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stumpvoid ASTReader::PassInterestingDeclsToConsumer() { 3260adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump assert(Consumer); 3261adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump while (!InterestingDecls.empty()) { 3262083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump DeclGroupRef DG(InterestingDecls.front()); 3263adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump InterestingDecls.pop_front(); 3264adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump Consumer->HandleInterestingDecl(DG); 3265adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump } 3266adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump} 3267adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3268adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stumpvoid ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 3269adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump this->Consumer = Consumer; 3270a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall 3271adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump if (!Consumer) 3272adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump return; 32732888b65aae768f54062505330df7be230a0510c7John McCall 3274adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 3275adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump // Force deserialization of this decl, which will cause it to be queued for 3276adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump // passing to the consumer. 3277838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor GetDecl(ExternalDefinitions[I]); 3278adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump } 3279adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3280adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump PassInterestingDeclsToConsumer(); 3281adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump} 3282adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3283adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stumpvoid ASTReader::PrintStats() { 3284adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump std::fprintf(stderr, "*** AST File Statistics:\n"); 3285adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3286adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump unsigned NumTypesLoaded 3287adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 3288adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump QualType()); 3289adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump unsigned NumDeclsLoaded 32904ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 3291083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump (Decl *)0); 3292083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump unsigned NumIdentifiersLoaded 3293083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 3294083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump IdentifiersLoaded.end(), 3295083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump (IdentifierInfo *)0); 3296465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara unsigned NumSelectorsLoaded 329779cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 32985cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall SelectorsLoaded.end(), 3299083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump Selector()); 3300083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump 3301083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump std::fprintf(stderr, " %u stat cache hits\n", NumStatHits); 3302083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses); 3303083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump if (TotalNumSLocEntries) 3304083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 3305083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump NumSLocEntriesRead, TotalNumSLocEntries, 3306083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 3307083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump if (!TypesLoaded.empty()) 3308083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump std::fprintf(stderr, " %u/%u types read (%f%%)\n", 3309083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump NumTypesLoaded, (unsigned)TypesLoaded.size(), 3310083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 3311083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump if (!DeclsLoaded.empty()) 3312083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 3313083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 3314083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 3315083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump if (!IdentifiersLoaded.empty()) 3316083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 3317083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 3318083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 3319a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall if (!SelectorsLoaded.empty()) 3320083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 3321083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 33222888b65aae768f54062505330df7be230a0510c7John McCall ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 3323083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump if (TotalNumStatements) 3324083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 3325083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump NumStatementsRead, TotalNumStatements, 3326838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor ((float)NumStatementsRead/TotalNumStatements * 100)); 3327083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump if (TotalNumMacros) 3328083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 3329083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump NumMacrosRead, TotalNumMacros, 3330083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump ((float)NumMacrosRead/TotalNumMacros * 100)); 3331083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump if (TotalLexicalDeclContexts) 3332083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 3333083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 3334083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 3335083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump * 100)); 3336083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump if (TotalVisibleDeclContexts) 3337083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 3338083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 33394ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 3340af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump * 100)); 3341af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump if (TotalNumMethodPoolEntries) { 3342af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 3343af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 3344af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 3345af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump * 100)); 3346e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses); 3347e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian } 3348e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian std::fprintf(stderr, "\n"); 3349e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian} 3350e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian 3351e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanianvoid ASTReader::InitializeSema(Sema &S) { 3352e38be617437ccdcc180c5a49e447cbcd07539292Fariborz Jahanian SemaObj = &S; 3353af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump S.ExternalSource = this; 3354af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3355af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // Makes sure any declarations that were deserialized "too early" 33564ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad // still get added to the identifier's declaration chains. 33574ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad if (SemaObj->TUScope) { 3358af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 3359ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump SemaObj->TUScope->AddDecl(PreloadedDecls[I]); 3360af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump SemaObj->IdResolver.AddDecl(PreloadedDecls[I]); 3361ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump } 3362ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump } 3363a7e6845660f91ec611427e1db842780e1ec12bdbEli Friedman PreloadedDecls.clear(); 3364a7e6845660f91ec611427e1db842780e1ec12bdbEli Friedman 3365af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // If there were any tentative definitions, deserialize them and add 3366ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // them to Sema's list of tentative definitions. 3367ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 3368af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump VarDecl *Var = cast<VarDecl>(GetDecl(TentativeDefinitions[I])); 3369af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump SemaObj->TentativeDefinitions.push_back(Var); 3370af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump } 3371f5942a44880be26878592eb052b737579349411eBenjamin Kramer 3372f5942a44880be26878592eb052b737579349411eBenjamin Kramer // If there were any unused file scoped decls, deserialize them and add to 3373f5942a44880be26878592eb052b737579349411eBenjamin Kramer // Sema's list of unused file scoped decls. 3374af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 3375465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara DeclaratorDecl *D = cast<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 337679cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson SemaObj->UnusedFileScopedDecls.push_back(D); 3377af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump } 3378af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3379af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // If there were any weak undeclared identifiers, deserialize them and add to 3380af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // Sema's list of weak undeclared identifiers. 3381af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump if (!WeakUndeclaredIdentifiers.empty()) { 3382af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump unsigned Idx = 0; 3383af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump for (unsigned I = 0, N = WeakUndeclaredIdentifiers[Idx++]; I != N; ++I) { 3384af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump IdentifierInfo *WeakId = GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx); 3385af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump IdentifierInfo *AliasId=GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx); 3386af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump SourceLocation Loc = ReadSourceLocation(WeakUndeclaredIdentifiers, Idx); 3387af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump bool Used = WeakUndeclaredIdentifiers[Idx++]; 3388af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump Sema::WeakInfo WI(AliasId, Loc); 3389af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump WI.setUsed(Used); 33904087f27e5416c799bcb6be072f905be752acb61cDaniel Dunbar SemaObj->WeakUndeclaredIdentifiers.insert(std::make_pair(WeakId, WI)); 3391af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump } 3392af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump } 3393af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3394af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // If there were any locally-scoped external declarations, 3395af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // deserialize them and add them to Sema's table of locally-scoped 3396af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // external declarations. 3397af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) { 3398af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump NamedDecl *D = cast<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I])); 3399af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump SemaObj->LocallyScopedExternalDecls[D->getDeclName()] = D; 3400af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump } 3401af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3402af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // If there were any ext_vector type declarations, deserialize them 3403af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // and add them to Sema's vector of such declarations. 3404af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) 3405a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall SemaObj->ExtVectorDecls.push_back( 3406af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump cast<TypedefDecl>(GetDecl(ExtVectorDecls[I]))); 34072888b65aae768f54062505330df7be230a0510c7John McCall 3408af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // FIXME: Do VTable uses and dynamic classes deserialize too much ? 3409af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // Can we cut them down before writing them ? 3410af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump 3411838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregor // If there were any VTable uses, deserialize the information and add it 3412af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump // to Sema's vector and map of VTable uses. 3413af7b44d847d3e44c43346d508b2e55a6254b6e9dMike Stump if (!VTableUses.empty()) { 3414ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump unsigned Idx = 0; 3415ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump for (unsigned I = 0, N = VTableUses[Idx++]; I != N; ++I) { 3416ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump CXXRecordDecl *Class = cast<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 3417ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump SourceLocation Loc = ReadSourceLocation(VTableUses, Idx); 3418083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump bool DefinitionRequired = VTableUses[Idx++]; 34194ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad SemaObj->VTableUses.push_back(std::make_pair(Class, Loc)); 3420ea1471e0e967548c596a71469702f8846dbaf3c0John McCall SemaObj->VTablesUsed[Class] = DefinitionRequired; 3421adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump } 3422f5942a44880be26878592eb052b737579349411eBenjamin Kramer } 3423f5942a44880be26878592eb052b737579349411eBenjamin Kramer 3424f5942a44880be26878592eb052b737579349411eBenjamin Kramer // If there were any dynamic classes declarations, deserialize them 3425adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump // and add them to Sema's vector of such declarations. 3426465d41b92b2c862f3062c412a0538db65c6a2661Abramo Bagnara for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) 342779cbc7dd2aacd85a28f469b5dc73c4ea296e7072Anders Carlsson SemaObj->DynamicClasses.push_back( 34285cfa011e61e14e6f2e1659047d809706c0e4c6a3John McCall cast<CXXRecordDecl>(GetDecl(DynamicClasses[I]))); 3429adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3430adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump // If there were any pending implicit instantiations, deserialize them 3431adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump // and add them to Sema's queue of such instantiations. 3432adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump assert(PendingImplicitInstantiations.size() % 2 == 0 && 3433adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump "Expected pairs of entries"); 3434083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump for (unsigned Idx = 0, N = PendingImplicitInstantiations.size(); Idx < N;) { 3435083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump ValueDecl *D=cast<ValueDecl>(GetDecl(PendingImplicitInstantiations[Idx++])); 3436083c25eea14bb4cc4ecc3ec763c60e2e609e22bdMike Stump SourceLocation Loc = ReadSourceLocation(PendingImplicitInstantiations, Idx); 3437adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump SemaObj->PendingImplicitInstantiations.push_back(std::make_pair(D, Loc)); 3438adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump } 3439adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3440adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump // Load the offsets of the declarations that Sema references. 3441adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump // They will be lazily deserialized when needed. 3442adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump if (!SemaDeclRefs.empty()) { 3443adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!"); 3444adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump SemaObj->StdNamespace = SemaDeclRefs[0]; 3445adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump SemaObj->StdBadAlloc = SemaDeclRefs[1]; 3446adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump } 3447adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3448ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // If there are @selector references added them to its pool. This is for 3449adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump // implementation of -Wselector. 3450a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall if (!ReferencedSelectorsData.empty()) { 3451ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump unsigned int DataSize = ReferencedSelectorsData.size()-1; 34522888b65aae768f54062505330df7be230a0510c7John McCall unsigned I = 0; 3453ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump while (I < DataSize) { 3454ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]); 3455ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump SourceLocation SelLoc = 3456ea1471e0e967548c596a71469702f8846dbaf3c0John McCall SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]); 3457ea1471e0e967548c596a71469702f8846dbaf3c0John McCall SemaObj->ReferencedSelectors.insert(std::make_pair(Sel, SelLoc)); 3458ea1471e0e967548c596a71469702f8846dbaf3c0John McCall } 3459ea1471e0e967548c596a71469702f8846dbaf3c0John McCall } 3460ea1471e0e967548c596a71469702f8846dbaf3c0John McCall} 3461ea1471e0e967548c596a71469702f8846dbaf3c0John McCall 3462ea1471e0e967548c596a71469702f8846dbaf3c0John McCallIdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 3463ea1471e0e967548c596a71469702f8846dbaf3c0John McCall // Try to find this name within our on-disk hash tables. We start with the 3464ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // most recent one, since that one contains the most up-to-date info. 3465ea1471e0e967548c596a71469702f8846dbaf3c0John McCall for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3466ea1471e0e967548c596a71469702f8846dbaf3c0John McCall ASTIdentifierLookupTable *IdTable 34674087f27e5416c799bcb6be072f905be752acb61cDaniel Dunbar = (ASTIdentifierLookupTable *)Chain[I]->IdentifierLookupTable; 3468ea1471e0e967548c596a71469702f8846dbaf3c0John McCall if (!IdTable) 3469ea1471e0e967548c596a71469702f8846dbaf3c0John McCall continue; 3470ea1471e0e967548c596a71469702f8846dbaf3c0John McCall std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart); 3471ea1471e0e967548c596a71469702f8846dbaf3c0John McCall ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key); 3472ea1471e0e967548c596a71469702f8846dbaf3c0John McCall if (Pos == IdTable->end()) 3473ea1471e0e967548c596a71469702f8846dbaf3c0John McCall continue; 3474ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump 3475ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // Dereferencing the iterator has the effect of building the 3476ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // IdentifierInfo node and populating it with the various 3477ea1471e0e967548c596a71469702f8846dbaf3c0John McCall // declarations it needs. 3478ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump return *Pos; 34792888b65aae768f54062505330df7be230a0510c7John McCall } 3480adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump return 0; 3481adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump} 3482adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump 3483838db383b69b9fb55f55c8e9546477df198a4faaDouglas Gregorstd::pair<ObjCMethodList, ObjCMethodList> 3484ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike StumpASTReader::ReadMethodPool(Selector Sel) { 3485ea26cb522e88fc86b0d1cae61dcefcfe4cc20231Mike Stump // Find this selector in a hash table. We want to find the most recent entry. 3486adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3487adaaad3715c9c26cdcfdfe3401a13d7b4423ddcfMike Stump PerFileData &F = *Chain[I]; 3488319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor if (!F.SelectorLookupTable) 34896217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek continue; 3490319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor 3491319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor ASTSelectorLookupTable *PoolTable 3492319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor = (ASTSelectorLookupTable*)F.SelectorLookupTable; 3493319ac896a0fef7365d5589b8021db7e41207fe42Douglas Gregor ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel); 3494e8c49533521c40643653f943d47229e62d277f88Anders Carlsson if (Pos != PoolTable->end()) { 3495e8c49533521c40643653f943d47229e62d277f88Anders Carlsson ++NumSelectorsRead; 34962d99833e8c956775f2183601cd120b65b569c867Chris Lattner // FIXME: Not quite happy with the statistics here. We probably should 3497e8c49533521c40643653f943d47229e62d277f88Anders Carlsson // disable this tracking when called via LoadSelector. 3498bb49c3ee5d270485f4b273691fd14bc97403fa5dChris Lattner // Also, should entries without methods count as misses? 3499bb49c3ee5d270485f4b273691fd14bc97403fa5dChris Lattner ++NumMethodPoolEntriesRead; 35001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump ASTSelectorLookupTrait::data_type Data = *Pos; 350185f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson if (DeserializationListener) 350285f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson DeserializationListener->SelectorRead(Data.ID, Sel); 350385f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson return std::make_pair(Data.Instance, Data.Factory); 3504a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek } 350533e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian } 35064ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad 3507199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck ++NumMethodPoolMisses; 35081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return std::pair<ObjCMethodList, ObjCMethodList>(); 350933e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian} 35102ade35e2cfd554e49d35a52047cea98a82787af9Douglas Gregor 3511199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyckvoid ASTReader::LoadSelector(Selector Sel) { 351233e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian // It would be complicated to avoid reading the methods anyway. So don't. 351333e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian ReadMethodPool(Sel); 3514199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck} 3515aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck 3516199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyckvoid ASTReader::SetIdentifierInfo(unsigned ID, IdentifierInfo *II) { 3517199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck assert(ID && "Non-zero identifier ID required"); 3518199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 3519199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck IdentifiersLoaded[ID - 1] = II; 3520199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck if (DeserializationListener) 352133e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian DeserializationListener->IdentifierRead(ID, II); 352233e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian} 35236f46c2653c1545cc3fef0c0df996d18160160ce8Fariborz Jahanian 35245e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall/// \brief Set the globally-visible declarations associated with the given 35255e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall/// identifier. 35264ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad/// 35275e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall/// If the AST reader is currently in a state where the given declaration IDs 35285e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall/// cannot safely be resolved, they are queued until it is safe to resolve 35295e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall/// them. 35305e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall/// 3531c71a4915ca216847599d03cab4ed1c5086b0eb43John McCall/// \param II an IdentifierInfo that refers to one or more globally-visible 35325e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall/// declarations. 35335e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall/// 35345e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall/// \param DeclIDs the set of declaration IDs with the name @p II that are 35355e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall/// visible at global scope. 3536199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck/// 3537199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck/// \param Nonrecursive should be true to indicate that the caller knows that 35386f46c2653c1545cc3fef0c0df996d18160160ce8Fariborz Jahanian/// this call is non-recursive, and therefore the globally-visible declarations 35395e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall/// will not be placed onto the pending queue. 35405e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnallvoid 3541aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen DyckASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 3542199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck const llvm::SmallVectorImpl<uint32_t> &DeclIDs, 35435e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall bool Nonrecursive) { 35445e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall if (NumCurrentElementsDeserializing && !Nonrecursive) { 35455e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall PendingIdentifierInfos.push_back(PendingIdentifierInfo()); 3546199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck PendingIdentifierInfo &PII = PendingIdentifierInfos.back(); 35475e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall PII.II = II; 35485e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) 35495e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall PII.DeclIDs.push_back(DeclIDs[I]); 35505e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall return; 35515e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall } 35525e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall 35535e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 35545e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 35555e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall if (SemaObj) { 35565e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall if (SemaObj->TUScope) { 35575e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Introduce this declaration into the translation-unit scope 35585e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // and add it to the declaration chain for this identifier, so 35595e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // that (unqualified) name lookup will find it. 35605389f48b24937ad7b4093307128b3cbf25235654David Chisnall SemaObj->TUScope->AddDecl(D); 35615389f48b24937ad7b4093307128b3cbf25235654David Chisnall SemaObj->IdResolver.AddDeclToIdentifierChain(II, D); 35625389f48b24937ad7b4093307128b3cbf25235654David Chisnall } 35635389f48b24937ad7b4093307128b3cbf25235654David Chisnall } else { 35645389f48b24937ad7b4093307128b3cbf25235654David Chisnall // Queue this declaration so that it will be added to the 35655389f48b24937ad7b4093307128b3cbf25235654David Chisnall // translation unit scope and identifier's declaration chain 35665389f48b24937ad7b4093307128b3cbf25235654David Chisnall // once a Sema object is known. 35675389f48b24937ad7b4093307128b3cbf25235654David Chisnall PreloadedDecls.push_back(D); 35685389f48b24937ad7b4093307128b3cbf25235654David Chisnall } 35695389f48b24937ad7b4093307128b3cbf25235654David Chisnall } 35705389f48b24937ad7b4093307128b3cbf25235654David Chisnall} 35715389f48b24937ad7b4093307128b3cbf25235654David Chisnall 35725389f48b24937ad7b4093307128b3cbf25235654David ChisnallIdentifierInfo *ASTReader::DecodeIdentifierInfo(unsigned ID) { 35735389f48b24937ad7b4093307128b3cbf25235654David Chisnall if (ID == 0) 35745389f48b24937ad7b4093307128b3cbf25235654David Chisnall return 0; 35755389f48b24937ad7b4093307128b3cbf25235654David Chisnall 35765389f48b24937ad7b4093307128b3cbf25235654David Chisnall if (IdentifiersLoaded.empty()) { 35775389f48b24937ad7b4093307128b3cbf25235654David Chisnall Error("no identifier table in AST file"); 35785389f48b24937ad7b4093307128b3cbf25235654David Chisnall return 0; 35795389f48b24937ad7b4093307128b3cbf25235654David Chisnall } 35805389f48b24937ad7b4093307128b3cbf25235654David Chisnall 35815389f48b24937ad7b4093307128b3cbf25235654David Chisnall assert(PP && "Forgot to set Preprocessor ?"); 35825389f48b24937ad7b4093307128b3cbf25235654David Chisnall ID -= 1; 35835389f48b24937ad7b4093307128b3cbf25235654David Chisnall if (!IdentifiersLoaded[ID]) { 35845389f48b24937ad7b4093307128b3cbf25235654David Chisnall unsigned Index = ID; 35855389f48b24937ad7b4093307128b3cbf25235654David Chisnall const char *Str = 0; 35865389f48b24937ad7b4093307128b3cbf25235654David Chisnall for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 35875389f48b24937ad7b4093307128b3cbf25235654David Chisnall PerFileData *F = Chain[N - I - 1]; 35885389f48b24937ad7b4093307128b3cbf25235654David Chisnall if (Index < F->LocalNumIdentifiers) { 35895389f48b24937ad7b4093307128b3cbf25235654David Chisnall uint32_t Offset = F->IdentifierOffsets[Index]; 35905389f48b24937ad7b4093307128b3cbf25235654David Chisnall Str = F->IdentifierTableData + Offset; 35915389f48b24937ad7b4093307128b3cbf25235654David Chisnall break; 35925389f48b24937ad7b4093307128b3cbf25235654David Chisnall } 35935389f48b24937ad7b4093307128b3cbf25235654David Chisnall Index -= F->LocalNumIdentifiers; 35945389f48b24937ad7b4093307128b3cbf25235654David Chisnall } 35955389f48b24937ad7b4093307128b3cbf25235654David Chisnall assert(Str && "Broken Chain"); 35965e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall 35975e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // All of the strings in the AST file are preceded by a 16-bit length. 35985e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // Extract that 16-bit length to avoid having to execute strlen(). 35995e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 36005e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // unsigned integers. This is important to avoid integer overflow when 36015e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall // we cast them to 'unsigned'. 3602199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 3603aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck unsigned StrLen = (((unsigned) StrLenPtr[0]) 36045e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall | (((unsigned) StrLenPtr[1]) << 8)) - 1; 36055e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall IdentifiersLoaded[ID] 36065e530af5d51572a0ed5dbe50da54bd333840c63dDavid Chisnall = &PP->getIdentifierTable().get(Str, StrLen); 3607a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek if (DeserializationListener) 360833e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 36091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 36104ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad 3611c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar return IdentifiersLoaded[ID]; 3612ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian} 3613a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek 361433e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanianvoid ASTReader::ReadSLocEntry(unsigned ID) { 36150d504c1da852e58ff802545c823ecff3b6c654b8Daniel Dunbar ReadSLocEntryRecord(ID); 361633e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian} 361733e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian 361833e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz JahanianSelector ASTReader::DecodeSelector(unsigned ID) { 361933e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian if (ID == 0) 3620199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck return Selector(); 362133e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian 362233e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian if (ID > SelectorsLoaded.size()) { 3623199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck Error("selector ID out of range in AST file"); 362489951a86b594513c2a013532ed45d197413b1087Chris Lattner return Selector(); 36257732cc9c0fdc97a2f8cce4e5933d8103213d1aefFariborz Jahanian } 362689951a86b594513c2a013532ed45d197413b1087Chris Lattner 3627aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 3628199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck // Load this selector from the selector table. 3629199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck unsigned Idx = ID - 1; 363033e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 363133e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian PerFileData &F = *Chain[N - I - 1]; 3632199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck if (Idx < F.LocalNumSelectors) { 363333e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian ASTSelectorLookupTrait Trait(*this); 3634199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck SelectorsLoaded[ID - 1] = 36351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Trait.ReadKey(F.SelectorLookupTableData + F.SelectorOffsets[Idx], 0); 363633e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian if (DeserializationListener) 363733e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 363889951a86b594513c2a013532ed45d197413b1087Chris Lattner break; 36397732cc9c0fdc97a2f8cce4e5933d8103213d1aefFariborz Jahanian } 364089951a86b594513c2a013532ed45d197413b1087Chris Lattner Idx -= F.LocalNumSelectors; 36411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 36424306d3cb9116605728252e2738df24b9f6ab53c3Fariborz Jahanian } 3643ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff 3644ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff return SelectorsLoaded[ID - 1]; 3645ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff} 3646bb3fde337fb712c0e6da8790d431621be4793048Steve Naroff 3647ab76d45e023fc5ae966968344e180cd09fdcc746Steve NaroffSelector ASTReader::GetExternalSelector(uint32_t ID) { 3648ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff return DecodeSelector(ID); 3649ab76d45e023fc5ae966968344e180cd09fdcc746Steve Naroff} 3650ecb01e666665efabd2aa76a76f6080e2a78965faFariborz Jahanian 365133e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanianuint32_t ASTReader::GetNumExternalSelectors() { 36524306d3cb9116605728252e2738df24b9f6ab53c3Fariborz Jahanian // ID 0 (the null selector) is considered an external selector. 36530d504c1da852e58ff802545c823ecff3b6c654b8Daniel Dunbar return getTotalNumSelectors() + 1; 3654199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck} 3655aa8741a1db98eef05f09b1200dba94aa5dc3bc3dKen Dyck 365633e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz JahanianDeclarationName 365733e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz JahanianASTReader::ReadDeclarationName(const RecordData &Record, unsigned &Idx) { 365833e1d64ab5cd5d27f8530ccd056191fe2c9f3f2eFariborz Jahanian DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 3659c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar switch (Kind) { 366083bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian case DeclarationName::Identifier: 3661c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar return DeclarationName(GetIdentifierInfo(Record, Idx)); 3662c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 36631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case DeclarationName::ObjCZeroArgSelector: 36641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case DeclarationName::ObjCOneArgSelector: 36651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case DeclarationName::ObjCMultiArgSelector: 36661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return DeclarationName(GetSelector(Record, Idx)); 36671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 366883bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian case DeclarationName::CXXConstructorName: 366983bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian return Context->DeclarationNames.getCXXConstructorName( 367083bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian Context->getCanonicalType(GetType(Record[Idx++]))); 367183bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian 367283bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian case DeclarationName::CXXDestructorName: 367383bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian return Context->DeclarationNames.getCXXDestructorName( 367483bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian Context->getCanonicalType(GetType(Record[Idx++]))); 367583bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian 367683bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian case DeclarationName::CXXConversionFunctionName: 367783bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian return Context->DeclarationNames.getCXXConversionFunctionName( 367883bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian Context->getCanonicalType(GetType(Record[Idx++]))); 367983bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian 368083bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian case DeclarationName::CXXOperatorName: 368183bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian return Context->DeclarationNames.getCXXOperatorName( 368283bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian (OverloadedOperatorKind)Record[Idx++]); 368383bccb85ff4b9981c4250c45494b439df8cbf983Fariborz Jahanian 36841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case DeclarationName::CXXLiteralOperatorName: 3685c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar return Context->DeclarationNames.getCXXLiteralOperatorName( 36864ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad GetIdentifierInfo(Record, Idx)); 3687c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 3688c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case DeclarationName::CXXUsingDirective: 3689c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar return DeclarationName::getUsingDirectiveName(); 3690c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 3691c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 3692c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar // Required to silence GCC warning 36931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return DeclarationName(); 3694c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar} 3695c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 369617945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios KyrtzidisTemplateName 3697653f1b1bf293a9bd96fd4dd6372e779cc7af1597Douglas GregorASTReader::ReadTemplateName(const RecordData &Record, unsigned &Idx) { 3698c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 3699c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar switch (Kind) { 3700c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case TemplateName::Template: 3701c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar return TemplateName(cast_or_null<TemplateDecl>(GetDecl(Record[Idx++]))); 3702c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 3703c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case TemplateName::OverloadedTemplate: { 3704c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar unsigned size = Record[Idx++]; 3705c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar UnresolvedSet<8> Decls; 3706c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar while (size--) 3707c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar Decls.addDecl(cast<NamedDecl>(GetDecl(Record[Idx++]))); 370861710854be2b098428aff5316e64bd34b30fbcb7Chris Lattner 3709c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar return Context->getOverloadedTemplateName(Decls.begin(), Decls.end()); 371017945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis } 3711653f1b1bf293a9bd96fd4dd6372e779cc7af1597Douglas Gregor 3712c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case TemplateName::QualifiedTemplate: { 3713c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 3714c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar bool hasTemplKeyword = Record[Idx++]; 3715c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar TemplateDecl *Template = cast<TemplateDecl>(GetDecl(Record[Idx++])); 3716c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 3717c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 3718c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 3719c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case TemplateName::DependentTemplate: { 37201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 3721c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar if (Record[Idx++]) // isIdentifier 3722c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar return Context->getDependentTemplateName(NNS, 3723c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar GetIdentifierInfo(Record, Idx)); 3724c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar return Context->getDependentTemplateName(NNS, 3725c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar (OverloadedOperatorKind)Record[Idx++]); 3726c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 3727c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 3728090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian 3729090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian assert(0 && "Unhandled template name kind!"); 37301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return TemplateName(); 3731090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian} 3732090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian 3733c56f34a1c1779de15330bdb3eec39b3418802d47Daniel DunbarTemplateArgument 3734c56f34a1c1779de15330bdb3eec39b3418802d47Daniel DunbarASTReader::ReadTemplateArgument(llvm::BitstreamCursor &DeclsCursor, 3735c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar const RecordData &Record, unsigned &Idx) { 3736c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar switch ((TemplateArgument::ArgKind)Record[Idx++]) { 3737c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case TemplateArgument::Null: 3738c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar return TemplateArgument(); 3739c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case TemplateArgument::Type: 37401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return TemplateArgument(GetType(Record[Idx++])); 3741c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case TemplateArgument::Declaration: 3742c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar return TemplateArgument(GetDecl(Record[Idx++])); 3743c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case TemplateArgument::Integral: { 3744c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar llvm::APSInt Value = ReadAPSInt(Record, Idx); 3745c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar QualType T = GetType(Record[Idx++]); 3746c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar return TemplateArgument(Value, T); 3747c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 3748c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case TemplateArgument::Template: 3749090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian return TemplateArgument(ReadTemplateName(Record, Idx)); 3750090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian case TemplateArgument::Expression: 37511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return TemplateArgument(ReadExpr(DeclsCursor)); 3752c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar case TemplateArgument::Pack: { 3753c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar unsigned NumArgs = Record[Idx++]; 3754077bf5e2f48acfa9e7d69429b6e4ba86ea14896dChris Lattner llvm::SmallVector<TemplateArgument, 8> Args; 3755c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar Args.reserve(NumArgs); 3756c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar while (NumArgs--) 3757c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar Args.push_back(ReadTemplateArgument(DeclsCursor, Record, Idx)); 3758c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar TemplateArgument TemplArg; 3759077bf5e2f48acfa9e7d69429b6e4ba86ea14896dChris Lattner TemplArg.setArgumentPack(Args.data(), Args.size(), /*CopyArgs=*/true); 3760c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar return TemplArg; 3761c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 3762c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar } 3763c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 3764c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar assert(0 && "Unhandled template argument kind!"); 376539f34e97d6a468f0a7dfa5664c61217cffc65b74Chris Lattner return TemplateArgument(); 3766c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar} 3767c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar 3768c56f34a1c1779de15330bdb3eec39b3418802d47Daniel DunbarTemplateParameterList * 3769c56f34a1c1779de15330bdb3eec39b3418802d47Daniel DunbarASTReader::ReadTemplateParameterList(const RecordData &Record, unsigned &Idx) { 3770c56f34a1c1779de15330bdb3eec39b3418802d47Daniel Dunbar SourceLocation TemplateLoc = ReadSourceLocation(Record, Idx); 3771a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian SourceLocation LAngleLoc = ReadSourceLocation(Record, Idx); 37721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SourceLocation RAngleLoc = ReadSourceLocation(Record, Idx); 37731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3774a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian unsigned NumParams = Record[Idx++]; 3775a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian llvm::SmallVector<NamedDecl *, 16> Params; 3776a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian Params.reserve(NumParams); 37778e1fab243ab8023b7ee3899745386b3b3a4258f8Mike Stump while (NumParams--) 3778183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall Params.push_back(cast<NamedDecl>(GetDecl(Record[Idx++]))); 37794ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad 3780a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian TemplateParameterList* TemplateParams = 37811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc, 37824ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Params.data(), Params.size(), RAngleLoc); 3783a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian return TemplateParams; 3784a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian} 3785a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian 3786a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanianvoid 3787a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz JahanianASTReader:: 37887d6b46d9a9d75dea8ef9f6973dd50633c1f37963Fariborz JahanianReadTemplateArgumentList(llvm::SmallVector<TemplateArgument, 8> &TemplArgs, 37894ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad llvm::BitstreamCursor &DeclsCursor, 379082a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar const RecordData &Record, unsigned &Idx) { 379182a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar unsigned NumTemplateArgs = Record[Idx++]; 379282a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar TemplArgs.reserve(NumTemplateArgs); 379382a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar while (NumTemplateArgs--) 37941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TemplArgs.push_back(ReadTemplateArgument(DeclsCursor, Record, Idx)); 37955b8c7d9fb620ba3a71e996d61e7b9bdf763b5c09Fariborz Jahanian} 379682a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar 379782a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar/// \brief Read a UnresolvedSet structure. 379864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnallvoid ASTReader::ReadUnresolvedSet(UnresolvedSetImpl &Set, 379964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall const RecordData &Record, unsigned &Idx) { 380064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall unsigned NumDecls = Record[Idx++]; 380164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall while (NumDecls--) { 380264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall NamedDecl *D = cast<NamedDecl>(GetDecl(Record[Idx++])); 380364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 380464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall Set.addDecl(D, AS); 380564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall } 380664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall} 380764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall 38084ba2a17694148e16eaa8d3917f657ffcd3667be4Jay FoadCXXBaseSpecifier 380964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David ChisnallASTReader::ReadCXXBaseSpecifier(llvm::BitstreamCursor &DeclsCursor, 381064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall const RecordData &Record, unsigned &Idx) { 381164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall bool isVirtual = static_cast<bool>(Record[Idx++]); 381264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 381364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 38143f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner TypeSourceInfo *TInfo = GetTypeSourceInfo(DeclsCursor, Record, Idx); 38153f59c975aa5d047f7edd1b900b5e885c38af0ef7Chris Lattner SourceRange Range = ReadSourceRange(Record, Idx); 381664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall return CXXBaseSpecifier(Range, isVirtual, isBaseOfClass, AS, TInfo); 381764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall} 38184ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad 381964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnallstd::pair<CXXBaseOrMemberInitializer **, unsigned> 382064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David ChisnallASTReader::ReadCXXBaseOrMemberInitializers(llvm::BitstreamCursor &Cursor, 382164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall const RecordData &Record, 382264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall unsigned &Idx) { 38233a0be84b2aed8563150cdbd976a98838afa261ebDaniel Dunbar CXXBaseOrMemberInitializer **BaseOrMemberInitializers = 0; 382464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall unsigned NumInitializers = Record[Idx++]; 382564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall if (NumInitializers) { 382664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall ASTContext &C = *getContext(); 38274ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad 382864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall BaseOrMemberInitializers 38298b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian = new (C) CXXBaseOrMemberInitializer*[NumInitializers]; 38308b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian for (unsigned i=0; i != NumInitializers; ++i) { 38318b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian TypeSourceInfo *BaseClassInfo = 0; 383264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall bool IsBaseVirtual = false; 383364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall FieldDecl *Member = 0; 383464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall 383564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall bool IsBaseInitializer = Record[Idx++]; 383664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall if (IsBaseInitializer) { 383764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall BaseClassInfo = GetTypeSourceInfo(Cursor, Record, Idx); 383864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall IsBaseVirtual = Record[Idx++]; 383964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall } else { 384064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall Member = cast<FieldDecl>(GetDecl(Record[Idx++])); 384164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall } 384264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall SourceLocation MemberLoc = ReadSourceLocation(Record, Idx); 384364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall Expr *Init = ReadExpr(Cursor); 384464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall FieldDecl *AnonUnionMember 384564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall = cast_or_null<FieldDecl>(GetDecl(Record[Idx++])); 384664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall SourceLocation LParenLoc = ReadSourceLocation(Record, Idx); 384764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall SourceLocation RParenLoc = ReadSourceLocation(Record, Idx); 384864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall bool IsWritten = Record[Idx++]; 384964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall unsigned SourceOrderOrNumArrayIndices; 385064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall llvm::SmallVector<VarDecl *, 8> Indices; 385164fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall if (IsWritten) { 385264fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall SourceOrderOrNumArrayIndices = Record[Idx++]; 385364fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall } else { 385464fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall SourceOrderOrNumArrayIndices = Record[Idx++]; 385564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall Indices.reserve(SourceOrderOrNumArrayIndices); 385664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 385764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall Indices.push_back(cast<VarDecl>(GetDecl(Record[Idx++]))); 385864fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall } 385964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall 386064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall CXXBaseOrMemberInitializer *BOMInit; 3861c7ff82c2040f45eaad2eddea0e4461dddc972cd1David Chisnall if (IsBaseInitializer) { 3862c7ff82c2040f45eaad2eddea0e4461dddc972cd1David Chisnall BOMInit = new (C) CXXBaseOrMemberInitializer(C, BaseClassInfo, 3863c7ff82c2040f45eaad2eddea0e4461dddc972cd1David Chisnall IsBaseVirtual, LParenLoc, 38644ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad Init, RParenLoc); 386564fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall } else if (IsWritten) { 386664fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall BOMInit = new (C) CXXBaseOrMemberInitializer(C, Member, MemberLoc, 38678b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian LParenLoc, Init, RParenLoc); 38688b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian } else { 38698b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian BOMInit = CXXBaseOrMemberInitializer::Create(C, Member, MemberLoc, 387001eb9b9683535d8a65c704ad2c545903409e2d36Daniel Dunbar LParenLoc, Init, RParenLoc, 387182a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar Indices.data(), 387282a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar Indices.size()); 387382a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar } 3874153bfe5795e2c1a5a738e73d3784964e082237fcDaniel Dunbar 3875090b3f71702c5626d8520f9608d77c6f26dcfa15Fariborz Jahanian BOMInit->setAnonUnionMember(AnonUnionMember); 38764ba2a17694148e16eaa8d3917f657ffcd3667be4Jay Foad BaseOrMemberInitializers[i] = BOMInit; 387764fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall } 3878ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 387964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall 388064fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall return std::make_pair(BaseOrMemberInitializers, NumInitializers); 3881ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner} 3882ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner 38831eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpNestedNameSpecifier * 3884183700f494ec9b6701b6efe82bcb25f4c79ba561John McCallASTReader::ReadNestedNameSpecifier(const RecordData &Record, unsigned &Idx) { 3885c612f7bc9a6379cd7e7c2dd306d05938e890051bAnders Carlsson unsigned N = Record[Idx++]; 38861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump NestedNameSpecifier *NNS = 0, *Prev = 0; 3887c612f7bc9a6379cd7e7c2dd306d05938e890051bAnders Carlsson for (unsigned I = 0; I != N; ++I) { 3888ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner NestedNameSpecifier::SpecifierKind Kind 3889ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 389060bce3ef20a4c9684e3825cdd739fefb9810327dFariborz Jahanian switch (Kind) { 3891aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian case NestedNameSpecifier::Identifier: { 3892aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian IdentifierInfo *II = GetIdentifierInfo(Record, Idx); 38936217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek NNS = NestedNameSpecifier::Create(*Context, Prev, II); 38948d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian break; 38958d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian } 38968d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian 38978d2c0a9814e56c2b22e22d1045181c735aef62fdFariborz Jahanian case NestedNameSpecifier::Namespace: { 3898aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian NamespaceDecl *NS = cast<NamespaceDecl>(GetDecl(Record[Idx++])); 3899aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian NNS = NestedNameSpecifier::Create(*Context, Prev, NS); 3900aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian break; 3901aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian } 3902aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz Jahanian 3903a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian case NestedNameSpecifier::TypeSpec: 3904a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian case NestedNameSpecifier::TypeSpecWithTemplate: { 3905a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian Type *T = GetType(Record[Idx++]).getTypePtr(); 3906a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian bool Template = Record[Idx++]; 39071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T); 39088e1fab243ab8023b7ee3899745386b3b3a4258f8Mike Stump break; 3909a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 3910a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian 3911a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian case NestedNameSpecifier::Global: { 3912a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian NNS = NestedNameSpecifier::GlobalSpecifier(*Context); 39139fdbab3cbc2fc04bcaf5768023d83707f3151144Mike Stump // No associated value, and there can't be a prefix. 3914a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian break; 39156217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek } 39166217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek } 3917a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian Prev = NNS; 3918a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian } 3919a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian return NNS; 3920a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian} 3921a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian 3922a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz JahanianSourceRange 3923a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz JahanianASTReader::ReadSourceRange(const RecordData &Record, unsigned &Idx) { 3924a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian SourceLocation beg = SourceLocation::getFromRawEncoding(Record[Idx++]); 3925a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian SourceLocation end = SourceLocation::getFromRawEncoding(Record[Idx++]); 39260237941e0beb0c929934b66ad29443b484d987feBenjamin Kramer return SourceRange(beg, end); 39270237941e0beb0c929934b66ad29443b484d987feBenjamin Kramer} 3928a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian 39291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Read an integral value 393085f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlssonllvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 393185f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson unsigned BitWidth = Record[Idx++]; 393285f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 3933e8c49533521c40643653f943d47229e62d277f88Anders Carlsson llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 393485f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson Idx += NumWords; 393585f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson return Result; 393685f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson} 39376217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek 39389533a7fdb8397421f3be52e879442460a87389f6Steve Naroff/// \brief Read a signed integral value 39399533a7fdb8397421f3be52e879442460a87389f6Steve Naroffllvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 39409533a7fdb8397421f3be52e879442460a87389f6Steve Naroff bool isUnsigned = Record[Idx++]; 39419533a7fdb8397421f3be52e879442460a87389f6Steve Naroff return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 39429533a7fdb8397421f3be52e879442460a87389f6Steve Naroff} 39439533a7fdb8397421f3be52e879442460a87389f6Steve Naroff 39449533a7fdb8397421f3be52e879442460a87389f6Steve Naroff/// \brief Read a floating-point value 39459533a7fdb8397421f3be52e879442460a87389f6Steve Naroffllvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) { 39469533a7fdb8397421f3be52e879442460a87389f6Steve Naroff return llvm::APFloat(ReadAPInt(Record, Idx)); 39479533a7fdb8397421f3be52e879442460a87389f6Steve Naroff} 39489533a7fdb8397421f3be52e879442460a87389f6Steve Naroff 394985f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson// \brief Read a string 395085f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlssonstd::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 3951a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian unsigned Len = Record[Idx++]; 3952a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 39531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Idx += Len; 395443822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian return Result; 3955ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner} 3956ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner 3957aa1d76163e4b0b1cc54e222be67379f8c02e8ffaFariborz JahanianCXXTemporary *ASTReader::ReadCXXTemporary(const RecordData &Record, 3958ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner unsigned &Idx) { 3959ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner CXXDestructorDecl *Decl = cast<CXXDestructorDecl>(GetDecl(Record[Idx++])); 3960ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return CXXTemporary::Create(*Context, Decl); 3961559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson} 3962559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson 3963559a83330416affb0e341a2c53800cbf924a5178Anders CarlssonDiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 3964559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson return Diag(SourceLocation(), DiagID); 39651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump} 3966559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson 3967559a83330416affb0e341a2c53800cbf924a5178Anders CarlssonDiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 3968559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson return Diags.Report(FullSourceLoc(Loc, SourceMgr), DiagID); 39691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump} 3970559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson 3971559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson/// \brief Retrieve the identifier table associated with the 3972559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson/// preprocessor. 3973559a83330416affb0e341a2c53800cbf924a5178Anders CarlssonIdentifierTable &ASTReader::getIdentifierTable() { 3974559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson assert(PP && "Forgot to set Preprocessor ?"); 3975559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson return PP->getIdentifierTable(); 3976559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson} 39771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 39781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \brief Record that the given ID maps to the given switch-case 3979559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson/// statement. 3980559a83330416affb0e341a2c53800cbf924a5178Anders Carlssonvoid ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 3981559a83330416affb0e341a2c53800cbf924a5178Anders Carlsson assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID"); 3982ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner SwitchCaseStmts[ID] = SC; 3983ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner} 39841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3985183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall/// \brief Retrieve the switch-case statement with the given ID. 3986c0a87b7db06643178ad2cbce0767548c139ea387Anders CarlssonSwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 3987ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID"); 3988ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner return SwitchCaseStmts[ID]; 39891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump} 39906217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek 399182a6cfbc421cc99c5b7313271f399f7ef95056ecDaniel Dunbar/// \brief Record that the given label statement has been 3992d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar/// deserialized and has the given ID. 3993502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbarvoid ASTReader::RecordLabelStmt(LabelStmt *S, unsigned ID) { 3994502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar assert(LabelStmts.find(ID) == LabelStmts.end() && 3995502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar "Deserialized label twice"); 39966fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian LabelStmts[ID] = S; 39976fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian 39986fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian // If we've already seen any goto statements that point to this 39996fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian // label, resolve them now. 40006fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian typedef std::multimap<unsigned, GotoStmt *>::iterator GotoIter; 4001910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor std::pair<GotoIter, GotoIter> Gotos = UnresolvedGotoStmts.equal_range(ID); 4002910f8008fea79120489a53593fe971b0b8a4a740Douglas Gregor for (GotoIter Goto = Gotos.first; Goto != Gotos.second; ++Goto) 40036fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian Goto->second->setLabel(S); 40046fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian UnresolvedGotoStmts.erase(Gotos.first, Gotos.second); 40056fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian 40066fb94391dc7cb11fd4bbdb969bbab11b6b48c223Fariborz Jahanian // If we've already seen any address-label statements that point to 4007502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar // this label, resolve them now. 4008502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar typedef std::multimap<unsigned, AddrLabelExpr *>::iterator AddrLabelIter; 4009502a4a1ce4c34cf78c8182d9798da0a51d9b7302Daniel Dunbar std::pair<AddrLabelIter, AddrLabelIter> AddrLabels 40100d504c1da852e58ff802545c823ecff3b6c654b8Daniel Dunbar = UnresolvedAddrLabelExprs.equal_range(ID); 40117d6b46d9a9d75dea8ef9f6973dd50633c1f37963Fariborz Jahanian for (AddrLabelIter AddrLabel = AddrLabels.first; 401217945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis AddrLabel != AddrLabels.second; ++AddrLabel) 401317945a0f64fe03ff6ec0c2146005a87636e3ac12Argyrios Kyrtzidis AddrLabel->second->setLabel(S); 401444b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor UnresolvedAddrLabelExprs.erase(AddrLabels.first, AddrLabels.second); 401543822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian} 4016d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar 401744b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor/// \brief Set the label of the given statement to the label 4018d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar/// identified by ID. 4019d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar/// 40201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// Depending on the order in which the label and other statements 4021d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar/// referencing that label occur, this operation may complete 402243822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian/// immediately (updating the statement) or it may queue the 40231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// statement to be back-patched later. 402443822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanianvoid ASTReader::SetLabelOf(GotoStmt *S, unsigned ID) { 4025d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar std::map<unsigned, LabelStmt *>::iterator Label = LabelStmts.find(ID); 4026a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian if (Label != LabelStmts.end()) { 4027a1c033e9514865f3a7b0d8b3b20e6de926cfec6cFariborz Jahanian // We've already seen this label, so set the label of the goto and 40281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // we're done. 402943822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian S->setLabel(Label->second); 4030d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar } else { 40317d6b46d9a9d75dea8ef9f6973dd50633c1f37963Fariborz Jahanian // We haven't seen this label yet, so add this goto to the set of 40326de88a873a4cbe06d72602eef57d68006730a80bFariborz Jahanian // unresolved goto statements. 4033d96b35bc6becf8db00d140c11e3d0e53f27567a1Daniel Dunbar UnresolvedGotoStmts.insert(std::make_pair(ID, S)); 4034ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 4035ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner} 4036e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian 4037ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner/// \brief Set the label of the given expression to the label 40388b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian/// identified by ID. 403964fd7e86c1a90d9ff78e4a0bd79f69499667a4e3David Chisnall/// 40408b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian/// Depending on the order in which the label and other statements 40418b4bf90eb6d3d08cf3bfb86705f0fdb20b9c5875Fariborz Jahanian/// referencing that label occur, this operation may complete 4042ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner/// immediately (updating the statement) or it may queue the 4043ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner/// statement to be back-patched later. 40441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpvoid ASTReader::SetLabelOf(AddrLabelExpr *S, unsigned ID) { 4045ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner std::map<unsigned, LabelStmt *>::iterator Label = LabelStmts.find(ID); 404621a98b188857d690aa4510c52ac4317ffa0908a8Steve Naroff if (Label != LabelStmts.end()) { 4047ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner // We've already seen this label, so set the label of the 4048ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner // label-address expression and we're done. 40491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump S->setLabel(Label->second); 4050c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall } else { 4051c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // We haven't seen this label yet, so add this label-address 4052c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall // expression to the set of unresolved label-address expressions. 4053c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall UnresolvedAddrLabelExprs.insert(std::make_pair(ID, S)); 40540953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 405543822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian} 40560953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 405743822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanianvoid ASTReader::FinishedDeserializing() { 405843822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian assert(NumCurrentElementsDeserializing && 405943822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian "FinishedDeserializing not paired with StartedDeserializing"); 406043822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian if (NumCurrentElementsDeserializing == 1) { 40612c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian // If any identifiers with corresponding top-level declarations have 40622c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian // been loaded, load those declarations now. 40632c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian while (!PendingIdentifierInfos.empty()) { 40642c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian SetGloballyVisibleDecls(PendingIdentifierInfos.front().II, 40652c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian PendingIdentifierInfos.front().DeclIDs, true); 40662c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian PendingIdentifierInfos.pop_front(); 406743822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian } 40682c18bb7c9fca66c30b6eabbdcbc6399d24a54fa9Fariborz Jahanian 406943822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian // We are not in recursive loading, so it's safe to pass the "interesting" 407043822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian // decls to the consumer. 4071ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner if (Consumer) 407243822eaeddeaa419b90f23c68af6b23c46788a58Fariborz Jahanian PassInterestingDeclsToConsumer(); 40731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 4074183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall --NumCurrentElementsDeserializing; 407514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff} 407614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 407714108da7f7fc059772711e4ffee1322a27b152a7Steve NaroffASTReader::ASTReader(Preprocessor &PP, ASTContext *Context, 4078ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner const char *isysroot, bool DisableValidation) 40791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 408027d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 408127d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context), 408227d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff Consumer(0), isysroot(isysroot), DisableValidation(DisableValidation), 408327d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff NumStatHits(0), NumStatMisses(0), NumSLocEntriesRead(0), 408414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff TotalNumSLocEntries(0), NumStatementsRead(0), TotalNumStatements(0), 408514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff NumMacrosRead(0), TotalNumMacros(0), NumSelectorsRead(0), 4086ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0), 40871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0), 4088ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0), 40891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump TotalVisibleDeclContexts(0), NumCurrentElementsDeserializing(0) { 409014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff RelocatablePCH = false; 409114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff} 409214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff 409314108da7f7fc059772711e4ffee1322a27b152a7Steve NaroffASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr, 409414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff Diagnostic &Diags, const char *isysroot, 409514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff bool DisableValidation) 409667ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff : DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr), 409767ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff Diags(Diags), SemaObj(0), PP(0), Context(0), Consumer(0), 409814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff isysroot(isysroot), DisableValidation(DisableValidation), NumStatHits(0), 409914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff NumStatMisses(0), NumSLocEntriesRead(0), TotalNumSLocEntries(0), 410014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0), 410114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0), 410214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0), 410314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0), 410414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0), 4105ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner NumCurrentElementsDeserializing(0) { 41061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump RelocatablePCH = false; 4107ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner} 4108ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner 4109ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris LattnerASTReader::~ASTReader() { 4110ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner for (unsigned i = 0, e = Chain.size(); i != e; ++i) 41111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump delete Chain[e - i - 1]; 4112ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner // Delete all visible decl lookup tables 4113ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(), 41141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump E = DeclContextOffsets.end(); 41151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump I != E; ++I) { 4116ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end(); 411714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff J != F; ++J) { 411814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (J->NameLookupTableData) 4119ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner delete static_cast<ASTDeclContextNameLookupTable*>( 4120ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner J->NameLookupTableData); 412127d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff } 4122ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 412327d20a24a1b816cecbd142727d2c81af5a6a111bSteve Naroff for (DeclContextVisibleUpdatesPending::iterator 412467ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff I = PendingVisibleUpdates.begin(), 412567ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff E = PendingVisibleUpdates.end(); 4126ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner I != E; ++I) { 4127ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 4128ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner F = I->second.end(); 41291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump J != F; ++J) 4130ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner delete static_cast<ASTDeclContextNameLookupTable*>(*J); 4131ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner } 4132ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner} 4133ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner 41341eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpASTReader::PerFileData::PerFileData() 4135532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall : StatCache(0), LocalNumSLocEntries(0), LocalNumTypes(0), TypeOffsets(0), 4136532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall LocalNumDecls(0), DeclOffsets(0), LocalNumIdentifiers(0), 4137532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall IdentifierOffsets(0), IdentifierTableData(0), IdentifierLookupTable(0), 4138532ec7baf2d0791abc9551ef856a537711c5774aJohn McCall LocalNumMacroDefinitions(0), MacroDefinitionOffsets(0), 4139e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian NumPreallocatedPreprocessingEntities(0), SelectorLookupTable(0), 4140e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian SelectorLookupTableData(0), SelectorOffsets(0), LocalNumSelectors(0) 4141e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian{} 4142e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian 4143e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz JahanianASTReader::PerFileData::~PerFileData() { 4144e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable); 4145e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable); 4146e6012c7ecb9d848f4091c8c48e7d9946cc36b23fFariborz Jahanian} 4147ce7b38c4f1ea9c51e2f46a82e3f57456b74269d5Chris Lattner 414885f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson