ASTReader.cpp revision 7c789c1a3f77f24032aa0bed2afacdb9e094e952
15821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)//===--- ASTReader.cpp - AST File Reader ------------------------*- C++ -*-===// 25821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 35821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// The LLVM Compiler Infrastructure 45821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 55821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// This file is distributed under the University of Illinois Open Source 65821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// License. See LICENSE.TXT for details. 75821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 8c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)//===----------------------------------------------------------------------===// 95821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 1058537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles)// This file defines the ASTReader class, which reads AST files. 11b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles)// 125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)//===----------------------------------------------------------------------===// 135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Serialization/ASTReader.h" 152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/Serialization/ASTDeserializationListener.h" 162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "ASTCommon.h" 175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Frontend/FrontendDiagnostic.h" 182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/Frontend/Utils.h" 195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Sema/Sema.h" 2090dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)#include "clang/Sema/Scope.h" 2190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)#include "clang/AST/ASTConsumer.h" 2290dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)#include "clang/AST/ASTContext.h" 2390dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)#include "clang/AST/DeclTemplate.h" 2468043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles)#include "clang/AST/Expr.h" 2568043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles)#include "clang/AST/ExprCXX.h" 2668043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles)#include "clang/AST/Type.h" 2790dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)#include "clang/AST/TypeLocVisitor.h" 285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Lex/MacroInfo.h" 295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Lex/PreprocessingRecord.h" 305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Lex/Preprocessor.h" 315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Lex/HeaderSearch.h" 325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Basic/OnDiskHashTable.h" 335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Basic/SourceManager.h" 345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Basic/SourceManagerInternals.h" 355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Basic/FileManager.h" 365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Basic/TargetInfo.h" 375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Basic/Version.h" 385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/ADT/StringExtras.h" 395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Bitcode/BitstreamReader.h" 405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Support/MemoryBuffer.h" 415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Support/ErrorHandling.h" 425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/System/Path.h" 435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <algorithm> 445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <iterator> 455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <cstdio> 465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <sys/stat.h> 475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)using namespace clang; 485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)using namespace clang::serialization; 495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)//===----------------------------------------------------------------------===// 51eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch// PCH validator implementation 52eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch//===----------------------------------------------------------------------===// 53eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 54eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen MurdochASTReaderListener::~ASTReaderListener() {} 555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)bool 575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts) { 5868043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) const LangOptions &PPLangOpts = PP.getLangOptions(); 5968043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles)#define PARSE_LANGOPT_BENIGN(Option) 6068043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles)#define PARSE_LANGOPT_IMPORTANT(Option, DiagID) \ 6168043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) if (PPLangOpts.Option != LangOpts.Option) { \ 6268043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) Reader.Diag(DiagID) << LangOpts.Option << PPLangOpts.Option; \ 6368043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) return true; \ 645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_BENIGN(Trigraphs); 675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_BENIGN(BCPLComment); 685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_BENIGN(DollarIdents); 695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_BENIGN(AsmPreprocessor); 705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(GNUMode, diag::warn_pch_gnu_extensions); 715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(GNUKeywords, diag::warn_pch_gnu_keywords); 725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_BENIGN(ImplicitInt); 735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_BENIGN(Digraphs); 745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_BENIGN(HexFloats); 755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(C99, diag::warn_pch_c99); 765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(Microsoft, diag::warn_pch_microsoft_extensions); 775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_BENIGN(MSCVersion); 785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(CPlusPlus, diag::warn_pch_cplusplus); 795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(CPlusPlus0x, diag::warn_pch_cplusplus0x); 805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_BENIGN(CXXOperatorName); 815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(ObjC1, diag::warn_pch_objective_c); 825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(ObjC2, diag::warn_pch_objective_c2); 835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI, diag::warn_pch_nonfragile_abi); 845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI2, diag::warn_pch_nonfragile_abi2); 855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(NoConstantCFStrings, 8690dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) diag::warn_pch_no_constant_cfstrings); 87c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) PARSE_LANGOPT_BENIGN(PascalStrings); 88c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) PARSE_LANGOPT_BENIGN(WritableStrings); 89c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) PARSE_LANGOPT_IMPORTANT(LaxVectorConversions, 90c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) diag::warn_pch_lax_vector_conversions); 915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(AltiVec, diag::warn_pch_altivec); 9290dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) PARSE_LANGOPT_IMPORTANT(Exceptions, diag::warn_pch_exceptions); 9390dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) PARSE_LANGOPT_IMPORTANT(SjLjExceptions, diag::warn_pch_sjlj_exceptions); 9490dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) PARSE_LANGOPT_IMPORTANT(NeXTRuntime, diag::warn_pch_objc_runtime); 9590dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) PARSE_LANGOPT_IMPORTANT(Freestanding, diag::warn_pch_freestanding); 9690dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) PARSE_LANGOPT_IMPORTANT(NoBuiltin, diag::warn_pch_builtins); 9790dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) PARSE_LANGOPT_IMPORTANT(ThreadsafeStatics, 9890dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) diag::warn_pch_thread_safe_statics); 9990dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) PARSE_LANGOPT_IMPORTANT(POSIXThreads, diag::warn_pch_posix_threads); 1005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(Blocks, diag::warn_pch_blocks); 1015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_BENIGN(EmitAllDecls); 1025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(MathErrno, diag::warn_pch_math_errno); 1035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_BENIGN(getSignedOverflowBehavior()); 1045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(HeinousExtensions, 1055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) diag::warn_pch_heinous_extensions); 1065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // FIXME: Most of the options below are benign if the macro wasn't 1075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // used. Unfortunately, this means that a PCH compiled without 1085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // optimization can't be used with optimization turned on, even 1095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // though the only thing that changes is whether __OPTIMIZE__ was 1105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // defined... but if __OPTIMIZE__ never showed up in the header, it 1115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // doesn't matter. We could consider making this some special kind 1125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // of check. 1135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(Optimize, diag::warn_pch_optimize); 1142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) PARSE_LANGOPT_IMPORTANT(OptimizeSize, diag::warn_pch_optimize_size); 1155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(Static, diag::warn_pch_static); 116c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) PARSE_LANGOPT_IMPORTANT(PICLevel, diag::warn_pch_pic_level); 117c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) PARSE_LANGOPT_IMPORTANT(GNUInline, diag::warn_pch_gnu_inline); 118c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) PARSE_LANGOPT_IMPORTANT(NoInline, diag::warn_pch_no_inline); 119c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) PARSE_LANGOPT_IMPORTANT(AccessControl, diag::warn_pch_access_control); 120c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) PARSE_LANGOPT_IMPORTANT(CharIsSigned, diag::warn_pch_char_signed); 1215d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(ShortWChar, diag::warn_pch_short_wchar); 1225d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(ShortEnums, diag::warn_pch_short_enums); 123c2db58bd994c04d98e4ee2cd7565b71548655fe3Ben Murdoch if ((PPLangOpts.getGCMode() != 0) != (LangOpts.getGCMode() != 0)) { 1245d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) Reader.Diag(diag::warn_pch_gc_mode) 1255d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) << LangOpts.getGCMode() << PPLangOpts.getGCMode(); 1265d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) return true; 1275d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) } 1285d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) PARSE_LANGOPT_BENIGN(getVisibilityMode()); 1295d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(getStackProtectorMode(), 130c2db58bd994c04d98e4ee2cd7565b71548655fe3Ben Murdoch diag::warn_pch_stack_protector); 1315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_BENIGN(InstantiationDepth); 1325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(OpenCL, diag::warn_pch_opencl); 1335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_BENIGN(CatchUndefined); 1345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PARSE_LANGOPT_IMPORTANT(ElideConstructors, diag::warn_pch_elide_constructors); 135c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) PARSE_LANGOPT_BENIGN(SpellChecking); 1365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#undef PARSE_LANGOPT_IMPORTANT 13790dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)#undef PARSE_LANGOPT_BENIGN 13890dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 13990dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) return false; 14068043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles)} 14168043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) 14268043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles)bool PCHValidator::ReadTargetTriple(llvm::StringRef Triple) { 1435d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (Triple == PP.getTargetInfo().getTriple().str()) 1445d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) return false; 1455d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) 146c2db58bd994c04d98e4ee2cd7565b71548655fe3Ben Murdoch Reader.Diag(diag::warn_pch_target_triple) 1475d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) << Triple << PP.getTargetInfo().getTriple().str(); 1485d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) return true; 149c2db58bd994c04d98e4ee2cd7565b71548655fe3Ben Murdoch} 1505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)struct EmptyStringRef { 1525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool operator ()(llvm::StringRef r) const { return r.empty(); } 1535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)}; 1545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)struct EmptyBlock { 1555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool operator ()(const PCHPredefinesBlock &r) const { return r.Data.empty(); } 1565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)}; 1575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 158static bool EqualConcatenations(llvm::SmallVector<llvm::StringRef, 2> L, 159 PCHPredefinesBlocks R) { 160 // First, sum up the lengths. 161 unsigned LL = 0, RL = 0; 162 for (unsigned I = 0, N = L.size(); I != N; ++I) { 163 LL += L[I].size(); 164 } 165 for (unsigned I = 0, N = R.size(); I != N; ++I) { 166 RL += R[I].Data.size(); 167 } 168 if (LL != RL) 169 return false; 170 if (LL == 0 && RL == 0) 171 return true; 172 173 // Kick out empty parts, they confuse the algorithm below. 174 L.erase(std::remove_if(L.begin(), L.end(), EmptyStringRef()), L.end()); 175 R.erase(std::remove_if(R.begin(), R.end(), EmptyBlock()), R.end()); 176 177 // Do it the hard way. At this point, both vectors must be non-empty. 178 llvm::StringRef LR = L[0], RR = R[0].Data; 179 unsigned LI = 0, RI = 0, LN = L.size(), RN = R.size(); 180 (void) RN; 181 for (;;) { 182 // Compare the current pieces. 183 if (LR.size() == RR.size()) { 184 // If they're the same length, it's pretty easy. 185 if (LR != RR) 186 return false; 187 // Both pieces are done, advance. 188 ++LI; 189 ++RI; 190 // If either string is done, they're both done, since they're the same 191 // length. 192 if (LI == LN) { 193 assert(RI == RN && "Strings not the same length after all?"); 194 return true; 195 } 196 LR = L[LI]; 197 RR = R[RI].Data; 198 } else if (LR.size() < RR.size()) { 199 // Right piece is longer. 200 if (!RR.startswith(LR)) 201 return false; 202 ++LI; 203 assert(LI != LN && "Strings not the same length after all?"); 204 RR = RR.substr(LR.size()); 205 LR = L[LI]; 206 } else { 207 // Left piece is longer. 208 if (!LR.startswith(RR)) 209 return false; 210 ++RI; 211 assert(RI != RN && "Strings not the same length after all?"); 212 LR = LR.substr(RR.size()); 213 RR = R[RI].Data; 214 } 215 } 216} 217 218static std::pair<FileID, llvm::StringRef::size_type> 219FindMacro(const PCHPredefinesBlocks &Buffers, llvm::StringRef MacroDef) { 220 std::pair<FileID, llvm::StringRef::size_type> Res; 221 for (unsigned I = 0, N = Buffers.size(); I != N; ++I) { 222 Res.second = Buffers[I].Data.find(MacroDef); 223 if (Res.second != llvm::StringRef::npos) { 224 Res.first = Buffers[I].BufferID; 225 break; 226 } 227 } 228 return Res; 229} 230 231bool PCHValidator::ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers, 232 llvm::StringRef OriginalFileName, 233 std::string &SuggestedPredefines) { 234 // We are in the context of an implicit include, so the predefines buffer will 235 // have a #include entry for the PCH file itself (as normalized by the 236 // preprocessor initialization). Find it and skip over it in the checking 237 // below. 238 llvm::SmallString<256> PCHInclude; 239 PCHInclude += "#include \""; 240 PCHInclude += NormalizeDashIncludePath(OriginalFileName); 241 PCHInclude += "\"\n"; 242 std::pair<llvm::StringRef,llvm::StringRef> Split = 243 llvm::StringRef(PP.getPredefines()).split(PCHInclude.str()); 244 llvm::StringRef Left = Split.first, Right = Split.second; 245 if (Left == PP.getPredefines()) { 246 Error("Missing PCH include entry!"); 247 return true; 248 } 249 250 // If the concatenation of all the PCH buffers is equal to the adjusted 251 // command line, we're done. 252 llvm::SmallVector<llvm::StringRef, 2> CommandLine; 253 CommandLine.push_back(Left); 254 CommandLine.push_back(Right); 255 if (EqualConcatenations(CommandLine, Buffers)) 256 return false; 257 258 SourceManager &SourceMgr = PP.getSourceManager(); 259 260 // The predefines buffers are different. Determine what the differences are, 261 // and whether they require us to reject the PCH file. 262 llvm::SmallVector<llvm::StringRef, 8> PCHLines; 263 for (unsigned I = 0, N = Buffers.size(); I != N; ++I) 264 Buffers[I].Data.split(PCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false); 265 266 llvm::SmallVector<llvm::StringRef, 8> CmdLineLines; 267 Left.split(CmdLineLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false); 268 269 // Pick out implicit #includes after the PCH and don't consider them for 270 // validation; we will insert them into SuggestedPredefines so that the 271 // preprocessor includes them. 272 std::string IncludesAfterPCH; 273 llvm::SmallVector<llvm::StringRef, 8> AfterPCHLines; 274 Right.split(AfterPCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false); 275 for (unsigned i = 0, e = AfterPCHLines.size(); i != e; ++i) { 276 if (AfterPCHLines[i].startswith("#include ")) { 277 IncludesAfterPCH += AfterPCHLines[i]; 278 IncludesAfterPCH += '\n'; 279 } else { 280 CmdLineLines.push_back(AfterPCHLines[i]); 281 } 282 } 283 284 // Make sure we add the includes last into SuggestedPredefines before we 285 // exit this function. 286 struct AddIncludesRAII { 287 std::string &SuggestedPredefines; 288 std::string &IncludesAfterPCH; 289 290 AddIncludesRAII(std::string &SuggestedPredefines, 291 std::string &IncludesAfterPCH) 292 : SuggestedPredefines(SuggestedPredefines), 293 IncludesAfterPCH(IncludesAfterPCH) { } 294 ~AddIncludesRAII() { 295 SuggestedPredefines += IncludesAfterPCH; 296 } 297 } AddIncludes(SuggestedPredefines, IncludesAfterPCH); 298 299 // Sort both sets of predefined buffer lines, since we allow some extra 300 // definitions and they may appear at any point in the output. 301 std::sort(CmdLineLines.begin(), CmdLineLines.end()); 302 std::sort(PCHLines.begin(), PCHLines.end()); 303 304 // Determine which predefines that were used to build the PCH file are missing 305 // from the command line. 306 std::vector<llvm::StringRef> MissingPredefines; 307 std::set_difference(PCHLines.begin(), PCHLines.end(), 308 CmdLineLines.begin(), CmdLineLines.end(), 309 std::back_inserter(MissingPredefines)); 310 311 bool MissingDefines = false; 312 bool ConflictingDefines = false; 313 for (unsigned I = 0, N = MissingPredefines.size(); I != N; ++I) { 314 llvm::StringRef Missing = MissingPredefines[I]; 315 if (Missing.startswith("#include ")) { 316 // An -include was specified when generating the PCH; it is included in 317 // the PCH, just ignore it. 318 continue; 319 } 320 if (!Missing.startswith("#define ")) { 321 Reader.Diag(diag::warn_pch_compiler_options_mismatch); 322 return true; 323 } 324 325 // This is a macro definition. Determine the name of the macro we're 326 // defining. 327 std::string::size_type StartOfMacroName = strlen("#define "); 328 std::string::size_type EndOfMacroName 329 = Missing.find_first_of("( \n\r", StartOfMacroName); 330 assert(EndOfMacroName != std::string::npos && 331 "Couldn't find the end of the macro name"); 332 llvm::StringRef MacroName = Missing.slice(StartOfMacroName, EndOfMacroName); 333 334 // Determine whether this macro was given a different definition on the 335 // command line. 336 std::string MacroDefStart = "#define " + MacroName.str(); 337 std::string::size_type MacroDefLen = MacroDefStart.size(); 338 llvm::SmallVector<llvm::StringRef, 8>::iterator ConflictPos 339 = std::lower_bound(CmdLineLines.begin(), CmdLineLines.end(), 340 MacroDefStart); 341 for (; ConflictPos != CmdLineLines.end(); ++ConflictPos) { 342 if (!ConflictPos->startswith(MacroDefStart)) { 343 // Different macro; we're done. 344 ConflictPos = CmdLineLines.end(); 345 break; 346 } 347 348 assert(ConflictPos->size() > MacroDefLen && 349 "Invalid #define in predefines buffer?"); 350 if ((*ConflictPos)[MacroDefLen] != ' ' && 351 (*ConflictPos)[MacroDefLen] != '(') 352 continue; // Longer macro name; keep trying. 353 354 // We found a conflicting macro definition. 355 break; 356 } 357 358 if (ConflictPos != CmdLineLines.end()) { 359 Reader.Diag(diag::warn_cmdline_conflicting_macro_def) 360 << MacroName; 361 362 // Show the definition of this macro within the PCH file. 363 std::pair<FileID, llvm::StringRef::size_type> MacroLoc = 364 FindMacro(Buffers, Missing); 365 assert(MacroLoc.second!=llvm::StringRef::npos && "Unable to find macro!"); 366 SourceLocation PCHMissingLoc = 367 SourceMgr.getLocForStartOfFile(MacroLoc.first) 368 .getFileLocWithOffset(MacroLoc.second); 369 Reader.Diag(PCHMissingLoc, diag::note_pch_macro_defined_as) << MacroName; 370 371 ConflictingDefines = true; 372 continue; 373 } 374 375 // If the macro doesn't conflict, then we'll just pick up the macro 376 // definition from the PCH file. Warn the user that they made a mistake. 377 if (ConflictingDefines) 378 continue; // Don't complain if there are already conflicting defs 379 380 if (!MissingDefines) { 381 Reader.Diag(diag::warn_cmdline_missing_macro_defs); 382 MissingDefines = true; 383 } 384 385 // Show the definition of this macro within the PCH file. 386 std::pair<FileID, llvm::StringRef::size_type> MacroLoc = 387 FindMacro(Buffers, Missing); 388 assert(MacroLoc.second!=llvm::StringRef::npos && "Unable to find macro!"); 389 SourceLocation PCHMissingLoc = 390 SourceMgr.getLocForStartOfFile(MacroLoc.first) 391 .getFileLocWithOffset(MacroLoc.second); 392 Reader.Diag(PCHMissingLoc, diag::note_using_macro_def_from_pch); 393 } 394 395 if (ConflictingDefines) 396 return true; 397 398 // Determine what predefines were introduced based on command-line 399 // parameters that were not present when building the PCH 400 // file. Extra #defines are okay, so long as the identifiers being 401 // defined were not used within the precompiled header. 402 std::vector<llvm::StringRef> ExtraPredefines; 403 std::set_difference(CmdLineLines.begin(), CmdLineLines.end(), 404 PCHLines.begin(), PCHLines.end(), 405 std::back_inserter(ExtraPredefines)); 406 for (unsigned I = 0, N = ExtraPredefines.size(); I != N; ++I) { 407 llvm::StringRef &Extra = ExtraPredefines[I]; 408 if (!Extra.startswith("#define ")) { 409 Reader.Diag(diag::warn_pch_compiler_options_mismatch); 410 return true; 411 } 412 413 // This is an extra macro definition. Determine the name of the 414 // macro we're defining. 415 std::string::size_type StartOfMacroName = strlen("#define "); 416 std::string::size_type EndOfMacroName 417 = Extra.find_first_of("( \n\r", StartOfMacroName); 418 assert(EndOfMacroName != std::string::npos && 419 "Couldn't find the end of the macro name"); 420 llvm::StringRef MacroName = Extra.slice(StartOfMacroName, EndOfMacroName); 421 422 // Check whether this name was used somewhere in the PCH file. If 423 // so, defining it as a macro could change behavior, so we reject 424 // the PCH file. 425 if (IdentifierInfo *II = Reader.get(MacroName)) { 426 Reader.Diag(diag::warn_macro_name_used_in_pch) << II; 427 return true; 428 } 429 430 // Add this definition to the suggested predefines buffer. 431 SuggestedPredefines += Extra; 432 SuggestedPredefines += '\n'; 433 } 434 435 // If we get here, it's because the predefines buffer had compatible 436 // contents. Accept the PCH file. 437 return false; 438} 439 440void PCHValidator::ReadHeaderFileInfo(const HeaderFileInfo &HFI, 441 unsigned ID) { 442 PP.getHeaderSearchInfo().setHeaderFileInfoForUID(HFI, ID); 443 ++NumHeaderInfos; 444} 445 446void PCHValidator::ReadCounter(unsigned Value) { 447 PP.setCounterValue(Value); 448} 449 450//===----------------------------------------------------------------------===// 451// AST reader implementation 452//===----------------------------------------------------------------------===// 453 454void 455ASTReader::setDeserializationListener(ASTDeserializationListener *Listener) { 456 DeserializationListener = Listener; 457} 458 459 460namespace { 461class ASTSelectorLookupTrait { 462 ASTReader &Reader; 463 464public: 465 struct data_type { 466 SelectorID ID; 467 ObjCMethodList Instance, Factory; 468 }; 469 470 typedef Selector external_key_type; 471 typedef external_key_type internal_key_type; 472 473 explicit ASTSelectorLookupTrait(ASTReader &Reader) : Reader(Reader) { } 474 475 static bool EqualKey(const internal_key_type& a, 476 const internal_key_type& b) { 477 return a == b; 478 } 479 480 static unsigned ComputeHash(Selector Sel) { 481 return serialization::ComputeHash(Sel); 482 } 483 484 // This hopefully will just get inlined and removed by the optimizer. 485 static const internal_key_type& 486 GetInternalKey(const external_key_type& x) { return x; } 487 488 static std::pair<unsigned, unsigned> 489 ReadKeyDataLength(const unsigned char*& d) { 490 using namespace clang::io; 491 unsigned KeyLen = ReadUnalignedLE16(d); 492 unsigned DataLen = ReadUnalignedLE16(d); 493 return std::make_pair(KeyLen, DataLen); 494 } 495 496 internal_key_type ReadKey(const unsigned char* d, unsigned) { 497 using namespace clang::io; 498 SelectorTable &SelTable = Reader.getContext()->Selectors; 499 unsigned N = ReadUnalignedLE16(d); 500 IdentifierInfo *FirstII 501 = Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d)); 502 if (N == 0) 503 return SelTable.getNullarySelector(FirstII); 504 else if (N == 1) 505 return SelTable.getUnarySelector(FirstII); 506 507 llvm::SmallVector<IdentifierInfo *, 16> Args; 508 Args.push_back(FirstII); 509 for (unsigned I = 1; I != N; ++I) 510 Args.push_back(Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d))); 511 512 return SelTable.getSelector(N, Args.data()); 513 } 514 515 data_type ReadData(Selector, const unsigned char* d, unsigned DataLen) { 516 using namespace clang::io; 517 518 data_type Result; 519 520 Result.ID = ReadUnalignedLE32(d); 521 unsigned NumInstanceMethods = ReadUnalignedLE16(d); 522 unsigned NumFactoryMethods = ReadUnalignedLE16(d); 523 524 // Load instance methods 525 ObjCMethodList *Prev = 0; 526 for (unsigned I = 0; I != NumInstanceMethods; ++I) { 527 ObjCMethodDecl *Method 528 = cast<ObjCMethodDecl>(Reader.GetDecl(ReadUnalignedLE32(d))); 529 if (!Result.Instance.Method) { 530 // This is the first method, which is the easy case. 531 Result.Instance.Method = Method; 532 Prev = &Result.Instance; 533 continue; 534 } 535 536 ObjCMethodList *Mem = 537 Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>(); 538 Prev->Next = new (Mem) ObjCMethodList(Method, 0); 539 Prev = Prev->Next; 540 } 541 542 // Load factory methods 543 Prev = 0; 544 for (unsigned I = 0; I != NumFactoryMethods; ++I) { 545 ObjCMethodDecl *Method 546 = cast<ObjCMethodDecl>(Reader.GetDecl(ReadUnalignedLE32(d))); 547 if (!Result.Factory.Method) { 548 // This is the first method, which is the easy case. 549 Result.Factory.Method = Method; 550 Prev = &Result.Factory; 551 continue; 552 } 553 554 ObjCMethodList *Mem = 555 Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>(); 556 Prev->Next = new (Mem) ObjCMethodList(Method, 0); 557 Prev = Prev->Next; 558 } 559 560 return Result; 561 } 562}; 563 564} // end anonymous namespace 565 566/// \brief The on-disk hash table used for the global method pool. 567typedef OnDiskChainedHashTable<ASTSelectorLookupTrait> 568 ASTSelectorLookupTable; 569 570namespace clang { 571class ASTIdentifierLookupTrait { 572 ASTReader &Reader; 573 ASTReader::PerFileData &F; 574 575 // If we know the IdentifierInfo in advance, it is here and we will 576 // not build a new one. Used when deserializing information about an 577 // identifier that was constructed before the AST file was read. 578 IdentifierInfo *KnownII; 579 580public: 581 typedef IdentifierInfo * data_type; 582 583 typedef const std::pair<const char*, unsigned> external_key_type; 584 585 typedef external_key_type internal_key_type; 586 587 ASTIdentifierLookupTrait(ASTReader &Reader, ASTReader::PerFileData &F, 588 IdentifierInfo *II = 0) 589 : Reader(Reader), F(F), KnownII(II) { } 590 591 static bool EqualKey(const internal_key_type& a, 592 const internal_key_type& b) { 593 return (a.second == b.second) ? memcmp(a.first, b.first, a.second) == 0 594 : false; 595 } 596 597 static unsigned ComputeHash(const internal_key_type& a) { 598 return llvm::HashString(llvm::StringRef(a.first, a.second)); 599 } 600 601 // This hopefully will just get inlined and removed by the optimizer. 602 static const internal_key_type& 603 GetInternalKey(const external_key_type& x) { return x; } 604 605 // This hopefully will just get inlined and removed by the optimizer. 606 static const external_key_type& 607 GetExternalKey(const internal_key_type& x) { return x; } 608 609 static std::pair<unsigned, unsigned> 610 ReadKeyDataLength(const unsigned char*& d) { 611 using namespace clang::io; 612 unsigned DataLen = ReadUnalignedLE16(d); 613 unsigned KeyLen = ReadUnalignedLE16(d); 614 return std::make_pair(KeyLen, DataLen); 615 } 616 617 static std::pair<const char*, unsigned> 618 ReadKey(const unsigned char* d, unsigned n) { 619 assert(n >= 2 && d[n-1] == '\0'); 620 return std::make_pair((const char*) d, n-1); 621 } 622 623 IdentifierInfo *ReadData(const internal_key_type& k, 624 const unsigned char* d, 625 unsigned DataLen) { 626 using namespace clang::io; 627 IdentID ID = ReadUnalignedLE32(d); 628 bool IsInteresting = ID & 0x01; 629 630 // Wipe out the "is interesting" bit. 631 ID = ID >> 1; 632 633 if (!IsInteresting) { 634 // For uninteresting identifiers, just build the IdentifierInfo 635 // and associate it with the persistent ID. 636 IdentifierInfo *II = KnownII; 637 if (!II) 638 II = &Reader.getIdentifierTable().getOwn(k.first, k.first + k.second); 639 Reader.SetIdentifierInfo(ID, II); 640 II->setIsFromAST(); 641 return II; 642 } 643 644 unsigned Bits = ReadUnalignedLE16(d); 645 bool CPlusPlusOperatorKeyword = Bits & 0x01; 646 Bits >>= 1; 647 bool HasRevertedTokenIDToIdentifier = Bits & 0x01; 648 Bits >>= 1; 649 bool Poisoned = Bits & 0x01; 650 Bits >>= 1; 651 bool ExtensionToken = Bits & 0x01; 652 Bits >>= 1; 653 bool hasMacroDefinition = Bits & 0x01; 654 Bits >>= 1; 655 unsigned ObjCOrBuiltinID = Bits & 0x3FF; 656 Bits >>= 10; 657 658 assert(Bits == 0 && "Extra bits in the identifier?"); 659 DataLen -= 6; 660 661 // Build the IdentifierInfo itself and link the identifier ID with 662 // the new IdentifierInfo. 663 IdentifierInfo *II = KnownII; 664 if (!II) 665 II = &Reader.getIdentifierTable().getOwn(k.first, k.first + k.second); 666 Reader.SetIdentifierInfo(ID, II); 667 668 // Set or check the various bits in the IdentifierInfo structure. 669 // Token IDs are read-only. 670 if (HasRevertedTokenIDToIdentifier) 671 II->RevertTokenIDToIdentifier(); 672 II->setObjCOrBuiltinID(ObjCOrBuiltinID); 673 assert(II->isExtensionToken() == ExtensionToken && 674 "Incorrect extension token flag"); 675 (void)ExtensionToken; 676 II->setIsPoisoned(Poisoned); 677 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword && 678 "Incorrect C++ operator keyword flag"); 679 (void)CPlusPlusOperatorKeyword; 680 681 // If this identifier is a macro, deserialize the macro 682 // definition. 683 if (hasMacroDefinition) { 684 uint32_t Offset = ReadUnalignedLE32(d); 685 Reader.ReadMacroRecord(F, Offset); 686 DataLen -= 4; 687 } 688 689 // Read all of the declarations visible at global scope with this 690 // name. 691 if (Reader.getContext() == 0) return II; 692 if (DataLen > 0) { 693 llvm::SmallVector<uint32_t, 4> DeclIDs; 694 for (; DataLen > 0; DataLen -= 4) 695 DeclIDs.push_back(ReadUnalignedLE32(d)); 696 Reader.SetGloballyVisibleDecls(II, DeclIDs); 697 } 698 699 II->setIsFromAST(); 700 return II; 701 } 702}; 703 704} // end anonymous namespace 705 706/// \brief The on-disk hash table used to contain information about 707/// all of the identifiers in the program. 708typedef OnDiskChainedHashTable<ASTIdentifierLookupTrait> 709 ASTIdentifierLookupTable; 710 711namespace { 712class ASTDeclContextNameLookupTrait { 713 ASTReader &Reader; 714 715public: 716 /// \brief Pair of begin/end iterators for DeclIDs. 717 typedef std::pair<DeclID *, DeclID *> data_type; 718 719 /// \brief Special internal key for declaration names. 720 /// The hash table creates keys for comparison; we do not create 721 /// a DeclarationName for the internal key to avoid deserializing types. 722 struct DeclNameKey { 723 DeclarationName::NameKind Kind; 724 uint64_t Data; 725 DeclNameKey() : Kind((DeclarationName::NameKind)0), Data(0) { } 726 }; 727 728 typedef DeclarationName external_key_type; 729 typedef DeclNameKey internal_key_type; 730 731 explicit ASTDeclContextNameLookupTrait(ASTReader &Reader) : Reader(Reader) { } 732 733 static bool EqualKey(const internal_key_type& a, 734 const internal_key_type& b) { 735 return a.Kind == b.Kind && a.Data == b.Data; 736 } 737 738 unsigned ComputeHash(const DeclNameKey &Key) const { 739 llvm::FoldingSetNodeID ID; 740 ID.AddInteger(Key.Kind); 741 742 switch (Key.Kind) { 743 case DeclarationName::Identifier: 744 case DeclarationName::CXXLiteralOperatorName: 745 ID.AddString(((IdentifierInfo*)Key.Data)->getName()); 746 break; 747 case DeclarationName::ObjCZeroArgSelector: 748 case DeclarationName::ObjCOneArgSelector: 749 case DeclarationName::ObjCMultiArgSelector: 750 ID.AddInteger(serialization::ComputeHash(Selector(Key.Data))); 751 break; 752 case DeclarationName::CXXConstructorName: 753 case DeclarationName::CXXDestructorName: 754 case DeclarationName::CXXConversionFunctionName: 755 ID.AddInteger((TypeID)Key.Data); 756 break; 757 case DeclarationName::CXXOperatorName: 758 ID.AddInteger((OverloadedOperatorKind)Key.Data); 759 break; 760 case DeclarationName::CXXUsingDirective: 761 break; 762 } 763 764 return ID.ComputeHash(); 765 } 766 767 internal_key_type GetInternalKey(const external_key_type& Name) const { 768 DeclNameKey Key; 769 Key.Kind = Name.getNameKind(); 770 switch (Name.getNameKind()) { 771 case DeclarationName::Identifier: 772 Key.Data = (uint64_t)Name.getAsIdentifierInfo(); 773 break; 774 case DeclarationName::ObjCZeroArgSelector: 775 case DeclarationName::ObjCOneArgSelector: 776 case DeclarationName::ObjCMultiArgSelector: 777 Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr(); 778 break; 779 case DeclarationName::CXXConstructorName: 780 case DeclarationName::CXXDestructorName: 781 case DeclarationName::CXXConversionFunctionName: 782 Key.Data = Reader.GetTypeID(Name.getCXXNameType()); 783 break; 784 case DeclarationName::CXXOperatorName: 785 Key.Data = Name.getCXXOverloadedOperator(); 786 break; 787 case DeclarationName::CXXLiteralOperatorName: 788 Key.Data = (uint64_t)Name.getCXXLiteralIdentifier(); 789 break; 790 case DeclarationName::CXXUsingDirective: 791 break; 792 } 793 794 return Key; 795 } 796 797 external_key_type GetExternalKey(const internal_key_type& Key) const { 798 ASTContext *Context = Reader.getContext(); 799 switch (Key.Kind) { 800 case DeclarationName::Identifier: 801 return DeclarationName((IdentifierInfo*)Key.Data); 802 803 case DeclarationName::ObjCZeroArgSelector: 804 case DeclarationName::ObjCOneArgSelector: 805 case DeclarationName::ObjCMultiArgSelector: 806 return DeclarationName(Selector(Key.Data)); 807 808 case DeclarationName::CXXConstructorName: 809 return Context->DeclarationNames.getCXXConstructorName( 810 Context->getCanonicalType(Reader.GetType(Key.Data))); 811 812 case DeclarationName::CXXDestructorName: 813 return Context->DeclarationNames.getCXXDestructorName( 814 Context->getCanonicalType(Reader.GetType(Key.Data))); 815 816 case DeclarationName::CXXConversionFunctionName: 817 return Context->DeclarationNames.getCXXConversionFunctionName( 818 Context->getCanonicalType(Reader.GetType(Key.Data))); 819 820 case DeclarationName::CXXOperatorName: 821 return Context->DeclarationNames.getCXXOperatorName( 822 (OverloadedOperatorKind)Key.Data); 823 824 case DeclarationName::CXXLiteralOperatorName: 825 return Context->DeclarationNames.getCXXLiteralOperatorName( 826 (IdentifierInfo*)Key.Data); 827 828 case DeclarationName::CXXUsingDirective: 829 return DeclarationName::getUsingDirectiveName(); 830 } 831 832 llvm_unreachable("Invalid Name Kind ?"); 833 } 834 835 static std::pair<unsigned, unsigned> 836 ReadKeyDataLength(const unsigned char*& d) { 837 using namespace clang::io; 838 unsigned KeyLen = ReadUnalignedLE16(d); 839 unsigned DataLen = ReadUnalignedLE16(d); 840 return std::make_pair(KeyLen, DataLen); 841 } 842 843 internal_key_type ReadKey(const unsigned char* d, unsigned) { 844 using namespace clang::io; 845 846 DeclNameKey Key; 847 Key.Kind = (DeclarationName::NameKind)*d++; 848 switch (Key.Kind) { 849 case DeclarationName::Identifier: 850 Key.Data = (uint64_t)Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d)); 851 break; 852 case DeclarationName::ObjCZeroArgSelector: 853 case DeclarationName::ObjCOneArgSelector: 854 case DeclarationName::ObjCMultiArgSelector: 855 Key.Data = 856 (uint64_t)Reader.DecodeSelector(ReadUnalignedLE32(d)).getAsOpaquePtr(); 857 break; 858 case DeclarationName::CXXConstructorName: 859 case DeclarationName::CXXDestructorName: 860 case DeclarationName::CXXConversionFunctionName: 861 Key.Data = ReadUnalignedLE32(d); // TypeID 862 break; 863 case DeclarationName::CXXOperatorName: 864 Key.Data = *d++; // OverloadedOperatorKind 865 break; 866 case DeclarationName::CXXLiteralOperatorName: 867 Key.Data = (uint64_t)Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d)); 868 break; 869 case DeclarationName::CXXUsingDirective: 870 break; 871 } 872 873 return Key; 874 } 875 876 data_type ReadData(internal_key_type, const unsigned char* d, 877 unsigned DataLen) { 878 using namespace clang::io; 879 unsigned NumDecls = ReadUnalignedLE16(d); 880 DeclID *Start = (DeclID *)d; 881 return std::make_pair(Start, Start + NumDecls); 882 } 883}; 884 885} // end anonymous namespace 886 887/// \brief The on-disk hash table used for the DeclContext's Name lookup table. 888typedef OnDiskChainedHashTable<ASTDeclContextNameLookupTrait> 889 ASTDeclContextNameLookupTable; 890 891bool ASTReader::ReadDeclContextStorage(llvm::BitstreamCursor &Cursor, 892 const std::pair<uint64_t, uint64_t> &Offsets, 893 DeclContextInfo &Info) { 894 SavedStreamPosition SavedPosition(Cursor); 895 // First the lexical decls. 896 if (Offsets.first != 0) { 897 Cursor.JumpToBit(Offsets.first); 898 899 RecordData Record; 900 const char *Blob; 901 unsigned BlobLen; 902 unsigned Code = Cursor.ReadCode(); 903 unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen); 904 if (RecCode != DECL_CONTEXT_LEXICAL) { 905 Error("Expected lexical block"); 906 return true; 907 } 908 909 Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair*>(Blob); 910 Info.NumLexicalDecls = BlobLen / sizeof(KindDeclIDPair); 911 } else { 912 Info.LexicalDecls = 0; 913 Info.NumLexicalDecls = 0; 914 } 915 916 // Now the lookup table. 917 if (Offsets.second != 0) { 918 Cursor.JumpToBit(Offsets.second); 919 920 RecordData Record; 921 const char *Blob; 922 unsigned BlobLen; 923 unsigned Code = Cursor.ReadCode(); 924 unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen); 925 if (RecCode != DECL_CONTEXT_VISIBLE) { 926 Error("Expected visible lookup table block"); 927 return true; 928 } 929 Info.NameLookupTableData 930 = ASTDeclContextNameLookupTable::Create( 931 (const unsigned char *)Blob + Record[0], 932 (const unsigned char *)Blob, 933 ASTDeclContextNameLookupTrait(*this)); 934 } else { 935 Info.NameLookupTableData = 0; 936 } 937 938 return false; 939} 940 941void ASTReader::Error(const char *Msg) { 942 Diag(diag::err_fe_pch_malformed) << Msg; 943} 944 945/// \brief Tell the AST listener about the predefines buffers in the chain. 946bool ASTReader::CheckPredefinesBuffers() { 947 if (Listener) 948 return Listener->ReadPredefinesBuffer(PCHPredefinesBuffers, 949 ActualOriginalFileName, 950 SuggestedPredefines); 951 return false; 952} 953 954//===----------------------------------------------------------------------===// 955// Source Manager Deserialization 956//===----------------------------------------------------------------------===// 957 958/// \brief Read the line table in the source manager block. 959/// \returns true if there was an error. 960bool ASTReader::ParseLineTable(PerFileData &F, 961 llvm::SmallVectorImpl<uint64_t> &Record) { 962 unsigned Idx = 0; 963 LineTableInfo &LineTable = SourceMgr.getLineTable(); 964 965 // Parse the file names 966 std::map<int, int> FileIDs; 967 for (int I = 0, N = Record[Idx++]; I != N; ++I) { 968 // Extract the file name 969 unsigned FilenameLen = Record[Idx++]; 970 std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen); 971 Idx += FilenameLen; 972 MaybeAddSystemRootToFilename(Filename); 973 FileIDs[I] = LineTable.getLineTableFilenameID(Filename.c_str(), 974 Filename.size()); 975 } 976 977 // Parse the line entries 978 std::vector<LineEntry> Entries; 979 while (Idx < Record.size()) { 980 int FID = Record[Idx++]; 981 982 // Extract the line entries 983 unsigned NumEntries = Record[Idx++]; 984 assert(NumEntries && "Numentries is 00000"); 985 Entries.clear(); 986 Entries.reserve(NumEntries); 987 for (unsigned I = 0; I != NumEntries; ++I) { 988 unsigned FileOffset = Record[Idx++]; 989 unsigned LineNo = Record[Idx++]; 990 int FilenameID = FileIDs[Record[Idx++]]; 991 SrcMgr::CharacteristicKind FileKind 992 = (SrcMgr::CharacteristicKind)Record[Idx++]; 993 unsigned IncludeOffset = Record[Idx++]; 994 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID, 995 FileKind, IncludeOffset)); 996 } 997 LineTable.AddEntry(FID, Entries); 998 } 999 1000 return false; 1001} 1002 1003namespace { 1004 1005class ASTStatData { 1006public: 1007 const bool hasStat; 1008 const ino_t ino; 1009 const dev_t dev; 1010 const mode_t mode; 1011 const time_t mtime; 1012 const off_t size; 1013 1014 ASTStatData(ino_t i, dev_t d, mode_t mo, time_t m, off_t s) 1015 : hasStat(true), ino(i), dev(d), mode(mo), mtime(m), size(s) {} 1016 1017 ASTStatData() 1018 : hasStat(false), ino(0), dev(0), mode(0), mtime(0), size(0) {} 1019}; 1020 1021class ASTStatLookupTrait { 1022 public: 1023 typedef const char *external_key_type; 1024 typedef const char *internal_key_type; 1025 1026 typedef ASTStatData data_type; 1027 1028 static unsigned ComputeHash(const char *path) { 1029 return llvm::HashString(path); 1030 } 1031 1032 static internal_key_type GetInternalKey(const char *path) { return path; } 1033 1034 static bool EqualKey(internal_key_type a, internal_key_type b) { 1035 return strcmp(a, b) == 0; 1036 } 1037 1038 static std::pair<unsigned, unsigned> 1039 ReadKeyDataLength(const unsigned char*& d) { 1040 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d); 1041 unsigned DataLen = (unsigned) *d++; 1042 return std::make_pair(KeyLen + 1, DataLen); 1043 } 1044 1045 static internal_key_type ReadKey(const unsigned char *d, unsigned) { 1046 return (const char *)d; 1047 } 1048 1049 static data_type ReadData(const internal_key_type, const unsigned char *d, 1050 unsigned /*DataLen*/) { 1051 using namespace clang::io; 1052 1053 if (*d++ == 1) 1054 return data_type(); 1055 1056 ino_t ino = (ino_t) ReadUnalignedLE32(d); 1057 dev_t dev = (dev_t) ReadUnalignedLE32(d); 1058 mode_t mode = (mode_t) ReadUnalignedLE16(d); 1059 time_t mtime = (time_t) ReadUnalignedLE64(d); 1060 off_t size = (off_t) ReadUnalignedLE64(d); 1061 return data_type(ino, dev, mode, mtime, size); 1062 } 1063}; 1064 1065/// \brief stat() cache for precompiled headers. 1066/// 1067/// This cache is very similar to the stat cache used by pretokenized 1068/// headers. 1069class ASTStatCache : public StatSysCallCache { 1070 typedef OnDiskChainedHashTable<ASTStatLookupTrait> CacheTy; 1071 CacheTy *Cache; 1072 1073 unsigned &NumStatHits, &NumStatMisses; 1074public: 1075 ASTStatCache(const unsigned char *Buckets, 1076 const unsigned char *Base, 1077 unsigned &NumStatHits, 1078 unsigned &NumStatMisses) 1079 : Cache(0), NumStatHits(NumStatHits), NumStatMisses(NumStatMisses) { 1080 Cache = CacheTy::Create(Buckets, Base); 1081 } 1082 1083 ~ASTStatCache() { delete Cache; } 1084 1085 int stat(const char *path, struct stat *buf) { 1086 // Do the lookup for the file's data in the AST file. 1087 CacheTy::iterator I = Cache->find(path); 1088 1089 // If we don't get a hit in the AST file just forward to 'stat'. 1090 if (I == Cache->end()) { 1091 ++NumStatMisses; 1092 return StatSysCallCache::stat(path, buf); 1093 } 1094 1095 ++NumStatHits; 1096 ASTStatData Data = *I; 1097 1098 if (!Data.hasStat) 1099 return 1; 1100 1101 buf->st_ino = Data.ino; 1102 buf->st_dev = Data.dev; 1103 buf->st_mtime = Data.mtime; 1104 buf->st_mode = Data.mode; 1105 buf->st_size = Data.size; 1106 return 0; 1107 } 1108}; 1109} // end anonymous namespace 1110 1111 1112/// \brief Read a source manager block 1113ASTReader::ASTReadResult ASTReader::ReadSourceManagerBlock(PerFileData &F) { 1114 using namespace SrcMgr; 1115 1116 llvm::BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor; 1117 1118 // Set the source-location entry cursor to the current position in 1119 // the stream. This cursor will be used to read the contents of the 1120 // source manager block initially, and then lazily read 1121 // source-location entries as needed. 1122 SLocEntryCursor = F.Stream; 1123 1124 // The stream itself is going to skip over the source manager block. 1125 if (F.Stream.SkipBlock()) { 1126 Error("malformed block record in AST file"); 1127 return Failure; 1128 } 1129 1130 // Enter the source manager block. 1131 if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) { 1132 Error("malformed source manager block record in AST file"); 1133 return Failure; 1134 } 1135 1136 RecordData Record; 1137 while (true) { 1138 unsigned Code = SLocEntryCursor.ReadCode(); 1139 if (Code == llvm::bitc::END_BLOCK) { 1140 if (SLocEntryCursor.ReadBlockEnd()) { 1141 Error("error at end of Source Manager block in AST file"); 1142 return Failure; 1143 } 1144 return Success; 1145 } 1146 1147 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1148 // No known subblocks, always skip them. 1149 SLocEntryCursor.ReadSubBlockID(); 1150 if (SLocEntryCursor.SkipBlock()) { 1151 Error("malformed block record in AST file"); 1152 return Failure; 1153 } 1154 continue; 1155 } 1156 1157 if (Code == llvm::bitc::DEFINE_ABBREV) { 1158 SLocEntryCursor.ReadAbbrevRecord(); 1159 continue; 1160 } 1161 1162 // Read a record. 1163 const char *BlobStart; 1164 unsigned BlobLen; 1165 Record.clear(); 1166 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 1167 default: // Default behavior: ignore. 1168 break; 1169 1170 case SM_LINE_TABLE: 1171 if (ParseLineTable(F, Record)) 1172 return Failure; 1173 break; 1174 1175 case SM_SLOC_FILE_ENTRY: 1176 case SM_SLOC_BUFFER_ENTRY: 1177 case SM_SLOC_INSTANTIATION_ENTRY: 1178 // Once we hit one of the source location entries, we're done. 1179 return Success; 1180 } 1181 } 1182} 1183 1184/// \brief Get a cursor that's correctly positioned for reading the source 1185/// location entry with the given ID. 1186ASTReader::PerFileData *ASTReader::SLocCursorForID(unsigned ID) { 1187 assert(ID != 0 && ID <= TotalNumSLocEntries && 1188 "SLocCursorForID should only be called for real IDs."); 1189 1190 ID -= 1; 1191 PerFileData *F = 0; 1192 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 1193 F = Chain[N - I - 1]; 1194 if (ID < F->LocalNumSLocEntries) 1195 break; 1196 ID -= F->LocalNumSLocEntries; 1197 } 1198 assert(F && F->LocalNumSLocEntries > ID && "Chain corrupted"); 1199 1200 F->SLocEntryCursor.JumpToBit(F->SLocOffsets[ID]); 1201 return F; 1202} 1203 1204/// \brief Read in the source location entry with the given ID. 1205ASTReader::ASTReadResult ASTReader::ReadSLocEntryRecord(unsigned ID) { 1206 if (ID == 0) 1207 return Success; 1208 1209 if (ID > TotalNumSLocEntries) { 1210 Error("source location entry ID out-of-range for AST file"); 1211 return Failure; 1212 } 1213 1214 PerFileData *F = SLocCursorForID(ID); 1215 llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor; 1216 1217 ++NumSLocEntriesRead; 1218 unsigned Code = SLocEntryCursor.ReadCode(); 1219 if (Code == llvm::bitc::END_BLOCK || 1220 Code == llvm::bitc::ENTER_SUBBLOCK || 1221 Code == llvm::bitc::DEFINE_ABBREV) { 1222 Error("incorrectly-formatted source location entry in AST file"); 1223 return Failure; 1224 } 1225 1226 RecordData Record; 1227 const char *BlobStart; 1228 unsigned BlobLen; 1229 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 1230 default: 1231 Error("incorrectly-formatted source location entry in AST file"); 1232 return Failure; 1233 1234 case SM_SLOC_FILE_ENTRY: { 1235 std::string Filename(BlobStart, BlobStart + BlobLen); 1236 MaybeAddSystemRootToFilename(Filename); 1237 const FileEntry *File = FileMgr.getFile(Filename); 1238 if (File == 0) { 1239 std::string ErrorStr = "could not find file '"; 1240 ErrorStr += Filename; 1241 ErrorStr += "' referenced by AST file"; 1242 Error(ErrorStr.c_str()); 1243 return Failure; 1244 } 1245 1246 if (Record.size() < 10) { 1247 Error("source location entry is incorrect"); 1248 return Failure; 1249 } 1250 1251 if (!DisableValidation && 1252 ((off_t)Record[4] != File->getSize() 1253#if !defined(LLVM_ON_WIN32) 1254 // In our regression testing, the Windows file system seems to 1255 // have inconsistent modification times that sometimes 1256 // erroneously trigger this error-handling path. 1257 || (time_t)Record[5] != File->getModificationTime() 1258#endif 1259 )) { 1260 Diag(diag::err_fe_pch_file_modified) 1261 << Filename; 1262 return Failure; 1263 } 1264 1265 FileID FID = SourceMgr.createFileID(File, 1266 ReadSourceLocation(*F, Record[1]), 1267 (SrcMgr::CharacteristicKind)Record[2], 1268 ID, Record[0]); 1269 if (Record[3]) 1270 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile()) 1271 .setHasLineDirectives(); 1272 1273 // Reconstruct header-search information for this file. 1274 HeaderFileInfo HFI; 1275 HFI.isImport = Record[6]; 1276 HFI.DirInfo = Record[7]; 1277 HFI.NumIncludes = Record[8]; 1278 HFI.ControllingMacroID = Record[9]; 1279 if (Listener) 1280 Listener->ReadHeaderFileInfo(HFI, File->getUID()); 1281 break; 1282 } 1283 1284 case SM_SLOC_BUFFER_ENTRY: { 1285 const char *Name = BlobStart; 1286 unsigned Offset = Record[0]; 1287 unsigned Code = SLocEntryCursor.ReadCode(); 1288 Record.clear(); 1289 unsigned RecCode 1290 = SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen); 1291 1292 if (RecCode != SM_SLOC_BUFFER_BLOB) { 1293 Error("AST record has invalid code"); 1294 return Failure; 1295 } 1296 1297 llvm::MemoryBuffer *Buffer 1298 = llvm::MemoryBuffer::getMemBuffer(llvm::StringRef(BlobStart, BlobLen - 1), 1299 Name); 1300 FileID BufferID = SourceMgr.createFileIDForMemBuffer(Buffer, ID, Offset); 1301 1302 if (strcmp(Name, "<built-in>") == 0) { 1303 PCHPredefinesBlock Block = { 1304 BufferID, 1305 llvm::StringRef(BlobStart, BlobLen - 1) 1306 }; 1307 PCHPredefinesBuffers.push_back(Block); 1308 } 1309 1310 break; 1311 } 1312 1313 case SM_SLOC_INSTANTIATION_ENTRY: { 1314 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]); 1315 SourceMgr.createInstantiationLoc(SpellingLoc, 1316 ReadSourceLocation(*F, Record[2]), 1317 ReadSourceLocation(*F, Record[3]), 1318 Record[4], 1319 ID, 1320 Record[0]); 1321 break; 1322 } 1323 } 1324 1325 return Success; 1326} 1327 1328/// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the 1329/// specified cursor. Read the abbreviations that are at the top of the block 1330/// and then leave the cursor pointing into the block. 1331bool ASTReader::ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor, 1332 unsigned BlockID) { 1333 if (Cursor.EnterSubBlock(BlockID)) { 1334 Error("malformed block record in AST file"); 1335 return Failure; 1336 } 1337 1338 while (true) { 1339 uint64_t Offset = Cursor.GetCurrentBitNo(); 1340 unsigned Code = Cursor.ReadCode(); 1341 1342 // We expect all abbrevs to be at the start of the block. 1343 if (Code != llvm::bitc::DEFINE_ABBREV) { 1344 Cursor.JumpToBit(Offset); 1345 return false; 1346 } 1347 Cursor.ReadAbbrevRecord(); 1348 } 1349} 1350 1351void ASTReader::ReadMacroRecord(PerFileData &F, uint64_t Offset) { 1352 assert(PP && "Forgot to set Preprocessor ?"); 1353 llvm::BitstreamCursor &Stream = F.MacroCursor; 1354 1355 // Keep track of where we are in the stream, then jump back there 1356 // after reading this macro. 1357 SavedStreamPosition SavedPosition(Stream); 1358 1359 Stream.JumpToBit(Offset); 1360 RecordData Record; 1361 llvm::SmallVector<IdentifierInfo*, 16> MacroArgs; 1362 MacroInfo *Macro = 0; 1363 1364 while (true) { 1365 unsigned Code = Stream.ReadCode(); 1366 switch (Code) { 1367 case llvm::bitc::END_BLOCK: 1368 return; 1369 1370 case llvm::bitc::ENTER_SUBBLOCK: 1371 // No known subblocks, always skip them. 1372 Stream.ReadSubBlockID(); 1373 if (Stream.SkipBlock()) { 1374 Error("malformed block record in AST file"); 1375 return; 1376 } 1377 continue; 1378 1379 case llvm::bitc::DEFINE_ABBREV: 1380 Stream.ReadAbbrevRecord(); 1381 continue; 1382 default: break; 1383 } 1384 1385 // Read a record. 1386 const char *BlobStart = 0; 1387 unsigned BlobLen = 0; 1388 Record.clear(); 1389 PreprocessorRecordTypes RecType = 1390 (PreprocessorRecordTypes)Stream.ReadRecord(Code, Record, BlobStart, 1391 BlobLen); 1392 switch (RecType) { 1393 case PP_MACRO_OBJECT_LIKE: 1394 case PP_MACRO_FUNCTION_LIKE: { 1395 // If we already have a macro, that means that we've hit the end 1396 // of the definition of the macro we were looking for. We're 1397 // done. 1398 if (Macro) 1399 return; 1400 1401 IdentifierInfo *II = DecodeIdentifierInfo(Record[0]); 1402 if (II == 0) { 1403 Error("macro must have a name in AST file"); 1404 return; 1405 } 1406 SourceLocation Loc = ReadSourceLocation(F, Record[1]); 1407 bool isUsed = Record[2]; 1408 1409 MacroInfo *MI = PP->AllocateMacroInfo(Loc); 1410 MI->setIsUsed(isUsed); 1411 MI->setIsFromAST(); 1412 1413 unsigned NextIndex = 3; 1414 if (RecType == PP_MACRO_FUNCTION_LIKE) { 1415 // Decode function-like macro info. 1416 bool isC99VarArgs = Record[3]; 1417 bool isGNUVarArgs = Record[4]; 1418 MacroArgs.clear(); 1419 unsigned NumArgs = Record[5]; 1420 NextIndex = 6 + NumArgs; 1421 for (unsigned i = 0; i != NumArgs; ++i) 1422 MacroArgs.push_back(DecodeIdentifierInfo(Record[6+i])); 1423 1424 // Install function-like macro info. 1425 MI->setIsFunctionLike(); 1426 if (isC99VarArgs) MI->setIsC99Varargs(); 1427 if (isGNUVarArgs) MI->setIsGNUVarargs(); 1428 MI->setArgumentList(MacroArgs.data(), MacroArgs.size(), 1429 PP->getPreprocessorAllocator()); 1430 } 1431 1432 // Finally, install the macro. 1433 PP->setMacroInfo(II, MI); 1434 1435 // Remember that we saw this macro last so that we add the tokens that 1436 // form its body to it. 1437 Macro = MI; 1438 1439 if (NextIndex + 1 == Record.size() && PP->getPreprocessingRecord()) { 1440 // We have a macro definition. Load it now. 1441 PP->getPreprocessingRecord()->RegisterMacroDefinition(Macro, 1442 getMacroDefinition(Record[NextIndex])); 1443 } 1444 1445 ++NumMacrosRead; 1446 break; 1447 } 1448 1449 case PP_TOKEN: { 1450 // If we see a TOKEN before a PP_MACRO_*, then the file is 1451 // erroneous, just pretend we didn't see this. 1452 if (Macro == 0) break; 1453 1454 Token Tok; 1455 Tok.startToken(); 1456 Tok.setLocation(ReadSourceLocation(F, Record[0])); 1457 Tok.setLength(Record[1]); 1458 if (IdentifierInfo *II = DecodeIdentifierInfo(Record[2])) 1459 Tok.setIdentifierInfo(II); 1460 Tok.setKind((tok::TokenKind)Record[3]); 1461 Tok.setFlag((Token::TokenFlags)Record[4]); 1462 Macro->AddTokenToBody(Tok); 1463 break; 1464 } 1465 1466 case PP_MACRO_INSTANTIATION: { 1467 // If we already have a macro, that means that we've hit the end 1468 // of the definition of the macro we were looking for. We're 1469 // done. 1470 if (Macro) 1471 return; 1472 1473 if (!PP->getPreprocessingRecord()) { 1474 Error("missing preprocessing record in AST file"); 1475 return; 1476 } 1477 1478 PreprocessingRecord &PPRec = *PP->getPreprocessingRecord(); 1479 if (PPRec.getPreprocessedEntity(Record[0])) 1480 return; 1481 1482 MacroInstantiation *MI 1483 = new (PPRec) MacroInstantiation(DecodeIdentifierInfo(Record[3]), 1484 SourceRange(ReadSourceLocation(F, Record[1]), 1485 ReadSourceLocation(F, Record[2])), 1486 getMacroDefinition(Record[4])); 1487 PPRec.SetPreallocatedEntity(Record[0], MI); 1488 return; 1489 } 1490 1491 case PP_MACRO_DEFINITION: { 1492 // If we already have a macro, that means that we've hit the end 1493 // of the definition of the macro we were looking for. We're 1494 // done. 1495 if (Macro) 1496 return; 1497 1498 if (!PP->getPreprocessingRecord()) { 1499 Error("missing preprocessing record in AST file"); 1500 return; 1501 } 1502 1503 PreprocessingRecord &PPRec = *PP->getPreprocessingRecord(); 1504 if (PPRec.getPreprocessedEntity(Record[0])) 1505 return; 1506 1507 if (Record[1] > MacroDefinitionsLoaded.size()) { 1508 Error("out-of-bounds macro definition record"); 1509 return; 1510 } 1511 1512 // Decode the identifier info and then check again; if the macro is 1513 // still defined and associated with the identifier, 1514 IdentifierInfo *II = DecodeIdentifierInfo(Record[4]); 1515 if (!MacroDefinitionsLoaded[Record[1] - 1]) { 1516 MacroDefinition *MD 1517 = new (PPRec) MacroDefinition(II, 1518 ReadSourceLocation(F, Record[5]), 1519 SourceRange( 1520 ReadSourceLocation(F, Record[2]), 1521 ReadSourceLocation(F, Record[3]))); 1522 1523 PPRec.SetPreallocatedEntity(Record[0], MD); 1524 MacroDefinitionsLoaded[Record[1] - 1] = MD; 1525 1526 if (DeserializationListener) 1527 DeserializationListener->MacroDefinitionRead(Record[1], MD); 1528 } 1529 1530 return; 1531 } 1532 1533 case PP_INCLUSION_DIRECTIVE: { 1534 // If we already have a macro, that means that we've hit the end 1535 // of the definition of the macro we were looking for. We're 1536 // done. 1537 if (Macro) 1538 return; 1539 1540 if (!PP->getPreprocessingRecord()) { 1541 Error("missing preprocessing record in AST file"); 1542 return; 1543 } 1544 1545 PreprocessingRecord &PPRec = *PP->getPreprocessingRecord(); 1546 if (PPRec.getPreprocessedEntity(Record[0])) 1547 return; 1548 1549 const char *FullFileNameStart = BlobStart + Record[3]; 1550 const FileEntry *File 1551 = PP->getFileManager().getFile(FullFileNameStart, 1552 FullFileNameStart + (BlobLen - Record[3])); 1553 1554 // FIXME: Stable encoding 1555 InclusionDirective::InclusionKind Kind 1556 = static_cast<InclusionDirective::InclusionKind>(Record[5]); 1557 InclusionDirective *ID 1558 = new (PPRec) InclusionDirective(Kind, 1559 llvm::StringRef(BlobStart, Record[3]), 1560 Record[4], 1561 File, 1562 SourceRange(ReadSourceLocation(F, Record[1]), 1563 ReadSourceLocation(F, Record[2]))); 1564 PPRec.SetPreallocatedEntity(Record[0], ID); 1565 return; 1566 } 1567 } 1568 } 1569} 1570 1571void ASTReader::ReadDefinedMacros() { 1572 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 1573 PerFileData &F = *Chain[N - I - 1]; 1574 llvm::BitstreamCursor &MacroCursor = F.MacroCursor; 1575 1576 // If there was no preprocessor block, skip this file. 1577 if (!MacroCursor.getBitStreamReader()) 1578 continue; 1579 1580 llvm::BitstreamCursor Cursor = MacroCursor; 1581 Cursor.JumpToBit(F.MacroStartOffset); 1582 1583 RecordData Record; 1584 while (true) { 1585 uint64_t Offset = Cursor.GetCurrentBitNo(); 1586 unsigned Code = Cursor.ReadCode(); 1587 if (Code == llvm::bitc::END_BLOCK) 1588 break; 1589 1590 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1591 // No known subblocks, always skip them. 1592 Cursor.ReadSubBlockID(); 1593 if (Cursor.SkipBlock()) { 1594 Error("malformed block record in AST file"); 1595 return; 1596 } 1597 continue; 1598 } 1599 1600 if (Code == llvm::bitc::DEFINE_ABBREV) { 1601 Cursor.ReadAbbrevRecord(); 1602 continue; 1603 } 1604 1605 // Read a record. 1606 const char *BlobStart; 1607 unsigned BlobLen; 1608 Record.clear(); 1609 switch (Cursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 1610 default: // Default behavior: ignore. 1611 break; 1612 1613 case PP_MACRO_OBJECT_LIKE: 1614 case PP_MACRO_FUNCTION_LIKE: 1615 DecodeIdentifierInfo(Record[0]); 1616 break; 1617 1618 case PP_TOKEN: 1619 // Ignore tokens. 1620 break; 1621 1622 case PP_MACRO_INSTANTIATION: 1623 case PP_MACRO_DEFINITION: 1624 case PP_INCLUSION_DIRECTIVE: 1625 // Read the macro record. 1626 // FIXME: That's a stupid way to do this. We should reuse this cursor. 1627 ReadMacroRecord(F, Offset); 1628 break; 1629 } 1630 } 1631 } 1632} 1633 1634MacroDefinition *ASTReader::getMacroDefinition(MacroID ID) { 1635 if (ID == 0 || ID > MacroDefinitionsLoaded.size()) 1636 return 0; 1637 1638 if (!MacroDefinitionsLoaded[ID - 1]) { 1639 unsigned Index = ID - 1; 1640 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 1641 PerFileData &F = *Chain[N - I - 1]; 1642 if (Index < F.LocalNumMacroDefinitions) { 1643 ReadMacroRecord(F, F.MacroDefinitionOffsets[Index]); 1644 break; 1645 } 1646 Index -= F.LocalNumMacroDefinitions; 1647 } 1648 assert(MacroDefinitionsLoaded[ID - 1] && "Broken chain"); 1649 } 1650 1651 return MacroDefinitionsLoaded[ID - 1]; 1652} 1653 1654/// \brief If we are loading a relocatable PCH file, and the filename is 1655/// not an absolute path, add the system root to the beginning of the file 1656/// name. 1657void ASTReader::MaybeAddSystemRootToFilename(std::string &Filename) { 1658 // If this is not a relocatable PCH file, there's nothing to do. 1659 if (!RelocatablePCH) 1660 return; 1661 1662 if (Filename.empty() || llvm::sys::Path(Filename).isAbsolute()) 1663 return; 1664 1665 if (isysroot == 0) { 1666 // If no system root was given, default to '/' 1667 Filename.insert(Filename.begin(), '/'); 1668 return; 1669 } 1670 1671 unsigned Length = strlen(isysroot); 1672 if (isysroot[Length - 1] != '/') 1673 Filename.insert(Filename.begin(), '/'); 1674 1675 Filename.insert(Filename.begin(), isysroot, isysroot + Length); 1676} 1677 1678ASTReader::ASTReadResult 1679ASTReader::ReadASTBlock(PerFileData &F) { 1680 llvm::BitstreamCursor &Stream = F.Stream; 1681 1682 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 1683 Error("malformed block record in AST file"); 1684 return Failure; 1685 } 1686 1687 // Read all of the records and blocks for the ASt file. 1688 RecordData Record; 1689 bool First = true; 1690 while (!Stream.AtEndOfStream()) { 1691 unsigned Code = Stream.ReadCode(); 1692 if (Code == llvm::bitc::END_BLOCK) { 1693 if (Stream.ReadBlockEnd()) { 1694 Error("error at end of module block in AST file"); 1695 return Failure; 1696 } 1697 1698 return Success; 1699 } 1700 1701 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1702 switch (Stream.ReadSubBlockID()) { 1703 case DECLTYPES_BLOCK_ID: 1704 // We lazily load the decls block, but we want to set up the 1705 // DeclsCursor cursor to point into it. Clone our current bitcode 1706 // cursor to it, enter the block and read the abbrevs in that block. 1707 // With the main cursor, we just skip over it. 1708 F.DeclsCursor = Stream; 1709 if (Stream.SkipBlock() || // Skip with the main cursor. 1710 // Read the abbrevs. 1711 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) { 1712 Error("malformed block record in AST file"); 1713 return Failure; 1714 } 1715 break; 1716 1717 case DECL_UPDATES_BLOCK_ID: 1718 if (Stream.SkipBlock()) { 1719 Error("malformed block record in AST file"); 1720 return Failure; 1721 } 1722 break; 1723 1724 case PREPROCESSOR_BLOCK_ID: 1725 F.MacroCursor = Stream; 1726 if (PP) 1727 PP->setExternalSource(this); 1728 1729 if (Stream.SkipBlock() || 1730 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) { 1731 Error("malformed block record in AST file"); 1732 return Failure; 1733 } 1734 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo(); 1735 break; 1736 1737 case SOURCE_MANAGER_BLOCK_ID: 1738 switch (ReadSourceManagerBlock(F)) { 1739 case Success: 1740 break; 1741 1742 case Failure: 1743 Error("malformed source manager block in AST file"); 1744 return Failure; 1745 1746 case IgnorePCH: 1747 return IgnorePCH; 1748 } 1749 break; 1750 } 1751 First = false; 1752 continue; 1753 } 1754 1755 if (Code == llvm::bitc::DEFINE_ABBREV) { 1756 Stream.ReadAbbrevRecord(); 1757 continue; 1758 } 1759 1760 // Read and process a record. 1761 Record.clear(); 1762 const char *BlobStart = 0; 1763 unsigned BlobLen = 0; 1764 switch ((ASTRecordTypes)Stream.ReadRecord(Code, Record, 1765 &BlobStart, &BlobLen)) { 1766 default: // Default behavior: ignore. 1767 break; 1768 1769 case METADATA: { 1770 if (Record[0] != VERSION_MAJOR && !DisableValidation) { 1771 Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old 1772 : diag::warn_pch_version_too_new); 1773 return IgnorePCH; 1774 } 1775 1776 RelocatablePCH = Record[4]; 1777 if (Listener) { 1778 std::string TargetTriple(BlobStart, BlobLen); 1779 if (Listener->ReadTargetTriple(TargetTriple)) 1780 return IgnorePCH; 1781 } 1782 break; 1783 } 1784 1785 case CHAINED_METADATA: { 1786 if (!First) { 1787 Error("CHAINED_METADATA is not first record in block"); 1788 return Failure; 1789 } 1790 if (Record[0] != VERSION_MAJOR && !DisableValidation) { 1791 Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old 1792 : diag::warn_pch_version_too_new); 1793 return IgnorePCH; 1794 } 1795 1796 // Load the chained file, which is always a PCH file. 1797 switch(ReadASTCore(llvm::StringRef(BlobStart, BlobLen), PCH)) { 1798 case Failure: return Failure; 1799 // If we have to ignore the dependency, we'll have to ignore this too. 1800 case IgnorePCH: return IgnorePCH; 1801 case Success: break; 1802 } 1803 break; 1804 } 1805 1806 case TYPE_OFFSET: 1807 if (F.LocalNumTypes != 0) { 1808 Error("duplicate TYPE_OFFSET record in AST file"); 1809 return Failure; 1810 } 1811 F.TypeOffsets = (const uint32_t *)BlobStart; 1812 F.LocalNumTypes = Record[0]; 1813 break; 1814 1815 case DECL_OFFSET: 1816 if (F.LocalNumDecls != 0) { 1817 Error("duplicate DECL_OFFSET record in AST file"); 1818 return Failure; 1819 } 1820 F.DeclOffsets = (const uint32_t *)BlobStart; 1821 F.LocalNumDecls = Record[0]; 1822 break; 1823 1824 case TU_UPDATE_LEXICAL: { 1825 DeclContextInfo Info = { 1826 /* No visible information */ 0, 1827 reinterpret_cast<const KindDeclIDPair *>(BlobStart), 1828 BlobLen / sizeof(KindDeclIDPair) 1829 }; 1830 DeclContextOffsets[Context ? Context->getTranslationUnitDecl() : 0] 1831 .push_back(Info); 1832 break; 1833 } 1834 1835 case UPDATE_VISIBLE: { 1836 serialization::DeclID ID = Record[0]; 1837 void *Table = ASTDeclContextNameLookupTable::Create( 1838 (const unsigned char *)BlobStart + Record[1], 1839 (const unsigned char *)BlobStart, 1840 ASTDeclContextNameLookupTrait(*this)); 1841 if (ID == 1 && Context) { // Is it the TU? 1842 DeclContextInfo Info = { 1843 Table, /* No lexical inforamtion */ 0, 0 1844 }; 1845 DeclContextOffsets[Context->getTranslationUnitDecl()].push_back(Info); 1846 } else 1847 PendingVisibleUpdates[ID].push_back(Table); 1848 break; 1849 } 1850 1851 case REDECLS_UPDATE_LATEST: { 1852 assert(Record.size() % 2 == 0 && "Expected pairs of DeclIDs"); 1853 for (unsigned i = 0, e = Record.size(); i < e; i += 2) { 1854 DeclID First = Record[i], Latest = Record[i+1]; 1855 assert((FirstLatestDeclIDs.find(First) == FirstLatestDeclIDs.end() || 1856 Latest > FirstLatestDeclIDs[First]) && 1857 "The new latest is supposed to come after the previous latest"); 1858 FirstLatestDeclIDs[First] = Latest; 1859 } 1860 break; 1861 } 1862 1863 case LANGUAGE_OPTIONS: 1864 if (ParseLanguageOptions(Record) && !DisableValidation) 1865 return IgnorePCH; 1866 break; 1867 1868 case IDENTIFIER_TABLE: 1869 F.IdentifierTableData = BlobStart; 1870 if (Record[0]) { 1871 F.IdentifierLookupTable 1872 = ASTIdentifierLookupTable::Create( 1873 (const unsigned char *)F.IdentifierTableData + Record[0], 1874 (const unsigned char *)F.IdentifierTableData, 1875 ASTIdentifierLookupTrait(*this, F)); 1876 if (PP) 1877 PP->getIdentifierTable().setExternalIdentifierLookup(this); 1878 } 1879 break; 1880 1881 case IDENTIFIER_OFFSET: 1882 if (F.LocalNumIdentifiers != 0) { 1883 Error("duplicate IDENTIFIER_OFFSET record in AST file"); 1884 return Failure; 1885 } 1886 F.IdentifierOffsets = (const uint32_t *)BlobStart; 1887 F.LocalNumIdentifiers = Record[0]; 1888 break; 1889 1890 case EXTERNAL_DEFINITIONS: 1891 // Optimization for the first block. 1892 if (ExternalDefinitions.empty()) 1893 ExternalDefinitions.swap(Record); 1894 else 1895 ExternalDefinitions.insert(ExternalDefinitions.end(), 1896 Record.begin(), Record.end()); 1897 break; 1898 1899 case SPECIAL_TYPES: 1900 // Optimization for the first block 1901 if (SpecialTypes.empty()) 1902 SpecialTypes.swap(Record); 1903 else 1904 SpecialTypes.insert(SpecialTypes.end(), Record.begin(), Record.end()); 1905 break; 1906 1907 case STATISTICS: 1908 TotalNumStatements += Record[0]; 1909 TotalNumMacros += Record[1]; 1910 TotalLexicalDeclContexts += Record[2]; 1911 TotalVisibleDeclContexts += Record[3]; 1912 break; 1913 1914 case TENTATIVE_DEFINITIONS: 1915 // Optimization for the first block. 1916 if (TentativeDefinitions.empty()) 1917 TentativeDefinitions.swap(Record); 1918 else 1919 TentativeDefinitions.insert(TentativeDefinitions.end(), 1920 Record.begin(), Record.end()); 1921 break; 1922 1923 case UNUSED_FILESCOPED_DECLS: 1924 // Optimization for the first block. 1925 if (UnusedFileScopedDecls.empty()) 1926 UnusedFileScopedDecls.swap(Record); 1927 else 1928 UnusedFileScopedDecls.insert(UnusedFileScopedDecls.end(), 1929 Record.begin(), Record.end()); 1930 break; 1931 1932 case WEAK_UNDECLARED_IDENTIFIERS: 1933 // Later blocks overwrite earlier ones. 1934 WeakUndeclaredIdentifiers.swap(Record); 1935 break; 1936 1937 case LOCALLY_SCOPED_EXTERNAL_DECLS: 1938 // Optimization for the first block. 1939 if (LocallyScopedExternalDecls.empty()) 1940 LocallyScopedExternalDecls.swap(Record); 1941 else 1942 LocallyScopedExternalDecls.insert(LocallyScopedExternalDecls.end(), 1943 Record.begin(), Record.end()); 1944 break; 1945 1946 case SELECTOR_OFFSETS: 1947 F.SelectorOffsets = (const uint32_t *)BlobStart; 1948 F.LocalNumSelectors = Record[0]; 1949 break; 1950 1951 case METHOD_POOL: 1952 F.SelectorLookupTableData = (const unsigned char *)BlobStart; 1953 if (Record[0]) 1954 F.SelectorLookupTable 1955 = ASTSelectorLookupTable::Create( 1956 F.SelectorLookupTableData + Record[0], 1957 F.SelectorLookupTableData, 1958 ASTSelectorLookupTrait(*this)); 1959 TotalNumMethodPoolEntries += Record[1]; 1960 break; 1961 1962 case REFERENCED_SELECTOR_POOL: 1963 F.ReferencedSelectorsData.swap(Record); 1964 break; 1965 1966 case PP_COUNTER_VALUE: 1967 if (!Record.empty() && Listener) 1968 Listener->ReadCounter(Record[0]); 1969 break; 1970 1971 case SOURCE_LOCATION_OFFSETS: 1972 F.SLocOffsets = (const uint32_t *)BlobStart; 1973 F.LocalNumSLocEntries = Record[0]; 1974 F.LocalSLocSize = Record[1]; 1975 break; 1976 1977 case SOURCE_LOCATION_PRELOADS: 1978 if (PreloadSLocEntries.empty()) 1979 PreloadSLocEntries.swap(Record); 1980 else 1981 PreloadSLocEntries.insert(PreloadSLocEntries.end(), 1982 Record.begin(), Record.end()); 1983 break; 1984 1985 case STAT_CACHE: { 1986 ASTStatCache *MyStatCache = 1987 new ASTStatCache((const unsigned char *)BlobStart + Record[0], 1988 (const unsigned char *)BlobStart, 1989 NumStatHits, NumStatMisses); 1990 FileMgr.addStatCache(MyStatCache); 1991 F.StatCache = MyStatCache; 1992 break; 1993 } 1994 1995 case EXT_VECTOR_DECLS: 1996 // Optimization for the first block. 1997 if (ExtVectorDecls.empty()) 1998 ExtVectorDecls.swap(Record); 1999 else 2000 ExtVectorDecls.insert(ExtVectorDecls.end(), 2001 Record.begin(), Record.end()); 2002 break; 2003 2004 case VTABLE_USES: 2005 // Later tables overwrite earlier ones. 2006 VTableUses.swap(Record); 2007 break; 2008 2009 case DYNAMIC_CLASSES: 2010 // Optimization for the first block. 2011 if (DynamicClasses.empty()) 2012 DynamicClasses.swap(Record); 2013 else 2014 DynamicClasses.insert(DynamicClasses.end(), 2015 Record.begin(), Record.end()); 2016 break; 2017 2018 case PENDING_IMPLICIT_INSTANTIATIONS: 2019 F.PendingInstantiations.swap(Record); 2020 break; 2021 2022 case SEMA_DECL_REFS: 2023 // Later tables overwrite earlier ones. 2024 SemaDeclRefs.swap(Record); 2025 break; 2026 2027 case ORIGINAL_FILE_NAME: 2028 // The primary AST will be the last to get here, so it will be the one 2029 // that's used. 2030 ActualOriginalFileName.assign(BlobStart, BlobLen); 2031 OriginalFileName = ActualOriginalFileName; 2032 MaybeAddSystemRootToFilename(OriginalFileName); 2033 break; 2034 2035 case VERSION_CONTROL_BRANCH_REVISION: { 2036 const std::string &CurBranch = getClangFullRepositoryVersion(); 2037 llvm::StringRef ASTBranch(BlobStart, BlobLen); 2038 if (llvm::StringRef(CurBranch) != ASTBranch && !DisableValidation) { 2039 Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch; 2040 return IgnorePCH; 2041 } 2042 break; 2043 } 2044 2045 case MACRO_DEFINITION_OFFSETS: 2046 F.MacroDefinitionOffsets = (const uint32_t *)BlobStart; 2047 F.NumPreallocatedPreprocessingEntities = Record[0]; 2048 F.LocalNumMacroDefinitions = Record[1]; 2049 break; 2050 2051 case DECL_UPDATE_OFFSETS: { 2052 if (Record.size() % 2 != 0) { 2053 Error("invalid DECL_UPDATE_OFFSETS block in AST file"); 2054 return Failure; 2055 } 2056 for (unsigned I = 0, N = Record.size(); I != N; I += 2) 2057 DeclUpdateOffsets[static_cast<DeclID>(Record[I])] 2058 .push_back(std::make_pair(&F, Record[I+1])); 2059 break; 2060 } 2061 2062 case DECL_REPLACEMENTS: { 2063 if (Record.size() % 2 != 0) { 2064 Error("invalid DECL_REPLACEMENTS block in AST file"); 2065 return Failure; 2066 } 2067 for (unsigned I = 0, N = Record.size(); I != N; I += 2) 2068 ReplacedDecls[static_cast<DeclID>(Record[I])] = 2069 std::make_pair(&F, Record[I+1]); 2070 break; 2071 } 2072 2073 case CXX_BASE_SPECIFIER_OFFSETS: { 2074 if (F.LocalNumCXXBaseSpecifiers != 0) { 2075 Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file"); 2076 return Failure; 2077 } 2078 2079 F.LocalNumCXXBaseSpecifiers = Record[0]; 2080 F.CXXBaseSpecifiersOffsets = (const uint32_t *)BlobStart; 2081 break; 2082 } 2083 } 2084 First = false; 2085 } 2086 Error("premature end of bitstream in AST file"); 2087 return Failure; 2088} 2089 2090ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName, 2091 ASTFileType Type) { 2092 switch(ReadASTCore(FileName, Type)) { 2093 case Failure: return Failure; 2094 case IgnorePCH: return IgnorePCH; 2095 case Success: break; 2096 } 2097 2098 // Here comes stuff that we only do once the entire chain is loaded. 2099 2100 // Allocate space for loaded slocentries, identifiers, decls and types. 2101 unsigned TotalNumIdentifiers = 0, TotalNumTypes = 0, TotalNumDecls = 0, 2102 TotalNumPreallocatedPreprocessingEntities = 0, TotalNumMacroDefs = 0, 2103 TotalNumSelectors = 0; 2104 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 2105 TotalNumSLocEntries += Chain[I]->LocalNumSLocEntries; 2106 NextSLocOffset += Chain[I]->LocalSLocSize; 2107 TotalNumIdentifiers += Chain[I]->LocalNumIdentifiers; 2108 TotalNumTypes += Chain[I]->LocalNumTypes; 2109 TotalNumDecls += Chain[I]->LocalNumDecls; 2110 TotalNumPreallocatedPreprocessingEntities += 2111 Chain[I]->NumPreallocatedPreprocessingEntities; 2112 TotalNumMacroDefs += Chain[I]->LocalNumMacroDefinitions; 2113 TotalNumSelectors += Chain[I]->LocalNumSelectors; 2114 } 2115 SourceMgr.PreallocateSLocEntries(this, TotalNumSLocEntries, NextSLocOffset); 2116 IdentifiersLoaded.resize(TotalNumIdentifiers); 2117 TypesLoaded.resize(TotalNumTypes); 2118 DeclsLoaded.resize(TotalNumDecls); 2119 MacroDefinitionsLoaded.resize(TotalNumMacroDefs); 2120 if (PP) { 2121 if (TotalNumIdentifiers > 0) 2122 PP->getHeaderSearchInfo().SetExternalLookup(this); 2123 if (TotalNumPreallocatedPreprocessingEntities > 0) { 2124 if (!PP->getPreprocessingRecord()) 2125 PP->createPreprocessingRecord(); 2126 PP->getPreprocessingRecord()->SetExternalSource(*this, 2127 TotalNumPreallocatedPreprocessingEntities); 2128 } 2129 } 2130 SelectorsLoaded.resize(TotalNumSelectors); 2131 // Preload SLocEntries. 2132 for (unsigned I = 0, N = PreloadSLocEntries.size(); I != N; ++I) { 2133 ASTReadResult Result = ReadSLocEntryRecord(PreloadSLocEntries[I]); 2134 if (Result != Success) 2135 return Result; 2136 } 2137 2138 // Check the predefines buffers. 2139 if (!DisableValidation && CheckPredefinesBuffers()) 2140 return IgnorePCH; 2141 2142 if (PP) { 2143 // Initialization of keywords and pragmas occurs before the 2144 // AST file is read, so there may be some identifiers that were 2145 // loaded into the IdentifierTable before we intercepted the 2146 // creation of identifiers. Iterate through the list of known 2147 // identifiers and determine whether we have to establish 2148 // preprocessor definitions or top-level identifier declaration 2149 // chains for those identifiers. 2150 // 2151 // We copy the IdentifierInfo pointers to a small vector first, 2152 // since de-serializing declarations or macro definitions can add 2153 // new entries into the identifier table, invalidating the 2154 // iterators. 2155 llvm::SmallVector<IdentifierInfo *, 128> Identifiers; 2156 for (IdentifierTable::iterator Id = PP->getIdentifierTable().begin(), 2157 IdEnd = PP->getIdentifierTable().end(); 2158 Id != IdEnd; ++Id) 2159 Identifiers.push_back(Id->second); 2160 // We need to search the tables in all files. 2161 for (unsigned J = 0, M = Chain.size(); J != M; ++J) { 2162 ASTIdentifierLookupTable *IdTable 2163 = (ASTIdentifierLookupTable *)Chain[J]->IdentifierLookupTable; 2164 // Not all AST files necessarily have identifier tables, only the useful 2165 // ones. 2166 if (!IdTable) 2167 continue; 2168 for (unsigned I = 0, N = Identifiers.size(); I != N; ++I) { 2169 IdentifierInfo *II = Identifiers[I]; 2170 // Look in the on-disk hash tables for an entry for this identifier 2171 ASTIdentifierLookupTrait Info(*this, *Chain[J], II); 2172 std::pair<const char*,unsigned> Key(II->getNameStart(),II->getLength()); 2173 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key, &Info); 2174 if (Pos == IdTable->end()) 2175 continue; 2176 2177 // Dereferencing the iterator has the effect of populating the 2178 // IdentifierInfo node with the various declarations it needs. 2179 (void)*Pos; 2180 } 2181 } 2182 } 2183 2184 if (Context) 2185 InitializeContext(*Context); 2186 2187 if (DeserializationListener) 2188 DeserializationListener->ReaderInitialized(this); 2189 2190 return Success; 2191} 2192 2193ASTReader::ASTReadResult ASTReader::ReadASTCore(llvm::StringRef FileName, 2194 ASTFileType Type) { 2195 PerFileData *Prev = Chain.empty() ? 0 : Chain.back(); 2196 Chain.push_back(new PerFileData(Type)); 2197 PerFileData &F = *Chain.back(); 2198 if (Prev) 2199 Prev->NextInSource = &F; 2200 else 2201 FirstInSource = &F; 2202 F.Loaders.push_back(Prev); 2203 2204 // Set the AST file name. 2205 F.FileName = FileName; 2206 2207 // Open the AST file. 2208 // 2209 // FIXME: This shouldn't be here, we should just take a raw_ostream. 2210 std::string ErrStr; 2211 F.Buffer.reset(llvm::MemoryBuffer::getFileOrSTDIN(FileName, &ErrStr)); 2212 if (!F.Buffer) { 2213 Error(ErrStr.c_str()); 2214 return IgnorePCH; 2215 } 2216 2217 // Initialize the stream 2218 F.StreamFile.init((const unsigned char *)F.Buffer->getBufferStart(), 2219 (const unsigned char *)F.Buffer->getBufferEnd()); 2220 llvm::BitstreamCursor &Stream = F.Stream; 2221 Stream.init(F.StreamFile); 2222 F.SizeInBits = F.Buffer->getBufferSize() * 8; 2223 2224 // Sniff for the signature. 2225 if (Stream.Read(8) != 'C' || 2226 Stream.Read(8) != 'P' || 2227 Stream.Read(8) != 'C' || 2228 Stream.Read(8) != 'H') { 2229 Diag(diag::err_not_a_pch_file) << FileName; 2230 return Failure; 2231 } 2232 2233 while (!Stream.AtEndOfStream()) { 2234 unsigned Code = Stream.ReadCode(); 2235 2236 if (Code != llvm::bitc::ENTER_SUBBLOCK) { 2237 Error("invalid record at top-level of AST file"); 2238 return Failure; 2239 } 2240 2241 unsigned BlockID = Stream.ReadSubBlockID(); 2242 2243 // We only know the AST subblock ID. 2244 switch (BlockID) { 2245 case llvm::bitc::BLOCKINFO_BLOCK_ID: 2246 if (Stream.ReadBlockInfoBlock()) { 2247 Error("malformed BlockInfoBlock in AST file"); 2248 return Failure; 2249 } 2250 break; 2251 case AST_BLOCK_ID: 2252 switch (ReadASTBlock(F)) { 2253 case Success: 2254 break; 2255 2256 case Failure: 2257 return Failure; 2258 2259 case IgnorePCH: 2260 // FIXME: We could consider reading through to the end of this 2261 // AST block, skipping subblocks, to see if there are other 2262 // AST blocks elsewhere. 2263 2264 // Clear out any preallocated source location entries, so that 2265 // the source manager does not try to resolve them later. 2266 SourceMgr.ClearPreallocatedSLocEntries(); 2267 2268 // Remove the stat cache. 2269 if (F.StatCache) 2270 FileMgr.removeStatCache((ASTStatCache*)F.StatCache); 2271 2272 return IgnorePCH; 2273 } 2274 break; 2275 default: 2276 if (Stream.SkipBlock()) { 2277 Error("malformed block record in AST file"); 2278 return Failure; 2279 } 2280 break; 2281 } 2282 } 2283 2284 return Success; 2285} 2286 2287void ASTReader::setPreprocessor(Preprocessor &pp) { 2288 PP = &pp; 2289 2290 unsigned TotalNum = 0; 2291 for (unsigned I = 0, N = Chain.size(); I != N; ++I) 2292 TotalNum += Chain[I]->NumPreallocatedPreprocessingEntities; 2293 if (TotalNum) { 2294 if (!PP->getPreprocessingRecord()) 2295 PP->createPreprocessingRecord(); 2296 PP->getPreprocessingRecord()->SetExternalSource(*this, TotalNum); 2297 } 2298} 2299 2300void ASTReader::InitializeContext(ASTContext &Ctx) { 2301 Context = &Ctx; 2302 assert(Context && "Passed null context!"); 2303 2304 assert(PP && "Forgot to set Preprocessor ?"); 2305 PP->getIdentifierTable().setExternalIdentifierLookup(this); 2306 PP->getHeaderSearchInfo().SetExternalLookup(this); 2307 PP->setExternalSource(this); 2308 2309 // If we have an update block for the TU waiting, we have to add it before 2310 // deserializing the decl. 2311 DeclContextOffsetsMap::iterator DCU = DeclContextOffsets.find(0); 2312 if (DCU != DeclContextOffsets.end()) { 2313 // Insertion could invalidate map, so grab vector. 2314 DeclContextInfos T; 2315 T.swap(DCU->second); 2316 DeclContextOffsets.erase(DCU); 2317 DeclContextOffsets[Ctx.getTranslationUnitDecl()].swap(T); 2318 } 2319 2320 // Load the translation unit declaration 2321 GetTranslationUnitDecl(); 2322 2323 // Load the special types. 2324 Context->setBuiltinVaListType( 2325 GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST])); 2326 if (unsigned Id = SpecialTypes[SPECIAL_TYPE_OBJC_ID]) 2327 Context->setObjCIdType(GetType(Id)); 2328 if (unsigned Sel = SpecialTypes[SPECIAL_TYPE_OBJC_SELECTOR]) 2329 Context->setObjCSelType(GetType(Sel)); 2330 if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL]) 2331 Context->setObjCProtoType(GetType(Proto)); 2332 if (unsigned Class = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS]) 2333 Context->setObjCClassType(GetType(Class)); 2334 2335 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) 2336 Context->setCFConstantStringType(GetType(String)); 2337 if (unsigned FastEnum 2338 = SpecialTypes[SPECIAL_TYPE_OBJC_FAST_ENUMERATION_STATE]) 2339 Context->setObjCFastEnumerationStateType(GetType(FastEnum)); 2340 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) { 2341 QualType FileType = GetType(File); 2342 if (FileType.isNull()) { 2343 Error("FILE type is NULL"); 2344 return; 2345 } 2346 if (const TypedefType *Typedef = FileType->getAs<TypedefType>()) 2347 Context->setFILEDecl(Typedef->getDecl()); 2348 else { 2349 const TagType *Tag = FileType->getAs<TagType>(); 2350 if (!Tag) { 2351 Error("Invalid FILE type in AST file"); 2352 return; 2353 } 2354 Context->setFILEDecl(Tag->getDecl()); 2355 } 2356 } 2357 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) { 2358 QualType Jmp_bufType = GetType(Jmp_buf); 2359 if (Jmp_bufType.isNull()) { 2360 Error("jmp_bug type is NULL"); 2361 return; 2362 } 2363 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>()) 2364 Context->setjmp_bufDecl(Typedef->getDecl()); 2365 else { 2366 const TagType *Tag = Jmp_bufType->getAs<TagType>(); 2367 if (!Tag) { 2368 Error("Invalid jmp_buf type in AST file"); 2369 return; 2370 } 2371 Context->setjmp_bufDecl(Tag->getDecl()); 2372 } 2373 } 2374 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) { 2375 QualType Sigjmp_bufType = GetType(Sigjmp_buf); 2376 if (Sigjmp_bufType.isNull()) { 2377 Error("sigjmp_buf type is NULL"); 2378 return; 2379 } 2380 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>()) 2381 Context->setsigjmp_bufDecl(Typedef->getDecl()); 2382 else { 2383 const TagType *Tag = Sigjmp_bufType->getAs<TagType>(); 2384 assert(Tag && "Invalid sigjmp_buf type in AST file"); 2385 Context->setsigjmp_bufDecl(Tag->getDecl()); 2386 } 2387 } 2388 if (unsigned ObjCIdRedef 2389 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) 2390 Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef); 2391 if (unsigned ObjCClassRedef 2392 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) 2393 Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef); 2394 if (unsigned String = SpecialTypes[SPECIAL_TYPE_BLOCK_DESCRIPTOR]) 2395 Context->setBlockDescriptorType(GetType(String)); 2396 if (unsigned String 2397 = SpecialTypes[SPECIAL_TYPE_BLOCK_EXTENDED_DESCRIPTOR]) 2398 Context->setBlockDescriptorExtendedType(GetType(String)); 2399 if (unsigned ObjCSelRedef 2400 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) 2401 Context->ObjCSelRedefinitionType = GetType(ObjCSelRedef); 2402 if (unsigned String = SpecialTypes[SPECIAL_TYPE_NS_CONSTANT_STRING]) 2403 Context->setNSConstantStringType(GetType(String)); 2404 2405 if (SpecialTypes[SPECIAL_TYPE_INT128_INSTALLED]) 2406 Context->setInt128Installed(); 2407} 2408 2409/// \brief Retrieve the name of the original source file name 2410/// directly from the AST file, without actually loading the AST 2411/// file. 2412std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, 2413 Diagnostic &Diags) { 2414 // Open the AST file. 2415 std::string ErrStr; 2416 llvm::OwningPtr<llvm::MemoryBuffer> Buffer; 2417 Buffer.reset(llvm::MemoryBuffer::getFile(ASTFileName.c_str(), &ErrStr)); 2418 if (!Buffer) { 2419 Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr; 2420 return std::string(); 2421 } 2422 2423 // Initialize the stream 2424 llvm::BitstreamReader StreamFile; 2425 llvm::BitstreamCursor Stream; 2426 StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 2427 (const unsigned char *)Buffer->getBufferEnd()); 2428 Stream.init(StreamFile); 2429 2430 // Sniff for the signature. 2431 if (Stream.Read(8) != 'C' || 2432 Stream.Read(8) != 'P' || 2433 Stream.Read(8) != 'C' || 2434 Stream.Read(8) != 'H') { 2435 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName; 2436 return std::string(); 2437 } 2438 2439 RecordData Record; 2440 while (!Stream.AtEndOfStream()) { 2441 unsigned Code = Stream.ReadCode(); 2442 2443 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 2444 unsigned BlockID = Stream.ReadSubBlockID(); 2445 2446 // We only know the AST subblock ID. 2447 switch (BlockID) { 2448 case AST_BLOCK_ID: 2449 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 2450 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 2451 return std::string(); 2452 } 2453 break; 2454 2455 default: 2456 if (Stream.SkipBlock()) { 2457 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 2458 return std::string(); 2459 } 2460 break; 2461 } 2462 continue; 2463 } 2464 2465 if (Code == llvm::bitc::END_BLOCK) { 2466 if (Stream.ReadBlockEnd()) { 2467 Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName; 2468 return std::string(); 2469 } 2470 continue; 2471 } 2472 2473 if (Code == llvm::bitc::DEFINE_ABBREV) { 2474 Stream.ReadAbbrevRecord(); 2475 continue; 2476 } 2477 2478 Record.clear(); 2479 const char *BlobStart = 0; 2480 unsigned BlobLen = 0; 2481 if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen) 2482 == ORIGINAL_FILE_NAME) 2483 return std::string(BlobStart, BlobLen); 2484 } 2485 2486 return std::string(); 2487} 2488 2489/// \brief Parse the record that corresponds to a LangOptions data 2490/// structure. 2491/// 2492/// This routine parses the language options from the AST file and then gives 2493/// them to the AST listener if one is set. 2494/// 2495/// \returns true if the listener deems the file unacceptable, false otherwise. 2496bool ASTReader::ParseLanguageOptions( 2497 const llvm::SmallVectorImpl<uint64_t> &Record) { 2498 if (Listener) { 2499 LangOptions LangOpts; 2500 2501 #define PARSE_LANGOPT(Option) \ 2502 LangOpts.Option = Record[Idx]; \ 2503 ++Idx 2504 2505 unsigned Idx = 0; 2506 PARSE_LANGOPT(Trigraphs); 2507 PARSE_LANGOPT(BCPLComment); 2508 PARSE_LANGOPT(DollarIdents); 2509 PARSE_LANGOPT(AsmPreprocessor); 2510 PARSE_LANGOPT(GNUMode); 2511 PARSE_LANGOPT(GNUKeywords); 2512 PARSE_LANGOPT(ImplicitInt); 2513 PARSE_LANGOPT(Digraphs); 2514 PARSE_LANGOPT(HexFloats); 2515 PARSE_LANGOPT(C99); 2516 PARSE_LANGOPT(Microsoft); 2517 PARSE_LANGOPT(CPlusPlus); 2518 PARSE_LANGOPT(CPlusPlus0x); 2519 PARSE_LANGOPT(CXXOperatorNames); 2520 PARSE_LANGOPT(ObjC1); 2521 PARSE_LANGOPT(ObjC2); 2522 PARSE_LANGOPT(ObjCNonFragileABI); 2523 PARSE_LANGOPT(ObjCNonFragileABI2); 2524 PARSE_LANGOPT(NoConstantCFStrings); 2525 PARSE_LANGOPT(PascalStrings); 2526 PARSE_LANGOPT(WritableStrings); 2527 PARSE_LANGOPT(LaxVectorConversions); 2528 PARSE_LANGOPT(AltiVec); 2529 PARSE_LANGOPT(Exceptions); 2530 PARSE_LANGOPT(SjLjExceptions); 2531 PARSE_LANGOPT(NeXTRuntime); 2532 PARSE_LANGOPT(Freestanding); 2533 PARSE_LANGOPT(NoBuiltin); 2534 PARSE_LANGOPT(ThreadsafeStatics); 2535 PARSE_LANGOPT(POSIXThreads); 2536 PARSE_LANGOPT(Blocks); 2537 PARSE_LANGOPT(EmitAllDecls); 2538 PARSE_LANGOPT(MathErrno); 2539 LangOpts.setSignedOverflowBehavior((LangOptions::SignedOverflowBehaviorTy) 2540 Record[Idx++]); 2541 PARSE_LANGOPT(HeinousExtensions); 2542 PARSE_LANGOPT(Optimize); 2543 PARSE_LANGOPT(OptimizeSize); 2544 PARSE_LANGOPT(Static); 2545 PARSE_LANGOPT(PICLevel); 2546 PARSE_LANGOPT(GNUInline); 2547 PARSE_LANGOPT(NoInline); 2548 PARSE_LANGOPT(AccessControl); 2549 PARSE_LANGOPT(CharIsSigned); 2550 PARSE_LANGOPT(ShortWChar); 2551 LangOpts.setGCMode((LangOptions::GCMode)Record[Idx++]); 2552 LangOpts.setVisibilityMode((Visibility)Record[Idx++]); 2553 LangOpts.setStackProtectorMode((LangOptions::StackProtectorMode) 2554 Record[Idx++]); 2555 PARSE_LANGOPT(InstantiationDepth); 2556 PARSE_LANGOPT(OpenCL); 2557 PARSE_LANGOPT(CatchUndefined); 2558 // FIXME: Missing ElideConstructors?! 2559 #undef PARSE_LANGOPT 2560 2561 return Listener->ReadLanguageOptions(LangOpts); 2562 } 2563 2564 return false; 2565} 2566 2567void ASTReader::ReadPreprocessedEntities() { 2568 ReadDefinedMacros(); 2569} 2570 2571/// \brief Get the correct cursor and offset for loading a type. 2572ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) { 2573 PerFileData *F = 0; 2574 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 2575 F = Chain[N - I - 1]; 2576 if (Index < F->LocalNumTypes) 2577 break; 2578 Index -= F->LocalNumTypes; 2579 } 2580 assert(F && F->LocalNumTypes > Index && "Broken chain"); 2581 return RecordLocation(F, F->TypeOffsets[Index]); 2582} 2583 2584/// \brief Read and return the type with the given index.. 2585/// 2586/// The index is the type ID, shifted and minus the number of predefs. This 2587/// routine actually reads the record corresponding to the type at the given 2588/// location. It is a helper routine for GetType, which deals with reading type 2589/// IDs. 2590QualType ASTReader::ReadTypeRecord(unsigned Index) { 2591 RecordLocation Loc = TypeCursorForIndex(Index); 2592 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor; 2593 2594 // Keep track of where we are in the stream, then jump back there 2595 // after reading this type. 2596 SavedStreamPosition SavedPosition(DeclsCursor); 2597 2598 ReadingKindTracker ReadingKind(Read_Type, *this); 2599 2600 // Note that we are loading a type record. 2601 Deserializing AType(this); 2602 2603 DeclsCursor.JumpToBit(Loc.Offset); 2604 RecordData Record; 2605 unsigned Code = DeclsCursor.ReadCode(); 2606 switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) { 2607 case TYPE_EXT_QUAL: { 2608 if (Record.size() != 2) { 2609 Error("Incorrect encoding of extended qualifier type"); 2610 return QualType(); 2611 } 2612 QualType Base = GetType(Record[0]); 2613 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[1]); 2614 return Context->getQualifiedType(Base, Quals); 2615 } 2616 2617 case TYPE_COMPLEX: { 2618 if (Record.size() != 1) { 2619 Error("Incorrect encoding of complex type"); 2620 return QualType(); 2621 } 2622 QualType ElemType = GetType(Record[0]); 2623 return Context->getComplexType(ElemType); 2624 } 2625 2626 case TYPE_POINTER: { 2627 if (Record.size() != 1) { 2628 Error("Incorrect encoding of pointer type"); 2629 return QualType(); 2630 } 2631 QualType PointeeType = GetType(Record[0]); 2632 return Context->getPointerType(PointeeType); 2633 } 2634 2635 case TYPE_BLOCK_POINTER: { 2636 if (Record.size() != 1) { 2637 Error("Incorrect encoding of block pointer type"); 2638 return QualType(); 2639 } 2640 QualType PointeeType = GetType(Record[0]); 2641 return Context->getBlockPointerType(PointeeType); 2642 } 2643 2644 case TYPE_LVALUE_REFERENCE: { 2645 if (Record.size() != 1) { 2646 Error("Incorrect encoding of lvalue reference type"); 2647 return QualType(); 2648 } 2649 QualType PointeeType = GetType(Record[0]); 2650 return Context->getLValueReferenceType(PointeeType); 2651 } 2652 2653 case TYPE_RVALUE_REFERENCE: { 2654 if (Record.size() != 1) { 2655 Error("Incorrect encoding of rvalue reference type"); 2656 return QualType(); 2657 } 2658 QualType PointeeType = GetType(Record[0]); 2659 return Context->getRValueReferenceType(PointeeType); 2660 } 2661 2662 case TYPE_MEMBER_POINTER: { 2663 if (Record.size() != 2) { 2664 Error("Incorrect encoding of member pointer type"); 2665 return QualType(); 2666 } 2667 QualType PointeeType = GetType(Record[0]); 2668 QualType ClassType = GetType(Record[1]); 2669 return Context->getMemberPointerType(PointeeType, ClassType.getTypePtr()); 2670 } 2671 2672 case TYPE_CONSTANT_ARRAY: { 2673 QualType ElementType = GetType(Record[0]); 2674 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 2675 unsigned IndexTypeQuals = Record[2]; 2676 unsigned Idx = 3; 2677 llvm::APInt Size = ReadAPInt(Record, Idx); 2678 return Context->getConstantArrayType(ElementType, Size, 2679 ASM, IndexTypeQuals); 2680 } 2681 2682 case TYPE_INCOMPLETE_ARRAY: { 2683 QualType ElementType = GetType(Record[0]); 2684 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 2685 unsigned IndexTypeQuals = Record[2]; 2686 return Context->getIncompleteArrayType(ElementType, ASM, IndexTypeQuals); 2687 } 2688 2689 case TYPE_VARIABLE_ARRAY: { 2690 QualType ElementType = GetType(Record[0]); 2691 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 2692 unsigned IndexTypeQuals = Record[2]; 2693 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]); 2694 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]); 2695 return Context->getVariableArrayType(ElementType, ReadExpr(*Loc.F), 2696 ASM, IndexTypeQuals, 2697 SourceRange(LBLoc, RBLoc)); 2698 } 2699 2700 case TYPE_VECTOR: { 2701 if (Record.size() != 3) { 2702 Error("incorrect encoding of vector type in AST file"); 2703 return QualType(); 2704 } 2705 2706 QualType ElementType = GetType(Record[0]); 2707 unsigned NumElements = Record[1]; 2708 unsigned AltiVecSpec = Record[2]; 2709 return Context->getVectorType(ElementType, NumElements, 2710 (VectorType::AltiVecSpecific)AltiVecSpec); 2711 } 2712 2713 case TYPE_EXT_VECTOR: { 2714 if (Record.size() != 3) { 2715 Error("incorrect encoding of extended vector type in AST file"); 2716 return QualType(); 2717 } 2718 2719 QualType ElementType = GetType(Record[0]); 2720 unsigned NumElements = Record[1]; 2721 return Context->getExtVectorType(ElementType, NumElements); 2722 } 2723 2724 case TYPE_FUNCTION_NO_PROTO: { 2725 if (Record.size() != 4) { 2726 Error("incorrect encoding of no-proto function type"); 2727 return QualType(); 2728 } 2729 QualType ResultType = GetType(Record[0]); 2730 FunctionType::ExtInfo Info(Record[1], Record[2], (CallingConv)Record[3]); 2731 return Context->getFunctionNoProtoType(ResultType, Info); 2732 } 2733 2734 case TYPE_FUNCTION_PROTO: { 2735 QualType ResultType = GetType(Record[0]); 2736 bool NoReturn = Record[1]; 2737 unsigned RegParm = Record[2]; 2738 CallingConv CallConv = (CallingConv)Record[3]; 2739 unsigned Idx = 4; 2740 unsigned NumParams = Record[Idx++]; 2741 llvm::SmallVector<QualType, 16> ParamTypes; 2742 for (unsigned I = 0; I != NumParams; ++I) 2743 ParamTypes.push_back(GetType(Record[Idx++])); 2744 bool isVariadic = Record[Idx++]; 2745 unsigned Quals = Record[Idx++]; 2746 bool hasExceptionSpec = Record[Idx++]; 2747 bool hasAnyExceptionSpec = Record[Idx++]; 2748 unsigned NumExceptions = Record[Idx++]; 2749 llvm::SmallVector<QualType, 2> Exceptions; 2750 for (unsigned I = 0; I != NumExceptions; ++I) 2751 Exceptions.push_back(GetType(Record[Idx++])); 2752 return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams, 2753 isVariadic, Quals, hasExceptionSpec, 2754 hasAnyExceptionSpec, NumExceptions, 2755 Exceptions.data(), 2756 FunctionType::ExtInfo(NoReturn, RegParm, 2757 CallConv)); 2758 } 2759 2760 case TYPE_UNRESOLVED_USING: 2761 return Context->getTypeDeclType( 2762 cast<UnresolvedUsingTypenameDecl>(GetDecl(Record[0]))); 2763 2764 case TYPE_TYPEDEF: { 2765 if (Record.size() != 2) { 2766 Error("incorrect encoding of typedef type"); 2767 return QualType(); 2768 } 2769 TypedefDecl *Decl = cast<TypedefDecl>(GetDecl(Record[0])); 2770 QualType Canonical = GetType(Record[1]); 2771 if (!Canonical.isNull()) 2772 Canonical = Context->getCanonicalType(Canonical); 2773 return Context->getTypedefType(Decl, Canonical); 2774 } 2775 2776 case TYPE_TYPEOF_EXPR: 2777 return Context->getTypeOfExprType(ReadExpr(*Loc.F)); 2778 2779 case TYPE_TYPEOF: { 2780 if (Record.size() != 1) { 2781 Error("incorrect encoding of typeof(type) in AST file"); 2782 return QualType(); 2783 } 2784 QualType UnderlyingType = GetType(Record[0]); 2785 return Context->getTypeOfType(UnderlyingType); 2786 } 2787 2788 case TYPE_DECLTYPE: 2789 return Context->getDecltypeType(ReadExpr(*Loc.F)); 2790 2791 case TYPE_RECORD: { 2792 if (Record.size() != 2) { 2793 Error("incorrect encoding of record type"); 2794 return QualType(); 2795 } 2796 bool IsDependent = Record[0]; 2797 QualType T = Context->getRecordType(cast<RecordDecl>(GetDecl(Record[1]))); 2798 T->setDependent(IsDependent); 2799 return T; 2800 } 2801 2802 case TYPE_ENUM: { 2803 if (Record.size() != 2) { 2804 Error("incorrect encoding of enum type"); 2805 return QualType(); 2806 } 2807 bool IsDependent = Record[0]; 2808 QualType T = Context->getEnumType(cast<EnumDecl>(GetDecl(Record[1]))); 2809 T->setDependent(IsDependent); 2810 return T; 2811 } 2812 2813 case TYPE_ELABORATED: { 2814 unsigned Idx = 0; 2815 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 2816 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 2817 QualType NamedType = GetType(Record[Idx++]); 2818 return Context->getElaboratedType(Keyword, NNS, NamedType); 2819 } 2820 2821 case TYPE_OBJC_INTERFACE: { 2822 unsigned Idx = 0; 2823 ObjCInterfaceDecl *ItfD = cast<ObjCInterfaceDecl>(GetDecl(Record[Idx++])); 2824 return Context->getObjCInterfaceType(ItfD); 2825 } 2826 2827 case TYPE_OBJC_OBJECT: { 2828 unsigned Idx = 0; 2829 QualType Base = GetType(Record[Idx++]); 2830 unsigned NumProtos = Record[Idx++]; 2831 llvm::SmallVector<ObjCProtocolDecl*, 4> Protos; 2832 for (unsigned I = 0; I != NumProtos; ++I) 2833 Protos.push_back(cast<ObjCProtocolDecl>(GetDecl(Record[Idx++]))); 2834 return Context->getObjCObjectType(Base, Protos.data(), NumProtos); 2835 } 2836 2837 case TYPE_OBJC_OBJECT_POINTER: { 2838 unsigned Idx = 0; 2839 QualType Pointee = GetType(Record[Idx++]); 2840 return Context->getObjCObjectPointerType(Pointee); 2841 } 2842 2843 case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 2844 unsigned Idx = 0; 2845 QualType Parm = GetType(Record[Idx++]); 2846 QualType Replacement = GetType(Record[Idx++]); 2847 return 2848 Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm), 2849 Replacement); 2850 } 2851 2852 case TYPE_INJECTED_CLASS_NAME: { 2853 CXXRecordDecl *D = cast<CXXRecordDecl>(GetDecl(Record[0])); 2854 QualType TST = GetType(Record[1]); // probably derivable 2855 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 2856 // for AST reading, too much interdependencies. 2857 return 2858 QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0); 2859 } 2860 2861 case TYPE_TEMPLATE_TYPE_PARM: { 2862 unsigned Idx = 0; 2863 unsigned Depth = Record[Idx++]; 2864 unsigned Index = Record[Idx++]; 2865 bool Pack = Record[Idx++]; 2866 IdentifierInfo *Name = GetIdentifierInfo(Record, Idx); 2867 return Context->getTemplateTypeParmType(Depth, Index, Pack, Name); 2868 } 2869 2870 case TYPE_DEPENDENT_NAME: { 2871 unsigned Idx = 0; 2872 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 2873 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 2874 const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx); 2875 QualType Canon = GetType(Record[Idx++]); 2876 if (!Canon.isNull()) 2877 Canon = Context->getCanonicalType(Canon); 2878 return Context->getDependentNameType(Keyword, NNS, Name, Canon); 2879 } 2880 2881 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 2882 unsigned Idx = 0; 2883 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 2884 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 2885 const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx); 2886 unsigned NumArgs = Record[Idx++]; 2887 llvm::SmallVector<TemplateArgument, 8> Args; 2888 Args.reserve(NumArgs); 2889 while (NumArgs--) 2890 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx)); 2891 return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name, 2892 Args.size(), Args.data()); 2893 } 2894 2895 case TYPE_DEPENDENT_SIZED_ARRAY: { 2896 unsigned Idx = 0; 2897 2898 // ArrayType 2899 QualType ElementType = GetType(Record[Idx++]); 2900 ArrayType::ArraySizeModifier ASM 2901 = (ArrayType::ArraySizeModifier)Record[Idx++]; 2902 unsigned IndexTypeQuals = Record[Idx++]; 2903 2904 // DependentSizedArrayType 2905 Expr *NumElts = ReadExpr(*Loc.F); 2906 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx); 2907 2908 return Context->getDependentSizedArrayType(ElementType, NumElts, ASM, 2909 IndexTypeQuals, Brackets); 2910 } 2911 2912 case TYPE_TEMPLATE_SPECIALIZATION: { 2913 unsigned Idx = 0; 2914 bool IsDependent = Record[Idx++]; 2915 TemplateName Name = ReadTemplateName(Record, Idx); 2916 llvm::SmallVector<TemplateArgument, 8> Args; 2917 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx); 2918 QualType Canon = GetType(Record[Idx++]); 2919 QualType T; 2920 if (Canon.isNull()) 2921 T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(), 2922 Args.size()); 2923 else 2924 T = Context->getTemplateSpecializationType(Name, Args.data(), 2925 Args.size(), Canon); 2926 T->setDependent(IsDependent); 2927 return T; 2928 } 2929 } 2930 // Suppress a GCC warning 2931 return QualType(); 2932} 2933 2934class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> { 2935 ASTReader &Reader; 2936 ASTReader::PerFileData &F; 2937 llvm::BitstreamCursor &DeclsCursor; 2938 const ASTReader::RecordData &Record; 2939 unsigned &Idx; 2940 2941 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R, 2942 unsigned &I) { 2943 return Reader.ReadSourceLocation(F, R, I); 2944 } 2945 2946public: 2947 TypeLocReader(ASTReader &Reader, ASTReader::PerFileData &F, 2948 const ASTReader::RecordData &Record, unsigned &Idx) 2949 : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx) 2950 { } 2951 2952 // We want compile-time assurance that we've enumerated all of 2953 // these, so unfortunately we have to declare them first, then 2954 // define them out-of-line. 2955#define ABSTRACT_TYPELOC(CLASS, PARENT) 2956#define TYPELOC(CLASS, PARENT) \ 2957 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 2958#include "clang/AST/TypeLocNodes.def" 2959 2960 void VisitFunctionTypeLoc(FunctionTypeLoc); 2961 void VisitArrayTypeLoc(ArrayTypeLoc); 2962}; 2963 2964void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 2965 // nothing to do 2966} 2967void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 2968 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx)); 2969 if (TL.needsExtraLocalData()) { 2970 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 2971 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 2972 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 2973 TL.setModeAttr(Record[Idx++]); 2974 } 2975} 2976void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 2977 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 2978} 2979void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 2980 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 2981} 2982void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 2983 TL.setCaretLoc(ReadSourceLocation(Record, Idx)); 2984} 2985void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 2986 TL.setAmpLoc(ReadSourceLocation(Record, Idx)); 2987} 2988void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 2989 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 2990} 2991void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 2992 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 2993} 2994void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 2995 TL.setLBracketLoc(ReadSourceLocation(Record, Idx)); 2996 TL.setRBracketLoc(ReadSourceLocation(Record, Idx)); 2997 if (Record[Idx++]) 2998 TL.setSizeExpr(Reader.ReadExpr(F)); 2999 else 3000 TL.setSizeExpr(0); 3001} 3002void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 3003 VisitArrayTypeLoc(TL); 3004} 3005void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 3006 VisitArrayTypeLoc(TL); 3007} 3008void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 3009 VisitArrayTypeLoc(TL); 3010} 3011void TypeLocReader::VisitDependentSizedArrayTypeLoc( 3012 DependentSizedArrayTypeLoc TL) { 3013 VisitArrayTypeLoc(TL); 3014} 3015void TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 3016 DependentSizedExtVectorTypeLoc TL) { 3017 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3018} 3019void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 3020 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3021} 3022void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 3023 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3024} 3025void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 3026 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3027 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3028 TL.setTrailingReturn(Record[Idx++]); 3029 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 3030 TL.setArg(i, cast_or_null<ParmVarDecl>(Reader.GetDecl(Record[Idx++]))); 3031 } 3032} 3033void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 3034 VisitFunctionTypeLoc(TL); 3035} 3036void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 3037 VisitFunctionTypeLoc(TL); 3038} 3039void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 3040 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3041} 3042void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 3043 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3044} 3045void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 3046 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 3047 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3048 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3049} 3050void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 3051 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 3052 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3053 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3054 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3055} 3056void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 3057 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3058} 3059void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 3060 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3061} 3062void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 3063 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3064} 3065void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 3066 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3067} 3068void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 3069 SubstTemplateTypeParmTypeLoc TL) { 3070 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3071} 3072void TypeLocReader::VisitTemplateSpecializationTypeLoc( 3073 TemplateSpecializationTypeLoc TL) { 3074 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 3075 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3076 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3077 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 3078 TL.setArgLocInfo(i, 3079 Reader.GetTemplateArgumentLocInfo(F, 3080 TL.getTypePtr()->getArg(i).getKind(), 3081 Record, Idx)); 3082} 3083void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 3084 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3085 TL.setQualifierRange(Reader.ReadSourceRange(F, Record, Idx)); 3086} 3087void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 3088 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3089} 3090void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 3091 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3092 TL.setQualifierRange(Reader.ReadSourceRange(F, Record, Idx)); 3093 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3094} 3095void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 3096 DependentTemplateSpecializationTypeLoc TL) { 3097 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3098 TL.setQualifierRange(Reader.ReadSourceRange(F, Record, Idx)); 3099 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3100 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3101 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3102 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 3103 TL.setArgLocInfo(I, 3104 Reader.GetTemplateArgumentLocInfo(F, 3105 TL.getTypePtr()->getArg(I).getKind(), 3106 Record, Idx)); 3107} 3108void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 3109 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3110} 3111void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 3112 TL.setHasBaseTypeAsWritten(Record[Idx++]); 3113 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3114 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3115 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 3116 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx)); 3117} 3118void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 3119 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3120} 3121 3122TypeSourceInfo *ASTReader::GetTypeSourceInfo(PerFileData &F, 3123 const RecordData &Record, 3124 unsigned &Idx) { 3125 QualType InfoTy = GetType(Record[Idx++]); 3126 if (InfoTy.isNull()) 3127 return 0; 3128 3129 TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy); 3130 TypeLocReader TLR(*this, F, Record, Idx); 3131 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 3132 TLR.Visit(TL); 3133 return TInfo; 3134} 3135 3136QualType ASTReader::GetType(TypeID ID) { 3137 unsigned FastQuals = ID & Qualifiers::FastMask; 3138 unsigned Index = ID >> Qualifiers::FastWidth; 3139 3140 if (Index < NUM_PREDEF_TYPE_IDS) { 3141 QualType T; 3142 switch ((PredefinedTypeIDs)Index) { 3143 case PREDEF_TYPE_NULL_ID: return QualType(); 3144 case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break; 3145 case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; break; 3146 3147 case PREDEF_TYPE_CHAR_U_ID: 3148 case PREDEF_TYPE_CHAR_S_ID: 3149 // FIXME: Check that the signedness of CharTy is correct! 3150 T = Context->CharTy; 3151 break; 3152 3153 case PREDEF_TYPE_UCHAR_ID: T = Context->UnsignedCharTy; break; 3154 case PREDEF_TYPE_USHORT_ID: T = Context->UnsignedShortTy; break; 3155 case PREDEF_TYPE_UINT_ID: T = Context->UnsignedIntTy; break; 3156 case PREDEF_TYPE_ULONG_ID: T = Context->UnsignedLongTy; break; 3157 case PREDEF_TYPE_ULONGLONG_ID: T = Context->UnsignedLongLongTy; break; 3158 case PREDEF_TYPE_UINT128_ID: T = Context->UnsignedInt128Ty; break; 3159 case PREDEF_TYPE_SCHAR_ID: T = Context->SignedCharTy; break; 3160 case PREDEF_TYPE_WCHAR_ID: T = Context->WCharTy; break; 3161 case PREDEF_TYPE_SHORT_ID: T = Context->ShortTy; break; 3162 case PREDEF_TYPE_INT_ID: T = Context->IntTy; break; 3163 case PREDEF_TYPE_LONG_ID: T = Context->LongTy; break; 3164 case PREDEF_TYPE_LONGLONG_ID: T = Context->LongLongTy; break; 3165 case PREDEF_TYPE_INT128_ID: T = Context->Int128Ty; break; 3166 case PREDEF_TYPE_FLOAT_ID: T = Context->FloatTy; break; 3167 case PREDEF_TYPE_DOUBLE_ID: T = Context->DoubleTy; break; 3168 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy; break; 3169 case PREDEF_TYPE_OVERLOAD_ID: T = Context->OverloadTy; break; 3170 case PREDEF_TYPE_DEPENDENT_ID: T = Context->DependentTy; break; 3171 case PREDEF_TYPE_NULLPTR_ID: T = Context->NullPtrTy; break; 3172 case PREDEF_TYPE_CHAR16_ID: T = Context->Char16Ty; break; 3173 case PREDEF_TYPE_CHAR32_ID: T = Context->Char32Ty; break; 3174 case PREDEF_TYPE_OBJC_ID: T = Context->ObjCBuiltinIdTy; break; 3175 case PREDEF_TYPE_OBJC_CLASS: T = Context->ObjCBuiltinClassTy; break; 3176 case PREDEF_TYPE_OBJC_SEL: T = Context->ObjCBuiltinSelTy; break; 3177 } 3178 3179 assert(!T.isNull() && "Unknown predefined type"); 3180 return T.withFastQualifiers(FastQuals); 3181 } 3182 3183 Index -= NUM_PREDEF_TYPE_IDS; 3184 assert(Index < TypesLoaded.size() && "Type index out-of-range"); 3185 if (TypesLoaded[Index].isNull()) { 3186 TypesLoaded[Index] = ReadTypeRecord(Index); 3187 if (TypesLoaded[Index].isNull()) 3188 return QualType(); 3189 3190 TypesLoaded[Index]->setFromAST(); 3191 TypeIdxs[TypesLoaded[Index]] = TypeIdx::fromTypeID(ID); 3192 if (DeserializationListener) 3193 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 3194 TypesLoaded[Index]); 3195 } 3196 3197 return TypesLoaded[Index].withFastQualifiers(FastQuals); 3198} 3199 3200TypeID ASTReader::GetTypeID(QualType T) const { 3201 return MakeTypeID(T, 3202 std::bind1st(std::mem_fun(&ASTReader::GetTypeIdx), this)); 3203} 3204 3205TypeIdx ASTReader::GetTypeIdx(QualType T) const { 3206 if (T.isNull()) 3207 return TypeIdx(); 3208 assert(!T.getLocalFastQualifiers()); 3209 3210 TypeIdxMap::const_iterator I = TypeIdxs.find(T); 3211 // GetTypeIdx is mostly used for computing the hash of DeclarationNames and 3212 // comparing keys of ASTDeclContextNameLookupTable. 3213 // If the type didn't come from the AST file use a specially marked index 3214 // so that any hash/key comparison fail since no such index is stored 3215 // in a AST file. 3216 if (I == TypeIdxs.end()) 3217 return TypeIdx(-1); 3218 return I->second; 3219} 3220 3221unsigned ASTReader::getTotalNumCXXBaseSpecifiers() const { 3222 unsigned Result = 0; 3223 for (unsigned I = 0, N = Chain.size(); I != N; ++I) 3224 Result += Chain[I]->LocalNumCXXBaseSpecifiers; 3225 3226 return Result; 3227} 3228 3229TemplateArgumentLocInfo 3230ASTReader::GetTemplateArgumentLocInfo(PerFileData &F, 3231 TemplateArgument::ArgKind Kind, 3232 const RecordData &Record, 3233 unsigned &Index) { 3234 switch (Kind) { 3235 case TemplateArgument::Expression: 3236 return ReadExpr(F); 3237 case TemplateArgument::Type: 3238 return GetTypeSourceInfo(F, Record, Index); 3239 case TemplateArgument::Template: { 3240 SourceRange QualifierRange = ReadSourceRange(F, Record, Index); 3241 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 3242 return TemplateArgumentLocInfo(QualifierRange, TemplateNameLoc); 3243 } 3244 case TemplateArgument::Null: 3245 case TemplateArgument::Integral: 3246 case TemplateArgument::Declaration: 3247 case TemplateArgument::Pack: 3248 return TemplateArgumentLocInfo(); 3249 } 3250 llvm_unreachable("unexpected template argument loc"); 3251 return TemplateArgumentLocInfo(); 3252} 3253 3254TemplateArgumentLoc 3255ASTReader::ReadTemplateArgumentLoc(PerFileData &F, 3256 const RecordData &Record, unsigned &Index) { 3257 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index); 3258 3259 if (Arg.getKind() == TemplateArgument::Expression) { 3260 if (Record[Index++]) // bool InfoHasSameExpr. 3261 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 3262 } 3263 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(), 3264 Record, Index)); 3265} 3266 3267Decl *ASTReader::GetExternalDecl(uint32_t ID) { 3268 return GetDecl(ID); 3269} 3270 3271uint64_t 3272ASTReader::GetCXXBaseSpecifiersOffset(serialization::CXXBaseSpecifiersID ID) { 3273 if (ID == 0) 3274 return 0; 3275 3276 --ID; 3277 uint64_t Offset = 0; 3278 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3279 if (ID < Chain[I]->LocalNumCXXBaseSpecifiers) 3280 return Offset + Chain[I]->CXXBaseSpecifiersOffsets[ID]; 3281 3282 ID -= Chain[I]->LocalNumCXXBaseSpecifiers; 3283 Offset += Chain[I]->SizeInBits; 3284 } 3285 3286 assert(false && "CXXBaseSpecifiers not found"); 3287 return 0; 3288} 3289 3290CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 3291 // Figure out which AST file contains this offset. 3292 PerFileData *F = 0; 3293 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3294 if (Offset < Chain[I]->SizeInBits) { 3295 F = Chain[I]; 3296 break; 3297 } 3298 3299 Offset -= Chain[I]->SizeInBits; 3300 } 3301 3302 if (!F) { 3303 Error("Malformed AST file: C++ base specifiers at impossible offset"); 3304 return 0; 3305 } 3306 3307 llvm::BitstreamCursor &Cursor = F->DeclsCursor; 3308 SavedStreamPosition SavedPosition(Cursor); 3309 Cursor.JumpToBit(Offset); 3310 ReadingKindTracker ReadingKind(Read_Decl, *this); 3311 RecordData Record; 3312 unsigned Code = Cursor.ReadCode(); 3313 unsigned RecCode = Cursor.ReadRecord(Code, Record); 3314 if (RecCode != DECL_CXX_BASE_SPECIFIERS) { 3315 Error("Malformed AST file: missing C++ base specifiers"); 3316 return 0; 3317 } 3318 3319 unsigned Idx = 0; 3320 unsigned NumBases = Record[Idx++]; 3321 void *Mem = Context->Allocate(sizeof(CXXBaseSpecifier) * NumBases); 3322 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases]; 3323 for (unsigned I = 0; I != NumBases; ++I) 3324 Bases[I] = ReadCXXBaseSpecifier(*F, Record, Idx); 3325 return Bases; 3326} 3327 3328TranslationUnitDecl *ASTReader::GetTranslationUnitDecl() { 3329 if (!DeclsLoaded[0]) { 3330 ReadDeclRecord(0, 1); 3331 if (DeserializationListener) 3332 DeserializationListener->DeclRead(1, DeclsLoaded[0]); 3333 } 3334 3335 return cast<TranslationUnitDecl>(DeclsLoaded[0]); 3336} 3337 3338Decl *ASTReader::GetDecl(DeclID ID) { 3339 if (ID == 0) 3340 return 0; 3341 3342 if (ID > DeclsLoaded.size()) { 3343 Error("declaration ID out-of-range for AST file"); 3344 return 0; 3345 } 3346 3347 unsigned Index = ID - 1; 3348 if (!DeclsLoaded[Index]) { 3349 ReadDeclRecord(Index, ID); 3350 if (DeserializationListener) 3351 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 3352 } 3353 3354 return DeclsLoaded[Index]; 3355} 3356 3357/// \brief Resolve the offset of a statement into a statement. 3358/// 3359/// This operation will read a new statement from the external 3360/// source each time it is called, and is meant to be used via a 3361/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 3362Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 3363 // Switch case IDs are per Decl. 3364 ClearSwitchCaseIDs(); 3365 3366 // Offset here is a global offset across the entire chain. 3367 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3368 PerFileData &F = *Chain[N - I - 1]; 3369 if (Offset < F.SizeInBits) { 3370 // Since we know that this statement is part of a decl, make sure to use 3371 // the decl cursor to read it. 3372 F.DeclsCursor.JumpToBit(Offset); 3373 return ReadStmtFromStream(F); 3374 } 3375 Offset -= F.SizeInBits; 3376 } 3377 llvm_unreachable("Broken chain"); 3378} 3379 3380bool ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 3381 bool (*isKindWeWant)(Decl::Kind), 3382 llvm::SmallVectorImpl<Decl*> &Decls) { 3383 assert(DC->hasExternalLexicalStorage() && 3384 "DeclContext has no lexical decls in storage"); 3385 3386 // There might be lexical decls in multiple parts of the chain, for the TU 3387 // at least. 3388 // DeclContextOffsets might reallocate as we load additional decls below, 3389 // so make a copy of the vector. 3390 DeclContextInfos Infos = DeclContextOffsets[DC]; 3391 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end(); 3392 I != E; ++I) { 3393 // IDs can be 0 if this context doesn't contain declarations. 3394 if (!I->LexicalDecls) 3395 continue; 3396 3397 // Load all of the declaration IDs 3398 for (const KindDeclIDPair *ID = I->LexicalDecls, 3399 *IDE = ID + I->NumLexicalDecls; ID != IDE; ++ID) { 3400 if (isKindWeWant && !isKindWeWant((Decl::Kind)ID->first)) 3401 continue; 3402 3403 Decl *D = GetDecl(ID->second); 3404 assert(D && "Null decl in lexical decls"); 3405 Decls.push_back(D); 3406 } 3407 } 3408 3409 ++NumLexicalDeclContextsRead; 3410 return false; 3411} 3412 3413DeclContext::lookup_result 3414ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 3415 DeclarationName Name) { 3416 assert(DC->hasExternalVisibleStorage() && 3417 "DeclContext has no visible decls in storage"); 3418 if (!Name) 3419 return DeclContext::lookup_result(DeclContext::lookup_iterator(0), 3420 DeclContext::lookup_iterator(0)); 3421 3422 llvm::SmallVector<NamedDecl *, 64> Decls; 3423 // There might be visible decls in multiple parts of the chain, for the TU 3424 // and namespaces. For any given name, the last available results replace 3425 // all earlier ones. For this reason, we walk in reverse. 3426 DeclContextInfos &Infos = DeclContextOffsets[DC]; 3427 for (DeclContextInfos::reverse_iterator I = Infos.rbegin(), E = Infos.rend(); 3428 I != E; ++I) { 3429 if (!I->NameLookupTableData) 3430 continue; 3431 3432 ASTDeclContextNameLookupTable *LookupTable = 3433 (ASTDeclContextNameLookupTable*)I->NameLookupTableData; 3434 ASTDeclContextNameLookupTable::iterator Pos = LookupTable->find(Name); 3435 if (Pos == LookupTable->end()) 3436 continue; 3437 3438 ASTDeclContextNameLookupTrait::data_type Data = *Pos; 3439 for (; Data.first != Data.second; ++Data.first) 3440 Decls.push_back(cast<NamedDecl>(GetDecl(*Data.first))); 3441 break; 3442 } 3443 3444 ++NumVisibleDeclContextsRead; 3445 3446 SetExternalVisibleDeclsForName(DC, Name, Decls); 3447 return const_cast<DeclContext*>(DC)->lookup(Name); 3448} 3449 3450void ASTReader::MaterializeVisibleDecls(const DeclContext *DC) { 3451 assert(DC->hasExternalVisibleStorage() && 3452 "DeclContext has no visible decls in storage"); 3453 3454 llvm::SmallVector<NamedDecl *, 64> Decls; 3455 // There might be visible decls in multiple parts of the chain, for the TU 3456 // and namespaces. 3457 DeclContextInfos &Infos = DeclContextOffsets[DC]; 3458 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end(); 3459 I != E; ++I) { 3460 if (!I->NameLookupTableData) 3461 continue; 3462 3463 ASTDeclContextNameLookupTable *LookupTable = 3464 (ASTDeclContextNameLookupTable*)I->NameLookupTableData; 3465 for (ASTDeclContextNameLookupTable::item_iterator 3466 ItemI = LookupTable->item_begin(), 3467 ItemEnd = LookupTable->item_end() ; ItemI != ItemEnd; ++ItemI) { 3468 ASTDeclContextNameLookupTable::item_iterator::value_type Val 3469 = *ItemI; 3470 ASTDeclContextNameLookupTrait::data_type Data = Val.second; 3471 Decls.clear(); 3472 for (; Data.first != Data.second; ++Data.first) 3473 Decls.push_back(cast<NamedDecl>(GetDecl(*Data.first))); 3474 MaterializeVisibleDeclsForName(DC, Val.first, Decls); 3475 } 3476 } 3477} 3478 3479void ASTReader::PassInterestingDeclsToConsumer() { 3480 assert(Consumer); 3481 while (!InterestingDecls.empty()) { 3482 DeclGroupRef DG(InterestingDecls.front()); 3483 InterestingDecls.pop_front(); 3484 Consumer->HandleInterestingDecl(DG); 3485 } 3486} 3487 3488void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 3489 this->Consumer = Consumer; 3490 3491 if (!Consumer) 3492 return; 3493 3494 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 3495 // Force deserialization of this decl, which will cause it to be queued for 3496 // passing to the consumer. 3497 GetDecl(ExternalDefinitions[I]); 3498 } 3499 3500 PassInterestingDeclsToConsumer(); 3501} 3502 3503void ASTReader::PrintStats() { 3504 std::fprintf(stderr, "*** AST File Statistics:\n"); 3505 3506 unsigned NumTypesLoaded 3507 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 3508 QualType()); 3509 unsigned NumDeclsLoaded 3510 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 3511 (Decl *)0); 3512 unsigned NumIdentifiersLoaded 3513 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 3514 IdentifiersLoaded.end(), 3515 (IdentifierInfo *)0); 3516 unsigned NumSelectorsLoaded 3517 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 3518 SelectorsLoaded.end(), 3519 Selector()); 3520 3521 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits); 3522 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses); 3523 if (TotalNumSLocEntries) 3524 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 3525 NumSLocEntriesRead, TotalNumSLocEntries, 3526 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 3527 if (!TypesLoaded.empty()) 3528 std::fprintf(stderr, " %u/%u types read (%f%%)\n", 3529 NumTypesLoaded, (unsigned)TypesLoaded.size(), 3530 ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 3531 if (!DeclsLoaded.empty()) 3532 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 3533 NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 3534 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 3535 if (!IdentifiersLoaded.empty()) 3536 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 3537 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 3538 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 3539 if (!SelectorsLoaded.empty()) 3540 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 3541 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 3542 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 3543 if (TotalNumStatements) 3544 std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 3545 NumStatementsRead, TotalNumStatements, 3546 ((float)NumStatementsRead/TotalNumStatements * 100)); 3547 if (TotalNumMacros) 3548 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 3549 NumMacrosRead, TotalNumMacros, 3550 ((float)NumMacrosRead/TotalNumMacros * 100)); 3551 if (TotalLexicalDeclContexts) 3552 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 3553 NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 3554 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 3555 * 100)); 3556 if (TotalVisibleDeclContexts) 3557 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 3558 NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 3559 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 3560 * 100)); 3561 if (TotalNumMethodPoolEntries) { 3562 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 3563 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 3564 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 3565 * 100)); 3566 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses); 3567 } 3568 std::fprintf(stderr, "\n"); 3569} 3570 3571void ASTReader::InitializeSema(Sema &S) { 3572 SemaObj = &S; 3573 S.ExternalSource = this; 3574 3575 // Makes sure any declarations that were deserialized "too early" 3576 // still get added to the identifier's declaration chains. 3577 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 3578 if (SemaObj->TUScope) 3579 SemaObj->TUScope->AddDecl(PreloadedDecls[I]); 3580 3581 SemaObj->IdResolver.AddDecl(PreloadedDecls[I]); 3582 } 3583 PreloadedDecls.clear(); 3584 3585 // If there were any tentative definitions, deserialize them and add 3586 // them to Sema's list of tentative definitions. 3587 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 3588 VarDecl *Var = cast<VarDecl>(GetDecl(TentativeDefinitions[I])); 3589 SemaObj->TentativeDefinitions.push_back(Var); 3590 } 3591 3592 // If there were any unused file scoped decls, deserialize them and add to 3593 // Sema's list of unused file scoped decls. 3594 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 3595 DeclaratorDecl *D = cast<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 3596 SemaObj->UnusedFileScopedDecls.push_back(D); 3597 } 3598 3599 // If there were any locally-scoped external declarations, 3600 // deserialize them and add them to Sema's table of locally-scoped 3601 // external declarations. 3602 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) { 3603 NamedDecl *D = cast<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I])); 3604 SemaObj->LocallyScopedExternalDecls[D->getDeclName()] = D; 3605 } 3606 3607 // If there were any ext_vector type declarations, deserialize them 3608 // and add them to Sema's vector of such declarations. 3609 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) 3610 SemaObj->ExtVectorDecls.push_back( 3611 cast<TypedefDecl>(GetDecl(ExtVectorDecls[I]))); 3612 3613 // FIXME: Do VTable uses and dynamic classes deserialize too much ? 3614 // Can we cut them down before writing them ? 3615 3616 // If there were any dynamic classes declarations, deserialize them 3617 // and add them to Sema's vector of such declarations. 3618 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) 3619 SemaObj->DynamicClasses.push_back( 3620 cast<CXXRecordDecl>(GetDecl(DynamicClasses[I]))); 3621 3622 // Load the offsets of the declarations that Sema references. 3623 // They will be lazily deserialized when needed. 3624 if (!SemaDeclRefs.empty()) { 3625 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!"); 3626 SemaObj->StdNamespace = SemaDeclRefs[0]; 3627 SemaObj->StdBadAlloc = SemaDeclRefs[1]; 3628 } 3629 3630 for (PerFileData *F = FirstInSource; F; F = F->NextInSource) { 3631 3632 // If there are @selector references added them to its pool. This is for 3633 // implementation of -Wselector. 3634 if (!F->ReferencedSelectorsData.empty()) { 3635 unsigned int DataSize = F->ReferencedSelectorsData.size()-1; 3636 unsigned I = 0; 3637 while (I < DataSize) { 3638 Selector Sel = DecodeSelector(F->ReferencedSelectorsData[I++]); 3639 SourceLocation SelLoc = ReadSourceLocation( 3640 *F, F->ReferencedSelectorsData, I); 3641 SemaObj->ReferencedSelectors.insert(std::make_pair(Sel, SelLoc)); 3642 } 3643 } 3644 3645 // If there were any pending implicit instantiations, deserialize them 3646 // and add them to Sema's queue of such instantiations. 3647 assert(F->PendingInstantiations.size() % 2 == 0 && 3648 "Expected pairs of entries"); 3649 for (unsigned Idx = 0, N = F->PendingInstantiations.size(); Idx < N;) { 3650 ValueDecl *D=cast<ValueDecl>(GetDecl(F->PendingInstantiations[Idx++])); 3651 SourceLocation Loc = ReadSourceLocation(*F, F->PendingInstantiations,Idx); 3652 SemaObj->PendingInstantiations.push_back(std::make_pair(D, Loc)); 3653 } 3654 } 3655 3656 // The two special data sets below always come from the most recent PCH, 3657 // which is at the front of the chain. 3658 PerFileData &F = *Chain.front(); 3659 3660 // If there were any weak undeclared identifiers, deserialize them and add to 3661 // Sema's list of weak undeclared identifiers. 3662 if (!WeakUndeclaredIdentifiers.empty()) { 3663 unsigned Idx = 0; 3664 for (unsigned I = 0, N = WeakUndeclaredIdentifiers[Idx++]; I != N; ++I) { 3665 IdentifierInfo *WeakId = GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx); 3666 IdentifierInfo *AliasId= GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx); 3667 SourceLocation Loc = ReadSourceLocation(F, WeakUndeclaredIdentifiers,Idx); 3668 bool Used = WeakUndeclaredIdentifiers[Idx++]; 3669 Sema::WeakInfo WI(AliasId, Loc); 3670 WI.setUsed(Used); 3671 SemaObj->WeakUndeclaredIdentifiers.insert(std::make_pair(WeakId, WI)); 3672 } 3673 } 3674 3675 // If there were any VTable uses, deserialize the information and add it 3676 // to Sema's vector and map of VTable uses. 3677 if (!VTableUses.empty()) { 3678 unsigned Idx = 0; 3679 for (unsigned I = 0, N = VTableUses[Idx++]; I != N; ++I) { 3680 CXXRecordDecl *Class = cast<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 3681 SourceLocation Loc = ReadSourceLocation(F, VTableUses, Idx); 3682 bool DefinitionRequired = VTableUses[Idx++]; 3683 SemaObj->VTableUses.push_back(std::make_pair(Class, Loc)); 3684 SemaObj->VTablesUsed[Class] = DefinitionRequired; 3685 } 3686 } 3687} 3688 3689IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 3690 // Try to find this name within our on-disk hash tables. We start with the 3691 // most recent one, since that one contains the most up-to-date info. 3692 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3693 ASTIdentifierLookupTable *IdTable 3694 = (ASTIdentifierLookupTable *)Chain[I]->IdentifierLookupTable; 3695 if (!IdTable) 3696 continue; 3697 std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart); 3698 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key); 3699 if (Pos == IdTable->end()) 3700 continue; 3701 3702 // Dereferencing the iterator has the effect of building the 3703 // IdentifierInfo node and populating it with the various 3704 // declarations it needs. 3705 return *Pos; 3706 } 3707 return 0; 3708} 3709 3710namespace clang { 3711 /// \brief An identifier-lookup iterator that enumerates all of the 3712 /// identifiers stored within a set of AST files. 3713 class ASTIdentifierIterator : public IdentifierIterator { 3714 /// \brief The AST reader whose identifiers are being enumerated. 3715 const ASTReader &Reader; 3716 3717 /// \brief The current index into the chain of AST files stored in 3718 /// the AST reader. 3719 unsigned Index; 3720 3721 /// \brief The current position within the identifier lookup table 3722 /// of the current AST file. 3723 ASTIdentifierLookupTable::key_iterator Current; 3724 3725 /// \brief The end position within the identifier lookup table of 3726 /// the current AST file. 3727 ASTIdentifierLookupTable::key_iterator End; 3728 3729 public: 3730 explicit ASTIdentifierIterator(const ASTReader &Reader); 3731 3732 virtual llvm::StringRef Next(); 3733 }; 3734} 3735 3736ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader) 3737 : Reader(Reader), Index(Reader.Chain.size() - 1) { 3738 ASTIdentifierLookupTable *IdTable 3739 = (ASTIdentifierLookupTable *)Reader.Chain[Index]->IdentifierLookupTable; 3740 Current = IdTable->key_begin(); 3741 End = IdTable->key_end(); 3742} 3743 3744llvm::StringRef ASTIdentifierIterator::Next() { 3745 while (Current == End) { 3746 // If we have exhausted all of our AST files, we're done. 3747 if (Index == 0) 3748 return llvm::StringRef(); 3749 3750 --Index; 3751 ASTIdentifierLookupTable *IdTable 3752 = (ASTIdentifierLookupTable *)Reader.Chain[Index]->IdentifierLookupTable; 3753 Current = IdTable->key_begin(); 3754 End = IdTable->key_end(); 3755 } 3756 3757 // We have any identifiers remaining in the current AST file; return 3758 // the next one. 3759 std::pair<const char*, unsigned> Key = *Current; 3760 ++Current; 3761 return llvm::StringRef(Key.first, Key.second); 3762} 3763 3764IdentifierIterator *ASTReader::getIdentifiers() const { 3765 return new ASTIdentifierIterator(*this); 3766} 3767 3768std::pair<ObjCMethodList, ObjCMethodList> 3769ASTReader::ReadMethodPool(Selector Sel) { 3770 // Find this selector in a hash table. We want to find the most recent entry. 3771 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3772 PerFileData &F = *Chain[I]; 3773 if (!F.SelectorLookupTable) 3774 continue; 3775 3776 ASTSelectorLookupTable *PoolTable 3777 = (ASTSelectorLookupTable*)F.SelectorLookupTable; 3778 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel); 3779 if (Pos != PoolTable->end()) { 3780 ++NumSelectorsRead; 3781 // FIXME: Not quite happy with the statistics here. We probably should 3782 // disable this tracking when called via LoadSelector. 3783 // Also, should entries without methods count as misses? 3784 ++NumMethodPoolEntriesRead; 3785 ASTSelectorLookupTrait::data_type Data = *Pos; 3786 if (DeserializationListener) 3787 DeserializationListener->SelectorRead(Data.ID, Sel); 3788 return std::make_pair(Data.Instance, Data.Factory); 3789 } 3790 } 3791 3792 ++NumMethodPoolMisses; 3793 return std::pair<ObjCMethodList, ObjCMethodList>(); 3794} 3795 3796void ASTReader::LoadSelector(Selector Sel) { 3797 // It would be complicated to avoid reading the methods anyway. So don't. 3798 ReadMethodPool(Sel); 3799} 3800 3801void ASTReader::SetIdentifierInfo(unsigned ID, IdentifierInfo *II) { 3802 assert(ID && "Non-zero identifier ID required"); 3803 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 3804 IdentifiersLoaded[ID - 1] = II; 3805 if (DeserializationListener) 3806 DeserializationListener->IdentifierRead(ID, II); 3807} 3808 3809/// \brief Set the globally-visible declarations associated with the given 3810/// identifier. 3811/// 3812/// If the AST reader is currently in a state where the given declaration IDs 3813/// cannot safely be resolved, they are queued until it is safe to resolve 3814/// them. 3815/// 3816/// \param II an IdentifierInfo that refers to one or more globally-visible 3817/// declarations. 3818/// 3819/// \param DeclIDs the set of declaration IDs with the name @p II that are 3820/// visible at global scope. 3821/// 3822/// \param Nonrecursive should be true to indicate that the caller knows that 3823/// this call is non-recursive, and therefore the globally-visible declarations 3824/// will not be placed onto the pending queue. 3825void 3826ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 3827 const llvm::SmallVectorImpl<uint32_t> &DeclIDs, 3828 bool Nonrecursive) { 3829 if (NumCurrentElementsDeserializing && !Nonrecursive) { 3830 PendingIdentifierInfos.push_back(PendingIdentifierInfo()); 3831 PendingIdentifierInfo &PII = PendingIdentifierInfos.back(); 3832 PII.II = II; 3833 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end()); 3834 return; 3835 } 3836 3837 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 3838 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 3839 if (SemaObj) { 3840 if (SemaObj->TUScope) { 3841 // Introduce this declaration into the translation-unit scope 3842 // and add it to the declaration chain for this identifier, so 3843 // that (unqualified) name lookup will find it. 3844 SemaObj->TUScope->AddDecl(D); 3845 } 3846 SemaObj->IdResolver.AddDeclToIdentifierChain(II, D); 3847 } else { 3848 // Queue this declaration so that it will be added to the 3849 // translation unit scope and identifier's declaration chain 3850 // once a Sema object is known. 3851 PreloadedDecls.push_back(D); 3852 } 3853 } 3854} 3855 3856IdentifierInfo *ASTReader::DecodeIdentifierInfo(unsigned ID) { 3857 if (ID == 0) 3858 return 0; 3859 3860 if (IdentifiersLoaded.empty()) { 3861 Error("no identifier table in AST file"); 3862 return 0; 3863 } 3864 3865 assert(PP && "Forgot to set Preprocessor ?"); 3866 ID -= 1; 3867 if (!IdentifiersLoaded[ID]) { 3868 unsigned Index = ID; 3869 const char *Str = 0; 3870 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3871 PerFileData *F = Chain[N - I - 1]; 3872 if (Index < F->LocalNumIdentifiers) { 3873 uint32_t Offset = F->IdentifierOffsets[Index]; 3874 Str = F->IdentifierTableData + Offset; 3875 break; 3876 } 3877 Index -= F->LocalNumIdentifiers; 3878 } 3879 assert(Str && "Broken Chain"); 3880 3881 // All of the strings in the AST file are preceded by a 16-bit length. 3882 // Extract that 16-bit length to avoid having to execute strlen(). 3883 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 3884 // unsigned integers. This is important to avoid integer overflow when 3885 // we cast them to 'unsigned'. 3886 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 3887 unsigned StrLen = (((unsigned) StrLenPtr[0]) 3888 | (((unsigned) StrLenPtr[1]) << 8)) - 1; 3889 IdentifiersLoaded[ID] 3890 = &PP->getIdentifierTable().get(Str, StrLen); 3891 if (DeserializationListener) 3892 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 3893 } 3894 3895 return IdentifiersLoaded[ID]; 3896} 3897 3898void ASTReader::ReadSLocEntry(unsigned ID) { 3899 ReadSLocEntryRecord(ID); 3900} 3901 3902Selector ASTReader::DecodeSelector(unsigned ID) { 3903 if (ID == 0) 3904 return Selector(); 3905 3906 if (ID > SelectorsLoaded.size()) { 3907 Error("selector ID out of range in AST file"); 3908 return Selector(); 3909 } 3910 3911 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 3912 // Load this selector from the selector table. 3913 unsigned Idx = ID - 1; 3914 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3915 PerFileData &F = *Chain[N - I - 1]; 3916 if (Idx < F.LocalNumSelectors) { 3917 ASTSelectorLookupTrait Trait(*this); 3918 SelectorsLoaded[ID - 1] = 3919 Trait.ReadKey(F.SelectorLookupTableData + F.SelectorOffsets[Idx], 0); 3920 if (DeserializationListener) 3921 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 3922 break; 3923 } 3924 Idx -= F.LocalNumSelectors; 3925 } 3926 } 3927 3928 return SelectorsLoaded[ID - 1]; 3929} 3930 3931Selector ASTReader::GetExternalSelector(uint32_t ID) { 3932 return DecodeSelector(ID); 3933} 3934 3935uint32_t ASTReader::GetNumExternalSelectors() { 3936 // ID 0 (the null selector) is considered an external selector. 3937 return getTotalNumSelectors() + 1; 3938} 3939 3940DeclarationName 3941ASTReader::ReadDeclarationName(const RecordData &Record, unsigned &Idx) { 3942 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 3943 switch (Kind) { 3944 case DeclarationName::Identifier: 3945 return DeclarationName(GetIdentifierInfo(Record, Idx)); 3946 3947 case DeclarationName::ObjCZeroArgSelector: 3948 case DeclarationName::ObjCOneArgSelector: 3949 case DeclarationName::ObjCMultiArgSelector: 3950 return DeclarationName(GetSelector(Record, Idx)); 3951 3952 case DeclarationName::CXXConstructorName: 3953 return Context->DeclarationNames.getCXXConstructorName( 3954 Context->getCanonicalType(GetType(Record[Idx++]))); 3955 3956 case DeclarationName::CXXDestructorName: 3957 return Context->DeclarationNames.getCXXDestructorName( 3958 Context->getCanonicalType(GetType(Record[Idx++]))); 3959 3960 case DeclarationName::CXXConversionFunctionName: 3961 return Context->DeclarationNames.getCXXConversionFunctionName( 3962 Context->getCanonicalType(GetType(Record[Idx++]))); 3963 3964 case DeclarationName::CXXOperatorName: 3965 return Context->DeclarationNames.getCXXOperatorName( 3966 (OverloadedOperatorKind)Record[Idx++]); 3967 3968 case DeclarationName::CXXLiteralOperatorName: 3969 return Context->DeclarationNames.getCXXLiteralOperatorName( 3970 GetIdentifierInfo(Record, Idx)); 3971 3972 case DeclarationName::CXXUsingDirective: 3973 return DeclarationName::getUsingDirectiveName(); 3974 } 3975 3976 // Required to silence GCC warning 3977 return DeclarationName(); 3978} 3979 3980void ASTReader::ReadDeclarationNameLoc(PerFileData &F, 3981 DeclarationNameLoc &DNLoc, 3982 DeclarationName Name, 3983 const RecordData &Record, unsigned &Idx) { 3984 switch (Name.getNameKind()) { 3985 case DeclarationName::CXXConstructorName: 3986 case DeclarationName::CXXDestructorName: 3987 case DeclarationName::CXXConversionFunctionName: 3988 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx); 3989 break; 3990 3991 case DeclarationName::CXXOperatorName: 3992 DNLoc.CXXOperatorName.BeginOpNameLoc 3993 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 3994 DNLoc.CXXOperatorName.EndOpNameLoc 3995 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 3996 break; 3997 3998 case DeclarationName::CXXLiteralOperatorName: 3999 DNLoc.CXXLiteralOperatorName.OpNameLoc 4000 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4001 break; 4002 4003 case DeclarationName::Identifier: 4004 case DeclarationName::ObjCZeroArgSelector: 4005 case DeclarationName::ObjCOneArgSelector: 4006 case DeclarationName::ObjCMultiArgSelector: 4007 case DeclarationName::CXXUsingDirective: 4008 break; 4009 } 4010} 4011 4012void ASTReader::ReadDeclarationNameInfo(PerFileData &F, 4013 DeclarationNameInfo &NameInfo, 4014 const RecordData &Record, unsigned &Idx) { 4015 NameInfo.setName(ReadDeclarationName(Record, Idx)); 4016 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx)); 4017 DeclarationNameLoc DNLoc; 4018 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx); 4019 NameInfo.setInfo(DNLoc); 4020} 4021 4022void ASTReader::ReadQualifierInfo(PerFileData &F, QualifierInfo &Info, 4023 const RecordData &Record, unsigned &Idx) { 4024 Info.NNS = ReadNestedNameSpecifier(Record, Idx); 4025 Info.NNSRange = ReadSourceRange(F, Record, Idx); 4026 unsigned NumTPLists = Record[Idx++]; 4027 Info.NumTemplParamLists = NumTPLists; 4028 if (NumTPLists) { 4029 Info.TemplParamLists = new (*Context) TemplateParameterList*[NumTPLists]; 4030 for (unsigned i=0; i != NumTPLists; ++i) 4031 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx); 4032 } 4033} 4034 4035TemplateName 4036ASTReader::ReadTemplateName(const RecordData &Record, unsigned &Idx) { 4037 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 4038 switch (Kind) { 4039 case TemplateName::Template: 4040 return TemplateName(cast_or_null<TemplateDecl>(GetDecl(Record[Idx++]))); 4041 4042 case TemplateName::OverloadedTemplate: { 4043 unsigned size = Record[Idx++]; 4044 UnresolvedSet<8> Decls; 4045 while (size--) 4046 Decls.addDecl(cast<NamedDecl>(GetDecl(Record[Idx++]))); 4047 4048 return Context->getOverloadedTemplateName(Decls.begin(), Decls.end()); 4049 } 4050 4051 case TemplateName::QualifiedTemplate: { 4052 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 4053 bool hasTemplKeyword = Record[Idx++]; 4054 TemplateDecl *Template = cast<TemplateDecl>(GetDecl(Record[Idx++])); 4055 return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 4056 } 4057 4058 case TemplateName::DependentTemplate: { 4059 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 4060 if (Record[Idx++]) // isIdentifier 4061 return Context->getDependentTemplateName(NNS, 4062 GetIdentifierInfo(Record, Idx)); 4063 return Context->getDependentTemplateName(NNS, 4064 (OverloadedOperatorKind)Record[Idx++]); 4065 } 4066 } 4067 4068 assert(0 && "Unhandled template name kind!"); 4069 return TemplateName(); 4070} 4071 4072TemplateArgument 4073ASTReader::ReadTemplateArgument(PerFileData &F, 4074 const RecordData &Record, unsigned &Idx) { 4075 switch ((TemplateArgument::ArgKind)Record[Idx++]) { 4076 case TemplateArgument::Null: 4077 return TemplateArgument(); 4078 case TemplateArgument::Type: 4079 return TemplateArgument(GetType(Record[Idx++])); 4080 case TemplateArgument::Declaration: 4081 return TemplateArgument(GetDecl(Record[Idx++])); 4082 case TemplateArgument::Integral: { 4083 llvm::APSInt Value = ReadAPSInt(Record, Idx); 4084 QualType T = GetType(Record[Idx++]); 4085 return TemplateArgument(Value, T); 4086 } 4087 case TemplateArgument::Template: 4088 return TemplateArgument(ReadTemplateName(Record, Idx)); 4089 case TemplateArgument::Expression: 4090 return TemplateArgument(ReadExpr(F)); 4091 case TemplateArgument::Pack: { 4092 unsigned NumArgs = Record[Idx++]; 4093 llvm::SmallVector<TemplateArgument, 8> Args; 4094 Args.reserve(NumArgs); 4095 while (NumArgs--) 4096 Args.push_back(ReadTemplateArgument(F, Record, Idx)); 4097 TemplateArgument TemplArg; 4098 TemplArg.setArgumentPack(Args.data(), Args.size(), /*CopyArgs=*/true); 4099 return TemplArg; 4100 } 4101 } 4102 4103 assert(0 && "Unhandled template argument kind!"); 4104 return TemplateArgument(); 4105} 4106 4107TemplateParameterList * 4108ASTReader::ReadTemplateParameterList(PerFileData &F, 4109 const RecordData &Record, unsigned &Idx) { 4110 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx); 4111 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx); 4112 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx); 4113 4114 unsigned NumParams = Record[Idx++]; 4115 llvm::SmallVector<NamedDecl *, 16> Params; 4116 Params.reserve(NumParams); 4117 while (NumParams--) 4118 Params.push_back(cast<NamedDecl>(GetDecl(Record[Idx++]))); 4119 4120 TemplateParameterList* TemplateParams = 4121 TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc, 4122 Params.data(), Params.size(), RAngleLoc); 4123 return TemplateParams; 4124} 4125 4126void 4127ASTReader:: 4128ReadTemplateArgumentList(llvm::SmallVector<TemplateArgument, 8> &TemplArgs, 4129 PerFileData &F, const RecordData &Record, 4130 unsigned &Idx) { 4131 unsigned NumTemplateArgs = Record[Idx++]; 4132 TemplArgs.reserve(NumTemplateArgs); 4133 while (NumTemplateArgs--) 4134 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx)); 4135} 4136 4137/// \brief Read a UnresolvedSet structure. 4138void ASTReader::ReadUnresolvedSet(UnresolvedSetImpl &Set, 4139 const RecordData &Record, unsigned &Idx) { 4140 unsigned NumDecls = Record[Idx++]; 4141 while (NumDecls--) { 4142 NamedDecl *D = cast<NamedDecl>(GetDecl(Record[Idx++])); 4143 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 4144 Set.addDecl(D, AS); 4145 } 4146} 4147 4148CXXBaseSpecifier 4149ASTReader::ReadCXXBaseSpecifier(PerFileData &F, 4150 const RecordData &Record, unsigned &Idx) { 4151 bool isVirtual = static_cast<bool>(Record[Idx++]); 4152 bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 4153 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 4154 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx); 4155 SourceRange Range = ReadSourceRange(F, Record, Idx); 4156 return CXXBaseSpecifier(Range, isVirtual, isBaseOfClass, AS, TInfo); 4157} 4158 4159std::pair<CXXBaseOrMemberInitializer **, unsigned> 4160ASTReader::ReadCXXBaseOrMemberInitializers(PerFileData &F, 4161 const RecordData &Record, 4162 unsigned &Idx) { 4163 CXXBaseOrMemberInitializer **BaseOrMemberInitializers = 0; 4164 unsigned NumInitializers = Record[Idx++]; 4165 if (NumInitializers) { 4166 ASTContext &C = *getContext(); 4167 4168 BaseOrMemberInitializers 4169 = new (C) CXXBaseOrMemberInitializer*[NumInitializers]; 4170 for (unsigned i=0; i != NumInitializers; ++i) { 4171 TypeSourceInfo *BaseClassInfo = 0; 4172 bool IsBaseVirtual = false; 4173 FieldDecl *Member = 0; 4174 4175 bool IsBaseInitializer = Record[Idx++]; 4176 if (IsBaseInitializer) { 4177 BaseClassInfo = GetTypeSourceInfo(F, Record, Idx); 4178 IsBaseVirtual = Record[Idx++]; 4179 } else { 4180 Member = cast<FieldDecl>(GetDecl(Record[Idx++])); 4181 } 4182 SourceLocation MemberLoc = ReadSourceLocation(F, Record, Idx); 4183 Expr *Init = ReadExpr(F); 4184 FieldDecl *AnonUnionMember 4185 = cast_or_null<FieldDecl>(GetDecl(Record[Idx++])); 4186 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx); 4187 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx); 4188 bool IsWritten = Record[Idx++]; 4189 unsigned SourceOrderOrNumArrayIndices; 4190 llvm::SmallVector<VarDecl *, 8> Indices; 4191 if (IsWritten) { 4192 SourceOrderOrNumArrayIndices = Record[Idx++]; 4193 } else { 4194 SourceOrderOrNumArrayIndices = Record[Idx++]; 4195 Indices.reserve(SourceOrderOrNumArrayIndices); 4196 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 4197 Indices.push_back(cast<VarDecl>(GetDecl(Record[Idx++]))); 4198 } 4199 4200 CXXBaseOrMemberInitializer *BOMInit; 4201 if (IsBaseInitializer) { 4202 BOMInit = new (C) CXXBaseOrMemberInitializer(C, BaseClassInfo, 4203 IsBaseVirtual, LParenLoc, 4204 Init, RParenLoc); 4205 } else if (IsWritten) { 4206 BOMInit = new (C) CXXBaseOrMemberInitializer(C, Member, MemberLoc, 4207 LParenLoc, Init, RParenLoc); 4208 } else { 4209 BOMInit = CXXBaseOrMemberInitializer::Create(C, Member, MemberLoc, 4210 LParenLoc, Init, RParenLoc, 4211 Indices.data(), 4212 Indices.size()); 4213 } 4214 4215 if (IsWritten) 4216 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 4217 BOMInit->setAnonUnionMember(AnonUnionMember); 4218 BaseOrMemberInitializers[i] = BOMInit; 4219 } 4220 } 4221 4222 return std::make_pair(BaseOrMemberInitializers, NumInitializers); 4223} 4224 4225NestedNameSpecifier * 4226ASTReader::ReadNestedNameSpecifier(const RecordData &Record, unsigned &Idx) { 4227 unsigned N = Record[Idx++]; 4228 NestedNameSpecifier *NNS = 0, *Prev = 0; 4229 for (unsigned I = 0; I != N; ++I) { 4230 NestedNameSpecifier::SpecifierKind Kind 4231 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 4232 switch (Kind) { 4233 case NestedNameSpecifier::Identifier: { 4234 IdentifierInfo *II = GetIdentifierInfo(Record, Idx); 4235 NNS = NestedNameSpecifier::Create(*Context, Prev, II); 4236 break; 4237 } 4238 4239 case NestedNameSpecifier::Namespace: { 4240 NamespaceDecl *NS = cast<NamespaceDecl>(GetDecl(Record[Idx++])); 4241 NNS = NestedNameSpecifier::Create(*Context, Prev, NS); 4242 break; 4243 } 4244 4245 case NestedNameSpecifier::TypeSpec: 4246 case NestedNameSpecifier::TypeSpecWithTemplate: { 4247 Type *T = GetType(Record[Idx++]).getTypePtr(); 4248 bool Template = Record[Idx++]; 4249 NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T); 4250 break; 4251 } 4252 4253 case NestedNameSpecifier::Global: { 4254 NNS = NestedNameSpecifier::GlobalSpecifier(*Context); 4255 // No associated value, and there can't be a prefix. 4256 break; 4257 } 4258 } 4259 Prev = NNS; 4260 } 4261 return NNS; 4262} 4263 4264SourceRange 4265ASTReader::ReadSourceRange(PerFileData &F, const RecordData &Record, 4266 unsigned &Idx) { 4267 SourceLocation beg = ReadSourceLocation(F, Record, Idx); 4268 SourceLocation end = ReadSourceLocation(F, Record, Idx); 4269 return SourceRange(beg, end); 4270} 4271 4272/// \brief Read an integral value 4273llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 4274 unsigned BitWidth = Record[Idx++]; 4275 unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 4276 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 4277 Idx += NumWords; 4278 return Result; 4279} 4280 4281/// \brief Read a signed integral value 4282llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 4283 bool isUnsigned = Record[Idx++]; 4284 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 4285} 4286 4287/// \brief Read a floating-point value 4288llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) { 4289 return llvm::APFloat(ReadAPInt(Record, Idx)); 4290} 4291 4292// \brief Read a string 4293std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 4294 unsigned Len = Record[Idx++]; 4295 std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 4296 Idx += Len; 4297 return Result; 4298} 4299 4300CXXTemporary *ASTReader::ReadCXXTemporary(const RecordData &Record, 4301 unsigned &Idx) { 4302 CXXDestructorDecl *Decl = cast<CXXDestructorDecl>(GetDecl(Record[Idx++])); 4303 return CXXTemporary::Create(*Context, Decl); 4304} 4305 4306DiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 4307 return Diag(SourceLocation(), DiagID); 4308} 4309 4310DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 4311 return Diags.Report(FullSourceLoc(Loc, SourceMgr), DiagID); 4312} 4313 4314/// \brief Retrieve the identifier table associated with the 4315/// preprocessor. 4316IdentifierTable &ASTReader::getIdentifierTable() { 4317 assert(PP && "Forgot to set Preprocessor ?"); 4318 return PP->getIdentifierTable(); 4319} 4320 4321/// \brief Record that the given ID maps to the given switch-case 4322/// statement. 4323void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 4324 assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID"); 4325 SwitchCaseStmts[ID] = SC; 4326} 4327 4328/// \brief Retrieve the switch-case statement with the given ID. 4329SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 4330 assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID"); 4331 return SwitchCaseStmts[ID]; 4332} 4333 4334void ASTReader::ClearSwitchCaseIDs() { 4335 SwitchCaseStmts.clear(); 4336} 4337 4338/// \brief Record that the given label statement has been 4339/// deserialized and has the given ID. 4340void ASTReader::RecordLabelStmt(LabelStmt *S, unsigned ID) { 4341 assert(LabelStmts.find(ID) == LabelStmts.end() && 4342 "Deserialized label twice"); 4343 LabelStmts[ID] = S; 4344 4345 // If we've already seen any goto statements that point to this 4346 // label, resolve them now. 4347 typedef std::multimap<unsigned, GotoStmt *>::iterator GotoIter; 4348 std::pair<GotoIter, GotoIter> Gotos = UnresolvedGotoStmts.equal_range(ID); 4349 for (GotoIter Goto = Gotos.first; Goto != Gotos.second; ++Goto) 4350 Goto->second->setLabel(S); 4351 UnresolvedGotoStmts.erase(Gotos.first, Gotos.second); 4352 4353 // If we've already seen any address-label statements that point to 4354 // this label, resolve them now. 4355 typedef std::multimap<unsigned, AddrLabelExpr *>::iterator AddrLabelIter; 4356 std::pair<AddrLabelIter, AddrLabelIter> AddrLabels 4357 = UnresolvedAddrLabelExprs.equal_range(ID); 4358 for (AddrLabelIter AddrLabel = AddrLabels.first; 4359 AddrLabel != AddrLabels.second; ++AddrLabel) 4360 AddrLabel->second->setLabel(S); 4361 UnresolvedAddrLabelExprs.erase(AddrLabels.first, AddrLabels.second); 4362} 4363 4364/// \brief Set the label of the given statement to the label 4365/// identified by ID. 4366/// 4367/// Depending on the order in which the label and other statements 4368/// referencing that label occur, this operation may complete 4369/// immediately (updating the statement) or it may queue the 4370/// statement to be back-patched later. 4371void ASTReader::SetLabelOf(GotoStmt *S, unsigned ID) { 4372 std::map<unsigned, LabelStmt *>::iterator Label = LabelStmts.find(ID); 4373 if (Label != LabelStmts.end()) { 4374 // We've already seen this label, so set the label of the goto and 4375 // we're done. 4376 S->setLabel(Label->second); 4377 } else { 4378 // We haven't seen this label yet, so add this goto to the set of 4379 // unresolved goto statements. 4380 UnresolvedGotoStmts.insert(std::make_pair(ID, S)); 4381 } 4382} 4383 4384/// \brief Set the label of the given expression to the label 4385/// identified by ID. 4386/// 4387/// Depending on the order in which the label and other statements 4388/// referencing that label occur, this operation may complete 4389/// immediately (updating the statement) or it may queue the 4390/// statement to be back-patched later. 4391void ASTReader::SetLabelOf(AddrLabelExpr *S, unsigned ID) { 4392 std::map<unsigned, LabelStmt *>::iterator Label = LabelStmts.find(ID); 4393 if (Label != LabelStmts.end()) { 4394 // We've already seen this label, so set the label of the 4395 // label-address expression and we're done. 4396 S->setLabel(Label->second); 4397 } else { 4398 // We haven't seen this label yet, so add this label-address 4399 // expression to the set of unresolved label-address expressions. 4400 UnresolvedAddrLabelExprs.insert(std::make_pair(ID, S)); 4401 } 4402} 4403 4404void ASTReader::FinishedDeserializing() { 4405 assert(NumCurrentElementsDeserializing && 4406 "FinishedDeserializing not paired with StartedDeserializing"); 4407 if (NumCurrentElementsDeserializing == 1) { 4408 // If any identifiers with corresponding top-level declarations have 4409 // been loaded, load those declarations now. 4410 while (!PendingIdentifierInfos.empty()) { 4411 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II, 4412 PendingIdentifierInfos.front().DeclIDs, true); 4413 PendingIdentifierInfos.pop_front(); 4414 } 4415 4416 // We are not in recursive loading, so it's safe to pass the "interesting" 4417 // decls to the consumer. 4418 if (Consumer) 4419 PassInterestingDeclsToConsumer(); 4420 4421 assert(PendingForwardRefs.size() == 0 && 4422 "Some forward refs did not get linked to the definition!"); 4423 } 4424 --NumCurrentElementsDeserializing; 4425} 4426 4427ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context, 4428 const char *isysroot, bool DisableValidation) 4429 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 4430 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 4431 Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context), 4432 Consumer(0), isysroot(isysroot), DisableValidation(DisableValidation), 4433 NumStatHits(0), NumStatMisses(0), NumSLocEntriesRead(0), 4434 TotalNumSLocEntries(0), NextSLocOffset(0), NumStatementsRead(0), 4435 TotalNumStatements(0), NumMacrosRead(0), TotalNumMacros(0), 4436 NumSelectorsRead(0), NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0), 4437 TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0), 4438 TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0), 4439 TotalVisibleDeclContexts(0), NumCurrentElementsDeserializing(0) { 4440 RelocatablePCH = false; 4441} 4442 4443ASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr, 4444 Diagnostic &Diags, const char *isysroot, 4445 bool DisableValidation) 4446 : DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr), 4447 Diags(Diags), SemaObj(0), PP(0), Context(0), Consumer(0), 4448 isysroot(isysroot), DisableValidation(DisableValidation), NumStatHits(0), 4449 NumStatMisses(0), NumSLocEntriesRead(0), TotalNumSLocEntries(0), 4450 NextSLocOffset(0), NumStatementsRead(0), TotalNumStatements(0), 4451 NumMacrosRead(0), TotalNumMacros(0), NumSelectorsRead(0), 4452 NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0), 4453 TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0), 4454 TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0), 4455 TotalVisibleDeclContexts(0), NumCurrentElementsDeserializing(0) { 4456 RelocatablePCH = false; 4457} 4458 4459ASTReader::~ASTReader() { 4460 for (unsigned i = 0, e = Chain.size(); i != e; ++i) 4461 delete Chain[e - i - 1]; 4462 // Delete all visible decl lookup tables 4463 for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(), 4464 E = DeclContextOffsets.end(); 4465 I != E; ++I) { 4466 for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end(); 4467 J != F; ++J) { 4468 if (J->NameLookupTableData) 4469 delete static_cast<ASTDeclContextNameLookupTable*>( 4470 J->NameLookupTableData); 4471 } 4472 } 4473 for (DeclContextVisibleUpdatesPending::iterator 4474 I = PendingVisibleUpdates.begin(), 4475 E = PendingVisibleUpdates.end(); 4476 I != E; ++I) { 4477 for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 4478 F = I->second.end(); 4479 J != F; ++J) 4480 delete static_cast<ASTDeclContextNameLookupTable*>(*J); 4481 } 4482} 4483 4484ASTReader::PerFileData::PerFileData(ASTFileType Ty) 4485 : Type(Ty), SizeInBits(0), LocalNumSLocEntries(0), SLocOffsets(0), LocalSLocSize(0), 4486 LocalNumIdentifiers(0), IdentifierOffsets(0), IdentifierTableData(0), 4487 IdentifierLookupTable(0), LocalNumMacroDefinitions(0), 4488 MacroDefinitionOffsets(0), LocalNumSelectors(0), SelectorOffsets(0), 4489 SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(0), 4490 DeclOffsets(0), LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0), 4491 LocalNumTypes(0), TypeOffsets(0), StatCache(0), 4492 NumPreallocatedPreprocessingEntities(0), NextInSource(0) 4493{} 4494 4495ASTReader::PerFileData::~PerFileData() { 4496 delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable); 4497 delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable); 4498} 4499 4500