ASTReader.cpp revision 211f6e894895f552e0a98421b2f6e931ca4a8c11
13447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein//===--- ASTReader.cpp - AST File Reader ------------------------*- C++ -*-===// 23447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein// 33447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein// The LLVM Compiler Infrastructure 43447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein// 53447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein// This file is distributed under the University of Illinois Open Source 63447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein// License. See LICENSE.TXT for details. 73447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein// 83447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein//===----------------------------------------------------------------------===// 93447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein// 103447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein// This file defines the ASTReader class, which reads AST files. 113447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein// 123447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein//===----------------------------------------------------------------------===// 133447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein 143447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/Serialization/ASTReader.h" 153447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/Serialization/ASTDeserializationListener.h" 163447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "ASTCommon.h" 173447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/Frontend/FrontendDiagnostic.h" 183447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/Frontend/Utils.h" 193447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/Sema/Sema.h" 203447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/Sema/Scope.h" 213447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/AST/ASTConsumer.h" 223447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/AST/ASTContext.h" 233447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/AST/DeclTemplate.h" 243447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/AST/Expr.h" 253447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/AST/ExprCXX.h" 263447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/AST/NestedNameSpecifier.h" 273447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/AST/Type.h" 283447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/AST/TypeLocVisitor.h" 293447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/Lex/MacroInfo.h" 303447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/Lex/PreprocessingRecord.h" 313447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/Lex/Preprocessor.h" 323447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/Lex/HeaderSearch.h" 333447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/Basic/OnDiskHashTable.h" 343447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/Basic/SourceManager.h" 353447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/Basic/SourceManagerInternals.h" 363447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/Basic/FileManager.h" 373447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/Basic/FileSystemStatCache.h" 383447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/Basic/TargetInfo.h" 393447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/Basic/Version.h" 403447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "clang/Basic/VersionTuple.h" 413447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "llvm/ADT/StringExtras.h" 423447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "llvm/Bitcode/BitstreamReader.h" 433447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "llvm/Support/MemoryBuffer.h" 443447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "llvm/Support/ErrorHandling.h" 453447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "llvm/Support/FileSystem.h" 463447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "llvm/Support/Path.h" 473447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include "llvm/Support/system_error.h" 483447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include <algorithm> 493447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include <iterator> 503447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include <cstdio> 513447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include <sys/stat.h> 523447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#include <queue> 533447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein 543447a5916aa62f44de24cc441fc9987116ddff52Andrew Sappersteinusing namespace clang; 553447a5916aa62f44de24cc441fc9987116ddff52Andrew Sappersteinusing namespace clang::serialization; 563447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein 573447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein//===----------------------------------------------------------------------===// 583447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein// PCH validator implementation 593447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein//===----------------------------------------------------------------------===// 603447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein 613447a5916aa62f44de24cc441fc9987116ddff52Andrew SappersteinASTReaderListener::~ASTReaderListener() {} 623447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein 633447a5916aa62f44de24cc441fc9987116ddff52Andrew Sappersteinbool 643447a5916aa62f44de24cc441fc9987116ddff52Andrew SappersteinPCHValidator::ReadLanguageOptions(const LangOptions &LangOpts) { 653447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein const LangOptions &PPLangOpts = PP.getLangOptions(); 663447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#define PARSE_LANGOPT_BENIGN(Option) 673447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#define PARSE_LANGOPT_IMPORTANT(Option, DiagID) \ 683447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein if (PPLangOpts.Option != LangOpts.Option) { \ 693447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein Reader.Diag(DiagID) << LangOpts.Option << PPLangOpts.Option; \ 703447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein return true; \ 713447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein } 723447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein 733447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(Trigraphs); 743447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(BCPLComment); 753447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(DollarIdents); 763447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(AsmPreprocessor); 773447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(GNUMode, diag::warn_pch_gnu_extensions); 783447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(GNUKeywords, diag::warn_pch_gnu_keywords); 793447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(ImplicitInt); 803447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(Digraphs); 813447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(HexFloats); 823447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(C99, diag::warn_pch_c99); 833447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(C1X, diag::warn_pch_c1x); 843447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(Microsoft, diag::warn_pch_microsoft_extensions); 853447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(MSCVersion); 863447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(CPlusPlus, diag::warn_pch_cplusplus); 873447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(CPlusPlus0x, diag::warn_pch_cplusplus0x); 883447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(CXXOperatorName); 893447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(ObjC1, diag::warn_pch_objective_c); 903447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(ObjC2, diag::warn_pch_objective_c2); 913447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI, diag::warn_pch_nonfragile_abi); 923447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI2, diag::warn_pch_nonfragile_abi2); 933447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(AppleKext, diag::warn_pch_apple_kext); 943447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(ObjCDefaultSynthProperties, 953447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein diag::warn_pch_objc_auto_properties); 963447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(ObjCInferRelatedResultType) 973447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(NoConstantCFStrings, 983447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein diag::warn_pch_no_constant_cfstrings); 993447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(PascalStrings); 1003447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(WritableStrings); 101324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver PARSE_LANGOPT_IMPORTANT(LaxVectorConversions, 102324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver diag::warn_pch_lax_vector_conversions); 103324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver PARSE_LANGOPT_IMPORTANT(AltiVec, diag::warn_pch_altivec); 104324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver PARSE_LANGOPT_IMPORTANT(Exceptions, diag::warn_pch_exceptions); 105324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver PARSE_LANGOPT_IMPORTANT(ObjCExceptions, diag::warn_pch_objc_exceptions); 106324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver PARSE_LANGOPT_IMPORTANT(CXXExceptions, diag::warn_pch_cxx_exceptions); 107324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver PARSE_LANGOPT_IMPORTANT(SjLjExceptions, diag::warn_pch_sjlj_exceptions); 1083447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(MSBitfields, diag::warn_pch_ms_bitfields); 1093447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(NeXTRuntime, diag::warn_pch_objc_runtime); 1103447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(Freestanding, diag::warn_pch_freestanding); 1113447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(NoBuiltin, diag::warn_pch_builtins); 1123447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(ThreadsafeStatics, 1133447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein diag::warn_pch_thread_safe_statics); 1143447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(POSIXThreads, diag::warn_pch_posix_threads); 1153447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(Blocks, diag::warn_pch_blocks); 1163447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(EmitAllDecls); 1173447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(MathErrno, diag::warn_pch_math_errno); 1183447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(getSignedOverflowBehavior()); 1193447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(HeinousExtensions, 1203447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein diag::warn_pch_heinous_extensions); 1213447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein // FIXME: Most of the options below are benign if the macro wasn't 1223447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein // used. Unfortunately, this means that a PCH compiled without 1233447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein // optimization can't be used with optimization turned on, even 1243447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein // though the only thing that changes is whether __OPTIMIZE__ was 1253447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein // defined... but if __OPTIMIZE__ never showed up in the header, it 1263447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein // doesn't matter. We could consider making this some special kind 1273447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein // of check. 1283447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(Optimize, diag::warn_pch_optimize); 1293447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(OptimizeSize, diag::warn_pch_optimize_size); 1303447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(Static, diag::warn_pch_static); 1313447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(PICLevel, diag::warn_pch_pic_level); 1323447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(GNUInline, diag::warn_pch_gnu_inline); 1333447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(NoInline, diag::warn_pch_no_inline); 1343447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(Deprecated, diag::warn_pch_deprecated); 1353447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(AccessControl, diag::warn_pch_access_control); 1363447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(CharIsSigned, diag::warn_pch_char_signed); 1373447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(ShortWChar, diag::warn_pch_short_wchar); 1383447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(ShortEnums, diag::warn_pch_short_enums); 1393447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein if ((PPLangOpts.getGCMode() != 0) != (LangOpts.getGCMode() != 0)) { 1403447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein Reader.Diag(diag::warn_pch_gc_mode) 1413447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein << LangOpts.getGCMode() << PPLangOpts.getGCMode(); 1423447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein return true; 1433447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein } 1443447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(getVisibilityMode()); 1453447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(getStackProtectorMode(), 1463447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein diag::warn_pch_stack_protector); 1473447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(InstantiationDepth); 1483447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(OpenCL, diag::warn_pch_opencl); 1493447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(CUDA, diag::warn_pch_cuda); 1503447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(CatchUndefined); 1513447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(DefaultFPContract); 1523447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(ElideConstructors, diag::warn_pch_elide_constructors); 1533447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(SpellChecking); 1543447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_IMPORTANT(ObjCAutoRefCount, diag::warn_pch_auto_ref_count); 1553447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PARSE_LANGOPT_BENIGN(ObjCInferRelatedReturnType); 1563447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#undef PARSE_LANGOPT_IMPORTANT 1573447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein#undef PARSE_LANGOPT_BENIGN 1583447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein 1593447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein return false; 1603447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein} 1613447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein 1623447a5916aa62f44de24cc441fc9987116ddff52Andrew Sappersteinbool PCHValidator::ReadTargetTriple(StringRef Triple) { 1633447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein if (Triple == PP.getTargetInfo().getTriple().str()) 1643447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein return false; 1653447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein 1663447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein Reader.Diag(diag::warn_pch_target_triple) 1673447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein << Triple << PP.getTargetInfo().getTriple().str(); 1683447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein return true; 1693447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein} 1703447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein 1713447a5916aa62f44de24cc441fc9987116ddff52Andrew Sappersteinnamespace { 1723447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein struct EmptyStringRef { 1733447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein bool operator ()(StringRef r) const { return r.empty(); } 1743447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein }; 1753447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein struct EmptyBlock { 1763447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein bool operator ()(const PCHPredefinesBlock &r) const {return r.Data.empty();} 1773447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein }; 1783447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein} 1793447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein 1803447a5916aa62f44de24cc441fc9987116ddff52Andrew Sappersteinstatic bool EqualConcatenations(SmallVector<StringRef, 2> L, 1813447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein PCHPredefinesBlocks R) { 1823447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein // First, sum up the lengths. 1833447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein unsigned LL = 0, RL = 0; 1843447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein for (unsigned I = 0, N = L.size(); I != N; ++I) { 1853447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein LL += L[I].size(); 1863447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein } 1873447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein for (unsigned I = 0, N = R.size(); I != N; ++I) { 1883447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein RL += R[I].Data.size(); 1893447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein } 1903447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein if (LL != RL) 1913447a5916aa62f44de24cc441fc9987116ddff52Andrew Sapperstein return false; 192 if (LL == 0 && RL == 0) 193 return true; 194 195 // Kick out empty parts, they confuse the algorithm below. 196 L.erase(std::remove_if(L.begin(), L.end(), EmptyStringRef()), L.end()); 197 R.erase(std::remove_if(R.begin(), R.end(), EmptyBlock()), R.end()); 198 199 // Do it the hard way. At this point, both vectors must be non-empty. 200 StringRef LR = L[0], RR = R[0].Data; 201 unsigned LI = 0, RI = 0, LN = L.size(), RN = R.size(); 202 (void) RN; 203 for (;;) { 204 // Compare the current pieces. 205 if (LR.size() == RR.size()) { 206 // If they're the same length, it's pretty easy. 207 if (LR != RR) 208 return false; 209 // Both pieces are done, advance. 210 ++LI; 211 ++RI; 212 // If either string is done, they're both done, since they're the same 213 // length. 214 if (LI == LN) { 215 assert(RI == RN && "Strings not the same length after all?"); 216 return true; 217 } 218 LR = L[LI]; 219 RR = R[RI].Data; 220 } else if (LR.size() < RR.size()) { 221 // Right piece is longer. 222 if (!RR.startswith(LR)) 223 return false; 224 ++LI; 225 assert(LI != LN && "Strings not the same length after all?"); 226 RR = RR.substr(LR.size()); 227 LR = L[LI]; 228 } else { 229 // Left piece is longer. 230 if (!LR.startswith(RR)) 231 return false; 232 ++RI; 233 assert(RI != RN && "Strings not the same length after all?"); 234 LR = LR.substr(RR.size()); 235 RR = R[RI].Data; 236 } 237 } 238} 239 240static std::pair<FileID, StringRef::size_type> 241FindMacro(const PCHPredefinesBlocks &Buffers, StringRef MacroDef) { 242 std::pair<FileID, StringRef::size_type> Res; 243 for (unsigned I = 0, N = Buffers.size(); I != N; ++I) { 244 Res.second = Buffers[I].Data.find(MacroDef); 245 if (Res.second != StringRef::npos) { 246 Res.first = Buffers[I].BufferID; 247 break; 248 } 249 } 250 return Res; 251} 252 253bool PCHValidator::ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers, 254 StringRef OriginalFileName, 255 std::string &SuggestedPredefines, 256 FileManager &FileMgr) { 257 // We are in the context of an implicit include, so the predefines buffer will 258 // have a #include entry for the PCH file itself (as normalized by the 259 // preprocessor initialization). Find it and skip over it in the checking 260 // below. 261 llvm::SmallString<256> PCHInclude; 262 PCHInclude += "#include \""; 263 PCHInclude += NormalizeDashIncludePath(OriginalFileName, FileMgr); 264 PCHInclude += "\"\n"; 265 std::pair<StringRef,StringRef> Split = 266 StringRef(PP.getPredefines()).split(PCHInclude.str()); 267 StringRef Left = Split.first, Right = Split.second; 268 if (Left == PP.getPredefines()) { 269 Error("Missing PCH include entry!"); 270 return true; 271 } 272 273 // If the concatenation of all the PCH buffers is equal to the adjusted 274 // command line, we're done. 275 SmallVector<StringRef, 2> CommandLine; 276 CommandLine.push_back(Left); 277 CommandLine.push_back(Right); 278 if (EqualConcatenations(CommandLine, Buffers)) 279 return false; 280 281 SourceManager &SourceMgr = PP.getSourceManager(); 282 283 // The predefines buffers are different. Determine what the differences are, 284 // and whether they require us to reject the PCH file. 285 SmallVector<StringRef, 8> PCHLines; 286 for (unsigned I = 0, N = Buffers.size(); I != N; ++I) 287 Buffers[I].Data.split(PCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false); 288 289 SmallVector<StringRef, 8> CmdLineLines; 290 Left.split(CmdLineLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false); 291 292 // Pick out implicit #includes after the PCH and don't consider them for 293 // validation; we will insert them into SuggestedPredefines so that the 294 // preprocessor includes them. 295 std::string IncludesAfterPCH; 296 SmallVector<StringRef, 8> AfterPCHLines; 297 Right.split(AfterPCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false); 298 for (unsigned i = 0, e = AfterPCHLines.size(); i != e; ++i) { 299 if (AfterPCHLines[i].startswith("#include ")) { 300 IncludesAfterPCH += AfterPCHLines[i]; 301 IncludesAfterPCH += '\n'; 302 } else { 303 CmdLineLines.push_back(AfterPCHLines[i]); 304 } 305 } 306 307 // Make sure we add the includes last into SuggestedPredefines before we 308 // exit this function. 309 struct AddIncludesRAII { 310 std::string &SuggestedPredefines; 311 std::string &IncludesAfterPCH; 312 313 AddIncludesRAII(std::string &SuggestedPredefines, 314 std::string &IncludesAfterPCH) 315 : SuggestedPredefines(SuggestedPredefines), 316 IncludesAfterPCH(IncludesAfterPCH) { } 317 ~AddIncludesRAII() { 318 SuggestedPredefines += IncludesAfterPCH; 319 } 320 } AddIncludes(SuggestedPredefines, IncludesAfterPCH); 321 322 // Sort both sets of predefined buffer lines, since we allow some extra 323 // definitions and they may appear at any point in the output. 324 std::sort(CmdLineLines.begin(), CmdLineLines.end()); 325 std::sort(PCHLines.begin(), PCHLines.end()); 326 327 // Determine which predefines that were used to build the PCH file are missing 328 // from the command line. 329 std::vector<StringRef> MissingPredefines; 330 std::set_difference(PCHLines.begin(), PCHLines.end(), 331 CmdLineLines.begin(), CmdLineLines.end(), 332 std::back_inserter(MissingPredefines)); 333 334 bool MissingDefines = false; 335 bool ConflictingDefines = false; 336 for (unsigned I = 0, N = MissingPredefines.size(); I != N; ++I) { 337 StringRef Missing = MissingPredefines[I]; 338 if (Missing.startswith("#include ")) { 339 // An -include was specified when generating the PCH; it is included in 340 // the PCH, just ignore it. 341 continue; 342 } 343 if (!Missing.startswith("#define ")) { 344 Reader.Diag(diag::warn_pch_compiler_options_mismatch); 345 return true; 346 } 347 348 // This is a macro definition. Determine the name of the macro we're 349 // defining. 350 std::string::size_type StartOfMacroName = strlen("#define "); 351 std::string::size_type EndOfMacroName 352 = Missing.find_first_of("( \n\r", StartOfMacroName); 353 assert(EndOfMacroName != std::string::npos && 354 "Couldn't find the end of the macro name"); 355 StringRef MacroName = Missing.slice(StartOfMacroName, EndOfMacroName); 356 357 // Determine whether this macro was given a different definition on the 358 // command line. 359 std::string MacroDefStart = "#define " + MacroName.str(); 360 std::string::size_type MacroDefLen = MacroDefStart.size(); 361 SmallVector<StringRef, 8>::iterator ConflictPos 362 = std::lower_bound(CmdLineLines.begin(), CmdLineLines.end(), 363 MacroDefStart); 364 for (; ConflictPos != CmdLineLines.end(); ++ConflictPos) { 365 if (!ConflictPos->startswith(MacroDefStart)) { 366 // Different macro; we're done. 367 ConflictPos = CmdLineLines.end(); 368 break; 369 } 370 371 assert(ConflictPos->size() > MacroDefLen && 372 "Invalid #define in predefines buffer?"); 373 if ((*ConflictPos)[MacroDefLen] != ' ' && 374 (*ConflictPos)[MacroDefLen] != '(') 375 continue; // Longer macro name; keep trying. 376 377 // We found a conflicting macro definition. 378 break; 379 } 380 381 if (ConflictPos != CmdLineLines.end()) { 382 Reader.Diag(diag::warn_cmdline_conflicting_macro_def) 383 << MacroName; 384 385 // Show the definition of this macro within the PCH file. 386 std::pair<FileID, StringRef::size_type> MacroLoc = 387 FindMacro(Buffers, Missing); 388 assert(MacroLoc.second!=StringRef::npos && "Unable to find macro!"); 389 SourceLocation PCHMissingLoc = 390 SourceMgr.getLocForStartOfFile(MacroLoc.first) 391 .getFileLocWithOffset(MacroLoc.second); 392 Reader.Diag(PCHMissingLoc, diag::note_pch_macro_defined_as) << MacroName; 393 394 ConflictingDefines = true; 395 continue; 396 } 397 398 // If the macro doesn't conflict, then we'll just pick up the macro 399 // definition from the PCH file. Warn the user that they made a mistake. 400 if (ConflictingDefines) 401 continue; // Don't complain if there are already conflicting defs 402 403 if (!MissingDefines) { 404 Reader.Diag(diag::warn_cmdline_missing_macro_defs); 405 MissingDefines = true; 406 } 407 408 // Show the definition of this macro within the PCH file. 409 std::pair<FileID, StringRef::size_type> MacroLoc = 410 FindMacro(Buffers, Missing); 411 assert(MacroLoc.second!=StringRef::npos && "Unable to find macro!"); 412 SourceLocation PCHMissingLoc = 413 SourceMgr.getLocForStartOfFile(MacroLoc.first) 414 .getFileLocWithOffset(MacroLoc.second); 415 Reader.Diag(PCHMissingLoc, diag::note_using_macro_def_from_pch); 416 } 417 418 if (ConflictingDefines) 419 return true; 420 421 // Determine what predefines were introduced based on command-line 422 // parameters that were not present when building the PCH 423 // file. Extra #defines are okay, so long as the identifiers being 424 // defined were not used within the precompiled header. 425 std::vector<StringRef> ExtraPredefines; 426 std::set_difference(CmdLineLines.begin(), CmdLineLines.end(), 427 PCHLines.begin(), PCHLines.end(), 428 std::back_inserter(ExtraPredefines)); 429 for (unsigned I = 0, N = ExtraPredefines.size(); I != N; ++I) { 430 StringRef &Extra = ExtraPredefines[I]; 431 if (!Extra.startswith("#define ")) { 432 Reader.Diag(diag::warn_pch_compiler_options_mismatch); 433 return true; 434 } 435 436 // This is an extra macro definition. Determine the name of the 437 // macro we're defining. 438 std::string::size_type StartOfMacroName = strlen("#define "); 439 std::string::size_type EndOfMacroName 440 = Extra.find_first_of("( \n\r", StartOfMacroName); 441 assert(EndOfMacroName != std::string::npos && 442 "Couldn't find the end of the macro name"); 443 StringRef MacroName = Extra.slice(StartOfMacroName, EndOfMacroName); 444 445 // Check whether this name was used somewhere in the PCH file. If 446 // so, defining it as a macro could change behavior, so we reject 447 // the PCH file. 448 if (IdentifierInfo *II = Reader.get(MacroName)) { 449 Reader.Diag(diag::warn_macro_name_used_in_pch) << II; 450 return true; 451 } 452 453 // Add this definition to the suggested predefines buffer. 454 SuggestedPredefines += Extra; 455 SuggestedPredefines += '\n'; 456 } 457 458 // If we get here, it's because the predefines buffer had compatible 459 // contents. Accept the PCH file. 460 return false; 461} 462 463void PCHValidator::ReadHeaderFileInfo(const HeaderFileInfo &HFI, 464 unsigned ID) { 465 PP.getHeaderSearchInfo().setHeaderFileInfoForUID(HFI, ID); 466 ++NumHeaderInfos; 467} 468 469void PCHValidator::ReadCounter(unsigned Value) { 470 PP.setCounterValue(Value); 471} 472 473//===----------------------------------------------------------------------===// 474// AST reader implementation 475//===----------------------------------------------------------------------===// 476 477void 478ASTReader::setDeserializationListener(ASTDeserializationListener *Listener) { 479 DeserializationListener = Listener; 480} 481 482 483namespace { 484class ASTSelectorLookupTrait { 485 ASTReader &Reader; 486 Module &F; 487 488public: 489 struct data_type { 490 SelectorID ID; 491 ObjCMethodList Instance, Factory; 492 }; 493 494 typedef Selector external_key_type; 495 typedef external_key_type internal_key_type; 496 497 ASTSelectorLookupTrait(ASTReader &Reader, Module &F) 498 : Reader(Reader), F(F) { } 499 500 static bool EqualKey(const internal_key_type& a, 501 const internal_key_type& b) { 502 return a == b; 503 } 504 505 static unsigned ComputeHash(Selector Sel) { 506 return serialization::ComputeHash(Sel); 507 } 508 509 // This hopefully will just get inlined and removed by the optimizer. 510 static const internal_key_type& 511 GetInternalKey(const external_key_type& x) { return x; } 512 513 static std::pair<unsigned, unsigned> 514 ReadKeyDataLength(const unsigned char*& d) { 515 using namespace clang::io; 516 unsigned KeyLen = ReadUnalignedLE16(d); 517 unsigned DataLen = ReadUnalignedLE16(d); 518 return std::make_pair(KeyLen, DataLen); 519 } 520 521 internal_key_type ReadKey(const unsigned char* d, unsigned) { 522 using namespace clang::io; 523 SelectorTable &SelTable = Reader.getContext()->Selectors; 524 unsigned N = ReadUnalignedLE16(d); 525 IdentifierInfo *FirstII 526 = Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)); 527 if (N == 0) 528 return SelTable.getNullarySelector(FirstII); 529 else if (N == 1) 530 return SelTable.getUnarySelector(FirstII); 531 532 SmallVector<IdentifierInfo *, 16> Args; 533 Args.push_back(FirstII); 534 for (unsigned I = 1; I != N; ++I) 535 Args.push_back(Reader.getLocalIdentifier(F, ReadUnalignedLE32(d))); 536 537 return SelTable.getSelector(N, Args.data()); 538 } 539 540 data_type ReadData(Selector, const unsigned char* d, unsigned DataLen) { 541 using namespace clang::io; 542 543 data_type Result; 544 545 Result.ID = Reader.getGlobalSelectorID(F, ReadUnalignedLE32(d)); 546 unsigned NumInstanceMethods = ReadUnalignedLE16(d); 547 unsigned NumFactoryMethods = ReadUnalignedLE16(d); 548 549 // Load instance methods 550 ObjCMethodList *Prev = 0; 551 for (unsigned I = 0; I != NumInstanceMethods; ++I) { 552 ObjCMethodDecl *Method 553 = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d)); 554 if (!Result.Instance.Method) { 555 // This is the first method, which is the easy case. 556 Result.Instance.Method = Method; 557 Prev = &Result.Instance; 558 continue; 559 } 560 561 ObjCMethodList *Mem = 562 Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>(); 563 Prev->Next = new (Mem) ObjCMethodList(Method, 0); 564 Prev = Prev->Next; 565 } 566 567 // Load factory methods 568 Prev = 0; 569 for (unsigned I = 0; I != NumFactoryMethods; ++I) { 570 ObjCMethodDecl *Method 571 = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d)); 572 if (!Result.Factory.Method) { 573 // This is the first method, which is the easy case. 574 Result.Factory.Method = Method; 575 Prev = &Result.Factory; 576 continue; 577 } 578 579 ObjCMethodList *Mem = 580 Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>(); 581 Prev->Next = new (Mem) ObjCMethodList(Method, 0); 582 Prev = Prev->Next; 583 } 584 585 return Result; 586 } 587}; 588 589} // end anonymous namespace 590 591/// \brief The on-disk hash table used for the global method pool. 592typedef OnDiskChainedHashTable<ASTSelectorLookupTrait> 593 ASTSelectorLookupTable; 594 595namespace clang { 596class ASTIdentifierLookupTrait { 597 ASTReader &Reader; 598 Module &F; 599 600 // If we know the IdentifierInfo in advance, it is here and we will 601 // not build a new one. Used when deserializing information about an 602 // identifier that was constructed before the AST file was read. 603 IdentifierInfo *KnownII; 604 605public: 606 typedef IdentifierInfo * data_type; 607 608 typedef const std::pair<const char*, unsigned> external_key_type; 609 610 typedef external_key_type internal_key_type; 611 612 ASTIdentifierLookupTrait(ASTReader &Reader, Module &F, 613 IdentifierInfo *II = 0) 614 : Reader(Reader), F(F), KnownII(II) { } 615 616 static bool EqualKey(const internal_key_type& a, 617 const internal_key_type& b) { 618 return (a.second == b.second) ? memcmp(a.first, b.first, a.second) == 0 619 : false; 620 } 621 622 static unsigned ComputeHash(const internal_key_type& a) { 623 return llvm::HashString(StringRef(a.first, a.second)); 624 } 625 626 // This hopefully will just get inlined and removed by the optimizer. 627 static const internal_key_type& 628 GetInternalKey(const external_key_type& x) { return x; } 629 630 // This hopefully will just get inlined and removed by the optimizer. 631 static const external_key_type& 632 GetExternalKey(const internal_key_type& x) { return x; } 633 634 static std::pair<unsigned, unsigned> 635 ReadKeyDataLength(const unsigned char*& d) { 636 using namespace clang::io; 637 unsigned DataLen = ReadUnalignedLE16(d); 638 unsigned KeyLen = ReadUnalignedLE16(d); 639 return std::make_pair(KeyLen, DataLen); 640 } 641 642 static std::pair<const char*, unsigned> 643 ReadKey(const unsigned char* d, unsigned n) { 644 assert(n >= 2 && d[n-1] == '\0'); 645 return std::make_pair((const char*) d, n-1); 646 } 647 648 IdentifierInfo *ReadData(const internal_key_type& k, 649 const unsigned char* d, 650 unsigned DataLen) { 651 using namespace clang::io; 652 unsigned RawID = ReadUnalignedLE32(d); 653 bool IsInteresting = RawID & 0x01; 654 655 // Wipe out the "is interesting" bit. 656 RawID = RawID >> 1; 657 658 IdentID ID = Reader.getGlobalIdentifierID(F, RawID); 659 if (!IsInteresting) { 660 // For uninteresting identifiers, just build the IdentifierInfo 661 // and associate it with the persistent ID. 662 IdentifierInfo *II = KnownII; 663 if (!II) 664 II = &Reader.getIdentifierTable().getOwn(StringRef(k.first, k.second)); 665 Reader.SetIdentifierInfo(ID, II); 666 II->setIsFromAST(); 667 return II; 668 } 669 670 unsigned Bits = ReadUnalignedLE16(d); 671 bool CPlusPlusOperatorKeyword = Bits & 0x01; 672 Bits >>= 1; 673 bool HasRevertedTokenIDToIdentifier = Bits & 0x01; 674 Bits >>= 1; 675 bool Poisoned = Bits & 0x01; 676 Bits >>= 1; 677 bool ExtensionToken = Bits & 0x01; 678 Bits >>= 1; 679 bool hasMacroDefinition = Bits & 0x01; 680 Bits >>= 1; 681 unsigned ObjCOrBuiltinID = Bits & 0x3FF; 682 Bits >>= 10; 683 684 assert(Bits == 0 && "Extra bits in the identifier?"); 685 DataLen -= 6; 686 687 // Build the IdentifierInfo itself and link the identifier ID with 688 // the new IdentifierInfo. 689 IdentifierInfo *II = KnownII; 690 if (!II) 691 II = &Reader.getIdentifierTable().getOwn(StringRef(k.first, k.second)); 692 Reader.SetIdentifierInfo(ID, II); 693 694 // Set or check the various bits in the IdentifierInfo structure. 695 // Token IDs are read-only. 696 if (HasRevertedTokenIDToIdentifier) 697 II->RevertTokenIDToIdentifier(); 698 II->setObjCOrBuiltinID(ObjCOrBuiltinID); 699 assert(II->isExtensionToken() == ExtensionToken && 700 "Incorrect extension token flag"); 701 (void)ExtensionToken; 702 II->setIsPoisoned(Poisoned); 703 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword && 704 "Incorrect C++ operator keyword flag"); 705 (void)CPlusPlusOperatorKeyword; 706 707 // If this identifier is a macro, deserialize the macro 708 // definition. 709 if (hasMacroDefinition) { 710 uint32_t Offset = ReadUnalignedLE32(d); 711 Reader.SetIdentifierIsMacro(II, F, Offset); 712 DataLen -= 4; 713 } 714 715 // Read all of the declarations visible at global scope with this 716 // name. 717 if (Reader.getContext() == 0) return II; 718 if (DataLen > 0) { 719 SmallVector<uint32_t, 4> DeclIDs; 720 for (; DataLen > 0; DataLen -= 4) 721 DeclIDs.push_back(Reader.getGlobalDeclID(F, ReadUnalignedLE32(d))); 722 Reader.SetGloballyVisibleDecls(II, DeclIDs); 723 } 724 725 II->setIsFromAST(); 726 return II; 727 } 728}; 729 730} // end anonymous namespace 731 732/// \brief The on-disk hash table used to contain information about 733/// all of the identifiers in the program. 734typedef OnDiskChainedHashTable<ASTIdentifierLookupTrait> 735 ASTIdentifierLookupTable; 736 737namespace { 738class ASTDeclContextNameLookupTrait { 739 ASTReader &Reader; 740 Module &F; 741 742public: 743 /// \brief Pair of begin/end iterators for DeclIDs. 744 /// 745 /// Note that these declaration IDs are local to the module that contains this 746 /// particular lookup t 747 typedef std::pair<DeclID *, DeclID *> data_type; 748 749 /// \brief Special internal key for declaration names. 750 /// The hash table creates keys for comparison; we do not create 751 /// a DeclarationName for the internal key to avoid deserializing types. 752 struct DeclNameKey { 753 DeclarationName::NameKind Kind; 754 uint64_t Data; 755 DeclNameKey() : Kind((DeclarationName::NameKind)0), Data(0) { } 756 }; 757 758 typedef DeclarationName external_key_type; 759 typedef DeclNameKey internal_key_type; 760 761 explicit ASTDeclContextNameLookupTrait(ASTReader &Reader, 762 Module &F) 763 : Reader(Reader), F(F) { } 764 765 static bool EqualKey(const internal_key_type& a, 766 const internal_key_type& b) { 767 return a.Kind == b.Kind && a.Data == b.Data; 768 } 769 770 unsigned ComputeHash(const DeclNameKey &Key) const { 771 llvm::FoldingSetNodeID ID; 772 ID.AddInteger(Key.Kind); 773 774 switch (Key.Kind) { 775 case DeclarationName::Identifier: 776 case DeclarationName::CXXLiteralOperatorName: 777 ID.AddString(((IdentifierInfo*)Key.Data)->getName()); 778 break; 779 case DeclarationName::ObjCZeroArgSelector: 780 case DeclarationName::ObjCOneArgSelector: 781 case DeclarationName::ObjCMultiArgSelector: 782 ID.AddInteger(serialization::ComputeHash(Selector(Key.Data))); 783 break; 784 case DeclarationName::CXXOperatorName: 785 ID.AddInteger((OverloadedOperatorKind)Key.Data); 786 break; 787 case DeclarationName::CXXConstructorName: 788 case DeclarationName::CXXDestructorName: 789 case DeclarationName::CXXConversionFunctionName: 790 case DeclarationName::CXXUsingDirective: 791 break; 792 } 793 794 return ID.ComputeHash(); 795 } 796 797 internal_key_type GetInternalKey(const external_key_type& Name) const { 798 DeclNameKey Key; 799 Key.Kind = Name.getNameKind(); 800 switch (Name.getNameKind()) { 801 case DeclarationName::Identifier: 802 Key.Data = (uint64_t)Name.getAsIdentifierInfo(); 803 break; 804 case DeclarationName::ObjCZeroArgSelector: 805 case DeclarationName::ObjCOneArgSelector: 806 case DeclarationName::ObjCMultiArgSelector: 807 Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr(); 808 break; 809 case DeclarationName::CXXOperatorName: 810 Key.Data = Name.getCXXOverloadedOperator(); 811 break; 812 case DeclarationName::CXXLiteralOperatorName: 813 Key.Data = (uint64_t)Name.getCXXLiteralIdentifier(); 814 break; 815 case DeclarationName::CXXConstructorName: 816 case DeclarationName::CXXDestructorName: 817 case DeclarationName::CXXConversionFunctionName: 818 case DeclarationName::CXXUsingDirective: 819 Key.Data = 0; 820 break; 821 } 822 823 return Key; 824 } 825 826 external_key_type GetExternalKey(const internal_key_type& Key) const { 827 ASTContext *Context = Reader.getContext(); 828 switch (Key.Kind) { 829 case DeclarationName::Identifier: 830 return DeclarationName((IdentifierInfo*)Key.Data); 831 832 case DeclarationName::ObjCZeroArgSelector: 833 case DeclarationName::ObjCOneArgSelector: 834 case DeclarationName::ObjCMultiArgSelector: 835 return DeclarationName(Selector(Key.Data)); 836 837 case DeclarationName::CXXConstructorName: 838 return Context->DeclarationNames.getCXXConstructorName( 839 Context->getCanonicalType(Reader.getLocalType(F, Key.Data))); 840 841 case DeclarationName::CXXDestructorName: 842 return Context->DeclarationNames.getCXXDestructorName( 843 Context->getCanonicalType(Reader.getLocalType(F, Key.Data))); 844 845 case DeclarationName::CXXConversionFunctionName: 846 return Context->DeclarationNames.getCXXConversionFunctionName( 847 Context->getCanonicalType(Reader.getLocalType(F, Key.Data))); 848 849 case DeclarationName::CXXOperatorName: 850 return Context->DeclarationNames.getCXXOperatorName( 851 (OverloadedOperatorKind)Key.Data); 852 853 case DeclarationName::CXXLiteralOperatorName: 854 return Context->DeclarationNames.getCXXLiteralOperatorName( 855 (IdentifierInfo*)Key.Data); 856 857 case DeclarationName::CXXUsingDirective: 858 return DeclarationName::getUsingDirectiveName(); 859 } 860 861 llvm_unreachable("Invalid Name Kind ?"); 862 } 863 864 static std::pair<unsigned, unsigned> 865 ReadKeyDataLength(const unsigned char*& d) { 866 using namespace clang::io; 867 unsigned KeyLen = ReadUnalignedLE16(d); 868 unsigned DataLen = ReadUnalignedLE16(d); 869 return std::make_pair(KeyLen, DataLen); 870 } 871 872 internal_key_type ReadKey(const unsigned char* d, unsigned) { 873 using namespace clang::io; 874 875 DeclNameKey Key; 876 Key.Kind = (DeclarationName::NameKind)*d++; 877 switch (Key.Kind) { 878 case DeclarationName::Identifier: 879 Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)); 880 break; 881 case DeclarationName::ObjCZeroArgSelector: 882 case DeclarationName::ObjCOneArgSelector: 883 case DeclarationName::ObjCMultiArgSelector: 884 Key.Data = 885 (uint64_t)Reader.getLocalSelector(F, ReadUnalignedLE32(d)) 886 .getAsOpaquePtr(); 887 break; 888 case DeclarationName::CXXOperatorName: 889 Key.Data = *d++; // OverloadedOperatorKind 890 break; 891 case DeclarationName::CXXLiteralOperatorName: 892 Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)); 893 break; 894 case DeclarationName::CXXConstructorName: 895 case DeclarationName::CXXDestructorName: 896 case DeclarationName::CXXConversionFunctionName: 897 case DeclarationName::CXXUsingDirective: 898 Key.Data = 0; 899 break; 900 } 901 902 return Key; 903 } 904 905 data_type ReadData(internal_key_type, const unsigned char* d, 906 unsigned DataLen) { 907 using namespace clang::io; 908 unsigned NumDecls = ReadUnalignedLE16(d); 909 DeclID *Start = (DeclID *)d; 910 return std::make_pair(Start, Start + NumDecls); 911 } 912}; 913 914} // end anonymous namespace 915 916/// \brief The on-disk hash table used for the DeclContext's Name lookup table. 917typedef OnDiskChainedHashTable<ASTDeclContextNameLookupTrait> 918 ASTDeclContextNameLookupTable; 919 920bool ASTReader::ReadDeclContextStorage(llvm::BitstreamCursor &Cursor, 921 const std::pair<uint64_t, uint64_t> &Offsets, 922 DeclContextInfo &Info) { 923 SavedStreamPosition SavedPosition(Cursor); 924 // First the lexical decls. 925 if (Offsets.first != 0) { 926 Cursor.JumpToBit(Offsets.first); 927 928 RecordData Record; 929 const char *Blob; 930 unsigned BlobLen; 931 unsigned Code = Cursor.ReadCode(); 932 unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen); 933 if (RecCode != DECL_CONTEXT_LEXICAL) { 934 Error("Expected lexical block"); 935 return true; 936 } 937 938 Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair*>(Blob); 939 Info.NumLexicalDecls = BlobLen / sizeof(KindDeclIDPair); 940 } else { 941 Info.LexicalDecls = 0; 942 Info.NumLexicalDecls = 0; 943 } 944 945 // Now the lookup table. 946 if (Offsets.second != 0) { 947 Cursor.JumpToBit(Offsets.second); 948 949 RecordData Record; 950 const char *Blob; 951 unsigned BlobLen; 952 unsigned Code = Cursor.ReadCode(); 953 unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen); 954 if (RecCode != DECL_CONTEXT_VISIBLE) { 955 Error("Expected visible lookup table block"); 956 return true; 957 } 958 Info.NameLookupTableData 959 = ASTDeclContextNameLookupTable::Create( 960 (const unsigned char *)Blob + Record[0], 961 (const unsigned char *)Blob, 962 ASTDeclContextNameLookupTrait(*this, *Info.F)); 963 } else { 964 Info.NameLookupTableData = 0; 965 } 966 967 return false; 968} 969 970void ASTReader::Error(StringRef Msg) { 971 Error(diag::err_fe_pch_malformed, Msg); 972} 973 974void ASTReader::Error(unsigned DiagID, 975 StringRef Arg1, StringRef Arg2) { 976 if (Diags.isDiagnosticInFlight()) 977 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2); 978 else 979 Diag(DiagID) << Arg1 << Arg2; 980} 981 982/// \brief Tell the AST listener about the predefines buffers in the chain. 983bool ASTReader::CheckPredefinesBuffers() { 984 if (Listener) 985 return Listener->ReadPredefinesBuffer(PCHPredefinesBuffers, 986 ActualOriginalFileName, 987 SuggestedPredefines, 988 FileMgr); 989 return false; 990} 991 992//===----------------------------------------------------------------------===// 993// Source Manager Deserialization 994//===----------------------------------------------------------------------===// 995 996/// \brief Read the line table in the source manager block. 997/// \returns true if there was an error. 998bool ASTReader::ParseLineTable(Module &F, 999 SmallVectorImpl<uint64_t> &Record) { 1000 unsigned Idx = 0; 1001 LineTableInfo &LineTable = SourceMgr.getLineTable(); 1002 1003 // Parse the file names 1004 std::map<int, int> FileIDs; 1005 for (int I = 0, N = Record[Idx++]; I != N; ++I) { 1006 // Extract the file name 1007 unsigned FilenameLen = Record[Idx++]; 1008 std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen); 1009 Idx += FilenameLen; 1010 MaybeAddSystemRootToFilename(Filename); 1011 FileIDs[I] = LineTable.getLineTableFilenameID(Filename); 1012 } 1013 1014 // Parse the line entries 1015 std::vector<LineEntry> Entries; 1016 while (Idx < Record.size()) { 1017 int FID = Record[Idx++]; 1018 assert(FID >= 0 && "Serialized line entries for non-local file."); 1019 // Remap FileID from 1-based old view. 1020 FID += F.SLocEntryBaseID - 1; 1021 1022 // Extract the line entries 1023 unsigned NumEntries = Record[Idx++]; 1024 assert(NumEntries && "Numentries is 00000"); 1025 Entries.clear(); 1026 Entries.reserve(NumEntries); 1027 for (unsigned I = 0; I != NumEntries; ++I) { 1028 unsigned FileOffset = Record[Idx++]; 1029 unsigned LineNo = Record[Idx++]; 1030 int FilenameID = FileIDs[Record[Idx++]]; 1031 SrcMgr::CharacteristicKind FileKind 1032 = (SrcMgr::CharacteristicKind)Record[Idx++]; 1033 unsigned IncludeOffset = Record[Idx++]; 1034 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID, 1035 FileKind, IncludeOffset)); 1036 } 1037 LineTable.AddEntry(FID, Entries); 1038 } 1039 1040 return false; 1041} 1042 1043namespace { 1044 1045class ASTStatData { 1046public: 1047 const ino_t ino; 1048 const dev_t dev; 1049 const mode_t mode; 1050 const time_t mtime; 1051 const off_t size; 1052 1053 ASTStatData(ino_t i, dev_t d, mode_t mo, time_t m, off_t s) 1054 : ino(i), dev(d), mode(mo), mtime(m), size(s) {} 1055}; 1056 1057class ASTStatLookupTrait { 1058 public: 1059 typedef const char *external_key_type; 1060 typedef const char *internal_key_type; 1061 1062 typedef ASTStatData data_type; 1063 1064 static unsigned ComputeHash(const char *path) { 1065 return llvm::HashString(path); 1066 } 1067 1068 static internal_key_type GetInternalKey(const char *path) { return path; } 1069 1070 static bool EqualKey(internal_key_type a, internal_key_type b) { 1071 return strcmp(a, b) == 0; 1072 } 1073 1074 static std::pair<unsigned, unsigned> 1075 ReadKeyDataLength(const unsigned char*& d) { 1076 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d); 1077 unsigned DataLen = (unsigned) *d++; 1078 return std::make_pair(KeyLen + 1, DataLen); 1079 } 1080 1081 static internal_key_type ReadKey(const unsigned char *d, unsigned) { 1082 return (const char *)d; 1083 } 1084 1085 static data_type ReadData(const internal_key_type, const unsigned char *d, 1086 unsigned /*DataLen*/) { 1087 using namespace clang::io; 1088 1089 ino_t ino = (ino_t) ReadUnalignedLE32(d); 1090 dev_t dev = (dev_t) ReadUnalignedLE32(d); 1091 mode_t mode = (mode_t) ReadUnalignedLE16(d); 1092 time_t mtime = (time_t) ReadUnalignedLE64(d); 1093 off_t size = (off_t) ReadUnalignedLE64(d); 1094 return data_type(ino, dev, mode, mtime, size); 1095 } 1096}; 1097 1098/// \brief stat() cache for precompiled headers. 1099/// 1100/// This cache is very similar to the stat cache used by pretokenized 1101/// headers. 1102class ASTStatCache : public FileSystemStatCache { 1103 typedef OnDiskChainedHashTable<ASTStatLookupTrait> CacheTy; 1104 CacheTy *Cache; 1105 1106 unsigned &NumStatHits, &NumStatMisses; 1107public: 1108 ASTStatCache(const unsigned char *Buckets, const unsigned char *Base, 1109 unsigned &NumStatHits, unsigned &NumStatMisses) 1110 : Cache(0), NumStatHits(NumStatHits), NumStatMisses(NumStatMisses) { 1111 Cache = CacheTy::Create(Buckets, Base); 1112 } 1113 1114 ~ASTStatCache() { delete Cache; } 1115 1116 LookupResult getStat(const char *Path, struct stat &StatBuf, 1117 int *FileDescriptor) { 1118 // Do the lookup for the file's data in the AST file. 1119 CacheTy::iterator I = Cache->find(Path); 1120 1121 // If we don't get a hit in the AST file just forward to 'stat'. 1122 if (I == Cache->end()) { 1123 ++NumStatMisses; 1124 return statChained(Path, StatBuf, FileDescriptor); 1125 } 1126 1127 ++NumStatHits; 1128 ASTStatData Data = *I; 1129 1130 StatBuf.st_ino = Data.ino; 1131 StatBuf.st_dev = Data.dev; 1132 StatBuf.st_mtime = Data.mtime; 1133 StatBuf.st_mode = Data.mode; 1134 StatBuf.st_size = Data.size; 1135 return CacheExists; 1136 } 1137}; 1138} // end anonymous namespace 1139 1140 1141/// \brief Read a source manager block 1142ASTReader::ASTReadResult ASTReader::ReadSourceManagerBlock(Module &F) { 1143 using namespace SrcMgr; 1144 1145 llvm::BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor; 1146 1147 // Set the source-location entry cursor to the current position in 1148 // the stream. This cursor will be used to read the contents of the 1149 // source manager block initially, and then lazily read 1150 // source-location entries as needed. 1151 SLocEntryCursor = F.Stream; 1152 1153 // The stream itself is going to skip over the source manager block. 1154 if (F.Stream.SkipBlock()) { 1155 Error("malformed block record in AST file"); 1156 return Failure; 1157 } 1158 1159 // Enter the source manager block. 1160 if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) { 1161 Error("malformed source manager block record in AST file"); 1162 return Failure; 1163 } 1164 1165 RecordData Record; 1166 while (true) { 1167 unsigned Code = SLocEntryCursor.ReadCode(); 1168 if (Code == llvm::bitc::END_BLOCK) { 1169 if (SLocEntryCursor.ReadBlockEnd()) { 1170 Error("error at end of Source Manager block in AST file"); 1171 return Failure; 1172 } 1173 return Success; 1174 } 1175 1176 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1177 // No known subblocks, always skip them. 1178 SLocEntryCursor.ReadSubBlockID(); 1179 if (SLocEntryCursor.SkipBlock()) { 1180 Error("malformed block record in AST file"); 1181 return Failure; 1182 } 1183 continue; 1184 } 1185 1186 if (Code == llvm::bitc::DEFINE_ABBREV) { 1187 SLocEntryCursor.ReadAbbrevRecord(); 1188 continue; 1189 } 1190 1191 // Read a record. 1192 const char *BlobStart; 1193 unsigned BlobLen; 1194 Record.clear(); 1195 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 1196 default: // Default behavior: ignore. 1197 break; 1198 1199 case SM_SLOC_FILE_ENTRY: 1200 case SM_SLOC_BUFFER_ENTRY: 1201 case SM_SLOC_EXPANSION_ENTRY: 1202 // Once we hit one of the source location entries, we're done. 1203 return Success; 1204 } 1205 } 1206} 1207 1208/// \brief If a header file is not found at the path that we expect it to be 1209/// and the PCH file was moved from its original location, try to resolve the 1210/// file by assuming that header+PCH were moved together and the header is in 1211/// the same place relative to the PCH. 1212static std::string 1213resolveFileRelativeToOriginalDir(const std::string &Filename, 1214 const std::string &OriginalDir, 1215 const std::string &CurrDir) { 1216 assert(OriginalDir != CurrDir && 1217 "No point trying to resolve the file if the PCH dir didn't change"); 1218 using namespace llvm::sys; 1219 llvm::SmallString<128> filePath(Filename); 1220 fs::make_absolute(filePath); 1221 assert(path::is_absolute(OriginalDir)); 1222 llvm::SmallString<128> currPCHPath(CurrDir); 1223 1224 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)), 1225 fileDirE = path::end(path::parent_path(filePath)); 1226 path::const_iterator origDirI = path::begin(OriginalDir), 1227 origDirE = path::end(OriginalDir); 1228 // Skip the common path components from filePath and OriginalDir. 1229 while (fileDirI != fileDirE && origDirI != origDirE && 1230 *fileDirI == *origDirI) { 1231 ++fileDirI; 1232 ++origDirI; 1233 } 1234 for (; origDirI != origDirE; ++origDirI) 1235 path::append(currPCHPath, ".."); 1236 path::append(currPCHPath, fileDirI, fileDirE); 1237 path::append(currPCHPath, path::filename(Filename)); 1238 return currPCHPath.str(); 1239} 1240 1241/// \brief Read in the source location entry with the given ID. 1242ASTReader::ASTReadResult ASTReader::ReadSLocEntryRecord(int ID) { 1243 if (ID == 0) 1244 return Success; 1245 1246 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) { 1247 Error("source location entry ID out-of-range for AST file"); 1248 return Failure; 1249 } 1250 1251 Module *F = GlobalSLocEntryMap.find(-ID)->second; 1252 F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]); 1253 llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor; 1254 unsigned BaseOffset = F->SLocEntryBaseOffset; 1255 1256 ++NumSLocEntriesRead; 1257 unsigned Code = SLocEntryCursor.ReadCode(); 1258 if (Code == llvm::bitc::END_BLOCK || 1259 Code == llvm::bitc::ENTER_SUBBLOCK || 1260 Code == llvm::bitc::DEFINE_ABBREV) { 1261 Error("incorrectly-formatted source location entry in AST file"); 1262 return Failure; 1263 } 1264 1265 RecordData Record; 1266 const char *BlobStart; 1267 unsigned BlobLen; 1268 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 1269 default: 1270 Error("incorrectly-formatted source location entry in AST file"); 1271 return Failure; 1272 1273 case SM_SLOC_FILE_ENTRY: { 1274 std::string Filename(BlobStart, BlobStart + BlobLen); 1275 MaybeAddSystemRootToFilename(Filename); 1276 const FileEntry *File = FileMgr.getFile(Filename); 1277 if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() && 1278 OriginalDir != CurrentDir) { 1279 std::string resolved = resolveFileRelativeToOriginalDir(Filename, 1280 OriginalDir, 1281 CurrentDir); 1282 if (!resolved.empty()) 1283 File = FileMgr.getFile(resolved); 1284 } 1285 if (File == 0) 1286 File = FileMgr.getVirtualFile(Filename, (off_t)Record[4], 1287 (time_t)Record[5]); 1288 if (File == 0) { 1289 std::string ErrorStr = "could not find file '"; 1290 ErrorStr += Filename; 1291 ErrorStr += "' referenced by AST file"; 1292 Error(ErrorStr.c_str()); 1293 return Failure; 1294 } 1295 1296 if (Record.size() < 6) { 1297 Error("source location entry is incorrect"); 1298 return Failure; 1299 } 1300 1301 if (!DisableValidation && 1302 ((off_t)Record[4] != File->getSize() 1303#if !defined(LLVM_ON_WIN32) 1304 // In our regression testing, the Windows file system seems to 1305 // have inconsistent modification times that sometimes 1306 // erroneously trigger this error-handling path. 1307 || (time_t)Record[5] != File->getModificationTime() 1308#endif 1309 )) { 1310 Error(diag::err_fe_pch_file_modified, Filename); 1311 return Failure; 1312 } 1313 1314 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]); 1315 if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) { 1316 // This is the module's main file. 1317 IncludeLoc = getImportLocation(F); 1318 } 1319 FileID FID = SourceMgr.createFileID(File, IncludeLoc, 1320 (SrcMgr::CharacteristicKind)Record[2], 1321 ID, BaseOffset + Record[0]); 1322 if (Record[3]) 1323 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile()) 1324 .setHasLineDirectives(); 1325 1326 break; 1327 } 1328 1329 case SM_SLOC_BUFFER_ENTRY: { 1330 const char *Name = BlobStart; 1331 unsigned Offset = Record[0]; 1332 unsigned Code = SLocEntryCursor.ReadCode(); 1333 Record.clear(); 1334 unsigned RecCode 1335 = SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen); 1336 1337 if (RecCode != SM_SLOC_BUFFER_BLOB) { 1338 Error("AST record has invalid code"); 1339 return Failure; 1340 } 1341 1342 llvm::MemoryBuffer *Buffer 1343 = llvm::MemoryBuffer::getMemBuffer(StringRef(BlobStart, BlobLen - 1), 1344 Name); 1345 FileID BufferID = SourceMgr.createFileIDForMemBuffer(Buffer, ID, 1346 BaseOffset + Offset); 1347 1348 if (strcmp(Name, "<built-in>") == 0) { 1349 PCHPredefinesBlock Block = { 1350 BufferID, 1351 StringRef(BlobStart, BlobLen - 1) 1352 }; 1353 PCHPredefinesBuffers.push_back(Block); 1354 } 1355 1356 break; 1357 } 1358 1359 case SM_SLOC_EXPANSION_ENTRY: { 1360 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]); 1361 SourceMgr.createExpansionLoc(SpellingLoc, 1362 ReadSourceLocation(*F, Record[2]), 1363 ReadSourceLocation(*F, Record[3]), 1364 Record[4], 1365 ID, 1366 BaseOffset + Record[0]); 1367 break; 1368 } 1369 } 1370 1371 return Success; 1372} 1373 1374/// \brief Find the location where the module F is imported. 1375SourceLocation ASTReader::getImportLocation(Module *F) { 1376 if (F->ImportLoc.isValid()) 1377 return F->ImportLoc; 1378 1379 // Otherwise we have a PCH. It's considered to be "imported" at the first 1380 // location of its includer. 1381 if (F->ImportedBy.empty() || !F->ImportedBy[0]) { 1382 // Main file is the importer. We assume that it is the first entry in the 1383 // entry table. We can't ask the manager, because at the time of PCH loading 1384 // the main file entry doesn't exist yet. 1385 // The very first entry is the invalid instantiation loc, which takes up 1386 // offsets 0 and 1. 1387 return SourceLocation::getFromRawEncoding(2U); 1388 } 1389 //return F->Loaders[0]->FirstLoc; 1390 return F->ImportedBy[0]->FirstLoc; 1391} 1392 1393/// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the 1394/// specified cursor. Read the abbreviations that are at the top of the block 1395/// and then leave the cursor pointing into the block. 1396bool ASTReader::ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor, 1397 unsigned BlockID) { 1398 if (Cursor.EnterSubBlock(BlockID)) { 1399 Error("malformed block record in AST file"); 1400 return Failure; 1401 } 1402 1403 while (true) { 1404 uint64_t Offset = Cursor.GetCurrentBitNo(); 1405 unsigned Code = Cursor.ReadCode(); 1406 1407 // We expect all abbrevs to be at the start of the block. 1408 if (Code != llvm::bitc::DEFINE_ABBREV) { 1409 Cursor.JumpToBit(Offset); 1410 return false; 1411 } 1412 Cursor.ReadAbbrevRecord(); 1413 } 1414} 1415 1416void ASTReader::ReadMacroRecord(Module &F, uint64_t Offset) { 1417 assert(PP && "Forgot to set Preprocessor ?"); 1418 llvm::BitstreamCursor &Stream = F.MacroCursor; 1419 1420 // Keep track of where we are in the stream, then jump back there 1421 // after reading this macro. 1422 SavedStreamPosition SavedPosition(Stream); 1423 1424 Stream.JumpToBit(Offset); 1425 RecordData Record; 1426 SmallVector<IdentifierInfo*, 16> MacroArgs; 1427 MacroInfo *Macro = 0; 1428 1429 while (true) { 1430 unsigned Code = Stream.ReadCode(); 1431 switch (Code) { 1432 case llvm::bitc::END_BLOCK: 1433 return; 1434 1435 case llvm::bitc::ENTER_SUBBLOCK: 1436 // No known subblocks, always skip them. 1437 Stream.ReadSubBlockID(); 1438 if (Stream.SkipBlock()) { 1439 Error("malformed block record in AST file"); 1440 return; 1441 } 1442 continue; 1443 1444 case llvm::bitc::DEFINE_ABBREV: 1445 Stream.ReadAbbrevRecord(); 1446 continue; 1447 default: break; 1448 } 1449 1450 // Read a record. 1451 const char *BlobStart = 0; 1452 unsigned BlobLen = 0; 1453 Record.clear(); 1454 PreprocessorRecordTypes RecType = 1455 (PreprocessorRecordTypes)Stream.ReadRecord(Code, Record, BlobStart, 1456 BlobLen); 1457 switch (RecType) { 1458 case PP_MACRO_OBJECT_LIKE: 1459 case PP_MACRO_FUNCTION_LIKE: { 1460 // If we already have a macro, that means that we've hit the end 1461 // of the definition of the macro we were looking for. We're 1462 // done. 1463 if (Macro) 1464 return; 1465 1466 IdentifierInfo *II = getLocalIdentifier(F, Record[0]); 1467 if (II == 0) { 1468 Error("macro must have a name in AST file"); 1469 return; 1470 } 1471 SourceLocation Loc = ReadSourceLocation(F, Record[1]); 1472 bool isUsed = Record[2]; 1473 1474 MacroInfo *MI = PP->AllocateMacroInfo(Loc); 1475 MI->setIsUsed(isUsed); 1476 MI->setIsFromAST(); 1477 1478 unsigned NextIndex = 3; 1479 if (RecType == PP_MACRO_FUNCTION_LIKE) { 1480 // Decode function-like macro info. 1481 bool isC99VarArgs = Record[3]; 1482 bool isGNUVarArgs = Record[4]; 1483 MacroArgs.clear(); 1484 unsigned NumArgs = Record[5]; 1485 NextIndex = 6 + NumArgs; 1486 for (unsigned i = 0; i != NumArgs; ++i) 1487 MacroArgs.push_back(getLocalIdentifier(F, Record[6+i])); 1488 1489 // Install function-like macro info. 1490 MI->setIsFunctionLike(); 1491 if (isC99VarArgs) MI->setIsC99Varargs(); 1492 if (isGNUVarArgs) MI->setIsGNUVarargs(); 1493 MI->setArgumentList(MacroArgs.data(), MacroArgs.size(), 1494 PP->getPreprocessorAllocator()); 1495 } 1496 1497 // Finally, install the macro. 1498 PP->setMacroInfo(II, MI); 1499 1500 // Remember that we saw this macro last so that we add the tokens that 1501 // form its body to it. 1502 Macro = MI; 1503 1504 if (NextIndex + 1 == Record.size() && PP->getPreprocessingRecord()) { 1505 // We have a macro definition. Load it now. 1506 PP->getPreprocessingRecord()->RegisterMacroDefinition(Macro, 1507 getLocalMacroDefinition(F, Record[NextIndex])); 1508 } 1509 1510 ++NumMacrosRead; 1511 break; 1512 } 1513 1514 case PP_TOKEN: { 1515 // If we see a TOKEN before a PP_MACRO_*, then the file is 1516 // erroneous, just pretend we didn't see this. 1517 if (Macro == 0) break; 1518 1519 Token Tok; 1520 Tok.startToken(); 1521 Tok.setLocation(ReadSourceLocation(F, Record[0])); 1522 Tok.setLength(Record[1]); 1523 if (IdentifierInfo *II = getLocalIdentifier(F, Record[2])) 1524 Tok.setIdentifierInfo(II); 1525 Tok.setKind((tok::TokenKind)Record[3]); 1526 Tok.setFlag((Token::TokenFlags)Record[4]); 1527 Macro->AddTokenToBody(Tok); 1528 break; 1529 } 1530 } 1531 } 1532 1533 return; 1534} 1535 1536PreprocessedEntity *ASTReader::LoadPreprocessedEntity(Module &F) { 1537 assert(PP && "Forgot to set Preprocessor ?"); 1538 unsigned Code = F.PreprocessorDetailCursor.ReadCode(); 1539 switch (Code) { 1540 case llvm::bitc::END_BLOCK: 1541 return 0; 1542 1543 case llvm::bitc::ENTER_SUBBLOCK: 1544 Error("unexpected subblock record in preprocessor detail block"); 1545 return 0; 1546 1547 case llvm::bitc::DEFINE_ABBREV: 1548 Error("unexpected abbrevation record in preprocessor detail block"); 1549 return 0; 1550 1551 default: 1552 break; 1553 } 1554 1555 if (!PP->getPreprocessingRecord()) { 1556 Error("no preprocessing record"); 1557 return 0; 1558 } 1559 1560 // Read the record. 1561 PreprocessingRecord &PPRec = *PP->getPreprocessingRecord(); 1562 const char *BlobStart = 0; 1563 unsigned BlobLen = 0; 1564 RecordData Record; 1565 PreprocessorDetailRecordTypes RecType = 1566 (PreprocessorDetailRecordTypes)F.PreprocessorDetailCursor.ReadRecord( 1567 Code, Record, BlobStart, BlobLen); 1568 switch (RecType) { 1569 case PPD_MACRO_EXPANSION: { 1570 PreprocessedEntityID GlobalID = getGlobalPreprocessedEntityID(F, Record[0]); 1571 if (PreprocessedEntity *PE = PPRec.getLoadedPreprocessedEntity(GlobalID-1)) 1572 return PE; 1573 1574 MacroExpansion *ME = 1575 new (PPRec) MacroExpansion(getLocalIdentifier(F, Record[3]), 1576 SourceRange(ReadSourceLocation(F, Record[1]), 1577 ReadSourceLocation(F, Record[2])), 1578 getLocalMacroDefinition(F, Record[4])); 1579 PPRec.setLoadedPreallocatedEntity(GlobalID - 1, ME); 1580 return ME; 1581 } 1582 1583 case PPD_MACRO_DEFINITION: { 1584 PreprocessedEntityID GlobalID = getGlobalPreprocessedEntityID(F, Record[0]); 1585 if (PreprocessedEntity *PE = PPRec.getLoadedPreprocessedEntity(GlobalID-1)) 1586 return PE; 1587 1588 unsigned MacroDefID = getGlobalMacroDefinitionID(F, Record[1]); 1589 if (MacroDefID > MacroDefinitionsLoaded.size()) { 1590 Error("out-of-bounds macro definition record"); 1591 return 0; 1592 } 1593 1594 // Decode the identifier info and then check again; if the macro is 1595 // still defined and associated with the identifier, 1596 IdentifierInfo *II = getLocalIdentifier(F, Record[4]); 1597 if (!MacroDefinitionsLoaded[MacroDefID - 1]) { 1598 MacroDefinition *MD 1599 = new (PPRec) MacroDefinition(II, 1600 ReadSourceLocation(F, Record[5]), 1601 SourceRange( 1602 ReadSourceLocation(F, Record[2]), 1603 ReadSourceLocation(F, Record[3]))); 1604 1605 PPRec.setLoadedPreallocatedEntity(GlobalID - 1, MD); 1606 MacroDefinitionsLoaded[MacroDefID - 1] = MD; 1607 1608 if (DeserializationListener) 1609 DeserializationListener->MacroDefinitionRead(MacroDefID, MD); 1610 } 1611 1612 return MacroDefinitionsLoaded[MacroDefID - 1]; 1613 } 1614 1615 case PPD_INCLUSION_DIRECTIVE: { 1616 PreprocessedEntityID GlobalID = getGlobalPreprocessedEntityID(F, Record[0]); 1617 if (PreprocessedEntity *PE = PPRec.getLoadedPreprocessedEntity(GlobalID-1)) 1618 return PE; 1619 1620 const char *FullFileNameStart = BlobStart + Record[3]; 1621 const FileEntry *File 1622 = PP->getFileManager().getFile(StringRef(FullFileNameStart, 1623 BlobLen - Record[3])); 1624 1625 // FIXME: Stable encoding 1626 InclusionDirective::InclusionKind Kind 1627 = static_cast<InclusionDirective::InclusionKind>(Record[5]); 1628 InclusionDirective *ID 1629 = new (PPRec) InclusionDirective(PPRec, Kind, 1630 StringRef(BlobStart, Record[3]), 1631 Record[4], 1632 File, 1633 SourceRange(ReadSourceLocation(F, Record[1]), 1634 ReadSourceLocation(F, Record[2]))); 1635 PPRec.setLoadedPreallocatedEntity(GlobalID - 1, ID); 1636 return ID; 1637 } 1638 } 1639 1640 Error("invalid offset in preprocessor detail block"); 1641 return 0; 1642} 1643 1644PreprocessedEntityID 1645ASTReader::getGlobalPreprocessedEntityID(Module &M, unsigned LocalID) { 1646 ContinuousRangeMap<uint32_t, int, 2>::iterator 1647 I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS); 1648 assert(I != M.PreprocessedEntityRemap.end() 1649 && "Invalid index into preprocessed entity index remap"); 1650 1651 return LocalID + I->second; 1652} 1653 1654namespace { 1655 /// \brief Trait class used to search the on-disk hash table containing all of 1656 /// the header search information. 1657 /// 1658 /// The on-disk hash table contains a mapping from each header path to 1659 /// information about that header (how many times it has been included, its 1660 /// controlling macro, etc.). Note that we actually hash based on the 1661 /// filename, and support "deep" comparisons of file names based on current 1662 /// inode numbers, so that the search can cope with non-normalized path names 1663 /// and symlinks. 1664 class HeaderFileInfoTrait { 1665 ASTReader &Reader; 1666 Module &M; 1667 HeaderSearch *HS; 1668 const char *FrameworkStrings; 1669 const char *SearchPath; 1670 struct stat SearchPathStatBuf; 1671 llvm::Optional<int> SearchPathStatResult; 1672 1673 int StatSimpleCache(const char *Path, struct stat *StatBuf) { 1674 if (Path == SearchPath) { 1675 if (!SearchPathStatResult) 1676 SearchPathStatResult = stat(Path, &SearchPathStatBuf); 1677 1678 *StatBuf = SearchPathStatBuf; 1679 return *SearchPathStatResult; 1680 } 1681 1682 return stat(Path, StatBuf); 1683 } 1684 1685 public: 1686 typedef const char *external_key_type; 1687 typedef const char *internal_key_type; 1688 1689 typedef HeaderFileInfo data_type; 1690 1691 HeaderFileInfoTrait(ASTReader &Reader, Module &M, HeaderSearch *HS, 1692 const char *FrameworkStrings, 1693 const char *SearchPath = 0) 1694 : Reader(Reader), M(M), HS(HS), FrameworkStrings(FrameworkStrings), 1695 SearchPath(SearchPath) { } 1696 1697 static unsigned ComputeHash(const char *path) { 1698 return llvm::HashString(llvm::sys::path::filename(path)); 1699 } 1700 1701 static internal_key_type GetInternalKey(const char *path) { return path; } 1702 1703 bool EqualKey(internal_key_type a, internal_key_type b) { 1704 if (strcmp(a, b) == 0) 1705 return true; 1706 1707 if (llvm::sys::path::filename(a) != llvm::sys::path::filename(b)) 1708 return false; 1709 1710 // The file names match, but the path names don't. stat() the files to 1711 // see if they are the same. 1712 struct stat StatBufA, StatBufB; 1713 if (StatSimpleCache(a, &StatBufA) || StatSimpleCache(b, &StatBufB)) 1714 return false; 1715 1716 return StatBufA.st_ino == StatBufB.st_ino; 1717 } 1718 1719 static std::pair<unsigned, unsigned> 1720 ReadKeyDataLength(const unsigned char*& d) { 1721 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d); 1722 unsigned DataLen = (unsigned) *d++; 1723 return std::make_pair(KeyLen + 1, DataLen); 1724 } 1725 1726 static internal_key_type ReadKey(const unsigned char *d, unsigned) { 1727 return (const char *)d; 1728 } 1729 1730 data_type ReadData(const internal_key_type, const unsigned char *d, 1731 unsigned DataLen) { 1732 const unsigned char *End = d + DataLen; 1733 using namespace clang::io; 1734 HeaderFileInfo HFI; 1735 unsigned Flags = *d++; 1736 HFI.isImport = (Flags >> 5) & 0x01; 1737 HFI.isPragmaOnce = (Flags >> 4) & 0x01; 1738 HFI.DirInfo = (Flags >> 2) & 0x03; 1739 HFI.Resolved = (Flags >> 1) & 0x01; 1740 HFI.IndexHeaderMapHeader = Flags & 0x01; 1741 HFI.NumIncludes = ReadUnalignedLE16(d); 1742 HFI.ControllingMacroID = Reader.getGlobalDeclID(M, ReadUnalignedLE32(d)); 1743 if (unsigned FrameworkOffset = ReadUnalignedLE32(d)) { 1744 // The framework offset is 1 greater than the actual offset, 1745 // since 0 is used as an indicator for "no framework name". 1746 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1); 1747 HFI.Framework = HS->getUniqueFrameworkName(FrameworkName); 1748 } 1749 1750 assert(End == d && "Wrong data length in HeaderFileInfo deserialization"); 1751 (void)End; 1752 1753 // This HeaderFileInfo was externally loaded. 1754 HFI.External = true; 1755 return HFI; 1756 } 1757 }; 1758} 1759 1760/// \brief The on-disk hash table used for the global method pool. 1761typedef OnDiskChainedHashTable<HeaderFileInfoTrait> 1762 HeaderFileInfoLookupTable; 1763 1764void ASTReader::SetIdentifierIsMacro(IdentifierInfo *II, Module &F, 1765 uint64_t LocalOffset) { 1766 // Note that this identifier has a macro definition. 1767 II->setHasMacroDefinition(true); 1768 1769 // Adjust the offset to a global offset. 1770 UnreadMacroRecordOffsets[II] = F.GlobalBitOffset + LocalOffset; 1771} 1772 1773void ASTReader::ReadDefinedMacros() { 1774 for (ModuleReverseIterator I = ModuleMgr.rbegin(), 1775 E = ModuleMgr.rend(); I != E; ++I) { 1776 llvm::BitstreamCursor &MacroCursor = (*I)->MacroCursor; 1777 1778 // If there was no preprocessor block, skip this file. 1779 if (!MacroCursor.getBitStreamReader()) 1780 continue; 1781 1782 llvm::BitstreamCursor Cursor = MacroCursor; 1783 Cursor.JumpToBit((*I)->MacroStartOffset); 1784 1785 RecordData Record; 1786 while (true) { 1787 unsigned Code = Cursor.ReadCode(); 1788 if (Code == llvm::bitc::END_BLOCK) 1789 break; 1790 1791 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1792 // No known subblocks, always skip them. 1793 Cursor.ReadSubBlockID(); 1794 if (Cursor.SkipBlock()) { 1795 Error("malformed block record in AST file"); 1796 return; 1797 } 1798 continue; 1799 } 1800 1801 if (Code == llvm::bitc::DEFINE_ABBREV) { 1802 Cursor.ReadAbbrevRecord(); 1803 continue; 1804 } 1805 1806 // Read a record. 1807 const char *BlobStart; 1808 unsigned BlobLen; 1809 Record.clear(); 1810 switch (Cursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 1811 default: // Default behavior: ignore. 1812 break; 1813 1814 case PP_MACRO_OBJECT_LIKE: 1815 case PP_MACRO_FUNCTION_LIKE: 1816 getLocalIdentifier(**I, Record[0]); 1817 break; 1818 1819 case PP_TOKEN: 1820 // Ignore tokens. 1821 break; 1822 } 1823 } 1824 } 1825 1826 // Drain the unread macro-record offsets map. 1827 while (!UnreadMacroRecordOffsets.empty()) 1828 LoadMacroDefinition(UnreadMacroRecordOffsets.begin()); 1829} 1830 1831void ASTReader::LoadMacroDefinition( 1832 llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos) { 1833 assert(Pos != UnreadMacroRecordOffsets.end() && "Unknown macro definition"); 1834 uint64_t Offset = Pos->second; 1835 UnreadMacroRecordOffsets.erase(Pos); 1836 1837 RecordLocation Loc = getLocalBitOffset(Offset); 1838 ReadMacroRecord(*Loc.F, Loc.Offset); 1839} 1840 1841void ASTReader::LoadMacroDefinition(IdentifierInfo *II) { 1842 llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos 1843 = UnreadMacroRecordOffsets.find(II); 1844 LoadMacroDefinition(Pos); 1845} 1846 1847MacroDefinition *ASTReader::getMacroDefinition(MacroID ID) { 1848 if (ID == 0 || ID > MacroDefinitionsLoaded.size()) 1849 return 0; 1850 1851 if (!MacroDefinitionsLoaded[ID - 1]) { 1852 GlobalMacroDefinitionMapType::iterator I =GlobalMacroDefinitionMap.find(ID); 1853 assert(I != GlobalMacroDefinitionMap.end() && 1854 "Corrupted global macro definition map"); 1855 Module &M = *I->second; 1856 unsigned Index = ID - 1 - M.BaseMacroDefinitionID; 1857 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor); 1858 M.PreprocessorDetailCursor.JumpToBit(M.MacroDefinitionOffsets[Index]); 1859 LoadPreprocessedEntity(M); 1860 } 1861 1862 return MacroDefinitionsLoaded[ID - 1]; 1863} 1864 1865const FileEntry *ASTReader::getFileEntry(StringRef filenameStrRef) { 1866 std::string Filename = filenameStrRef; 1867 MaybeAddSystemRootToFilename(Filename); 1868 const FileEntry *File = FileMgr.getFile(Filename); 1869 if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() && 1870 OriginalDir != CurrentDir) { 1871 std::string resolved = resolveFileRelativeToOriginalDir(Filename, 1872 OriginalDir, 1873 CurrentDir); 1874 if (!resolved.empty()) 1875 File = FileMgr.getFile(resolved); 1876 } 1877 1878 return File; 1879} 1880 1881MacroID ASTReader::getGlobalMacroDefinitionID(Module &M, unsigned LocalID) { 1882 if (LocalID < NUM_PREDEF_MACRO_IDS) 1883 return LocalID; 1884 1885 ContinuousRangeMap<uint32_t, int, 2>::iterator I 1886 = M.MacroDefinitionRemap.find(LocalID - NUM_PREDEF_MACRO_IDS); 1887 assert(I != M.MacroDefinitionRemap.end() && 1888 "Invalid index into macro definition ID remap"); 1889 1890 return LocalID + I->second; 1891} 1892 1893/// \brief If we are loading a relocatable PCH file, and the filename is 1894/// not an absolute path, add the system root to the beginning of the file 1895/// name. 1896void ASTReader::MaybeAddSystemRootToFilename(std::string &Filename) { 1897 // If this is not a relocatable PCH file, there's nothing to do. 1898 if (!RelocatablePCH) 1899 return; 1900 1901 if (Filename.empty() || llvm::sys::path::is_absolute(Filename)) 1902 return; 1903 1904 if (isysroot.empty()) { 1905 // If no system root was given, default to '/' 1906 Filename.insert(Filename.begin(), '/'); 1907 return; 1908 } 1909 1910 unsigned Length = isysroot.size(); 1911 if (isysroot[Length - 1] != '/') 1912 Filename.insert(Filename.begin(), '/'); 1913 1914 Filename.insert(Filename.begin(), isysroot.begin(), isysroot.end()); 1915} 1916 1917ASTReader::ASTReadResult 1918ASTReader::ReadASTBlock(Module &F) { 1919 llvm::BitstreamCursor &Stream = F.Stream; 1920 1921 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 1922 Error("malformed block record in AST file"); 1923 return Failure; 1924 } 1925 1926 // Read all of the records and blocks for the ASt file. 1927 RecordData Record; 1928 bool First = true; 1929 while (!Stream.AtEndOfStream()) { 1930 unsigned Code = Stream.ReadCode(); 1931 if (Code == llvm::bitc::END_BLOCK) { 1932 if (Stream.ReadBlockEnd()) { 1933 Error("error at end of module block in AST file"); 1934 return Failure; 1935 } 1936 1937 return Success; 1938 } 1939 1940 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1941 switch (Stream.ReadSubBlockID()) { 1942 case DECLTYPES_BLOCK_ID: 1943 // We lazily load the decls block, but we want to set up the 1944 // DeclsCursor cursor to point into it. Clone our current bitcode 1945 // cursor to it, enter the block and read the abbrevs in that block. 1946 // With the main cursor, we just skip over it. 1947 F.DeclsCursor = Stream; 1948 if (Stream.SkipBlock() || // Skip with the main cursor. 1949 // Read the abbrevs. 1950 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) { 1951 Error("malformed block record in AST file"); 1952 return Failure; 1953 } 1954 break; 1955 1956 case DECL_UPDATES_BLOCK_ID: 1957 if (Stream.SkipBlock()) { 1958 Error("malformed block record in AST file"); 1959 return Failure; 1960 } 1961 break; 1962 1963 case PREPROCESSOR_BLOCK_ID: 1964 F.MacroCursor = Stream; 1965 if (PP) 1966 PP->setExternalSource(this); 1967 1968 if (Stream.SkipBlock() || 1969 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) { 1970 Error("malformed block record in AST file"); 1971 return Failure; 1972 } 1973 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo(); 1974 break; 1975 1976 case PREPROCESSOR_DETAIL_BLOCK_ID: 1977 F.PreprocessorDetailCursor = Stream; 1978 if (Stream.SkipBlock() || 1979 ReadBlockAbbrevs(F.PreprocessorDetailCursor, 1980 PREPROCESSOR_DETAIL_BLOCK_ID)) { 1981 Error("malformed preprocessor detail record in AST file"); 1982 return Failure; 1983 } 1984 F.PreprocessorDetailStartOffset 1985 = F.PreprocessorDetailCursor.GetCurrentBitNo(); 1986 break; 1987 1988 case SOURCE_MANAGER_BLOCK_ID: 1989 switch (ReadSourceManagerBlock(F)) { 1990 case Success: 1991 break; 1992 1993 case Failure: 1994 Error("malformed source manager block in AST file"); 1995 return Failure; 1996 1997 case IgnorePCH: 1998 return IgnorePCH; 1999 } 2000 break; 2001 } 2002 First = false; 2003 continue; 2004 } 2005 2006 if (Code == llvm::bitc::DEFINE_ABBREV) { 2007 Stream.ReadAbbrevRecord(); 2008 continue; 2009 } 2010 2011 // Read and process a record. 2012 Record.clear(); 2013 const char *BlobStart = 0; 2014 unsigned BlobLen = 0; 2015 switch ((ASTRecordTypes)Stream.ReadRecord(Code, Record, 2016 &BlobStart, &BlobLen)) { 2017 default: // Default behavior: ignore. 2018 break; 2019 2020 case METADATA: { 2021 if (Record[0] != VERSION_MAJOR && !DisableValidation) { 2022 Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old 2023 : diag::warn_pch_version_too_new); 2024 return IgnorePCH; 2025 } 2026 2027 RelocatablePCH = Record[4]; 2028 if (Listener) { 2029 std::string TargetTriple(BlobStart, BlobLen); 2030 if (Listener->ReadTargetTriple(TargetTriple)) 2031 return IgnorePCH; 2032 } 2033 break; 2034 } 2035 2036 case IMPORTS: { 2037 // Load each of the imported PCH files. 2038 unsigned Idx = 0, N = Record.size(); 2039 while (Idx < N) { 2040 // Read information about the AST file. 2041 ModuleKind ImportedKind = (ModuleKind)Record[Idx++]; 2042 unsigned Length = Record[Idx++]; 2043 llvm::SmallString<128> ImportedFile(Record.begin() + Idx, 2044 Record.begin() + Idx + Length); 2045 Idx += Length; 2046 2047 // Load the AST file. 2048 switch(ReadASTCore(ImportedFile, ImportedKind, &F)) { 2049 case Failure: return Failure; 2050 // If we have to ignore the dependency, we'll have to ignore this too. 2051 case IgnorePCH: return IgnorePCH; 2052 case Success: break; 2053 } 2054 } 2055 break; 2056 } 2057 2058 case TYPE_OFFSET: { 2059 if (F.LocalNumTypes != 0) { 2060 Error("duplicate TYPE_OFFSET record in AST file"); 2061 return Failure; 2062 } 2063 F.TypeOffsets = (const uint32_t *)BlobStart; 2064 F.LocalNumTypes = Record[0]; 2065 unsigned LocalBaseTypeIndex = Record[1]; 2066 F.BaseTypeIndex = getTotalNumTypes(); 2067 2068 if (F.LocalNumTypes > 0) { 2069 // Introduce the global -> local mapping for types within this module. 2070 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F)); 2071 2072 // Introduce the local -> global mapping for types within this module. 2073 F.TypeRemap.insert(std::make_pair(LocalBaseTypeIndex, 2074 F.BaseTypeIndex - LocalBaseTypeIndex)); 2075 2076 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes); 2077 } 2078 break; 2079 } 2080 2081 case DECL_OFFSET: { 2082 if (F.LocalNumDecls != 0) { 2083 Error("duplicate DECL_OFFSET record in AST file"); 2084 return Failure; 2085 } 2086 F.DeclOffsets = (const uint32_t *)BlobStart; 2087 F.LocalNumDecls = Record[0]; 2088 unsigned LocalBaseDeclID = Record[1]; 2089 F.BaseDeclID = getTotalNumDecls(); 2090 2091 if (F.LocalNumDecls > 0) { 2092 // Introduce the global -> local mapping for declarations within this 2093 // module. 2094 GlobalDeclMap.insert( 2095 std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F)); 2096 2097 // Introduce the local -> global mapping for declarations within this 2098 // module. 2099 F.DeclRemap.insert(std::make_pair(LocalBaseDeclID, 2100 F.BaseDeclID - LocalBaseDeclID)); 2101 2102 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls); 2103 } 2104 break; 2105 } 2106 2107 case TU_UPDATE_LEXICAL: { 2108 DeclContextInfo Info = { 2109 &F, 2110 /* No visible information */ 0, 2111 reinterpret_cast<const KindDeclIDPair *>(BlobStart), 2112 static_cast<unsigned int>(BlobLen / sizeof(KindDeclIDPair)) 2113 }; 2114 2115 DeclContext *TU = Context ? Context->getTranslationUnitDecl() : 0; 2116 DeclContextOffsets[TU].push_back(Info); 2117 if (TU) 2118 TU->setHasExternalLexicalStorage(true); 2119 2120 break; 2121 } 2122 2123 case UPDATE_VISIBLE: { 2124 unsigned Idx = 0; 2125 serialization::DeclID ID = ReadDeclID(F, Record, Idx); 2126 void *Table = ASTDeclContextNameLookupTable::Create( 2127 (const unsigned char *)BlobStart + Record[Idx++], 2128 (const unsigned char *)BlobStart, 2129 ASTDeclContextNameLookupTrait(*this, F)); 2130 // FIXME: Complete hack to check for the TU 2131 if (ID == PREDEF_DECL_TRANSLATION_UNIT_ID && Context) { // Is it the TU? 2132 DeclContextInfo Info = { 2133 &F, Table, /* No lexical information */ 0, 0 2134 }; 2135 2136 DeclContext *TU = Context->getTranslationUnitDecl(); 2137 DeclContextOffsets[TU].push_back(Info); 2138 TU->setHasExternalVisibleStorage(true); 2139 } else 2140 PendingVisibleUpdates[ID].push_back(std::make_pair(Table, &F)); 2141 break; 2142 } 2143 2144 case REDECLS_UPDATE_LATEST: { 2145 assert(Record.size() % 2 == 0 && "Expected pairs of DeclIDs"); 2146 for (unsigned i = 0, e = Record.size(); i < e; /* in loop */) { 2147 DeclID First = ReadDeclID(F, Record, i); 2148 DeclID Latest = ReadDeclID(F, Record, i); 2149 FirstLatestDeclIDs[First] = Latest; 2150 } 2151 break; 2152 } 2153 2154 case LANGUAGE_OPTIONS: 2155 if (ParseLanguageOptions(Record) && !DisableValidation) 2156 return IgnorePCH; 2157 break; 2158 2159 case IDENTIFIER_TABLE: 2160 F.IdentifierTableData = BlobStart; 2161 if (Record[0]) { 2162 F.IdentifierLookupTable 2163 = ASTIdentifierLookupTable::Create( 2164 (const unsigned char *)F.IdentifierTableData + Record[0], 2165 (const unsigned char *)F.IdentifierTableData, 2166 ASTIdentifierLookupTrait(*this, F)); 2167 if (PP) { 2168 PP->getIdentifierTable().setExternalIdentifierLookup(this); 2169 PP->getHeaderSearchInfo().SetExternalLookup(this); 2170 } 2171 } 2172 break; 2173 2174 case IDENTIFIER_OFFSET: { 2175 if (F.LocalNumIdentifiers != 0) { 2176 Error("duplicate IDENTIFIER_OFFSET record in AST file"); 2177 return Failure; 2178 } 2179 F.IdentifierOffsets = (const uint32_t *)BlobStart; 2180 F.LocalNumIdentifiers = Record[0]; 2181 unsigned LocalBaseIdentifierID = Record[1]; 2182 F.BaseIdentifierID = getTotalNumIdentifiers(); 2183 2184 if (F.LocalNumIdentifiers > 0) { 2185 // Introduce the global -> local mapping for identifiers within this 2186 // module. 2187 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1, 2188 &F)); 2189 2190 // Introduce the local -> global mapping for identifiers within this 2191 // module. 2192 F.IdentifierRemap.insert( 2193 std::make_pair(LocalBaseIdentifierID, 2194 F.BaseIdentifierID - LocalBaseIdentifierID)); 2195 2196 IdentifiersLoaded.resize(IdentifiersLoaded.size() 2197 + F.LocalNumIdentifiers); 2198 } 2199 break; 2200 } 2201 2202 case EXTERNAL_DEFINITIONS: 2203 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2204 ExternalDefinitions.push_back(getGlobalDeclID(F, Record[I])); 2205 break; 2206 2207 case SPECIAL_TYPES: 2208 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2209 SpecialTypes.push_back(getGlobalTypeID(F, Record[I])); 2210 break; 2211 2212 case STATISTICS: 2213 TotalNumStatements += Record[0]; 2214 TotalNumMacros += Record[1]; 2215 TotalLexicalDeclContexts += Record[2]; 2216 TotalVisibleDeclContexts += Record[3]; 2217 break; 2218 2219 case UNUSED_FILESCOPED_DECLS: 2220 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2221 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I])); 2222 break; 2223 2224 case DELEGATING_CTORS: 2225 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2226 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I])); 2227 break; 2228 2229 case WEAK_UNDECLARED_IDENTIFIERS: 2230 if (Record.size() % 4 != 0) { 2231 Error("invalid weak identifiers record"); 2232 return Failure; 2233 } 2234 2235 // FIXME: Ignore weak undeclared identifiers from non-original PCH 2236 // files. This isn't the way to do it :) 2237 WeakUndeclaredIdentifiers.clear(); 2238 2239 // Translate the weak, undeclared identifiers into global IDs. 2240 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) { 2241 WeakUndeclaredIdentifiers.push_back( 2242 getGlobalIdentifierID(F, Record[I++])); 2243 WeakUndeclaredIdentifiers.push_back( 2244 getGlobalIdentifierID(F, Record[I++])); 2245 WeakUndeclaredIdentifiers.push_back( 2246 ReadSourceLocation(F, Record, I).getRawEncoding()); 2247 WeakUndeclaredIdentifiers.push_back(Record[I++]); 2248 } 2249 break; 2250 2251 case LOCALLY_SCOPED_EXTERNAL_DECLS: 2252 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2253 LocallyScopedExternalDecls.push_back(getGlobalDeclID(F, Record[I])); 2254 break; 2255 2256 case SELECTOR_OFFSETS: { 2257 F.SelectorOffsets = (const uint32_t *)BlobStart; 2258 F.LocalNumSelectors = Record[0]; 2259 unsigned LocalBaseSelectorID = Record[1]; 2260 F.BaseSelectorID = getTotalNumSelectors(); 2261 2262 if (F.LocalNumSelectors > 0) { 2263 // Introduce the global -> local mapping for selectors within this 2264 // module. 2265 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F)); 2266 2267 // Introduce the local -> global mapping for selectors within this 2268 // module. 2269 F.SelectorRemap.insert(std::make_pair(LocalBaseSelectorID, 2270 F.BaseSelectorID - LocalBaseSelectorID)); 2271 2272 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors); 2273 } 2274 break; 2275 } 2276 2277 case METHOD_POOL: 2278 F.SelectorLookupTableData = (const unsigned char *)BlobStart; 2279 if (Record[0]) 2280 F.SelectorLookupTable 2281 = ASTSelectorLookupTable::Create( 2282 F.SelectorLookupTableData + Record[0], 2283 F.SelectorLookupTableData, 2284 ASTSelectorLookupTrait(*this, F)); 2285 TotalNumMethodPoolEntries += Record[1]; 2286 break; 2287 2288 case REFERENCED_SELECTOR_POOL: 2289 if (!Record.empty()) { 2290 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) { 2291 ReferencedSelectorsData.push_back(getGlobalSelectorID(F, 2292 Record[Idx++])); 2293 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx). 2294 getRawEncoding()); 2295 } 2296 } 2297 break; 2298 2299 case PP_COUNTER_VALUE: 2300 if (!Record.empty() && Listener) 2301 Listener->ReadCounter(Record[0]); 2302 break; 2303 2304 case SOURCE_LOCATION_OFFSETS: { 2305 F.SLocEntryOffsets = (const uint32_t *)BlobStart; 2306 F.LocalNumSLocEntries = Record[0]; 2307 llvm::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) = 2308 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries, Record[1]); 2309 // Make our entry in the range map. BaseID is negative and growing, so 2310 // we invert it. Because we invert it, though, we need the other end of 2311 // the range. 2312 unsigned RangeStart = 2313 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1; 2314 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F)); 2315 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset); 2316 2317 // Initialize the remapping table. 2318 // Invalid stays invalid. 2319 F.SLocRemap.insert(std::make_pair(0U, 0)); 2320 // This module. Base was 2 when being compiled. 2321 F.SLocRemap.insert(std::make_pair(2U, 2322 static_cast<int>(F.SLocEntryBaseOffset - 2))); 2323 2324 TotalNumSLocEntries += F.LocalNumSLocEntries; 2325 break; 2326 } 2327 2328 case MODULE_OFFSET_MAP: { 2329 // Additional remapping information. 2330 const unsigned char *Data = (const unsigned char*)BlobStart; 2331 const unsigned char *DataEnd = Data + BlobLen; 2332 2333 // Continuous range maps we may be updating in our module. 2334 ContinuousRangeMap<uint32_t, int, 2>::Builder SLocRemap(F.SLocRemap); 2335 ContinuousRangeMap<uint32_t, int, 2>::Builder 2336 IdentifierRemap(F.IdentifierRemap); 2337 ContinuousRangeMap<uint32_t, int, 2>::Builder 2338 PreprocessedEntityRemap(F.PreprocessedEntityRemap); 2339 ContinuousRangeMap<uint32_t, int, 2>::Builder 2340 MacroDefinitionRemap(F.MacroDefinitionRemap); 2341 ContinuousRangeMap<uint32_t, int, 2>::Builder 2342 SelectorRemap(F.SelectorRemap); 2343 ContinuousRangeMap<uint32_t, int, 2>::Builder DeclRemap(F.DeclRemap); 2344 ContinuousRangeMap<uint32_t, int, 2>::Builder TypeRemap(F.TypeRemap); 2345 2346 while(Data < DataEnd) { 2347 uint16_t Len = io::ReadUnalignedLE16(Data); 2348 StringRef Name = StringRef((const char*)Data, Len); 2349 Data += Len; 2350 Module *OM = ModuleMgr.lookup(Name); 2351 if (!OM) { 2352 Error("SourceLocation remap refers to unknown module"); 2353 return Failure; 2354 } 2355 2356 uint32_t SLocOffset = io::ReadUnalignedLE32(Data); 2357 uint32_t IdentifierIDOffset = io::ReadUnalignedLE32(Data); 2358 uint32_t PreprocessedEntityIDOffset = io::ReadUnalignedLE32(Data); 2359 uint32_t MacroDefinitionIDOffset = io::ReadUnalignedLE32(Data); 2360 uint32_t SelectorIDOffset = io::ReadUnalignedLE32(Data); 2361 uint32_t DeclIDOffset = io::ReadUnalignedLE32(Data); 2362 uint32_t TypeIndexOffset = io::ReadUnalignedLE32(Data); 2363 2364 // Source location offset is mapped to OM->SLocEntryBaseOffset. 2365 SLocRemap.insert(std::make_pair(SLocOffset, 2366 static_cast<int>(OM->SLocEntryBaseOffset - SLocOffset))); 2367 IdentifierRemap.insert( 2368 std::make_pair(IdentifierIDOffset, 2369 OM->BaseIdentifierID - IdentifierIDOffset)); 2370 PreprocessedEntityRemap.insert( 2371 std::make_pair(PreprocessedEntityIDOffset, 2372 OM->BasePreprocessedEntityID - PreprocessedEntityIDOffset)); 2373 MacroDefinitionRemap.insert( 2374 std::make_pair(MacroDefinitionIDOffset, 2375 OM->BaseMacroDefinitionID - MacroDefinitionIDOffset)); 2376 SelectorRemap.insert(std::make_pair(SelectorIDOffset, 2377 OM->BaseSelectorID - SelectorIDOffset)); 2378 DeclRemap.insert(std::make_pair(DeclIDOffset, 2379 OM->BaseDeclID - DeclIDOffset)); 2380 2381 TypeRemap.insert(std::make_pair(TypeIndexOffset, 2382 OM->BaseTypeIndex - TypeIndexOffset)); 2383 } 2384 break; 2385 } 2386 2387 case SOURCE_MANAGER_LINE_TABLE: 2388 if (ParseLineTable(F, Record)) 2389 return Failure; 2390 break; 2391 2392 case FILE_SOURCE_LOCATION_OFFSETS: 2393 F.SLocFileOffsets = (const uint32_t *)BlobStart; 2394 F.LocalNumSLocFileEntries = Record[0]; 2395 break; 2396 2397 case SOURCE_LOCATION_PRELOADS: { 2398 // Need to transform from the local view (1-based IDs) to the global view, 2399 // which is based off F.SLocEntryBaseID. 2400 PreloadSLocEntries.reserve(PreloadSLocEntries.size() + Record.size()); 2401 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2402 PreloadSLocEntries.push_back(int(Record[I] - 1) + F.SLocEntryBaseID); 2403 break; 2404 } 2405 2406 case STAT_CACHE: { 2407 if (!DisableStatCache) { 2408 ASTStatCache *MyStatCache = 2409 new ASTStatCache((const unsigned char *)BlobStart + Record[0], 2410 (const unsigned char *)BlobStart, 2411 NumStatHits, NumStatMisses); 2412 FileMgr.addStatCache(MyStatCache); 2413 F.StatCache = MyStatCache; 2414 } 2415 break; 2416 } 2417 2418 case EXT_VECTOR_DECLS: 2419 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2420 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I])); 2421 break; 2422 2423 case VTABLE_USES: 2424 if (Record.size() % 3 != 0) { 2425 Error("Invalid VTABLE_USES record"); 2426 return Failure; 2427 } 2428 2429 // Later tables overwrite earlier ones. 2430 // FIXME: Modules will have some trouble with this. This is clearly not 2431 // the right way to do this. 2432 VTableUses.clear(); 2433 2434 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) { 2435 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++])); 2436 VTableUses.push_back( 2437 ReadSourceLocation(F, Record, Idx).getRawEncoding()); 2438 VTableUses.push_back(Record[Idx++]); 2439 } 2440 break; 2441 2442 case DYNAMIC_CLASSES: 2443 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2444 DynamicClasses.push_back(getGlobalDeclID(F, Record[I])); 2445 break; 2446 2447 case PENDING_IMPLICIT_INSTANTIATIONS: 2448 if (PendingInstantiations.size() % 2 != 0) { 2449 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block"); 2450 return Failure; 2451 } 2452 2453 // Later lists of pending instantiations overwrite earlier ones. 2454 // FIXME: This is most certainly wrong for modules. 2455 PendingInstantiations.clear(); 2456 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) { 2457 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++])); 2458 PendingInstantiations.push_back( 2459 ReadSourceLocation(F, Record, I).getRawEncoding()); 2460 } 2461 break; 2462 2463 case SEMA_DECL_REFS: 2464 // Later tables overwrite earlier ones. 2465 // FIXME: Modules will have some trouble with this. 2466 SemaDeclRefs.clear(); 2467 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2468 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I])); 2469 break; 2470 2471 case ORIGINAL_FILE_NAME: 2472 // The primary AST will be the last to get here, so it will be the one 2473 // that's used. 2474 ActualOriginalFileName.assign(BlobStart, BlobLen); 2475 OriginalFileName = ActualOriginalFileName; 2476 MaybeAddSystemRootToFilename(OriginalFileName); 2477 break; 2478 2479 case ORIGINAL_FILE_ID: 2480 OriginalFileID = FileID::get(Record[0]); 2481 break; 2482 2483 case ORIGINAL_PCH_DIR: 2484 // The primary AST will be the last to get here, so it will be the one 2485 // that's used. 2486 OriginalDir.assign(BlobStart, BlobLen); 2487 break; 2488 2489 case VERSION_CONTROL_BRANCH_REVISION: { 2490 const std::string &CurBranch = getClangFullRepositoryVersion(); 2491 StringRef ASTBranch(BlobStart, BlobLen); 2492 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) { 2493 Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch; 2494 return IgnorePCH; 2495 } 2496 break; 2497 } 2498 2499 case MACRO_DEFINITION_OFFSETS: { 2500 F.MacroDefinitionOffsets = (const uint32_t *)BlobStart; 2501 F.NumPreallocatedPreprocessingEntities = Record[0]; 2502 unsigned LocalBasePreprocessedEntityID = Record[1]; 2503 F.LocalNumMacroDefinitions = Record[2]; 2504 unsigned LocalBaseMacroID = Record[3]; 2505 2506 unsigned StartingID; 2507 if (PP) { 2508 if (!PP->getPreprocessingRecord()) 2509 PP->createPreprocessingRecord(true); 2510 if (!PP->getPreprocessingRecord()->getExternalSource()) 2511 PP->getPreprocessingRecord()->SetExternalSource(*this); 2512 StartingID 2513 = PP->getPreprocessingRecord() 2514 ->allocateLoadedEntities(F.NumPreallocatedPreprocessingEntities); 2515 } else { 2516 // FIXME: We'll eventually want to kill this path, since it assumes 2517 // a particular allocation strategy in the preprocessing record. 2518 StartingID = getTotalNumPreprocessedEntities() 2519 - F.NumPreallocatedPreprocessingEntities; 2520 } 2521 F.BaseMacroDefinitionID = getTotalNumMacroDefinitions(); 2522 F.BasePreprocessedEntityID = StartingID; 2523 2524 if (F.NumPreallocatedPreprocessingEntities > 0) { 2525 // Introduce the global -> local mapping for preprocessed entities in 2526 // this module. 2527 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F)); 2528 2529 // Introduce the local -> global mapping for preprocessed entities in 2530 // this module. 2531 F.PreprocessedEntityRemap.insert( 2532 std::make_pair(LocalBasePreprocessedEntityID, 2533 F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID)); 2534 } 2535 2536 2537 if (F.LocalNumMacroDefinitions > 0) { 2538 // Introduce the global -> local mapping for macro definitions within 2539 // this module. 2540 GlobalMacroDefinitionMap.insert( 2541 std::make_pair(getTotalNumMacroDefinitions() + 1, &F)); 2542 2543 // Introduce the local -> global mapping for macro definitions within 2544 // this module. 2545 F.MacroDefinitionRemap.insert( 2546 std::make_pair(LocalBaseMacroID, 2547 F.BaseMacroDefinitionID - LocalBaseMacroID)); 2548 2549 MacroDefinitionsLoaded.resize( 2550 MacroDefinitionsLoaded.size() + F.LocalNumMacroDefinitions); 2551 } 2552 2553 break; 2554 } 2555 2556 case DECL_UPDATE_OFFSETS: { 2557 if (Record.size() % 2 != 0) { 2558 Error("invalid DECL_UPDATE_OFFSETS block in AST file"); 2559 return Failure; 2560 } 2561 for (unsigned I = 0, N = Record.size(); I != N; I += 2) 2562 DeclUpdateOffsets[getGlobalDeclID(F, Record[I])] 2563 .push_back(std::make_pair(&F, Record[I+1])); 2564 break; 2565 } 2566 2567 case DECL_REPLACEMENTS: { 2568 if (Record.size() % 2 != 0) { 2569 Error("invalid DECL_REPLACEMENTS block in AST file"); 2570 return Failure; 2571 } 2572 for (unsigned I = 0, N = Record.size(); I != N; I += 2) 2573 ReplacedDecls[getGlobalDeclID(F, Record[I])] 2574 = std::make_pair(&F, Record[I+1]); 2575 break; 2576 } 2577 2578 case CXX_BASE_SPECIFIER_OFFSETS: { 2579 if (F.LocalNumCXXBaseSpecifiers != 0) { 2580 Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file"); 2581 return Failure; 2582 } 2583 2584 F.LocalNumCXXBaseSpecifiers = Record[0]; 2585 F.CXXBaseSpecifiersOffsets = (const uint32_t *)BlobStart; 2586 NumCXXBaseSpecifiersLoaded += F.LocalNumCXXBaseSpecifiers; 2587 break; 2588 } 2589 2590 case DIAG_PRAGMA_MAPPINGS: 2591 if (Record.size() % 2 != 0) { 2592 Error("invalid DIAG_USER_MAPPINGS block in AST file"); 2593 return Failure; 2594 } 2595 2596 if (F.PragmaDiagMappings.empty()) 2597 F.PragmaDiagMappings.swap(Record); 2598 else 2599 F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(), 2600 Record.begin(), Record.end()); 2601 break; 2602 2603 case CUDA_SPECIAL_DECL_REFS: 2604 // Later tables overwrite earlier ones. 2605 // FIXME: Modules will have trouble with this. 2606 CUDASpecialDeclRefs.clear(); 2607 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2608 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I])); 2609 break; 2610 2611 case HEADER_SEARCH_TABLE: { 2612 F.HeaderFileInfoTableData = BlobStart; 2613 F.LocalNumHeaderFileInfos = Record[1]; 2614 F.HeaderFileFrameworkStrings = BlobStart + Record[2]; 2615 if (Record[0]) { 2616 F.HeaderFileInfoTable 2617 = HeaderFileInfoLookupTable::Create( 2618 (const unsigned char *)F.HeaderFileInfoTableData + Record[0], 2619 (const unsigned char *)F.HeaderFileInfoTableData, 2620 HeaderFileInfoTrait(*this, F, 2621 PP? &PP->getHeaderSearchInfo() : 0, 2622 BlobStart + Record[2])); 2623 if (PP) 2624 PP->getHeaderSearchInfo().SetExternalSource(this); 2625 } 2626 break; 2627 } 2628 2629 case FP_PRAGMA_OPTIONS: 2630 // Later tables overwrite earlier ones. 2631 FPPragmaOptions.swap(Record); 2632 break; 2633 2634 case OPENCL_EXTENSIONS: 2635 // Later tables overwrite earlier ones. 2636 OpenCLExtensions.swap(Record); 2637 break; 2638 2639 case TENTATIVE_DEFINITIONS: 2640 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2641 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I])); 2642 break; 2643 2644 case KNOWN_NAMESPACES: 2645 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2646 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I])); 2647 break; 2648 } 2649 First = false; 2650 } 2651 Error("premature end of bitstream in AST file"); 2652 return Failure; 2653} 2654 2655ASTReader::ASTReadResult ASTReader::validateFileEntries() { 2656 for (ModuleIterator I = ModuleMgr.begin(), 2657 E = ModuleMgr.end(); I != E; ++I) { 2658 Module *F = *I; 2659 llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor; 2660 2661 for (unsigned i = 0, e = F->LocalNumSLocFileEntries; i != e; ++i) { 2662 SLocEntryCursor.JumpToBit(F->SLocFileOffsets[i]); 2663 unsigned Code = SLocEntryCursor.ReadCode(); 2664 if (Code == llvm::bitc::END_BLOCK || 2665 Code == llvm::bitc::ENTER_SUBBLOCK || 2666 Code == llvm::bitc::DEFINE_ABBREV) { 2667 Error("incorrectly-formatted source location entry in AST file"); 2668 return Failure; 2669 } 2670 2671 RecordData Record; 2672 const char *BlobStart; 2673 unsigned BlobLen; 2674 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 2675 default: 2676 Error("incorrectly-formatted source location entry in AST file"); 2677 return Failure; 2678 2679 case SM_SLOC_FILE_ENTRY: { 2680 StringRef Filename(BlobStart, BlobLen); 2681 const FileEntry *File = getFileEntry(Filename); 2682 2683 if (File == 0) { 2684 std::string ErrorStr = "could not find file '"; 2685 ErrorStr += Filename; 2686 ErrorStr += "' referenced by AST file"; 2687 Error(ErrorStr.c_str()); 2688 return IgnorePCH; 2689 } 2690 2691 if (Record.size() < 6) { 2692 Error("source location entry is incorrect"); 2693 return Failure; 2694 } 2695 2696 // The stat info from the FileEntry came from the cached stat 2697 // info of the PCH, so we cannot trust it. 2698 struct stat StatBuf; 2699 if (::stat(File->getName(), &StatBuf) != 0) { 2700 StatBuf.st_size = File->getSize(); 2701 StatBuf.st_mtime = File->getModificationTime(); 2702 } 2703 2704 if (((off_t)Record[4] != StatBuf.st_size 2705#if !defined(LLVM_ON_WIN32) 2706 // In our regression testing, the Windows file system seems to 2707 // have inconsistent modification times that sometimes 2708 // erroneously trigger this error-handling path. 2709 || (time_t)Record[5] != StatBuf.st_mtime 2710#endif 2711 )) { 2712 Error(diag::err_fe_pch_file_modified, Filename); 2713 return IgnorePCH; 2714 } 2715 2716 break; 2717 } 2718 } 2719 } 2720 } 2721 2722 return Success; 2723} 2724 2725ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName, 2726 ModuleKind Type) { 2727 switch(ReadASTCore(FileName, Type, /*ImportedBy=*/0)) { 2728 case Failure: return Failure; 2729 case IgnorePCH: return IgnorePCH; 2730 case Success: break; 2731 } 2732 2733 // Here comes stuff that we only do once the entire chain is loaded. 2734 2735 if (!DisableValidation) { 2736 switch(validateFileEntries()) { 2737 case Failure: return Failure; 2738 case IgnorePCH: return IgnorePCH; 2739 case Success: break; 2740 } 2741 } 2742 2743 // Preload SLocEntries. 2744 for (unsigned I = 0, N = PreloadSLocEntries.size(); I != N; ++I) { 2745 ASTReadResult Result = ReadSLocEntryRecord(PreloadSLocEntries[I]); 2746 if (Result != Success) 2747 return Failure; 2748 } 2749 PreloadSLocEntries.clear(); 2750 2751 // Check the predefines buffers. 2752 if (!DisableValidation && Type != MK_Module && CheckPredefinesBuffers()) 2753 return IgnorePCH; 2754 2755 if (PP) { 2756 // Initialization of keywords and pragmas occurs before the 2757 // AST file is read, so there may be some identifiers that were 2758 // loaded into the IdentifierTable before we intercepted the 2759 // creation of identifiers. Iterate through the list of known 2760 // identifiers and determine whether we have to establish 2761 // preprocessor definitions or top-level identifier declaration 2762 // chains for those identifiers. 2763 // 2764 // We copy the IdentifierInfo pointers to a small vector first, 2765 // since de-serializing declarations or macro definitions can add 2766 // new entries into the identifier table, invalidating the 2767 // iterators. 2768 // 2769 // FIXME: We need a lazier way to load this information, e.g., by marking 2770 // the identifier data as 'dirty', so that it will be looked up in the 2771 // AST file(s) if it is uttered in the source. This could save us some 2772 // module load time. 2773 SmallVector<IdentifierInfo *, 128> Identifiers; 2774 for (IdentifierTable::iterator Id = PP->getIdentifierTable().begin(), 2775 IdEnd = PP->getIdentifierTable().end(); 2776 Id != IdEnd; ++Id) 2777 Identifiers.push_back(Id->second); 2778 // We need to search the tables in all files. 2779 for (ModuleIterator J = ModuleMgr.begin(), 2780 M = ModuleMgr.end(); J != M; ++J) { 2781 ASTIdentifierLookupTable *IdTable 2782 = (ASTIdentifierLookupTable *)(*J)->IdentifierLookupTable; 2783 // Not all AST files necessarily have identifier tables, only the useful 2784 // ones. 2785 if (!IdTable) 2786 continue; 2787 for (unsigned I = 0, N = Identifiers.size(); I != N; ++I) { 2788 IdentifierInfo *II = Identifiers[I]; 2789 // Look in the on-disk hash tables for an entry for this identifier 2790 ASTIdentifierLookupTrait Info(*this, *(*J), II); 2791 std::pair<const char*,unsigned> Key(II->getNameStart(),II->getLength()); 2792 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key, &Info); 2793 if (Pos == IdTable->end()) 2794 continue; 2795 2796 // Dereferencing the iterator has the effect of populating the 2797 // IdentifierInfo node with the various declarations it needs. 2798 (void)*Pos; 2799 } 2800 } 2801 } 2802 2803 if (Context) 2804 InitializeContext(*Context); 2805 2806 if (DeserializationListener) 2807 DeserializationListener->ReaderInitialized(this); 2808 2809 // If this AST file is a precompiled preamble, then set the main file ID of 2810 // the source manager to the file source file from which the preamble was 2811 // built. This is the only valid way to use a precompiled preamble. 2812 if (Type == MK_Preamble) { 2813 if (OriginalFileID.isInvalid()) { 2814 SourceLocation Loc 2815 = SourceMgr.getLocation(FileMgr.getFile(getOriginalSourceFile()), 1, 1); 2816 if (Loc.isValid()) 2817 OriginalFileID = SourceMgr.getDecomposedLoc(Loc).first; 2818 } 2819 else { 2820 OriginalFileID = FileID::get(ModuleMgr.getPrimaryModule().SLocEntryBaseID 2821 + OriginalFileID.getOpaqueValue() - 1); 2822 } 2823 2824 if (!OriginalFileID.isInvalid()) 2825 SourceMgr.SetPreambleFileID(OriginalFileID); 2826 } 2827 2828 return Success; 2829} 2830 2831ASTReader::ASTReadResult ASTReader::ReadASTCore(StringRef FileName, 2832 ModuleKind Type, 2833 Module *ImportedBy) { 2834 Module *M; 2835 bool NewModule; 2836 std::string ErrorStr; 2837 llvm::tie(M, NewModule) = ModuleMgr.addModule(FileName, Type, ImportedBy, 2838 ErrorStr); 2839 2840 if (!M) { 2841 // We couldn't load the module. 2842 std::string Msg = "Unable to load module \"" + FileName.str() + "\": " 2843 + ErrorStr; 2844 Error(Msg); 2845 return Failure; 2846 } 2847 2848 if (!NewModule) { 2849 // We've already loaded this module. 2850 return Success; 2851 } 2852 2853 // FIXME: This seems rather a hack. Should CurrentDir be part of the 2854 // module? 2855 if (FileName != "-") { 2856 CurrentDir = llvm::sys::path::parent_path(FileName); 2857 if (CurrentDir.empty()) CurrentDir = "."; 2858 } 2859 2860 Module &F = *M; 2861 llvm::BitstreamCursor &Stream = F.Stream; 2862 Stream.init(F.StreamFile); 2863 F.SizeInBits = F.Buffer->getBufferSize() * 8; 2864 2865 // Sniff for the signature. 2866 if (Stream.Read(8) != 'C' || 2867 Stream.Read(8) != 'P' || 2868 Stream.Read(8) != 'C' || 2869 Stream.Read(8) != 'H') { 2870 Diag(diag::err_not_a_pch_file) << FileName; 2871 return Failure; 2872 } 2873 2874 while (!Stream.AtEndOfStream()) { 2875 unsigned Code = Stream.ReadCode(); 2876 2877 if (Code != llvm::bitc::ENTER_SUBBLOCK) { 2878 Error("invalid record at top-level of AST file"); 2879 return Failure; 2880 } 2881 2882 unsigned BlockID = Stream.ReadSubBlockID(); 2883 2884 // We only know the AST subblock ID. 2885 switch (BlockID) { 2886 case llvm::bitc::BLOCKINFO_BLOCK_ID: 2887 if (Stream.ReadBlockInfoBlock()) { 2888 Error("malformed BlockInfoBlock in AST file"); 2889 return Failure; 2890 } 2891 break; 2892 case AST_BLOCK_ID: 2893 switch (ReadASTBlock(F)) { 2894 case Success: 2895 break; 2896 2897 case Failure: 2898 return Failure; 2899 2900 case IgnorePCH: 2901 // FIXME: We could consider reading through to the end of this 2902 // AST block, skipping subblocks, to see if there are other 2903 // AST blocks elsewhere. 2904 2905 // FIXME: We can't clear loaded slocentries anymore. 2906 //SourceMgr.ClearPreallocatedSLocEntries(); 2907 2908 // Remove the stat cache. 2909 if (F.StatCache) 2910 FileMgr.removeStatCache((ASTStatCache*)F.StatCache); 2911 2912 return IgnorePCH; 2913 } 2914 break; 2915 default: 2916 if (Stream.SkipBlock()) { 2917 Error("malformed block record in AST file"); 2918 return Failure; 2919 } 2920 break; 2921 } 2922 } 2923 2924 // Once read, set the Module bit base offset and update the size in 2925 // bits of all files we've seen. 2926 F.GlobalBitOffset = TotalModulesSizeInBits; 2927 TotalModulesSizeInBits += F.SizeInBits; 2928 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F)); 2929 return Success; 2930} 2931 2932void ASTReader::setPreprocessor(Preprocessor &pp) { 2933 PP = &pp; 2934 2935 if (unsigned N = getTotalNumPreprocessedEntities()) { 2936 if (!PP->getPreprocessingRecord()) 2937 PP->createPreprocessingRecord(true); 2938 PP->getPreprocessingRecord()->SetExternalSource(*this); 2939 PP->getPreprocessingRecord()->allocateLoadedEntities(N); 2940 } 2941 2942 PP->getHeaderSearchInfo().SetExternalLookup(this); 2943 PP->getHeaderSearchInfo().SetExternalSource(this); 2944} 2945 2946void ASTReader::InitializeContext(ASTContext &Ctx) { 2947 Context = &Ctx; 2948 assert(Context && "Passed null context!"); 2949 2950 assert(PP && "Forgot to set Preprocessor ?"); 2951 PP->getIdentifierTable().setExternalIdentifierLookup(this); 2952 PP->setExternalSource(this); 2953 2954 // If we have an update block for the TU waiting, we have to add it before 2955 // deserializing the decl. 2956 TranslationUnitDecl *TU = Ctx.getTranslationUnitDecl(); 2957 DeclContextOffsetsMap::iterator DCU = DeclContextOffsets.find(0); 2958 if (DCU != DeclContextOffsets.end()) { 2959 // Insertion could invalidate map, so grab vector. 2960 DeclContextInfos T; 2961 T.swap(DCU->second); 2962 DeclContextOffsets.erase(DCU); 2963 DeclContextOffsets[TU].swap(T); 2964 } 2965 2966 // If there's a listener, notify them that we "read" the translation unit. 2967 if (DeserializationListener) 2968 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID, TU); 2969 2970 // Make sure we load the declaration update records for the translation unit, 2971 // if there are any. 2972 loadDeclUpdateRecords(PREDEF_DECL_TRANSLATION_UNIT_ID, TU); 2973 2974 // Note that the translation unit has external lexical and visible storage. 2975 TU->setHasExternalLexicalStorage(true); 2976 TU->setHasExternalVisibleStorage(true); 2977 2978 // FIXME: Find a better way to deal with collisions between these 2979 // built-in types. Right now, we just ignore the problem. 2980 2981 // Load the special types. 2982 if (Context->getBuiltinVaListType().isNull()) { 2983 Context->setBuiltinVaListType( 2984 GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST])); 2985 } 2986 2987 if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL]) { 2988 if (Context->ObjCProtoType.isNull()) 2989 Context->ObjCProtoType = GetType(Proto); 2990 } 2991 2992 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) { 2993 if (!Context->CFConstantStringTypeDecl) 2994 Context->setCFConstantStringType(GetType(String)); 2995 } 2996 2997 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) { 2998 QualType FileType = GetType(File); 2999 if (FileType.isNull()) { 3000 Error("FILE type is NULL"); 3001 return; 3002 } 3003 3004 if (!Context->FILEDecl) { 3005 if (const TypedefType *Typedef = FileType->getAs<TypedefType>()) 3006 Context->setFILEDecl(Typedef->getDecl()); 3007 else { 3008 const TagType *Tag = FileType->getAs<TagType>(); 3009 if (!Tag) { 3010 Error("Invalid FILE type in AST file"); 3011 return; 3012 } 3013 Context->setFILEDecl(Tag->getDecl()); 3014 } 3015 } 3016 } 3017 3018 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) { 3019 QualType Jmp_bufType = GetType(Jmp_buf); 3020 if (Jmp_bufType.isNull()) { 3021 Error("jmp_buf type is NULL"); 3022 return; 3023 } 3024 3025 if (!Context->jmp_bufDecl) { 3026 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>()) 3027 Context->setjmp_bufDecl(Typedef->getDecl()); 3028 else { 3029 const TagType *Tag = Jmp_bufType->getAs<TagType>(); 3030 if (!Tag) { 3031 Error("Invalid jmp_buf type in AST file"); 3032 return; 3033 } 3034 Context->setjmp_bufDecl(Tag->getDecl()); 3035 } 3036 } 3037 } 3038 3039 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) { 3040 QualType Sigjmp_bufType = GetType(Sigjmp_buf); 3041 if (Sigjmp_bufType.isNull()) { 3042 Error("sigjmp_buf type is NULL"); 3043 return; 3044 } 3045 3046 if (!Context->sigjmp_bufDecl) { 3047 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>()) 3048 Context->setsigjmp_bufDecl(Typedef->getDecl()); 3049 else { 3050 const TagType *Tag = Sigjmp_bufType->getAs<TagType>(); 3051 assert(Tag && "Invalid sigjmp_buf type in AST file"); 3052 Context->setsigjmp_bufDecl(Tag->getDecl()); 3053 } 3054 } 3055 } 3056 3057 if (unsigned ObjCIdRedef 3058 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) { 3059 if (Context->ObjCIdRedefinitionType.isNull()) 3060 Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef); 3061 } 3062 3063 if (unsigned ObjCClassRedef 3064 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) { 3065 if (Context->ObjCClassRedefinitionType.isNull()) 3066 Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef); 3067 } 3068 3069 if (unsigned ObjCSelRedef 3070 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) { 3071 if (Context->ObjCSelRedefinitionType.isNull()) 3072 Context->ObjCSelRedefinitionType = GetType(ObjCSelRedef); 3073 } 3074 3075 ReadPragmaDiagnosticMappings(Context->getDiagnostics()); 3076 3077 // If there were any CUDA special declarations, deserialize them. 3078 if (!CUDASpecialDeclRefs.empty()) { 3079 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!"); 3080 Context->setcudaConfigureCallDecl( 3081 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0]))); 3082 } 3083} 3084 3085/// \brief Retrieve the name of the original source file name 3086/// directly from the AST file, without actually loading the AST 3087/// file. 3088std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, 3089 FileManager &FileMgr, 3090 Diagnostic &Diags) { 3091 // Open the AST file. 3092 std::string ErrStr; 3093 llvm::OwningPtr<llvm::MemoryBuffer> Buffer; 3094 Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr)); 3095 if (!Buffer) { 3096 Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr; 3097 return std::string(); 3098 } 3099 3100 // Initialize the stream 3101 llvm::BitstreamReader StreamFile; 3102 llvm::BitstreamCursor Stream; 3103 StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 3104 (const unsigned char *)Buffer->getBufferEnd()); 3105 Stream.init(StreamFile); 3106 3107 // Sniff for the signature. 3108 if (Stream.Read(8) != 'C' || 3109 Stream.Read(8) != 'P' || 3110 Stream.Read(8) != 'C' || 3111 Stream.Read(8) != 'H') { 3112 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName; 3113 return std::string(); 3114 } 3115 3116 RecordData Record; 3117 while (!Stream.AtEndOfStream()) { 3118 unsigned Code = Stream.ReadCode(); 3119 3120 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 3121 unsigned BlockID = Stream.ReadSubBlockID(); 3122 3123 // We only know the AST subblock ID. 3124 switch (BlockID) { 3125 case AST_BLOCK_ID: 3126 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 3127 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 3128 return std::string(); 3129 } 3130 break; 3131 3132 default: 3133 if (Stream.SkipBlock()) { 3134 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 3135 return std::string(); 3136 } 3137 break; 3138 } 3139 continue; 3140 } 3141 3142 if (Code == llvm::bitc::END_BLOCK) { 3143 if (Stream.ReadBlockEnd()) { 3144 Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName; 3145 return std::string(); 3146 } 3147 continue; 3148 } 3149 3150 if (Code == llvm::bitc::DEFINE_ABBREV) { 3151 Stream.ReadAbbrevRecord(); 3152 continue; 3153 } 3154 3155 Record.clear(); 3156 const char *BlobStart = 0; 3157 unsigned BlobLen = 0; 3158 if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen) 3159 == ORIGINAL_FILE_NAME) 3160 return std::string(BlobStart, BlobLen); 3161 } 3162 3163 return std::string(); 3164} 3165 3166/// \brief Parse the record that corresponds to a LangOptions data 3167/// structure. 3168/// 3169/// This routine parses the language options from the AST file and then gives 3170/// them to the AST listener if one is set. 3171/// 3172/// \returns true if the listener deems the file unacceptable, false otherwise. 3173bool ASTReader::ParseLanguageOptions( 3174 const SmallVectorImpl<uint64_t> &Record) { 3175 if (Listener) { 3176 LangOptions LangOpts; 3177 3178 #define PARSE_LANGOPT(Option) \ 3179 LangOpts.Option = Record[Idx]; \ 3180 ++Idx 3181 3182 unsigned Idx = 0; 3183 PARSE_LANGOPT(Trigraphs); 3184 PARSE_LANGOPT(BCPLComment); 3185 PARSE_LANGOPT(DollarIdents); 3186 PARSE_LANGOPT(AsmPreprocessor); 3187 PARSE_LANGOPT(GNUMode); 3188 PARSE_LANGOPT(GNUKeywords); 3189 PARSE_LANGOPT(ImplicitInt); 3190 PARSE_LANGOPT(Digraphs); 3191 PARSE_LANGOPT(HexFloats); 3192 PARSE_LANGOPT(C99); 3193 PARSE_LANGOPT(C1X); 3194 PARSE_LANGOPT(Microsoft); 3195 PARSE_LANGOPT(CPlusPlus); 3196 PARSE_LANGOPT(CPlusPlus0x); 3197 PARSE_LANGOPT(CXXOperatorNames); 3198 PARSE_LANGOPT(ObjC1); 3199 PARSE_LANGOPT(ObjC2); 3200 PARSE_LANGOPT(ObjCNonFragileABI); 3201 PARSE_LANGOPT(ObjCNonFragileABI2); 3202 PARSE_LANGOPT(AppleKext); 3203 PARSE_LANGOPT(ObjCDefaultSynthProperties); 3204 PARSE_LANGOPT(ObjCInferRelatedResultType); 3205 PARSE_LANGOPT(NoConstantCFStrings); 3206 PARSE_LANGOPT(PascalStrings); 3207 PARSE_LANGOPT(WritableStrings); 3208 PARSE_LANGOPT(LaxVectorConversions); 3209 PARSE_LANGOPT(AltiVec); 3210 PARSE_LANGOPT(Exceptions); 3211 PARSE_LANGOPT(ObjCExceptions); 3212 PARSE_LANGOPT(CXXExceptions); 3213 PARSE_LANGOPT(SjLjExceptions); 3214 PARSE_LANGOPT(MSBitfields); 3215 PARSE_LANGOPT(NeXTRuntime); 3216 PARSE_LANGOPT(Freestanding); 3217 PARSE_LANGOPT(NoBuiltin); 3218 PARSE_LANGOPT(ThreadsafeStatics); 3219 PARSE_LANGOPT(POSIXThreads); 3220 PARSE_LANGOPT(Blocks); 3221 PARSE_LANGOPT(EmitAllDecls); 3222 PARSE_LANGOPT(MathErrno); 3223 LangOpts.setSignedOverflowBehavior((LangOptions::SignedOverflowBehaviorTy) 3224 Record[Idx++]); 3225 PARSE_LANGOPT(HeinousExtensions); 3226 PARSE_LANGOPT(Optimize); 3227 PARSE_LANGOPT(OptimizeSize); 3228 PARSE_LANGOPT(Static); 3229 PARSE_LANGOPT(PICLevel); 3230 PARSE_LANGOPT(GNUInline); 3231 PARSE_LANGOPT(NoInline); 3232 PARSE_LANGOPT(Deprecated); 3233 PARSE_LANGOPT(AccessControl); 3234 PARSE_LANGOPT(CharIsSigned); 3235 PARSE_LANGOPT(ShortWChar); 3236 PARSE_LANGOPT(ShortEnums); 3237 LangOpts.setGCMode((LangOptions::GCMode)Record[Idx++]); 3238 LangOpts.setVisibilityMode((Visibility)Record[Idx++]); 3239 LangOpts.setStackProtectorMode((LangOptions::StackProtectorMode) 3240 Record[Idx++]); 3241 PARSE_LANGOPT(InstantiationDepth); 3242 PARSE_LANGOPT(OpenCL); 3243 PARSE_LANGOPT(CUDA); 3244 PARSE_LANGOPT(CatchUndefined); 3245 PARSE_LANGOPT(DefaultFPContract); 3246 PARSE_LANGOPT(ElideConstructors); 3247 PARSE_LANGOPT(SpellChecking); 3248 PARSE_LANGOPT(MRTD); 3249 PARSE_LANGOPT(ObjCAutoRefCount); 3250 PARSE_LANGOPT(ObjCInferRelatedReturnType); 3251 #undef PARSE_LANGOPT 3252 3253 return Listener->ReadLanguageOptions(LangOpts); 3254 } 3255 3256 return false; 3257} 3258 3259void ASTReader::ReadPreprocessedEntities() { 3260 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 3261 Module &F = *(*I); 3262 if (!F.PreprocessorDetailCursor.getBitStreamReader()) 3263 continue; 3264 3265 SavedStreamPosition SavedPosition(F.PreprocessorDetailCursor); 3266 F.PreprocessorDetailCursor.JumpToBit(F.PreprocessorDetailStartOffset); 3267 while (LoadPreprocessedEntity(F)) { } 3268 } 3269} 3270 3271PreprocessedEntity *ASTReader::ReadPreprocessedEntityAtOffset(uint64_t Offset) { 3272 RecordLocation Loc = getLocalBitOffset(Offset); 3273 3274 // Keep track of where we are in the stream, then jump back there 3275 // after reading this entity. 3276 SavedStreamPosition SavedPosition(Loc.F->PreprocessorDetailCursor); 3277 Loc.F->PreprocessorDetailCursor.JumpToBit(Loc.Offset); 3278 return LoadPreprocessedEntity(*Loc.F); 3279} 3280 3281HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) { 3282 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 3283 Module &F = *(*I); 3284 3285 HeaderFileInfoTrait Trait(*this, F, &PP->getHeaderSearchInfo(), 3286 F.HeaderFileFrameworkStrings, 3287 FE->getName()); 3288 3289 HeaderFileInfoLookupTable *Table 3290 = static_cast<HeaderFileInfoLookupTable *>(F.HeaderFileInfoTable); 3291 if (!Table) 3292 continue; 3293 3294 // Look in the on-disk hash table for an entry for this file name. 3295 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE->getName(), 3296 &Trait); 3297 if (Pos == Table->end()) 3298 continue; 3299 3300 HeaderFileInfo HFI = *Pos; 3301 if (Listener) 3302 Listener->ReadHeaderFileInfo(HFI, FE->getUID()); 3303 3304 return HFI; 3305 } 3306 3307 return HeaderFileInfo(); 3308} 3309 3310void ASTReader::ReadPragmaDiagnosticMappings(Diagnostic &Diag) { 3311 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 3312 Module &F = *(*I); 3313 unsigned Idx = 0; 3314 while (Idx < F.PragmaDiagMappings.size()) { 3315 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]); 3316 while (1) { 3317 assert(Idx < F.PragmaDiagMappings.size() && 3318 "Invalid data, didn't find '-1' marking end of diag/map pairs"); 3319 if (Idx >= F.PragmaDiagMappings.size()) { 3320 break; // Something is messed up but at least avoid infinite loop in 3321 // release build. 3322 } 3323 unsigned DiagID = F.PragmaDiagMappings[Idx++]; 3324 if (DiagID == (unsigned)-1) { 3325 break; // no more diag/map pairs for this location. 3326 } 3327 diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++]; 3328 Diag.setDiagnosticMapping(DiagID, Map, Loc); 3329 } 3330 } 3331 } 3332} 3333 3334/// \brief Get the correct cursor and offset for loading a type. 3335ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) { 3336 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index); 3337 assert(I != GlobalTypeMap.end() && "Corrupted global type map"); 3338 Module *M = I->second; 3339 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]); 3340} 3341 3342/// \brief Read and return the type with the given index.. 3343/// 3344/// The index is the type ID, shifted and minus the number of predefs. This 3345/// routine actually reads the record corresponding to the type at the given 3346/// location. It is a helper routine for GetType, which deals with reading type 3347/// IDs. 3348QualType ASTReader::readTypeRecord(unsigned Index) { 3349 RecordLocation Loc = TypeCursorForIndex(Index); 3350 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor; 3351 3352 // Keep track of where we are in the stream, then jump back there 3353 // after reading this type. 3354 SavedStreamPosition SavedPosition(DeclsCursor); 3355 3356 ReadingKindTracker ReadingKind(Read_Type, *this); 3357 3358 // Note that we are loading a type record. 3359 Deserializing AType(this); 3360 3361 unsigned Idx = 0; 3362 DeclsCursor.JumpToBit(Loc.Offset); 3363 RecordData Record; 3364 unsigned Code = DeclsCursor.ReadCode(); 3365 switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) { 3366 case TYPE_EXT_QUAL: { 3367 if (Record.size() != 2) { 3368 Error("Incorrect encoding of extended qualifier type"); 3369 return QualType(); 3370 } 3371 QualType Base = readType(*Loc.F, Record, Idx); 3372 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]); 3373 return Context->getQualifiedType(Base, Quals); 3374 } 3375 3376 case TYPE_COMPLEX: { 3377 if (Record.size() != 1) { 3378 Error("Incorrect encoding of complex type"); 3379 return QualType(); 3380 } 3381 QualType ElemType = readType(*Loc.F, Record, Idx); 3382 return Context->getComplexType(ElemType); 3383 } 3384 3385 case TYPE_POINTER: { 3386 if (Record.size() != 1) { 3387 Error("Incorrect encoding of pointer type"); 3388 return QualType(); 3389 } 3390 QualType PointeeType = readType(*Loc.F, Record, Idx); 3391 return Context->getPointerType(PointeeType); 3392 } 3393 3394 case TYPE_BLOCK_POINTER: { 3395 if (Record.size() != 1) { 3396 Error("Incorrect encoding of block pointer type"); 3397 return QualType(); 3398 } 3399 QualType PointeeType = readType(*Loc.F, Record, Idx); 3400 return Context->getBlockPointerType(PointeeType); 3401 } 3402 3403 case TYPE_LVALUE_REFERENCE: { 3404 if (Record.size() != 2) { 3405 Error("Incorrect encoding of lvalue reference type"); 3406 return QualType(); 3407 } 3408 QualType PointeeType = readType(*Loc.F, Record, Idx); 3409 return Context->getLValueReferenceType(PointeeType, Record[1]); 3410 } 3411 3412 case TYPE_RVALUE_REFERENCE: { 3413 if (Record.size() != 1) { 3414 Error("Incorrect encoding of rvalue reference type"); 3415 return QualType(); 3416 } 3417 QualType PointeeType = readType(*Loc.F, Record, Idx); 3418 return Context->getRValueReferenceType(PointeeType); 3419 } 3420 3421 case TYPE_MEMBER_POINTER: { 3422 if (Record.size() != 2) { 3423 Error("Incorrect encoding of member pointer type"); 3424 return QualType(); 3425 } 3426 QualType PointeeType = readType(*Loc.F, Record, Idx); 3427 QualType ClassType = readType(*Loc.F, Record, Idx); 3428 if (PointeeType.isNull() || ClassType.isNull()) 3429 return QualType(); 3430 3431 return Context->getMemberPointerType(PointeeType, ClassType.getTypePtr()); 3432 } 3433 3434 case TYPE_CONSTANT_ARRAY: { 3435 QualType ElementType = readType(*Loc.F, Record, Idx); 3436 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3437 unsigned IndexTypeQuals = Record[2]; 3438 unsigned Idx = 3; 3439 llvm::APInt Size = ReadAPInt(Record, Idx); 3440 return Context->getConstantArrayType(ElementType, Size, 3441 ASM, IndexTypeQuals); 3442 } 3443 3444 case TYPE_INCOMPLETE_ARRAY: { 3445 QualType ElementType = readType(*Loc.F, Record, Idx); 3446 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3447 unsigned IndexTypeQuals = Record[2]; 3448 return Context->getIncompleteArrayType(ElementType, ASM, IndexTypeQuals); 3449 } 3450 3451 case TYPE_VARIABLE_ARRAY: { 3452 QualType ElementType = readType(*Loc.F, Record, Idx); 3453 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3454 unsigned IndexTypeQuals = Record[2]; 3455 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]); 3456 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]); 3457 return Context->getVariableArrayType(ElementType, ReadExpr(*Loc.F), 3458 ASM, IndexTypeQuals, 3459 SourceRange(LBLoc, RBLoc)); 3460 } 3461 3462 case TYPE_VECTOR: { 3463 if (Record.size() != 3) { 3464 Error("incorrect encoding of vector type in AST file"); 3465 return QualType(); 3466 } 3467 3468 QualType ElementType = readType(*Loc.F, Record, Idx); 3469 unsigned NumElements = Record[1]; 3470 unsigned VecKind = Record[2]; 3471 return Context->getVectorType(ElementType, NumElements, 3472 (VectorType::VectorKind)VecKind); 3473 } 3474 3475 case TYPE_EXT_VECTOR: { 3476 if (Record.size() != 3) { 3477 Error("incorrect encoding of extended vector type in AST file"); 3478 return QualType(); 3479 } 3480 3481 QualType ElementType = readType(*Loc.F, Record, Idx); 3482 unsigned NumElements = Record[1]; 3483 return Context->getExtVectorType(ElementType, NumElements); 3484 } 3485 3486 case TYPE_FUNCTION_NO_PROTO: { 3487 if (Record.size() != 6) { 3488 Error("incorrect encoding of no-proto function type"); 3489 return QualType(); 3490 } 3491 QualType ResultType = readType(*Loc.F, Record, Idx); 3492 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3], 3493 (CallingConv)Record[4], Record[5]); 3494 return Context->getFunctionNoProtoType(ResultType, Info); 3495 } 3496 3497 case TYPE_FUNCTION_PROTO: { 3498 QualType ResultType = readType(*Loc.F, Record, Idx); 3499 3500 FunctionProtoType::ExtProtoInfo EPI; 3501 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1], 3502 /*hasregparm*/ Record[2], 3503 /*regparm*/ Record[3], 3504 static_cast<CallingConv>(Record[4]), 3505 /*produces*/ Record[5]); 3506 3507 unsigned Idx = 6; 3508 unsigned NumParams = Record[Idx++]; 3509 SmallVector<QualType, 16> ParamTypes; 3510 for (unsigned I = 0; I != NumParams; ++I) 3511 ParamTypes.push_back(readType(*Loc.F, Record, Idx)); 3512 3513 EPI.Variadic = Record[Idx++]; 3514 EPI.TypeQuals = Record[Idx++]; 3515 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]); 3516 ExceptionSpecificationType EST = 3517 static_cast<ExceptionSpecificationType>(Record[Idx++]); 3518 EPI.ExceptionSpecType = EST; 3519 if (EST == EST_Dynamic) { 3520 EPI.NumExceptions = Record[Idx++]; 3521 SmallVector<QualType, 2> Exceptions; 3522 for (unsigned I = 0; I != EPI.NumExceptions; ++I) 3523 Exceptions.push_back(readType(*Loc.F, Record, Idx)); 3524 EPI.Exceptions = Exceptions.data(); 3525 } else if (EST == EST_ComputedNoexcept) { 3526 EPI.NoexceptExpr = ReadExpr(*Loc.F); 3527 } 3528 return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams, 3529 EPI); 3530 } 3531 3532 case TYPE_UNRESOLVED_USING: { 3533 unsigned Idx = 0; 3534 return Context->getTypeDeclType( 3535 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx)); 3536 } 3537 3538 case TYPE_TYPEDEF: { 3539 if (Record.size() != 2) { 3540 Error("incorrect encoding of typedef type"); 3541 return QualType(); 3542 } 3543 unsigned Idx = 0; 3544 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx); 3545 QualType Canonical = readType(*Loc.F, Record, Idx); 3546 if (!Canonical.isNull()) 3547 Canonical = Context->getCanonicalType(Canonical); 3548 return Context->getTypedefType(Decl, Canonical); 3549 } 3550 3551 case TYPE_TYPEOF_EXPR: 3552 return Context->getTypeOfExprType(ReadExpr(*Loc.F)); 3553 3554 case TYPE_TYPEOF: { 3555 if (Record.size() != 1) { 3556 Error("incorrect encoding of typeof(type) in AST file"); 3557 return QualType(); 3558 } 3559 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 3560 return Context->getTypeOfType(UnderlyingType); 3561 } 3562 3563 case TYPE_DECLTYPE: 3564 return Context->getDecltypeType(ReadExpr(*Loc.F)); 3565 3566 case TYPE_UNARY_TRANSFORM: { 3567 QualType BaseType = readType(*Loc.F, Record, Idx); 3568 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 3569 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2]; 3570 return Context->getUnaryTransformType(BaseType, UnderlyingType, UKind); 3571 } 3572 3573 case TYPE_AUTO: 3574 return Context->getAutoType(readType(*Loc.F, Record, Idx)); 3575 3576 case TYPE_RECORD: { 3577 if (Record.size() != 2) { 3578 Error("incorrect encoding of record type"); 3579 return QualType(); 3580 } 3581 unsigned Idx = 0; 3582 bool IsDependent = Record[Idx++]; 3583 QualType T 3584 = Context->getRecordType(ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx)); 3585 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3586 return T; 3587 } 3588 3589 case TYPE_ENUM: { 3590 if (Record.size() != 2) { 3591 Error("incorrect encoding of enum type"); 3592 return QualType(); 3593 } 3594 unsigned Idx = 0; 3595 bool IsDependent = Record[Idx++]; 3596 QualType T 3597 = Context->getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx)); 3598 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3599 return T; 3600 } 3601 3602 case TYPE_ATTRIBUTED: { 3603 if (Record.size() != 3) { 3604 Error("incorrect encoding of attributed type"); 3605 return QualType(); 3606 } 3607 QualType modifiedType = readType(*Loc.F, Record, Idx); 3608 QualType equivalentType = readType(*Loc.F, Record, Idx); 3609 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]); 3610 return Context->getAttributedType(kind, modifiedType, equivalentType); 3611 } 3612 3613 case TYPE_PAREN: { 3614 if (Record.size() != 1) { 3615 Error("incorrect encoding of paren type"); 3616 return QualType(); 3617 } 3618 QualType InnerType = readType(*Loc.F, Record, Idx); 3619 return Context->getParenType(InnerType); 3620 } 3621 3622 case TYPE_PACK_EXPANSION: { 3623 if (Record.size() != 2) { 3624 Error("incorrect encoding of pack expansion type"); 3625 return QualType(); 3626 } 3627 QualType Pattern = readType(*Loc.F, Record, Idx); 3628 if (Pattern.isNull()) 3629 return QualType(); 3630 llvm::Optional<unsigned> NumExpansions; 3631 if (Record[1]) 3632 NumExpansions = Record[1] - 1; 3633 return Context->getPackExpansionType(Pattern, NumExpansions); 3634 } 3635 3636 case TYPE_ELABORATED: { 3637 unsigned Idx = 0; 3638 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3639 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3640 QualType NamedType = readType(*Loc.F, Record, Idx); 3641 return Context->getElaboratedType(Keyword, NNS, NamedType); 3642 } 3643 3644 case TYPE_OBJC_INTERFACE: { 3645 unsigned Idx = 0; 3646 ObjCInterfaceDecl *ItfD 3647 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx); 3648 return Context->getObjCInterfaceType(ItfD); 3649 } 3650 3651 case TYPE_OBJC_OBJECT: { 3652 unsigned Idx = 0; 3653 QualType Base = readType(*Loc.F, Record, Idx); 3654 unsigned NumProtos = Record[Idx++]; 3655 SmallVector<ObjCProtocolDecl*, 4> Protos; 3656 for (unsigned I = 0; I != NumProtos; ++I) 3657 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx)); 3658 return Context->getObjCObjectType(Base, Protos.data(), NumProtos); 3659 } 3660 3661 case TYPE_OBJC_OBJECT_POINTER: { 3662 unsigned Idx = 0; 3663 QualType Pointee = readType(*Loc.F, Record, Idx); 3664 return Context->getObjCObjectPointerType(Pointee); 3665 } 3666 3667 case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 3668 unsigned Idx = 0; 3669 QualType Parm = readType(*Loc.F, Record, Idx); 3670 QualType Replacement = readType(*Loc.F, Record, Idx); 3671 return 3672 Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm), 3673 Replacement); 3674 } 3675 3676 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: { 3677 unsigned Idx = 0; 3678 QualType Parm = readType(*Loc.F, Record, Idx); 3679 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx); 3680 return Context->getSubstTemplateTypeParmPackType( 3681 cast<TemplateTypeParmType>(Parm), 3682 ArgPack); 3683 } 3684 3685 case TYPE_INJECTED_CLASS_NAME: { 3686 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx); 3687 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable 3688 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 3689 // for AST reading, too much interdependencies. 3690 return 3691 QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0); 3692 } 3693 3694 case TYPE_TEMPLATE_TYPE_PARM: { 3695 unsigned Idx = 0; 3696 unsigned Depth = Record[Idx++]; 3697 unsigned Index = Record[Idx++]; 3698 bool Pack = Record[Idx++]; 3699 TemplateTypeParmDecl *D 3700 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx); 3701 return Context->getTemplateTypeParmType(Depth, Index, Pack, D); 3702 } 3703 3704 case TYPE_DEPENDENT_NAME: { 3705 unsigned Idx = 0; 3706 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3707 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3708 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 3709 QualType Canon = readType(*Loc.F, Record, Idx); 3710 if (!Canon.isNull()) 3711 Canon = Context->getCanonicalType(Canon); 3712 return Context->getDependentNameType(Keyword, NNS, Name, Canon); 3713 } 3714 3715 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 3716 unsigned Idx = 0; 3717 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3718 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3719 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 3720 unsigned NumArgs = Record[Idx++]; 3721 SmallVector<TemplateArgument, 8> Args; 3722 Args.reserve(NumArgs); 3723 while (NumArgs--) 3724 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx)); 3725 return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name, 3726 Args.size(), Args.data()); 3727 } 3728 3729 case TYPE_DEPENDENT_SIZED_ARRAY: { 3730 unsigned Idx = 0; 3731 3732 // ArrayType 3733 QualType ElementType = readType(*Loc.F, Record, Idx); 3734 ArrayType::ArraySizeModifier ASM 3735 = (ArrayType::ArraySizeModifier)Record[Idx++]; 3736 unsigned IndexTypeQuals = Record[Idx++]; 3737 3738 // DependentSizedArrayType 3739 Expr *NumElts = ReadExpr(*Loc.F); 3740 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx); 3741 3742 return Context->getDependentSizedArrayType(ElementType, NumElts, ASM, 3743 IndexTypeQuals, Brackets); 3744 } 3745 3746 case TYPE_TEMPLATE_SPECIALIZATION: { 3747 unsigned Idx = 0; 3748 bool IsDependent = Record[Idx++]; 3749 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx); 3750 SmallVector<TemplateArgument, 8> Args; 3751 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx); 3752 QualType Underlying = readType(*Loc.F, Record, Idx); 3753 QualType T; 3754 if (Underlying.isNull()) 3755 T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(), 3756 Args.size()); 3757 else 3758 T = Context->getTemplateSpecializationType(Name, Args.data(), 3759 Args.size(), Underlying); 3760 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3761 return T; 3762 } 3763 } 3764 // Suppress a GCC warning 3765 return QualType(); 3766} 3767 3768class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> { 3769 ASTReader &Reader; 3770 Module &F; 3771 llvm::BitstreamCursor &DeclsCursor; 3772 const ASTReader::RecordData &Record; 3773 unsigned &Idx; 3774 3775 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R, 3776 unsigned &I) { 3777 return Reader.ReadSourceLocation(F, R, I); 3778 } 3779 3780 template<typename T> 3781 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) { 3782 return Reader.ReadDeclAs<T>(F, Record, Idx); 3783 } 3784 3785public: 3786 TypeLocReader(ASTReader &Reader, Module &F, 3787 const ASTReader::RecordData &Record, unsigned &Idx) 3788 : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx) 3789 { } 3790 3791 // We want compile-time assurance that we've enumerated all of 3792 // these, so unfortunately we have to declare them first, then 3793 // define them out-of-line. 3794#define ABSTRACT_TYPELOC(CLASS, PARENT) 3795#define TYPELOC(CLASS, PARENT) \ 3796 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 3797#include "clang/AST/TypeLocNodes.def" 3798 3799 void VisitFunctionTypeLoc(FunctionTypeLoc); 3800 void VisitArrayTypeLoc(ArrayTypeLoc); 3801}; 3802 3803void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 3804 // nothing to do 3805} 3806void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 3807 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx)); 3808 if (TL.needsExtraLocalData()) { 3809 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 3810 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 3811 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 3812 TL.setModeAttr(Record[Idx++]); 3813 } 3814} 3815void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 3816 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3817} 3818void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 3819 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3820} 3821void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 3822 TL.setCaretLoc(ReadSourceLocation(Record, Idx)); 3823} 3824void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 3825 TL.setAmpLoc(ReadSourceLocation(Record, Idx)); 3826} 3827void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 3828 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 3829} 3830void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 3831 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3832 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3833} 3834void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 3835 TL.setLBracketLoc(ReadSourceLocation(Record, Idx)); 3836 TL.setRBracketLoc(ReadSourceLocation(Record, Idx)); 3837 if (Record[Idx++]) 3838 TL.setSizeExpr(Reader.ReadExpr(F)); 3839 else 3840 TL.setSizeExpr(0); 3841} 3842void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 3843 VisitArrayTypeLoc(TL); 3844} 3845void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 3846 VisitArrayTypeLoc(TL); 3847} 3848void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 3849 VisitArrayTypeLoc(TL); 3850} 3851void TypeLocReader::VisitDependentSizedArrayTypeLoc( 3852 DependentSizedArrayTypeLoc TL) { 3853 VisitArrayTypeLoc(TL); 3854} 3855void TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 3856 DependentSizedExtVectorTypeLoc TL) { 3857 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3858} 3859void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 3860 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3861} 3862void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 3863 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3864} 3865void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 3866 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx)); 3867 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx)); 3868 TL.setTrailingReturn(Record[Idx++]); 3869 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 3870 TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx)); 3871 } 3872} 3873void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 3874 VisitFunctionTypeLoc(TL); 3875} 3876void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 3877 VisitFunctionTypeLoc(TL); 3878} 3879void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 3880 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3881} 3882void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 3883 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3884} 3885void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 3886 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 3887 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3888 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3889} 3890void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 3891 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 3892 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3893 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3894 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3895} 3896void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 3897 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3898} 3899void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 3900 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 3901 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3902 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3903 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3904} 3905void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) { 3906 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3907} 3908void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 3909 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3910} 3911void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 3912 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3913} 3914void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 3915 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx)); 3916 if (TL.hasAttrOperand()) { 3917 SourceRange range; 3918 range.setBegin(ReadSourceLocation(Record, Idx)); 3919 range.setEnd(ReadSourceLocation(Record, Idx)); 3920 TL.setAttrOperandParensRange(range); 3921 } 3922 if (TL.hasAttrExprOperand()) { 3923 if (Record[Idx++]) 3924 TL.setAttrExprOperand(Reader.ReadExpr(F)); 3925 else 3926 TL.setAttrExprOperand(0); 3927 } else if (TL.hasAttrEnumOperand()) 3928 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx)); 3929} 3930void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 3931 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3932} 3933void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 3934 SubstTemplateTypeParmTypeLoc TL) { 3935 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3936} 3937void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc( 3938 SubstTemplateTypeParmPackTypeLoc TL) { 3939 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3940} 3941void TypeLocReader::VisitTemplateSpecializationTypeLoc( 3942 TemplateSpecializationTypeLoc TL) { 3943 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 3944 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3945 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3946 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 3947 TL.setArgLocInfo(i, 3948 Reader.GetTemplateArgumentLocInfo(F, 3949 TL.getTypePtr()->getArg(i).getKind(), 3950 Record, Idx)); 3951} 3952void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) { 3953 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3954 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3955} 3956void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 3957 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3958 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3959} 3960void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 3961 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3962} 3963void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 3964 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3965 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3966 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3967} 3968void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 3969 DependentTemplateSpecializationTypeLoc TL) { 3970 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3971 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3972 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3973 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3974 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3975 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 3976 TL.setArgLocInfo(I, 3977 Reader.GetTemplateArgumentLocInfo(F, 3978 TL.getTypePtr()->getArg(I).getKind(), 3979 Record, Idx)); 3980} 3981void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 3982 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx)); 3983} 3984void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 3985 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3986} 3987void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 3988 TL.setHasBaseTypeAsWritten(Record[Idx++]); 3989 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3990 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3991 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 3992 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx)); 3993} 3994void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 3995 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3996} 3997 3998TypeSourceInfo *ASTReader::GetTypeSourceInfo(Module &F, 3999 const RecordData &Record, 4000 unsigned &Idx) { 4001 QualType InfoTy = readType(F, Record, Idx); 4002 if (InfoTy.isNull()) 4003 return 0; 4004 4005 TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy); 4006 TypeLocReader TLR(*this, F, Record, Idx); 4007 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 4008 TLR.Visit(TL); 4009 return TInfo; 4010} 4011 4012QualType ASTReader::GetType(TypeID ID) { 4013 unsigned FastQuals = ID & Qualifiers::FastMask; 4014 unsigned Index = ID >> Qualifiers::FastWidth; 4015 4016 if (Index < NUM_PREDEF_TYPE_IDS) { 4017 QualType T; 4018 switch ((PredefinedTypeIDs)Index) { 4019 case PREDEF_TYPE_NULL_ID: return QualType(); 4020 case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break; 4021 case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; break; 4022 4023 case PREDEF_TYPE_CHAR_U_ID: 4024 case PREDEF_TYPE_CHAR_S_ID: 4025 // FIXME: Check that the signedness of CharTy is correct! 4026 T = Context->CharTy; 4027 break; 4028 4029 case PREDEF_TYPE_UCHAR_ID: T = Context->UnsignedCharTy; break; 4030 case PREDEF_TYPE_USHORT_ID: T = Context->UnsignedShortTy; break; 4031 case PREDEF_TYPE_UINT_ID: T = Context->UnsignedIntTy; break; 4032 case PREDEF_TYPE_ULONG_ID: T = Context->UnsignedLongTy; break; 4033 case PREDEF_TYPE_ULONGLONG_ID: T = Context->UnsignedLongLongTy; break; 4034 case PREDEF_TYPE_UINT128_ID: T = Context->UnsignedInt128Ty; break; 4035 case PREDEF_TYPE_SCHAR_ID: T = Context->SignedCharTy; break; 4036 case PREDEF_TYPE_WCHAR_ID: T = Context->WCharTy; break; 4037 case PREDEF_TYPE_SHORT_ID: T = Context->ShortTy; break; 4038 case PREDEF_TYPE_INT_ID: T = Context->IntTy; break; 4039 case PREDEF_TYPE_LONG_ID: T = Context->LongTy; break; 4040 case PREDEF_TYPE_LONGLONG_ID: T = Context->LongLongTy; break; 4041 case PREDEF_TYPE_INT128_ID: T = Context->Int128Ty; break; 4042 case PREDEF_TYPE_FLOAT_ID: T = Context->FloatTy; break; 4043 case PREDEF_TYPE_DOUBLE_ID: T = Context->DoubleTy; break; 4044 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy; break; 4045 case PREDEF_TYPE_OVERLOAD_ID: T = Context->OverloadTy; break; 4046 case PREDEF_TYPE_BOUND_MEMBER: T = Context->BoundMemberTy; break; 4047 case PREDEF_TYPE_DEPENDENT_ID: T = Context->DependentTy; break; 4048 case PREDEF_TYPE_UNKNOWN_ANY: T = Context->UnknownAnyTy; break; 4049 case PREDEF_TYPE_NULLPTR_ID: T = Context->NullPtrTy; break; 4050 case PREDEF_TYPE_CHAR16_ID: T = Context->Char16Ty; break; 4051 case PREDEF_TYPE_CHAR32_ID: T = Context->Char32Ty; break; 4052 case PREDEF_TYPE_OBJC_ID: T = Context->ObjCBuiltinIdTy; break; 4053 case PREDEF_TYPE_OBJC_CLASS: T = Context->ObjCBuiltinClassTy; break; 4054 case PREDEF_TYPE_OBJC_SEL: T = Context->ObjCBuiltinSelTy; break; 4055 case PREDEF_TYPE_AUTO_DEDUCT: T = Context->getAutoDeductType(); break; 4056 4057 case PREDEF_TYPE_AUTO_RREF_DEDUCT: 4058 T = Context->getAutoRRefDeductType(); 4059 break; 4060 } 4061 4062 assert(!T.isNull() && "Unknown predefined type"); 4063 return T.withFastQualifiers(FastQuals); 4064 } 4065 4066 Index -= NUM_PREDEF_TYPE_IDS; 4067 assert(Index < TypesLoaded.size() && "Type index out-of-range"); 4068 if (TypesLoaded[Index].isNull()) { 4069 TypesLoaded[Index] = readTypeRecord(Index); 4070 if (TypesLoaded[Index].isNull()) 4071 return QualType(); 4072 4073 TypesLoaded[Index]->setFromAST(); 4074 if (DeserializationListener) 4075 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 4076 TypesLoaded[Index]); 4077 } 4078 4079 return TypesLoaded[Index].withFastQualifiers(FastQuals); 4080} 4081 4082QualType ASTReader::getLocalType(Module &F, unsigned LocalID) { 4083 return GetType(getGlobalTypeID(F, LocalID)); 4084} 4085 4086serialization::TypeID 4087ASTReader::getGlobalTypeID(Module &F, unsigned LocalID) const { 4088 unsigned FastQuals = LocalID & Qualifiers::FastMask; 4089 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth; 4090 4091 if (LocalIndex < NUM_PREDEF_TYPE_IDS) 4092 return LocalID; 4093 4094 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4095 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS); 4096 assert(I != F.TypeRemap.end() && "Invalid index into type index remap"); 4097 4098 unsigned GlobalIndex = LocalIndex + I->second; 4099 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals; 4100} 4101 4102TemplateArgumentLocInfo 4103ASTReader::GetTemplateArgumentLocInfo(Module &F, 4104 TemplateArgument::ArgKind Kind, 4105 const RecordData &Record, 4106 unsigned &Index) { 4107 switch (Kind) { 4108 case TemplateArgument::Expression: 4109 return ReadExpr(F); 4110 case TemplateArgument::Type: 4111 return GetTypeSourceInfo(F, Record, Index); 4112 case TemplateArgument::Template: { 4113 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 4114 Index); 4115 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 4116 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 4117 SourceLocation()); 4118 } 4119 case TemplateArgument::TemplateExpansion: { 4120 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 4121 Index); 4122 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 4123 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index); 4124 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 4125 EllipsisLoc); 4126 } 4127 case TemplateArgument::Null: 4128 case TemplateArgument::Integral: 4129 case TemplateArgument::Declaration: 4130 case TemplateArgument::Pack: 4131 return TemplateArgumentLocInfo(); 4132 } 4133 llvm_unreachable("unexpected template argument loc"); 4134 return TemplateArgumentLocInfo(); 4135} 4136 4137TemplateArgumentLoc 4138ASTReader::ReadTemplateArgumentLoc(Module &F, 4139 const RecordData &Record, unsigned &Index) { 4140 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index); 4141 4142 if (Arg.getKind() == TemplateArgument::Expression) { 4143 if (Record[Index++]) // bool InfoHasSameExpr. 4144 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 4145 } 4146 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(), 4147 Record, Index)); 4148} 4149 4150Decl *ASTReader::GetExternalDecl(uint32_t ID) { 4151 return GetDecl(ID); 4152} 4153 4154uint64_t ASTReader::readCXXBaseSpecifiers(Module &M, const RecordData &Record, 4155 unsigned &Idx){ 4156 if (Idx >= Record.size()) 4157 return 0; 4158 4159 unsigned LocalID = Record[Idx++]; 4160 return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]); 4161} 4162 4163CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 4164 RecordLocation Loc = getLocalBitOffset(Offset); 4165 llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor; 4166 SavedStreamPosition SavedPosition(Cursor); 4167 Cursor.JumpToBit(Loc.Offset); 4168 ReadingKindTracker ReadingKind(Read_Decl, *this); 4169 RecordData Record; 4170 unsigned Code = Cursor.ReadCode(); 4171 unsigned RecCode = Cursor.ReadRecord(Code, Record); 4172 if (RecCode != DECL_CXX_BASE_SPECIFIERS) { 4173 Error("Malformed AST file: missing C++ base specifiers"); 4174 return 0; 4175 } 4176 4177 unsigned Idx = 0; 4178 unsigned NumBases = Record[Idx++]; 4179 void *Mem = Context->Allocate(sizeof(CXXBaseSpecifier) * NumBases); 4180 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases]; 4181 for (unsigned I = 0; I != NumBases; ++I) 4182 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx); 4183 return Bases; 4184} 4185 4186serialization::DeclID 4187ASTReader::getGlobalDeclID(Module &F, unsigned LocalID) const { 4188 if (LocalID < NUM_PREDEF_DECL_IDS) 4189 return LocalID; 4190 4191 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4192 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS); 4193 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap"); 4194 4195 return LocalID + I->second; 4196} 4197 4198Decl *ASTReader::GetDecl(DeclID ID) { 4199 if (ID < NUM_PREDEF_DECL_IDS) { 4200 switch ((PredefinedDeclIDs)ID) { 4201 case PREDEF_DECL_NULL_ID: 4202 return 0; 4203 4204 case PREDEF_DECL_TRANSLATION_UNIT_ID: 4205 assert(Context && "No context available?"); 4206 return Context->getTranslationUnitDecl(); 4207 4208 case PREDEF_DECL_OBJC_ID_ID: 4209 assert(Context && "No context available?"); 4210 return Context->getObjCIdDecl(); 4211 4212 case PREDEF_DECL_OBJC_SEL_ID: 4213 assert(Context && "No context available?"); 4214 return Context->getObjCSelDecl(); 4215 4216 case PREDEF_DECL_OBJC_CLASS_ID: 4217 assert(Context && "No context available?"); 4218 return Context->getObjCClassDecl(); 4219 4220 case PREDEF_DECL_INT_128_ID: 4221 assert(Context && "No context available?"); 4222 return Context->getInt128Decl(); 4223 4224 case PREDEF_DECL_UNSIGNED_INT_128_ID: 4225 assert(Context && "No context available?"); 4226 return Context->getUInt128Decl(); 4227 } 4228 4229 return 0; 4230 } 4231 4232 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 4233 4234 if (Index > DeclsLoaded.size()) { 4235 Error("declaration ID out-of-range for AST file"); 4236 return 0; 4237 } 4238 4239if (!DeclsLoaded[Index]) { 4240 ReadDeclRecord(ID); 4241 if (DeserializationListener) 4242 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 4243 } 4244 4245 return DeclsLoaded[Index]; 4246} 4247 4248serialization::DeclID ASTReader::ReadDeclID(Module &F, 4249 const RecordData &Record, 4250 unsigned &Idx) { 4251 if (Idx >= Record.size()) { 4252 Error("Corrupted AST file"); 4253 return 0; 4254 } 4255 4256 return getGlobalDeclID(F, Record[Idx++]); 4257} 4258 4259/// \brief Resolve the offset of a statement into a statement. 4260/// 4261/// This operation will read a new statement from the external 4262/// source each time it is called, and is meant to be used via a 4263/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 4264Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 4265 // Switch case IDs are per Decl. 4266 ClearSwitchCaseIDs(); 4267 4268 // Offset here is a global offset across the entire chain. 4269 RecordLocation Loc = getLocalBitOffset(Offset); 4270 Loc.F->DeclsCursor.JumpToBit(Loc.Offset); 4271 return ReadStmtFromStream(*Loc.F); 4272} 4273 4274ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 4275 bool (*isKindWeWant)(Decl::Kind), 4276 SmallVectorImpl<Decl*> &Decls) { 4277 // There might be lexical decls in multiple parts of the chain, for the TU 4278 // at least. 4279 // DeclContextOffsets might reallocate as we load additional decls below, 4280 // so make a copy of the vector. 4281 DeclContextInfos Infos = DeclContextOffsets[DC]; 4282 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end(); 4283 I != E; ++I) { 4284 // IDs can be 0 if this context doesn't contain declarations. 4285 if (!I->LexicalDecls) 4286 continue; 4287 4288 // Load all of the declaration IDs 4289 for (const KindDeclIDPair *ID = I->LexicalDecls, 4290 *IDE = ID + I->NumLexicalDecls; ID != IDE; ++ID) { 4291 if (isKindWeWant && !isKindWeWant((Decl::Kind)ID->first)) 4292 continue; 4293 4294 Decl *D = GetLocalDecl(*I->F, ID->second); 4295 assert(D && "Null decl in lexical decls"); 4296 Decls.push_back(D); 4297 } 4298 } 4299 4300 ++NumLexicalDeclContextsRead; 4301 return ELR_Success; 4302} 4303 4304DeclContext::lookup_result 4305ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 4306 DeclarationName Name) { 4307 assert(DC->hasExternalVisibleStorage() && 4308 "DeclContext has no visible decls in storage"); 4309 if (!Name) 4310 return DeclContext::lookup_result(DeclContext::lookup_iterator(0), 4311 DeclContext::lookup_iterator(0)); 4312 4313 SmallVector<NamedDecl *, 64> Decls; 4314 // There might be visible decls in multiple parts of the chain, for the TU 4315 // and namespaces. For any given name, the last available results replace 4316 // all earlier ones. For this reason, we walk in reverse. 4317 // Copy the DeclContextInfos vector instead of using a reference to the 4318 // vector stored in the map, because DeclContextOffsets can change while 4319 // we load declarations with GetLocalDeclAs. 4320 DeclContextInfos Infos = DeclContextOffsets[DC]; 4321 for (DeclContextInfos::reverse_iterator I = Infos.rbegin(), E = Infos.rend(); 4322 I != E; ++I) { 4323 if (!I->NameLookupTableData) 4324 continue; 4325 4326 ASTDeclContextNameLookupTable *LookupTable = 4327 (ASTDeclContextNameLookupTable*)I->NameLookupTableData; 4328 ASTDeclContextNameLookupTable::iterator Pos = LookupTable->find(Name); 4329 if (Pos == LookupTable->end()) 4330 continue; 4331 4332 ASTDeclContextNameLookupTrait::data_type Data = *Pos; 4333 for (; Data.first != Data.second; ++Data.first) { 4334 NamedDecl *ND = GetLocalDeclAs<NamedDecl>(*I->F, *Data.first); 4335 if (!ND) 4336 continue; 4337 4338 if (ND->getDeclName() != Name) { 4339 assert(!Name.getCXXNameType().isNull() && 4340 "Name mismatch without a type"); 4341 continue; 4342 } 4343 4344 Decls.push_back(ND); 4345 } 4346 4347 // If we rejected all of the declarations we found, e.g., because the 4348 // name didn't actually match, continue looking through DeclContexts. 4349 if (Decls.empty()) 4350 continue; 4351 4352 break; 4353 } 4354 4355 ++NumVisibleDeclContextsRead; 4356 4357 SetExternalVisibleDeclsForName(DC, Name, Decls); 4358 return const_cast<DeclContext*>(DC)->lookup(Name); 4359} 4360 4361void ASTReader::MaterializeVisibleDecls(const DeclContext *DC) { 4362 assert(DC->hasExternalVisibleStorage() && 4363 "DeclContext has no visible decls in storage"); 4364 4365 SmallVector<NamedDecl *, 64> Decls; 4366 // There might be visible decls in multiple parts of the chain, for the TU 4367 // and namespaces. 4368 DeclContextInfos &Infos = DeclContextOffsets[DC]; 4369 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end(); 4370 I != E; ++I) { 4371 if (!I->NameLookupTableData) 4372 continue; 4373 4374 ASTDeclContextNameLookupTable *LookupTable = 4375 (ASTDeclContextNameLookupTable*)I->NameLookupTableData; 4376 for (ASTDeclContextNameLookupTable::item_iterator 4377 ItemI = LookupTable->item_begin(), 4378 ItemEnd = LookupTable->item_end() ; ItemI != ItemEnd; ++ItemI) { 4379 ASTDeclContextNameLookupTable::item_iterator::value_type Val 4380 = *ItemI; 4381 ASTDeclContextNameLookupTrait::data_type Data = Val.second; 4382 Decls.clear(); 4383 for (; Data.first != Data.second; ++Data.first) 4384 Decls.push_back(GetLocalDeclAs<NamedDecl>(*I->F, *Data.first)); 4385 MaterializeVisibleDeclsForName(DC, Val.first, Decls); 4386 } 4387 } 4388} 4389 4390void ASTReader::PassInterestingDeclsToConsumer() { 4391 assert(Consumer); 4392 while (!InterestingDecls.empty()) { 4393 DeclGroupRef DG(InterestingDecls.front()); 4394 InterestingDecls.pop_front(); 4395 Consumer->HandleInterestingDecl(DG); 4396 } 4397} 4398 4399void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 4400 this->Consumer = Consumer; 4401 4402 if (!Consumer) 4403 return; 4404 4405 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 4406 // Force deserialization of this decl, which will cause it to be queued for 4407 // passing to the consumer. 4408 GetDecl(ExternalDefinitions[I]); 4409 } 4410 4411 PassInterestingDeclsToConsumer(); 4412} 4413 4414void ASTReader::PrintStats() { 4415 std::fprintf(stderr, "*** AST File Statistics:\n"); 4416 4417 unsigned NumTypesLoaded 4418 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 4419 QualType()); 4420 unsigned NumDeclsLoaded 4421 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 4422 (Decl *)0); 4423 unsigned NumIdentifiersLoaded 4424 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 4425 IdentifiersLoaded.end(), 4426 (IdentifierInfo *)0); 4427 unsigned NumSelectorsLoaded 4428 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 4429 SelectorsLoaded.end(), 4430 Selector()); 4431 4432 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits); 4433 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses); 4434 if (unsigned TotalNumSLocEntries = getTotalNumSLocs()) 4435 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 4436 NumSLocEntriesRead, TotalNumSLocEntries, 4437 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 4438 if (!TypesLoaded.empty()) 4439 std::fprintf(stderr, " %u/%u types read (%f%%)\n", 4440 NumTypesLoaded, (unsigned)TypesLoaded.size(), 4441 ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 4442 if (!DeclsLoaded.empty()) 4443 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 4444 NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 4445 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 4446 if (!IdentifiersLoaded.empty()) 4447 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 4448 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 4449 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 4450 if (!SelectorsLoaded.empty()) 4451 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 4452 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 4453 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 4454 if (TotalNumStatements) 4455 std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 4456 NumStatementsRead, TotalNumStatements, 4457 ((float)NumStatementsRead/TotalNumStatements * 100)); 4458 if (TotalNumMacros) 4459 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 4460 NumMacrosRead, TotalNumMacros, 4461 ((float)NumMacrosRead/TotalNumMacros * 100)); 4462 if (TotalLexicalDeclContexts) 4463 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 4464 NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 4465 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 4466 * 100)); 4467 if (TotalVisibleDeclContexts) 4468 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 4469 NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 4470 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 4471 * 100)); 4472 if (TotalNumMethodPoolEntries) { 4473 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 4474 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 4475 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 4476 * 100)); 4477 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses); 4478 } 4479 std::fprintf(stderr, "\n"); 4480 dump(); 4481 std::fprintf(stderr, "\n"); 4482} 4483 4484template<typename Key, typename Module, unsigned InitialCapacity> 4485static void 4486dumpModuleIDMap(StringRef Name, 4487 const ContinuousRangeMap<Key, Module *, 4488 InitialCapacity> &Map) { 4489 if (Map.begin() == Map.end()) 4490 return; 4491 4492 typedef ContinuousRangeMap<Key, Module *, InitialCapacity> MapType; 4493 llvm::errs() << Name << ":\n"; 4494 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 4495 I != IEnd; ++I) { 4496 llvm::errs() << " " << I->first << " -> " << I->second->FileName 4497 << "\n"; 4498 } 4499} 4500 4501void ASTReader::dump() { 4502 llvm::errs() << "*** PCH/Module Remappings:\n"; 4503 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap); 4504 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap); 4505 dumpModuleIDMap("Global type map", GlobalTypeMap); 4506 dumpModuleIDMap("Global declaration map", GlobalDeclMap); 4507 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap); 4508 dumpModuleIDMap("Global selector map", GlobalSelectorMap); 4509 dumpModuleIDMap("Global macro definition map", GlobalMacroDefinitionMap); 4510 dumpModuleIDMap("Global preprocessed entity map", 4511 GlobalPreprocessedEntityMap); 4512 4513 llvm::errs() << "\n*** PCH/Modules Loaded:"; 4514 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(), 4515 MEnd = ModuleMgr.end(); 4516 M != MEnd; ++M) 4517 (*M)->dump(); 4518} 4519 4520/// Return the amount of memory used by memory buffers, breaking down 4521/// by heap-backed versus mmap'ed memory. 4522void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const { 4523 for (ModuleConstIterator I = ModuleMgr.begin(), 4524 E = ModuleMgr.end(); I != E; ++I) { 4525 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) { 4526 size_t bytes = buf->getBufferSize(); 4527 switch (buf->getBufferKind()) { 4528 case llvm::MemoryBuffer::MemoryBuffer_Malloc: 4529 sizes.malloc_bytes += bytes; 4530 break; 4531 case llvm::MemoryBuffer::MemoryBuffer_MMap: 4532 sizes.mmap_bytes += bytes; 4533 break; 4534 } 4535 } 4536 } 4537} 4538 4539void ASTReader::InitializeSema(Sema &S) { 4540 SemaObj = &S; 4541 S.ExternalSource = this; 4542 4543 // Makes sure any declarations that were deserialized "too early" 4544 // still get added to the identifier's declaration chains. 4545 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 4546 if (SemaObj->TUScope) 4547 SemaObj->TUScope->AddDecl(PreloadedDecls[I]); 4548 4549 SemaObj->IdResolver.AddDecl(PreloadedDecls[I]); 4550 } 4551 PreloadedDecls.clear(); 4552 4553 // Load the offsets of the declarations that Sema references. 4554 // They will be lazily deserialized when needed. 4555 if (!SemaDeclRefs.empty()) { 4556 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!"); 4557 if (!SemaObj->StdNamespace) 4558 SemaObj->StdNamespace = SemaDeclRefs[0]; 4559 if (!SemaObj->StdBadAlloc) 4560 SemaObj->StdBadAlloc = SemaDeclRefs[1]; 4561 } 4562 4563 if (!FPPragmaOptions.empty()) { 4564 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS"); 4565 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0]; 4566 } 4567 4568 if (!OpenCLExtensions.empty()) { 4569 unsigned I = 0; 4570#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++]; 4571#include "clang/Basic/OpenCLExtensions.def" 4572 4573 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS"); 4574 } 4575} 4576 4577namespace { 4578 /// \brief Visitor class used to look up identifirs in 4579 class IdentifierLookupVisitor { 4580 StringRef Name; 4581 IdentifierInfo *Found; 4582 public: 4583 explicit IdentifierLookupVisitor(StringRef Name) : Name(Name), Found() { } 4584 4585 static bool visit(Module &M, void *UserData) { 4586 IdentifierLookupVisitor *This 4587 = static_cast<IdentifierLookupVisitor *>(UserData); 4588 4589 ASTIdentifierLookupTable *IdTable 4590 = (ASTIdentifierLookupTable *)M.IdentifierLookupTable; 4591 if (!IdTable) 4592 return false; 4593 4594 std::pair<const char*, unsigned> Key(This->Name.begin(), 4595 This->Name.size()); 4596 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key); 4597 if (Pos == IdTable->end()) 4598 return false; 4599 4600 // Dereferencing the iterator has the effect of building the 4601 // IdentifierInfo node and populating it with the various 4602 // declarations it needs. 4603 This->Found = *Pos; 4604 return true; 4605 } 4606 4607 // \brief Retrieve the identifier info found within the module 4608 // files. 4609 IdentifierInfo *getIdentifierInfo() const { return Found; } 4610 }; 4611} 4612 4613IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 4614 std::string Name(NameStart, NameEnd); 4615 IdentifierLookupVisitor Visitor(StringRef(NameStart, NameEnd - NameStart)); 4616 ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor); 4617 return Visitor.getIdentifierInfo(); 4618} 4619 4620namespace clang { 4621 /// \brief An identifier-lookup iterator that enumerates all of the 4622 /// identifiers stored within a set of AST files. 4623 class ASTIdentifierIterator : public IdentifierIterator { 4624 /// \brief The AST reader whose identifiers are being enumerated. 4625 const ASTReader &Reader; 4626 4627 /// \brief The current index into the chain of AST files stored in 4628 /// the AST reader. 4629 unsigned Index; 4630 4631 /// \brief The current position within the identifier lookup table 4632 /// of the current AST file. 4633 ASTIdentifierLookupTable::key_iterator Current; 4634 4635 /// \brief The end position within the identifier lookup table of 4636 /// the current AST file. 4637 ASTIdentifierLookupTable::key_iterator End; 4638 4639 public: 4640 explicit ASTIdentifierIterator(const ASTReader &Reader); 4641 4642 virtual StringRef Next(); 4643 }; 4644} 4645 4646ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader) 4647 : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) { 4648 ASTIdentifierLookupTable *IdTable 4649 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable; 4650 Current = IdTable->key_begin(); 4651 End = IdTable->key_end(); 4652} 4653 4654StringRef ASTIdentifierIterator::Next() { 4655 while (Current == End) { 4656 // If we have exhausted all of our AST files, we're done. 4657 if (Index == 0) 4658 return StringRef(); 4659 4660 --Index; 4661 ASTIdentifierLookupTable *IdTable 4662 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index]. 4663 IdentifierLookupTable; 4664 Current = IdTable->key_begin(); 4665 End = IdTable->key_end(); 4666 } 4667 4668 // We have any identifiers remaining in the current AST file; return 4669 // the next one. 4670 std::pair<const char*, unsigned> Key = *Current; 4671 ++Current; 4672 return StringRef(Key.first, Key.second); 4673} 4674 4675IdentifierIterator *ASTReader::getIdentifiers() const { 4676 return new ASTIdentifierIterator(*this); 4677} 4678 4679std::pair<ObjCMethodList, ObjCMethodList> 4680ASTReader::ReadMethodPool(Selector Sel) { 4681 // Find this selector in a hash table. We want to find the most recent entry. 4682 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 4683 Module &F = *(*I); 4684 if (!F.SelectorLookupTable) 4685 continue; 4686 4687 ASTSelectorLookupTable *PoolTable 4688 = (ASTSelectorLookupTable*)F.SelectorLookupTable; 4689 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel); 4690 if (Pos != PoolTable->end()) { 4691 ++NumSelectorsRead; 4692 // FIXME: Not quite happy with the statistics here. We probably should 4693 // disable this tracking when called via LoadSelector. 4694 // Also, should entries without methods count as misses? 4695 ++NumMethodPoolEntriesRead; 4696 ASTSelectorLookupTrait::data_type Data = *Pos; 4697 if (DeserializationListener) 4698 DeserializationListener->SelectorRead(Data.ID, Sel); 4699 return std::make_pair(Data.Instance, Data.Factory); 4700 } 4701 } 4702 4703 ++NumMethodPoolMisses; 4704 return std::pair<ObjCMethodList, ObjCMethodList>(); 4705} 4706 4707void ASTReader::ReadKnownNamespaces( 4708 SmallVectorImpl<NamespaceDecl *> &Namespaces) { 4709 Namespaces.clear(); 4710 4711 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) { 4712 if (NamespaceDecl *Namespace 4713 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I]))) 4714 Namespaces.push_back(Namespace); 4715 } 4716} 4717 4718void ASTReader::ReadTentativeDefinitions( 4719 SmallVectorImpl<VarDecl *> &TentativeDefs) { 4720 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 4721 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I])); 4722 if (Var) 4723 TentativeDefs.push_back(Var); 4724 } 4725 TentativeDefinitions.clear(); 4726} 4727 4728void ASTReader::ReadUnusedFileScopedDecls( 4729 SmallVectorImpl<const DeclaratorDecl *> &Decls) { 4730 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 4731 DeclaratorDecl *D 4732 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 4733 if (D) 4734 Decls.push_back(D); 4735 } 4736 UnusedFileScopedDecls.clear(); 4737} 4738 4739void ASTReader::ReadDelegatingConstructors( 4740 SmallVectorImpl<CXXConstructorDecl *> &Decls) { 4741 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) { 4742 CXXConstructorDecl *D 4743 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I])); 4744 if (D) 4745 Decls.push_back(D); 4746 } 4747 DelegatingCtorDecls.clear(); 4748} 4749 4750void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) { 4751 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) { 4752 TypedefNameDecl *D 4753 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I])); 4754 if (D) 4755 Decls.push_back(D); 4756 } 4757 ExtVectorDecls.clear(); 4758} 4759 4760void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) { 4761 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) { 4762 CXXRecordDecl *D 4763 = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I])); 4764 if (D) 4765 Decls.push_back(D); 4766 } 4767 DynamicClasses.clear(); 4768} 4769 4770void 4771ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) { 4772 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) { 4773 NamedDecl *D 4774 = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I])); 4775 if (D) 4776 Decls.push_back(D); 4777 } 4778 LocallyScopedExternalDecls.clear(); 4779} 4780 4781void ASTReader::ReadReferencedSelectors( 4782 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) { 4783 if (ReferencedSelectorsData.empty()) 4784 return; 4785 4786 // If there are @selector references added them to its pool. This is for 4787 // implementation of -Wselector. 4788 unsigned int DataSize = ReferencedSelectorsData.size()-1; 4789 unsigned I = 0; 4790 while (I < DataSize) { 4791 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]); 4792 SourceLocation SelLoc 4793 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]); 4794 Sels.push_back(std::make_pair(Sel, SelLoc)); 4795 } 4796 ReferencedSelectorsData.clear(); 4797} 4798 4799void ASTReader::ReadWeakUndeclaredIdentifiers( 4800 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) { 4801 if (WeakUndeclaredIdentifiers.empty()) 4802 return; 4803 4804 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) { 4805 IdentifierInfo *WeakId 4806 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 4807 IdentifierInfo *AliasId 4808 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 4809 SourceLocation Loc 4810 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]); 4811 bool Used = WeakUndeclaredIdentifiers[I++]; 4812 WeakInfo WI(AliasId, Loc); 4813 WI.setUsed(Used); 4814 WeakIDs.push_back(std::make_pair(WeakId, WI)); 4815 } 4816 WeakUndeclaredIdentifiers.clear(); 4817} 4818 4819void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) { 4820 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) { 4821 ExternalVTableUse VT; 4822 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 4823 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]); 4824 VT.DefinitionRequired = VTableUses[Idx++]; 4825 VTables.push_back(VT); 4826 } 4827 4828 VTableUses.clear(); 4829} 4830 4831void ASTReader::ReadPendingInstantiations( 4832 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) { 4833 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) { 4834 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++])); 4835 SourceLocation Loc 4836 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]); 4837 Pending.push_back(std::make_pair(D, Loc)); 4838 } 4839 PendingInstantiations.clear(); 4840} 4841 4842void ASTReader::LoadSelector(Selector Sel) { 4843 // It would be complicated to avoid reading the methods anyway. So don't. 4844 ReadMethodPool(Sel); 4845} 4846 4847void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) { 4848 assert(ID && "Non-zero identifier ID required"); 4849 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 4850 IdentifiersLoaded[ID - 1] = II; 4851 if (DeserializationListener) 4852 DeserializationListener->IdentifierRead(ID, II); 4853} 4854 4855/// \brief Set the globally-visible declarations associated with the given 4856/// identifier. 4857/// 4858/// If the AST reader is currently in a state where the given declaration IDs 4859/// cannot safely be resolved, they are queued until it is safe to resolve 4860/// them. 4861/// 4862/// \param II an IdentifierInfo that refers to one or more globally-visible 4863/// declarations. 4864/// 4865/// \param DeclIDs the set of declaration IDs with the name @p II that are 4866/// visible at global scope. 4867/// 4868/// \param Nonrecursive should be true to indicate that the caller knows that 4869/// this call is non-recursive, and therefore the globally-visible declarations 4870/// will not be placed onto the pending queue. 4871void 4872ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 4873 const SmallVectorImpl<uint32_t> &DeclIDs, 4874 bool Nonrecursive) { 4875 if (NumCurrentElementsDeserializing && !Nonrecursive) { 4876 PendingIdentifierInfos.push_back(PendingIdentifierInfo()); 4877 PendingIdentifierInfo &PII = PendingIdentifierInfos.back(); 4878 PII.II = II; 4879 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end()); 4880 return; 4881 } 4882 4883 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 4884 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 4885 if (SemaObj) { 4886 if (SemaObj->TUScope) { 4887 // Introduce this declaration into the translation-unit scope 4888 // and add it to the declaration chain for this identifier, so 4889 // that (unqualified) name lookup will find it. 4890 SemaObj->TUScope->AddDecl(D); 4891 } 4892 SemaObj->IdResolver.AddDeclToIdentifierChain(II, D); 4893 } else { 4894 // Queue this declaration so that it will be added to the 4895 // translation unit scope and identifier's declaration chain 4896 // once a Sema object is known. 4897 PreloadedDecls.push_back(D); 4898 } 4899 } 4900} 4901 4902IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) { 4903 if (ID == 0) 4904 return 0; 4905 4906 if (IdentifiersLoaded.empty()) { 4907 Error("no identifier table in AST file"); 4908 return 0; 4909 } 4910 4911 assert(PP && "Forgot to set Preprocessor ?"); 4912 ID -= 1; 4913 if (!IdentifiersLoaded[ID]) { 4914 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1); 4915 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map"); 4916 Module *M = I->second; 4917 unsigned Index = ID - M->BaseIdentifierID; 4918 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index]; 4919 4920 // All of the strings in the AST file are preceded by a 16-bit length. 4921 // Extract that 16-bit length to avoid having to execute strlen(). 4922 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 4923 // unsigned integers. This is important to avoid integer overflow when 4924 // we cast them to 'unsigned'. 4925 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 4926 unsigned StrLen = (((unsigned) StrLenPtr[0]) 4927 | (((unsigned) StrLenPtr[1]) << 8)) - 1; 4928 IdentifiersLoaded[ID] 4929 = &PP->getIdentifierTable().get(StringRef(Str, StrLen)); 4930 if (DeserializationListener) 4931 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 4932 } 4933 4934 return IdentifiersLoaded[ID]; 4935} 4936 4937IdentifierInfo *ASTReader::getLocalIdentifier(Module &M, unsigned LocalID) { 4938 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID)); 4939} 4940 4941IdentifierID ASTReader::getGlobalIdentifierID(Module &M, unsigned LocalID) { 4942 if (LocalID < NUM_PREDEF_IDENT_IDS) 4943 return LocalID; 4944 4945 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4946 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS); 4947 assert(I != M.IdentifierRemap.end() 4948 && "Invalid index into identifier index remap"); 4949 4950 return LocalID + I->second; 4951} 4952 4953bool ASTReader::ReadSLocEntry(int ID) { 4954 return ReadSLocEntryRecord(ID) != Success; 4955} 4956 4957Selector ASTReader::getLocalSelector(Module &M, unsigned LocalID) { 4958 return DecodeSelector(getGlobalSelectorID(M, LocalID)); 4959} 4960 4961Selector ASTReader::DecodeSelector(serialization::SelectorID ID) { 4962 if (ID == 0) 4963 return Selector(); 4964 4965 if (ID > SelectorsLoaded.size()) { 4966 Error("selector ID out of range in AST file"); 4967 return Selector(); 4968 } 4969 4970 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 4971 // Load this selector from the selector table. 4972 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID); 4973 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map"); 4974 Module &M = *I->second; 4975 ASTSelectorLookupTrait Trait(*this, M); 4976 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS; 4977 SelectorsLoaded[ID - 1] = 4978 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0); 4979 if (DeserializationListener) 4980 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 4981 } 4982 4983 return SelectorsLoaded[ID - 1]; 4984} 4985 4986Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) { 4987 return DecodeSelector(ID); 4988} 4989 4990uint32_t ASTReader::GetNumExternalSelectors() { 4991 // ID 0 (the null selector) is considered an external selector. 4992 return getTotalNumSelectors() + 1; 4993} 4994 4995serialization::SelectorID 4996ASTReader::getGlobalSelectorID(Module &M, unsigned LocalID) const { 4997 if (LocalID < NUM_PREDEF_SELECTOR_IDS) 4998 return LocalID; 4999 5000 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5001 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS); 5002 assert(I != M.SelectorRemap.end() 5003 && "Invalid index into identifier index remap"); 5004 5005 return LocalID + I->second; 5006} 5007 5008DeclarationName 5009ASTReader::ReadDeclarationName(Module &F, 5010 const RecordData &Record, unsigned &Idx) { 5011 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 5012 switch (Kind) { 5013 case DeclarationName::Identifier: 5014 return DeclarationName(GetIdentifierInfo(F, Record, Idx)); 5015 5016 case DeclarationName::ObjCZeroArgSelector: 5017 case DeclarationName::ObjCOneArgSelector: 5018 case DeclarationName::ObjCMultiArgSelector: 5019 return DeclarationName(ReadSelector(F, Record, Idx)); 5020 5021 case DeclarationName::CXXConstructorName: 5022 return Context->DeclarationNames.getCXXConstructorName( 5023 Context->getCanonicalType(readType(F, Record, Idx))); 5024 5025 case DeclarationName::CXXDestructorName: 5026 return Context->DeclarationNames.getCXXDestructorName( 5027 Context->getCanonicalType(readType(F, Record, Idx))); 5028 5029 case DeclarationName::CXXConversionFunctionName: 5030 return Context->DeclarationNames.getCXXConversionFunctionName( 5031 Context->getCanonicalType(readType(F, Record, Idx))); 5032 5033 case DeclarationName::CXXOperatorName: 5034 return Context->DeclarationNames.getCXXOperatorName( 5035 (OverloadedOperatorKind)Record[Idx++]); 5036 5037 case DeclarationName::CXXLiteralOperatorName: 5038 return Context->DeclarationNames.getCXXLiteralOperatorName( 5039 GetIdentifierInfo(F, Record, Idx)); 5040 5041 case DeclarationName::CXXUsingDirective: 5042 return DeclarationName::getUsingDirectiveName(); 5043 } 5044 5045 // Required to silence GCC warning 5046 return DeclarationName(); 5047} 5048 5049void ASTReader::ReadDeclarationNameLoc(Module &F, 5050 DeclarationNameLoc &DNLoc, 5051 DeclarationName Name, 5052 const RecordData &Record, unsigned &Idx) { 5053 switch (Name.getNameKind()) { 5054 case DeclarationName::CXXConstructorName: 5055 case DeclarationName::CXXDestructorName: 5056 case DeclarationName::CXXConversionFunctionName: 5057 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx); 5058 break; 5059 5060 case DeclarationName::CXXOperatorName: 5061 DNLoc.CXXOperatorName.BeginOpNameLoc 5062 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 5063 DNLoc.CXXOperatorName.EndOpNameLoc 5064 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 5065 break; 5066 5067 case DeclarationName::CXXLiteralOperatorName: 5068 DNLoc.CXXLiteralOperatorName.OpNameLoc 5069 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 5070 break; 5071 5072 case DeclarationName::Identifier: 5073 case DeclarationName::ObjCZeroArgSelector: 5074 case DeclarationName::ObjCOneArgSelector: 5075 case DeclarationName::ObjCMultiArgSelector: 5076 case DeclarationName::CXXUsingDirective: 5077 break; 5078 } 5079} 5080 5081void ASTReader::ReadDeclarationNameInfo(Module &F, 5082 DeclarationNameInfo &NameInfo, 5083 const RecordData &Record, unsigned &Idx) { 5084 NameInfo.setName(ReadDeclarationName(F, Record, Idx)); 5085 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx)); 5086 DeclarationNameLoc DNLoc; 5087 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx); 5088 NameInfo.setInfo(DNLoc); 5089} 5090 5091void ASTReader::ReadQualifierInfo(Module &F, QualifierInfo &Info, 5092 const RecordData &Record, unsigned &Idx) { 5093 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); 5094 unsigned NumTPLists = Record[Idx++]; 5095 Info.NumTemplParamLists = NumTPLists; 5096 if (NumTPLists) { 5097 Info.TemplParamLists = new (*Context) TemplateParameterList*[NumTPLists]; 5098 for (unsigned i=0; i != NumTPLists; ++i) 5099 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx); 5100 } 5101} 5102 5103TemplateName 5104ASTReader::ReadTemplateName(Module &F, const RecordData &Record, 5105 unsigned &Idx) { 5106 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 5107 switch (Kind) { 5108 case TemplateName::Template: 5109 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx)); 5110 5111 case TemplateName::OverloadedTemplate: { 5112 unsigned size = Record[Idx++]; 5113 UnresolvedSet<8> Decls; 5114 while (size--) 5115 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx)); 5116 5117 return Context->getOverloadedTemplateName(Decls.begin(), Decls.end()); 5118 } 5119 5120 case TemplateName::QualifiedTemplate: { 5121 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 5122 bool hasTemplKeyword = Record[Idx++]; 5123 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx); 5124 return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 5125 } 5126 5127 case TemplateName::DependentTemplate: { 5128 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 5129 if (Record[Idx++]) // isIdentifier 5130 return Context->getDependentTemplateName(NNS, 5131 GetIdentifierInfo(F, Record, 5132 Idx)); 5133 return Context->getDependentTemplateName(NNS, 5134 (OverloadedOperatorKind)Record[Idx++]); 5135 } 5136 5137 case TemplateName::SubstTemplateTemplateParm: { 5138 TemplateTemplateParmDecl *param 5139 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 5140 if (!param) return TemplateName(); 5141 TemplateName replacement = ReadTemplateName(F, Record, Idx); 5142 return Context->getSubstTemplateTemplateParm(param, replacement); 5143 } 5144 5145 case TemplateName::SubstTemplateTemplateParmPack: { 5146 TemplateTemplateParmDecl *Param 5147 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 5148 if (!Param) 5149 return TemplateName(); 5150 5151 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx); 5152 if (ArgPack.getKind() != TemplateArgument::Pack) 5153 return TemplateName(); 5154 5155 return Context->getSubstTemplateTemplateParmPack(Param, ArgPack); 5156 } 5157 } 5158 5159 assert(0 && "Unhandled template name kind!"); 5160 return TemplateName(); 5161} 5162 5163TemplateArgument 5164ASTReader::ReadTemplateArgument(Module &F, 5165 const RecordData &Record, unsigned &Idx) { 5166 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++]; 5167 switch (Kind) { 5168 case TemplateArgument::Null: 5169 return TemplateArgument(); 5170 case TemplateArgument::Type: 5171 return TemplateArgument(readType(F, Record, Idx)); 5172 case TemplateArgument::Declaration: 5173 return TemplateArgument(ReadDecl(F, Record, Idx)); 5174 case TemplateArgument::Integral: { 5175 llvm::APSInt Value = ReadAPSInt(Record, Idx); 5176 QualType T = readType(F, Record, Idx); 5177 return TemplateArgument(Value, T); 5178 } 5179 case TemplateArgument::Template: 5180 return TemplateArgument(ReadTemplateName(F, Record, Idx)); 5181 case TemplateArgument::TemplateExpansion: { 5182 TemplateName Name = ReadTemplateName(F, Record, Idx); 5183 llvm::Optional<unsigned> NumTemplateExpansions; 5184 if (unsigned NumExpansions = Record[Idx++]) 5185 NumTemplateExpansions = NumExpansions - 1; 5186 return TemplateArgument(Name, NumTemplateExpansions); 5187 } 5188 case TemplateArgument::Expression: 5189 return TemplateArgument(ReadExpr(F)); 5190 case TemplateArgument::Pack: { 5191 unsigned NumArgs = Record[Idx++]; 5192 TemplateArgument *Args = new (*Context) TemplateArgument[NumArgs]; 5193 for (unsigned I = 0; I != NumArgs; ++I) 5194 Args[I] = ReadTemplateArgument(F, Record, Idx); 5195 return TemplateArgument(Args, NumArgs); 5196 } 5197 } 5198 5199 assert(0 && "Unhandled template argument kind!"); 5200 return TemplateArgument(); 5201} 5202 5203TemplateParameterList * 5204ASTReader::ReadTemplateParameterList(Module &F, 5205 const RecordData &Record, unsigned &Idx) { 5206 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx); 5207 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx); 5208 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx); 5209 5210 unsigned NumParams = Record[Idx++]; 5211 SmallVector<NamedDecl *, 16> Params; 5212 Params.reserve(NumParams); 5213 while (NumParams--) 5214 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx)); 5215 5216 TemplateParameterList* TemplateParams = 5217 TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc, 5218 Params.data(), Params.size(), RAngleLoc); 5219 return TemplateParams; 5220} 5221 5222void 5223ASTReader:: 5224ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs, 5225 Module &F, const RecordData &Record, 5226 unsigned &Idx) { 5227 unsigned NumTemplateArgs = Record[Idx++]; 5228 TemplArgs.reserve(NumTemplateArgs); 5229 while (NumTemplateArgs--) 5230 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx)); 5231} 5232 5233/// \brief Read a UnresolvedSet structure. 5234void ASTReader::ReadUnresolvedSet(Module &F, UnresolvedSetImpl &Set, 5235 const RecordData &Record, unsigned &Idx) { 5236 unsigned NumDecls = Record[Idx++]; 5237 while (NumDecls--) { 5238 NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx); 5239 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 5240 Set.addDecl(D, AS); 5241 } 5242} 5243 5244CXXBaseSpecifier 5245ASTReader::ReadCXXBaseSpecifier(Module &F, 5246 const RecordData &Record, unsigned &Idx) { 5247 bool isVirtual = static_cast<bool>(Record[Idx++]); 5248 bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 5249 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 5250 bool inheritConstructors = static_cast<bool>(Record[Idx++]); 5251 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx); 5252 SourceRange Range = ReadSourceRange(F, Record, Idx); 5253 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx); 5254 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo, 5255 EllipsisLoc); 5256 Result.setInheritConstructors(inheritConstructors); 5257 return Result; 5258} 5259 5260std::pair<CXXCtorInitializer **, unsigned> 5261ASTReader::ReadCXXCtorInitializers(Module &F, const RecordData &Record, 5262 unsigned &Idx) { 5263 CXXCtorInitializer **CtorInitializers = 0; 5264 unsigned NumInitializers = Record[Idx++]; 5265 if (NumInitializers) { 5266 ASTContext &C = *getContext(); 5267 5268 CtorInitializers 5269 = new (C) CXXCtorInitializer*[NumInitializers]; 5270 for (unsigned i=0; i != NumInitializers; ++i) { 5271 TypeSourceInfo *BaseClassInfo = 0; 5272 bool IsBaseVirtual = false; 5273 FieldDecl *Member = 0; 5274 IndirectFieldDecl *IndirectMember = 0; 5275 CXXConstructorDecl *Target = 0; 5276 5277 CtorInitializerType Type = (CtorInitializerType)Record[Idx++]; 5278 switch (Type) { 5279 case CTOR_INITIALIZER_BASE: 5280 BaseClassInfo = GetTypeSourceInfo(F, Record, Idx); 5281 IsBaseVirtual = Record[Idx++]; 5282 break; 5283 5284 case CTOR_INITIALIZER_DELEGATING: 5285 Target = ReadDeclAs<CXXConstructorDecl>(F, Record, Idx); 5286 break; 5287 5288 case CTOR_INITIALIZER_MEMBER: 5289 Member = ReadDeclAs<FieldDecl>(F, Record, Idx); 5290 break; 5291 5292 case CTOR_INITIALIZER_INDIRECT_MEMBER: 5293 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx); 5294 break; 5295 } 5296 5297 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx); 5298 Expr *Init = ReadExpr(F); 5299 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx); 5300 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx); 5301 bool IsWritten = Record[Idx++]; 5302 unsigned SourceOrderOrNumArrayIndices; 5303 SmallVector<VarDecl *, 8> Indices; 5304 if (IsWritten) { 5305 SourceOrderOrNumArrayIndices = Record[Idx++]; 5306 } else { 5307 SourceOrderOrNumArrayIndices = Record[Idx++]; 5308 Indices.reserve(SourceOrderOrNumArrayIndices); 5309 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 5310 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx)); 5311 } 5312 5313 CXXCtorInitializer *BOMInit; 5314 if (Type == CTOR_INITIALIZER_BASE) { 5315 BOMInit = new (C) CXXCtorInitializer(C, BaseClassInfo, IsBaseVirtual, 5316 LParenLoc, Init, RParenLoc, 5317 MemberOrEllipsisLoc); 5318 } else if (Type == CTOR_INITIALIZER_DELEGATING) { 5319 BOMInit = new (C) CXXCtorInitializer(C, MemberOrEllipsisLoc, LParenLoc, 5320 Target, Init, RParenLoc); 5321 } else if (IsWritten) { 5322 if (Member) 5323 BOMInit = new (C) CXXCtorInitializer(C, Member, MemberOrEllipsisLoc, 5324 LParenLoc, Init, RParenLoc); 5325 else 5326 BOMInit = new (C) CXXCtorInitializer(C, IndirectMember, 5327 MemberOrEllipsisLoc, LParenLoc, 5328 Init, RParenLoc); 5329 } else { 5330 BOMInit = CXXCtorInitializer::Create(C, Member, MemberOrEllipsisLoc, 5331 LParenLoc, Init, RParenLoc, 5332 Indices.data(), Indices.size()); 5333 } 5334 5335 if (IsWritten) 5336 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 5337 CtorInitializers[i] = BOMInit; 5338 } 5339 } 5340 5341 return std::make_pair(CtorInitializers, NumInitializers); 5342} 5343 5344NestedNameSpecifier * 5345ASTReader::ReadNestedNameSpecifier(Module &F, 5346 const RecordData &Record, unsigned &Idx) { 5347 unsigned N = Record[Idx++]; 5348 NestedNameSpecifier *NNS = 0, *Prev = 0; 5349 for (unsigned I = 0; I != N; ++I) { 5350 NestedNameSpecifier::SpecifierKind Kind 5351 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 5352 switch (Kind) { 5353 case NestedNameSpecifier::Identifier: { 5354 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 5355 NNS = NestedNameSpecifier::Create(*Context, Prev, II); 5356 break; 5357 } 5358 5359 case NestedNameSpecifier::Namespace: { 5360 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 5361 NNS = NestedNameSpecifier::Create(*Context, Prev, NS); 5362 break; 5363 } 5364 5365 case NestedNameSpecifier::NamespaceAlias: { 5366 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 5367 NNS = NestedNameSpecifier::Create(*Context, Prev, Alias); 5368 break; 5369 } 5370 5371 case NestedNameSpecifier::TypeSpec: 5372 case NestedNameSpecifier::TypeSpecWithTemplate: { 5373 const Type *T = readType(F, Record, Idx).getTypePtrOrNull(); 5374 if (!T) 5375 return 0; 5376 5377 bool Template = Record[Idx++]; 5378 NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T); 5379 break; 5380 } 5381 5382 case NestedNameSpecifier::Global: { 5383 NNS = NestedNameSpecifier::GlobalSpecifier(*Context); 5384 // No associated value, and there can't be a prefix. 5385 break; 5386 } 5387 } 5388 Prev = NNS; 5389 } 5390 return NNS; 5391} 5392 5393NestedNameSpecifierLoc 5394ASTReader::ReadNestedNameSpecifierLoc(Module &F, const RecordData &Record, 5395 unsigned &Idx) { 5396 unsigned N = Record[Idx++]; 5397 NestedNameSpecifierLocBuilder Builder; 5398 for (unsigned I = 0; I != N; ++I) { 5399 NestedNameSpecifier::SpecifierKind Kind 5400 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 5401 switch (Kind) { 5402 case NestedNameSpecifier::Identifier: { 5403 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 5404 SourceRange Range = ReadSourceRange(F, Record, Idx); 5405 Builder.Extend(*Context, II, Range.getBegin(), Range.getEnd()); 5406 break; 5407 } 5408 5409 case NestedNameSpecifier::Namespace: { 5410 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 5411 SourceRange Range = ReadSourceRange(F, Record, Idx); 5412 Builder.Extend(*Context, NS, Range.getBegin(), Range.getEnd()); 5413 break; 5414 } 5415 5416 case NestedNameSpecifier::NamespaceAlias: { 5417 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 5418 SourceRange Range = ReadSourceRange(F, Record, Idx); 5419 Builder.Extend(*Context, Alias, Range.getBegin(), Range.getEnd()); 5420 break; 5421 } 5422 5423 case NestedNameSpecifier::TypeSpec: 5424 case NestedNameSpecifier::TypeSpecWithTemplate: { 5425 bool Template = Record[Idx++]; 5426 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx); 5427 if (!T) 5428 return NestedNameSpecifierLoc(); 5429 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 5430 5431 // FIXME: 'template' keyword location not saved anywhere, so we fake it. 5432 Builder.Extend(*Context, 5433 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(), 5434 T->getTypeLoc(), ColonColonLoc); 5435 break; 5436 } 5437 5438 case NestedNameSpecifier::Global: { 5439 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 5440 Builder.MakeGlobal(*Context, ColonColonLoc); 5441 break; 5442 } 5443 } 5444 } 5445 5446 return Builder.getWithLocInContext(*Context); 5447} 5448 5449SourceRange 5450ASTReader::ReadSourceRange(Module &F, const RecordData &Record, 5451 unsigned &Idx) { 5452 SourceLocation beg = ReadSourceLocation(F, Record, Idx); 5453 SourceLocation end = ReadSourceLocation(F, Record, Idx); 5454 return SourceRange(beg, end); 5455} 5456 5457/// \brief Read an integral value 5458llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 5459 unsigned BitWidth = Record[Idx++]; 5460 unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 5461 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 5462 Idx += NumWords; 5463 return Result; 5464} 5465 5466/// \brief Read a signed integral value 5467llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 5468 bool isUnsigned = Record[Idx++]; 5469 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 5470} 5471 5472/// \brief Read a floating-point value 5473llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) { 5474 return llvm::APFloat(ReadAPInt(Record, Idx)); 5475} 5476 5477// \brief Read a string 5478std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 5479 unsigned Len = Record[Idx++]; 5480 std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 5481 Idx += Len; 5482 return Result; 5483} 5484 5485VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record, 5486 unsigned &Idx) { 5487 unsigned Major = Record[Idx++]; 5488 unsigned Minor = Record[Idx++]; 5489 unsigned Subminor = Record[Idx++]; 5490 if (Minor == 0) 5491 return VersionTuple(Major); 5492 if (Subminor == 0) 5493 return VersionTuple(Major, Minor - 1); 5494 return VersionTuple(Major, Minor - 1, Subminor - 1); 5495} 5496 5497CXXTemporary *ASTReader::ReadCXXTemporary(Module &F, 5498 const RecordData &Record, 5499 unsigned &Idx) { 5500 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx); 5501 return CXXTemporary::Create(*Context, Decl); 5502} 5503 5504DiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 5505 return Diag(SourceLocation(), DiagID); 5506} 5507 5508DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 5509 return Diags.Report(Loc, DiagID); 5510} 5511 5512/// \brief Retrieve the identifier table associated with the 5513/// preprocessor. 5514IdentifierTable &ASTReader::getIdentifierTable() { 5515 assert(PP && "Forgot to set Preprocessor ?"); 5516 return PP->getIdentifierTable(); 5517} 5518 5519/// \brief Record that the given ID maps to the given switch-case 5520/// statement. 5521void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 5522 assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID"); 5523 SwitchCaseStmts[ID] = SC; 5524} 5525 5526/// \brief Retrieve the switch-case statement with the given ID. 5527SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 5528 assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID"); 5529 return SwitchCaseStmts[ID]; 5530} 5531 5532void ASTReader::ClearSwitchCaseIDs() { 5533 SwitchCaseStmts.clear(); 5534} 5535 5536void ASTReader::FinishedDeserializing() { 5537 assert(NumCurrentElementsDeserializing && 5538 "FinishedDeserializing not paired with StartedDeserializing"); 5539 if (NumCurrentElementsDeserializing == 1) { 5540 // If any identifiers with corresponding top-level declarations have 5541 // been loaded, load those declarations now. 5542 while (!PendingIdentifierInfos.empty()) { 5543 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II, 5544 PendingIdentifierInfos.front().DeclIDs, true); 5545 PendingIdentifierInfos.pop_front(); 5546 } 5547 5548 // Ready to load previous declarations of Decls that were delayed. 5549 while (!PendingPreviousDecls.empty()) { 5550 loadAndAttachPreviousDecl(PendingPreviousDecls.front().first, 5551 PendingPreviousDecls.front().second); 5552 PendingPreviousDecls.pop_front(); 5553 } 5554 5555 // We are not in recursive loading, so it's safe to pass the "interesting" 5556 // decls to the consumer. 5557 if (Consumer) 5558 PassInterestingDeclsToConsumer(); 5559 5560 assert(PendingForwardRefs.size() == 0 && 5561 "Some forward refs did not get linked to the definition!"); 5562 } 5563 --NumCurrentElementsDeserializing; 5564} 5565 5566ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context, 5567 StringRef isysroot, bool DisableValidation, 5568 bool DisableStatCache) 5569 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 5570 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 5571 Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context), 5572 Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()), 5573 RelocatablePCH(false), isysroot(isysroot), 5574 DisableValidation(DisableValidation), 5575 DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0), 5576 NumSLocEntriesRead(0), TotalNumSLocEntries(0), 5577 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0), 5578 TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0), 5579 NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0), 5580 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0), 5581 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0), 5582 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0), 5583 NumCXXBaseSpecifiersLoaded(0) 5584{ 5585 SourceMgr.setExternalSLocEntrySource(this); 5586} 5587 5588ASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr, 5589 Diagnostic &Diags, StringRef isysroot, 5590 bool DisableValidation, bool DisableStatCache) 5591 : DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr), 5592 Diags(Diags), SemaObj(0), PP(0), Context(0), 5593 Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()), 5594 RelocatablePCH(false), isysroot(isysroot), 5595 DisableValidation(DisableValidation), DisableStatCache(DisableStatCache), 5596 NumStatHits(0), NumStatMisses(0), NumSLocEntriesRead(0), 5597 TotalNumSLocEntries(0), NumStatementsRead(0), 5598 TotalNumStatements(0), NumMacrosRead(0), TotalNumMacros(0), 5599 NumSelectorsRead(0), NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0), 5600 TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0), 5601 TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0), 5602 TotalVisibleDeclContexts(0), TotalModulesSizeInBits(0), 5603 NumCurrentElementsDeserializing(0), NumCXXBaseSpecifiersLoaded(0) 5604{ 5605 SourceMgr.setExternalSLocEntrySource(this); 5606} 5607 5608ASTReader::~ASTReader() { 5609 // Delete all visible decl lookup tables 5610 for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(), 5611 E = DeclContextOffsets.end(); 5612 I != E; ++I) { 5613 for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end(); 5614 J != F; ++J) { 5615 if (J->NameLookupTableData) 5616 delete static_cast<ASTDeclContextNameLookupTable*>( 5617 J->NameLookupTableData); 5618 } 5619 } 5620 for (DeclContextVisibleUpdatesPending::iterator 5621 I = PendingVisibleUpdates.begin(), 5622 E = PendingVisibleUpdates.end(); 5623 I != E; ++I) { 5624 for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 5625 F = I->second.end(); 5626 J != F; ++J) 5627 delete static_cast<ASTDeclContextNameLookupTable*>(J->first); 5628 } 5629} 5630 5631//===----------------------------------------------------------------------===// 5632// Module implementation 5633//===----------------------------------------------------------------------===// 5634Module::Module(ModuleKind Kind) 5635 : Kind(Kind), DirectlyImported(false), SizeInBits(0), 5636 LocalNumSLocEntries(0), SLocEntryBaseID(0), 5637 SLocEntryBaseOffset(0), SLocEntryOffsets(0), 5638 SLocFileOffsets(0), LocalNumIdentifiers(0), 5639 IdentifierOffsets(0), BaseIdentifierID(0), IdentifierTableData(0), 5640 IdentifierLookupTable(0), BasePreprocessedEntityID(0), 5641 LocalNumMacroDefinitions(0), MacroDefinitionOffsets(0), 5642 BaseMacroDefinitionID(0), LocalNumHeaderFileInfos(0), 5643 HeaderFileInfoTableData(0), HeaderFileInfoTable(0), 5644 HeaderFileFrameworkStrings(0), 5645 LocalNumSelectors(0), SelectorOffsets(0), BaseSelectorID(0), 5646 SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(0), 5647 DeclOffsets(0), BaseDeclID(0), 5648 LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0), 5649 LocalNumTypes(0), TypeOffsets(0), BaseTypeIndex(0), StatCache(0), 5650 NumPreallocatedPreprocessingEntities(0) 5651{} 5652 5653Module::~Module() { 5654 delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable); 5655 delete static_cast<HeaderFileInfoLookupTable *>(HeaderFileInfoTable); 5656 delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable); 5657} 5658 5659template<typename Key, typename Offset, unsigned InitialCapacity> 5660static void 5661dumpLocalRemap(StringRef Name, 5662 const ContinuousRangeMap<Key, Offset, InitialCapacity> &Map) { 5663 if (Map.begin() == Map.end()) 5664 return; 5665 5666 typedef ContinuousRangeMap<Key, Offset, InitialCapacity> MapType; 5667 llvm::errs() << " " << Name << ":\n"; 5668 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 5669 I != IEnd; ++I) { 5670 llvm::errs() << " " << I->first << " -> " << I->second 5671 << "\n"; 5672 } 5673} 5674 5675void Module::dump() { 5676 llvm::errs() << "\nModule: " << FileName << "\n"; 5677 if (!Imports.empty()) { 5678 llvm::errs() << " Imports: "; 5679 for (unsigned I = 0, N = Imports.size(); I != N; ++I) { 5680 if (I) 5681 llvm::errs() << ", "; 5682 llvm::errs() << Imports[I]->FileName; 5683 } 5684 llvm::errs() << "\n"; 5685 } 5686 5687 // Remapping tables. 5688 llvm::errs() << " Base source location offset: " << SLocEntryBaseOffset 5689 << '\n'; 5690 dumpLocalRemap("Source location offset local -> global map", SLocRemap); 5691 5692 llvm::errs() << " Base identifier ID: " << BaseIdentifierID << '\n' 5693 << " Number of identifiers: " << LocalNumIdentifiers << '\n'; 5694 dumpLocalRemap("Identifier ID local -> global map", IdentifierRemap); 5695 5696 llvm::errs() << " Base selector ID: " << BaseSelectorID << '\n' 5697 << " Number of selectors: " << LocalNumSelectors << '\n'; 5698 dumpLocalRemap("Selector ID local -> global map", SelectorRemap); 5699 5700 llvm::errs() << " Base preprocessed entity ID: " << BasePreprocessedEntityID 5701 << '\n' 5702 << " Number of preprocessed entities: " 5703 << NumPreallocatedPreprocessingEntities << '\n'; 5704 dumpLocalRemap("Preprocessed entity ID local -> global map", 5705 PreprocessedEntityRemap); 5706 5707 llvm::errs() << " Base macro definition ID: " << BaseMacroDefinitionID 5708 << '\n' 5709 << " Number of macro definitions: " << LocalNumMacroDefinitions 5710 << '\n'; 5711 dumpLocalRemap("Macro definition ID local -> global map", 5712 MacroDefinitionRemap); 5713 5714 llvm::errs() << " Base type index: " << BaseTypeIndex << '\n' 5715 << " Number of types: " << LocalNumTypes << '\n'; 5716 dumpLocalRemap("Type index local -> global map", TypeRemap); 5717 5718 llvm::errs() << " Base decl ID: " << BaseDeclID << '\n' 5719 << " Number of decls: " << LocalNumDecls << '\n'; 5720 dumpLocalRemap("Decl ID local -> global map", DeclRemap); 5721} 5722 5723//===----------------------------------------------------------------------===// 5724// Module manager implementation 5725//===----------------------------------------------------------------------===// 5726 5727Module *ModuleManager::lookup(StringRef Name) { 5728 const FileEntry *Entry = FileMgr.getFile(Name); 5729 return Modules[Entry]; 5730} 5731 5732llvm::MemoryBuffer *ModuleManager::lookupBuffer(StringRef Name) { 5733 const FileEntry *Entry = FileMgr.getFile(Name); 5734 return InMemoryBuffers[Entry]; 5735} 5736 5737std::pair<Module *, bool> 5738ModuleManager::addModule(StringRef FileName, ModuleKind Type, 5739 Module *ImportedBy, std::string &ErrorStr) { 5740 const FileEntry *Entry = FileMgr.getFile(FileName); 5741 if (!Entry && FileName != "-") { 5742 ErrorStr = "file not found"; 5743 return std::make_pair(static_cast<Module*>(0), false); 5744 } 5745 5746 // Check whether we already loaded this module, before 5747 Module *&ModuleEntry = Modules[Entry]; 5748 bool NewModule = false; 5749 if (!ModuleEntry) { 5750 // Allocate a new module. 5751 Module *New = new Module(Type); 5752 New->FileName = FileName.str(); 5753 Chain.push_back(New); 5754 NewModule = true; 5755 ModuleEntry = New; 5756 5757 // Load the contents of the module 5758 if (llvm::MemoryBuffer *Buffer = lookupBuffer(FileName)) { 5759 // The buffer was already provided for us. 5760 assert(Buffer && "Passed null buffer"); 5761 New->Buffer.reset(Buffer); 5762 } else { 5763 // Open the AST file. 5764 llvm::error_code ec; 5765 if (FileName == "-") { 5766 ec = llvm::MemoryBuffer::getSTDIN(New->Buffer); 5767 if (ec) 5768 ErrorStr = ec.message(); 5769 } else 5770 New->Buffer.reset(FileMgr.getBufferForFile(FileName, &ErrorStr)); 5771 5772 if (!New->Buffer) 5773 return std::make_pair(static_cast<Module*>(0), false); 5774 } 5775 5776 // Initialize the stream 5777 New->StreamFile.init((const unsigned char *)New->Buffer->getBufferStart(), 5778 (const unsigned char *)New->Buffer->getBufferEnd()); } 5779 5780 if (ImportedBy) { 5781 ModuleEntry->ImportedBy.insert(ImportedBy); 5782 ImportedBy->Imports.insert(ModuleEntry); 5783 } else { 5784 ModuleEntry->DirectlyImported = true; 5785 } 5786 5787 return std::make_pair(ModuleEntry, NewModule); 5788} 5789 5790void ModuleManager::addInMemoryBuffer(StringRef FileName, 5791 llvm::MemoryBuffer *Buffer) { 5792 5793 const FileEntry *Entry = FileMgr.getVirtualFile(FileName, 5794 Buffer->getBufferSize(), 0); 5795 InMemoryBuffers[Entry] = Buffer; 5796} 5797 5798ModuleManager::ModuleManager(const FileSystemOptions &FSO) : FileMgr(FSO) { } 5799 5800ModuleManager::~ModuleManager() { 5801 for (unsigned i = 0, e = Chain.size(); i != e; ++i) 5802 delete Chain[e - i - 1]; 5803} 5804 5805void ModuleManager::visit(bool (*Visitor)(Module &M, void *UserData), 5806 void *UserData) { 5807 unsigned N = size(); 5808 5809 // Record the number of incoming edges for each module. When we 5810 // encounter a module with no incoming edges, push it into the queue 5811 // to seed the queue. 5812 SmallVector<Module *, 4> Queue; 5813 Queue.reserve(N); 5814 llvm::DenseMap<Module *, unsigned> UnusedIncomingEdges; 5815 for (ModuleIterator M = begin(), MEnd = end(); M != MEnd; ++M) { 5816 if (unsigned Size = (*M)->ImportedBy.size()) 5817 UnusedIncomingEdges[*M] = Size; 5818 else 5819 Queue.push_back(*M); 5820 } 5821 5822 llvm::SmallPtrSet<Module *, 4> Skipped; 5823 unsigned QueueStart = 0; 5824 while (QueueStart < Queue.size()) { 5825 Module *CurrentModule = Queue[QueueStart++]; 5826 5827 // Check whether this module should be skipped. 5828 if (Skipped.count(CurrentModule)) 5829 continue; 5830 5831 if (Visitor(*CurrentModule, UserData)) { 5832 // The visitor has requested that cut off visitation of any 5833 // module that the current module depends on. To indicate this 5834 // behavior, we mark all of the reachable modules as having N 5835 // incoming edges (which is impossible otherwise). 5836 SmallVector<Module *, 4> Stack; 5837 Stack.push_back(CurrentModule); 5838 Skipped.insert(CurrentModule); 5839 while (!Stack.empty()) { 5840 Module *NextModule = Stack.back(); 5841 Stack.pop_back(); 5842 5843 // For any module that this module depends on, push it on the 5844 // stack (if it hasn't already been marked as visited). 5845 for (llvm::SetVector<Module *>::iterator 5846 M = NextModule->Imports.begin(), 5847 MEnd = NextModule->Imports.end(); 5848 M != MEnd; ++M) { 5849 if (Skipped.insert(*M)) 5850 Stack.push_back(*M); 5851 } 5852 } 5853 continue; 5854 } 5855 5856 // For any module that this module depends on, push it on the 5857 // stack (if it hasn't already been marked as visited). 5858 for (llvm::SetVector<Module *>::iterator M = CurrentModule->Imports.begin(), 5859 MEnd = CurrentModule->Imports.end(); 5860 M != MEnd; ++M) { 5861 5862 // Remove our current module as an impediment to visiting the 5863 // module we depend on. If we were the last unvisited module 5864 // that depends on this particular module, push it into the 5865 // queue to be visited. 5866 unsigned &NumUnusedEdges = UnusedIncomingEdges[*M]; 5867 if (NumUnusedEdges && (--NumUnusedEdges == 0)) 5868 Queue.push_back(*M); 5869 } 5870 } 5871} 5872